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 // This is a "No Compile Test" suite.
   6 // http://dev.chromium.org/developers/testing/no-compile-tests
   7
   8 #include <utility>
   9
  10 #include "base/bind.h"
  11 #include "base/callback.h"
  12 #include "base/macros.h"
  13 #include "base/memory/ref_counted.h"
  14 #include "base/test/bind_test_util.h"
  15
  16 namespace base {
  17
  18 // Do not put everything inside an anonymous namespace.  If you do, many of the
  19 // helper function declarations will generate unused definition warnings.
  20
  21 static const int kParentValue = 1;
  22 static const int kChildValue = 2;
  23
  24 class NoRef {
  25  public:
  26   void VoidMethod0() {}
  27   void VoidConstMethod0() const {}
  28   int IntMethod0() { return 1; }
  29 };
  30
  31 class HasRef : public NoRef, public base::RefCounted<HasRef> {
  32 };
  33
  34 class Parent {
  35  public:
  36   void AddRef() const {}
  37   void Release() const {}
  38   virtual void VirtualSet() { value = kParentValue; }
  39   void NonVirtualSet() { value = kParentValue; }
  40   int value;
  41 };
  42
  43 class Child : public Parent {
  44  public:
  45   virtual void VirtualSet() { value = kChildValue; }
  46   void NonVirtualSet() { value = kChildValue; }
  47 };
  48
  49 class NoRefParent {
  50  public:
  51   virtual void VirtualSet() { value = kParentValue; }
  52   void NonVirtualSet() { value = kParentValue; }
  53   int value;
  54 };
  55
  56 class NoRefChild : public NoRefParent {
  57   virtual void VirtualSet() { value = kChildValue; }
  58   void NonVirtualSet() { value = kChildValue; }
  59 };
  60
  61 template <typename T>
  62 T PolymorphicIdentity(T t) {
  63   return t;
  64 }
  65
  66 int UnwrapParentRef(Parent& p) {
  67   return p.value;
  68 }
  69
  70 template <typename T>
  71 void VoidPolymorphic1(T t) {
  72 }
  73
  74 void TakesMoveOnly(std::unique_ptr<int>) {
  75 }
  76
  77 struct NonEmptyFunctor {
  78   int x;
  79   void operator()() const {}
  80 };
  81
  82 #if defined(NCTEST_METHOD_ON_CONST_OBJECT)  // [r"fatal error: static_assert failed due to requirement 'param_is_forwardable' \"Bound argument |i| of type |Arg| cannot be forwarded as |Unwrapped| to the bound functor, which declares it as |Param|.\""]
  83 // Method bound to const-object.
  84 //
  85 // Only const methods should be allowed to work with const objects.
  86 void WontCompile() {
  87   HasRef has_ref;
  88   const HasRef* const_has_ref_ptr_ = &has_ref;
  89   Callback<void()> method_to_const_cb =
  90       Bind(&HasRef::VoidMethod0, const_has_ref_ptr_);
  91   method_to_const_cb.Run();
  92 }
  93
  94 #elif defined(NCTEST_METHOD_BIND_NEEDS_REFCOUNTED_OBJECT)  // [r"fatal error: static_assert failed due to requirement '!std::is_pointer<base::NoRef *>::value || IsRefCountedType<base::NoRef, void>::value' \"Receivers may not be raw pointers. If using a raw pointer here is safe and has no lifetime concerns, use base::Unretained() and document why it's safe.\""]
  95
  96
  97 // Method bound to non-refcounted object.
  98 //
  99 // We require refcounts unless you have Unretained().
 100 void WontCompile() {
 101   NoRef no_ref;
 102   Callback<void()> no_ref_cb =
 103       Bind(&NoRef::VoidMethod0, &no_ref);
 104   no_ref_cb.Run();
 105 }
 106
 107 #elif defined(NCTEST_CONST_METHOD_NEEDS_REFCOUNTED_OBJECT)  // [r"fatal error: static_assert failed due to requirement '!std::is_pointer<base::NoRef *>::value || IsRefCountedType<base::NoRef, void>::value' \"Receivers may not be raw pointers. If using a raw pointer here is safe and has no lifetime concerns, use base::Unretained() and document why it's safe.\""]
 108
 109 // Const Method bound to non-refcounted object.
 110 //
 111 // We require refcounts unless you have Unretained().
 112 void WontCompile() {
 113   NoRef no_ref;
 114   Callback<void()> no_ref_const_cb =
 115       Bind(&NoRef::VoidConstMethod0, &no_ref);
 116   no_ref_const_cb.Run();
 117 }
 118
 119 #elif defined(NCTEST_CONST_POINTER)  // [r"fatal error: static_assert failed due to requirement 'param_is_forwardable' \"Bound argument |i| of type |Arg| cannot be forwarded as |Unwrapped| to the bound functor, which declares it as |Param|.\""]
 120
 121 // Const argument used with non-const pointer parameter of same type.
 122 //
 123 // This is just a const-correctness check.
 124 void WontCompile() {
 125   const NoRef* const_no_ref_ptr;
 126   Callback<NoRef*()> pointer_same_cb =
 127       Bind(&PolymorphicIdentity<NoRef*>, const_no_ref_ptr);
 128   pointer_same_cb.Run();
 129 }
 130
 131 #elif defined(NCTEST_CONST_POINTER_SUBTYPE)  // [r"fatal error: static_assert failed due to requirement 'param_is_forwardable' \"Bound argument |i| of type |Arg| cannot be forwarded as |Unwrapped| to the bound functor, which declares it as |Param|.\""]
 132
 133 // Const argument used with non-const pointer parameter of super type.
 134 //
 135 // This is just a const-correctness check.
 136 void WontCompile() {
 137   const NoRefChild* const_child_ptr;
 138   Callback<NoRefParent*()> pointer_super_cb =
 139     Bind(&PolymorphicIdentity<NoRefParent*>, const_child_ptr);
 140   pointer_super_cb.Run();
 141 }
 142
 143 #elif defined(DISABLED_NCTEST_DISALLOW_NON_CONST_REF_PARAM)  // [r"fatal error: no member named 'AddRef' in 'base::NoRef'"]
 144 // TODO(dcheng): I think there's a type safety promotion issue here where we can
 145 // pass a const ref to a non const-ref function, or vice versa accidentally. Or
 146 // we make a copy accidentally. Check.
 147
 148 // Functions with reference parameters, unsupported.
 149 //
 150 // First, non-const reference parameters are disallowed by the Google
 151 // style guide. Second, since we are doing argument forwarding it becomes
 152 // very tricky to avoid copies, maintain const correctness, and not
 153 // accidentally have the function be modifying a temporary, or a copy.
 154 void WontCompile() {
 155   Parent p;
 156   Callback<int(Parent&)> ref_arg_cb = Bind(&UnwrapParentRef);
 157   ref_arg_cb.Run(p);
 158 }
 159
 160 #elif defined(NCTEST_DISALLOW_BIND_TO_NON_CONST_REF_PARAM)  // [r"fatal error: static_assert failed due to requirement 'param_is_forwardable' \"Bound argument |i| of type |Arg| cannot be forwarded as |Unwrapped| to the bound functor, which declares it as |Param|.\""]
 161
 162 // Binding functions with reference parameters, unsupported.
 163 //
 164 // See comment in NCTEST_DISALLOW_NON_CONST_REF_PARAM
 165 void WontCompile() {
 166   Parent p;
 167   Callback<int()> ref_cb = Bind(&UnwrapParentRef, p);
 168   ref_cb.Run();
 169 }
 170
 171 #elif defined(NCTEST_NO_IMPLICIT_ARRAY_PTR_CONVERSION)  // [r"fatal error: static_assert failed due to requirement '!std::is_array<base::HasRef \[10\]>::value' \"First bound argument to a method cannot be an array.\""]
 172
 173 // A method should not be bindable with an array of objects.
 174 //
 175 // This is likely not wanted behavior. We specifically check for it though
 176 // because it is possible, depending on how you implement prebinding, to
 177 // implicitly convert an array type to a pointer type.
 178 void WontCompile() {
 179   HasRef p[10];
 180   Callback<void()> method_bound_to_array_cb =
 181       Bind(&HasRef::VoidMethod0, p);
 182   method_bound_to_array_cb.Run();
 183 }
 184
 185 #elif defined(NCTEST_NO_RVALUE_RAW_PTR_FOR_REFCOUNTED_TYPES)  // [r"fatal error: static_assert failed due to requirement '!HasRefCountedTypeAsRawPtr<base::HasRef \*>::value' \"A parameter is a refcounted type and needs scoped_refptr.\""]
 186
 187 // Refcounted types should not be bound as a raw pointer.
 188 void WontCompile() {
 189   HasRef for_raw_ptr;
 190   int a;
 191   Callback<void()> ref_count_as_raw_ptr_a =
 192       Bind(&VoidPolymorphic1<int*>, &a);
 193   Callback<void()> ref_count_as_raw_ptr =
 194       Bind(&VoidPolymorphic1<HasRef*>, &for_raw_ptr);
 195 }
 196
 197 #elif defined(NCTEST_NO_LVALUE_RAW_PTR_FOR_REFCOUNTED_TYPES)  // [r"fatal error: static_assert failed due to requirement '!HasRefCountedTypeAsRawPtr<base::HasRef \*>::value' \"A parameter is a refcounted type and needs scoped_refptr.\""]
 198
 199 // Refcounted types should not be bound as a raw pointer.
 200 void WontCompile() {
 201   HasRef* for_raw_ptr = nullptr;
 202   Callback<void()> ref_count_as_raw_ptr =
 203       Bind(&VoidPolymorphic1<HasRef*>, for_raw_ptr);
 204 }
 205
 206 #elif defined(NCTEST_NO_RVALUE_CONST_RAW_PTR_FOR_REFCOUNTED_TYPES)  // [r"fatal error: static_assert failed due to requirement '!HasRefCountedTypeAsRawPtr<const base::HasRef \*>::value' \"A parameter is a refcounted type and needs scoped_refptr.\""]
 207
 208 // Refcounted types should not be bound as a raw pointer.
 209 void WontCompile() {
 210   const HasRef for_raw_ptr;
 211   Callback<void()> ref_count_as_raw_ptr =
 212       Bind(&VoidPolymorphic1<const HasRef*>, &for_raw_ptr);
 213 }
 214
 215 #elif defined(NCTEST_NO_LVALUE_CONST_RAW_PTR_FOR_REFCOUNTED_TYPES)  // [r"fatal error: static_assert failed due to requirement '!HasRefCountedTypeAsRawPtr<const base::HasRef \*>::value' \"A parameter is a refcounted type and needs scoped_refptr.\""]
 216
 217 // Refcounted types should not be bound as a raw pointer.
 218 void WontCompile() {
 219   const HasRef* for_raw_ptr = nullptr;
 220   Callback<void()> ref_count_as_raw_ptr =
 221       Bind(&VoidPolymorphic1<const HasRef*>, for_raw_ptr);
 222 }
 223
 224 #elif defined(NCTEST_WEAKPTR_BIND_MUST_RETURN_VOID)  // [r"fatal error: static_assert failed due to requirement 'std::is_void<int>::value' \"weak_ptrs can only bind to methods without return values\""]
 225
 226 // WeakPtrs cannot be bound to methods with return types.
 227 void WontCompile() {
 228   NoRef no_ref;
 229   WeakPtrFactory<NoRef> weak_factory(&no_ref);
 230   Callback<int()> weak_ptr_with_non_void_return_type =
 231       Bind(&NoRef::IntMethod0, weak_factory.GetWeakPtr());
 232   weak_ptr_with_non_void_return_type.Run();
 233 }
 234
 235 #elif defined(NCTEST_DISALLOW_ASSIGN_DIFFERENT_TYPES)  // [r"fatal error: no viable conversion from 'Callback<MakeUnboundRunType<void \(\*\)\(int\)>>' to 'Callback<void \(\)>'"]
 236
 237 // Bind result cannot be assigned to Callbacks with a mismatching type.
 238 void WontCompile() {
 239   Closure callback_mismatches_bind_type = Bind(&VoidPolymorphic1<int>);
 240 }
 241
 242 #elif defined(NCTEST_DISALLOW_CAPTURING_LAMBDA)  // [r"fatal error: implicit instantiation of undefined template 'base::internal::FunctorTraits<\(lambda at (\.\./)+base/bind_unittest.nc:[0-9]+:[0-9]+\), void>'"]
 243
 244 void WontCompile() {
 245   int i = 0, j = 0;
 246   Bind([i,&j]() {j = i;});
 247 }
 248
 249 #elif defined(NCTEST_DISALLOW_ONCECALLBACK_RUN_ON_LVALUE)  // [r"fatal error: static_assert failed due to requirement '!sizeof \(\*this\)' \"OnceCallback::Run\(\) may only be invoked on a non-const rvalue, i\.e\. std::move\(callback\).Run\(\).\""]
 250
 251 void WontCompile() {
 252   OnceClosure cb = Bind([] {});
 253   cb.Run();
 254 }
 255
 256 #elif defined(NCTEST_DISALLOW_ONCECALLBACK_RUN_ON_CONST_LVALUE)  // [r"fatal error: static_assert failed due to requirement '!sizeof \(\*this\)' \"OnceCallback::Run\(\) may only be invoked on a non-const rvalue, i\.e\. std::move\(callback\).Run\(\).\""]
 257
 258 void WontCompile() {
 259   const OnceClosure cb = Bind([] {});
 260   cb.Run();
 261 }
 262
 263 #elif defined(NCTEST_DISALLOW_ONCECALLBACK_RUN_ON_CONST_RVALUE)  // [r"fatal error: static_assert failed due to requirement '!sizeof \(\*this\)' \"OnceCallback::Run\(\) may only be invoked on a non-const rvalue, i\.e\. std::move\(callback\).Run\(\).\""]
 264
 265 void WontCompile() {
 266   const OnceClosure cb = Bind([] {});
 267   std::move(cb).Run();
 268 }
 269
 270 #elif defined(NCTEST_DISALLOW_BIND_ONCECALLBACK)  // [r"fatal error: static_assert failed due to requirement '!base::internal::IsOnceCallback<base::OnceCallback<void \(int\)> >\(\)' \"BindRepeating cannot bind OnceCallback. Use BindOnce with std::move\(\).\""]
 271
 272 void WontCompile() {
 273   Bind(BindOnce([](int) {}), 42);
 274 }
 275
 276 #elif defined(NCTEST_DISALLOW_BINDONCE_LVALUE_ONCECALLBACK)  // [r"fatal error: static_assert failed due to requirement '!internal::IsOnceCallback<std::decay_t<OnceCallback<void (int)> &> >() || (std::is_rvalue_reference<OnceCallback<void (int)> &>() && !std::is_const<std::remove_reference_t<OnceCallback<void (int)> &> >())' \"BindOnce requires non-const rvalue for OnceCallback binding. I.e.: base::BindOnce(std::move(callback)).\""]
 277 void WontCompile() {
 278   auto cb = BindOnce([](int) {});
 279   BindOnce(cb, 42);
 280 }
 281
 282 #elif defined(NCTEST_DISALLOW_BINDONCE_RVALUE_CONST_ONCECALLBACK)  // [r"fatal error: static_assert failed due to requirement '!internal::IsOnceCallback<std::decay_t<const OnceCallback<void (int)> > >() || (std::is_rvalue_reference<const OnceCallback<void (int)> &&>() && !std::is_const<std::remove_reference_t<const OnceCallback<void (int)> > >())' \"BindOnce requires non-const rvalue for OnceCallback binding. I.e.: base::BindOnce(std::move(callback)).\""]
 283
 284 void WontCompile() {
 285   const auto cb = BindOnce([](int) {});
 286   BindOnce(std::move(cb), 42);
 287 }
 288
 289 #elif defined(NCTEST_BINDONCE_MOVEONLY_TYPE_BY_VALUE)  // [r"fatal error: static_assert failed due to requirement 'arg_is_storable || !std::is_constructible<std::__1::unique_ptr<int, std::__1::default_delete<int> >, std::__1::unique_ptr<int, std::__1::default_delete<int> > &&>::value' \"Bound argument |i| is move-only but will be bound by copy. Ensure |Arg| is mutable and bound using std::move\(\).\""]
 290
 291 void WontCompile() {
 292   std::unique_ptr<int> x;
 293   BindOnce(&TakesMoveOnly, x);
 294 }
 295
 296 #elif defined(NCTEST_BIND_MOVEONLY_TYPE_BY_VALUE)  // [r"Bound argument \|i\| is move-only but will be forwarded by copy\. Ensure \|Arg\| is bound using base::Passed\(\), not std::move\(\)."]
 297
 298 void WontCompile() {
 299   std::unique_ptr<int> x;
 300   Bind(&TakesMoveOnly, x);
 301 }
 302
 303 #elif defined(NCTEST_BIND_MOVEONLY_TYPE_WITH_STDMOVE)  // [r"Bound argument \|i\| is move-only but will be forwarded by copy\. Ensure \|Arg\| is bound using base::Passed\(\), not std::move\(\)."]
 304
 305 void WontCompile() {
 306   std::unique_ptr<int> x;
 307   Bind(&TakesMoveOnly, std::move(x));
 308 }
 309
 310 #elif defined(NCTEST_BIND_NON_EMPTY_FUNCTOR)  // [r"fatal error: implicit instantiation of undefined template 'base::internal::FunctorTraits<base::NonEmptyFunctor, void>'"]
 311
 312 void WontCompile() {
 313   Bind(NonEmptyFunctor());
 314 }
 315
 316 #endif
 317
 318 }  // namespace base