base: Use TEST() macro when possible.

base/id_map_unittest.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/id_map.h"
 
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 
-class IDMapTest : public testing::Test {
-};
-
 class TestObject {
 };
 
 class DestructorCounter {
  public:
   explicit DestructorCounter(int* counter) : counter_(counter) {}
   ~DestructorCounter() { ++(*counter_); }
+
  private:
   int* counter_;
 };
 
-TEST_F(IDMapTest, Basic) {
+TEST(IDMapTest, Basic) {
   IDMap<TestObject> map;
   EXPECT_TRUE(map.IsEmpty());
   EXPECT_EQ(0U, map.size());
 
   TestObject obj1;
   TestObject obj2;
 
   int32 id1 = map.Add(&obj1);
   EXPECT_FALSE(map.IsEmpty());
   EXPECT_EQ(1U, map.size());
@@ skipping 15 matching lines @@
   EXPECT_EQ(0U, map.size());
 
   map.AddWithID(&obj1, 1);
   map.AddWithID(&obj2, 2);
   EXPECT_EQ(&obj1, map.Lookup(1));
   EXPECT_EQ(&obj2, map.Lookup(2));
 
   EXPECT_EQ(0, map.iteration_depth());
 }
 
-TEST_F(IDMapTest, IteratorRemainsValidWhenRemovingCurrentElement) {
+TEST(IDMapTest, IteratorRemainsValidWhenRemovingCurrentElement) {
   IDMap<TestObject> map;
 
   TestObject obj1;
   TestObject obj2;
   TestObject obj3;
 
   map.Add(&obj1);
   map.Add(&obj2);
   map.Add(&obj3);
 
@@ skipping 12 matching lines @@
     EXPECT_TRUE(map.IsEmpty());
     EXPECT_EQ(0U, map.size());
   }
 
   EXPECT_TRUE(map.IsEmpty());
   EXPECT_EQ(0U, map.size());
 
   EXPECT_EQ(0, map.iteration_depth());
 }
 
-TEST_F(IDMapTest, IteratorRemainsValidWhenRemovingOtherElements) {
+TEST(IDMapTest, IteratorRemainsValidWhenRemovingOtherElements) {
   IDMap<TestObject> map;
 
   const int kCount = 5;
   TestObject obj[kCount];
   int32 ids[kCount];
 
   for (int i = 0; i < kCount; i++)
     ids[i] = map.Add(&obj[i]);
 
   int counter = 0;
@@ skipping 21 matching lines @@
         FAIL() << "should not have that many elements";
         break;
     }
 
     counter++;
   }
 
   EXPECT_EQ(0, map.iteration_depth());
 }
 
-TEST_F(IDMapTest, CopyIterator) {
+TEST(IDMapTest, CopyIterator) {
   IDMap<TestObject> map;
 
   TestObject obj1;
   TestObject obj2;
   TestObject obj3;
 
   map.Add(&obj1);
   map.Add(&obj2);
   map.Add(&obj3);
 
   EXPECT_EQ(0, map.iteration_depth());
 
   {
     IDMap<TestObject>::const_iterator iter1(&map);
     EXPECT_EQ(1, map.iteration_depth());
 
     // Make sure that copying the iterator correctly increments
     // map's iteration depth.
     IDMap<TestObject>::const_iterator iter2(iter1);
     EXPECT_EQ(2, map.iteration_depth());
   }
 
   // Make sure after destroying all iterators the map's iteration depth
   // returns to initial state.
   EXPECT_EQ(0, map.iteration_depth());
 }
 
-TEST_F(IDMapTest, AssignIterator) {
+TEST(IDMapTest, AssignIterator) {
   IDMap<TestObject> map;
 
   TestObject obj1;
   TestObject obj2;
   TestObject obj3;
 
   map.Add(&obj1);
   map.Add(&obj2);
   map.Add(&obj3);
 
   EXPECT_EQ(0, map.iteration_depth());
 
   {
     IDMap<TestObject>::const_iterator iter1(&map);
     EXPECT_EQ(1, map.iteration_depth());
 
     IDMap<TestObject>::const_iterator iter2(&map);
     EXPECT_EQ(2, map.iteration_depth());
 
     // Make sure that assigning the iterator correctly updates
     // map's iteration depth (-1 for destruction, +1 for assignment).
     EXPECT_EQ(2, map.iteration_depth());
   }
 
   // Make sure after destroying all iterators the map's iteration depth
   // returns to initial state.
   EXPECT_EQ(0, map.iteration_depth());
 }
 
-TEST_F(IDMapTest, IteratorRemainsValidWhenClearing) {
+TEST(IDMapTest, IteratorRemainsValidWhenClearing) {
   IDMap<TestObject> map;
 
   const int kCount = 5;
   TestObject obj[kCount];
   int32 ids[kCount];
 
   for (int i = 0; i < kCount; i++)
     ids[i] = map.Add(&obj[i]);
 
   int counter = 0;
@@ skipping 15 matching lines @@
         FAIL() << "should not have that many elements";
         break;
     }
     counter++;
   }
 
   EXPECT_TRUE(map.IsEmpty());
   EXPECT_EQ(0U, map.size());
 }
 
-TEST_F(IDMapTest, OwningPointersDeletesThemOnRemove) {
+TEST(IDMapTest, OwningPointersDeletesThemOnRemove) {
   const int kCount = 3;
 
   int external_del_count = 0;
   DestructorCounter* external_obj[kCount];
   int map_external_ids[kCount];
 
   int owned_del_count = 0;
   DestructorCounter* owned_obj[kCount];
   int map_owned_ids[kCount];
 
@@ skipping 17 matching lines @@
   }
 
   for (int i = 0; i < kCount; ++i) {
     delete external_obj[i];
   }
 
   EXPECT_EQ(external_del_count, kCount);
   EXPECT_EQ(owned_del_count, kCount);
 }
 
-TEST_F(IDMapTest, OwningPointersDeletesThemOnClear) {
+TEST(IDMapTest, OwningPointersDeletesThemOnClear) {
   const int kCount = 3;
 
   int external_del_count = 0;
   DestructorCounter* external_obj[kCount];
 
   int owned_del_count = 0;
   DestructorCounter* owned_obj[kCount];
 
   IDMap<DestructorCounter> map_external;
   IDMap<DestructorCounter, IDMapOwnPointer> map_owned;
@@ skipping 16 matching lines @@
   EXPECT_EQ(owned_del_count, kCount);
 
   for (int i = 0; i < kCount; ++i) {
     delete external_obj[i];
   }
 
   EXPECT_EQ(external_del_count, kCount);
   EXPECT_EQ(owned_del_count, kCount);
 }
 
-TEST_F(IDMapTest, OwningPointersDeletesThemOnDestruct) {
+TEST(IDMapTest, OwningPointersDeletesThemOnDestruct) {
   const int kCount = 3;
 
   int external_del_count = 0;
   DestructorCounter* external_obj[kCount];
 
   int owned_del_count = 0;
   DestructorCounter* owned_obj[kCount];
 
   {
     IDMap<DestructorCounter> map_external;
@@ skipping 12 matching lines @@
 
   for (int i = 0; i < kCount; ++i) {
     delete external_obj[i];
   }
 
   EXPECT_EQ(external_del_count, kCount);
   EXPECT_EQ(owned_del_count, kCount);
 }
 
 }  // namespace