base/guid_unittest.cc

   1 // Copyright 2012 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/guid.h"
   6
   7 #include <stdint.h>
   8
   9 #include <limits>
  10 #include <set>
  11 #include <unordered_set>
  12
  13 #include "base/strings/string_util.h"
  14 #include "build/build_config.h"
  15 #include "testing/gtest/include/gtest/gtest.h"
  16
  17 namespace base {
  18
  19 TEST(GUIDTest, GUIDGeneratesAllZeroes) {
  20   static constexpr uint64_t kBytes[] = {0, 0};
  21   const std::string clientid = RandomDataToGUIDString(kBytes);
  22   EXPECT_EQ("00000000-0000-0000-0000-000000000000", clientid);
  23 }
  24
  25 TEST(GUIDTest, GUIDGeneratesCorrectly) {
  26   static constexpr uint64_t kBytes[] = {0x0123456789ABCDEFULL,
  27                                         0xFEDCBA9876543210ULL};
  28   const std::string clientid = RandomDataToGUIDString(kBytes);
  29   EXPECT_EQ("01234567-89ab-cdef-fedc-ba9876543210", clientid);
  30 }
  31
  32 TEST(GUIDTest, DeprecatedGUIDCorrectlyFormatted) {
  33   constexpr int kIterations = 10;
  34   for (int i = 0; i < kIterations; ++i) {
  35     const std::string guid = GenerateGUID();
  36     EXPECT_TRUE(IsValidGUID(guid));
  37     EXPECT_TRUE(IsValidGUIDOutputString(guid));
  38     EXPECT_TRUE(IsValidGUID(ToLowerASCII(guid)));
  39     EXPECT_TRUE(IsValidGUID(ToUpperASCII(guid)));
  40   }
  41 }
  42
  43 TEST(GUIDTest, DeprecatedGUIDBasicUniqueness) {
  44   constexpr int kIterations = 10;
  45   for (int i = 0; i < kIterations; ++i) {
  46     const std::string guid_str1 = GenerateGUID();
  47     const std::string guid_str2 = GenerateGUID();
  48     EXPECT_EQ(36U, guid_str1.length());
  49     EXPECT_EQ(36U, guid_str2.length());
  50     EXPECT_NE(guid_str1, guid_str2);
  51
  52     const GUID guid1 = GUID::ParseCaseInsensitive(guid_str1);
  53     EXPECT_TRUE(guid1.is_valid());
  54     const GUID guid2 = GUID::ParseCaseInsensitive(guid_str2);
  55     EXPECT_TRUE(guid2.is_valid());
  56   }
  57 }
  58
  59 namespace {
  60
  61 // The format of GUID version 4 must be xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx,
  62 // where y is one of [8, 9, a, b].
  63 bool IsValidV4(const GUID& guid) {
  64   const std::string& lowercase = guid.AsLowercaseString();
  65   return guid.is_valid() && lowercase[14] == '4' &&
  66          (lowercase[19] == '8' || lowercase[19] == '9' ||
  67           lowercase[19] == 'a' || lowercase[19] == 'b');
  68 }
  69
  70 }  // namespace
  71
  72 TEST(GUIDTest, GUIDBasicUniqueness) {
  73   constexpr int kIterations = 10;
  74   for (int i = 0; i < kIterations; ++i) {
  75     const GUID guid1 = GUID::GenerateRandomV4();
  76     const GUID guid2 = GUID::GenerateRandomV4();
  77     EXPECT_NE(guid1, guid2);
  78     EXPECT_TRUE(guid1.is_valid());
  79     EXPECT_TRUE(IsValidV4(guid1));
  80     EXPECT_TRUE(guid2.is_valid());
  81     EXPECT_TRUE(IsValidV4(guid2));
  82   }
  83 }
  84
  85 namespace {
  86
  87 void TestGUIDValidity(StringPiece input, bool case_insensitive, bool strict) {
  88   SCOPED_TRACE(input);
  89   {
  90     const GUID guid = GUID::ParseCaseInsensitive(input);
  91     EXPECT_EQ(case_insensitive, guid.is_valid());
  92   }
  93   {
  94     const GUID guid = GUID::ParseLowercase(input);
  95     EXPECT_EQ(strict, guid.is_valid());
  96   }
  97 }
  98
  99 }  // namespace
 100
 101 TEST(GUIDTest, Validity) {
 102   // Empty GUID is invalid.
 103   EXPECT_FALSE(GUID().is_valid());
 104
 105   enum Parsability { kDoesntParse, kParsesCaseInsensitiveOnly, kAlwaysParses };
 106
 107   static constexpr struct {
 108     StringPiece input;
 109     Parsability parsability;
 110   } kGUIDValidity[] = {
 111       {"invalid", kDoesntParse},
 112       {"0123456789ab-cdef-fedc-ba98-76543210", kDoesntParse},
 113       {"0123456789abcdeffedcba9876543210", kDoesntParse},
 114       {"01234567-89Zz-ZzZz-ZzZz-Zz9876543210", kDoesntParse},
 115       {"DEADBEEFDEADBEEFDEADBEEFDEADBEEF", kDoesntParse},
 116       {"deadbeefWdeadXbeefYdeadZbeefdeadbeef", kDoesntParse},
 117       {"XXXdeadbeefWdeadXbeefYdeadZbeefdeadbeefXXX", kDoesntParse},
 118       {"01234567-89aB-cDeF-fEdC-bA9876543210", kParsesCaseInsensitiveOnly},
 119       {"DEADBEEF-DEAD-BEEF-DEAD-BEEFDEADBEEF", kParsesCaseInsensitiveOnly},
 120       {"00000000-0000-0000-0000-000000000000", kAlwaysParses},
 121       {"deadbeef-dead-beef-dead-beefdeadbeef", kAlwaysParses},
 122   };
 123
 124   for (const auto& validity : kGUIDValidity) {
 125     const bool case_insensitive = validity.parsability != kDoesntParse;
 126     const bool strict = validity.parsability == kAlwaysParses;
 127     TestGUIDValidity(validity.input, case_insensitive, strict);
 128   }
 129 }
 130
 131 TEST(GUIDTest, Equality) {
 132   static constexpr uint64_t kBytes[] = {0xDEADBEEFDEADBEEFULL,
 133                                         0xDEADBEEFDEADBEEFULL};
 134   const std::string clientid = RandomDataToGUIDString(kBytes);
 135
 136   static constexpr char kExpectedCanonicalStr[] =
 137       "deadbeef-dead-beef-dead-beefdeadbeef";
 138   ASSERT_EQ(kExpectedCanonicalStr, clientid);
 139
 140   const GUID from_lower = GUID::ParseCaseInsensitive(ToLowerASCII(clientid));
 141   EXPECT_EQ(kExpectedCanonicalStr, from_lower.AsLowercaseString());
 142
 143   const GUID from_upper = GUID::ParseCaseInsensitive(ToUpperASCII(clientid));
 144   EXPECT_EQ(kExpectedCanonicalStr, from_upper.AsLowercaseString());
 145
 146   EXPECT_EQ(from_lower, from_upper);
 147
 148   // Invalid GUIDs are equal.
 149   EXPECT_EQ(GUID(), GUID());
 150 }
 151
 152 TEST(GUIDTest, UnorderedSet) {
 153   std::unordered_set<GUID, GUIDHash> guid_set;
 154
 155   static constexpr char kGUID1[] = "01234567-89ab-cdef-fedc-ba9876543210";
 156   guid_set.insert(GUID::ParseCaseInsensitive(ToLowerASCII(kGUID1)));
 157   EXPECT_EQ(1u, guid_set.size());
 158   guid_set.insert(GUID::ParseCaseInsensitive(ToUpperASCII(kGUID1)));
 159   EXPECT_EQ(1u, guid_set.size());
 160
 161   static constexpr char kGUID2[] = "deadbeef-dead-beef-dead-beefdeadbeef";
 162   guid_set.insert(GUID::ParseCaseInsensitive(ToLowerASCII(kGUID2)));
 163   EXPECT_EQ(2u, guid_set.size());
 164   guid_set.insert(GUID::ParseCaseInsensitive(ToUpperASCII(kGUID2)));
 165   EXPECT_EQ(2u, guid_set.size());
 166 }
 167
 168 TEST(GUIDTest, Set) {
 169   std::set<GUID> guid_set;
 170
 171   static constexpr char kGUID1[] = "01234567-89ab-cdef-0123-456789abcdef";
 172   const GUID guid1 = GUID::ParseLowercase(kGUID1);
 173   ASSERT_TRUE(guid1.is_valid());
 174   guid_set.insert(guid1);
 175
 176   static constexpr char kGUID2[] = "deadbeef-dead-beef-dead-beefdeadbeef";
 177   const GUID guid2 = GUID::ParseLowercase(kGUID2);
 178   ASSERT_TRUE(guid2.is_valid());
 179   guid_set.insert(guid2);
 180
 181   // Test that the order of the GUIDs was preserved.
 182   auto it = guid_set.begin();
 183   EXPECT_EQ(guid1, *it);
 184   ++it;
 185   EXPECT_EQ(guid2, *it);
 186   ++it;
 187   EXPECT_EQ(guid_set.end(), it);
 188 }
 189
 190 TEST(GUIDTest, Compare) {
 191   static constexpr char kGUID[] = "21abd97f-73e8-4b88-9389-a9fee6abda5e";
 192   static constexpr char kGUIDLess[] = "1e0dcaca-9e7c-4f4b-bcc6-e4c02b0c99df";
 193   static constexpr char kGUIDGreater[] = "6eeb1bc8-186b-433c-9d6a-a827bc96b2d4";
 194
 195   const GUID guid = GUID::ParseLowercase(kGUID);
 196   const GUID guid_eq = GUID::ParseLowercase(kGUID);
 197   const GUID guid_lt = GUID::ParseLowercase(kGUIDLess);
 198   const GUID guid_gt = GUID::ParseLowercase(kGUIDGreater);
 199   const GUID guid_invalid = GUID();
 200
 201   EXPECT_TRUE(guid_eq == guid);
 202   EXPECT_FALSE(guid_eq != guid);
 203   EXPECT_FALSE(guid_eq < guid);
 204   EXPECT_TRUE(guid_eq <= guid);
 205   EXPECT_FALSE(guid_eq > guid);
 206   EXPECT_TRUE(guid_eq >= guid);
 207
 208   EXPECT_FALSE(guid_lt == guid);
 209   EXPECT_TRUE(guid_lt != guid);
 210   EXPECT_TRUE(guid_lt < guid);
 211   EXPECT_TRUE(guid_lt <= guid);
 212   EXPECT_FALSE(guid_lt > guid);
 213   EXPECT_FALSE(guid_lt >= guid);
 214
 215   EXPECT_FALSE(guid_gt == guid);
 216   EXPECT_TRUE(guid_gt != guid);
 217   EXPECT_FALSE(guid_gt < guid);
 218   EXPECT_FALSE(guid_gt <= guid);
 219   EXPECT_TRUE(guid_gt > guid);
 220   EXPECT_TRUE(guid_gt >= guid);
 221
 222   // Invalid GUIDs are the "least".
 223   EXPECT_FALSE(guid_invalid == guid);
 224   EXPECT_TRUE(guid_invalid != guid);
 225   EXPECT_TRUE(guid_invalid < guid);
 226   EXPECT_TRUE(guid_invalid <= guid);
 227   EXPECT_FALSE(guid_invalid > guid);
 228   EXPECT_FALSE(guid_invalid >= guid);
 229 }
 230
 231 TEST(GUIDTest, FormatRandomDataAsV4) {
 232   static constexpr uint64_t bytes1a[] = {0x0123456789abcdefull,
 233                                          0x5a5a5a5aa5a5a5a5ull};
 234   static constexpr uint64_t bytes1b[] = {bytes1a[0], bytes1a[1]};
 235   static constexpr uint64_t bytes2[] = {0xfffffffffffffffdull,
 236                                         0xfffffffffffffffeull};
 237   static constexpr uint64_t bytes3[] = {0xfffffffffffffffdull,
 238                                         0xfffffffffffffffcull};
 239
 240   const GUID guid1a =
 241       GUID::FormatRandomDataAsV4ForTesting(as_bytes(make_span(bytes1a)));
 242   const GUID guid1b =
 243       GUID::FormatRandomDataAsV4ForTesting(as_bytes(make_span(bytes1b)));
 244   const GUID guid2 =
 245       GUID::FormatRandomDataAsV4ForTesting(as_bytes(make_span(bytes2)));
 246   const GUID guid3 =
 247       GUID::FormatRandomDataAsV4ForTesting(as_bytes(make_span(bytes3)));
 248
 249   EXPECT_TRUE(guid1a.is_valid());
 250   EXPECT_TRUE(guid1b.is_valid());
 251   EXPECT_TRUE(guid2.is_valid());
 252   EXPECT_TRUE(guid3.is_valid());
 253
 254   // The same input should give the same GUID.
 255   EXPECT_EQ(guid1a, guid1b);
 256
 257   EXPECT_NE(guid1a, guid2);
 258   EXPECT_NE(guid1a, guid3);
 259   EXPECT_NE(guid2, guid3);
 260 }
 261
 262 }  // namespace base