| // Copyright 2008, Google Inc. |
| // All rights reserved. |
| // |
| // Redistribution and use in source and binary forms, with or without |
| // modification, are permitted provided that the following conditions are |
| // met: |
| // |
| // * Redistributions of source code must retain the above copyright |
| // notice, this list of conditions and the following disclaimer. |
| // * Redistributions in binary form must reproduce the above |
| // copyright notice, this list of conditions and the following disclaimer |
| // in the documentation and/or other materials provided with the |
| // distribution. |
| // * Neither the name of Google Inc. nor the names of its |
| // contributors may be used to endorse or promote products derived from |
| // this software without specific prior written permission. |
| // |
| // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| |
| #include <process.h> |
| #include <time.h> |
| |
| #include "base/time.h" |
| #include "testing/gtest/include/gtest/gtest.h" |
| |
| // Test conversions to/from time_t and exploding/unexploding. |
| TEST(Time, TimeT) { |
| // C library time and exploded time. |
| time_t now_t_1 = time(NULL); |
| struct tm tms; |
| localtime_s(&tms, &now_t_1); |
| |
| // Convert to ours. |
| Time our_time_1 = Time::FromTimeT(now_t_1); |
| Time::Exploded exploded; |
| our_time_1.LocalExplode(&exploded); |
| |
| // This will test both our exploding and our time_t -> Time conversion. |
| EXPECT_EQ(tms.tm_year + 1900, exploded.year); |
| EXPECT_EQ(tms.tm_mon + 1, exploded.month); |
| EXPECT_EQ(tms.tm_mday, exploded.day_of_month); |
| EXPECT_EQ(tms.tm_hour, exploded.hour); |
| EXPECT_EQ(tms.tm_min, exploded.minute); |
| EXPECT_EQ(tms.tm_sec, exploded.second); |
| |
| // Convert exploded back to the time struct. |
| Time our_time_2 = Time::FromLocalExploded(exploded); |
| EXPECT_TRUE(our_time_1 == our_time_2); |
| |
| time_t now_t_2 = our_time_2.ToTimeT(); |
| EXPECT_EQ(now_t_1, now_t_2); |
| |
| // Conversions of 0 should stay 0. |
| EXPECT_EQ(0, Time().ToTimeT()); |
| EXPECT_EQ(0, Time::FromTimeT(0).ToInternalValue()); |
| } |
| |
| TEST(Time, ZeroIsSymmetric) { |
| Time zeroTime(Time::FromTimeT(0)); |
| EXPECT_EQ(0, zeroTime.ToTimeT()); |
| } |
| |
| TEST(Time, LocalExplode) { |
| Time a = Time::Now(); |
| Time::Exploded exploded; |
| a.LocalExplode(&exploded); |
| |
| Time b = Time::FromLocalExploded(exploded); |
| |
| // The exploded structure doesn't have microseconds, so the result will be |
| // rounded to the nearest millisecond. |
| EXPECT_TRUE((a - b) < TimeDelta::FromMilliseconds(1)); |
| } |
| |
| TEST(Time, UTCExplode) { |
| Time a = Time::Now(); |
| Time::Exploded exploded; |
| a.UTCExplode(&exploded); |
| |
| Time b = Time::FromUTCExploded(exploded); |
| EXPECT_TRUE((a - b) < TimeDelta::FromMilliseconds(1)); |
| } |
| |
| TEST(TimeTicks, Deltas) { |
| TimeTicks ticks_start = TimeTicks::Now(); |
| Sleep(10); |
| TimeTicks ticks_stop = TimeTicks::Now(); |
| TimeDelta delta = ticks_stop - ticks_start; |
| EXPECT_GE(delta.InMilliseconds(), 10); |
| EXPECT_GE(delta.InMicroseconds(), 10000); |
| EXPECT_EQ(delta.InSeconds(), 0); |
| } |
| |
| namespace { |
| |
| class MockTimeTicks : public TimeTicks { |
| public: |
| static int Ticker() { |
| return static_cast<int>(InterlockedIncrement(&ticker_)); |
| } |
| |
| static void InstallTicker() { |
| old_tick_function_ = tick_function_; |
| tick_function_ = reinterpret_cast<TickFunction>(&Ticker); |
| ticker_ = -5; |
| } |
| |
| static void UninstallTicker() { |
| tick_function_ = old_tick_function_; |
| } |
| |
| private: |
| static volatile LONG ticker_; |
| static TickFunction old_tick_function_; |
| }; |
| |
| volatile LONG MockTimeTicks::ticker_; |
| MockTimeTicks::TickFunction MockTimeTicks::old_tick_function_; |
| |
| HANDLE g_rollover_test_start; |
| |
| unsigned __stdcall RolloverTestThreadMain(void* param) { |
| int64 counter = reinterpret_cast<int64>(param); |
| DWORD rv = WaitForSingleObject(g_rollover_test_start, INFINITE); |
| EXPECT_EQ(rv, WAIT_OBJECT_0); |
| |
| TimeTicks last = TimeTicks::Now(); |
| for (int index = 0; index < counter; index++) { |
| TimeTicks now = TimeTicks::Now(); |
| int64 milliseconds = (now - last).InMilliseconds(); |
| EXPECT_GT(milliseconds, 0); |
| EXPECT_LT(milliseconds, 250); |
| last = now; |
| } |
| return 0; |
| } |
| |
| } // namespace |
| |
| TEST(TimeTicks, Rollover) { |
| // The internal counter rolls over at ~49days. We'll use a mock |
| // timer to test this case. |
| // Basic test algorithm: |
| // 1) Set clock to rollover - N |
| // 2) Create N threads |
| // 3) Start the threads |
| // 4) Each thread loops through TimeTicks() N times |
| // 5) Each thread verifies integrity of result. |
| |
| const int kThreads = 8; |
| // Use int64 so we can cast into a void* without a compiler warning. |
| const int64 kChecks = 10; |
| |
| // It takes a lot of iterations to reproduce the bug! |
| // (See bug 1081395) |
| for (int loop = 0; loop < 4096; loop++) { |
| // Setup |
| MockTimeTicks::InstallTicker(); |
| g_rollover_test_start = CreateEvent(0, TRUE, FALSE, 0); |
| HANDLE threads[kThreads]; |
| |
| for (int index = 0; index < kThreads; index++) { |
| void* argument = reinterpret_cast<void*>(kChecks); |
| unsigned thread_id; |
| threads[index] = reinterpret_cast<HANDLE>( |
| _beginthreadex(NULL, 0, RolloverTestThreadMain, argument, 0, |
| &thread_id)); |
| EXPECT_NE((HANDLE)NULL, threads[index]); |
| } |
| |
| // Start! |
| SetEvent(g_rollover_test_start); |
| |
| // Wait for threads to finish |
| for (int index = 0; index < kThreads; index++) { |
| DWORD rv = WaitForSingleObject(threads[index], INFINITE); |
| EXPECT_EQ(rv, WAIT_OBJECT_0); |
| } |
| |
| CloseHandle(g_rollover_test_start); |
| |
| // Teardown |
| MockTimeTicks::UninstallTicker(); |
| } |
| } |