Update Crashpad to 32981a3ee9d7c2769fb27afa038fe2e194cfa329

third_party/crashpad/crashpad/util/misc/uuid_test.cc

 // Copyright 2014 The Crashpad Authors. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
@@ skipping 13 matching lines @@
 #include "base/scoped_generic.h"
 #include "base/strings/stringprintf.h"
 #include "gtest/gtest.h"
 
 namespace crashpad {
 namespace test {
 namespace {
 
 TEST(UUID, UUID) {
   UUID uuid_zero;
+  uuid_zero.InitializeToZero();
   EXPECT_EQ(0u, uuid_zero.data_1);
   EXPECT_EQ(0u, uuid_zero.data_2);
   EXPECT_EQ(0u, uuid_zero.data_3);
   EXPECT_EQ(0u, uuid_zero.data_4[0]);
   EXPECT_EQ(0u, uuid_zero.data_4[1]);
   EXPECT_EQ(0u, uuid_zero.data_5[0]);
   EXPECT_EQ(0u, uuid_zero.data_5[1]);
   EXPECT_EQ(0u, uuid_zero.data_5[2]);
   EXPECT_EQ(0u, uuid_zero.data_5[3]);
   EXPECT_EQ(0u, uuid_zero.data_5[4]);
   EXPECT_EQ(0u, uuid_zero.data_5[5]);
   EXPECT_EQ("00000000-0000-0000-0000-000000000000", uuid_zero.ToString());
 
   const uint8_t kBytes[16] = {0x00,
                               0x01,
                               0x02,
                               0x03,
                               0x04,
                               0x05,
                               0x06,
                               0x07,
                               0x08,
                               0x09,
                               0x0a,
                               0x0b,
                               0x0c,
                               0x0d,
                               0x0e,
                               0x0f};
-  UUID uuid(kBytes);
+  UUID uuid;
+  uuid.InitializeFromBytes(kBytes);
   EXPECT_EQ(0x00010203u, uuid.data_1);
   EXPECT_EQ(0x0405u, uuid.data_2);
   EXPECT_EQ(0x0607u, uuid.data_3);
   EXPECT_EQ(0x08u, uuid.data_4[0]);
   EXPECT_EQ(0x09u, uuid.data_4[1]);
   EXPECT_EQ(0x0au, uuid.data_5[0]);
   EXPECT_EQ(0x0bu, uuid.data_5[1]);
   EXPECT_EQ(0x0cu, uuid.data_5[2]);
   EXPECT_EQ(0x0du, uuid.data_5[3]);
   EXPECT_EQ(0x0eu, uuid.data_5[4]);
   EXPECT_EQ(0x0fu, uuid.data_5[5]);
   EXPECT_EQ("00010203-0405-0607-0809-0a0b0c0d0e0f", uuid.ToString());
 
   // Test both operator== and operator!=.
   EXPECT_FALSE(uuid == uuid_zero);
   EXPECT_NE(uuid, uuid_zero);
 
-  UUID uuid_2(kBytes);
+  UUID uuid_2;
+  uuid_2.InitializeFromBytes(kBytes);
   EXPECT_EQ(uuid, uuid_2);
   EXPECT_FALSE(uuid != uuid_2);
 
   // Make sure that operator== and operator!= check the entire UUID.
   ++uuid.data_1;
   EXPECT_NE(uuid, uuid_2);
   --uuid.data_1;
   ++uuid.data_2;
   EXPECT_NE(uuid, uuid_2);
   --uuid.data_2;
@@ skipping 56 matching lines @@
   EXPECT_EQ(0x45u, uuid.data_4[0]);
   EXPECT_EQ(0x45u, uuid.data_4[1]);
   EXPECT_EQ(0x45u, uuid.data_5[0]);
   EXPECT_EQ(0x45u, uuid.data_5[1]);
   EXPECT_EQ(0x45u, uuid.data_5[2]);
   EXPECT_EQ(0x45u, uuid.data_5[3]);
   EXPECT_EQ(0x45u, uuid.data_5[4]);
   EXPECT_EQ(0x45u, uuid.data_5[5]);
   EXPECT_EQ("45454545-4545-4545-4545-454545454545", uuid.ToString());
 
-  UUID initialized_generated(UUID::InitializeWithNewTag{});
+  UUID initialized_generated;
+  initialized_generated.InitializeWithNew();
   EXPECT_NE(initialized_generated, uuid_zero);
 }
 
 TEST(UUID, FromString) {
   const struct TestCase {
     const char* uuid_string;
     bool success;
   } kCases[] = {
     // Valid:
     {"c6849cb5-fe14-4a79-8978-9ae6034c521d", true},
     {"00000000-0000-0000-0000-000000000000", true},
     {"ffffffff-ffff-ffff-ffff-ffffffffffff", true},
     // Outside HEX range:
     {"7318z10b-c453-4cef-9dc8-015655cb4bbc", false},
     {"7318a10b-c453-4cef-9dz8-015655cb4bbc", false},
     // Incomplete:
     {"15655cb4-", false},
     {"7318f10b-c453-4cef-9dc8-015655cb4bb", false},
     {"318f10b-c453-4cef-9dc8-015655cb4bb2", false},
     {"7318f10b-c453-4ef-9dc8-015655cb4bb2", false},
     {"", false},
     {"abcd", false},
     // Trailing data:
     {"6d247a34-53d5-40ec-a90d-d8dea9e94cc01", false}
   };
 
-  const std::string empty_uuid = UUID().ToString();
+  UUID uuid_zero;
+  uuid_zero.InitializeToZero();
+  const std::string empty_uuid = uuid_zero.ToString();
 
   for (size_t index = 0; index < arraysize(kCases); ++index) {
     const TestCase& test_case = kCases[index];
     SCOPED_TRACE(base::StringPrintf(
         "index %" PRIuS ": %s", index, test_case.uuid_string));
 
     UUID uuid;
+    uuid.InitializeToZero();
     EXPECT_EQ(test_case.success,
               uuid.InitializeFromString(test_case.uuid_string));
     if (test_case.success) {
       EXPECT_EQ(test_case.uuid_string, uuid.ToString());
     } else {
       EXPECT_EQ(empty_uuid, uuid.ToString());
     }
   }
 
   // Test for case insensitivty.
@@ skipping 29 matching lines @@
   ScopedRpcString scoped_system_string(&system_string);
 
   EXPECT_EQ(reinterpret_cast<wchar_t*>(system_string), uuid.ToString16());
 }
 
 #endif  // OS_WIN
 
 }  // namespace
 }  // namespace test
 }  // namespace crashpad