base/memory/ref_counted_unittest.cc

   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/ref_counted.h"
   6
   7 #include "base/test/opaque_ref_counted.h"
   8 #include "testing/gtest/include/gtest/gtest.h"
   9
  10 namespace {
  11
  12 class SelfAssign : public base::RefCounted<SelfAssign> {
  13  protected:
  14   virtual ~SelfAssign() {}
  15
  16  private:
  17   friend class base::RefCounted<SelfAssign>;
  18 };
  19
  20 class Derived : public SelfAssign {
  21  protected:
  22   ~Derived() override {}
  23
  24  private:
  25   friend class base::RefCounted<Derived>;
  26 };
  27
  28 class CheckDerivedMemberAccess : public scoped_refptr<SelfAssign> {
  29  public:
  30   CheckDerivedMemberAccess() {
  31     // This shouldn't compile if we don't have access to the member variable.
  32     SelfAssign** pptr = &ptr_;
  33     EXPECT_EQ(*pptr, ptr_);
  34   }
  35 };
  36
  37 class ScopedRefPtrToSelf : public base::RefCounted<ScopedRefPtrToSelf> {
  38  public:
  39   ScopedRefPtrToSelf() : self_ptr_(this) {}
  40
  41   static bool was_destroyed() { return was_destroyed_; }
  42
  43   void SelfDestruct() { self_ptr_ = NULL; }
  44
  45  private:
  46   friend class base::RefCounted<ScopedRefPtrToSelf>;
  47   ~ScopedRefPtrToSelf() { was_destroyed_ = true; }
  48
  49   static bool was_destroyed_;
  50
  51   scoped_refptr<ScopedRefPtrToSelf> self_ptr_;
  52 };
  53
  54 bool ScopedRefPtrToSelf::was_destroyed_ = false;
  55
  56 }  // end namespace
  57
  58 TEST(RefCountedUnitTest, TestSelfAssignment) {
  59   SelfAssign* p = new SelfAssign;
  60   scoped_refptr<SelfAssign> var(p);
  61   var = var;
  62   EXPECT_EQ(var.get(), p);
  63 }
  64
  65 TEST(RefCountedUnitTest, ScopedRefPtrMemberAccess) {
  66   CheckDerivedMemberAccess check;
  67 }
  68
  69 TEST(RefCountedUnitTest, ScopedRefPtrToSelf) {
  70   ScopedRefPtrToSelf* check = new ScopedRefPtrToSelf();
  71   EXPECT_FALSE(ScopedRefPtrToSelf::was_destroyed());
  72   check->SelfDestruct();
  73   EXPECT_TRUE(ScopedRefPtrToSelf::was_destroyed());
  74 }
  75
  76 TEST(RefCountedUnitTest, ScopedRefPtrToOpaque) {
  77   scoped_refptr<base::OpaqueRefCounted> p = base::MakeOpaqueRefCounted();
  78   base::TestOpaqueRefCounted(p);
  79
  80   scoped_refptr<base::OpaqueRefCounted> q;
  81   q = p;
  82   base::TestOpaqueRefCounted(p);
  83   base::TestOpaqueRefCounted(q);
  84 }
  85
  86 TEST(RefCountedUnitTest, BooleanTesting) {
  87   scoped_refptr<SelfAssign> p;
  88   EXPECT_FALSE(p);
  89   p = new SelfAssign;
  90   EXPECT_TRUE(p);
  91 }
  92
  93 TEST(RefCountedUnitTest, Equality) {
  94   scoped_refptr<SelfAssign> p1(new SelfAssign);
  95   scoped_refptr<SelfAssign> p2(new SelfAssign);
  96
  97   EXPECT_EQ(p1, p1);
  98   EXPECT_EQ(p2, p2);
  99
 100   EXPECT_NE(p1, p2);
 101   EXPECT_NE(p2, p1);
 102 }
 103
 104 TEST(RefCountedUnitTest, ConvertibleEquality) {
 105   scoped_refptr<Derived> p1(new Derived);
 106   scoped_refptr<SelfAssign> p2;
 107
 108   EXPECT_NE(p1, p2);
 109   EXPECT_NE(p2, p1);
 110
 111   p2 = p1;
 112
 113   EXPECT_EQ(p1, p2);
 114   EXPECT_EQ(p2, p1);
 115 }