Fix unit test style in Source/wtf/.

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
  *    documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
  * THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
+#include "wtf/HashMap.h"
 
-#include "wtf/HashMap.h"
 #include "wtf/OwnPtr.h"
 #include "wtf/PassOwnPtr.h"
 #include "wtf/PassRefPtr.h"
 #include "wtf/RefCounted.h"
 #include "wtf/Vector.h"
 #include <gtest/gtest.h>
 
+namespace WTF {
+
 namespace {
 
-typedef WTF::HashMap<int, int> IntHashMap;
+using IntHashMap = HashMap<int, int>;
 
 TEST(HashMapTest, IteratorComparison)
 {
     IntHashMap map;
     map.add(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);
     EXPECT_FALSE(begin == map.end());
     EXPECT_FALSE(map.end() == begin);
 }
 
 struct TestDoubleHashTraits : HashTraits<double> {
     static const unsigned minimumTableSize = 8;
 };
 
-typedef HashMap<double, int64_t, DefaultHash<double>::Hash, TestDoubleHashTraits> DoubleHashMap;
+using DoubleHashMap = HashMap<double, int64_t, DefaultHash<double>::Hash, TestDoubleHashTraits>;
 
-static int bucketForKey(double key)
+int bucketForKey(double key)
 {
     return DefaultHash<double>::Hash::hash(key) & (TestDoubleHashTraits::minimumTableSize - 1);
 }
 
 TEST(HashMapTest, DoubleHashCollisions)
 {
     // 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;
@@ skipping 20 matching lines @@
     { }
 
     ~DestructCounter() { ++(*m_destructNumber); }
     int get() const { return m_i; }
 
 private:
     int m_i;
     int* m_destructNumber;
 };
 
-typedef WTF::HashMap<int, OwnPtr<DestructCounter>> OwnPtrHashMap;
+using OwnPtrHashMap = HashMap<int, OwnPtr<DestructCounter>>;
 
 TEST(HashMapTest, OwnPtrAsValue)
 {
     int destructNumber = 0;
     OwnPtrHashMap map;
     map.add(1, adoptPtr(new DestructCounter(1, &destructNumber)));
     map.add(2, adoptPtr(new DestructCounter(2, &destructNumber)));
 
     DestructCounter* counter1 = map.get(1);
     EXPECT_EQ(1, counter1->get());
@@ skipping 14 matching lines @@
 
     map.remove(2);
     EXPECT_FALSE(map.contains(2));
     EXPECT_EQ(0UL, map.size());
     EXPECT_EQ(1, destructNumber);
 
     ownCounter1.clear();
     EXPECT_EQ(2, destructNumber);
 }
 
-
-class DummyRefCounted: public WTF::RefCounted<DummyRefCounted> {
+class DummyRefCounted : public RefCounted<DummyRefCounted> {
 public:
     DummyRefCounted(bool& isDeleted) : m_isDeleted(isDeleted) { m_isDeleted = false; }
     ~DummyRefCounted()
     {
         ASSERT(!m_isDeleted);
         m_isDeleted = true;
     }
 
     void ref()
     {
@@ skipping 83 matching lines @@
 }
 
 class SimpleClass {
 public:
     explicit SimpleClass(int v) : m_v(v) { }
     int v() { return m_v; }
 
 private:
     int m_v;
 };
-typedef HashMap<int, OwnPtr<SimpleClass>> IntSimpleMap;
+using IntSimpleMap = HashMap<int, OwnPtr<SimpleClass>>;
 
 TEST(HashMapTest, AddResult)
 {
     IntSimpleMap map;
     IntSimpleMap::AddResult result = map.add(1, nullptr);
     EXPECT_TRUE(result.isNewEntry);
     EXPECT_EQ(1, result.storedValue->key);
     EXPECT_EQ(0, result.storedValue->value.get());
 
     SimpleClass* simple1 = new SimpleClass(1);
@@ skipping 39 matching lines @@
 
 TEST(HashMapTest, ValueTypeDestructed)
 {
     InstanceCounter::counter = 0;
     HashMap<int, InstanceCounter> map;
     map.set(1, InstanceCounter());
     map.clear();
     EXPECT_EQ(0, InstanceCounter::counter);
 }
 
-} // namespace
+} // anonymous namespace
+
+} // namespace WTF