base/bind_unittest.nc

   1 // Copyright (c) 2011 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/callback.h"
   6 #include "base/bind.h"
   7 #include "base/memory/ref_counted.h"
   8
   9 namespace base {
  10
  11 // Do not put everything inside an anonymous namespace.  If you do, many of the
  12 // helper function declarations will generate unused definition warnings.
  13
  14 static const int kParentValue = 1;
  15 static const int kChildValue = 2;
  16
  17 class NoRef {
  18  public:
  19   void VoidMethod0() {}
  20   void VoidConstMethod0() const {}
  21   int IntMethod0() { return 1; }
  22 };
  23
  24 class HasRef : public NoRef, public base::RefCounted<HasRef> {
  25 };
  26
  27 class Parent {
  28  public:
  29   void AddRef(void) const {}
  30   void Release(void) const {}
  31   virtual void VirtualSet() { value = kParentValue; }
  32   void NonVirtualSet() { value = kParentValue; }
  33   int value;
  34 };
  35
  36 class Child : public Parent {
  37  public:
  38   virtual void VirtualSet() { value = kChildValue; }
  39   void NonVirtualSet() { value = kChildValue; }
  40 };
  41
  42 class NoRefParent {
  43  public:
  44   virtual void VirtualSet() { value = kParentValue; }
  45   void NonVirtualSet() { value = kParentValue; }
  46   int value;
  47 };
  48
  49 class NoRefChild : public NoRefParent {
  50   virtual void VirtualSet() { value = kChildValue; }
  51   void NonVirtualSet() { value = kChildValue; }
  52 };
  53
  54 template <typename T>
  55 T PolymorphicIdentity(T t) {
  56   return t;
  57 }
  58
  59 int UnwrapParentRef(Parent& p) {
  60   return p.value;
  61 }
  62
  63 template <typename T>
  64 void VoidPolymorphic1(T t) {
  65 }
  66
  67 #if defined(NCTEST_METHOD_ON_CONST_OBJECT)  // [r"invalid conversion from 'const base::NoRef\*' to 'base::NoRef\*'"]
  68
  69 // Method bound to const-object.
  70 //
  71 // Only const methods should be allowed to work with const objects.
  72 void WontCompile() {
  73   HasRef has_ref;
  74   const HasRef* const_has_ref_ptr_ = &has_ref;
  75   Callback<void(void)> method_to_const_cb =
  76       Bind(&HasRef::VoidMethod0, const_has_ref_ptr_);
  77   method_to_const_cb.Run();
  78 }
  79
  80 #elif defined(NCTEST_METHOD_BIND_NEEDS_REFCOUNTED_OBJECT)  // [r"has no member named 'AddRef'"]
  81
  82 // Method bound to non-refcounted object.
  83 //
  84 // We require refcounts unless you have Unretained().
  85 void WontCompile() {
  86   NoRef no_ref;
  87   Callback<void(void)> no_ref_cb =
  88       Bind(&NoRef::VoidMethod0, &no_ref);
  89   no_ref_cb.Run();
  90 }
  91
  92 #elif defined(NCTEST_CONST_METHOD_NEEDS_REFCOUNTED_OBJECT)  // [r"has no member named 'AddRef'"]
  93
  94 // Const Method bound to non-refcounted object.
  95 //
  96 // We require refcounts unless you have Unretained().
  97 void WontCompile() {
  98   NoRef no_ref;
  99   Callback<void(void)> no_ref_const_cb =
 100       Bind(&NoRef::VoidConstMethod0, &no_ref);
 101   no_ref_const_cb.Run();
 102 }
 103
 104 #elif defined(NCTEST_CONST_POINTER)  // [r"invalid conversion from 'const base::NoRef\*' to 'base::NoRef\*'"]
 105
 106 // Const argument used with non-const pointer parameter of same type.
 107 //
 108 // This is just a const-correctness check.
 109 void WontCompile() {
 110   const NoRef* const_no_ref_ptr;
 111   Callback<NoRef*(void)> pointer_same_cb =
 112       Bind(&PolymorphicIdentity<NoRef*>, const_no_ref_ptr);
 113   pointer_same_cb.Run();
 114 }
 115
 116 #elif defined(NCTEST_CONST_POINTER_SUBTYPE)  // [r"'const base::NoRefParent\*' to 'base::NoRefParent\*'"]
 117
 118 // Const argument used with non-const pointer parameter of super type.
 119 //
 120 // This is just a const-correctness check.
 121 void WontCompile() {
 122   const NoRefChild* const_child_ptr;
 123   Callback<NoRefParent*(void)> pointer_super_cb =
 124     Bind(&PolymorphicIdentity<NoRefParent*>, const_child_ptr);
 125   pointer_super_cb.Run();
 126 }
 127
 128 #elif defined(DISABLED_NCTEST_DISALLOW_NON_CONST_REF_PARAM)  // [r"badstring"]
 129 // I think there's a type safety promotion issue here where we can pass a const
 130 // ref to a non const-ref function, or vice versa accidentally. Or we make a
 131 // copy accidentally. Check.
 132
 133 // Functions with reference parameters, unsupported.
 134 //
 135 // First, non-const reference parameters are disallowed by the Google
 136 // style guide. Second, since we are doing argument forwarding it becomes
 137 // very tricky to avoid copies, maintain const correctness, and not
 138 // accidentally have the function be modifying a temporary, or a copy.
 139 void WontCompile() {
 140   Parent p;
 141   Callback<int(Parent&)> ref_arg_cb = Bind(&UnwrapParentRef);
 142   ref_arg_cb.Run(p);
 143 }
 144
 145 #elif defined(NCTEST_DISALLOW_BIND_TO_NON_CONST_REF_PARAM)  // [r"size of array is negative"]
 146
 147 // Binding functions with reference parameters, unsupported.
 148 //
 149 // See comment in NCTEST_DISALLOW_NON_CONST_REF_PARAM
 150 void WontCompile() {
 151   Parent p;
 152   Callback<int(void)> ref_cb = Bind(&UnwrapParentRef, p);
 153   ref_cb.Run();
 154 }
 155
 156 #elif defined(NCTEST_NO_IMPLICIT_ARRAY_PTR_CONVERSION)  // [r"size of array is negative"]
 157
 158 // A method should not be bindable with an array of objects.
 159 //
 160 // This is likely not wanted behavior. We specifically check for it though
 161 // because it is possible, depending on how you implement prebinding, to
 162 // implicitly convert an array type to a pointer type.
 163 void WontCompile() {
 164   HasRef p[10];
 165   Callback<void(void)> method_bound_to_array_cb =
 166       Bind(&HasRef::VoidMethod0, p);
 167   method_bound_to_array_cb.Run();
 168 }
 169
 170 #elif defined(NCTEST_NO_RAW_PTR_FOR_REFCOUNTED_TYPES)  // [r"size of array is negative"]
 171
 172 // Refcounted types should not be bound as a raw pointer.
 173 void WontCompile() {
 174   HasRef for_raw_ptr;
 175   int a;
 176   Callback<void(void)> ref_count_as_raw_ptr_a =
 177       Bind(&VoidPolymorphic1<int*>, &a);
 178   Callback<void(void)> ref_count_as_raw_ptr =
 179       Bind(&VoidPolymorphic1<HasRef*>, &for_raw_ptr);
 180 }
 181
 182 #elif defined(NCTEST_WEAKPTR_BIND_MUST_RETURN_VOID)  // [r"size of array is negative"]
 183
 184 // WeakPtrs cannot be bound to methods with return types.
 185 void WontCompile() {
 186   NoRef no_ref;
 187   WeakPtrFactory<NoRef> weak_factory(&no_ref);
 188   Callback<int(void)> weak_ptr_with_non_void_return_type =
 189       Bind(&NoRef::IntMethod0, weak_factory.GetWeakPtr());
 190   weak_ptr_with_non_void_return_type.Run();
 191 }
 192
 193 #elif defined(NCTEST_DISALLOW_ASSIGN_DIFFERENT_TYPES)  // [r"conversion from 'base::Callback<void\(int\)>' to non-scalar type"]
 194
 195 // Bind result cannot be assigned to Callbacks with a mismatching type.
 196 void WontCompile() {
 197   Closure callback_mismatches_bind_type = Bind(&VoidPolymorphic1<int>);
 198 }
 199
 200 #endif
 201
 202 }  // namespace base