base: Add bulk insert to flat_tree.

base/containers/flat_tree_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_tree.h"
 
 // Following tests are ported and extended tests from libcpp for std::set.
 // They can be found here:
 // https://github.com/llvm-mirror/libcxx/tree/master/test/std/containers/associative/set
 //
@@ skipping 696 matching lines @@
   EXPECT_EQ(3, *result);
 
   result = cont.insert(cont.cend(), 3);
   EXPECT_EQ(std::prev(cont.end()), result);
   EXPECT_EQ(3U, cont.size());
   EXPECT_EQ(3, *result);
 }
 
 // iterator insert(const_iterator position_hint, value_type&& val)
 
+TEST(FlatTree, BulkInsertLValueIntoEmpty) {
+  IntPairTree cont;
+  IntPair inputs[] = {{1, 1}, {4, 1}, {3, 1}, {0, 1}, {2, 1}, {5, 1}};
+  cont.insert(MakeInputIterator(std::begin(inputs)),
+              MakeInputIterator(std::end(inputs)));
+
+  EXPECT_THAT(cont, ElementsAre(IntPair(0, 1), IntPair(1, 1), IntPair(2, 1),
+                                IntPair(3, 1), IntPair(4, 1), IntPair(5, 1)));
+}
+
+TEST(FlatTree, BulkInsertLValueIntoNonEmpty) {
+  IntPair initial_inputs[] = {{1, 0}, {3, 0}, {4, 0}, {6, 0}};
+  IntPairTree cont(MakeInputIterator(std::begin(initial_inputs)),
+                   MakeInputIterator(std::end(initial_inputs)),
+                   KEEP_FIRST_OF_DUPES);
+
+  IntPair new_inputs[] = {{1, 1}, {0, 1}, {4, 1}, {3, 1},
+                          {0, 2}, {2, 1}, {2, 2}, {5, 1}};
+  cont.insert(MakeInputIterator(std::begin(new_inputs)),
+              MakeInputIterator(std::end(new_inputs)));
+
+  EXPECT_THAT(cont, ElementsAre(IntPair(0, 1), IntPair(1, 0), IntPair(2, 1),
+                                IntPair(3, 0), IntPair(4, 0), IntPair(5, 1),
+                                IntPair(6, 0)));
+}
+
+TEST(FlatTree, BulkInsertRValue) {
+  int initial_inputs[] = {1, 3, 4, 6};
+  MoveOnlyTree cont(std::begin(initial_inputs), std::end(initial_inputs),
+                    KEEP_FIRST_OF_DUPES);
+  MoveOnlyInt new_inputs[] = {MoveOnlyInt(0), MoveOnlyInt(1), MoveOnlyInt(5),
+                              MoveOnlyInt(4), MoveOnlyInt(3), MoveOnlyInt(2)};
+  cont.insert(std::make_move_iterator(std::begin(new_inputs)),
+              std::make_move_iterator(std::end(new_inputs)));
+  EXPECT_EQ(1U, cont.count(MoveOnlyInt(0)));
+  EXPECT_EQ(1U, cont.count(MoveOnlyInt(1)));
+  EXPECT_EQ(1U, cont.count(MoveOnlyInt(2)));
+  EXPECT_EQ(1U, cont.count(MoveOnlyInt(3)));
+  EXPECT_EQ(1U, cont.count(MoveOnlyInt(4)));
+  EXPECT_EQ(1U, cont.count(MoveOnlyInt(5)));
+  EXPECT_EQ(1U, cont.count(MoveOnlyInt(6)));
+}
+
 TEST(FlatTree, InsertPositionRValue) {
   MoveOnlyTree cont;
 
   MoveOnlyTree::iterator result = cont.insert(cont.cend(), MoveOnlyInt(2));
   EXPECT_EQ(cont.begin(), result);
   EXPECT_EQ(1U, cont.size());
   EXPECT_EQ(2, result->data());
 
   result = cont.insert(cont.cend(), MoveOnlyInt(1));
   EXPECT_EQ(cont.begin(), result);
@@ skipping 649 matching lines @@
   EraseIf(x, [](int elem) { return !(elem & 1); });
   EXPECT_THAT(x, ElementsAre(1, 3));
 
   x = {1, 2, 3, 4};
   EraseIf(x, [](int elem) { return elem & 1; });
   EXPECT_THAT(x, ElementsAre(2, 4));
 }
 
 }  // namespace internal
 }  // namespace base