Fix template angle bracket syntax

Source/wtf/ListHashSetTest.cpp

 /*
  * Copyright (C) 2012 Apple 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 47 matching lines @@
 
     list.removeFirst();
     EXPECT_EQ(2, list.first());
 
     list.removeFirst();
     EXPECT_TRUE(list.isEmpty());
 }
 
 TEST(ListHashSetTest, RemoveFirst)
 {
-    removeFirstHelper<ListHashSet<int> >();
-    removeFirstHelper<ListHashSet<int, 1> >();
+    removeFirstHelper<ListHashSet<int>>();
+    removeFirstHelper<ListHashSet<int, 1>>();
 }
 
 TEST(LinkedHashSetTest, RemoveFirst)
 {
-    removeFirstHelper<LinkedHashSet<int> >();
+    removeFirstHelper<LinkedHashSet<int>>();
 }
 
 template<typename Set>
 void appendOrMoveToLastNewItems()
 {
     Set list;
     typename Set::AddResult result = list.appendOrMoveToLast(1);
     EXPECT_TRUE(result.isNewEntry);
     result = list.add(2);
     EXPECT_TRUE(result.isNewEntry);
     result = list.appendOrMoveToLast(3);
     EXPECT_TRUE(result.isNewEntry);
 
     EXPECT_EQ(list.size(), 3UL);
 
     // The list should be in order 1, 2, 3.
     typename Set::iterator iterator = list.begin();
     EXPECT_EQ(1, *iterator);
     ++iterator;
     EXPECT_EQ(2, *iterator);
     ++iterator;
     EXPECT_EQ(3, *iterator);
     ++iterator;
 }
 
 TEST(ListHashSetTest, AppendOrMoveToLastNewItems)
 {
-    appendOrMoveToLastNewItems<ListHashSet<int> >();
-    appendOrMoveToLastNewItems<ListHashSet<int, 1> >();
+    appendOrMoveToLastNewItems<ListHashSet<int>>();
+    appendOrMoveToLastNewItems<ListHashSet<int, 1>>();
 }
 
 TEST(LinkedHashSetTest, AppendOrMoveToLastNewItems)
 {
-    appendOrMoveToLastNewItems<LinkedHashSet<int> >();
+    appendOrMoveToLastNewItems<LinkedHashSet<int>>();
 }
 
 template<typename Set>
 void appendOrMoveToLastWithDuplicates()
 {
     Set list;
 
     // Add a single element twice.
     typename Set::AddResult result = list.add(1);
     EXPECT_TRUE(result.isNewEntry);
@@ skipping 24 matching lines @@
     EXPECT_EQ(3, *iterator);
     ++iterator;
     EXPECT_EQ(2, *iterator);
     ++iterator;
     EXPECT_EQ(1, *iterator);
     ++iterator;
 }
 
 TEST(ListHashSetTest, AppendOrMoveToLastWithDuplicates)
 {
-    appendOrMoveToLastWithDuplicates<ListHashSet<int> >();
-    appendOrMoveToLastWithDuplicates<ListHashSet<int, 1> >();
+    appendOrMoveToLastWithDuplicates<ListHashSet<int>>();
+    appendOrMoveToLastWithDuplicates<ListHashSet<int, 1>>();
 }
 
 TEST(LinkedHashSetTest, AppendOrMoveToLastWithDuplicates)
 {
-    appendOrMoveToLastWithDuplicates<LinkedHashSet<int> >();
+    appendOrMoveToLastWithDuplicates<LinkedHashSet<int>>();
 }
 
 template<typename Set>
 void prependOrMoveToFirstNewItems()
 {
     Set list;
     typename Set::AddResult result = list.prependOrMoveToFirst(1);
     EXPECT_TRUE(result.isNewEntry);
     result = list.add(2);
     EXPECT_TRUE(result.isNewEntry);
     result = list.prependOrMoveToFirst(3);
     EXPECT_TRUE(result.isNewEntry);
 
     EXPECT_EQ(list.size(), 3UL);
 
     // The list should be in order 3, 1, 2.
     typename Set::iterator iterator = list.begin();
     EXPECT_EQ(3, *iterator);
     ++iterator;
     EXPECT_EQ(1, *iterator);
     ++iterator;
     EXPECT_EQ(2, *iterator);
     ++iterator;
 }
 
 TEST(ListHashSetTest, PrependOrMoveToFirstNewItems)
 {
-    prependOrMoveToFirstNewItems<ListHashSet<int> >();
-    prependOrMoveToFirstNewItems<ListHashSet<int, 1> >();
+    prependOrMoveToFirstNewItems<ListHashSet<int>>();
+    prependOrMoveToFirstNewItems<ListHashSet<int, 1>>();
 }
 
 TEST(LinkedHashSetTest, PrependOrMoveToFirstNewItems)
 {
-    prependOrMoveToFirstNewItems<LinkedHashSet<int> >();
+    prependOrMoveToFirstNewItems<LinkedHashSet<int>>();
 }
 
 template<typename Set>
 void prependOrMoveToLastWithDuplicates()
 {
     Set list;
 
     // Add a single element twice.
     typename Set::AddResult result = list.add(1);
     EXPECT_TRUE(result.isNewEntry);
@@ skipping 24 matching lines @@
     EXPECT_EQ(3, *iterator);
     ++iterator;
     EXPECT_EQ(2, *iterator);
     ++iterator;
     EXPECT_EQ(1, *iterator);
     ++iterator;
 }
 
 TEST(ListHashSetTest, PrependOrMoveToLastWithDuplicates)
 {
-    prependOrMoveToLastWithDuplicates<ListHashSet<int> >();
-    prependOrMoveToLastWithDuplicates<ListHashSet<int, 1> >();
+    prependOrMoveToLastWithDuplicates<ListHashSet<int>>();
+    prependOrMoveToLastWithDuplicates<ListHashSet<int, 1>>();
 }
 
 TEST(LinkedHashSetTest, PrependOrMoveToLastWithDuplicates)
 {
-    prependOrMoveToLastWithDuplicates<LinkedHashSet<int> >();
+    prependOrMoveToLastWithDuplicates<LinkedHashSet<int>>();
 }
 
 class DummyRefCounted: public WTF::RefCounted<DummyRefCounted> {
 public:
     DummyRefCounted(bool& isDeleted) : m_isDeleted(isDeleted) { m_isDeleted = false; }
     ~DummyRefCounted() { m_isDeleted = true; }
     void ref()
     {
         WTF::RefCounted<DummyRefCounted>::ref();
         ++m_refInvokesCount;
@@ skipping 33 matching lines @@
     EXPECT_EQ(1, DummyRefCounted::m_refInvokesCount);
 
     set.remove(rawPtr);
     EXPECT_TRUE(isDeleted);
 
     EXPECT_EQ(1, DummyRefCounted::m_refInvokesCount);
 }
 
 TEST(ListHashSetTest, WithRefPtr)
 {
-    withRefPtr<ListHashSet<RefPtr<DummyRefCounted> > >();
-    withRefPtr<ListHashSet<RefPtr<DummyRefCounted>, 1> >();
+    withRefPtr<ListHashSet<RefPtr<DummyRefCounted>>>();
+    withRefPtr<ListHashSet<RefPtr<DummyRefCounted>, 1>>();
 }
 
 TEST(LinkedHashSetTest, WithRefPtr)
 {
-    withRefPtr<LinkedHashSet<RefPtr<DummyRefCounted> > >();
+    withRefPtr<LinkedHashSet<RefPtr<DummyRefCounted>>>();
 }
 
 template<typename Set, typename SetRef, typename Iterator>
 void findHelper()
 {
     Set set;
     set.add(-1);
     set.add(0);
     set.add(1);
     set.add(2);
@@ skipping 64 matching lines @@
     EXPECT_EQ(103, set.first());
     if (!canModifyWhileIterating)
         it = set.find(1);
     ++it;
     EXPECT_EQ(42, *it);
     EXPECT_EQ(7u, set.size());
 }
 
 TEST(ListHashSetTest, InsertBefore)
 {
-    insertBeforeHelper<ListHashSet<int> >(true);
-    insertBeforeHelper<ListHashSet<int, 1> >(true);
+    insertBeforeHelper<ListHashSet<int>>(true);
+    insertBeforeHelper<ListHashSet<int, 1>>(true);
 }
 
 TEST(LinkedHashSetTest, InsertBefore)
 {
-    insertBeforeHelper<LinkedHashSet<int> >(false);
+    insertBeforeHelper<LinkedHashSet<int>>(false);
 }
 
 template<typename Set>
 void addReturnIterator(bool canModifyWhileIterating)
 {
     Set set;
     set.add(-1);
     set.add(0);
     set.add(1);
     set.add(2);
@@ skipping 31 matching lines @@
     EXPECT_EQ(6u, set.size());
     it = set.addReturnIterator(5);
     EXPECT_EQ(7u, set.size());
     set.remove(it);
     EXPECT_EQ(6u, set.size());
     EXPECT_EQ(4, set.last());
 }
 
 TEST(ListHashSetTest, AddReturnIterator)
 {
-    addReturnIterator<ListHashSet<int> >(true);
-    addReturnIterator<ListHashSet<int, 1> >(true);
+    addReturnIterator<ListHashSet<int>>(true);
+    addReturnIterator<ListHashSet<int, 1>>(true);
 }
 
 TEST(LinkedHashSetTest, AddReturnIterator)
 {
-    addReturnIterator<LinkedHashSet<int> >(false);
+    addReturnIterator<LinkedHashSet<int>>(false);
 }
 
 template<typename Set>
 void excerciseValuePeekInType()
 {
     Set set;
     bool isDeleted = false;
     bool isDeleted2 = false;
 
     RefPtr<DummyRefCounted> ptr = adoptRef(new DummyRefCounted(isDeleted));
@@ skipping 21 matching lines @@
 
     EXPECT_FALSE(isDeleted2);
     set.removeFirst();
     EXPECT_TRUE(isDeleted2);
 
     EXPECT_EQ(0u, set.size());
 }
 
 TEST(ListHashSetTest, ExcerciseValuePeekInType)
 {
-    excerciseValuePeekInType<ListHashSet<RefPtr<DummyRefCounted> > >();
-    excerciseValuePeekInType<ListHashSet<RefPtr<DummyRefCounted>, 1> >();
+    excerciseValuePeekInType<ListHashSet<RefPtr<DummyRefCounted>>>();
+    excerciseValuePeekInType<ListHashSet<RefPtr<DummyRefCounted>, 1>>();
 }
 
 TEST(LinkedHashSetTest, ExcerciseValuePeekInType)
 {
-    excerciseValuePeekInType<LinkedHashSet<RefPtr<DummyRefCounted> > >();
+    excerciseValuePeekInType<LinkedHashSet<RefPtr<DummyRefCounted>>>();
 }
 
 struct Simple {
     Simple(int value) : m_value(value) { };
     int m_value;
 };
 
 struct Complicated {
     Complicated(int value) : m_simple(value)
     {
@@ skipping 44 matching lines @@
     EXPECT_NE(constIterator, constSet.end());
     EXPECT_EQ(baseLine, Complicated::s_objectsConstructed);
 
     constIterator = constSet.template find<ComplexityTranslator>(Simple(103));
     EXPECT_EQ(constIterator, constSet.end());
     EXPECT_EQ(baseLine, Complicated::s_objectsConstructed);
 }
 
 TEST(ListHashSetTest, ComplexityTranslator)
 {
-    translatorTest<ListHashSet<Complicated, 256, ComplicatedHashFunctions> >();
-    translatorTest<ListHashSet<Complicated, 1, ComplicatedHashFunctions> >();
+    translatorTest<ListHashSet<Complicated, 256, ComplicatedHashFunctions>>();
+    translatorTest<ListHashSet<Complicated, 1, ComplicatedHashFunctions>>();
 }
 
 TEST(LinkedHashSetTest, ComplexityTranslator)
 {
-    translatorTest<LinkedHashSet<Complicated, ComplicatedHashFunctions> >();
+    translatorTest<LinkedHashSet<Complicated, ComplicatedHashFunctions>>();
 }
 
 struct Dummy {
     Dummy(bool& deleted) : deleted(deleted) { }
 
     ~Dummy()
     {
         deleted = true;
     }
 
     bool& deleted;
 };
 
 TEST(ListHashSetTest, WithOwnPtr)
 {
     bool deleted1 = false, deleted2 = false;
 
-    typedef ListHashSet<OwnPtr<Dummy> > OwnPtrSet;
+    typedef ListHashSet<OwnPtr<Dummy>> OwnPtrSet;
     OwnPtrSet set;
 
     Dummy* ptr1 = new Dummy(deleted1);
     {
         // AddResult in a separate scope to avoid assertion hit,
         // since we modify the container further.
         OwnPtrSet::AddResult res1 = set.add(adoptPtr(ptr1));
         EXPECT_EQ(res1.storedValue->m_value.get(), ptr1);
     }
 
@@ skipping 102 matching lines @@
             ++i;
         EXPECT_EQ(*it1, i + 1);
         EXPECT_EQ(*it2, num - i);
     }
     EXPECT_EQ(it1, set0.end());
     EXPECT_EQ(it2, set1.end());
 }
 
 TEST(ListHashSetTest, Swap)
 {
-    swapTestHelper<ListHashSet<int> >();
+    swapTestHelper<ListHashSet<int>>();
 }
 
 TEST(LinkedHashSetTest, Swap)
 {
-    swapTestHelper<LinkedHashSet<int> >();
+    swapTestHelper<LinkedHashSet<int>>();
 }
 
 } // namespace