Member initialization for scoped_refptr<T>::ptr_.

base/memory/ref_counted_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/ref_counted.h"
 
+#include <utility>
+
 #include "base/test/opaque_ref_counted.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 
 class SelfAssign : public base::RefCounted<SelfAssign> {
  protected:
   virtual ~SelfAssign() {}
 
  private:
@@ skipping 132 matching lines @@
   ScopedRefPtrToSelf* check = new ScopedRefPtrToSelf();
   EXPECT_FALSE(ScopedRefPtrToSelf::was_destroyed());
   // Releasing |check->self_ptr_| will delete |check|.
   // The move assignment operator must assign |check->self_ptr_| first then
   // release |check->self_ptr_|.
   check->self_ptr_ = scoped_refptr<ScopedRefPtrToSelf>();
   EXPECT_TRUE(ScopedRefPtrToSelf::was_destroyed());
 }
 
 TEST(RefCountedUnitTest, ScopedRefPtrToOpaque) {
-  scoped_refptr<base::OpaqueRefCounted> p = base::MakeOpaqueRefCounted();
-  base::TestOpaqueRefCounted(p);
+  scoped_refptr<base::OpaqueRefCounted> initial = base::MakeOpaqueRefCounted();
+  base::TestOpaqueRefCounted(initial);
 
-  scoped_refptr<base::OpaqueRefCounted> q;
-  q = p;
-  base::TestOpaqueRefCounted(p);
-  base::TestOpaqueRefCounted(q);
+  scoped_refptr<base::OpaqueRefCounted> assigned;
+  assigned = initial;
+  base::TestOpaqueRefCounted(initial);
+  base::TestOpaqueRefCounted(assigned);
+
+  scoped_refptr<base::OpaqueRefCounted> copied(initial);
+  base::TestOpaqueRefCounted(initial);
+  base::TestOpaqueRefCounted(copied);
+
+  scoped_refptr<base::OpaqueRefCounted> moved(std::move(initial));

[danakj, 2016/10/27 22:10:54]

Isn't this just testing different ways to make a scoped_refptr? Once you have
one, all called to TestOpaqueRefCounted are the same at that point?

[gab, 2016/10/28 14:02:26]

Right I guess the multiple calls to TestOpaqueRefCounted() aren't verifying much
(i.e. the test is mostly about making sure it compiles not about logic testing
so the multiple calls aren't necessarily helpful -- other than to verify the
move happened correctly but other tests are already testing move so this is
perhaps overkill, WDYT?)

[danakj, 2016/10/29 00:49:09]

Yes if u wanna test them do it as a separate test if its not redundant with
other tests, but no need to call TestOpaqueRefCounted after each one :)

[gab, 2016/10/31 15:01:14]

Removed extraneous calls.

+  EXPECT_EQ(nullptr, initial.get());
+  base::TestOpaqueRefCounted(moved);
+
+  scoped_refptr<base::OpaqueRefCounted> move_assigned;
+  move_assigned = std::move(moved);
+  EXPECT_EQ(nullptr, moved.get());
+  base::TestOpaqueRefCounted(move_assigned);
+}
+
+TEST(RefCountedUnitTest, ScopedRefPtrToOpaqueThreadSafe) {
+  scoped_refptr<base::OpaqueRefCountedThreadSafe> initial =
+      base::MakeOpaqueRefCountedThreadSafe();
+  base::TestOpaqueRefCountedThreadSafe(initial);
+
+  scoped_refptr<base::OpaqueRefCountedThreadSafe> assigned;
+  assigned = initial;
+  base::TestOpaqueRefCountedThreadSafe(initial);
+  base::TestOpaqueRefCountedThreadSafe(assigned);
+
+  scoped_refptr<base::OpaqueRefCountedThreadSafe> copied(initial);
+  base::TestOpaqueRefCountedThreadSafe(initial);
+  base::TestOpaqueRefCountedThreadSafe(copied);
+
+  scoped_refptr<base::OpaqueRefCountedThreadSafe> moved(std::move(initial));
+  EXPECT_EQ(nullptr, initial.get());
+  base::TestOpaqueRefCountedThreadSafe(moved);
+
+  scoped_refptr<base::OpaqueRefCountedThreadSafe> move_assigned;
+  move_assigned = std::move(moved);
+  EXPECT_EQ(nullptr, moved.get());
+  base::TestOpaqueRefCountedThreadSafe(move_assigned);
 }
 
 TEST(RefCountedUnitTest, BooleanTesting) {
   scoped_refptr<SelfAssign> ptr_to_an_instance = new SelfAssign;
   EXPECT_TRUE(ptr_to_an_instance);
   EXPECT_FALSE(!ptr_to_an_instance);
 
   if (ptr_to_an_instance) {
   } else {
     ADD_FAILURE() << "Pointer to an instance should result in true.";
@@ skipping 322 matching lines @@
 
 TEST(RefCountedUnitTest, TestOverloadResolutionMove) {
   scoped_refptr<Derived> derived(new Derived);
   scoped_refptr<SelfAssign> expected(derived);
   EXPECT_EQ(expected, Overloaded(std::move(derived)));
 
   scoped_refptr<Other> other(new Other);
   scoped_refptr<Other> other2(other);
   EXPECT_EQ(other2, Overloaded(std::move(other)));
 }