Sebastian Jansson | 30bd403 | 2018-04-13 13:56:17 +0200 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (c) 2018 The WebRTC project authors. All Rights Reserved. |
| 3 | * |
| 4 | * Use of this source code is governed by a BSD-style license |
| 5 | * that can be found in the LICENSE file in the root of the source |
| 6 | * tree. An additional intellectual property rights grant can be found |
| 7 | * in the file PATENTS. All contributing project authors may |
| 8 | * be found in the AUTHORS file in the root of the source tree. |
| 9 | */ |
| 10 | |
Sebastian Jansson | 6fae6ec | 2018-05-08 10:43:18 +0200 | [diff] [blame] | 11 | #include "api/units/timestamp.h" |
Sebastian Jansson | 30bd403 | 2018-04-13 13:56:17 +0200 | [diff] [blame] | 12 | #include "test/gtest.h" |
| 13 | |
| 14 | namespace webrtc { |
| 15 | namespace test { |
Sebastian Jansson | 8e06419 | 2018-08-07 12:34:33 +0200 | [diff] [blame] | 16 | TEST(TimestampTest, ConstExpr) { |
Sebastian Jansson | c1c8b8e | 2018-08-07 15:29:04 +0200 | [diff] [blame] | 17 | constexpr int64_t kValue = 12345; |
Sebastian Jansson | 9de4ef4 | 2018-09-04 17:32:36 +0200 | [diff] [blame] | 18 | constexpr Timestamp kTimestampInf = Timestamp::PlusInfinity(); |
Sebastian Jansson | 8e06419 | 2018-08-07 12:34:33 +0200 | [diff] [blame] | 19 | static_assert(kTimestampInf.IsInfinite(), ""); |
Sebastian Jansson | c1c8b8e | 2018-08-07 15:29:04 +0200 | [diff] [blame] | 20 | static_assert(kTimestampInf.ms_or(-1) == -1, ""); |
| 21 | |
| 22 | constexpr Timestamp kTimestampSeconds = Timestamp::Seconds<kValue>(); |
| 23 | constexpr Timestamp kTimestampMs = Timestamp::Millis<kValue>(); |
| 24 | constexpr Timestamp kTimestampUs = Timestamp::Micros<kValue>(); |
| 25 | |
| 26 | static_assert(kTimestampSeconds.seconds_or(0) == kValue, ""); |
| 27 | static_assert(kTimestampMs.ms_or(0) == kValue, ""); |
| 28 | static_assert(kTimestampUs.us_or(0) == kValue, ""); |
| 29 | |
| 30 | static_assert(kTimestampMs > kTimestampUs, ""); |
| 31 | |
| 32 | EXPECT_EQ(kTimestampSeconds.seconds(), kValue); |
| 33 | EXPECT_EQ(kTimestampMs.ms(), kValue); |
| 34 | EXPECT_EQ(kTimestampUs.us(), kValue); |
Sebastian Jansson | 8e06419 | 2018-08-07 12:34:33 +0200 | [diff] [blame] | 35 | } |
| 36 | |
Sebastian Jansson | 30bd403 | 2018-04-13 13:56:17 +0200 | [diff] [blame] | 37 | TEST(TimestampTest, GetBackSameValues) { |
| 38 | const int64_t kValue = 499; |
| 39 | EXPECT_EQ(Timestamp::ms(kValue).ms(), kValue); |
| 40 | EXPECT_EQ(Timestamp::us(kValue).us(), kValue); |
Sebastian Jansson | f7ffd94 | 2018-04-16 11:46:42 +0200 | [diff] [blame] | 41 | EXPECT_EQ(Timestamp::seconds(kValue).seconds(), kValue); |
Sebastian Jansson | 30bd403 | 2018-04-13 13:56:17 +0200 | [diff] [blame] | 42 | } |
| 43 | |
| 44 | TEST(TimestampTest, GetDifferentPrefix) { |
| 45 | const int64_t kValue = 3000000; |
Sebastian Jansson | f7ffd94 | 2018-04-16 11:46:42 +0200 | [diff] [blame] | 46 | EXPECT_EQ(Timestamp::us(kValue).seconds(), kValue / 1000000); |
| 47 | EXPECT_EQ(Timestamp::ms(kValue).seconds(), kValue / 1000); |
Sebastian Jansson | 30bd403 | 2018-04-13 13:56:17 +0200 | [diff] [blame] | 48 | EXPECT_EQ(Timestamp::us(kValue).ms(), kValue / 1000); |
| 49 | |
| 50 | EXPECT_EQ(Timestamp::ms(kValue).us(), kValue * 1000); |
Sebastian Jansson | f7ffd94 | 2018-04-16 11:46:42 +0200 | [diff] [blame] | 51 | EXPECT_EQ(Timestamp::seconds(kValue).ms(), kValue * 1000); |
| 52 | EXPECT_EQ(Timestamp::seconds(kValue).us(), kValue * 1000000); |
Sebastian Jansson | 30bd403 | 2018-04-13 13:56:17 +0200 | [diff] [blame] | 53 | } |
| 54 | |
| 55 | TEST(TimestampTest, IdentityChecks) { |
| 56 | const int64_t kValue = 3000; |
| 57 | |
Sebastian Jansson | 9de4ef4 | 2018-09-04 17:32:36 +0200 | [diff] [blame] | 58 | EXPECT_TRUE(Timestamp::PlusInfinity().IsInfinite()); |
| 59 | EXPECT_TRUE(Timestamp::MinusInfinity().IsInfinite()); |
Sebastian Jansson | 30bd403 | 2018-04-13 13:56:17 +0200 | [diff] [blame] | 60 | EXPECT_FALSE(Timestamp::ms(kValue).IsInfinite()); |
| 61 | |
Sebastian Jansson | 9de4ef4 | 2018-09-04 17:32:36 +0200 | [diff] [blame] | 62 | EXPECT_FALSE(Timestamp::PlusInfinity().IsFinite()); |
| 63 | EXPECT_FALSE(Timestamp::MinusInfinity().IsFinite()); |
Sebastian Jansson | 30bd403 | 2018-04-13 13:56:17 +0200 | [diff] [blame] | 64 | EXPECT_TRUE(Timestamp::ms(kValue).IsFinite()); |
Sebastian Jansson | 9de4ef4 | 2018-09-04 17:32:36 +0200 | [diff] [blame] | 65 | |
| 66 | EXPECT_TRUE(Timestamp::PlusInfinity().IsPlusInfinity()); |
| 67 | EXPECT_FALSE(Timestamp::MinusInfinity().IsPlusInfinity()); |
| 68 | |
| 69 | EXPECT_TRUE(Timestamp::MinusInfinity().IsMinusInfinity()); |
| 70 | EXPECT_FALSE(Timestamp::PlusInfinity().IsMinusInfinity()); |
Sebastian Jansson | 30bd403 | 2018-04-13 13:56:17 +0200 | [diff] [blame] | 71 | } |
| 72 | |
| 73 | TEST(TimestampTest, ComparisonOperators) { |
| 74 | const int64_t kSmall = 450; |
| 75 | const int64_t kLarge = 451; |
| 76 | |
Sebastian Jansson | 9de4ef4 | 2018-09-04 17:32:36 +0200 | [diff] [blame] | 77 | EXPECT_EQ(Timestamp::PlusInfinity(), Timestamp::PlusInfinity()); |
| 78 | EXPECT_GE(Timestamp::PlusInfinity(), Timestamp::PlusInfinity()); |
| 79 | EXPECT_GT(Timestamp::PlusInfinity(), Timestamp::ms(kLarge)); |
Sebastian Jansson | 30bd403 | 2018-04-13 13:56:17 +0200 | [diff] [blame] | 80 | EXPECT_EQ(Timestamp::ms(kSmall), Timestamp::ms(kSmall)); |
| 81 | EXPECT_LE(Timestamp::ms(kSmall), Timestamp::ms(kSmall)); |
| 82 | EXPECT_GE(Timestamp::ms(kSmall), Timestamp::ms(kSmall)); |
| 83 | EXPECT_NE(Timestamp::ms(kSmall), Timestamp::ms(kLarge)); |
| 84 | EXPECT_LE(Timestamp::ms(kSmall), Timestamp::ms(kLarge)); |
| 85 | EXPECT_LT(Timestamp::ms(kSmall), Timestamp::ms(kLarge)); |
| 86 | EXPECT_GE(Timestamp::ms(kLarge), Timestamp::ms(kSmall)); |
| 87 | EXPECT_GT(Timestamp::ms(kLarge), Timestamp::ms(kSmall)); |
| 88 | } |
| 89 | |
Sebastian Jansson | 942b360 | 2018-05-30 15:47:44 +0200 | [diff] [blame] | 90 | TEST(TimestampTest, CanBeInititializedFromLargeInt) { |
| 91 | const int kMaxInt = std::numeric_limits<int>::max(); |
| 92 | EXPECT_EQ(Timestamp::seconds(kMaxInt).us(), |
| 93 | static_cast<int64_t>(kMaxInt) * 1000000); |
| 94 | EXPECT_EQ(Timestamp::ms(kMaxInt).us(), static_cast<int64_t>(kMaxInt) * 1000); |
| 95 | } |
| 96 | |
| 97 | TEST(TimestampTest, ConvertsToAndFromDouble) { |
| 98 | const int64_t kMicros = 17017; |
| 99 | const double kMicrosDouble = kMicros; |
| 100 | const double kMillisDouble = kMicros * 1e-3; |
| 101 | const double kSecondsDouble = kMillisDouble * 1e-3; |
| 102 | |
| 103 | EXPECT_EQ(Timestamp::us(kMicros).seconds<double>(), kSecondsDouble); |
| 104 | EXPECT_EQ(Timestamp::seconds(kSecondsDouble).us(), kMicros); |
| 105 | |
| 106 | EXPECT_EQ(Timestamp::us(kMicros).ms<double>(), kMillisDouble); |
| 107 | EXPECT_EQ(Timestamp::ms(kMillisDouble).us(), kMicros); |
| 108 | |
| 109 | EXPECT_EQ(Timestamp::us(kMicros).us<double>(), kMicrosDouble); |
| 110 | EXPECT_EQ(Timestamp::us(kMicrosDouble).us(), kMicros); |
| 111 | |
| 112 | const double kPlusInfinity = std::numeric_limits<double>::infinity(); |
Sebastian Jansson | 9de4ef4 | 2018-09-04 17:32:36 +0200 | [diff] [blame] | 113 | const double kMinusInfinity = -kPlusInfinity; |
Sebastian Jansson | 942b360 | 2018-05-30 15:47:44 +0200 | [diff] [blame] | 114 | |
Sebastian Jansson | 9de4ef4 | 2018-09-04 17:32:36 +0200 | [diff] [blame] | 115 | EXPECT_EQ(Timestamp::PlusInfinity().seconds<double>(), kPlusInfinity); |
| 116 | EXPECT_EQ(Timestamp::MinusInfinity().seconds<double>(), kMinusInfinity); |
| 117 | EXPECT_EQ(Timestamp::PlusInfinity().ms<double>(), kPlusInfinity); |
| 118 | EXPECT_EQ(Timestamp::MinusInfinity().ms<double>(), kMinusInfinity); |
| 119 | EXPECT_EQ(Timestamp::PlusInfinity().us<double>(), kPlusInfinity); |
| 120 | EXPECT_EQ(Timestamp::MinusInfinity().us<double>(), kMinusInfinity); |
Sebastian Jansson | 942b360 | 2018-05-30 15:47:44 +0200 | [diff] [blame] | 121 | |
Sebastian Jansson | 9de4ef4 | 2018-09-04 17:32:36 +0200 | [diff] [blame] | 122 | EXPECT_TRUE(Timestamp::seconds(kPlusInfinity).IsPlusInfinity()); |
| 123 | EXPECT_TRUE(Timestamp::seconds(kMinusInfinity).IsMinusInfinity()); |
| 124 | EXPECT_TRUE(Timestamp::ms(kPlusInfinity).IsPlusInfinity()); |
| 125 | EXPECT_TRUE(Timestamp::ms(kMinusInfinity).IsMinusInfinity()); |
| 126 | EXPECT_TRUE(Timestamp::us(kPlusInfinity).IsPlusInfinity()); |
| 127 | EXPECT_TRUE(Timestamp::us(kMinusInfinity).IsMinusInfinity()); |
Sebastian Jansson | 942b360 | 2018-05-30 15:47:44 +0200 | [diff] [blame] | 128 | } |
| 129 | |
Sebastian Jansson | 30bd403 | 2018-04-13 13:56:17 +0200 | [diff] [blame] | 130 | TEST(UnitConversionTest, TimestampAndTimeDeltaMath) { |
| 131 | const int64_t kValueA = 267; |
| 132 | const int64_t kValueB = 450; |
| 133 | const Timestamp time_a = Timestamp::ms(kValueA); |
| 134 | const Timestamp time_b = Timestamp::ms(kValueB); |
| 135 | const TimeDelta delta_a = TimeDelta::ms(kValueA); |
Sebastian Jansson | 88c1a9e | 2018-08-30 13:58:38 +0200 | [diff] [blame] | 136 | const TimeDelta delta_b = TimeDelta::ms(kValueB); |
Sebastian Jansson | 30bd403 | 2018-04-13 13:56:17 +0200 | [diff] [blame] | 137 | |
| 138 | EXPECT_EQ((time_a - time_b), TimeDelta::ms(kValueA - kValueB)); |
| 139 | EXPECT_EQ((time_b - delta_a), Timestamp::ms(kValueB - kValueA)); |
| 140 | EXPECT_EQ((time_b + delta_a), Timestamp::ms(kValueB + kValueA)); |
Sebastian Jansson | 88c1a9e | 2018-08-30 13:58:38 +0200 | [diff] [blame] | 141 | |
| 142 | Timestamp mutable_time = time_a; |
| 143 | mutable_time += delta_b; |
| 144 | EXPECT_EQ(mutable_time, time_a + delta_b); |
| 145 | mutable_time -= delta_b; |
| 146 | EXPECT_EQ(mutable_time, time_a); |
| 147 | } |
| 148 | |
| 149 | TEST(UnitConversionTest, InfinityOperations) { |
| 150 | const int64_t kValue = 267; |
| 151 | const Timestamp finite_time = Timestamp::ms(kValue); |
| 152 | const TimeDelta finite_delta = TimeDelta::ms(kValue); |
Sebastian Jansson | 9de4ef4 | 2018-09-04 17:32:36 +0200 | [diff] [blame] | 153 | EXPECT_TRUE((Timestamp::PlusInfinity() + finite_delta).IsInfinite()); |
| 154 | EXPECT_TRUE((Timestamp::PlusInfinity() - finite_delta).IsInfinite()); |
Sebastian Jansson | 88c1a9e | 2018-08-30 13:58:38 +0200 | [diff] [blame] | 155 | EXPECT_TRUE((finite_time + TimeDelta::PlusInfinity()).IsInfinite()); |
| 156 | EXPECT_TRUE((finite_time - TimeDelta::MinusInfinity()).IsInfinite()); |
Sebastian Jansson | 30bd403 | 2018-04-13 13:56:17 +0200 | [diff] [blame] | 157 | } |
| 158 | } // namespace test |
| 159 | } // namespace webrtc |