Migrate WTF::HashMap::get() to ::at()

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 65 matching lines @@
   const double zeroKey = 0;
   const double negativeZeroKey = -zeroKey;
 
   DoubleHashMap map;
 
   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));
+  EXPECT_EQ(1, map.at(clobberKey));
+  EXPECT_EQ(2, map.at(zeroKey));
+  EXPECT_EQ(3, map.at(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.insert(1, WTF::wrapUnique(new DestructCounter(1, &destructNumber)));
   map.insert(2, WTF::wrapUnique(new DestructCounter(2, &destructNumber)));
 
-  DestructCounter* counter1 = map.get(1);
+  DestructCounter* counter1 = map.at(1);
   EXPECT_EQ(1, counter1->get());
-  DestructCounter* counter2 = map.get(2);
+  DestructCounter* counter2 = map.at(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());
   }
   ASSERT_EQ(0, destructNumber);
 
   std::unique_ptr<DestructCounter> ownCounter1 = map.take(1);
@@ skipping 41 matching lines @@
 
 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.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));
+  EXPECT_EQ(1, map.at(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));
   EXPECT_EQ(1, DummyRefCounted::m_refInvokesCount);
 
   ptr.clear();
@@ skipping 11 matching lines @@
 
   typedef HashMap<int, RefPtr<DummyRefCounted>> Map;
   Map map;
 
   RefPtr<DummyRefCounted> ptr = adoptRef(new DummyRefCounted(isDeleted));
   EXPECT_EQ(0, DummyRefCounted::m_refInvokesCount);
 
   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));
+  EXPECT_EQ(ptr, map.at(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.
@@ skipping 21 matching lines @@
 
 TEST(HashMapTest, AddResult) {
   IntSimpleMap map;
   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));
+  EXPECT_EQ(simple1, map.at(1));
 
   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());
+  EXPECT_EQ(1, map.at(1)->v());
 }
 
 TEST(HashMapTest, AddResultVectorValue) {
   using IntVectorMap = HashMap<int, Vector<int>>;
   IntVectorMap map;
   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());
 
@@ skipping 282 matching lines @@
     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);
+  int* onePointer = map.at(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.insert(i, Pointer(new int(i)));
     EXPECT_TRUE(addResult.isNewEntry);
     EXPECT_EQ(i, addResult.storedValue->key);
@@ skipping 78 matching lines @@
   int oneThirty = map.take(Pair(MoveOnly(13), -13));
   EXPECT_EQ(130, oneThirty);
   iter = map.find(Pair(MoveOnly(13), -13));
   EXPECT_TRUE(iter == map.end());
 
   map.clear();
 }
 
 bool isOneTwoThree(const HashMap<int, int>& map) {
   return map.size() == 3 && map.contains(1) && map.contains(2) &&
-         map.contains(3) && map.get(1) == 11 && map.get(2) == 22 &&
-         map.get(3) == 33;
+         map.contains(3) && map.at(1) == 11 && map.at(2) == 22 &&
+         map.at(3) == 33;
 };
 
 HashMap<int, int> returnOneTwoThree() {
   return {{1, 11}, {2, 22}, {3, 33}};
 };
 
 TEST(HashMapTest, InitializerList) {
   HashMap<int, int> empty({});
   EXPECT_TRUE(empty.isEmpty());
 
   HashMap<int, int> one({{1, 11}});
   EXPECT_EQ(one.size(), 1u);
   EXPECT_TRUE(one.contains(1));
-  EXPECT_EQ(one.get(1), 11);
+  EXPECT_EQ(one.at(1), 11);
 
   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);
+  EXPECT_EQ(oneTwoThree.at(1), 11);
+  EXPECT_EQ(oneTwoThree.at(2), 22);
+  EXPECT_EQ(oneTwoThree.at(3), 33);
 
   // Put some jank so we can check if the assignments can clear them later.
   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);
+  EXPECT_EQ(one.at(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);
+  EXPECT_EQ(oneTwoThree.at(1), 11);
+  EXPECT_EQ(oneTwoThree.at(2), 22);
+  EXPECT_EQ(oneTwoThree.at(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