Add base::UnguessableToken

base/nonce_token_unittest.cc

+// Copyright (c) 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "base/nonce_token.h"
+
+#include <type_traits>
+
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace base {
+
+void TestSmallerThanOperator(const NonceToken& a, const NonceToken& b) {
+  EXPECT_TRUE(a < b);
+  EXPECT_FALSE(b < a);
+}
+
+TEST(NonceTest, VerifyEqualityOperators) {
+  // Deserialize is used for testing purposes.
+  // Use NonceToken::Create() in production code instead.
+  NonceToken nonce = NonceToken::Deserialize(1, 2);
+  NonceToken same_nonce = NonceToken::Deserialize(1, 2);
+  NonceToken diff_nonce = NonceToken::Deserialize(1, 3);
+
+  EXPECT_TRUE(nonce == nonce);
+  EXPECT_FALSE(nonce != nonce);
+
+  EXPECT_TRUE(nonce == same_nonce);
+  EXPECT_FALSE(nonce != same_nonce);
+
+  EXPECT_FALSE(nonce == diff_nonce);
+  EXPECT_FALSE(diff_nonce == nonce);
+  EXPECT_TRUE(nonce != diff_nonce);
+  EXPECT_TRUE(diff_nonce != nonce);
+}
+
+TEST(NonceTest, VerifyConstructors) {
+  NonceToken nonce = NonceToken::Create();
+  EXPECT_FALSE(nonce.is_empty());
+  EXPECT_TRUE(nonce);
+
+  NonceToken copied_nonce(nonce);
+  EXPECT_TRUE(copied_nonce);
+  EXPECT_EQ(nonce, copied_nonce);
+
+  NonceToken uninitialized;
+  EXPECT_TRUE(uninitialized.is_empty());
+  EXPECT_FALSE(uninitialized);
+
+  EXPECT_TRUE(NonceToken().is_empty());
+  EXPECT_FALSE(NonceToken());
+}
+
+TEST(NonceTest, VerifySerialization) {
+  NonceToken nonce = NonceToken::Create();
+
+  uint64_t high = 0;
+  uint64_t low = 0;
+  nonce.Serialize(&high, &low);
+
+  EXPECT_FALSE(NonceToken::IsZeroData(high, low));
+
+  NonceToken Deserialized = NonceToken::Deserialize(high, low);
+  EXPECT_EQ(nonce, Deserialized);
+}
+
+TEST(NonceTest, VerifySmallerThanOperator) {
+  // Deserialize is used for testing purposes.
+  // Use NonceToken::Create() in production code instead.
+
+  // a.low < b.low and a.high == b.high.
+  TestSmallerThanOperator(NonceToken::Deserialize(0, 1),
+                          NonceToken::Deserialize(0, 5));
+
+  // a.low == b.low and a.high < b.high.
+  TestSmallerThanOperator(NonceToken::Deserialize(1, 0),
+                          NonceToken::Deserialize(5, 0));
+
+  // a.low < b.low and a.high < b.high.
+  TestSmallerThanOperator(NonceToken::Deserialize(1, 1),
+                          NonceToken::Deserialize(5, 5));
+
+  // a.low > b.low and a.high < b.high.
+  TestSmallerThanOperator(NonceToken::Deserialize(1, 10),
+                          NonceToken::Deserialize(10, 1));
+}
+
+TEST(NonceTest, VerifyHash) {
+  NonceToken nonce = NonceToken::Create();
+
+  uint64_t high, low;
+  nonce.Serialize(&high, &low);
+
+  EXPECT_EQ(base::HashInts64(high, low), NonceTokenHash{}(nonce));
+}
+
+TEST(NonceTest, VerifyBasicUniqueness) {
+  EXPECT_NE(NonceToken::Create(), NonceToken::Create());
+
+  uint64_t high, low;
+  NonceToken::Create().Serialize(&high, &low);
+  EXPECT_NE(high, low);
+}
+}