Handle-like interface for HashTable.

runtime/vm/hash_table_test.cc

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include <algorithm>
 #include <cstring>
 #include <map>
 #include <set>
 #include <string>
 #include <utility>
@@ skipping 42 matching lines @@
     num_deleted -= table.IsDeleted(i);
   }
   EXPECT_EQ(0, num_unused);
   EXPECT_EQ(0, num_occupied);
   EXPECT_EQ(0, num_deleted);
 }
 
 
 TEST_CASE(HashTable) {
   typedef HashTable<TestTraits, 2, 1> Table;
-  Table table(Array::Handle(HashTables::New<Table>(5)));
+  Table table(HashTables::New<Table>(5));
   // Ensure that we did get at least 5 entries.
   EXPECT_LE(5, table.NumEntries());
   EXPECT_EQ(0, table.NumOccupied());
   Validate(table);
   EXPECT_EQ(-1, table.FindKey("a"));
 
   // Insertion and lookup.
   intptr_t a_entry = -1;
   EXPECT(!table.FindKeyOrDeletedOrUnused("a", &a_entry));
   EXPECT_NE(-1, a_entry);
@@ skipping 40 matching lines @@
     k = String::New("f");
     table.InsertKey(entry, k);
     EXPECT_EQ(5, table.NumOccupied());
   }
   table.Release();
 }
 
 
 TEST_CASE(EnumIndexHashMap) {
   typedef EnumIndexHashMap<TestTraits> Table;
-  Table table(Array::Handle(HashTables::New<Table>(5)));
+  Table table(HashTables::New<Table>(5));
   table.UpdateOrInsert(String::Handle(String::New("a")),
                        String::Handle(String::New("A")));
   EXPECT(table.ContainsKey("a"));
   table.UpdateValue("a", String::Handle(String::New("AAA")));
   String& a_value = String::Handle();
   a_value ^= table.GetOrNull("a");
   EXPECT(a_value.Equals("AAA"));
   Object& null_value = Object::Handle(table.GetOrNull("0"));
   EXPECT(null_value.IsNull());
 
@@ skipping 86 matching lines @@
     value ^= entries.At(2 * i + 1);
     EXPECT(expected_vec[i].first == ToStdString(key));
     EXPECT_EQ(expected_vec[i].second, value.Value());
   }
 }
 
 
 template<typename Set>
 void TestSet(intptr_t initial_capacity, bool ordered) {
   std::set<std::string> expected;
-  Set actual(Array::Handle(HashTables::New<Set>(initial_capacity)));
+  Set actual(HashTables::New<Set>(initial_capacity));
   // Insert the following strings twice:
   // aaa...aaa (length 26)
   // bbb..bbb
   // ...
   // yy
   // z
   for (int i = 0; i < 2; ++i) {
     for (char ch = 'a'; ch <= 'z'; ++ch) {
       std::string key('z' - ch + 1, ch);
       expected.insert(key);
       bool present = actual.Insert(String::Handle(String::New(key.c_str())));
       EXPECT_EQ((i != 0), present);
       Validate(actual);
       VerifyStringSetsEqual(expected, actual, ordered);
     }
   }
   // TODO(koda): Delete all entries.
   actual.Release();
 }
 
 
 template<typename Map>
 void TestMap(intptr_t initial_capacity, bool ordered) {
   std::map<std::string, int> expected;
-  Map actual(Array::Handle(HashTables::New<Map>(initial_capacity)));
+  Map actual(HashTables::New<Map>(initial_capacity));
   // Insert the following (strings, int) mapping:
   // aaa...aaa -> 26
   // bbb..bbb -> 25
   // ...
   // yy -> 2
   // z -> 1
   for (int i = 0; i < 2; ++i) {
     for (char ch = 'a'; ch <= 'z'; ++ch) {
       int length = 'z' - ch + 1;
       std::string key(length, ch);
@@ skipping 26 matching lines @@
 TEST_CASE(Maps) {
   for (intptr_t initial_capacity = 0;
        initial_capacity < 32;
        ++initial_capacity) {
     TestMap<UnorderedHashMap<TestTraits> >(initial_capacity, false);
     TestMap<EnumIndexHashMap<TestTraits> >(initial_capacity, true);
   }
 }
 
 }  // namespace dart