clang-format runtime/vm

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>
 #include <vector>
 
 #include "platform/assert.h"
 #include "vm/unit_test.h"
 #include "vm/hash_table.h"
 
 namespace dart {
 
 // Various ways to look up strings. Uses length as the hash code to make it
 // easy to engineer collisions.
 class TestTraits {
  public:
   static const char* Name() { return "TestTraits"; }
   static bool ReportStats() { return false; }
 
   static bool IsMatch(const char* key, const Object& obj) {
     return String::Cast(obj).Equals(key);
   }
-  static uword Hash(const char* key) {
-    return static_cast<uword>(strlen(key));
-  }
+  static uword Hash(const char* key) { return static_cast<uword>(strlen(key)); }
   static bool IsMatch(const Object& a, const Object& b) {
     return a.IsString() && b.IsString() &&
-        String::Cast(a).Equals(String::Cast(b));
+           String::Cast(a).Equals(String::Cast(b));
   }
-  static uword Hash(const Object& obj) {
-    return String::Cast(obj).Length();
-  }
-  static RawObject* NewKey(const char* key) {
-    return String::New(key);
-  }
+  static uword Hash(const Object& obj) { return String::Cast(obj).Length(); }
+  static RawObject* NewKey(const char* key) { return String::New(key); }
 };
 
 
-template<typename Table>
+template <typename Table>
 void Validate(const Table& table) {
   // Verify consistency of entry state tracking.
   intptr_t num_entries = table.NumEntries();
   intptr_t num_unused = table.NumUnused();
   intptr_t num_occupied = table.NumOccupied();
   intptr_t num_deleted = table.NumDeleted();
   for (intptr_t i = 0; i < num_entries; ++i) {
     EXPECT_EQ(1, table.IsUnused(i) + table.IsOccupied(i) + table.IsDeleted(i));
     num_unused -= table.IsUnused(i);
     num_occupied -= table.IsOccupied(i);
@@ skipping 72 matching lines @@
   for (intptr_t i = 0; i < str.Length(); ++i) {
     result += static_cast<char>(str.CharAt(i));
   }
   return result;
 }
 
 
 // Checks that 'expected' and 'actual' are equal sets. If 'ordered' is true,
 // it also verifies that their iteration orders match, i.e., that actual's
 // insertion order coincides with lexicographic order.
-template<typename Set>
+template <typename Set>
 void VerifyStringSetsEqual(const std::set<std::string>& expected,
                            const Set& actual,
                            bool ordered) {
   // Get actual keys in iteration order.
   Array& keys = Array::Handle(HashTables::ToArray(actual, true));
   // Cardinality must match.
   EXPECT_EQ(static_cast<intptr_t>(expected.size()), keys.Length());
   std::vector<std::string> expected_vec(expected.begin(), expected.end());
   // Check containment.
   for (uintptr_t i = 0; i < expected_vec.size(); ++i) {
     EXPECT(actual.ContainsKey(expected_vec[i].c_str()));
   }
   // Equality, including order, if requested.
   std::vector<std::string> actual_vec;
   String& key = String::Handle();
   for (int i = 0; i < keys.Length(); ++i) {
     key ^= keys.At(i);
     actual_vec.push_back(ToStdString(key));
   }
   if (!ordered) {
     std::sort(actual_vec.begin(), actual_vec.end());
   }
-  EXPECT(std::equal(actual_vec.begin(), actual_vec.end(),
-                    expected_vec.begin()));
+  EXPECT(
+      std::equal(actual_vec.begin(), actual_vec.end(), expected_vec.begin()));
 }
 
 
 // Checks that 'expected' and 'actual' are equal maps. If 'ordered' is true,
 // it also verifies that their iteration orders match, i.e., that actual's
 // insertion order coincides with lexicographic order.
-template<typename Map>
+template <typename Map>
 void VerifyStringMapsEqual(const std::map<std::string, int>& expected,
                            const Map& actual,
                            bool ordered) {
   intptr_t expected_size = expected.size();
   // Get actual concatenated (key, value) pairs in iteration order.
   Array& entries = Array::Handle(HashTables::ToArray(actual, true));
   // Cardinality must match.
   EXPECT_EQ(expected_size * 2, entries.Length());
   std::vector<std::pair<std::string, int> > expected_vec(expected.begin(),
                                                          expected.end());
@@ skipping 13 matching lines @@
   String& key = String::Handle();
   for (int i = 0; i < expected_size; ++i) {
     key ^= entries.At(2 * i);
     value ^= entries.At(2 * i + 1);
     EXPECT(expected_vec[i].first == ToStdString(key));
     EXPECT_EQ(expected_vec[i].second, value.Value());
   }
 }
 
 
-template<typename Set>
+template <typename Set>
 void TestSet(intptr_t initial_capacity, bool ordered) {
   std::set<std::string> expected;
   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);
     }
   }
   actual.Clear();
   EXPECT_EQ(0, actual.NumOccupied());
   actual.Release();
 }
 
 
-template<typename Map>
+template <typename Map>
 void TestMap(intptr_t initial_capacity, bool ordered) {
   std::map<std::string, int> expected;
   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) {
@@ skipping 11 matching lines @@
       VerifyStringMapsEqual(expected, actual, ordered);
     }
   }
   actual.Clear();
   EXPECT_EQ(0, actual.NumOccupied());
   actual.Release();
 }
 
 
 TEST_CASE(Sets) {
-  for (intptr_t initial_capacity = 0;
-       initial_capacity < 32;
+  for (intptr_t initial_capacity = 0; initial_capacity < 32;
        ++initial_capacity) {
     TestSet<UnorderedHashSet<TestTraits> >(initial_capacity, false);
   }
 }
 
 
 TEST_CASE(Maps) {
-  for (intptr_t initial_capacity = 0;
-       initial_capacity < 32;
+  for (intptr_t initial_capacity = 0; initial_capacity < 32;
        ++initial_capacity) {
     TestMap<UnorderedHashMap<TestTraits> >(initial_capacity, false);
   }
 }
 
 }  // namespace dart