Make flat containers stable, allow constructing from vector.

base/containers/flat_set_unittest.cc

 // Copyright 2017 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/containers/flat_set.h"
 
 #include <string>
 #include <vector>
 
 #include "base/containers/container_test_utils.h"
@@ skipping 19 matching lines @@
 
     // We do not declare operator< because clang complains that it's unused.
   };
 
   A a;
 }
 
 TEST(FlatSet, RangeConstructor) {
   flat_set<int>::value_type input_vals[] = {1, 1, 1, 2, 2, 2, 3, 3, 3};
 
-  flat_set<int> cont(std::begin(input_vals), std::end(input_vals));
+  flat_set<int> cont(std::begin(input_vals), std::end(input_vals),
+                     base::KEEP_FIRST_OF_DUPES);

[danakj, 2017/04/05 21:33:43]

how come only keep first is tested?

[brettw, 2017/04/07 21:59:04]

Since set is just a typedef for tree, most of the tests are there and I was
trying to avoid duplicating huge amounts of code. This file contains a few cases
to make sure the typedef for unique elements is getting used properly.

   EXPECT_THAT(cont, ElementsAre(1, 2, 3));
 }
 
 TEST(FlatSet, MoveConstructor) {
   int input_range[] = {1, 2, 3, 4};
 
-  flat_set<MoveOnlyInt> original(std::begin(input_range),
-                                 std::end(input_range));
+  flat_set<MoveOnlyInt> original(std::begin(input_range), std::end(input_range),
+                                 base::KEEP_FIRST_OF_DUPES);
   flat_set<MoveOnlyInt> moved(std::move(original));
 
   EXPECT_EQ(1U, moved.count(MoveOnlyInt(1)));
   EXPECT_EQ(1U, moved.count(MoveOnlyInt(2)));
   EXPECT_EQ(1U, moved.count(MoveOnlyInt(3)));
   EXPECT_EQ(1U, moved.count(MoveOnlyInt(4)));
 }
 
 TEST(FlatSet, InitializerListConstructor) {
-  flat_set<int> cont{1, 2, 3, 4, 5, 6, 10, 8};
+  flat_set<int> cont({1, 2, 3, 4, 5, 6, 10, 8}, KEEP_FIRST_OF_DUPES);
   EXPECT_THAT(cont, ElementsAre(1, 2, 3, 4, 5, 6, 8, 10));
 }
 
 TEST(FlatSet, InsertFindSize) {
   base::flat_set<int> s;
   s.insert(1);
   s.insert(1);
   s.insert(2);
 
   EXPECT_EQ(2u, s.size());
@@ skipping 14 matching lines @@
   copy.erase(copy.begin());
   copy.insert(10);
   EXPECT_THAT(copy, ElementsAre(2, 10));
 
   original.swap(copy);
   EXPECT_THAT(original, ElementsAre(2, 10));
   EXPECT_THAT(copy, ElementsAre(1, 2));
 }
 
 }  // namespace base