time_delta_unittest.cc (9758B)
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 11 #include "api/units/time_delta.h" 12 13 #include <cstddef> 14 #include <cstdint> 15 #include <limits> 16 17 #include "test/gtest.h" 18 19 namespace webrtc { 20 namespace test { 21 TEST(TimeDeltaTest, ConstExpr) { 22 constexpr int64_t kValue = -12345; 23 constexpr TimeDelta kTimeDeltaZero = TimeDelta::Zero(); 24 constexpr TimeDelta kTimeDeltaPlusInf = TimeDelta::PlusInfinity(); 25 constexpr TimeDelta kTimeDeltaMinusInf = TimeDelta::MinusInfinity(); 26 static_assert(TimeDelta() == kTimeDeltaZero); 27 static_assert(kTimeDeltaZero.IsZero(), ""); 28 static_assert(kTimeDeltaPlusInf.IsPlusInfinity(), ""); 29 static_assert(kTimeDeltaMinusInf.IsMinusInfinity(), ""); 30 static_assert(kTimeDeltaPlusInf.ms_or(-1) == -1, ""); 31 32 static_assert(kTimeDeltaPlusInf > kTimeDeltaZero, ""); 33 34 constexpr TimeDelta kTimeDeltaMinutes = TimeDelta::Minutes(kValue); 35 constexpr TimeDelta kTimeDeltaSeconds = TimeDelta::Seconds(kValue); 36 constexpr TimeDelta kTimeDeltaMs = TimeDelta::Millis(kValue); 37 constexpr TimeDelta kTimeDeltaUs = TimeDelta::Micros(kValue); 38 39 static_assert(kTimeDeltaMinutes.seconds_or(0) == kValue * 60, ""); 40 static_assert(kTimeDeltaSeconds.seconds_or(0) == kValue, ""); 41 static_assert(kTimeDeltaMs.ms_or(0) == kValue, ""); 42 static_assert(kTimeDeltaUs.us_or(0) == kValue, ""); 43 } 44 45 TEST(TimeDeltaTest, GetBackSameValues) { 46 const int64_t kValue = 499; 47 for (int sign = -1; sign <= 1; ++sign) { 48 int64_t value = kValue * sign; 49 EXPECT_EQ(TimeDelta::Millis(value).ms(), value); 50 EXPECT_EQ(TimeDelta::Micros(value).us(), value); 51 EXPECT_EQ(TimeDelta::Seconds(value).seconds(), value); 52 EXPECT_EQ(TimeDelta::Seconds(value).seconds(), value); 53 } 54 EXPECT_EQ(TimeDelta::Zero().us(), 0); 55 } 56 57 TEST(TimeDeltaTest, GetDifferentPrefix) { 58 const int64_t kValue = 3000000; 59 EXPECT_EQ(TimeDelta::Micros(kValue).seconds(), kValue / 1000000); 60 EXPECT_EQ(TimeDelta::Millis(kValue).seconds(), kValue / 1000); 61 EXPECT_EQ(TimeDelta::Micros(kValue).ms(), kValue / 1000); 62 EXPECT_EQ(TimeDelta::Minutes(kValue / 60).seconds(), kValue); 63 64 EXPECT_EQ(TimeDelta::Millis(kValue).us(), kValue * 1000); 65 EXPECT_EQ(TimeDelta::Seconds(kValue).ms(), kValue * 1000); 66 EXPECT_EQ(TimeDelta::Seconds(kValue).us(), kValue * 1000000); 67 EXPECT_EQ(TimeDelta::Minutes(kValue / 60).seconds(), kValue); 68 } 69 70 TEST(TimeDeltaTest, IdentityChecks) { 71 const int64_t kValue = 3000; 72 EXPECT_TRUE(TimeDelta::Zero().IsZero()); 73 EXPECT_FALSE(TimeDelta::Millis(kValue).IsZero()); 74 75 EXPECT_TRUE(TimeDelta::PlusInfinity().IsInfinite()); 76 EXPECT_TRUE(TimeDelta::MinusInfinity().IsInfinite()); 77 EXPECT_FALSE(TimeDelta::Zero().IsInfinite()); 78 EXPECT_FALSE(TimeDelta::Millis(-kValue).IsInfinite()); 79 EXPECT_FALSE(TimeDelta::Millis(kValue).IsInfinite()); 80 81 EXPECT_FALSE(TimeDelta::PlusInfinity().IsFinite()); 82 EXPECT_FALSE(TimeDelta::MinusInfinity().IsFinite()); 83 EXPECT_TRUE(TimeDelta::Millis(-kValue).IsFinite()); 84 EXPECT_TRUE(TimeDelta::Millis(kValue).IsFinite()); 85 EXPECT_TRUE(TimeDelta::Zero().IsFinite()); 86 87 EXPECT_TRUE(TimeDelta::PlusInfinity().IsPlusInfinity()); 88 EXPECT_FALSE(TimeDelta::MinusInfinity().IsPlusInfinity()); 89 90 EXPECT_TRUE(TimeDelta::MinusInfinity().IsMinusInfinity()); 91 EXPECT_FALSE(TimeDelta::PlusInfinity().IsMinusInfinity()); 92 } 93 94 TEST(TimeDeltaTest, ComparisonOperators) { 95 const int64_t kSmall = 450; 96 const int64_t kLarge = 451; 97 const TimeDelta small = TimeDelta::Millis(kSmall); 98 const TimeDelta large = TimeDelta::Millis(kLarge); 99 100 EXPECT_EQ(TimeDelta::Zero(), TimeDelta::Millis(0)); 101 EXPECT_EQ(TimeDelta::PlusInfinity(), TimeDelta::PlusInfinity()); 102 EXPECT_EQ(small, TimeDelta::Millis(kSmall)); 103 EXPECT_LE(small, TimeDelta::Millis(kSmall)); 104 EXPECT_GE(small, TimeDelta::Millis(kSmall)); 105 EXPECT_NE(small, TimeDelta::Millis(kLarge)); 106 EXPECT_LE(small, TimeDelta::Millis(kLarge)); 107 EXPECT_LT(small, TimeDelta::Millis(kLarge)); 108 EXPECT_GE(large, TimeDelta::Millis(kSmall)); 109 EXPECT_GT(large, TimeDelta::Millis(kSmall)); 110 EXPECT_LT(TimeDelta::Zero(), small); 111 EXPECT_GT(TimeDelta::Zero(), TimeDelta::Millis(-kSmall)); 112 EXPECT_GT(TimeDelta::Zero(), TimeDelta::Millis(-kSmall)); 113 114 EXPECT_GT(TimeDelta::PlusInfinity(), large); 115 EXPECT_LT(TimeDelta::MinusInfinity(), TimeDelta::Zero()); 116 } 117 118 TEST(TimeDeltaTest, Clamping) { 119 const TimeDelta upper = TimeDelta::Millis(800); 120 const TimeDelta lower = TimeDelta::Millis(100); 121 const TimeDelta under = TimeDelta::Millis(100); 122 const TimeDelta inside = TimeDelta::Millis(500); 123 const TimeDelta over = TimeDelta::Millis(1000); 124 EXPECT_EQ(under.Clamped(lower, upper), lower); 125 EXPECT_EQ(inside.Clamped(lower, upper), inside); 126 EXPECT_EQ(over.Clamped(lower, upper), upper); 127 128 TimeDelta mutable_delta = lower; 129 mutable_delta.Clamp(lower, upper); 130 EXPECT_EQ(mutable_delta, lower); 131 mutable_delta = inside; 132 mutable_delta.Clamp(lower, upper); 133 EXPECT_EQ(mutable_delta, inside); 134 mutable_delta = over; 135 mutable_delta.Clamp(lower, upper); 136 EXPECT_EQ(mutable_delta, upper); 137 } 138 139 TEST(TimeDeltaTest, CanBeInititializedFromLargeInt) { 140 const int kMaxInt = std::numeric_limits<int>::max(); 141 EXPECT_EQ(TimeDelta::Seconds(kMaxInt).us(), 142 static_cast<int64_t>(kMaxInt) * 1000000); 143 EXPECT_EQ(TimeDelta::Millis(kMaxInt).us(), 144 static_cast<int64_t>(kMaxInt) * 1000); 145 } 146 147 TEST(TimeDeltaTest, ConvertsToAndFromDouble) { 148 const int64_t kMicros = 17017; 149 const double kNanosDouble = kMicros * 1e3; 150 const double kMicrosDouble = kMicros; 151 const double kMillisDouble = kMicros * 1e-3; 152 const double kSecondsDouble = kMillisDouble * 1e-3; 153 154 EXPECT_EQ(TimeDelta::Micros(kMicros).seconds<double>(), kSecondsDouble); 155 EXPECT_EQ(TimeDelta::Seconds(kSecondsDouble).us(), kMicros); 156 157 EXPECT_EQ(TimeDelta::Micros(kMicros).ms<double>(), kMillisDouble); 158 EXPECT_EQ(TimeDelta::Millis(kMillisDouble).us(), kMicros); 159 160 EXPECT_EQ(TimeDelta::Micros(kMicros).us<double>(), kMicrosDouble); 161 EXPECT_EQ(TimeDelta::Micros(kMicrosDouble).us(), kMicros); 162 163 EXPECT_NEAR(TimeDelta::Micros(kMicros).ns<double>(), kNanosDouble, 1); 164 165 const double kPlusInfinity = std::numeric_limits<double>::infinity(); 166 const double kMinusInfinity = -kPlusInfinity; 167 168 EXPECT_EQ(TimeDelta::PlusInfinity().seconds<double>(), kPlusInfinity); 169 EXPECT_EQ(TimeDelta::MinusInfinity().seconds<double>(), kMinusInfinity); 170 EXPECT_EQ(TimeDelta::PlusInfinity().ms<double>(), kPlusInfinity); 171 EXPECT_EQ(TimeDelta::MinusInfinity().ms<double>(), kMinusInfinity); 172 EXPECT_EQ(TimeDelta::PlusInfinity().us<double>(), kPlusInfinity); 173 EXPECT_EQ(TimeDelta::MinusInfinity().us<double>(), kMinusInfinity); 174 EXPECT_EQ(TimeDelta::PlusInfinity().ns<double>(), kPlusInfinity); 175 EXPECT_EQ(TimeDelta::MinusInfinity().ns<double>(), kMinusInfinity); 176 177 EXPECT_TRUE(TimeDelta::Seconds(kPlusInfinity).IsPlusInfinity()); 178 EXPECT_TRUE(TimeDelta::Seconds(kMinusInfinity).IsMinusInfinity()); 179 EXPECT_TRUE(TimeDelta::Millis(kPlusInfinity).IsPlusInfinity()); 180 EXPECT_TRUE(TimeDelta::Millis(kMinusInfinity).IsMinusInfinity()); 181 EXPECT_TRUE(TimeDelta::Micros(kPlusInfinity).IsPlusInfinity()); 182 EXPECT_TRUE(TimeDelta::Micros(kMinusInfinity).IsMinusInfinity()); 183 } 184 185 TEST(TimeDeltaTest, MathOperations) { 186 const int64_t kValueA = 267; 187 const int64_t kValueB = 450; 188 const TimeDelta delta_a = TimeDelta::Millis(kValueA); 189 const TimeDelta delta_b = TimeDelta::Millis(kValueB); 190 EXPECT_EQ((delta_a + delta_b).ms(), kValueA + kValueB); 191 EXPECT_EQ((delta_a - delta_b).ms(), kValueA - kValueB); 192 193 EXPECT_EQ((delta_b / 10).ms(), kValueB / 10); 194 EXPECT_EQ(delta_b / delta_a, static_cast<double>(kValueB) / kValueA); 195 196 EXPECT_EQ(TimeDelta::Micros(-kValueA).Abs().us(), kValueA); 197 EXPECT_EQ(TimeDelta::Micros(kValueA).Abs().us(), kValueA); 198 199 TimeDelta mutable_delta = TimeDelta::Millis(kValueA); 200 mutable_delta += TimeDelta::Millis(kValueB); 201 EXPECT_EQ(mutable_delta, TimeDelta::Millis(kValueA + kValueB)); 202 mutable_delta -= TimeDelta::Millis(kValueB); 203 EXPECT_EQ(mutable_delta, TimeDelta::Millis(kValueA)); 204 } 205 206 TEST(TimeDeltaTest, MultiplyByScalar) { 207 const TimeDelta kValue = TimeDelta::Micros(267); 208 const int64_t kInt64 = 450; 209 const int32_t kInt32 = 123; 210 const size_t kUnsignedInt = 125; 211 const double kFloat = 123.0; 212 213 EXPECT_EQ((kValue * kInt64).us(), kValue.us() * kInt64); 214 EXPECT_EQ(kValue * kInt64, kInt64 * kValue); 215 216 EXPECT_EQ((kValue * kInt32).us(), kValue.us() * kInt32); 217 EXPECT_EQ(kValue * kInt32, kInt32 * kValue); 218 219 EXPECT_EQ((kValue * kUnsignedInt).us(), kValue.us() * int64_t{kUnsignedInt}); 220 EXPECT_EQ(kValue * kUnsignedInt, kUnsignedInt * kValue); 221 222 EXPECT_DOUBLE_EQ((kValue * kFloat).us(), kValue.us() * kFloat); 223 EXPECT_EQ(kValue * kFloat, kFloat * kValue); 224 } 225 226 TEST(TimeDeltaTest, InfinityOperations) { 227 const int64_t kValue = 267; 228 const TimeDelta finite = TimeDelta::Millis(kValue); 229 EXPECT_TRUE((TimeDelta::PlusInfinity() + finite).IsPlusInfinity()); 230 EXPECT_TRUE((TimeDelta::PlusInfinity() - finite).IsPlusInfinity()); 231 EXPECT_TRUE((finite + TimeDelta::PlusInfinity()).IsPlusInfinity()); 232 EXPECT_TRUE((finite - TimeDelta::MinusInfinity()).IsPlusInfinity()); 233 234 EXPECT_TRUE((TimeDelta::MinusInfinity() + finite).IsMinusInfinity()); 235 EXPECT_TRUE((TimeDelta::MinusInfinity() - finite).IsMinusInfinity()); 236 EXPECT_TRUE((finite + TimeDelta::MinusInfinity()).IsMinusInfinity()); 237 EXPECT_TRUE((finite - TimeDelta::PlusInfinity()).IsMinusInfinity()); 238 } 239 } // namespace test 240 } // namespace webrtc