| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "base/memory/scoped_vector.h" | |
| 6 | |
| 7 #include <memory> | |
| 8 #include <utility> | |
| 9 | |
| 10 #include "base/bind.h" | |
| 11 #include "base/callback.h" | |
| 12 #include "base/macros.h" | |
| 13 #include "testing/gtest/include/gtest/gtest.h" | |
| 14 | |
| 15 namespace { | |
| 16 | |
| 17 // The LifeCycleObject notifies its Observer upon construction & destruction. | |
| 18 class LifeCycleObject { | |
| 19 public: | |
| 20 class Observer { | |
| 21 public: | |
| 22 virtual void OnLifeCycleConstruct(LifeCycleObject* o) = 0; | |
| 23 virtual void OnLifeCycleDestroy(LifeCycleObject* o) = 0; | |
| 24 | |
| 25 protected: | |
| 26 virtual ~Observer() {} | |
| 27 }; | |
| 28 | |
| 29 ~LifeCycleObject() { | |
| 30 if (observer_) | |
| 31 observer_->OnLifeCycleDestroy(this); | |
| 32 } | |
| 33 | |
| 34 private: | |
| 35 friend class LifeCycleWatcher; | |
| 36 | |
| 37 explicit LifeCycleObject(Observer* observer) | |
| 38 : observer_(observer) { | |
| 39 observer_->OnLifeCycleConstruct(this); | |
| 40 } | |
| 41 | |
| 42 void DisconnectObserver() { | |
| 43 observer_ = nullptr; | |
| 44 } | |
| 45 | |
| 46 Observer* observer_; | |
| 47 | |
| 48 DISALLOW_COPY_AND_ASSIGN(LifeCycleObject); | |
| 49 }; | |
| 50 | |
| 51 // The life cycle states we care about for the purposes of testing ScopedVector | |
| 52 // against objects. | |
| 53 enum LifeCycleState { | |
| 54 LC_INITIAL, | |
| 55 LC_CONSTRUCTED, | |
| 56 LC_DESTROYED, | |
| 57 }; | |
| 58 | |
| 59 // Because we wish to watch the life cycle of an object being constructed and | |
| 60 // destroyed, and further wish to test expectations against the state of that | |
| 61 // object, we cannot save state in that object itself. Instead, we use this | |
| 62 // pairing of the watcher, which observes the object and notifies of | |
| 63 // construction & destruction. Since we also may be testing assumptions about | |
| 64 // things not getting freed, this class also acts like a scoping object and | |
| 65 // deletes the |constructed_life_cycle_object_|, if any when the | |
| 66 // LifeCycleWatcher is destroyed. To keep this simple, the only expected state | |
| 67 // changes are: | |
| 68 // INITIAL -> CONSTRUCTED -> DESTROYED. | |
| 69 // Anything more complicated than that should start another test. | |
| 70 class LifeCycleWatcher : public LifeCycleObject::Observer { | |
| 71 public: | |
| 72 LifeCycleWatcher() : life_cycle_state_(LC_INITIAL) {} | |
| 73 ~LifeCycleWatcher() override { | |
| 74 // Stop watching the watched object. Without this, the object's destructor | |
| 75 // will call into OnLifeCycleDestroy when destructed, which happens after | |
| 76 // this destructor has finished running. | |
| 77 if (constructed_life_cycle_object_) | |
| 78 constructed_life_cycle_object_->DisconnectObserver(); | |
| 79 } | |
| 80 | |
| 81 // Assert INITIAL -> CONSTRUCTED and no LifeCycleObject associated with this | |
| 82 // LifeCycleWatcher. | |
| 83 void OnLifeCycleConstruct(LifeCycleObject* object) override { | |
| 84 ASSERT_EQ(LC_INITIAL, life_cycle_state_); | |
| 85 ASSERT_EQ(NULL, constructed_life_cycle_object_.get()); | |
| 86 life_cycle_state_ = LC_CONSTRUCTED; | |
| 87 constructed_life_cycle_object_.reset(object); | |
| 88 } | |
| 89 | |
| 90 // Assert CONSTRUCTED -> DESTROYED and the |object| being destroyed is the | |
| 91 // same one we saw constructed. | |
| 92 void OnLifeCycleDestroy(LifeCycleObject* object) override { | |
| 93 ASSERT_EQ(LC_CONSTRUCTED, life_cycle_state_); | |
| 94 LifeCycleObject* constructed_life_cycle_object = | |
| 95 constructed_life_cycle_object_.release(); | |
| 96 ASSERT_EQ(constructed_life_cycle_object, object); | |
| 97 life_cycle_state_ = LC_DESTROYED; | |
| 98 } | |
| 99 | |
| 100 LifeCycleState life_cycle_state() const { return life_cycle_state_; } | |
| 101 | |
| 102 // Factory method for creating a new LifeCycleObject tied to this | |
| 103 // LifeCycleWatcher. | |
| 104 LifeCycleObject* NewLifeCycleObject() { | |
| 105 return new LifeCycleObject(this); | |
| 106 } | |
| 107 | |
| 108 // Returns true iff |object| is the same object that this watcher is tracking. | |
| 109 bool IsWatching(LifeCycleObject* object) const { | |
| 110 return object == constructed_life_cycle_object_.get(); | |
| 111 } | |
| 112 | |
| 113 private: | |
| 114 LifeCycleState life_cycle_state_; | |
| 115 std::unique_ptr<LifeCycleObject> constructed_life_cycle_object_; | |
| 116 | |
| 117 DISALLOW_COPY_AND_ASSIGN(LifeCycleWatcher); | |
| 118 }; | |
| 119 | |
| 120 TEST(ScopedVectorTest, LifeCycleWatcher) { | |
| 121 LifeCycleWatcher watcher; | |
| 122 EXPECT_EQ(LC_INITIAL, watcher.life_cycle_state()); | |
| 123 LifeCycleObject* object = watcher.NewLifeCycleObject(); | |
| 124 EXPECT_EQ(LC_CONSTRUCTED, watcher.life_cycle_state()); | |
| 125 delete object; | |
| 126 EXPECT_EQ(LC_DESTROYED, watcher.life_cycle_state()); | |
| 127 } | |
| 128 | |
| 129 TEST(ScopedVectorTest, PopBack) { | |
| 130 LifeCycleWatcher watcher; | |
| 131 EXPECT_EQ(LC_INITIAL, watcher.life_cycle_state()); | |
| 132 ScopedVector<LifeCycleObject> scoped_vector; | |
| 133 scoped_vector.push_back(watcher.NewLifeCycleObject()); | |
| 134 EXPECT_EQ(LC_CONSTRUCTED, watcher.life_cycle_state()); | |
| 135 EXPECT_TRUE(watcher.IsWatching(scoped_vector.back())); | |
| 136 scoped_vector.pop_back(); | |
| 137 EXPECT_EQ(LC_DESTROYED, watcher.life_cycle_state()); | |
| 138 EXPECT_TRUE(scoped_vector.empty()); | |
| 139 } | |
| 140 | |
| 141 TEST(ScopedVectorTest, Clear) { | |
| 142 LifeCycleWatcher watcher; | |
| 143 EXPECT_EQ(LC_INITIAL, watcher.life_cycle_state()); | |
| 144 ScopedVector<LifeCycleObject> scoped_vector; | |
| 145 scoped_vector.push_back(watcher.NewLifeCycleObject()); | |
| 146 EXPECT_EQ(LC_CONSTRUCTED, watcher.life_cycle_state()); | |
| 147 EXPECT_TRUE(watcher.IsWatching(scoped_vector.back())); | |
| 148 scoped_vector.clear(); | |
| 149 EXPECT_EQ(LC_DESTROYED, watcher.life_cycle_state()); | |
| 150 EXPECT_TRUE(scoped_vector.empty()); | |
| 151 } | |
| 152 | |
| 153 TEST(ScopedVectorTest, WeakClear) { | |
| 154 LifeCycleWatcher watcher; | |
| 155 EXPECT_EQ(LC_INITIAL, watcher.life_cycle_state()); | |
| 156 ScopedVector<LifeCycleObject> scoped_vector; | |
| 157 scoped_vector.push_back(watcher.NewLifeCycleObject()); | |
| 158 EXPECT_EQ(LC_CONSTRUCTED, watcher.life_cycle_state()); | |
| 159 EXPECT_TRUE(watcher.IsWatching(scoped_vector.back())); | |
| 160 scoped_vector.weak_clear(); | |
| 161 EXPECT_EQ(LC_CONSTRUCTED, watcher.life_cycle_state()); | |
| 162 EXPECT_TRUE(scoped_vector.empty()); | |
| 163 } | |
| 164 | |
| 165 TEST(ScopedVectorTest, ResizeShrink) { | |
| 166 LifeCycleWatcher first_watcher; | |
| 167 EXPECT_EQ(LC_INITIAL, first_watcher.life_cycle_state()); | |
| 168 LifeCycleWatcher second_watcher; | |
| 169 EXPECT_EQ(LC_INITIAL, second_watcher.life_cycle_state()); | |
| 170 ScopedVector<LifeCycleObject> scoped_vector; | |
| 171 | |
| 172 scoped_vector.push_back(first_watcher.NewLifeCycleObject()); | |
| 173 EXPECT_EQ(LC_CONSTRUCTED, first_watcher.life_cycle_state()); | |
| 174 EXPECT_EQ(LC_INITIAL, second_watcher.life_cycle_state()); | |
| 175 EXPECT_TRUE(first_watcher.IsWatching(scoped_vector[0])); | |
| 176 EXPECT_FALSE(second_watcher.IsWatching(scoped_vector[0])); | |
| 177 | |
| 178 scoped_vector.push_back(second_watcher.NewLifeCycleObject()); | |
| 179 EXPECT_EQ(LC_CONSTRUCTED, first_watcher.life_cycle_state()); | |
| 180 EXPECT_EQ(LC_CONSTRUCTED, second_watcher.life_cycle_state()); | |
| 181 EXPECT_FALSE(first_watcher.IsWatching(scoped_vector[1])); | |
| 182 EXPECT_TRUE(second_watcher.IsWatching(scoped_vector[1])); | |
| 183 | |
| 184 // Test that shrinking a vector deletes elements in the disappearing range. | |
| 185 scoped_vector.resize(1); | |
| 186 EXPECT_EQ(LC_CONSTRUCTED, first_watcher.life_cycle_state()); | |
| 187 EXPECT_EQ(LC_DESTROYED, second_watcher.life_cycle_state()); | |
| 188 EXPECT_EQ(1u, scoped_vector.size()); | |
| 189 EXPECT_TRUE(first_watcher.IsWatching(scoped_vector[0])); | |
| 190 } | |
| 191 | |
| 192 TEST(ScopedVectorTest, ResizeGrow) { | |
| 193 LifeCycleWatcher watcher; | |
| 194 EXPECT_EQ(LC_INITIAL, watcher.life_cycle_state()); | |
| 195 ScopedVector<LifeCycleObject> scoped_vector; | |
| 196 scoped_vector.push_back(watcher.NewLifeCycleObject()); | |
| 197 EXPECT_EQ(LC_CONSTRUCTED, watcher.life_cycle_state()); | |
| 198 EXPECT_TRUE(watcher.IsWatching(scoped_vector.back())); | |
| 199 | |
| 200 scoped_vector.resize(5); | |
| 201 EXPECT_EQ(LC_CONSTRUCTED, watcher.life_cycle_state()); | |
| 202 ASSERT_EQ(5u, scoped_vector.size()); | |
| 203 EXPECT_TRUE(watcher.IsWatching(scoped_vector[0])); | |
| 204 EXPECT_FALSE(watcher.IsWatching(scoped_vector[1])); | |
| 205 EXPECT_FALSE(watcher.IsWatching(scoped_vector[2])); | |
| 206 EXPECT_FALSE(watcher.IsWatching(scoped_vector[3])); | |
| 207 EXPECT_FALSE(watcher.IsWatching(scoped_vector[4])); | |
| 208 } | |
| 209 | |
| 210 TEST(ScopedVectorTest, Scope) { | |
| 211 LifeCycleWatcher watcher; | |
| 212 EXPECT_EQ(LC_INITIAL, watcher.life_cycle_state()); | |
| 213 { | |
| 214 ScopedVector<LifeCycleObject> scoped_vector; | |
| 215 scoped_vector.push_back(watcher.NewLifeCycleObject()); | |
| 216 EXPECT_EQ(LC_CONSTRUCTED, watcher.life_cycle_state()); | |
| 217 EXPECT_TRUE(watcher.IsWatching(scoped_vector.back())); | |
| 218 } | |
| 219 EXPECT_EQ(LC_DESTROYED, watcher.life_cycle_state()); | |
| 220 } | |
| 221 | |
| 222 TEST(ScopedVectorTest, MoveConstruct) { | |
| 223 LifeCycleWatcher watcher; | |
| 224 EXPECT_EQ(LC_INITIAL, watcher.life_cycle_state()); | |
| 225 { | |
| 226 ScopedVector<LifeCycleObject> scoped_vector; | |
| 227 scoped_vector.push_back(watcher.NewLifeCycleObject()); | |
| 228 EXPECT_FALSE(scoped_vector.empty()); | |
| 229 EXPECT_TRUE(watcher.IsWatching(scoped_vector.back())); | |
| 230 | |
| 231 ScopedVector<LifeCycleObject> scoped_vector_copy(std::move(scoped_vector)); | |
| 232 EXPECT_TRUE(scoped_vector.empty()); | |
| 233 EXPECT_FALSE(scoped_vector_copy.empty()); | |
| 234 EXPECT_TRUE(watcher.IsWatching(scoped_vector_copy.back())); | |
| 235 | |
| 236 EXPECT_EQ(LC_CONSTRUCTED, watcher.life_cycle_state()); | |
| 237 } | |
| 238 EXPECT_EQ(LC_DESTROYED, watcher.life_cycle_state()); | |
| 239 } | |
| 240 | |
| 241 TEST(ScopedVectorTest, MoveAssign) { | |
| 242 LifeCycleWatcher watcher; | |
| 243 EXPECT_EQ(LC_INITIAL, watcher.life_cycle_state()); | |
| 244 { | |
| 245 ScopedVector<LifeCycleObject> scoped_vector; | |
| 246 scoped_vector.push_back(watcher.NewLifeCycleObject()); | |
| 247 ScopedVector<LifeCycleObject> scoped_vector_assign; | |
| 248 EXPECT_FALSE(scoped_vector.empty()); | |
| 249 EXPECT_TRUE(watcher.IsWatching(scoped_vector.back())); | |
| 250 | |
| 251 scoped_vector_assign = std::move(scoped_vector); | |
| 252 EXPECT_TRUE(scoped_vector.empty()); | |
| 253 EXPECT_FALSE(scoped_vector_assign.empty()); | |
| 254 EXPECT_TRUE(watcher.IsWatching(scoped_vector_assign.back())); | |
| 255 | |
| 256 EXPECT_EQ(LC_CONSTRUCTED, watcher.life_cycle_state()); | |
| 257 } | |
| 258 EXPECT_EQ(LC_DESTROYED, watcher.life_cycle_state()); | |
| 259 } | |
| 260 | |
| 261 class DeleteCounter { | |
| 262 public: | |
| 263 explicit DeleteCounter(int* deletes) | |
| 264 : deletes_(deletes) { | |
| 265 } | |
| 266 | |
| 267 ~DeleteCounter() { | |
| 268 (*deletes_)++; | |
| 269 } | |
| 270 | |
| 271 void VoidMethod0() {} | |
| 272 | |
| 273 private: | |
| 274 int* const deletes_; | |
| 275 | |
| 276 DISALLOW_COPY_AND_ASSIGN(DeleteCounter); | |
| 277 }; | |
| 278 | |
| 279 template <typename T> | |
| 280 ScopedVector<T> PassThru(ScopedVector<T> scoper) { | |
| 281 return scoper; | |
| 282 } | |
| 283 | |
| 284 TEST(ScopedVectorTest, Passed) { | |
| 285 int deletes = 0; | |
| 286 ScopedVector<DeleteCounter> deleter_vector; | |
| 287 deleter_vector.push_back(new DeleteCounter(&deletes)); | |
| 288 EXPECT_EQ(0, deletes); | |
| 289 base::Callback<ScopedVector<DeleteCounter>(void)> callback = | |
| 290 base::Bind(&PassThru<DeleteCounter>, base::Passed(&deleter_vector)); | |
| 291 EXPECT_EQ(0, deletes); | |
| 292 ScopedVector<DeleteCounter> result = callback.Run(); | |
| 293 EXPECT_EQ(0, deletes); | |
| 294 result.clear(); | |
| 295 EXPECT_EQ(1, deletes); | |
| 296 }; | |
| 297 | |
| 298 TEST(ScopedVectorTest, InsertRange) { | |
| 299 LifeCycleWatcher watchers[5]; | |
| 300 | |
| 301 std::vector<LifeCycleObject*> vec; | |
| 302 for(LifeCycleWatcher* it = watchers; it != watchers + arraysize(watchers); | |
| 303 ++it) { | |
| 304 EXPECT_EQ(LC_INITIAL, it->life_cycle_state()); | |
| 305 vec.push_back(it->NewLifeCycleObject()); | |
| 306 EXPECT_EQ(LC_CONSTRUCTED, it->life_cycle_state()); | |
| 307 } | |
| 308 // Start scope for ScopedVector. | |
| 309 { | |
| 310 ScopedVector<LifeCycleObject> scoped_vector; | |
| 311 scoped_vector.insert(scoped_vector.end(), vec.begin() + 1, vec.begin() + 3); | |
| 312 for(LifeCycleWatcher* it = watchers; it != watchers + arraysize(watchers); | |
| 313 ++it) | |
| 314 EXPECT_EQ(LC_CONSTRUCTED, it->life_cycle_state()); | |
| 315 } | |
| 316 for(LifeCycleWatcher* it = watchers; it != watchers + 1; ++it) | |
| 317 EXPECT_EQ(LC_CONSTRUCTED, it->life_cycle_state()); | |
| 318 for(LifeCycleWatcher* it = watchers + 1; it != watchers + 3; ++it) | |
| 319 EXPECT_EQ(LC_DESTROYED, it->life_cycle_state()); | |
| 320 for(LifeCycleWatcher* it = watchers + 3; it != watchers + arraysize(watchers); | |
| 321 ++it) | |
| 322 EXPECT_EQ(LC_CONSTRUCTED, it->life_cycle_state()); | |
| 323 } | |
| 324 | |
| 325 // Assertions for push_back(unique_ptr). | |
| 326 TEST(ScopedVectorTest, PushBackScopedPtr) { | |
| 327 int delete_counter = 0; | |
| 328 std::unique_ptr<DeleteCounter> elem(new DeleteCounter(&delete_counter)); | |
| 329 EXPECT_EQ(0, delete_counter); | |
| 330 { | |
| 331 ScopedVector<DeleteCounter> v; | |
| 332 v.push_back(std::move(elem)); | |
| 333 EXPECT_EQ(0, delete_counter); | |
| 334 } | |
| 335 EXPECT_EQ(1, delete_counter); | |
| 336 } | |
| 337 | |
| 338 } // namespace | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2968253002:
Remove ScopedVector. (Closed)
