| OLD | NEW |
|---|
| (Empty) |
| 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/bind.h" | |
| 6 | |
| 7 #include "base/callback.h" | |
| 8 #include "base/memory/ref_counted.h" | |
| 9 #include "base/memory/scoped_ptr.h" | |
| 10 #include "base/memory/weak_ptr.h" | |
| 11 #include "testing/gmock/include/gmock/gmock.h" | |
| 12 #include "testing/gtest/include/gtest/gtest.h" | |
| 13 | |
| 14 using ::testing::Mock; | |
| 15 using ::testing::Return; | |
| 16 using ::testing::StrictMock; | |
| 17 | |
| 18 namespace base { | |
| 19 namespace { | |
| 20 | |
| 21 class IncompleteType; | |
| 22 | |
| 23 class NoRef { | |
| 24 public: | |
| 25 NoRef() {} | |
| 26 | |
| 27 MOCK_METHOD0(VoidMethod0, void(void)); | |
| 28 MOCK_CONST_METHOD0(VoidConstMethod0, void(void)); | |
| 29 | |
| 30 MOCK_METHOD0(IntMethod0, int(void)); | |
| 31 MOCK_CONST_METHOD0(IntConstMethod0, int(void)); | |
| 32 | |
| 33 private: | |
| 34 // Particularly important in this test to ensure no copies are made. | |
| 35 DISALLOW_COPY_AND_ASSIGN(NoRef); | |
| 36 }; | |
| 37 | |
| 38 class HasRef : public NoRef { | |
| 39 public: | |
| 40 HasRef() {} | |
| 41 | |
| 42 MOCK_CONST_METHOD0(AddRef, void(void)); | |
| 43 MOCK_CONST_METHOD0(Release, bool(void)); | |
| 44 | |
| 45 private: | |
| 46 // Particularly important in this test to ensure no copies are made. | |
| 47 DISALLOW_COPY_AND_ASSIGN(HasRef); | |
| 48 }; | |
| 49 | |
| 50 class HasRefPrivateDtor : public HasRef { | |
| 51 private: | |
| 52 ~HasRefPrivateDtor() {} | |
| 53 }; | |
| 54 | |
| 55 static const int kParentValue = 1; | |
| 56 static const int kChildValue = 2; | |
| 57 | |
| 58 class Parent { | |
| 59 public: | |
| 60 void AddRef(void) const {} | |
| 61 void Release(void) const {} | |
| 62 virtual void VirtualSet() { value = kParentValue; } | |
| 63 void NonVirtualSet() { value = kParentValue; } | |
| 64 int value; | |
| 65 }; | |
| 66 | |
| 67 class Child : public Parent { | |
| 68 public: | |
| 69 void VirtualSet() override { value = kChildValue; } | |
| 70 void NonVirtualSet() { value = kChildValue; } | |
| 71 }; | |
| 72 | |
| 73 class NoRefParent { | |
| 74 public: | |
| 75 virtual void VirtualSet() { value = kParentValue; } | |
| 76 void NonVirtualSet() { value = kParentValue; } | |
| 77 int value; | |
| 78 }; | |
| 79 | |
| 80 class NoRefChild : public NoRefParent { | |
| 81 void VirtualSet() override { value = kChildValue; } | |
| 82 void NonVirtualSet() { value = kChildValue; } | |
| 83 }; | |
| 84 | |
| 85 // Used for probing the number of copies that occur if a type must be coerced | |
| 86 // during argument forwarding in the Run() methods. | |
| 87 struct DerivedCopyCounter { | |
| 88 DerivedCopyCounter(int* copies, int* assigns) | |
| 89 : copies_(copies), assigns_(assigns) { | |
| 90 } | |
| 91 int* copies_; | |
| 92 int* assigns_; | |
| 93 }; | |
| 94 | |
| 95 // Used for probing the number of copies in an argument. | |
| 96 class CopyCounter { | |
| 97 public: | |
| 98 CopyCounter(int* copies, int* assigns) | |
| 99 : copies_(copies), assigns_(assigns) { | |
| 100 } | |
| 101 | |
| 102 CopyCounter(const CopyCounter& other) | |
| 103 : copies_(other.copies_), | |
| 104 assigns_(other.assigns_) { | |
| 105 (*copies_)++; | |
| 106 } | |
| 107 | |
| 108 // Probing for copies from coercion. | |
| 109 explicit CopyCounter(const DerivedCopyCounter& other) | |
| 110 : copies_(other.copies_), | |
| 111 assigns_(other.assigns_) { | |
| 112 (*copies_)++; | |
| 113 } | |
| 114 | |
| 115 const CopyCounter& operator=(const CopyCounter& rhs) { | |
| 116 copies_ = rhs.copies_; | |
| 117 assigns_ = rhs.assigns_; | |
| 118 | |
| 119 if (assigns_) { | |
| 120 (*assigns_)++; | |
| 121 } | |
| 122 | |
| 123 return *this; | |
| 124 } | |
| 125 | |
| 126 int copies() const { | |
| 127 return *copies_; | |
| 128 } | |
| 129 | |
| 130 private: | |
| 131 int* copies_; | |
| 132 int* assigns_; | |
| 133 }; | |
| 134 | |
| 135 class DeleteCounter { | |
| 136 public: | |
| 137 explicit DeleteCounter(int* deletes) | |
| 138 : deletes_(deletes) { | |
| 139 } | |
| 140 | |
| 141 ~DeleteCounter() { | |
| 142 (*deletes_)++; | |
| 143 } | |
| 144 | |
| 145 void VoidMethod0() {} | |
| 146 | |
| 147 private: | |
| 148 int* deletes_; | |
| 149 }; | |
| 150 | |
| 151 template <typename T> | |
| 152 T PassThru(T scoper) { | |
| 153 return scoper.Pass(); | |
| 154 } | |
| 155 | |
| 156 // Some test functions that we can Bind to. | |
| 157 template <typename T> | |
| 158 T PolymorphicIdentity(T t) { | |
| 159 return t; | |
| 160 } | |
| 161 | |
| 162 template <typename T> | |
| 163 void VoidPolymorphic1(T t) { | |
| 164 } | |
| 165 | |
| 166 int Identity(int n) { | |
| 167 return n; | |
| 168 } | |
| 169 | |
| 170 int ArrayGet(const int array[], int n) { | |
| 171 return array[n]; | |
| 172 } | |
| 173 | |
| 174 int Sum(int a, int b, int c, int d, int e, int f) { | |
| 175 return a + b + c + d + e + f; | |
| 176 } | |
| 177 | |
| 178 const char* CStringIdentity(const char* s) { | |
| 179 return s; | |
| 180 } | |
| 181 | |
| 182 int GetCopies(const CopyCounter& counter) { | |
| 183 return counter.copies(); | |
| 184 } | |
| 185 | |
| 186 int UnwrapNoRefParent(NoRefParent p) { | |
| 187 return p.value; | |
| 188 } | |
| 189 | |
| 190 int UnwrapNoRefParentPtr(NoRefParent* p) { | |
| 191 return p->value; | |
| 192 } | |
| 193 | |
| 194 int UnwrapNoRefParentConstRef(const NoRefParent& p) { | |
| 195 return p.value; | |
| 196 } | |
| 197 | |
| 198 void RefArgSet(int &n) { | |
| 199 n = 2; | |
| 200 } | |
| 201 | |
| 202 void PtrArgSet(int *n) { | |
| 203 *n = 2; | |
| 204 } | |
| 205 | |
| 206 int FunctionWithWeakFirstParam(WeakPtr<NoRef> o, int n) { | |
| 207 return n; | |
| 208 } | |
| 209 | |
| 210 int FunctionWithScopedRefptrFirstParam(const scoped_refptr<HasRef>& o, int n) { | |
| 211 return n; | |
| 212 } | |
| 213 | |
| 214 void TakesACallback(const Closure& callback) { | |
| 215 callback.Run(); | |
| 216 } | |
| 217 | |
| 218 class BindTest : public ::testing::Test { | |
| 219 public: | |
| 220 BindTest() { | |
| 221 const_has_ref_ptr_ = &has_ref_; | |
| 222 const_no_ref_ptr_ = &no_ref_; | |
| 223 static_func_mock_ptr = &static_func_mock_; | |
| 224 } | |
| 225 | |
| 226 virtual ~BindTest() { | |
| 227 } | |
| 228 | |
| 229 static void VoidFunc0(void) { | |
| 230 static_func_mock_ptr->VoidMethod0(); | |
| 231 } | |
| 232 | |
| 233 static int IntFunc0(void) { return static_func_mock_ptr->IntMethod0(); } | |
| 234 | |
| 235 protected: | |
| 236 StrictMock<NoRef> no_ref_; | |
| 237 StrictMock<HasRef> has_ref_; | |
| 238 const HasRef* const_has_ref_ptr_; | |
| 239 const NoRef* const_no_ref_ptr_; | |
| 240 StrictMock<NoRef> static_func_mock_; | |
| 241 | |
| 242 // Used by the static functions to perform expectations. | |
| 243 static StrictMock<NoRef>* static_func_mock_ptr; | |
| 244 | |
| 245 private: | |
| 246 DISALLOW_COPY_AND_ASSIGN(BindTest); | |
| 247 }; | |
| 248 | |
| 249 StrictMock<NoRef>* BindTest::static_func_mock_ptr; | |
| 250 | |
| 251 // Sanity check that we can instantiate a callback for each arity. | |
| 252 TEST_F(BindTest, ArityTest) { | |
| 253 Callback<int(void)> c0 = Bind(&Sum, 32, 16, 8, 4, 2, 1); | |
| 254 EXPECT_EQ(63, c0.Run()); | |
| 255 | |
| 256 Callback<int(int)> c1 = Bind(&Sum, 32, 16, 8, 4, 2); | |
| 257 EXPECT_EQ(75, c1.Run(13)); | |
| 258 | |
| 259 Callback<int(int,int)> c2 = Bind(&Sum, 32, 16, 8, 4); | |
| 260 EXPECT_EQ(85, c2.Run(13, 12)); | |
| 261 | |
| 262 Callback<int(int,int,int)> c3 = Bind(&Sum, 32, 16, 8); | |
| 263 EXPECT_EQ(92, c3.Run(13, 12, 11)); | |
| 264 | |
| 265 Callback<int(int,int,int,int)> c4 = Bind(&Sum, 32, 16); | |
| 266 EXPECT_EQ(94, c4.Run(13, 12, 11, 10)); | |
| 267 | |
| 268 Callback<int(int,int,int,int,int)> c5 = Bind(&Sum, 32); | |
| 269 EXPECT_EQ(87, c5.Run(13, 12, 11, 10, 9)); | |
| 270 | |
| 271 Callback<int(int,int,int,int,int,int)> c6 = Bind(&Sum); | |
| 272 EXPECT_EQ(69, c6.Run(13, 12, 11, 10, 9, 14)); | |
| 273 } | |
| 274 | |
| 275 // Test the Currying ability of the Callback system. | |
| 276 TEST_F(BindTest, CurryingTest) { | |
| 277 Callback<int(int,int,int,int,int,int)> c6 = Bind(&Sum); | |
| 278 EXPECT_EQ(69, c6.Run(13, 12, 11, 10, 9, 14)); | |
| 279 | |
| 280 Callback<int(int,int,int,int,int)> c5 = Bind(c6, 32); | |
| 281 EXPECT_EQ(87, c5.Run(13, 12, 11, 10, 9)); | |
| 282 | |
| 283 Callback<int(int,int,int,int)> c4 = Bind(c5, 16); | |
| 284 EXPECT_EQ(94, c4.Run(13, 12, 11, 10)); | |
| 285 | |
| 286 Callback<int(int,int,int)> c3 = Bind(c4, 8); | |
| 287 EXPECT_EQ(92, c3.Run(13, 12, 11)); | |
| 288 | |
| 289 Callback<int(int,int)> c2 = Bind(c3, 4); | |
| 290 EXPECT_EQ(85, c2.Run(13, 12)); | |
| 291 | |
| 292 Callback<int(int)> c1 = Bind(c2, 2); | |
| 293 EXPECT_EQ(75, c1.Run(13)); | |
| 294 | |
| 295 Callback<int(void)> c0 = Bind(c1, 1); | |
| 296 EXPECT_EQ(63, c0.Run()); | |
| 297 } | |
| 298 | |
| 299 // Test that currying the rvalue result of another Bind() works correctly. | |
| 300 // - rvalue should be usable as argument to Bind(). | |
| 301 // - multiple runs of resulting Callback remain valid. | |
| 302 TEST_F(BindTest, CurryingRvalueResultOfBind) { | |
| 303 int n = 0; | |
| 304 Closure cb = base::Bind(&TakesACallback, base::Bind(&PtrArgSet, &n)); | |
| 305 | |
| 306 // If we implement Bind() such that the return value has auto_ptr-like | |
| 307 // semantics, the second call here will fail because ownership of | |
| 308 // the internal BindState<> would have been transfered to a *temporary* | |
| 309 // constructon of a Callback object on the first call. | |
| 310 cb.Run(); | |
| 311 EXPECT_EQ(2, n); | |
| 312 | |
| 313 n = 0; | |
| 314 cb.Run(); | |
| 315 EXPECT_EQ(2, n); | |
| 316 } | |
| 317 | |
| 318 // Function type support. | |
| 319 // - Normal function. | |
| 320 // - Normal function bound with non-refcounted first argument. | |
| 321 // - Method bound to non-const object. | |
| 322 // - Method bound to scoped_refptr. | |
| 323 // - Const method bound to non-const object. | |
| 324 // - Const method bound to const object. | |
| 325 // - Derived classes can be used with pointers to non-virtual base functions. | |
| 326 // - Derived classes can be used with pointers to virtual base functions (and | |
| 327 // preserve virtual dispatch). | |
| 328 TEST_F(BindTest, FunctionTypeSupport) { | |
| 329 EXPECT_CALL(static_func_mock_, VoidMethod0()); | |
| 330 EXPECT_CALL(has_ref_, AddRef()).Times(5); | |
| 331 EXPECT_CALL(has_ref_, Release()).Times(5); | |
| 332 EXPECT_CALL(has_ref_, VoidMethod0()).Times(2); | |
| 333 EXPECT_CALL(has_ref_, VoidConstMethod0()).Times(2); | |
| 334 | |
| 335 Closure normal_cb = Bind(&VoidFunc0); | |
| 336 Callback<NoRef*(void)> normal_non_refcounted_cb = | |
| 337 Bind(&PolymorphicIdentity<NoRef*>, &no_ref_); | |
| 338 normal_cb.Run(); | |
| 339 EXPECT_EQ(&no_ref_, normal_non_refcounted_cb.Run()); | |
| 340 | |
| 341 Closure method_cb = Bind(&HasRef::VoidMethod0, &has_ref_); | |
| 342 Closure method_refptr_cb = Bind(&HasRef::VoidMethod0, | |
| 343 make_scoped_refptr(&has_ref_)); | |
| 344 Closure const_method_nonconst_obj_cb = Bind(&HasRef::VoidConstMethod0, | |
| 345 &has_ref_); | |
| 346 Closure const_method_const_obj_cb = Bind(&HasRef::VoidConstMethod0, | |
| 347 const_has_ref_ptr_); | |
| 348 method_cb.Run(); | |
| 349 method_refptr_cb.Run(); | |
| 350 const_method_nonconst_obj_cb.Run(); | |
| 351 const_method_const_obj_cb.Run(); | |
| 352 | |
| 353 Child child; | |
| 354 child.value = 0; | |
| 355 Closure virtual_set_cb = Bind(&Parent::VirtualSet, &child); | |
| 356 virtual_set_cb.Run(); | |
| 357 EXPECT_EQ(kChildValue, child.value); | |
| 358 | |
| 359 child.value = 0; | |
| 360 Closure non_virtual_set_cb = Bind(&Parent::NonVirtualSet, &child); | |
| 361 non_virtual_set_cb.Run(); | |
| 362 EXPECT_EQ(kParentValue, child.value); | |
| 363 } | |
| 364 | |
| 365 // Return value support. | |
| 366 // - Function with return value. | |
| 367 // - Method with return value. | |
| 368 // - Const method with return value. | |
| 369 TEST_F(BindTest, ReturnValues) { | |
| 370 EXPECT_CALL(static_func_mock_, IntMethod0()).WillOnce(Return(1337)); | |
| 371 EXPECT_CALL(has_ref_, AddRef()).Times(3); | |
| 372 EXPECT_CALL(has_ref_, Release()).Times(3); | |
| 373 EXPECT_CALL(has_ref_, IntMethod0()).WillOnce(Return(31337)); | |
| 374 EXPECT_CALL(has_ref_, IntConstMethod0()) | |
| 375 .WillOnce(Return(41337)) | |
| 376 .WillOnce(Return(51337)); | |
| 377 | |
| 378 Callback<int(void)> normal_cb = Bind(&IntFunc0); | |
| 379 Callback<int(void)> method_cb = Bind(&HasRef::IntMethod0, &has_ref_); | |
| 380 Callback<int(void)> const_method_nonconst_obj_cb = | |
| 381 Bind(&HasRef::IntConstMethod0, &has_ref_); | |
| 382 Callback<int(void)> const_method_const_obj_cb = | |
| 383 Bind(&HasRef::IntConstMethod0, const_has_ref_ptr_); | |
| 384 EXPECT_EQ(1337, normal_cb.Run()); | |
| 385 EXPECT_EQ(31337, method_cb.Run()); | |
| 386 EXPECT_EQ(41337, const_method_nonconst_obj_cb.Run()); | |
| 387 EXPECT_EQ(51337, const_method_const_obj_cb.Run()); | |
| 388 } | |
| 389 | |
| 390 // IgnoreResult adapter test. | |
| 391 // - Function with return value. | |
| 392 // - Method with return value. | |
| 393 // - Const Method with return. | |
| 394 // - Method with return value bound to WeakPtr<>. | |
| 395 // - Const Method with return bound to WeakPtr<>. | |
| 396 TEST_F(BindTest, IgnoreResult) { | |
| 397 EXPECT_CALL(static_func_mock_, IntMethod0()).WillOnce(Return(1337)); | |
| 398 EXPECT_CALL(has_ref_, AddRef()).Times(2); | |
| 399 EXPECT_CALL(has_ref_, Release()).Times(2); | |
| 400 EXPECT_CALL(has_ref_, IntMethod0()).WillOnce(Return(10)); | |
| 401 EXPECT_CALL(has_ref_, IntConstMethod0()).WillOnce(Return(11)); | |
| 402 EXPECT_CALL(no_ref_, IntMethod0()).WillOnce(Return(12)); | |
| 403 EXPECT_CALL(no_ref_, IntConstMethod0()).WillOnce(Return(13)); | |
| 404 | |
| 405 Closure normal_func_cb = Bind(IgnoreResult(&IntFunc0)); | |
| 406 normal_func_cb.Run(); | |
| 407 | |
| 408 Closure non_void_method_cb = | |
| 409 Bind(IgnoreResult(&HasRef::IntMethod0), &has_ref_); | |
| 410 non_void_method_cb.Run(); | |
| 411 | |
| 412 Closure non_void_const_method_cb = | |
| 413 Bind(IgnoreResult(&HasRef::IntConstMethod0), &has_ref_); | |
| 414 non_void_const_method_cb.Run(); | |
| 415 | |
| 416 WeakPtrFactory<NoRef> weak_factory(&no_ref_); | |
| 417 WeakPtrFactory<const NoRef> const_weak_factory(const_no_ref_ptr_); | |
| 418 | |
| 419 Closure non_void_weak_method_cb = | |
| 420 Bind(IgnoreResult(&NoRef::IntMethod0), weak_factory.GetWeakPtr()); | |
| 421 non_void_weak_method_cb.Run(); | |
| 422 | |
| 423 Closure non_void_weak_const_method_cb = | |
| 424 Bind(IgnoreResult(&NoRef::IntConstMethod0), weak_factory.GetWeakPtr()); | |
| 425 non_void_weak_const_method_cb.Run(); | |
| 426 | |
| 427 weak_factory.InvalidateWeakPtrs(); | |
| 428 non_void_weak_const_method_cb.Run(); | |
| 429 non_void_weak_method_cb.Run(); | |
| 430 } | |
| 431 | |
| 432 // Argument binding tests. | |
| 433 // - Argument binding to primitive. | |
| 434 // - Argument binding to primitive pointer. | |
| 435 // - Argument binding to a literal integer. | |
| 436 // - Argument binding to a literal string. | |
| 437 // - Argument binding with template function. | |
| 438 // - Argument binding to an object. | |
| 439 // - Argument binding to pointer to incomplete type. | |
| 440 // - Argument gets type converted. | |
| 441 // - Pointer argument gets converted. | |
| 442 // - Const Reference forces conversion. | |
| 443 TEST_F(BindTest, ArgumentBinding) { | |
| 444 int n = 2; | |
| 445 | |
| 446 Callback<int(void)> bind_primitive_cb = Bind(&Identity, n); | |
| 447 EXPECT_EQ(n, bind_primitive_cb.Run()); | |
| 448 | |
| 449 Callback<int*(void)> bind_primitive_pointer_cb = | |
| 450 Bind(&PolymorphicIdentity<int*>, &n); | |
| 451 EXPECT_EQ(&n, bind_primitive_pointer_cb.Run()); | |
| 452 | |
| 453 Callback<int(void)> bind_int_literal_cb = Bind(&Identity, 3); | |
| 454 EXPECT_EQ(3, bind_int_literal_cb.Run()); | |
| 455 | |
| 456 Callback<const char*(void)> bind_string_literal_cb = | |
| 457 Bind(&CStringIdentity, "hi"); | |
| 458 EXPECT_STREQ("hi", bind_string_literal_cb.Run()); | |
| 459 | |
| 460 Callback<int(void)> bind_template_function_cb = | |
| 461 Bind(&PolymorphicIdentity<int>, 4); | |
| 462 EXPECT_EQ(4, bind_template_function_cb.Run()); | |
| 463 | |
| 464 NoRefParent p; | |
| 465 p.value = 5; | |
| 466 Callback<int(void)> bind_object_cb = Bind(&UnwrapNoRefParent, p); | |
| 467 EXPECT_EQ(5, bind_object_cb.Run()); | |
| 468 | |
| 469 IncompleteType* incomplete_ptr = reinterpret_cast<IncompleteType*>(123); | |
| 470 Callback<IncompleteType*(void)> bind_incomplete_ptr_cb = | |
| 471 Bind(&PolymorphicIdentity<IncompleteType*>, incomplete_ptr); | |
| 472 EXPECT_EQ(incomplete_ptr, bind_incomplete_ptr_cb.Run()); | |
| 473 | |
| 474 NoRefChild c; | |
| 475 c.value = 6; | |
| 476 Callback<int(void)> bind_promotes_cb = Bind(&UnwrapNoRefParent, c); | |
| 477 EXPECT_EQ(6, bind_promotes_cb.Run()); | |
| 478 | |
| 479 c.value = 7; | |
| 480 Callback<int(void)> bind_pointer_promotes_cb = | |
| 481 Bind(&UnwrapNoRefParentPtr, &c); | |
| 482 EXPECT_EQ(7, bind_pointer_promotes_cb.Run()); | |
| 483 | |
| 484 c.value = 8; | |
| 485 Callback<int(void)> bind_const_reference_promotes_cb = | |
| 486 Bind(&UnwrapNoRefParentConstRef, c); | |
| 487 EXPECT_EQ(8, bind_const_reference_promotes_cb.Run()); | |
| 488 } | |
| 489 | |
| 490 // Unbound argument type support tests. | |
| 491 // - Unbound value. | |
| 492 // - Unbound pointer. | |
| 493 // - Unbound reference. | |
| 494 // - Unbound const reference. | |
| 495 // - Unbound unsized array. | |
| 496 // - Unbound sized array. | |
| 497 // - Unbound array-of-arrays. | |
| 498 TEST_F(BindTest, UnboundArgumentTypeSupport) { | |
| 499 Callback<void(int)> unbound_value_cb = Bind(&VoidPolymorphic1<int>); | |
| 500 Callback<void(int*)> unbound_pointer_cb = Bind(&VoidPolymorphic1<int*>); | |
| 501 Callback<void(int&)> unbound_ref_cb = Bind(&VoidPolymorphic1<int&>); | |
| 502 Callback<void(const int&)> unbound_const_ref_cb = | |
| 503 Bind(&VoidPolymorphic1<const int&>); | |
| 504 Callback<void(int[])> unbound_unsized_array_cb = | |
| 505 Bind(&VoidPolymorphic1<int[]>); | |
| 506 Callback<void(int[2])> unbound_sized_array_cb = | |
| 507 Bind(&VoidPolymorphic1<int[2]>); | |
| 508 Callback<void(int[][2])> unbound_array_of_arrays_cb = | |
| 509 Bind(&VoidPolymorphic1<int[][2]>); | |
| 510 } | |
| 511 | |
| 512 // Function with unbound reference parameter. | |
| 513 // - Original parameter is modified by callback. | |
| 514 TEST_F(BindTest, UnboundReferenceSupport) { | |
| 515 int n = 0; | |
| 516 Callback<void(int&)> unbound_ref_cb = Bind(&RefArgSet); | |
| 517 unbound_ref_cb.Run(n); | |
| 518 EXPECT_EQ(2, n); | |
| 519 } | |
| 520 | |
| 521 // Functions that take reference parameters. | |
| 522 // - Forced reference parameter type still stores a copy. | |
| 523 // - Forced const reference parameter type still stores a copy. | |
| 524 TEST_F(BindTest, ReferenceArgumentBinding) { | |
| 525 int n = 1; | |
| 526 int& ref_n = n; | |
| 527 const int& const_ref_n = n; | |
| 528 | |
| 529 Callback<int(void)> ref_copies_cb = Bind(&Identity, ref_n); | |
| 530 EXPECT_EQ(n, ref_copies_cb.Run()); | |
| 531 n++; | |
| 532 EXPECT_EQ(n - 1, ref_copies_cb.Run()); | |
| 533 | |
| 534 Callback<int(void)> const_ref_copies_cb = Bind(&Identity, const_ref_n); | |
| 535 EXPECT_EQ(n, const_ref_copies_cb.Run()); | |
| 536 n++; | |
| 537 EXPECT_EQ(n - 1, const_ref_copies_cb.Run()); | |
| 538 } | |
| 539 | |
| 540 // Check that we can pass in arrays and have them be stored as a pointer. | |
| 541 // - Array of values stores a pointer. | |
| 542 // - Array of const values stores a pointer. | |
| 543 TEST_F(BindTest, ArrayArgumentBinding) { | |
| 544 int array[4] = {1, 1, 1, 1}; | |
| 545 const int (*const_array_ptr)[4] = &array; | |
| 546 | |
| 547 Callback<int(void)> array_cb = Bind(&ArrayGet, array, 1); | |
| 548 EXPECT_EQ(1, array_cb.Run()); | |
| 549 | |
| 550 Callback<int(void)> const_array_cb = Bind(&ArrayGet, *const_array_ptr, 1); | |
| 551 EXPECT_EQ(1, const_array_cb.Run()); | |
| 552 | |
| 553 array[1] = 3; | |
| 554 EXPECT_EQ(3, array_cb.Run()); | |
| 555 EXPECT_EQ(3, const_array_cb.Run()); | |
| 556 } | |
| 557 | |
| 558 // Verify SupportsAddRefAndRelease correctly introspects the class type for | |
| 559 // AddRef() and Release(). | |
| 560 // - Class with AddRef() and Release() | |
| 561 // - Class without AddRef() and Release() | |
| 562 // - Derived Class with AddRef() and Release() | |
| 563 // - Derived Class without AddRef() and Release() | |
| 564 // - Derived Class with AddRef() and Release() and a private destructor. | |
| 565 TEST_F(BindTest, SupportsAddRefAndRelease) { | |
| 566 EXPECT_TRUE(internal::SupportsAddRefAndRelease<HasRef>::value); | |
| 567 EXPECT_FALSE(internal::SupportsAddRefAndRelease<NoRef>::value); | |
| 568 | |
| 569 // StrictMock<T> is a derived class of T. So, we use StrictMock<HasRef> and | |
| 570 // StrictMock<NoRef> to test that SupportsAddRefAndRelease works over | |
| 571 // inheritance. | |
| 572 EXPECT_TRUE(internal::SupportsAddRefAndRelease<StrictMock<HasRef> >::value); | |
| 573 EXPECT_FALSE(internal::SupportsAddRefAndRelease<StrictMock<NoRef> >::value); | |
| 574 | |
| 575 // This matters because the implementation creates a dummy class that | |
| 576 // inherits from the template type. | |
| 577 EXPECT_TRUE(internal::SupportsAddRefAndRelease<HasRefPrivateDtor>::value); | |
| 578 } | |
| 579 | |
| 580 // Unretained() wrapper support. | |
| 581 // - Method bound to Unretained() non-const object. | |
| 582 // - Const method bound to Unretained() non-const object. | |
| 583 // - Const method bound to Unretained() const object. | |
| 584 TEST_F(BindTest, Unretained) { | |
| 585 EXPECT_CALL(no_ref_, VoidMethod0()); | |
| 586 EXPECT_CALL(no_ref_, VoidConstMethod0()).Times(2); | |
| 587 | |
| 588 Callback<void(void)> method_cb = | |
| 589 Bind(&NoRef::VoidMethod0, Unretained(&no_ref_)); | |
| 590 method_cb.Run(); | |
| 591 | |
| 592 Callback<void(void)> const_method_cb = | |
| 593 Bind(&NoRef::VoidConstMethod0, Unretained(&no_ref_)); | |
| 594 const_method_cb.Run(); | |
| 595 | |
| 596 Callback<void(void)> const_method_const_ptr_cb = | |
| 597 Bind(&NoRef::VoidConstMethod0, Unretained(const_no_ref_ptr_)); | |
| 598 const_method_const_ptr_cb.Run(); | |
| 599 } | |
| 600 | |
| 601 // WeakPtr() support. | |
| 602 // - Method bound to WeakPtr<> to non-const object. | |
| 603 // - Const method bound to WeakPtr<> to non-const object. | |
| 604 // - Const method bound to WeakPtr<> to const object. | |
| 605 // - Normal Function with WeakPtr<> as P1 can have return type and is | |
| 606 // not canceled. | |
| 607 TEST_F(BindTest, WeakPtr) { | |
| 608 EXPECT_CALL(no_ref_, VoidMethod0()); | |
| 609 EXPECT_CALL(no_ref_, VoidConstMethod0()).Times(2); | |
| 610 | |
| 611 WeakPtrFactory<NoRef> weak_factory(&no_ref_); | |
| 612 WeakPtrFactory<const NoRef> const_weak_factory(const_no_ref_ptr_); | |
| 613 | |
| 614 Closure method_cb = | |
| 615 Bind(&NoRef::VoidMethod0, weak_factory.GetWeakPtr()); | |
| 616 method_cb.Run(); | |
| 617 | |
| 618 Closure const_method_cb = | |
| 619 Bind(&NoRef::VoidConstMethod0, const_weak_factory.GetWeakPtr()); | |
| 620 const_method_cb.Run(); | |
| 621 | |
| 622 Closure const_method_const_ptr_cb = | |
| 623 Bind(&NoRef::VoidConstMethod0, const_weak_factory.GetWeakPtr()); | |
| 624 const_method_const_ptr_cb.Run(); | |
| 625 | |
| 626 Callback<int(int)> normal_func_cb = | |
| 627 Bind(&FunctionWithWeakFirstParam, weak_factory.GetWeakPtr()); | |
| 628 EXPECT_EQ(1, normal_func_cb.Run(1)); | |
| 629 | |
| 630 weak_factory.InvalidateWeakPtrs(); | |
| 631 const_weak_factory.InvalidateWeakPtrs(); | |
| 632 | |
| 633 method_cb.Run(); | |
| 634 const_method_cb.Run(); | |
| 635 const_method_const_ptr_cb.Run(); | |
| 636 | |
| 637 // Still runs even after the pointers are invalidated. | |
| 638 EXPECT_EQ(2, normal_func_cb.Run(2)); | |
| 639 } | |
| 640 | |
| 641 // ConstRef() wrapper support. | |
| 642 // - Binding w/o ConstRef takes a copy. | |
| 643 // - Binding a ConstRef takes a reference. | |
| 644 // - Binding ConstRef to a function ConstRef does not copy on invoke. | |
| 645 TEST_F(BindTest, ConstRef) { | |
| 646 int n = 1; | |
| 647 | |
| 648 Callback<int(void)> copy_cb = Bind(&Identity, n); | |
| 649 Callback<int(void)> const_ref_cb = Bind(&Identity, ConstRef(n)); | |
| 650 EXPECT_EQ(n, copy_cb.Run()); | |
| 651 EXPECT_EQ(n, const_ref_cb.Run()); | |
| 652 n++; | |
| 653 EXPECT_EQ(n - 1, copy_cb.Run()); | |
| 654 EXPECT_EQ(n, const_ref_cb.Run()); | |
| 655 | |
| 656 int copies = 0; | |
| 657 int assigns = 0; | |
| 658 CopyCounter counter(&copies, &assigns); | |
| 659 Callback<int(void)> all_const_ref_cb = | |
| 660 Bind(&GetCopies, ConstRef(counter)); | |
| 661 EXPECT_EQ(0, all_const_ref_cb.Run()); | |
| 662 EXPECT_EQ(0, copies); | |
| 663 EXPECT_EQ(0, assigns); | |
| 664 } | |
| 665 | |
| 666 TEST_F(BindTest, ScopedRefptr) { | |
| 667 // BUG: The scoped_refptr should cause the only AddRef()/Release() pair. But | |
| 668 // due to a bug in base::Bind(), there's an extra call when invoking the | |
| 669 // callback. | |
| 670 // https://code.google.com/p/chromium/issues/detail?id=251937 | |
| 671 EXPECT_CALL(has_ref_, AddRef()).Times(2); | |
| 672 EXPECT_CALL(has_ref_, Release()).Times(2); | |
| 673 | |
| 674 const scoped_refptr<StrictMock<HasRef> > refptr(&has_ref_); | |
| 675 | |
| 676 Callback<int(void)> scoped_refptr_const_ref_cb = | |
| 677 Bind(&FunctionWithScopedRefptrFirstParam, base::ConstRef(refptr), 1); | |
| 678 EXPECT_EQ(1, scoped_refptr_const_ref_cb.Run()); | |
| 679 } | |
| 680 | |
| 681 // Test Owned() support. | |
| 682 TEST_F(BindTest, Owned) { | |
| 683 int deletes = 0; | |
| 684 DeleteCounter* counter = new DeleteCounter(&deletes); | |
| 685 | |
| 686 // If we don't capture, delete happens on Callback destruction/reset. | |
| 687 // return the same value. | |
| 688 Callback<DeleteCounter*(void)> no_capture_cb = | |
| 689 Bind(&PolymorphicIdentity<DeleteCounter*>, Owned(counter)); | |
| 690 ASSERT_EQ(counter, no_capture_cb.Run()); | |
| 691 ASSERT_EQ(counter, no_capture_cb.Run()); | |
| 692 EXPECT_EQ(0, deletes); | |
| 693 no_capture_cb.Reset(); // This should trigger a delete. | |
| 694 EXPECT_EQ(1, deletes); | |
| 695 | |
| 696 deletes = 0; | |
| 697 counter = new DeleteCounter(&deletes); | |
| 698 base::Closure own_object_cb = | |
| 699 Bind(&DeleteCounter::VoidMethod0, Owned(counter)); | |
| 700 own_object_cb.Run(); | |
| 701 EXPECT_EQ(0, deletes); | |
| 702 own_object_cb.Reset(); | |
| 703 EXPECT_EQ(1, deletes); | |
| 704 } | |
| 705 | |
| 706 // Passed() wrapper support. | |
| 707 // - Passed() can be constructed from a pointer to scoper. | |
| 708 // - Passed() can be constructed from a scoper rvalue. | |
| 709 // - Using Passed() gives Callback Ownership. | |
| 710 // - Ownership is transferred from Callback to callee on the first Run(). | |
| 711 // - Callback supports unbound arguments. | |
| 712 TEST_F(BindTest, ScopedPtr) { | |
| 713 int deletes = 0; | |
| 714 | |
| 715 // Tests the Passed() function's support for pointers. | |
| 716 scoped_ptr<DeleteCounter> ptr(new DeleteCounter(&deletes)); | |
| 717 Callback<scoped_ptr<DeleteCounter>(void)> unused_callback = | |
| 718 Bind(&PassThru<scoped_ptr<DeleteCounter> >, Passed(&ptr)); | |
| 719 EXPECT_FALSE(ptr.get()); | |
| 720 EXPECT_EQ(0, deletes); | |
| 721 | |
| 722 // If we never invoke the Callback, it retains ownership and deletes. | |
| 723 unused_callback.Reset(); | |
| 724 EXPECT_EQ(1, deletes); | |
| 725 | |
| 726 // Tests the Passed() function's support for rvalues. | |
| 727 deletes = 0; | |
| 728 DeleteCounter* counter = new DeleteCounter(&deletes); | |
| 729 Callback<scoped_ptr<DeleteCounter>(void)> callback = | |
| 730 Bind(&PassThru<scoped_ptr<DeleteCounter> >, | |
| 731 Passed(scoped_ptr<DeleteCounter>(counter))); | |
| 732 EXPECT_FALSE(ptr.get()); | |
| 733 EXPECT_EQ(0, deletes); | |
| 734 | |
| 735 // Check that ownership can be transferred back out. | |
| 736 scoped_ptr<DeleteCounter> result = callback.Run(); | |
| 737 ASSERT_EQ(counter, result.get()); | |
| 738 EXPECT_EQ(0, deletes); | |
| 739 | |
| 740 // Resetting does not delete since ownership was transferred. | |
| 741 callback.Reset(); | |
| 742 EXPECT_EQ(0, deletes); | |
| 743 | |
| 744 // Ensure that we actually did get ownership. | |
| 745 result.reset(); | |
| 746 EXPECT_EQ(1, deletes); | |
| 747 | |
| 748 // Test unbound argument forwarding. | |
| 749 Callback<scoped_ptr<DeleteCounter>(scoped_ptr<DeleteCounter>)> cb_unbound = | |
| 750 Bind(&PassThru<scoped_ptr<DeleteCounter> >); | |
| 751 ptr.reset(new DeleteCounter(&deletes)); | |
| 752 cb_unbound.Run(ptr.Pass()); | |
| 753 } | |
| 754 | |
| 755 // Argument Copy-constructor usage for non-reference parameters. | |
| 756 // - Bound arguments are only copied once. | |
| 757 // - Forwarded arguments are only copied once. | |
| 758 // - Forwarded arguments with coercions are only copied twice (once for the | |
| 759 // coercion, and one for the final dispatch). | |
| 760 TEST_F(BindTest, ArgumentCopies) { | |
| 761 int copies = 0; | |
| 762 int assigns = 0; | |
| 763 | |
| 764 CopyCounter counter(&copies, &assigns); | |
| 765 | |
| 766 Callback<void(void)> copy_cb = | |
| 767 Bind(&VoidPolymorphic1<CopyCounter>, counter); | |
| 768 EXPECT_GE(1, copies); | |
| 769 EXPECT_EQ(0, assigns); | |
| 770 | |
| 771 copies = 0; | |
| 772 assigns = 0; | |
| 773 Callback<void(CopyCounter)> forward_cb = | |
| 774 Bind(&VoidPolymorphic1<CopyCounter>); | |
| 775 forward_cb.Run(counter); | |
| 776 EXPECT_GE(1, copies); | |
| 777 EXPECT_EQ(0, assigns); | |
| 778 | |
| 779 copies = 0; | |
| 780 assigns = 0; | |
| 781 DerivedCopyCounter derived(&copies, &assigns); | |
| 782 Callback<void(CopyCounter)> coerce_cb = | |
| 783 Bind(&VoidPolymorphic1<CopyCounter>); | |
| 784 coerce_cb.Run(CopyCounter(derived)); | |
| 785 EXPECT_GE(2, copies); | |
| 786 EXPECT_EQ(0, assigns); | |
| 787 } | |
| 788 | |
| 789 // Callback construction and assignment tests. | |
| 790 // - Construction from an InvokerStorageHolder should not cause ref/deref. | |
| 791 // - Assignment from other callback should only cause one ref | |
| 792 // | |
| 793 // TODO(ajwong): Is there actually a way to test this? | |
| 794 | |
| 795 #if defined(OS_WIN) | |
| 796 int __fastcall FastCallFunc(int n) { | |
| 797 return n; | |
| 798 } | |
| 799 | |
| 800 int __stdcall StdCallFunc(int n) { | |
| 801 return n; | |
| 802 } | |
| 803 | |
| 804 // Windows specific calling convention support. | |
| 805 // - Can bind a __fastcall function. | |
| 806 // - Can bind a __stdcall function. | |
| 807 TEST_F(BindTest, WindowsCallingConventions) { | |
| 808 Callback<int(void)> fastcall_cb = Bind(&FastCallFunc, 1); | |
| 809 EXPECT_EQ(1, fastcall_cb.Run()); | |
| 810 | |
| 811 Callback<int(void)> stdcall_cb = Bind(&StdCallFunc, 2); | |
| 812 EXPECT_EQ(2, stdcall_cb.Run()); | |
| 813 } | |
| 814 #endif | |
| 815 | |
| 816 #if (!defined(NDEBUG) || defined(DCHECK_ALWAYS_ON)) && GTEST_HAS_DEATH_TEST | |
| 817 | |
| 818 // Test null callbacks cause a DCHECK. | |
| 819 TEST(BindDeathTest, NullCallback) { | |
| 820 base::Callback<void(int)> null_cb; | |
| 821 ASSERT_TRUE(null_cb.is_null()); | |
| 822 EXPECT_DEATH(base::Bind(null_cb, 42), ""); | |
| 823 } | |
| 824 | |
| 825 #endif // (!defined(NDEBUG) || defined(DCHECK_ALWAYS_ON)) && | |
| 826 // GTEST_HAS_DEATH_TEST | |
| 827 | |
| 828 } // namespace | |
| 829 } // namespace base | |
| OLD | NEW |
|---|
Chromium Code Reviews
