1/****************************************************************************** 2 * 3 * Copyright (C) 2015 Google, Inc. 4 * 5 * Licensed under the Apache License, Version 2.0 (the "License"); 6 * you may not use this file except in compliance with the License. 7 * You may obtain a copy of the License at: 8 * 9 * http://www.apache.org/licenses/LICENSE-2.0 10 * 11 * Unless required by applicable law or agreed to in writing, software 12 * distributed under the License is distributed on an "AS IS" BASIS, 13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 * See the License for the specific language governing permissions and 15 * limitations under the License. 16 * 17 ******************************************************************************/ 18 19#include <gtest/gtest.h> 20 21#include "AllocationTestHarness.h" 22 23#include "osi/include/time.h" 24 25// Generous upper bound: 10 seconds 26static const uint32_t TEST_TIME_DELTA_UPPER_BOUND_MS = 10 * 1000; 27 28class TimeTest : public AllocationTestHarness {}; 29 30// 31// Test that the return value of time_get_os_boottime_ms() is not zero. 32// 33// NOTE: For now this test is disabled, because the return value 34// of time_get_os_boottime_ms() is 32-bits integer that could wrap-around 35// in 49.7 days. It should be re-enabled if/after the wrap-around issue 36// is resolved (e.g., if the return value is 64-bits integer). 37// 38#if 0 39TEST_F(TimeTest, test_time_get_os_boottime_ms_not_zero) { 40 uint32_t t1 = time_get_os_boottime_ms(); 41 ASSERT_TRUE(t1 > 0); 42} 43#endif 44 45// 46// Test that the return value of time_get_os_boottime_us() is not zero. 47// 48TEST_F(TimeTest, test_time_get_os_boottime_us_not_zero) { 49 uint64_t t1 = time_get_os_boottime_us(); 50 ASSERT_TRUE(t1 > 0); 51} 52 53// 54// Test that the return value of time_get_os_boottime_ms() 55// is monotonically increasing within reasonable boundries. 56// 57TEST_F(TimeTest, test_time_get_os_boottime_ms_increases_upper_bound) { 58 uint32_t t1 = time_get_os_boottime_ms(); 59 uint32_t t2 = time_get_os_boottime_ms(); 60 ASSERT_TRUE((t2 - t1) < TEST_TIME_DELTA_UPPER_BOUND_MS); 61} 62 63// 64// Test that the return value of time_get_os_boottime_us() 65// is monotonically increasing within reasonable boundries. 66// 67TEST_F(TimeTest, test_time_get_os_boottime_us_increases_upper_bound) { 68 uint64_t t1 = time_get_os_boottime_us(); 69 uint64_t t2 = time_get_os_boottime_us(); 70 ASSERT_TRUE((t2 - t1) < TEST_TIME_DELTA_UPPER_BOUND_MS * 1000); 71} 72 73// 74// Test that the return value of time_get_os_boottime_ms() 75// is increasing. 76// 77TEST_F(TimeTest, test_time_get_os_boottime_ms_increases_lower_bound) { 78 static const uint32_t TEST_TIME_SLEEP_MS = 100; 79 struct timespec delay; 80 81 delay.tv_sec = TEST_TIME_SLEEP_MS / 1000; 82 delay.tv_nsec = 1000 * 1000 * (TEST_TIME_SLEEP_MS % 1000); 83 84 // Take two timestamps with sleep in-between 85 uint32_t t1 = time_get_os_boottime_ms(); 86 int err = nanosleep(&delay, &delay); 87 uint32_t t2 = time_get_os_boottime_ms(); 88 89 ASSERT_TRUE(err == 0); 90 ASSERT_TRUE((t2 - t1) >= TEST_TIME_SLEEP_MS); 91 ASSERT_TRUE((t2 - t1) < TEST_TIME_DELTA_UPPER_BOUND_MS); 92} 93 94// 95// Test that the return value of time_get_os_boottime_us() 96// is increasing. 97// 98TEST_F(TimeTest, test_time_get_os_boottime_us_increases_lower_bound) { 99 static const uint64_t TEST_TIME_SLEEP_US = 100 * 1000; 100 struct timespec delay; 101 102 delay.tv_sec = TEST_TIME_SLEEP_US / (1000 * 1000); 103 delay.tv_nsec = 1000 * (TEST_TIME_SLEEP_US % (1000 * 1000)); 104 105 // Take two timestamps with sleep in-between 106 uint64_t t1 = time_get_os_boottime_us(); 107 int err = nanosleep(&delay, &delay); 108 uint64_t t2 = time_get_os_boottime_us(); 109 110 ASSERT_TRUE(err == 0); 111 ASSERT_TRUE(t2 > t1); 112 ASSERT_TRUE((t2 - t1) >= TEST_TIME_SLEEP_US); 113 ASSERT_TRUE((t2 - t1) < TEST_TIME_DELTA_UPPER_BOUND_MS * 1000); 114} 115 116// 117// Test that the return value of time_gettimeofday_us() is not zero. 118// 119TEST_F(TimeTest, test_time_gettimeofday_us_not_zero) { 120 uint64_t t1 = time_gettimeofday_us(); 121 ASSERT_TRUE(t1 > 0); 122} 123 124// 125// Test that the return value of time_gettimeofday_us() 126// is monotonically increasing within reasonable boundaries. 127// 128TEST_F(TimeTest, test_time_gettimeofday_us_increases_upper_bound) { 129 uint64_t t1 = time_gettimeofday_us(); 130 uint64_t t2 = time_gettimeofday_us(); 131 ASSERT_TRUE((t2 - t1) < TEST_TIME_DELTA_UPPER_BOUND_MS * 1000); 132} 133 134// 135// Test that the return value of time_gettimeofday_us() 136// is increasing. 137// 138TEST_F(TimeTest, test_time_gettimeofday_us_increases_lower_bound) { 139 static const uint64_t TEST_TIME_SLEEP_US = 100 * 1000; 140 struct timespec delay; 141 142 delay.tv_sec = TEST_TIME_SLEEP_US / (1000 * 1000); 143 delay.tv_nsec = 1000 * (TEST_TIME_SLEEP_US % (1000 * 1000)); 144 145 // Take two timestamps with sleep in-between 146 uint64_t t1 = time_gettimeofday_us(); 147 int err = nanosleep(&delay, &delay); 148 uint64_t t2 = time_gettimeofday_us(); 149 150 ASSERT_TRUE(err == 0); 151 ASSERT_TRUE(t2 > t1); 152 ASSERT_TRUE((t2 - t1) >= TEST_TIME_SLEEP_US); 153 ASSERT_TRUE((t2 - t1) < TEST_TIME_DELTA_UPPER_BOUND_MS * 1000); 154} 155