Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(581)

Side by Side Diff: base/memory/ref_counted_unittest.cc

Issue 1076953002: Add move support for scoped_refptr. (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: add |override| for |virtual ~ScopedRefPtrCountDerived|. Created 5 years, 8 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
OLDNEW
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. 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 2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file. 3 // found in the LICENSE file.
4 4
5 #include "base/memory/ref_counted.h" 5 #include "base/memory/ref_counted.h"
6 6
7 #include "base/test/opaque_ref_counted.h" 7 #include "base/test/opaque_ref_counted.h"
8 #include "testing/gtest/include/gtest/gtest.h" 8 #include "testing/gtest/include/gtest/gtest.h"
9 9
10 namespace { 10 namespace {
(...skipping 35 matching lines...) Expand 10 before | Expand all | Expand 10 after
46 friend class base::RefCounted<ScopedRefPtrToSelf>; 46 friend class base::RefCounted<ScopedRefPtrToSelf>;
47 ~ScopedRefPtrToSelf() { was_destroyed_ = true; } 47 ~ScopedRefPtrToSelf() { was_destroyed_ = true; }
48 48
49 static bool was_destroyed_; 49 static bool was_destroyed_;
50 50
51 scoped_refptr<ScopedRefPtrToSelf> self_ptr_; 51 scoped_refptr<ScopedRefPtrToSelf> self_ptr_;
52 }; 52 };
53 53
54 bool ScopedRefPtrToSelf::was_destroyed_ = false; 54 bool ScopedRefPtrToSelf::was_destroyed_ = false;
55 55
56 class ScopedRefPtrCountBase : public base::RefCounted<ScopedRefPtrCountBase> {
57 public:
58 ScopedRefPtrCountBase() { ++constructor_count_; }
59
60 static int constructor_count() { return constructor_count_; }
61
62 static int destructor_count() { return destructor_count_; }
63
64 static void reset_count() {
65 constructor_count_ = 0;
66 destructor_count_ = 0;
67 }
68
69 protected:
70 virtual ~ScopedRefPtrCountBase() { ++destructor_count_; }
71
72 private:
73 friend class base::RefCounted<ScopedRefPtrCountBase>;
74
75 static int constructor_count_;
76 static int destructor_count_;
77 };
78
79 int ScopedRefPtrCountBase::constructor_count_ = 0;
80 int ScopedRefPtrCountBase::destructor_count_ = 0;
81
82 class ScopedRefPtrCountDerived : public ScopedRefPtrCountBase {
83 public:
84 ScopedRefPtrCountDerived() { ++constructor_count_; }
85
86 static int constructor_count() { return constructor_count_; }
87
88 static int destructor_count() { return destructor_count_; }
89
90 static void reset_count() {
91 constructor_count_ = 0;
92 destructor_count_ = 0;
93 }
94
95 protected:
96 virtual ~ScopedRefPtrCountDerived() override { ++destructor_count_; }
97
98 private:
99 friend class base::RefCounted<ScopedRefPtrCountDerived>;
100
101 static int constructor_count_;
102 static int destructor_count_;
103 };
104
105 int ScopedRefPtrCountDerived::constructor_count_ = 0;
106 int ScopedRefPtrCountDerived::destructor_count_ = 0;
107
56 } // end namespace 108 } // end namespace
57 109
58 TEST(RefCountedUnitTest, TestSelfAssignment) { 110 TEST(RefCountedUnitTest, TestSelfAssignment) {
59 SelfAssign* p = new SelfAssign; 111 SelfAssign* p = new SelfAssign;
60 scoped_refptr<SelfAssign> var(p); 112 scoped_refptr<SelfAssign> var(p);
61 var = var; 113 var = var;
62 EXPECT_EQ(var.get(), p); 114 EXPECT_EQ(var.get(), p);
63 } 115 }
64 116
65 TEST(RefCountedUnitTest, ScopedRefPtrMemberAccess) { 117 TEST(RefCountedUnitTest, ScopedRefPtrMemberAccess) {
(...skipping 40 matching lines...) Expand 10 before | Expand all | Expand 10 after
106 scoped_refptr<SelfAssign> p2; 158 scoped_refptr<SelfAssign> p2;
107 159
108 EXPECT_NE(p1, p2); 160 EXPECT_NE(p1, p2);
109 EXPECT_NE(p2, p1); 161 EXPECT_NE(p2, p1);
110 162
111 p2 = p1; 163 p2 = p1;
112 164
113 EXPECT_EQ(p1, p2); 165 EXPECT_EQ(p1, p2);
114 EXPECT_EQ(p2, p1); 166 EXPECT_EQ(p2, p1);
115 } 167 }
168
169 TEST(RefCountedUnitTest, SelfMoveAssignment) {
170 ScopedRefPtrCountBase::reset_count();
171
172 {
173 ScopedRefPtrCountBase *raw = new ScopedRefPtrCountBase();
174 scoped_refptr<ScopedRefPtrCountBase> p(raw);
175 EXPECT_EQ(1, ScopedRefPtrCountBase::constructor_count());
176 EXPECT_EQ(0, ScopedRefPtrCountBase::destructor_count());
177
178 p = p.Pass();
179 EXPECT_EQ(1, ScopedRefPtrCountBase::constructor_count());
180 EXPECT_EQ(0, ScopedRefPtrCountBase::destructor_count());
181 EXPECT_EQ(raw, p.get());
182
183 // p goes out of scope.
184 }
185 EXPECT_EQ(1, ScopedRefPtrCountBase::constructor_count());
186 EXPECT_EQ(1, ScopedRefPtrCountBase::destructor_count());
187 }
188
189 TEST(RefCountedUnitTest, MoveAssignment1) {
190 ScopedRefPtrCountBase::reset_count();
191
192 {
193 ScopedRefPtrCountBase *raw = new ScopedRefPtrCountBase();
194 scoped_refptr<ScopedRefPtrCountBase> p1(raw);
195 EXPECT_EQ(1, ScopedRefPtrCountBase::constructor_count());
196 EXPECT_EQ(0, ScopedRefPtrCountBase::destructor_count());
197
198 {
199 scoped_refptr<ScopedRefPtrCountBase> p2;
200
201 p2 = p1.Pass();
202 EXPECT_EQ(1, ScopedRefPtrCountBase::constructor_count());
203 EXPECT_EQ(0, ScopedRefPtrCountBase::destructor_count());
204 EXPECT_EQ(nullptr, p1.get());
205 EXPECT_EQ(raw, p2.get());
206
207 // p2 goes out of scope.
208 }
209 EXPECT_EQ(1, ScopedRefPtrCountBase::constructor_count());
210 EXPECT_EQ(1, ScopedRefPtrCountBase::destructor_count());
211
212 // p1 goes out of scope.
213 }
214 EXPECT_EQ(1, ScopedRefPtrCountBase::constructor_count());
215 EXPECT_EQ(1, ScopedRefPtrCountBase::destructor_count());
216 }
217
218 TEST(RefCountedUnitTest, MoveAssignment2) {
219 ScopedRefPtrCountBase::reset_count();
220
221 {
222 ScopedRefPtrCountBase *raw = new ScopedRefPtrCountBase();
223 scoped_refptr<ScopedRefPtrCountBase> p1;
224 EXPECT_EQ(1, ScopedRefPtrCountBase::constructor_count());
225 EXPECT_EQ(0, ScopedRefPtrCountBase::destructor_count());
226
227 {
228 scoped_refptr<ScopedRefPtrCountBase> p2(raw);
229 EXPECT_EQ(1, ScopedRefPtrCountBase::constructor_count());
230 EXPECT_EQ(0, ScopedRefPtrCountBase::destructor_count());
231
232 p1 = p2.Pass();
233 EXPECT_EQ(1, ScopedRefPtrCountBase::constructor_count());
234 EXPECT_EQ(0, ScopedRefPtrCountBase::destructor_count());
235 EXPECT_EQ(raw, p1.get());
236 EXPECT_EQ(nullptr, p2.get());
237
238 // p2 goes out of scope.
239 }
240 EXPECT_EQ(1, ScopedRefPtrCountBase::constructor_count());
241 EXPECT_EQ(0, ScopedRefPtrCountBase::destructor_count());
242
243 // p1 goes out of scope.
244 }
245 EXPECT_EQ(1, ScopedRefPtrCountBase::constructor_count());
246 EXPECT_EQ(1, ScopedRefPtrCountBase::destructor_count());
247 }
248
249 TEST(RefCountedUnitTest, MoveAssignmentSameInstance1) {
250 ScopedRefPtrCountBase::reset_count();
251
252 {
253 ScopedRefPtrCountBase *raw = new ScopedRefPtrCountBase();
254 scoped_refptr<ScopedRefPtrCountBase> p1(raw);
255 EXPECT_EQ(1, ScopedRefPtrCountBase::constructor_count());
256 EXPECT_EQ(0, ScopedRefPtrCountBase::destructor_count());
257
258 {
259 scoped_refptr<ScopedRefPtrCountBase> p2(p1);
260 EXPECT_EQ(1, ScopedRefPtrCountBase::constructor_count());
261 EXPECT_EQ(0, ScopedRefPtrCountBase::destructor_count());
262
263 p1 = p2.Pass();
264 EXPECT_EQ(1, ScopedRefPtrCountBase::constructor_count());
265 EXPECT_EQ(0, ScopedRefPtrCountBase::destructor_count());
266 EXPECT_EQ(raw, p1.get());
267 EXPECT_EQ(nullptr, p2.get());
268
269 // p2 goes out of scope.
270 }
271 EXPECT_EQ(1, ScopedRefPtrCountBase::constructor_count());
272 EXPECT_EQ(0, ScopedRefPtrCountBase::destructor_count());
273
274 // p1 goes out of scope.
275 }
276 EXPECT_EQ(1, ScopedRefPtrCountBase::constructor_count());
277 EXPECT_EQ(1, ScopedRefPtrCountBase::destructor_count());
278 }
279
280 TEST(RefCountedUnitTest, MoveAssignmentSameInstance2) {
281 ScopedRefPtrCountBase::reset_count();
282
283 {
284 ScopedRefPtrCountBase *raw = new ScopedRefPtrCountBase();
285 scoped_refptr<ScopedRefPtrCountBase> p1(raw);
286 EXPECT_EQ(1, ScopedRefPtrCountBase::constructor_count());
287 EXPECT_EQ(0, ScopedRefPtrCountBase::destructor_count());
288
289 {
290 scoped_refptr<ScopedRefPtrCountBase> p2(p1);
291 EXPECT_EQ(1, ScopedRefPtrCountBase::constructor_count());
292 EXPECT_EQ(0, ScopedRefPtrCountBase::destructor_count());
293
294 p2 = p1.Pass();
295 EXPECT_EQ(1, ScopedRefPtrCountBase::constructor_count());
296 EXPECT_EQ(0, ScopedRefPtrCountBase::destructor_count());
297 EXPECT_EQ(nullptr, p1.get());
298 EXPECT_EQ(raw, p2.get());
299
300 // p2 goes out of scope.
301 }
302 EXPECT_EQ(1, ScopedRefPtrCountBase::constructor_count());
303 EXPECT_EQ(1, ScopedRefPtrCountBase::destructor_count());
304
305 // p1 goes out of scope.
306 }
307 EXPECT_EQ(1, ScopedRefPtrCountBase::constructor_count());
308 EXPECT_EQ(1, ScopedRefPtrCountBase::destructor_count());
309 }
310
311 TEST(RefCountedUnitTest, MoveAssignmentDifferentInstances) {
312 ScopedRefPtrCountBase::reset_count();
313
314 {
315 ScopedRefPtrCountBase *raw1 = new ScopedRefPtrCountBase();
316 scoped_refptr<ScopedRefPtrCountBase> p1(raw1);
317 EXPECT_EQ(1, ScopedRefPtrCountBase::constructor_count());
318 EXPECT_EQ(0, ScopedRefPtrCountBase::destructor_count());
319
320 {
321 ScopedRefPtrCountBase *raw2 = new ScopedRefPtrCountBase();
322 scoped_refptr<ScopedRefPtrCountBase> p2(raw2);
323 EXPECT_EQ(2, ScopedRefPtrCountBase::constructor_count());
324 EXPECT_EQ(0, ScopedRefPtrCountBase::destructor_count());
325
326 p1 = p2.Pass();
327 EXPECT_EQ(2, ScopedRefPtrCountBase::constructor_count());
328 EXPECT_EQ(1, ScopedRefPtrCountBase::destructor_count());
329 EXPECT_EQ(raw2, p1.get());
330 EXPECT_EQ(nullptr, p2.get());
331
332 // p2 goes out of scope.
333 }
334 EXPECT_EQ(2, ScopedRefPtrCountBase::constructor_count());
335 EXPECT_EQ(1, ScopedRefPtrCountBase::destructor_count());
336
337 // p1 goes out of scope.
338 }
339 EXPECT_EQ(2, ScopedRefPtrCountBase::constructor_count());
340 EXPECT_EQ(2, ScopedRefPtrCountBase::destructor_count());
341 }
342
343 TEST(RefCountedUnitTest, MoveAssignmentDerived) {
344 ScopedRefPtrCountBase::reset_count();
345 ScopedRefPtrCountDerived::reset_count();
346
347 {
348 ScopedRefPtrCountBase *raw1 = new ScopedRefPtrCountBase();
349 scoped_refptr<ScopedRefPtrCountBase> p1(raw1);
350 EXPECT_EQ(1, ScopedRefPtrCountBase::constructor_count());
351 EXPECT_EQ(0, ScopedRefPtrCountBase::destructor_count());
352 EXPECT_EQ(0, ScopedRefPtrCountDerived::constructor_count());
353 EXPECT_EQ(0, ScopedRefPtrCountDerived::destructor_count());
354
355 {
356 ScopedRefPtrCountDerived *raw2 = new ScopedRefPtrCountDerived();
357 scoped_refptr<ScopedRefPtrCountDerived> p2(raw2);
358 EXPECT_EQ(2, ScopedRefPtrCountBase::constructor_count());
359 EXPECT_EQ(0, ScopedRefPtrCountBase::destructor_count());
360 EXPECT_EQ(1, ScopedRefPtrCountDerived::constructor_count());
361 EXPECT_EQ(0, ScopedRefPtrCountDerived::destructor_count());
362
363 p1 = p2.Pass();
364 EXPECT_EQ(2, ScopedRefPtrCountBase::constructor_count());
365 EXPECT_EQ(1, ScopedRefPtrCountBase::destructor_count());
366 EXPECT_EQ(1, ScopedRefPtrCountDerived::constructor_count());
367 EXPECT_EQ(0, ScopedRefPtrCountDerived::destructor_count());
368 EXPECT_EQ(raw2, p1.get());
369 EXPECT_EQ(nullptr, p2.get());
370
371 // p2 goes out of scope.
372 }
373 EXPECT_EQ(2, ScopedRefPtrCountBase::constructor_count());
374 EXPECT_EQ(1, ScopedRefPtrCountBase::destructor_count());
375 EXPECT_EQ(1, ScopedRefPtrCountDerived::constructor_count());
376 EXPECT_EQ(0, ScopedRefPtrCountDerived::destructor_count());
377
378 // p1 goes out of scope.
379 }
380 EXPECT_EQ(2, ScopedRefPtrCountBase::constructor_count());
381 EXPECT_EQ(2, ScopedRefPtrCountBase::destructor_count());
382 EXPECT_EQ(1, ScopedRefPtrCountDerived::constructor_count());
383 EXPECT_EQ(1, ScopedRefPtrCountDerived::destructor_count());
384 }
385
386 TEST(RefCountedUnitTest, MoveConstructor) {
387 ScopedRefPtrCountBase::reset_count();
388
389 {
390 ScopedRefPtrCountBase *raw = new ScopedRefPtrCountBase();
391 scoped_refptr<ScopedRefPtrCountBase> p1(raw);
392 EXPECT_EQ(1, ScopedRefPtrCountBase::constructor_count());
393 EXPECT_EQ(0, ScopedRefPtrCountBase::destructor_count());
394
395 {
396 scoped_refptr<ScopedRefPtrCountBase> p2(p1.Pass());
397 EXPECT_EQ(1, ScopedRefPtrCountBase::constructor_count());
398 EXPECT_EQ(0, ScopedRefPtrCountBase::destructor_count());
399 EXPECT_EQ(nullptr, p1.get());
400 EXPECT_EQ(raw, p2.get());
401
402 // p2 goes out of scope.
403 }
404 EXPECT_EQ(1, ScopedRefPtrCountBase::constructor_count());
405 EXPECT_EQ(1, ScopedRefPtrCountBase::destructor_count());
406
407 // p1 goes out of scope.
408 }
409 EXPECT_EQ(1, ScopedRefPtrCountBase::constructor_count());
410 EXPECT_EQ(1, ScopedRefPtrCountBase::destructor_count());
411 }
412
413 TEST(RefCountedUnitTest, MoveConstructorDerived) {
414 ScopedRefPtrCountBase::reset_count();
415 ScopedRefPtrCountDerived::reset_count();
416
417 {
418 ScopedRefPtrCountDerived *raw1 = new ScopedRefPtrCountDerived();
419 scoped_refptr<ScopedRefPtrCountDerived> p1(raw1);
420 EXPECT_EQ(1, ScopedRefPtrCountBase::constructor_count());
421 EXPECT_EQ(0, ScopedRefPtrCountBase::destructor_count());
422 EXPECT_EQ(1, ScopedRefPtrCountDerived::constructor_count());
423 EXPECT_EQ(0, ScopedRefPtrCountDerived::destructor_count());
424
425 {
426 scoped_refptr<ScopedRefPtrCountBase> p2(p1.Pass());
427 EXPECT_EQ(1, ScopedRefPtrCountBase::constructor_count());
428 EXPECT_EQ(0, ScopedRefPtrCountBase::destructor_count());
429 EXPECT_EQ(1, ScopedRefPtrCountDerived::constructor_count());
430 EXPECT_EQ(0, ScopedRefPtrCountDerived::destructor_count());
431 EXPECT_EQ(nullptr, p1.get());
432 EXPECT_EQ(raw1, p2.get());
433
434 // p2 goes out of scope.
435 }
436 EXPECT_EQ(1, ScopedRefPtrCountBase::constructor_count());
437 EXPECT_EQ(1, ScopedRefPtrCountBase::destructor_count());
438 EXPECT_EQ(1, ScopedRefPtrCountDerived::constructor_count());
439 EXPECT_EQ(1, ScopedRefPtrCountDerived::destructor_count());
440
441 // p1 goes out of scope.
442 }
443 EXPECT_EQ(1, ScopedRefPtrCountBase::constructor_count());
444 EXPECT_EQ(1, ScopedRefPtrCountBase::destructor_count());
445 EXPECT_EQ(1, ScopedRefPtrCountDerived::constructor_count());
446 EXPECT_EQ(1, ScopedRefPtrCountDerived::destructor_count());
447 }
448
OLDNEW
« base/memory/ref_counted.h ('K') | « base/memory/ref_counted.h ('k') | base/move.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698