Change stl_util_unittest.cc to use uniform initialization syntax.

base/stl_util_unittest.cc

 // Copyright 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/stl_util.h"
 
 #include <set>
 
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ skipping 17 matching lines @@
   int value_;
 };
 
 }  // namespace
 
 namespace base {
 namespace {
 
 TEST(STLUtilTest, STLIsSorted) {
   {
-    std::set<int> set;
-    set.insert(24);
-    set.insert(1);
-    set.insert(12);
+    std::set<int> set = {24, 1, 12};
     EXPECT_TRUE(STLIsSorted(set));
   }
 
   {
-    std::set<ComparableValue> set;
-    set.insert(ComparableValue(24));
-    set.insert(ComparableValue(1));
-    set.insert(ComparableValue(12));
+    std::set<ComparableValue> set = {ComparableValue(24), ComparableValue(1),
+                                     ComparableValue(12)};
     EXPECT_TRUE(STLIsSorted(set));
   }
 
   {
-    std::vector<int> vector;
-    vector.push_back(1);
-    vector.push_back(1);
-    vector.push_back(4);
-    vector.push_back(64);
-    vector.push_back(12432);
+    std::vector<int> vector = {1, 1, 4, 64, 12432};
     EXPECT_TRUE(STLIsSorted(vector));
     vector.back() = 1;
     EXPECT_FALSE(STLIsSorted(vector));
   }
 }
 
 TEST(STLUtilTest, STLSetDifference) {
-  std::set<int> a1;
-  a1.insert(1);
-  a1.insert(2);
-  a1.insert(3);
-  a1.insert(4);
-
-  std::set<int> a2;
-  a2.insert(3);
-  a2.insert(4);
-  a2.insert(5);
-  a2.insert(6);
-  a2.insert(7);
-
+  std::set<int> a1 = {1, 2, 3, 4};
+  std::set<int> a2 = {3, 4, 5, 6, 7};
   {
-    std::set<int> difference;
-    difference.insert(1);
-    difference.insert(2);
+    std::set<int> difference = {1, 2};
     EXPECT_EQ(difference, STLSetDifference<std::set<int> >(a1, a2));
   }
 
   {
-    std::set<int> difference;
-    difference.insert(5);
-    difference.insert(6);
-    difference.insert(7);
+    std::set<int> difference = {5, 6, 7};
     EXPECT_EQ(difference, STLSetDifference<std::set<int> >(a2, a1));
   }
 
   {
-    std::vector<int> difference;
-    difference.push_back(1);
-    difference.push_back(2);
+    std::vector<int> difference = {1, 2};
     EXPECT_EQ(difference, STLSetDifference<std::vector<int> >(a1, a2));
   }
 
   {
-    std::vector<int> difference;
-    difference.push_back(5);
-    difference.push_back(6);
-    difference.push_back(7);
+    std::vector<int> difference = {5, 6, 7};
     EXPECT_EQ(difference, STLSetDifference<std::vector<int> >(a2, a1));
   }
 }
 
 TEST(STLUtilTest, STLSetUnion) {
-  std::set<int> a1;
-  a1.insert(1);
-  a1.insert(2);
-  a1.insert(3);
-  a1.insert(4);
-
-  std::set<int> a2;
-  a2.insert(3);
-  a2.insert(4);
-  a2.insert(5);
-  a2.insert(6);
-  a2.insert(7);
-
+  std::set<int> a1 = {1, 2, 3, 4};
+  std::set<int> a2 = {3, 4, 5, 6, 7};
   {
-    std::set<int> result;
-    result.insert(1);
-    result.insert(2);
-    result.insert(3);
-    result.insert(4);
-    result.insert(5);
-    result.insert(6);
-    result.insert(7);
+    std::set<int> result = {1, 2, 3, 4, 5, 6, 7};
     EXPECT_EQ(result, STLSetUnion<std::set<int> >(a1, a2));
   }
 
   {
-    std::set<int> result;
-    result.insert(1);
-    result.insert(2);
-    result.insert(3);
-    result.insert(4);
-    result.insert(5);
-    result.insert(6);
-    result.insert(7);
+    std::set<int> result = {1, 2, 3, 4, 5, 6, 7};
     EXPECT_EQ(result, STLSetUnion<std::set<int> >(a2, a1));
   }
 
   {
-    std::vector<int> result;
-    result.push_back(1);
-    result.push_back(2);
-    result.push_back(3);
-    result.push_back(4);
-    result.push_back(5);
-    result.push_back(6);
-    result.push_back(7);
+    std::vector<int> result = {1, 2, 3, 4, 5, 6, 7};
     EXPECT_EQ(result, STLSetUnion<std::vector<int> >(a1, a2));
   }
 
   {
-    std::vector<int> result;
-    result.push_back(1);
-    result.push_back(2);
-    result.push_back(3);
-    result.push_back(4);
-    result.push_back(5);
-    result.push_back(6);
-    result.push_back(7);
+    std::vector<int> result = {1, 2, 3, 4, 5, 6, 7};
     EXPECT_EQ(result, STLSetUnion<std::vector<int> >(a2, a1));
   }
 }
 
 TEST(STLUtilTest, STLSetIntersection) {
-  std::set<int> a1;
-  a1.insert(1);
-  a1.insert(2);
-  a1.insert(3);
-  a1.insert(4);
-
-  std::set<int> a2;
-  a2.insert(3);
-  a2.insert(4);
-  a2.insert(5);
-  a2.insert(6);
-  a2.insert(7);
-
+  std::set<int> a1 = {1, 2, 3, 4};
+  std::set<int> a2 = {3, 4, 5, 6, 7};
   {
-    std::set<int> result;
-    result.insert(3);
-    result.insert(4);
+    std::set<int> result = {3, 4};
     EXPECT_EQ(result, STLSetIntersection<std::set<int> >(a1, a2));
   }
 
   {
-    std::set<int> result;
-    result.insert(3);
-    result.insert(4);
+    std::set<int> result = {3, 4};
     EXPECT_EQ(result, STLSetIntersection<std::set<int> >(a2, a1));
   }
 
   {
-    std::vector<int> result;
-    result.push_back(3);
-    result.push_back(4);
+    std::vector<int> result = {3, 4};
     EXPECT_EQ(result, STLSetIntersection<std::vector<int> >(a1, a2));
   }
 
   {
-    std::vector<int> result;
-    result.push_back(3);
-    result.push_back(4);
+    std::vector<int> result = {3, 4};
     EXPECT_EQ(result, STLSetIntersection<std::vector<int> >(a2, a1));
   }
 }
 
 TEST(STLUtilTest, STLIncludes) {
-  std::set<int> a1;
-  a1.insert(1);
-  a1.insert(2);
-  a1.insert(3);
-  a1.insert(4);
-
-  std::set<int> a2;
-  a2.insert(3);
-  a2.insert(4);
-
-  std::set<int> a3;
-  a3.insert(3);
-  a3.insert(4);
-  a3.insert(5);
+  std::set<int> a1 = {1, 2, 3, 4};
+  std::set<int> a2 = {3, 4};
+  std::set<int> a3 = {3, 4, 5};
 
   EXPECT_TRUE(STLIncludes<std::set<int> >(a1, a2));
   EXPECT_FALSE(STLIncludes<std::set<int> >(a1, a3));
   EXPECT_FALSE(STLIncludes<std::set<int> >(a2, a1));
   EXPECT_FALSE(STLIncludes<std::set<int> >(a2, a3));
   EXPECT_FALSE(STLIncludes<std::set<int> >(a3, a1));
   EXPECT_TRUE(STLIncludes<std::set<int> >(a3, a2));
 }
 
 TEST(StringAsArrayTest, Empty) {
   std::string empty;
   EXPECT_EQ(nullptr, string_as_array(&empty));
 }
 
 TEST(StringAsArrayTest, NullTerminated) {
   // If any std::string implementation is not null-terminated, this should
   // fail. All compilers we use return a null-terminated buffer, but please do
   // not rely on this fact in your code.
-  std::string str("abcde");
+  std::string str = {"abcde"};
   str.resize(3);
   EXPECT_STREQ("abc", string_as_array(&str));
 }
 
 TEST(StringAsArrayTest, WriteCopy) {
   // With a COW implementation, this test will fail if
   // string_as_array(&str) is implemented as
   // const_cast<char*>(str->data()).
-  std::string s1("abc");
-  const std::string s2(s1);
+  std::string s1 = {"abc"};
+  const std::string s2 = {s1};
   string_as_array(&s1)[1] = 'x';
   EXPECT_EQ("axc", s1);
   EXPECT_EQ("abc", s2);
 }
 
 }  // namespace
 }  // namespace base