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