[go: nahoru, domu]
Google Git
Sign in
chromium / chromium / src / f873781812fb1cb5679d9d82cc1441037d3f0d9a / . / base / unguessable_token_unittest.cc
blob: e190778d8cedd8f2a59e419cb517007dd79d53fa [file] [log] [blame]
Avi Drissmane4622aa2022-09-08 20:36:06[diff] [blame]1// Copyright 2016 The Chromium Authors
tguilbert4a5ac602016-09-19 21:11:25[diff] [blame]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
yucliud62536a2017-08-01 06:06:30[diff] [blame]7#include <memory>
tguilbert13be8a32016-09-20 02:04:50[diff] [blame]8#include <sstream>
tguilbert4a5ac602016-09-19 21:11:25[diff] [blame]9#include <type_traits>
10
Lei Zhang54bf25d2023-09-30 02:03:58[diff] [blame]11#include "base/hash/hash.h"
yucliud62536a2017-08-01 06:06:30[diff] [blame]12#include "base/values.h"
tguilbert4a5ac602016-09-19 21:11:25[diff] [blame]13#include "testing/gtest/include/gtest/gtest.h"
14
15namespace base {
16
17void TestSmallerThanOperator(const UnguessableToken& a,
18 const UnguessableToken& b) {
19 EXPECT_TRUE(a < b);
20 EXPECT_FALSE(b < a);
21}
22
Liza Burakovae7e943012021-07-16 14:09:05[diff] [blame]23TEST(UnguessableTokenTest, VerifyEveryBit) {
Andrew Williams228be952023-01-26 15:13:01[diff] [blame]24 absl::optional<UnguessableToken> token = UnguessableToken::Deserialize(1, 2);
Andrew Williams6e56276f2023-01-05 16:53:44[diff] [blame]25 ASSERT_TRUE(token.has_value());
Liza Burakovae7e943012021-07-16 14:09:05[diff] [blame]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;
Andrew Williams6e56276f2023-01-05 16:53:44[diff] [blame]31 absl::optional<UnguessableToken> new_token =
Andrew Williams228be952023-01-26 15:13:01[diff] [blame]32 UnguessableToken::Deserialize(new_high, low);
Andrew Williams6e56276f2023-01-05 16:53:44[diff] [blame]33 ASSERT_TRUE(new_token.has_value());
34 EXPECT_FALSE(*token == *new_token);
Liza Burakovae7e943012021-07-16 14:09:05[diff] [blame]35 }
36
37 for (uint64_t bit = 1; bit != 0; bit <<= 1) {
38 uint64_t new_low = low ^ bit;
Andrew Williams6e56276f2023-01-05 16:53:44[diff] [blame]39 absl::optional<UnguessableToken> new_token =
Andrew Williams228be952023-01-26 15:13:01[diff] [blame]40 UnguessableToken::Deserialize(high, new_low);
Andrew Williams6e56276f2023-01-05 16:53:44[diff] [blame]41 ASSERT_TRUE(new_token.has_value());
42 EXPECT_FALSE(*token == *new_token);
Liza Burakovae7e943012021-07-16 14:09:05[diff] [blame]43 }
44}
45
tguilbert4a5ac602016-09-19 21:11:25[diff] [blame]46TEST(UnguessableTokenTest, VerifyEqualityOperators) {
47 // Deserialize is used for testing purposes.
48 // Use UnguessableToken::Create() in production code instead.
Andrew Williams228be952023-01-26 15:13:01[diff] [blame]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();
Dan McArdle1c44f4cc2021-08-31 22:33:52[diff] [blame]52 UnguessableToken empty_token;
tguilbert4a5ac602016-09-19 21:11:25[diff] [blame]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);
Dan McArdle1c44f4cc2021-08-31 22:33:52[diff] [blame]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 }
tguilbert4a5ac602016-09-19 21:11:25[diff] [blame]71}
72
73TEST(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
90TEST(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
Andrew Williams6e56276f2023-01-05 16:53:44[diff] [blame]99 absl::optional<UnguessableToken> Deserialized =
Andrew Williams228be952023-01-26 15:13:01[diff] [blame]100 UnguessableToken::Deserialize(high, low);
Andrew Williams6e56276f2023-01-05 16:53:44[diff] [blame]101 ASSERT_TRUE(Deserialized.has_value());
102 EXPECT_EQ(token, *Deserialized);
tguilbert4a5ac602016-09-19 21:11:25[diff] [blame]103}
104
Elad Alond16e74c2018-02-26 13:16:50[diff] [blame]105// Common case (~88% of the time) - no leading zeroes in high_ nor low_.
106TEST(UnguessableTokenTest, VerifyToString1) {
107 UnguessableToken token =
Andrew Williams228be952023-01-26 15:13:01[diff] [blame]108 UnguessableToken::Deserialize(0x1234567890ABCDEF, 0xFEDCBA0987654321)
Andrew Williams6e56276f2023-01-05 16:53:44[diff] [blame]109 .value();
Elad Alond16e74c2018-02-26 13:16:50[diff] [blame]110 std::string expected = "1234567890ABCDEFFEDCBA0987654321";
tguilbert4a5ac602016-09-19 21:11:25[diff] [blame]111
112 EXPECT_EQ(expected, token.ToString());
tguilbert13be8a32016-09-20 02:04:50[diff] [blame]113
Elad Alond16e74c2018-02-26 13:16:50[diff] [blame]114 std::string expected_stream = "(1234567890ABCDEFFEDCBA0987654321)";
tguilbert13be8a32016-09-20 02:04:50[diff] [blame]115 std::stringstream stream;
116 stream << token;
Pavel Feldman7bbfbc82017-12-29 01:42:56[diff] [blame]117 EXPECT_EQ(expected_stream, stream.str());
tguilbert4a5ac602016-09-19 21:11:25[diff] [blame]118}
119
Elad Alond16e74c2018-02-26 13:16:50[diff] [blame]120// Less common case - leading zeroes in high_ or low_ (testing with both).
121TEST(UnguessableTokenTest, VerifyToString2) {
Andrew Williams228be952023-01-26 15:13:01[diff] [blame]122 UnguessableToken token = UnguessableToken::Deserialize(0x123, 0xABC).value();
Elad Alond16e74c2018-02-26 13:16:50[diff] [blame]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
133TEST(UnguessableTokenTest, VerifyToStringUniqueness) {
134 const UnguessableToken token1 =
Andrew Williams228be952023-01-26 15:13:01[diff] [blame]135 UnguessableToken::Deserialize(0x0000000012345678, 0x0000000123456789)
Andrew Williams6e56276f2023-01-05 16:53:44[diff] [blame]136 .value();
Elad Alond16e74c2018-02-26 13:16:50[diff] [blame]137 const UnguessableToken token2 =
Andrew Williams228be952023-01-26 15:13:01[diff] [blame]138 UnguessableToken::Deserialize(0x0000000123456781, 0x0000000023456789)
Andrew Williams6e56276f2023-01-05 16:53:44[diff] [blame]139 .value();
Elad Alond16e74c2018-02-26 13:16:50[diff] [blame]140 EXPECT_NE(token1.ToString(), token2.ToString());
141}
142
Andrew Williams6e56276f2023-01-05 16:53:44[diff] [blame]143TEST(UnguessableTokenTest, VerifyDeserializeZeroes) {
Andrew Williams228be952023-01-26 15:13:01[diff] [blame]144 absl::optional<UnguessableToken> token = UnguessableToken::Deserialize(0, 0);
Andrew Williams6e56276f2023-01-05 16:53:44[diff] [blame]145
146 EXPECT_FALSE(token.has_value());
147}
148
Yulun Zeng82a26912023-12-18 23:04:57[diff] [blame]149TEST(UnguessableTokenTest, VerifyDeserializeFromString) {
150 auto expected = UnguessableToken::CreateForTesting(1, 2);
151 auto actual = UnguessableToken::DeserializeFromString(
152 "00000000000000010000000000000002");
153 EXPECT_TRUE(actual.has_value());
154 EXPECT_TRUE(actual.value() == expected);
155}
156
157TEST(UnguessableTokenTest, VerifyDeserializeFromInvalidString) {
158 const char* invalid_representations[] = {
159 // Not a hex string representing 128 bits.
160 "1234",
161 // A string with valid length of 128 bits but 'X' is not a hex value.
162 "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX",
163 // A invalid hex string because of the lower case letters.
164 "0123456789abcdef0123456789abcdef",
165 // A zeroed out token is not a valid `UnguessableToken`.
166 "00000000000000000000000000000000"};
167 for (auto* invalid_representation : invalid_representations) {
168 auto actual =
169 UnguessableToken::DeserializeFromString(invalid_representation);
170 EXPECT_FALSE(actual.has_value())
171 << "'" << invalid_representation
172 << "' should not be deserialized to an UnguessableToken.";
173 ;
174 }
175}
176
tguilbert4a5ac602016-09-19 21:11:25[diff] [blame]177TEST(UnguessableTokenTest, VerifySmallerThanOperator) {
178 // Deserialize is used for testing purposes.
179 // Use UnguessableToken::Create() in production code instead.
180 {
181 SCOPED_TRACE("a.low < b.low and a.high == b.high.");
Andrew Williams228be952023-01-26 15:13:01[diff] [blame]182 TestSmallerThanOperator(UnguessableToken::Deserialize(0, 1).value(),
183 UnguessableToken::Deserialize(0, 5).value());
tguilbert4a5ac602016-09-19 21:11:25[diff] [blame]184 }
185 {
186 SCOPED_TRACE("a.low == b.low and a.high < b.high.");
Andrew Williams228be952023-01-26 15:13:01[diff] [blame]187 TestSmallerThanOperator(UnguessableToken::Deserialize(1, 0).value(),
188 UnguessableToken::Deserialize(5, 0).value());
tguilbert4a5ac602016-09-19 21:11:25[diff] [blame]189 }
190 {
191 SCOPED_TRACE("a.low < b.low and a.high < b.high.");
Andrew Williams228be952023-01-26 15:13:01[diff] [blame]192 TestSmallerThanOperator(UnguessableToken::Deserialize(1, 1).value(),
193 UnguessableToken::Deserialize(5, 5).value());
tguilbert4a5ac602016-09-19 21:11:25[diff] [blame]194 }
195 {
196 SCOPED_TRACE("a.low > b.low and a.high < b.high.");
Andrew Williams228be952023-01-26 15:13:01[diff] [blame]197 TestSmallerThanOperator(UnguessableToken::Deserialize(1, 10).value(),
198 UnguessableToken::Deserialize(10, 1).value());
tguilbert4a5ac602016-09-19 21:11:25[diff] [blame]199 }
200}
201
202TEST(UnguessableTokenTest, VerifyHash) {
203 UnguessableToken token = UnguessableToken::Create();
204
205 EXPECT_EQ(base::HashInts64(token.GetHighForSerialization(),
206 token.GetLowForSerialization()),
207 UnguessableTokenHash()(token));
208}
209
210TEST(UnguessableTokenTest, VerifyBasicUniqueness) {
211 EXPECT_NE(UnguessableToken::Create(), UnguessableToken::Create());
212
213 UnguessableToken token = UnguessableToken::Create();
214 EXPECT_NE(token.GetHighForSerialization(), token.GetLowForSerialization());
215}
216}