Removing (dest != prev) check from LastUnique algorithm.

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 152 matching lines @@
 
 using TreeWithStrangeCompare = flat_tree<int,
                                          int,
                                          GetKeyFromValueIdentity<int>,
                                          NonDefaultConstructibleCompare>;
 
 using ::testing::ElementsAre;
 
 }  // namespace
 
-TEST(FlatTree, LastUnique) {

[dyaroshev, 2017/04/08 16:48:03]

@brettew - I haven't seen these tests.
I like my tests somewhat better and I incorporated your cases in ints cases. I
can do smth else if you want.

-  using Pair = std::pair<int, int>;
-  using Vect = std::vector<Pair>;
-
-  auto cmp = [](const Pair& lhs, const Pair& rhs) {
-    return lhs.first == rhs.first;
-  };
-
-  // Empty case.
-  Vect empty;
-  EXPECT_EQ(empty.end(), LastUnique(empty.begin(), empty.end(), cmp));
-
-  // Single element.
-  Vect one;
-  one.push_back(Pair(1, 1));
-  EXPECT_EQ(one.end(), LastUnique(one.begin(), one.end(), cmp));
-  ASSERT_EQ(1u, one.size());
-  EXPECT_THAT(one, ElementsAre(Pair(1, 1)));
-
-  // Two elements, already unique.
-  Vect two_u;
-  two_u.push_back(Pair(1, 1));
-  two_u.push_back(Pair(2, 2));
-  EXPECT_EQ(two_u.end(), LastUnique(two_u.begin(), two_u.end(), cmp));
-  EXPECT_THAT(two_u, ElementsAre(Pair(1, 1), Pair(2, 2)));
-
-  // Two elements, dupes.
-  Vect two_d;
-  two_d.push_back(Pair(1, 1));
-  two_d.push_back(Pair(1, 2));
-  auto last = LastUnique(two_d.begin(), two_d.end(), cmp);
-  EXPECT_EQ(two_d.begin() + 1, last);
-  two_d.erase(last, two_d.end());
-  EXPECT_THAT(two_d, ElementsAre(Pair(1, 2)));
-
-  // Non-dupes, dupes, non-dupes.
-  Vect ndn;
-  ndn.push_back(Pair(1, 1));
-  ndn.push_back(Pair(2, 1));
-  ndn.push_back(Pair(2, 2));
-  ndn.push_back(Pair(2, 3));
-  ndn.push_back(Pair(3, 1));
-  last = LastUnique(ndn.begin(), ndn.end(), cmp);
-  EXPECT_EQ(ndn.begin() + 3, last);
-  ndn.erase(last, ndn.end());
-  EXPECT_THAT(ndn, ElementsAre(Pair(1, 1), Pair(2, 3), Pair(3, 1)));
-
-  // Dupes, non-dupes, dupes.
-  Vect dnd;
-  dnd.push_back(Pair(1, 1));
-  dnd.push_back(Pair(1, 2));
-  dnd.push_back(Pair(1, 3));
-  dnd.push_back(Pair(2, 1));
-  dnd.push_back(Pair(3, 1));
-  dnd.push_back(Pair(3, 2));
-  dnd.push_back(Pair(3, 3));
-  last = LastUnique(dnd.begin(), dnd.end(), cmp);
-  EXPECT_EQ(dnd.begin() + 3, last);
-  dnd.erase(last, dnd.end());
-  EXPECT_THAT(dnd, ElementsAre(Pair(1, 3), Pair(2, 1), Pair(3, 3)));
-}
-
 // ----------------------------------------------------------------------------
 // Class.
 
 // Check that flat_tree and its iterators can be instantiated with an
 // incomplete type.
 
 TEST(FlatTree, IncompleteType) {
   struct A {
     using Tree = flat_tree<A, A, GetKeyFromValueIdentity<A>, std::less<A>>;
     int data;
@@ skipping 1131 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