base/unguessable_token_unittest.cc

   1 // Copyright 2016 The Chromium Authors
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/unguessable_token.h"
   6
   7 #include <memory>
   8 #include <sstream>
   9 #include <type_traits>
  10
  11 #include "base/hash/hash.h"
  12 #include "base/values.h"
  13 #include "testing/gtest/include/gtest/gtest.h"
  14
  15 namespace base {
  16
  17 void TestSmallerThanOperator(const UnguessableToken& a,
  18                              const UnguessableToken& b) {
  19   EXPECT_TRUE(a < b);
  20   EXPECT_FALSE(b < a);
  21 }
  22
  23 TEST(UnguessableTokenTest, VerifyEveryBit) {
  24   absl::optional<UnguessableToken> token = UnguessableToken::Deserialize(1, 2);
  25   ASSERT_TRUE(token.has_value());
  26   uint64_t high = 1;
  27   uint64_t low = 2;
  28
  29   for (uint64_t bit = 1; bit != 0; bit <<= 1) {
  30     uint64_t new_high = high ^ bit;
  31     absl::optional<UnguessableToken> new_token =
  32         UnguessableToken::Deserialize(new_high, low);
  33     ASSERT_TRUE(new_token.has_value());
  34     EXPECT_FALSE(*token == *new_token);
  35   }
  36
  37   for (uint64_t bit = 1; bit != 0; bit <<= 1) {
  38     uint64_t new_low = low ^ bit;
  39     absl::optional<UnguessableToken> new_token =
  40         UnguessableToken::Deserialize(high, new_low);
  41     ASSERT_TRUE(new_token.has_value());
  42     EXPECT_FALSE(*token == *new_token);
  43   }
  44 }
  45
  46 TEST(UnguessableTokenTest, VerifyEqualityOperators) {
  47   // Deserialize is used for testing purposes.
  48   // Use UnguessableToken::Create() in production code instead.
  49   UnguessableToken token = UnguessableToken::Deserialize(1, 2).value();
  50   UnguessableToken same_token = UnguessableToken::Deserialize(1, 2).value();
  51   UnguessableToken diff_token = UnguessableToken::Deserialize(1, 3).value();
  52   UnguessableToken empty_token;
  53
  54   EXPECT_TRUE(token == token);
  55   EXPECT_FALSE(token != token);
  56
  57   EXPECT_TRUE(token == same_token);
  58   EXPECT_FALSE(token != same_token);
  59
  60   EXPECT_FALSE(token == diff_token);
  61   EXPECT_FALSE(diff_token == token);
  62   EXPECT_TRUE(token != diff_token);
  63   EXPECT_TRUE(diff_token != token);
  64
  65   EXPECT_TRUE(empty_token == empty_token);
  66   EXPECT_FALSE(empty_token != empty_token);
  67   for (const UnguessableToken& this_token : {token, same_token, diff_token}) {
  68     EXPECT_FALSE(this_token == empty_token);
  69     EXPECT_TRUE(this_token != empty_token);
  70   }
  71 }
  72
  73 TEST(UnguessableTokenTest, VerifyConstructors) {
  74   UnguessableToken token = UnguessableToken::Create();
  75   EXPECT_FALSE(token.is_empty());
  76   EXPECT_TRUE(token);
  77
  78   UnguessableToken copied_token(token);
  79   EXPECT_TRUE(copied_token);
  80   EXPECT_EQ(token, copied_token);
  81
  82   UnguessableToken uninitialized;
  83   EXPECT_TRUE(uninitialized.is_empty());
  84   EXPECT_FALSE(uninitialized);
  85
  86   EXPECT_TRUE(UnguessableToken().is_empty());
  87   EXPECT_FALSE(UnguessableToken());
  88 }
  89
  90 TEST(UnguessableTokenTest, VerifySerialization) {
  91   UnguessableToken token = UnguessableToken::Create();
  92
  93   uint64_t high = token.GetHighForSerialization();
  94   uint64_t low = token.GetLowForSerialization();
  95
  96   EXPECT_TRUE(high);
  97   EXPECT_TRUE(low);
  98
  99   absl::optional<UnguessableToken> Deserialized =
 100       UnguessableToken::Deserialize(high, low);
 101   ASSERT_TRUE(Deserialized.has_value());
 102   EXPECT_EQ(token, *Deserialized);
 103 }
 104
 105 // Common case (~88% of the time) - no leading zeroes in high_ nor low_.
 106 TEST(UnguessableTokenTest, VerifyToString1) {
 107   UnguessableToken token =
 108       UnguessableToken::Deserialize(0x1234567890ABCDEF, 0xFEDCBA0987654321)
 109           .value();
 110   std::string expected = "1234567890ABCDEFFEDCBA0987654321";
 111
 112   EXPECT_EQ(expected, token.ToString());
 113
 114   std::string expected_stream = "(1234567890ABCDEFFEDCBA0987654321)";
 115   std::stringstream stream;
 116   stream << token;
 117   EXPECT_EQ(expected_stream, stream.str());
 118 }
 119
 120 // Less common case - leading zeroes in high_ or low_ (testing with both).
 121 TEST(UnguessableTokenTest, VerifyToString2) {
 122   UnguessableToken token = UnguessableToken::Deserialize(0x123, 0xABC).value();
 123   std::string expected = "00000000000001230000000000000ABC";
 124
 125   EXPECT_EQ(expected, token.ToString());
 126
 127   std::string expected_stream = "(00000000000001230000000000000ABC)";
 128   std::stringstream stream;
 129   stream << token;
 130   EXPECT_EQ(expected_stream, stream.str());
 131 }
 132
 133 TEST(UnguessableTokenTest, VerifyToStringUniqueness) {
 134   const UnguessableToken token1 =
 135       UnguessableToken::Deserialize(0x0000000012345678, 0x0000000123456789)
 136           .value();
 137   const UnguessableToken token2 =
 138       UnguessableToken::Deserialize(0x0000000123456781, 0x0000000023456789)
 139           .value();
 140   EXPECT_NE(token1.ToString(), token2.ToString());
 141 }
 142
 143 TEST(UnguessableTokenTest, VerifyDeserializeZeroes) {
 144   absl::optional<UnguessableToken> token = UnguessableToken::Deserialize(0, 0);
 145
 146   EXPECT_FALSE(token.has_value());
 147 }
 148
 149 TEST(UnguessableTokenTest, VerifySmallerThanOperator) {
 150   // Deserialize is used for testing purposes.
 151   // Use UnguessableToken::Create() in production code instead.
 152   {
 153     SCOPED_TRACE("a.low < b.low and a.high == b.high.");
 154     TestSmallerThanOperator(UnguessableToken::Deserialize(0, 1).value(),
 155                             UnguessableToken::Deserialize(0, 5).value());
 156   }
 157   {
 158     SCOPED_TRACE("a.low == b.low and a.high < b.high.");
 159     TestSmallerThanOperator(UnguessableToken::Deserialize(1, 0).value(),
 160                             UnguessableToken::Deserialize(5, 0).value());
 161   }
 162   {
 163     SCOPED_TRACE("a.low < b.low and a.high < b.high.");
 164     TestSmallerThanOperator(UnguessableToken::Deserialize(1, 1).value(),
 165                             UnguessableToken::Deserialize(5, 5).value());
 166   }
 167   {
 168     SCOPED_TRACE("a.low > b.low and a.high < b.high.");
 169     TestSmallerThanOperator(UnguessableToken::Deserialize(1, 10).value(),
 170                             UnguessableToken::Deserialize(10, 1).value());
 171   }
 172 }
 173
 174 TEST(UnguessableTokenTest, VerifyHash) {
 175   UnguessableToken token = UnguessableToken::Create();
 176
 177   EXPECT_EQ(base::HashInts64(token.GetHighForSerialization(),
 178                              token.GetLowForSerialization()),
 179             UnguessableTokenHash()(token));
 180 }
 181
 182 TEST(UnguessableTokenTest, VerifyBasicUniqueness) {
 183   EXPECT_NE(UnguessableToken::Create(), UnguessableToken::Create());
 184
 185   UnguessableToken token = UnguessableToken::Create();
 186   EXPECT_NE(token.GetHighForSerialization(), token.GetLowForSerialization());
 187 }
 188 }