Provide method for returning certificate expiration timestamp.

webrtc/base/timeutils_unittest.cc

 /*
  *  Copyright 2004 The WebRTC Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 #include "webrtc/base/common.h"
 #include "webrtc/base/gunit.h"
+#include "webrtc/base/helpers.h"
 #include "webrtc/base/thread.h"
 #include "webrtc/base/timeutils.h"
 
 namespace rtc {
 
 TEST(TimeTest, TimeInMs) {
   uint32_t ts_earlier = Time();
   Thread::SleepMs(100);
   uint32_t ts_now = Time();
   // Allow for the thread to wakeup ~20ms early.
@@ skipping 136 matching lines @@
   unwrapped_ts += 0x10;
   EXPECT_EQ(unwrapped_ts, wraparound_handler_.Unwrap(ts));
   ts = 0xfffffff2;
   unwrapped_ts += 0xfffffff0;
   EXPECT_EQ(unwrapped_ts, wraparound_handler_.Unwrap(ts));
   ts = 0;
   unwrapped_ts += 0xe;
   EXPECT_EQ(unwrapped_ts, wraparound_handler_.Unwrap(ts));
 }
 
+class TmToSeconds : public testing::Test {
+ public:
+  TmToSeconds() {
+    // Set use of the test RNG to get deterministic expiration timestamp.
+    rtc::SetRandomTestMode(true);
+  }
+  ~TmToSeconds() {
+    // Put it back for the next test.
+    rtc::SetRandomTestMode(false);
+  }
+
+  void TestTmToSeconds(int times) {
+    static char mdays[12] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
+    for (int i = 0; i < times; i++) {
+
+      // First generate something correct and check that TmToSeconds is happy.

[nisse-webrtc, 2015/12/01 08:10:37]

If you don't do that elsewhere, I think it would make sense to produce valid
inputs using gmtime, and check that TmToSeconds is the inverse. Like,

time_t t = random_something(); // Possibly 32-bit only
std::tm tm;
EXPECT_TRUE(gmtime_r(&t, &tm));
EXPECT_TRUE(rtc::TmToSeconds(tm) == t);

BTW, I guess all time formats involved here are blissfully ignorant of leap
seconds? (Which could be represented in a struct tm, but gmtime inherits
ignorance from the definition of time_t values. To be clear, I see *no*
practical problem with treating an expiration time with seconds == 60 as always
invalid, and seconds == 59 as always valid, but I'm a bit curious as to what the
spec says. Most likely, it says nothing...).

+      int year = rtc::CreateRandomId() % 400 + 1970;
+
+      bool leap_year = false;
+      if (year % 4 == 0)
+        leap_year = true;
+      if (year % 100 == 0)
+        leap_year = false;
+      if (year % 400 == 0)
+        leap_year = true;
+
+      std::tm tm;
+      tm.tm_year = year - 1900;  // std::tm is year 1900 based.
+      tm.tm_mon = rtc::CreateRandomId() % 12;
+      tm.tm_mday = rtc::CreateRandomId() % mdays[tm.tm_mon] + 1;
+      tm.tm_hour = rtc::CreateRandomId() % 24;
+      tm.tm_min = rtc::CreateRandomId() % 60;
+      tm.tm_sec = rtc::CreateRandomId() % 60;
+      int64_t t = rtc::TmToSeconds(tm);
+      EXPECT_TRUE(t >= 0);
+
+      // Now damage a random field and check that TmToSeconds is unhappy.
+      switch (rtc::CreateRandomId() % 11) {
+        case 0:
+          tm.tm_year = 1969 - 1900;
+          break;
+        case 1:
+          tm.tm_mon = -1;
+          break;
+        case 2:
+          tm.tm_mon = 12;
+          break;
+        case 3:
+          tm.tm_mday = 0;
+          break;
+        case 4:
+          tm.tm_mday = mdays[tm.tm_mon] + (leap_year && tm.tm_mon == 1) + 1;
+          break;
+        case 5:
+          tm.tm_hour = -1;
+          break;
+        case 6:
+          tm.tm_hour = 24;
+          break;
+        case 7:
+          tm.tm_min = -1;
+          break;
+        case 8:
+          tm.tm_min = 60;
+          break;
+        case 9:
+          tm.tm_sec = -1;
+          break;
+        case 10:
+          tm.tm_sec = 60;
+          break;
+      }
+      EXPECT_EQ(rtc::TmToSeconds(tm), -1);
+    }
+  }
+};
+
+TEST_F(TmToSeconds, TestTmToSeconds) {
+  TestTmToSeconds(100000);
+}
+
 }  // namespace rtc