commit 9de4ef4b24f0473082081b040e7f874cb4abfda4
author Sebastian Jansson <srte@webrtc.org> Tue Sep 04 17:32:36 2018 +0200
committer Commit Bot <commit-bot@chromium.org> Tue Sep 04 17:14:05 2018 +0000
tree 71dc701c456617ecd0529a1a088eb1f97880b17c
parent 376e1147e6b7ff4842b2d8804de24a395fd96756

Adds signed infinity to timestamps.

Negative infinity is useful in comparisons as it represents a value
guaranteed to be less than any other timestamp. This avoid using
Timestamp::ms(0) to represent such a value or having to use optional
for the special case of first time execution.

To avoid ambiguity, Timestamp::Infinity is renamed to PlusInfinity.

Bug: webrtc:9709
Change-Id: Ib2debff91036e94d1dc903ec0c6faae30febde4e
Reviewed-on: https://webrtc-review.googlesource.com/79440
Commit-Queue: Sebastian Jansson <srte@webrtc.org>
Reviewed-by: Karl Wiberg <kwiberg@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#24556}

api/units/timestamp_unittest.cc

diff --git a/api/units/timestamp_unittest.cc b/api/units/timestamp_unittest.cc
index ff0c79e..6c2d1ee 100644
--- a/api/units/timestamp_unittest.cc
+++ b/api/units/timestamp_unittest.cc
@@ -15,7 +15,7 @@
 namespace test {
 TEST(TimestampTest, ConstExpr) {
   constexpr int64_t kValue = 12345;
-  constexpr Timestamp kTimestampInf = Timestamp::Infinity();
+  constexpr Timestamp kTimestampInf = Timestamp::PlusInfinity();
   static_assert(kTimestampInf.IsInfinite(), "");
   static_assert(kTimestampInf.ms_or(-1) == -1, "");
 
@@ -55,20 +55,28 @@
 TEST(TimestampTest, IdentityChecks) {
   const int64_t kValue = 3000;
 
-  EXPECT_TRUE(Timestamp::Infinity().IsInfinite());
+  EXPECT_TRUE(Timestamp::PlusInfinity().IsInfinite());
+  EXPECT_TRUE(Timestamp::MinusInfinity().IsInfinite());
   EXPECT_FALSE(Timestamp::ms(kValue).IsInfinite());
 
-  EXPECT_FALSE(Timestamp::Infinity().IsFinite());
+  EXPECT_FALSE(Timestamp::PlusInfinity().IsFinite());
+  EXPECT_FALSE(Timestamp::MinusInfinity().IsFinite());
   EXPECT_TRUE(Timestamp::ms(kValue).IsFinite());
+
+  EXPECT_TRUE(Timestamp::PlusInfinity().IsPlusInfinity());
+  EXPECT_FALSE(Timestamp::MinusInfinity().IsPlusInfinity());
+
+  EXPECT_TRUE(Timestamp::MinusInfinity().IsMinusInfinity());
+  EXPECT_FALSE(Timestamp::PlusInfinity().IsMinusInfinity());
 }
 
 TEST(TimestampTest, ComparisonOperators) {
   const int64_t kSmall = 450;
   const int64_t kLarge = 451;
 
-  EXPECT_EQ(Timestamp::Infinity(), Timestamp::Infinity());
-  EXPECT_GE(Timestamp::Infinity(), Timestamp::Infinity());
-  EXPECT_GT(Timestamp::Infinity(), Timestamp::ms(kLarge));
+  EXPECT_EQ(Timestamp::PlusInfinity(), Timestamp::PlusInfinity());
+  EXPECT_GE(Timestamp::PlusInfinity(), Timestamp::PlusInfinity());
+  EXPECT_GT(Timestamp::PlusInfinity(), Timestamp::ms(kLarge));
   EXPECT_EQ(Timestamp::ms(kSmall), Timestamp::ms(kSmall));
   EXPECT_LE(Timestamp::ms(kSmall), Timestamp::ms(kSmall));
   EXPECT_GE(Timestamp::ms(kSmall), Timestamp::ms(kSmall));
@@ -102,14 +110,21 @@
   EXPECT_EQ(Timestamp::us(kMicrosDouble).us(), kMicros);
 
   const double kPlusInfinity = std::numeric_limits<double>::infinity();
+  const double kMinusInfinity = -kPlusInfinity;
 
-  EXPECT_EQ(Timestamp::Infinity().seconds<double>(), kPlusInfinity);
-  EXPECT_EQ(Timestamp::Infinity().ms<double>(), kPlusInfinity);
-  EXPECT_EQ(Timestamp::Infinity().us<double>(), kPlusInfinity);
+  EXPECT_EQ(Timestamp::PlusInfinity().seconds<double>(), kPlusInfinity);
+  EXPECT_EQ(Timestamp::MinusInfinity().seconds<double>(), kMinusInfinity);
+  EXPECT_EQ(Timestamp::PlusInfinity().ms<double>(), kPlusInfinity);
+  EXPECT_EQ(Timestamp::MinusInfinity().ms<double>(), kMinusInfinity);
+  EXPECT_EQ(Timestamp::PlusInfinity().us<double>(), kPlusInfinity);
+  EXPECT_EQ(Timestamp::MinusInfinity().us<double>(), kMinusInfinity);
 
-  EXPECT_TRUE(Timestamp::seconds(kPlusInfinity).IsInfinite());
-  EXPECT_TRUE(Timestamp::ms(kPlusInfinity).IsInfinite());
-  EXPECT_TRUE(Timestamp::us(kPlusInfinity).IsInfinite());
+  EXPECT_TRUE(Timestamp::seconds(kPlusInfinity).IsPlusInfinity());
+  EXPECT_TRUE(Timestamp::seconds(kMinusInfinity).IsMinusInfinity());
+  EXPECT_TRUE(Timestamp::ms(kPlusInfinity).IsPlusInfinity());
+  EXPECT_TRUE(Timestamp::ms(kMinusInfinity).IsMinusInfinity());
+  EXPECT_TRUE(Timestamp::us(kPlusInfinity).IsPlusInfinity());
+  EXPECT_TRUE(Timestamp::us(kMinusInfinity).IsMinusInfinity());
 }
 
 TEST(UnitConversionTest, TimestampAndTimeDeltaMath) {
@@ -135,8 +150,8 @@
   const int64_t kValue = 267;
   const Timestamp finite_time = Timestamp::ms(kValue);
   const TimeDelta finite_delta = TimeDelta::ms(kValue);
-  EXPECT_TRUE((Timestamp::Infinity() + finite_delta).IsInfinite());
-  EXPECT_TRUE((Timestamp::Infinity() - finite_delta).IsInfinite());
+  EXPECT_TRUE((Timestamp::PlusInfinity() + finite_delta).IsInfinite());
+  EXPECT_TRUE((Timestamp::PlusInfinity() - finite_delta).IsInfinite());
   EXPECT_TRUE((finite_time + TimeDelta::PlusInfinity()).IsInfinite());
   EXPECT_TRUE((finite_time - TimeDelta::MinusInfinity()).IsInfinite());
 }