| // Copyright 2012 The Chromium Authors |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include"base/uuid.h" |
| |
| #include<stdint.h> |
| |
| #include<array> |
| #include<limits> |
| #include<set> |
| #include<string_view> |
| #include<unordered_set> |
| |
| #include"base/strings/string_util.h" |
| #include"build/build_config.h" |
| #include"testing/gtest/include/gtest/gtest.h" |
| |
| namespace base{ |
| |
| namespace{ |
| |
| // The format of Uuid version 4 must be xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx, |
| // where y is one of [8, 9, a, b]. |
| boolIsValidV4(constUuid& guid){ |
| const std::string& lowercase= guid.AsLowercaseString(); |
| return guid.is_valid()&& lowercase[14]=='4'&& |
| (lowercase[19]=='8'|| lowercase[19]=='9'|| |
| lowercase[19]=='a'|| lowercase[19]=='b'); |
| } |
| |
| }// namespace |
| |
| TEST(UuidTest,UuidBasicUniqueness){ |
| constexprint kIterations=10; |
| for(int i=0; i< kIterations;++i){ |
| constUuid guid1=Uuid::GenerateRandomV4(); |
| constUuid guid2=Uuid::GenerateRandomV4(); |
| EXPECT_NE(guid1, guid2); |
| EXPECT_TRUE(guid1.is_valid()); |
| EXPECT_TRUE(IsValidV4(guid1)); |
| EXPECT_TRUE(guid2.is_valid()); |
| EXPECT_TRUE(IsValidV4(guid2)); |
| } |
| } |
| |
| namespace{ |
| |
| voidTestUuidValidity(std::string_view input, |
| bool case_insensitive, |
| bool strict){ |
| SCOPED_TRACE(input); |
| { |
| constUuid guid=Uuid::ParseCaseInsensitive(input); |
| EXPECT_EQ(case_insensitive, guid.is_valid()); |
| } |
| { |
| constUuid guid=Uuid::ParseLowercase(input); |
| EXPECT_EQ(strict, guid.is_valid()); |
| } |
| } |
| |
| }// namespace |
| |
| TEST(UuidTest,Validity){ |
| // Empty Uuid is invalid. |
| EXPECT_FALSE(Uuid().is_valid()); |
| |
| enumParsability{ kDoesntParse, kParsesCaseInsensitiveOnly, kAlwaysParses}; |
| |
| staticconstexprstruct{ |
| std::string_view input; |
| Parsability parsability; |
| } kUuidValidity[]={ |
| {"invalid", kDoesntParse}, |
| {"0123456789ab-cdef-fedc-ba98-76543210", kDoesntParse}, |
| {"0123456789abcdeffedcba9876543210", kDoesntParse}, |
| {"01234567-89Zz-ZzZz-ZzZz-Zz9876543210", kDoesntParse}, |
| {"DEADBEEFDEADBEEFDEADBEEFDEADBEEF", kDoesntParse}, |
| {"deadbeefWdeadXbeefYdeadZbeefdeadbeef", kDoesntParse}, |
| {"XXXdeadbeefWdeadXbeefYdeadZbeefdeadbeefXXX", kDoesntParse}, |
| {"01234567-89aB-cDeF-fEdC-bA9876543210", kParsesCaseInsensitiveOnly}, |
| {"DEADBEEF-DEAD-BEEF-DEAD-BEEFDEADBEEF", kParsesCaseInsensitiveOnly}, |
| {"00000000-0000-0000-0000-000000000000", kAlwaysParses}, |
| {"deadbeef-dead-beef-dead-beefdeadbeef", kAlwaysParses}, |
| }; |
| |
| for(constauto& validity: kUuidValidity){ |
| constbool case_insensitive= validity.parsability!= kDoesntParse; |
| constbool strict= validity.parsability== kAlwaysParses; |
| TestUuidValidity(validity.input, case_insensitive, strict); |
| } |
| } |
| |
| TEST(UuidTest,EqualityAndRoundTrip){ |
| staticconstexprchar kCanonicalStr[]= |
| "deadbeef-dead-4eef-bead-beefdeadbeef"; |
| |
| constUuid from_lower= |
| Uuid::ParseCaseInsensitive(ToLowerASCII(kCanonicalStr)); |
| EXPECT_EQ(kCanonicalStr, from_lower.AsLowercaseString()); |
| |
| constUuid from_upper= |
| Uuid::ParseCaseInsensitive(ToUpperASCII(kCanonicalStr)); |
| EXPECT_EQ(kCanonicalStr, from_upper.AsLowercaseString()); |
| |
| EXPECT_EQ(from_lower, from_upper); |
| |
| // Invalid Uuids are equal. |
| EXPECT_EQ(Uuid(),Uuid()); |
| } |
| |
| TEST(UuidTest,UnorderedSet){ |
| std::unordered_set<Uuid,UuidHash> guid_set; |
| |
| staticconstexprchar kUuid1[]="01234567-89ab-cdef-fedc-ba9876543210"; |
| guid_set.insert(Uuid::ParseCaseInsensitive(ToLowerASCII(kUuid1))); |
| EXPECT_EQ(1u, guid_set.size()); |
| guid_set.insert(Uuid::ParseCaseInsensitive(ToUpperASCII(kUuid1))); |
| EXPECT_EQ(1u, guid_set.size()); |
| |
| staticconstexprchar kUuid2[]="deadbeef-dead-beef-dead-beefdeadbeef"; |
| guid_set.insert(Uuid::ParseCaseInsensitive(ToLowerASCII(kUuid2))); |
| EXPECT_EQ(2u, guid_set.size()); |
| guid_set.insert(Uuid::ParseCaseInsensitive(ToUpperASCII(kUuid2))); |
| EXPECT_EQ(2u, guid_set.size()); |
| } |
| |
| TEST(UuidTest,Set){ |
| std::set<Uuid> guid_set; |
| |
| staticconstexprchar kUuid1[]="01234567-89ab-cdef-0123-456789abcdef"; |
| constUuid guid1=Uuid::ParseLowercase(kUuid1); |
| ASSERT_TRUE(guid1.is_valid()); |
| guid_set.insert(guid1); |
| |
| staticconstexprchar kUuid2[]="deadbeef-dead-beef-dead-beefdeadbeef"; |
| constUuid guid2=Uuid::ParseLowercase(kUuid2); |
| ASSERT_TRUE(guid2.is_valid()); |
| guid_set.insert(guid2); |
| |
| // Test that the order of the Uuids was preserved. |
| auto it= guid_set.begin(); |
| EXPECT_EQ(guid1,*it); |
| ++it; |
| EXPECT_EQ(guid2,*it); |
| ++it; |
| EXPECT_EQ(guid_set.end(), it); |
| } |
| |
| TEST(UuidTest,Compare){ |
| staticconstexprchar kUuid[]="21abd97f-73e8-4b88-9389-a9fee6abda5e"; |
| staticconstexprchar kUuidLess[]="1e0dcaca-9e7c-4f4b-bcc6-e4c02b0c99df"; |
| staticconstexprchar kUuidGreater[]="6eeb1bc8-186b-433c-9d6a-a827bc96b2d4"; |
| |
| constUuid guid=Uuid::ParseLowercase(kUuid); |
| constUuid guid_eq=Uuid::ParseLowercase(kUuid); |
| constUuid guid_lt=Uuid::ParseLowercase(kUuidLess); |
| constUuid guid_gt=Uuid::ParseLowercase(kUuidGreater); |
| constUuid guid_invalid=Uuid(); |
| |
| EXPECT_TRUE(guid_eq== guid); |
| EXPECT_FALSE(guid_eq!= guid); |
| EXPECT_FALSE(guid_eq< guid); |
| EXPECT_TRUE(guid_eq<= guid); |
| EXPECT_FALSE(guid_eq> guid); |
| EXPECT_TRUE(guid_eq>= guid); |
| |
| EXPECT_FALSE(guid_lt== guid); |
| EXPECT_TRUE(guid_lt!= guid); |
| EXPECT_TRUE(guid_lt< guid); |
| EXPECT_TRUE(guid_lt<= guid); |
| EXPECT_FALSE(guid_lt> guid); |
| EXPECT_FALSE(guid_lt>= guid); |
| |
| EXPECT_FALSE(guid_gt== guid); |
| EXPECT_TRUE(guid_gt!= guid); |
| EXPECT_FALSE(guid_gt< guid); |
| EXPECT_FALSE(guid_gt<= guid); |
| EXPECT_TRUE(guid_gt> guid); |
| EXPECT_TRUE(guid_gt>= guid); |
| |
| // Invalid Uuids are the "least". |
| EXPECT_FALSE(guid_invalid== guid); |
| EXPECT_TRUE(guid_invalid!= guid); |
| EXPECT_TRUE(guid_invalid< guid); |
| EXPECT_TRUE(guid_invalid<= guid); |
| EXPECT_FALSE(guid_invalid> guid); |
| EXPECT_FALSE(guid_invalid>= guid); |
| } |
| |
| }// namespace base |
