Migrate WTF::HashMap::add() to ::insert()

third_party/WebKit/Source/wtf/HashMapTest.cpp

 /*
  * Copyright (C) 2011 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 22 matching lines @@
 #include <memory>
 
 namespace WTF {
 
 namespace {
 
 using IntHashMap = HashMap<int, int>;
 
 TEST(HashMapTest, IteratorComparison) {
   IntHashMap map;
-  map.add(1, 2);
+  map.insert(1, 2);
   EXPECT_TRUE(map.begin() != map.end());
   EXPECT_FALSE(map.begin() == map.end());
 
   IntHashMap::const_iterator begin = map.begin();
   EXPECT_TRUE(begin == map.begin());
   EXPECT_TRUE(map.begin() == begin);
   EXPECT_TRUE(begin != map.end());
   EXPECT_TRUE(map.end() != begin);
   EXPECT_FALSE(begin != map.begin());
   EXPECT_FALSE(map.begin() != begin);
@@ skipping 17 matching lines @@
   // The "clobber" key here is one that ends up stealing the bucket that the -0
   // key originally wants to be in. This makes the 0 and -0 keys collide and
   // the test then fails unless the FloatHash::equals() implementation can
   // distinguish them.
   const double clobberKey = 6;
   const double zeroKey = 0;
   const double negativeZeroKey = -zeroKey;
 
   DoubleHashMap map;
 
-  map.add(clobberKey, 1);
-  map.add(zeroKey, 2);
-  map.add(negativeZeroKey, 3);
+  map.insert(clobberKey, 1);
+  map.insert(zeroKey, 2);
+  map.insert(negativeZeroKey, 3);
 
   EXPECT_EQ(bucketForKey(clobberKey), bucketForKey(negativeZeroKey));
   EXPECT_EQ(1, map.get(clobberKey));
   EXPECT_EQ(2, map.get(zeroKey));
   EXPECT_EQ(3, map.get(negativeZeroKey));
 }
 
 class DestructCounter {
  public:
   explicit DestructCounter(int i, int* destructNumber)
       : m_i(i), m_destructNumber(destructNumber) {}
 
   ~DestructCounter() { ++(*m_destructNumber); }
   int get() const { return m_i; }
 
  private:
   int m_i;
   int* m_destructNumber;
 };
 
 using OwnPtrHashMap = HashMap<int, std::unique_ptr<DestructCounter>>;
 
 TEST(HashMapTest, OwnPtrAsValue) {
   int destructNumber = 0;
   OwnPtrHashMap map;
-  map.add(1, WTF::wrapUnique(new DestructCounter(1, &destructNumber)));
-  map.add(2, WTF::wrapUnique(new DestructCounter(2, &destructNumber)));
+  map.insert(1, WTF::wrapUnique(new DestructCounter(1, &destructNumber)));
+  map.insert(2, WTF::wrapUnique(new DestructCounter(2, &destructNumber)));
 
   DestructCounter* counter1 = map.get(1);
   EXPECT_EQ(1, counter1->get());
   DestructCounter* counter2 = map.get(2);
   EXPECT_EQ(2, counter2->get());
   EXPECT_EQ(0, destructNumber);
 
   for (OwnPtrHashMap::iterator iter = map.begin(); iter != map.end(); ++iter) {
     std::unique_ptr<DestructCounter>& ownCounter = iter->value;
     EXPECT_EQ(iter->key, ownCounter->get());
@@ skipping 42 matching lines @@
 };
 
 int DummyRefCounted::m_refInvokesCount = 0;
 
 TEST(HashMapTest, RefPtrAsKey) {
   bool isDeleted = false;
   DummyRefCounted::m_refInvokesCount = 0;
   RefPtr<DummyRefCounted> ptr = adoptRef(new DummyRefCounted(isDeleted));
   EXPECT_EQ(0, DummyRefCounted::m_refInvokesCount);
   HashMap<RefPtr<DummyRefCounted>, int> map;
-  map.add(ptr, 1);
+  map.insert(ptr, 1);
   // Referenced only once (to store a copy in the container).
   EXPECT_EQ(1, DummyRefCounted::m_refInvokesCount);
   EXPECT_EQ(1, map.get(ptr));
 
   DummyRefCounted* rawPtr = ptr.get();
 
   EXPECT_TRUE(map.contains(rawPtr));
   EXPECT_NE(map.end(), map.find(rawPtr));
   EXPECT_TRUE(map.contains(ptr));
   EXPECT_NE(map.end(), map.find(ptr));
@@ skipping 11 matching lines @@
 TEST(HashMaptest, RemoveAdd) {
   DummyRefCounted::m_refInvokesCount = 0;
   bool isDeleted = false;
 
   typedef HashMap<int, RefPtr<DummyRefCounted>> Map;
   Map map;
 
   RefPtr<DummyRefCounted> ptr = adoptRef(new DummyRefCounted(isDeleted));
   EXPECT_EQ(0, DummyRefCounted::m_refInvokesCount);
 
-  map.add(1, ptr);
+  map.insert(1, ptr);
   // Referenced only once (to store a copy in the container).
   EXPECT_EQ(1, DummyRefCounted::m_refInvokesCount);
   EXPECT_EQ(ptr, map.get(1));
 
   ptr.clear();
   EXPECT_FALSE(isDeleted);
 
   map.erase(1);
   EXPECT_EQ(1, DummyRefCounted::m_refInvokesCount);
   EXPECT_TRUE(isDeleted);
   EXPECT_TRUE(map.isEmpty());
 
   // Add and remove until the deleted slot is reused.
   for (int i = 1; i < 100; i++) {
     bool isDeleted2 = false;
     RefPtr<DummyRefCounted> ptr2 = adoptRef(new DummyRefCounted(isDeleted2));
-    map.add(i, ptr2);
+    map.insert(i, ptr2);
     EXPECT_FALSE(isDeleted2);
     ptr2.clear();
     EXPECT_FALSE(isDeleted2);
     map.erase(i);
     EXPECT_TRUE(isDeleted2);
   }
 }
 
 class SimpleClass {
  public:
   explicit SimpleClass(int v) : m_v(v) {}
   int v() { return m_v; }
 
  private:
   int m_v;
 };
 using IntSimpleMap = HashMap<int, std::unique_ptr<SimpleClass>>;
 
 TEST(HashMapTest, AddResult) {
   IntSimpleMap map;
-  IntSimpleMap::AddResult result = map.add(1, nullptr);
+  IntSimpleMap::AddResult result = map.insert(1, nullptr);
   EXPECT_TRUE(result.isNewEntry);
   EXPECT_EQ(1, result.storedValue->key);
   EXPECT_EQ(0, result.storedValue->value.get());
 
   SimpleClass* simple1 = new SimpleClass(1);
   result.storedValue->value = WTF::wrapUnique(simple1);
   EXPECT_EQ(simple1, map.get(1));
 
-  IntSimpleMap::AddResult result2 = map.add(1, WTF::makeUnique<SimpleClass>(2));
+  IntSimpleMap::AddResult result2 =
+      map.insert(1, WTF::makeUnique<SimpleClass>(2));
   EXPECT_FALSE(result2.isNewEntry);
   EXPECT_EQ(1, result.storedValue->key);
   EXPECT_EQ(1, result.storedValue->value->v());
   EXPECT_EQ(1, map.get(1)->v());
 }
 
 TEST(HashMapTest, AddResultVectorValue) {
   using IntVectorMap = HashMap<int, Vector<int>>;
   IntVectorMap map;
-  IntVectorMap::AddResult result = map.add(1, Vector<int>());
+  IntVectorMap::AddResult result = map.insert(1, Vector<int>());
   EXPECT_TRUE(result.isNewEntry);
   EXPECT_EQ(1, result.storedValue->key);
   EXPECT_EQ(0u, result.storedValue->value.size());
 
   result.storedValue->value.push_back(11);
   EXPECT_EQ(1u, map.find(1)->value.size());
   EXPECT_EQ(11, map.find(1)->value.front());
 
-  IntVectorMap::AddResult result2 = map.add(1, Vector<int>());
+  IntVectorMap::AddResult result2 = map.insert(1, Vector<int>());
   EXPECT_FALSE(result2.isNewEntry);
   EXPECT_EQ(1, result.storedValue->key);
   EXPECT_EQ(1u, result.storedValue->value.size());
   EXPECT_EQ(11, result.storedValue->value.front());
   EXPECT_EQ(11, map.find(1)->value.front());
 }
 
 class InstanceCounter {
  public:
   InstanceCounter() { ++counter; }
@@ skipping 72 matching lines @@
 struct DefaultHash<MoveOnly> {
   using Hash = MoveOnlyHash;
 };
 
 namespace {
 
 TEST(HashMapTest, MoveOnlyValueType) {
   using TheMap = HashMap<int, MoveOnly>;
   TheMap map;
   {
-    TheMap::AddResult addResult = map.add(1, MoveOnly(10));
+    TheMap::AddResult addResult = map.insert(1, MoveOnly(10));
     EXPECT_TRUE(addResult.isNewEntry);
     EXPECT_EQ(1, addResult.storedValue->key);
     EXPECT_EQ(10, addResult.storedValue->value.value());
   }
   auto iter = map.find(1);
   ASSERT_TRUE(iter != map.end());
   EXPECT_EQ(1, iter->key);
   EXPECT_EQ(10, iter->value.value());
 
   iter = map.find(2);
   EXPECT_TRUE(iter == map.end());
 
   // Try to add more to trigger rehashing.
   for (int i = 2; i < 32; ++i) {
-    TheMap::AddResult addResult = map.add(i, MoveOnly(i * 10));
+    TheMap::AddResult addResult = map.insert(i, MoveOnly(i * 10));
     EXPECT_TRUE(addResult.isNewEntry);
     EXPECT_EQ(i, addResult.storedValue->key);
     EXPECT_EQ(i * 10, addResult.storedValue->value.value());
   }
 
   iter = map.find(1);
   ASSERT_TRUE(iter != map.end());
   EXPECT_EQ(1, iter->key);
   EXPECT_EQ(10, iter->value.value());
 
@@ skipping 20 matching lines @@
 
   map.clear();
 }
 
 TEST(HashMapTest, MoveOnlyKeyType) {
   // The content of this test is similar to the test above, except that the
   // types of key and value are swapped.
   using TheMap = HashMap<MoveOnly, int>;
   TheMap map;
   {
-    TheMap::AddResult addResult = map.add(MoveOnly(1), 10);
+    TheMap::AddResult addResult = map.insert(MoveOnly(1), 10);
     EXPECT_TRUE(addResult.isNewEntry);
     EXPECT_EQ(1, addResult.storedValue->key.value());
     EXPECT_EQ(10, addResult.storedValue->value);
   }
   auto iter = map.find(MoveOnly(1));
   ASSERT_TRUE(iter != map.end());
   EXPECT_EQ(1, iter->key.value());
   EXPECT_EQ(10, iter->value);
 
   iter = map.find(MoveOnly(2));
   EXPECT_TRUE(iter == map.end());
 
   for (int i = 2; i < 32; ++i) {
-    TheMap::AddResult addResult = map.add(MoveOnly(i), i * 10);
+    TheMap::AddResult addResult = map.insert(MoveOnly(i), i * 10);
     EXPECT_TRUE(addResult.isNewEntry);
     EXPECT_EQ(i, addResult.storedValue->key.value());
     EXPECT_EQ(i * 10, addResult.storedValue->value);
   }
 
   iter = map.find(MoveOnly(1));
   ASSERT_TRUE(iter != map.end());
   EXPECT_EQ(1, iter->key.value());
   EXPECT_EQ(10, iter->value);
 
@@ skipping 36 matching lines @@
     return *this;
   }
 
  private:
   int* m_counter;
 };
 
 TEST(HashMapTest, MoveShouldNotMakeCopy) {
   HashMap<int, CountCopy> map;
   int counter = 0;
-  map.add(1, CountCopy(counter));
+  map.insert(1, CountCopy(counter));
 
   HashMap<int, CountCopy> other(map);
   counter = 0;
   map = std::move(other);
   EXPECT_EQ(0, counter);
 
   counter = 0;
   HashMap<int, CountCopy> yetAnother(std::move(map));
   EXPECT_EQ(0, counter);
 }
 
 TEST(HashMapTest, UniquePtrAsKey) {
   using Pointer = std::unique_ptr<int>;
   using Map = HashMap<Pointer, int>;
   Map map;
   int* onePointer = new int(1);
   {
-    Map::AddResult addResult = map.add(Pointer(onePointer), 1);
+    Map::AddResult addResult = map.insert(Pointer(onePointer), 1);
     EXPECT_TRUE(addResult.isNewEntry);
     EXPECT_EQ(onePointer, addResult.storedValue->key.get());
     EXPECT_EQ(1, *addResult.storedValue->key);
     EXPECT_EQ(1, addResult.storedValue->value);
   }
   auto iter = map.find(onePointer);
   ASSERT_TRUE(iter != map.end());
   EXPECT_EQ(onePointer, iter->key.get());
   EXPECT_EQ(1, iter->value);
 
   Pointer nonexistent(new int(42));
   iter = map.find(nonexistent.get());
   EXPECT_TRUE(iter == map.end());
 
   // Insert more to cause a rehash.
   for (int i = 2; i < 32; ++i) {
-    Map::AddResult addResult = map.add(Pointer(new int(i)), i);
+    Map::AddResult addResult = map.insert(Pointer(new int(i)), i);
     EXPECT_TRUE(addResult.isNewEntry);
     EXPECT_EQ(i, *addResult.storedValue->key);
     EXPECT_EQ(i, addResult.storedValue->value);
   }
 
   iter = map.find(onePointer);
   ASSERT_TRUE(iter != map.end());
   EXPECT_EQ(onePointer, iter->key.get());
   EXPECT_EQ(1, iter->value);
 
   EXPECT_EQ(1, map.take(onePointer));
   // From now on, |onePointer| is a dangling pointer.
 
   iter = map.find(onePointer);
   EXPECT_TRUE(iter == map.end());
 }
 
 TEST(HashMapTest, UniquePtrAsValue) {
   using Pointer = std::unique_ptr<int>;
   using Map = HashMap<int, Pointer>;
   Map map;
   {
-    Map::AddResult addResult = map.add(1, Pointer(new int(1)));
+    Map::AddResult addResult = map.insert(1, Pointer(new int(1)));
     EXPECT_TRUE(addResult.isNewEntry);
     EXPECT_EQ(1, addResult.storedValue->key);
     EXPECT_EQ(1, *addResult.storedValue->value);
   }
   auto iter = map.find(1);
   ASSERT_TRUE(iter != map.end());
   EXPECT_EQ(1, iter->key);
   EXPECT_EQ(1, *iter->value);
 
   int* onePointer = map.get(1);
   EXPECT_TRUE(onePointer);
   EXPECT_EQ(1, *onePointer);
 
   iter = map.find(42);
   EXPECT_TRUE(iter == map.end());
 
   for (int i = 2; i < 32; ++i) {
-    Map::AddResult addResult = map.add(i, Pointer(new int(i)));
+    Map::AddResult addResult = map.insert(i, Pointer(new int(i)));
     EXPECT_TRUE(addResult.isNewEntry);
     EXPECT_EQ(i, addResult.storedValue->key);
     EXPECT_EQ(i, *addResult.storedValue->value);
   }
 
   iter = map.find(1);
   ASSERT_TRUE(iter != map.end());
   EXPECT_EQ(1, iter->key);
   EXPECT_EQ(1, *iter->value);
 
   Pointer one(map.take(1));
   ASSERT_TRUE(one);
   EXPECT_EQ(1, *one);
 
   Pointer empty(map.take(42));
   EXPECT_TRUE(!empty);
 
   iter = map.find(1);
   EXPECT_TRUE(iter == map.end());
 
   {
-    Map::AddResult addResult = map.add(1, std::move(one));
+    Map::AddResult addResult = map.insert(1, std::move(one));
     EXPECT_TRUE(addResult.isNewEntry);
     EXPECT_EQ(1, addResult.storedValue->key);
     EXPECT_EQ(1, *addResult.storedValue->value);
   }
 }
 
 TEST(HashMapTest, MoveOnlyPairKeyType) {
   using Pair = std::pair<MoveOnly, int>;
   using TheMap = HashMap<Pair, int>;
   TheMap map;
   {
-    TheMap::AddResult addResult = map.add(Pair(MoveOnly(1), -1), 10);
+    TheMap::AddResult addResult = map.insert(Pair(MoveOnly(1), -1), 10);
     EXPECT_TRUE(addResult.isNewEntry);
     EXPECT_EQ(1, addResult.storedValue->key.first.value());
     EXPECT_EQ(-1, addResult.storedValue->key.second);
     EXPECT_EQ(10, addResult.storedValue->value);
   }
   auto iter = map.find(Pair(MoveOnly(1), -1));
   ASSERT_TRUE(iter != map.end());
   EXPECT_EQ(1, iter->key.first.value());
   EXPECT_EQ(-1, iter->key.second);
   EXPECT_EQ(10, iter->value);
 
   iter = map.find(Pair(MoveOnly(1), 0));
   EXPECT_TRUE(iter == map.end());
 
   for (int i = 2; i < 32; ++i) {
-    TheMap::AddResult addResult = map.add(Pair(MoveOnly(i), -i), i * 10);
+    TheMap::AddResult addResult = map.insert(Pair(MoveOnly(i), -i), i * 10);
     EXPECT_TRUE(addResult.isNewEntry);
     EXPECT_EQ(i, addResult.storedValue->key.first.value());
     EXPECT_EQ(-i, addResult.storedValue->key.second);
     EXPECT_EQ(i * 10, addResult.storedValue->value);
   }
 
   iter = map.find(Pair(MoveOnly(1), -1));
   ASSERT_TRUE(iter != map.end());
   EXPECT_EQ(1, iter->key.first.value());
   EXPECT_EQ(-1, iter->key.second);
@@ skipping 47 matching lines @@
   HashMap<int, int> oneTwoThree({{1, 11}, {2, 22}, {3, 33}});
   EXPECT_EQ(oneTwoThree.size(), 3u);
   EXPECT_TRUE(oneTwoThree.contains(1));
   EXPECT_TRUE(oneTwoThree.contains(2));
   EXPECT_TRUE(oneTwoThree.contains(3));
   EXPECT_EQ(oneTwoThree.get(1), 11);
   EXPECT_EQ(oneTwoThree.get(2), 22);
   EXPECT_EQ(oneTwoThree.get(3), 33);
 
   // Put some jank so we can check if the assignments can clear them later.
-  empty.add(9999, 99999);
-  one.add(9999, 99999);
-  oneTwoThree.add(9999, 99999);
+  empty.insert(9999, 99999);
+  one.insert(9999, 99999);
+  oneTwoThree.insert(9999, 99999);
 
   empty = {};
   EXPECT_TRUE(empty.isEmpty());
 
   one = {{1, 11}};
   EXPECT_EQ(one.size(), 1u);
   EXPECT_TRUE(one.contains(1));
   EXPECT_EQ(one.get(1), 11);
 
   oneTwoThree = {{1, 11}, {2, 22}, {3, 33}};
   EXPECT_EQ(oneTwoThree.size(), 3u);
   EXPECT_TRUE(oneTwoThree.contains(1));
   EXPECT_TRUE(oneTwoThree.contains(2));
   EXPECT_TRUE(oneTwoThree.contains(3));
   EXPECT_EQ(oneTwoThree.get(1), 11);
   EXPECT_EQ(oneTwoThree.get(2), 22);
   EXPECT_EQ(oneTwoThree.get(3), 33);
 
   // Other ways of construction: as a function parameter and in a return
   // statement.
   EXPECT_TRUE(isOneTwoThree({{1, 11}, {2, 22}, {3, 33}}));
   EXPECT_TRUE(isOneTwoThree(returnOneTwoThree()));
 }
 
 }  // anonymous namespace
 
 }  // namespace WTF