RTCCertificate serialization.

webrtc/base/rtccertificate_unittest.cc

 /*
  *  Copyright 2015 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.
  */
 
@@ skipping 17 matching lines @@
 static const char* kTestCertCommonName = "RTCCertificateTest's certificate";
 
 }  // namespace
 
 class RTCCertificateTest : public testing::Test {
  public:
   RTCCertificateTest() {}
   ~RTCCertificateTest() {}
 
  protected:
+  scoped_refptr<RTCCertificate> GenerateECDSA() {
+    std::unique_ptr<SSLIdentity> identity(
+        SSLIdentity::Generate(kTestCertCommonName, KeyParams::ECDSA()));
+    RTC_CHECK(identity);
+    return RTCCertificate::Create(std::move(identity));
+  }
+
   // Timestamp note:
   //   All timestamps in this unittest are expressed in number of seconds since
   // epoch, 1970-01-01T00:00:00Z (UTC). The RTCCertificate interface uses ms,
   // but only seconds-precision is supported by SSLCertificate. To make the
   // tests clearer we convert everything to seconds since the precision matters
   // when generating certificates or comparing timestamps.
   //   As a result, ExpiresSeconds and HasExpiredSeconds are used instead of
   // RTCCertificate::Expires and ::HasExpired for ms -> s conversion.
 
   uint64_t NowSeconds() const {
@@ skipping 30 matching lines @@
     params.key_params = KeyParams::ECDSA();
 
     std::unique_ptr<SSLIdentity> identity(SSLIdentity::GenerateForTest(params));
     return RTCCertificate::Create(std::move(identity));
   }
 };
 
 TEST_F(RTCCertificateTest, NewCertificateNotExpired) {
   // Generate a real certificate without specifying the expiration time.
   // Certificate type doesn't matter, using ECDSA because it's fast to generate.
-  std::unique_ptr<SSLIdentity> identity(
-      SSLIdentity::Generate(kTestCertCommonName, KeyParams::ECDSA()));
-  scoped_refptr<RTCCertificate> certificate =
-      RTCCertificate::Create(std::move(identity));
+  scoped_refptr<RTCCertificate> certificate = GenerateECDSA();
 
   uint64_t now = NowSeconds();
   EXPECT_FALSE(HasExpiredSeconds(certificate, now));
   // Even without specifying the expiration time we would expect it to be valid
   // for at least half an hour.
   EXPECT_FALSE(HasExpiredSeconds(certificate, now + 30*60));
 }
 
 TEST_F(RTCCertificateTest, UsesExpiresAskedFor) {
   uint64_t now = NowSeconds();
   scoped_refptr<RTCCertificate> certificate =
       GenerateCertificateWithExpires(now);
   EXPECT_EQ(now, ExpiresSeconds(certificate));
 }
 
 TEST_F(RTCCertificateTest, ExpiresInOneSecond) {
   // Generate a certificate that expires in 1s.
   uint64_t now = NowSeconds();
   scoped_refptr<RTCCertificate> certificate =
       GenerateCertificateWithExpires(now + 1);
   // Now it should not have expired.
   EXPECT_FALSE(HasExpiredSeconds(certificate, now));
   // In 2s it should have expired.
   EXPECT_TRUE(HasExpiredSeconds(certificate, now + 2));
 }
 
+TEST_F(RTCCertificateTest, DifferentCertificatesNotEqual) {
+  scoped_refptr<RTCCertificate> a = GenerateECDSA();
+  scoped_refptr<RTCCertificate> b = GenerateECDSA();
+  EXPECT_TRUE(*a != *b);
+}
+
+TEST_F(RTCCertificateTest, CloneWithPEMSerialization) {
+  scoped_refptr<RTCCertificate> orig = GenerateECDSA();
+
+  // To PEM.
+  RTCCertificatePEM orig_pem = orig->ToPEM();
+  // Clone from PEM.
+  scoped_refptr<RTCCertificate> clone = RTCCertificate::FromPEM(orig_pem);
+  EXPECT_TRUE(clone);
+  EXPECT_TRUE(*orig == *clone);
+  EXPECT_EQ(orig->Expires(), clone->Expires());
+}
+
 }  // namespace rtc