Assert on actual contents of ScopedVector in scoped_vector_unittest.

base/memory/scoped_vector_unittest.cc

 // Copyright (c) 2012 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/memory/scoped_vector.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/memory/scoped_ptr.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 73 matching lines @@
   }
 
   LifeCycleState life_cycle_state() const { return life_cycle_state_; }
 
   // Factory method for creating a new LifeCycleObject tied to this
   // LifeCycleWatcher.
   LifeCycleObject* NewLifeCycleObject() {
     return new LifeCycleObject(this);
   }
 
+  // Returns true iff |object| is the same object that this watcher is tracking.
+  bool IsWatching(LifeCycleObject* object) const {
+    return object == constructed_life_cycle_object_.get();
+  }
+
  private:
   LifeCycleState life_cycle_state_;
   scoped_ptr<LifeCycleObject> constructed_life_cycle_object_;
 
   DISALLOW_COPY_AND_ASSIGN(LifeCycleWatcher);
 };
 
 TEST(ScopedVectorTest, LifeCycleWatcher) {
   LifeCycleWatcher watcher;
   EXPECT_EQ(LC_INITIAL, watcher.life_cycle_state());
   LifeCycleObject* object = watcher.NewLifeCycleObject();
   EXPECT_EQ(LC_CONSTRUCTED, watcher.life_cycle_state());
   delete object;
   EXPECT_EQ(LC_DESTROYED, watcher.life_cycle_state());
 }
 
 TEST(ScopedVectorTest, Clear) {
   LifeCycleWatcher watcher;
   EXPECT_EQ(LC_INITIAL, watcher.life_cycle_state());
   ScopedVector<LifeCycleObject> scoped_vector;
   scoped_vector.push_back(watcher.NewLifeCycleObject());
   EXPECT_EQ(LC_CONSTRUCTED, watcher.life_cycle_state());
+  EXPECT_TRUE(watcher.IsWatching(scoped_vector.back()));
   scoped_vector.clear();
   EXPECT_EQ(LC_DESTROYED, watcher.life_cycle_state());
   EXPECT_EQ(implicit_cast<size_t>(0), scoped_vector.size());
 }
 
 TEST(ScopedVectorTest, WeakClear) {
   LifeCycleWatcher watcher;
   EXPECT_EQ(LC_INITIAL, watcher.life_cycle_state());
   ScopedVector<LifeCycleObject> scoped_vector;
   scoped_vector.push_back(watcher.NewLifeCycleObject());
   EXPECT_EQ(LC_CONSTRUCTED, watcher.life_cycle_state());
+  EXPECT_TRUE(watcher.IsWatching(scoped_vector.back()));
   scoped_vector.weak_clear();
   EXPECT_EQ(LC_CONSTRUCTED, watcher.life_cycle_state());
   EXPECT_EQ(implicit_cast<size_t>(0), scoped_vector.size());
 }
 
 TEST(ScopedVectorTest, ResizeShrink) {
   LifeCycleWatcher first_watcher;
   EXPECT_EQ(LC_INITIAL, first_watcher.life_cycle_state());
   LifeCycleWatcher second_watcher;
   EXPECT_EQ(LC_INITIAL, second_watcher.life_cycle_state());
   ScopedVector<LifeCycleObject> scoped_vector;
 
   scoped_vector.push_back(first_watcher.NewLifeCycleObject());
   EXPECT_EQ(LC_CONSTRUCTED, first_watcher.life_cycle_state());
   EXPECT_EQ(LC_INITIAL, second_watcher.life_cycle_state());
+  EXPECT_TRUE(first_watcher.IsWatching(scoped_vector[0]));
+  EXPECT_FALSE(second_watcher.IsWatching(scoped_vector[0]));
 
   scoped_vector.push_back(second_watcher.NewLifeCycleObject());
   EXPECT_EQ(LC_CONSTRUCTED, first_watcher.life_cycle_state());
   EXPECT_EQ(LC_CONSTRUCTED, second_watcher.life_cycle_state());
+  EXPECT_FALSE(first_watcher.IsWatching(scoped_vector[1]));
+  EXPECT_TRUE(second_watcher.IsWatching(scoped_vector[1]));
 
   // Test that shrinking a vector deletes elements in the dissapearing range.

[willchan no longer on Chromium, 2012/12/04 01:41:50]

disappearing

[gavinp, 2012/12/08 17:39:59]

Done.

   scoped_vector.resize(1);
   EXPECT_EQ(LC_CONSTRUCTED, first_watcher.life_cycle_state());
   EXPECT_EQ(LC_DESTROYED, second_watcher.life_cycle_state());
   EXPECT_EQ(implicit_cast<size_t>(1), scoped_vector.size());
+  EXPECT_TRUE(first_watcher.IsWatching(scoped_vector[0]));
 }
 
 TEST(ScopedVectorTest, ResizeGrow) {
   LifeCycleWatcher watcher;
   EXPECT_EQ(LC_INITIAL, watcher.life_cycle_state());
   ScopedVector<LifeCycleObject> scoped_vector;
   scoped_vector.push_back(watcher.NewLifeCycleObject());
   EXPECT_EQ(LC_CONSTRUCTED, watcher.life_cycle_state());
+  EXPECT_TRUE(watcher.IsWatching(scoped_vector.back()));
 
   scoped_vector.resize(5);
   EXPECT_EQ(LC_CONSTRUCTED, watcher.life_cycle_state());
+  EXPECT_TRUE(watcher.IsWatching(scoped_vector[0]));
+  EXPECT_FALSE(watcher.IsWatching(scoped_vector[1]) ||

[willchan no longer on Chromium, 2012/12/04 01:41:50]

Just do multiple EXPECT_FALSEs, since if one of them fails, you want to know
which one failed.

[gavinp, 2012/12/08 17:39:59]

Done.

+               watcher.IsWatching(scoped_vector[2]) ||
+               watcher.IsWatching(scoped_vector[3]) ||
+               watcher.IsWatching(scoped_vector[4]));
   EXPECT_EQ(implicit_cast<size_t>(5), scoped_vector.size());

[willchan no longer on Chromium, 2012/12/04 01:41:50]

Move this ahead and do ASSERT_EQ, since if it's false, the others may crash.

[gavinp, 2012/12/08 17:39:59]

Done. Good point, I'll remember to watch for this in other tests.

 }
 
 TEST(ScopedVectorTest, Scope) {
   LifeCycleWatcher watcher;
   EXPECT_EQ(LC_INITIAL, watcher.life_cycle_state());
   {
     ScopedVector<LifeCycleObject> scoped_vector;
     scoped_vector.push_back(watcher.NewLifeCycleObject());
     EXPECT_EQ(LC_CONSTRUCTED, watcher.life_cycle_state());
+    EXPECT_TRUE(watcher.IsWatching(scoped_vector.back()));
   }
   EXPECT_EQ(LC_DESTROYED, watcher.life_cycle_state());
 }
 
 TEST(ScopedVectorTest, MoveConstruct) {
   LifeCycleWatcher watcher;
   EXPECT_EQ(LC_INITIAL, watcher.life_cycle_state());
   {
     ScopedVector<LifeCycleObject> scoped_vector;
     scoped_vector.push_back(watcher.NewLifeCycleObject());
     EXPECT_FALSE(scoped_vector.empty());
+    EXPECT_TRUE(watcher.IsWatching(scoped_vector.back()));
 
     ScopedVector<LifeCycleObject> scoped_vector_copy(scoped_vector.Pass());
     EXPECT_TRUE(scoped_vector.empty());
     EXPECT_FALSE(scoped_vector_copy.empty());
+    EXPECT_TRUE(watcher.IsWatching(scoped_vector_copy.back()));
 
     EXPECT_EQ(LC_CONSTRUCTED, watcher.life_cycle_state());
   }
   EXPECT_EQ(LC_DESTROYED, watcher.life_cycle_state());
 }
 
 TEST(ScopedVectorTest, MoveAssign) {
   LifeCycleWatcher watcher;
   EXPECT_EQ(LC_INITIAL, watcher.life_cycle_state());
   {
     ScopedVector<LifeCycleObject> scoped_vector;
     scoped_vector.push_back(watcher.NewLifeCycleObject());
     ScopedVector<LifeCycleObject> scoped_vector_assign;
     EXPECT_FALSE(scoped_vector.empty());
+    EXPECT_TRUE(watcher.IsWatching(scoped_vector.back()));
 
     scoped_vector_assign = scoped_vector.Pass();
     EXPECT_TRUE(scoped_vector.empty());
     EXPECT_FALSE(scoped_vector_assign.empty());
+    EXPECT_TRUE(watcher.IsWatching(scoped_vector_assign.back()));
 
     EXPECT_EQ(LC_CONSTRUCTED, watcher.life_cycle_state());
   }
   EXPECT_EQ(LC_DESTROYED, watcher.life_cycle_state());
 }
 
 class DeleteCounter {
  public:
   explicit DeleteCounter(int* deletes)
       : deletes_(deletes) {
@@ skipping 51 matching lines @@
   for(LifeCycleWatcher* it = watchers; it != watchers + 1; ++it)
     EXPECT_EQ(LC_CONSTRUCTED, it->life_cycle_state());
   for(LifeCycleWatcher* it = watchers + 1; it != watchers + 3; ++it)
     EXPECT_EQ(LC_DESTROYED, it->life_cycle_state());
   for(LifeCycleWatcher* it = watchers + 3; it != watchers + arraysize(watchers);
       ++it)
     EXPECT_EQ(LC_CONSTRUCTED, it->life_cycle_state());
 }
 
 }  // namespace