base/memory/scoped_ptr_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/scoped_ptr.h"
   6
   7 #include "base/basictypes.h"
   8 #include "base/bind.h"
   9 #include "base/callback.h"
  10 #include "testing/gtest/include/gtest/gtest.h"
  11
  12 namespace {
  13
  14 // Used to test depth subtyping.
  15 class ConDecLoggerParent {
  16  public:
  17   virtual ~ConDecLoggerParent() {}
  18
  19   virtual void SetPtr(int* ptr) = 0;
  20
  21   virtual int SomeMeth(int x) const = 0;
  22 };
  23
  24 class ConDecLogger : public ConDecLoggerParent {
  25  public:
  26   ConDecLogger() : ptr_(NULL) { }
  27   explicit ConDecLogger(int* ptr) { SetPtr(ptr); }
  28   virtual ~ConDecLogger() { --*ptr_; }
  29
  30   virtual void SetPtr(int* ptr) override { ptr_ = ptr; ++*ptr_; }
  31
  32   virtual int SomeMeth(int x) const override { return x; }
  33
  34  private:
  35   int* ptr_;
  36
  37   DISALLOW_COPY_AND_ASSIGN(ConDecLogger);
  38 };
  39
  40 struct CountingDeleter {
  41   explicit CountingDeleter(int* count) : count_(count) {}
  42   inline void operator()(double* ptr) const {
  43     (*count_)++;
  44   }
  45   int* count_;
  46 };
  47
  48 // Used to test assignment of convertible deleters.
  49 struct CountingDeleterChild : public CountingDeleter {
  50   explicit CountingDeleterChild(int* count) : CountingDeleter(count) {}
  51 };
  52
  53 class OverloadedNewAndDelete {
  54  public:
  55   void* operator new(size_t size) {
  56     g_new_count++;
  57     return malloc(size);
  58   }
  59
  60   void operator delete(void* ptr) {
  61     g_delete_count++;
  62     free(ptr);
  63   }
  64
  65   static void ResetCounters() {
  66     g_new_count = 0;
  67     g_delete_count = 0;
  68   }
  69
  70   static int new_count() { return g_new_count; }
  71   static int delete_count() { return g_delete_count; }
  72
  73  private:
  74   static int g_new_count;
  75   static int g_delete_count;
  76 };
  77
  78 int OverloadedNewAndDelete::g_new_count = 0;
  79 int OverloadedNewAndDelete::g_delete_count = 0;
  80
  81 scoped_ptr<ConDecLogger> PassThru(scoped_ptr<ConDecLogger> logger) {
  82   return logger.Pass();
  83 }
  84
  85 void GrabAndDrop(scoped_ptr<ConDecLogger> logger) {
  86 }
  87
  88 // Do not delete this function!  It's existence is to test that you can
  89 // return a temporarily constructed version of the scoper.
  90 scoped_ptr<ConDecLogger> TestReturnOfType(int* constructed) {
  91   return scoped_ptr<ConDecLogger>(new ConDecLogger(constructed));
  92 }
  93
  94 scoped_ptr<ConDecLoggerParent> UpcastUsingPassAs(
  95     scoped_ptr<ConDecLogger> object) {
  96   return object.PassAs<ConDecLoggerParent>();
  97 }
  98
  99 }  // namespace
 100
 101 TEST(ScopedPtrTest, ScopedPtr) {
 102   int constructed = 0;
 103
 104   // Ensure size of scoped_ptr<> doesn't increase unexpectedly.
 105   COMPILE_ASSERT(sizeof(int*) >= sizeof(scoped_ptr<int>),
 106                  scoped_ptr_larger_than_raw_ptr);
 107
 108   {
 109     scoped_ptr<ConDecLogger> scoper(new ConDecLogger(&constructed));
 110     EXPECT_EQ(1, constructed);
 111     EXPECT_TRUE(scoper.get());
 112
 113     EXPECT_EQ(10, scoper->SomeMeth(10));
 114     EXPECT_EQ(10, scoper.get()->SomeMeth(10));
 115     EXPECT_EQ(10, (*scoper).SomeMeth(10));
 116   }
 117   EXPECT_EQ(0, constructed);
 118
 119   // Test reset() and release()
 120   {
 121     scoped_ptr<ConDecLogger> scoper(new ConDecLogger(&constructed));
 122     EXPECT_EQ(1, constructed);
 123     EXPECT_TRUE(scoper.get());
 124
 125     scoper.reset(new ConDecLogger(&constructed));
 126     EXPECT_EQ(1, constructed);
 127     EXPECT_TRUE(scoper.get());
 128
 129     scoper.reset();
 130     EXPECT_EQ(0, constructed);
 131     EXPECT_FALSE(scoper.get());
 132
 133     scoper.reset(new ConDecLogger(&constructed));
 134     EXPECT_EQ(1, constructed);
 135     EXPECT_TRUE(scoper.get());
 136
 137     ConDecLogger* take = scoper.release();
 138     EXPECT_EQ(1, constructed);
 139     EXPECT_FALSE(scoper.get());
 140     delete take;
 141     EXPECT_EQ(0, constructed);
 142
 143     scoper.reset(new ConDecLogger(&constructed));
 144     EXPECT_EQ(1, constructed);
 145     EXPECT_TRUE(scoper.get());
 146   }
 147   EXPECT_EQ(0, constructed);
 148
 149   // Test swap(), == and !=
 150   {
 151     scoped_ptr<ConDecLogger> scoper1;
 152     scoped_ptr<ConDecLogger> scoper2;
 153     EXPECT_TRUE(scoper1 == scoper2.get());
 154     EXPECT_FALSE(scoper1 != scoper2.get());
 155
 156     ConDecLogger* logger = new ConDecLogger(&constructed);
 157     scoper1.reset(logger);
 158     EXPECT_EQ(logger, scoper1.get());
 159     EXPECT_FALSE(scoper2.get());
 160     EXPECT_FALSE(scoper1 == scoper2.get());
 161     EXPECT_TRUE(scoper1 != scoper2.get());
 162
 163     scoper2.swap(scoper1);
 164     EXPECT_EQ(logger, scoper2.get());
 165     EXPECT_FALSE(scoper1.get());
 166     EXPECT_FALSE(scoper1 == scoper2.get());
 167     EXPECT_TRUE(scoper1 != scoper2.get());
 168   }
 169   EXPECT_EQ(0, constructed);
 170 }
 171
 172 TEST(ScopedPtrTest, ScopedPtrDepthSubtyping) {
 173   int constructed = 0;
 174
 175   // Test construction from a scoped_ptr to a derived class.
 176   {
 177     scoped_ptr<ConDecLogger> scoper(new ConDecLogger(&constructed));
 178     EXPECT_EQ(1, constructed);
 179     EXPECT_TRUE(scoper.get());
 180
 181     scoped_ptr<ConDecLoggerParent> scoper_parent(scoper.Pass());
 182     EXPECT_EQ(1, constructed);
 183     EXPECT_TRUE(scoper_parent.get());
 184     EXPECT_FALSE(scoper.get());
 185
 186     EXPECT_EQ(10, scoper_parent->SomeMeth(10));
 187     EXPECT_EQ(10, scoper_parent.get()->SomeMeth(10));
 188     EXPECT_EQ(10, (*scoper_parent).SomeMeth(10));
 189   }
 190   EXPECT_EQ(0, constructed);
 191
 192   // Test assignment from a scoped_ptr to a derived class.
 193   {
 194     scoped_ptr<ConDecLogger> scoper(new ConDecLogger(&constructed));
 195     EXPECT_EQ(1, constructed);
 196     EXPECT_TRUE(scoper.get());
 197
 198     scoped_ptr<ConDecLoggerParent> scoper_parent;
 199     scoper_parent = scoper.Pass();
 200     EXPECT_EQ(1, constructed);
 201     EXPECT_TRUE(scoper_parent.get());
 202     EXPECT_FALSE(scoper.get());
 203   }
 204   EXPECT_EQ(0, constructed);
 205
 206   // Test construction of a scoped_ptr with an additional const annotation.
 207   {
 208     scoped_ptr<ConDecLogger> scoper(new ConDecLogger(&constructed));
 209     EXPECT_EQ(1, constructed);
 210     EXPECT_TRUE(scoper.get());
 211
 212     scoped_ptr<const ConDecLogger> scoper_const(scoper.Pass());
 213     EXPECT_EQ(1, constructed);
 214     EXPECT_TRUE(scoper_const.get());
 215     EXPECT_FALSE(scoper.get());
 216
 217     EXPECT_EQ(10, scoper_const->SomeMeth(10));
 218     EXPECT_EQ(10, scoper_const.get()->SomeMeth(10));
 219     EXPECT_EQ(10, (*scoper_const).SomeMeth(10));
 220   }
 221   EXPECT_EQ(0, constructed);
 222
 223   // Test assignment to a scoped_ptr with an additional const annotation.
 224   {
 225     scoped_ptr<ConDecLogger> scoper(new ConDecLogger(&constructed));
 226     EXPECT_EQ(1, constructed);
 227     EXPECT_TRUE(scoper.get());
 228
 229     scoped_ptr<const ConDecLogger> scoper_const;
 230     scoper_const = scoper.Pass();
 231     EXPECT_EQ(1, constructed);
 232     EXPECT_TRUE(scoper_const.get());
 233     EXPECT_FALSE(scoper.get());
 234   }
 235   EXPECT_EQ(0, constructed);
 236
 237   // Test assignment to a scoped_ptr deleter of parent type.
 238   {
 239     // Custom deleters never touch these value.
 240     double dummy_value, dummy_value2;
 241     int deletes = 0;
 242     int alternate_deletes = 0;
 243     scoped_ptr<double, CountingDeleter> scoper(&dummy_value,
 244                                                CountingDeleter(&deletes));
 245     scoped_ptr<double, CountingDeleterChild> scoper_child(
 246         &dummy_value2, CountingDeleterChild(&alternate_deletes));
 247
 248     EXPECT_TRUE(scoper);
 249     EXPECT_TRUE(scoper_child);
 250     EXPECT_EQ(0, deletes);
 251     EXPECT_EQ(0, alternate_deletes);
 252
 253     // Test this compiles and correctly overwrites the deleter state.
 254     scoper = scoper_child.Pass();
 255     EXPECT_TRUE(scoper);
 256     EXPECT_FALSE(scoper_child);
 257     EXPECT_EQ(1, deletes);
 258     EXPECT_EQ(0, alternate_deletes);
 259
 260     scoper.reset();
 261     EXPECT_FALSE(scoper);
 262     EXPECT_FALSE(scoper_child);
 263     EXPECT_EQ(1, deletes);
 264     EXPECT_EQ(1, alternate_deletes);
 265
 266     scoper_child.reset(&dummy_value);
 267     EXPECT_TRUE(scoper_child);
 268     EXPECT_EQ(1, deletes);
 269     EXPECT_EQ(1, alternate_deletes);
 270     scoped_ptr<double, CountingDeleter> scoper_construct(scoper_child.Pass());
 271     EXPECT_TRUE(scoper_construct);
 272     EXPECT_FALSE(scoper_child);
 273     EXPECT_EQ(1, deletes);
 274     EXPECT_EQ(1, alternate_deletes);
 275
 276     scoper_construct.reset();
 277     EXPECT_EQ(1, deletes);
 278     EXPECT_EQ(2, alternate_deletes);
 279   }
 280 }
 281
 282 TEST(ScopedPtrTest, ScopedPtrWithArray) {
 283   static const int kNumLoggers = 12;
 284
 285   int constructed = 0;
 286
 287   {
 288     scoped_ptr<ConDecLogger[]> scoper(new ConDecLogger[kNumLoggers]);
 289     EXPECT_TRUE(scoper);
 290     EXPECT_EQ(&scoper[0], scoper.get());
 291     for (int i = 0; i < kNumLoggers; ++i) {
 292       scoper[i].SetPtr(&constructed);
 293     }
 294     EXPECT_EQ(12, constructed);
 295
 296     EXPECT_EQ(10, scoper.get()->SomeMeth(10));
 297     EXPECT_EQ(10, scoper[2].SomeMeth(10));
 298   }
 299   EXPECT_EQ(0, constructed);
 300
 301   // Test reset() and release()
 302   {
 303     scoped_ptr<ConDecLogger[]> scoper;
 304     EXPECT_FALSE(scoper.get());
 305     EXPECT_FALSE(scoper.release());
 306     EXPECT_FALSE(scoper.get());
 307     scoper.reset();
 308     EXPECT_FALSE(scoper.get());
 309
 310     scoper.reset(new ConDecLogger[kNumLoggers]);
 311     for (int i = 0; i < kNumLoggers; ++i) {
 312       scoper[i].SetPtr(&constructed);
 313     }
 314     EXPECT_EQ(12, constructed);
 315     scoper.reset();
 316     EXPECT_EQ(0, constructed);
 317
 318     scoper.reset(new ConDecLogger[kNumLoggers]);
 319     for (int i = 0; i < kNumLoggers; ++i) {
 320       scoper[i].SetPtr(&constructed);
 321     }
 322     EXPECT_EQ(12, constructed);
 323     ConDecLogger* ptr = scoper.release();
 324     EXPECT_EQ(12, constructed);
 325     delete[] ptr;
 326     EXPECT_EQ(0, constructed);
 327   }
 328   EXPECT_EQ(0, constructed);
 329
 330   // Test swap(), ==, !=, and type-safe Boolean.
 331   {
 332     scoped_ptr<ConDecLogger[]> scoper1;
 333     scoped_ptr<ConDecLogger[]> scoper2;
 334     EXPECT_TRUE(scoper1 == scoper2.get());
 335     EXPECT_FALSE(scoper1 != scoper2.get());
 336
 337     ConDecLogger* loggers = new ConDecLogger[kNumLoggers];
 338     for (int i = 0; i < kNumLoggers; ++i) {
 339       loggers[i].SetPtr(&constructed);
 340     }
 341     scoper1.reset(loggers);
 342     EXPECT_TRUE(scoper1);
 343     EXPECT_EQ(loggers, scoper1.get());
 344     EXPECT_FALSE(scoper2);
 345     EXPECT_FALSE(scoper2.get());
 346     EXPECT_FALSE(scoper1 == scoper2.get());
 347     EXPECT_TRUE(scoper1 != scoper2.get());
 348
 349     scoper2.swap(scoper1);
 350     EXPECT_EQ(loggers, scoper2.get());
 351     EXPECT_FALSE(scoper1.get());
 352     EXPECT_FALSE(scoper1 == scoper2.get());
 353     EXPECT_TRUE(scoper1 != scoper2.get());
 354   }
 355   EXPECT_EQ(0, constructed);
 356
 357   {
 358     ConDecLogger* loggers = new ConDecLogger[kNumLoggers];
 359     scoped_ptr<ConDecLogger[]> scoper(loggers);
 360     EXPECT_TRUE(scoper);
 361     for (int i = 0; i < kNumLoggers; ++i) {
 362       scoper[i].SetPtr(&constructed);
 363     }
 364     EXPECT_EQ(kNumLoggers, constructed);
 365
 366     // Test Pass() with constructor;
 367     scoped_ptr<ConDecLogger[]> scoper2(scoper.Pass());
 368     EXPECT_EQ(kNumLoggers, constructed);
 369
 370     // Test Pass() with assignment;
 371     scoped_ptr<ConDecLogger[]> scoper3;
 372     scoper3 = scoper2.Pass();
 373     EXPECT_EQ(kNumLoggers, constructed);
 374     EXPECT_FALSE(scoper);
 375     EXPECT_FALSE(scoper2);
 376     EXPECT_TRUE(scoper3);
 377   }
 378   EXPECT_EQ(0, constructed);
 379 }
 380
 381 TEST(ScopedPtrTest, PassBehavior) {
 382   int constructed = 0;
 383   {
 384     ConDecLogger* logger = new ConDecLogger(&constructed);
 385     scoped_ptr<ConDecLogger> scoper(logger);
 386     EXPECT_EQ(1, constructed);
 387
 388     // Test Pass() with constructor;
 389     scoped_ptr<ConDecLogger> scoper2(scoper.Pass());
 390     EXPECT_EQ(1, constructed);
 391
 392     // Test Pass() with assignment;
 393     scoped_ptr<ConDecLogger> scoper3;
 394     scoper3 = scoper2.Pass();
 395     EXPECT_EQ(1, constructed);
 396     EXPECT_FALSE(scoper.get());
 397     EXPECT_FALSE(scoper2.get());
 398     EXPECT_TRUE(scoper3.get());
 399   }
 400
 401   // Test uncaught Pass() does not have side effects.
 402   {
 403     ConDecLogger* logger = new ConDecLogger(&constructed);
 404     scoped_ptr<ConDecLogger> scoper(logger);
 405     EXPECT_EQ(1, constructed);
 406
 407     // Should auto-destruct logger by end of scope.
 408     scoped_ptr<ConDecLogger>&& rvalue = scoper.Pass();
 409     // The Pass() function mimics std::move(), which does not have side-effects.
 410     EXPECT_TRUE(scoper.get());
 411     EXPECT_TRUE(rvalue);
 412   }
 413   EXPECT_EQ(0, constructed);
 414
 415   // Test that passing to function which does nothing does not leak.
 416   {
 417     ConDecLogger* logger = new ConDecLogger(&constructed);
 418     scoped_ptr<ConDecLogger> scoper(logger);
 419     EXPECT_EQ(1, constructed);
 420
 421     // Should auto-destruct logger by end of scope.
 422     GrabAndDrop(scoper.Pass());
 423     EXPECT_FALSE(scoper.get());
 424   }
 425   EXPECT_EQ(0, constructed);
 426 }
 427
 428 TEST(ScopedPtrTest, ReturnTypeBehavior) {
 429   int constructed = 0;
 430
 431   // Test that we can return a scoped_ptr.
 432   {
 433     ConDecLogger* logger = new ConDecLogger(&constructed);
 434     scoped_ptr<ConDecLogger> scoper(logger);
 435     EXPECT_EQ(1, constructed);
 436
 437     PassThru(scoper.Pass());
 438     EXPECT_FALSE(scoper.get());
 439   }
 440   EXPECT_EQ(0, constructed);
 441
 442   // Test uncaught return type not leak.
 443   {
 444     ConDecLogger* logger = new ConDecLogger(&constructed);
 445     scoped_ptr<ConDecLogger> scoper(logger);
 446     EXPECT_EQ(1, constructed);
 447
 448     // Should auto-destruct logger by end of scope.
 449     PassThru(scoper.Pass());
 450     EXPECT_FALSE(scoper.get());
 451   }
 452   EXPECT_EQ(0, constructed);
 453
 454   // Call TestReturnOfType() so the compiler doesn't warn for an unused
 455   // function.
 456   {
 457     TestReturnOfType(&constructed);
 458   }
 459   EXPECT_EQ(0, constructed);
 460 }
 461
 462 TEST(ScopedPtrTest, PassAs) {
 463   int constructed = 0;
 464   {
 465     scoped_ptr<ConDecLogger> scoper(new ConDecLogger(&constructed));
 466     EXPECT_EQ(1, constructed);
 467     EXPECT_TRUE(scoper.get());
 468
 469     scoped_ptr<ConDecLoggerParent> scoper_parent;
 470     scoper_parent = UpcastUsingPassAs(scoper.Pass());
 471     EXPECT_EQ(1, constructed);
 472     EXPECT_TRUE(scoper_parent.get());
 473     EXPECT_FALSE(scoper.get());
 474   }
 475   EXPECT_EQ(0, constructed);
 476 }
 477
 478 TEST(ScopedPtrTest, CustomDeleter) {
 479   double dummy_value;  // Custom deleter never touches this value.
 480   int deletes = 0;
 481   int alternate_deletes = 0;
 482
 483   // Normal delete support.
 484   {
 485     deletes = 0;
 486     scoped_ptr<double, CountingDeleter> scoper(&dummy_value,
 487                                                CountingDeleter(&deletes));
 488     EXPECT_EQ(0, deletes);
 489     EXPECT_TRUE(scoper.get());
 490   }
 491   EXPECT_EQ(1, deletes);
 492
 493   // Test reset() and release().
 494   deletes = 0;
 495   {
 496     scoped_ptr<double, CountingDeleter> scoper(NULL,
 497                                                CountingDeleter(&deletes));
 498     EXPECT_FALSE(scoper.get());
 499     EXPECT_FALSE(scoper.release());
 500     EXPECT_FALSE(scoper.get());
 501     scoper.reset();
 502     EXPECT_FALSE(scoper.get());
 503     EXPECT_EQ(0, deletes);
 504
 505     scoper.reset(&dummy_value);
 506     scoper.reset();
 507     EXPECT_EQ(1, deletes);
 508
 509     scoper.reset(&dummy_value);
 510     EXPECT_EQ(&dummy_value, scoper.release());
 511   }
 512   EXPECT_EQ(1, deletes);
 513
 514   // Test get_deleter().
 515   deletes = 0;
 516   alternate_deletes = 0;
 517   {
 518     scoped_ptr<double, CountingDeleter> scoper(&dummy_value,
 519                                                CountingDeleter(&deletes));
 520     // Call deleter manually.
 521     EXPECT_EQ(0, deletes);
 522     scoper.get_deleter()(&dummy_value);
 523     EXPECT_EQ(1, deletes);
 524
 525     // Deleter is still there after reset.
 526     scoper.reset();
 527     EXPECT_EQ(2, deletes);
 528     scoper.get_deleter()(&dummy_value);
 529     EXPECT_EQ(3, deletes);
 530
 531     // Deleter can be assigned into (matches C++11 unique_ptr<> spec).
 532     scoper.get_deleter() = CountingDeleter(&alternate_deletes);
 533     scoper.reset(&dummy_value);
 534     EXPECT_EQ(0, alternate_deletes);
 535
 536   }
 537   EXPECT_EQ(3, deletes);
 538   EXPECT_EQ(1, alternate_deletes);
 539
 540   // Test operator= deleter support.
 541   deletes = 0;
 542   alternate_deletes = 0;
 543   {
 544     double dummy_value2;
 545     scoped_ptr<double, CountingDeleter> scoper(&dummy_value,
 546                                                CountingDeleter(&deletes));
 547     scoped_ptr<double, CountingDeleter> scoper2(
 548         &dummy_value2,
 549         CountingDeleter(&alternate_deletes));
 550     EXPECT_EQ(0, deletes);
 551     EXPECT_EQ(0, alternate_deletes);
 552
 553     // Pass the second deleter through a constructor and an operator=. Then
 554     // reinitialize the empty scopers to ensure that each one is deleting
 555     // properly.
 556     scoped_ptr<double, CountingDeleter> scoper3(scoper2.Pass());
 557     scoper = scoper3.Pass();
 558     EXPECT_EQ(1, deletes);
 559
 560     scoper2.reset(&dummy_value2);
 561     scoper3.reset(&dummy_value2);
 562     EXPECT_EQ(0, alternate_deletes);
 563
 564   }
 565   EXPECT_EQ(1, deletes);
 566   EXPECT_EQ(3, alternate_deletes);
 567
 568   // Test swap(), ==, !=, and type-safe Boolean.
 569   {
 570     scoped_ptr<double, CountingDeleter> scoper1(NULL,
 571                                                 CountingDeleter(&deletes));
 572     scoped_ptr<double, CountingDeleter> scoper2(NULL,
 573                                                 CountingDeleter(&deletes));
 574     EXPECT_TRUE(scoper1 == scoper2.get());
 575     EXPECT_FALSE(scoper1 != scoper2.get());
 576
 577     scoper1.reset(&dummy_value);
 578     EXPECT_TRUE(scoper1);
 579     EXPECT_EQ(&dummy_value, scoper1.get());
 580     EXPECT_FALSE(scoper2);
 581     EXPECT_FALSE(scoper2.get());
 582     EXPECT_FALSE(scoper1 == scoper2.get());
 583     EXPECT_TRUE(scoper1 != scoper2.get());
 584
 585     scoper2.swap(scoper1);
 586     EXPECT_EQ(&dummy_value, scoper2.get());
 587     EXPECT_FALSE(scoper1.get());
 588     EXPECT_FALSE(scoper1 == scoper2.get());
 589     EXPECT_TRUE(scoper1 != scoper2.get());
 590   }
 591 }
 592
 593 // Sanity check test for overloaded new and delete operators. Does not do full
 594 // coverage of reset/release/Pass() operations as that is redundant with the
 595 // above.
 596 TEST(ScopedPtrTest, OverloadedNewAndDelete) {
 597   {
 598     OverloadedNewAndDelete::ResetCounters();
 599     scoped_ptr<OverloadedNewAndDelete> scoper(new OverloadedNewAndDelete());
 600     EXPECT_TRUE(scoper.get());
 601
 602     scoped_ptr<OverloadedNewAndDelete> scoper2(scoper.Pass());
 603   }
 604   EXPECT_EQ(1, OverloadedNewAndDelete::delete_count());
 605   EXPECT_EQ(1, OverloadedNewAndDelete::new_count());
 606 }
 607
 608 scoped_ptr<int> NullIntReturn() {
 609   return nullptr;
 610 }
 611
 612 TEST(ScopedPtrTest, Nullptr) {
 613   scoped_ptr<int> scoper1(nullptr);
 614   scoped_ptr<int> scoper2(new int);
 615   scoper2 = nullptr;
 616   scoped_ptr<int> scoper3(NullIntReturn());
 617   scoped_ptr<int> scoper4 = NullIntReturn();
 618   EXPECT_EQ(nullptr, scoper1.get());
 619   EXPECT_EQ(nullptr, scoper2.get());
 620   EXPECT_EQ(nullptr, scoper3.get());
 621   EXPECT_EQ(nullptr, scoper4.get());
 622 }
 623
 624 scoped_ptr<int[]> NullIntArrayReturn() {
 625   return nullptr;
 626 }
 627
 628 TEST(ScopedPtrTest, NullptrArray) {
 629   scoped_ptr<int[]> scoper1(nullptr);
 630   scoped_ptr<int[]> scoper2(new int[3]);
 631   scoper2 = nullptr;
 632   scoped_ptr<int[]> scoper3(NullIntArrayReturn());
 633   scoped_ptr<int[]> scoper4 = NullIntArrayReturn();
 634   EXPECT_EQ(nullptr, scoper1.get());
 635   EXPECT_EQ(nullptr, scoper2.get());
 636   EXPECT_EQ(nullptr, scoper3.get());
 637   EXPECT_EQ(nullptr, scoper4.get());
 638 }
 639
 640 class Super {};
 641 class Sub : public Super {};
 642
 643 scoped_ptr<Sub> SubClassReturn() {
 644   return make_scoped_ptr(new Sub);
 645 }
 646
 647 TEST(ScopedPtrTest, Conversion) {
 648   scoped_ptr<Sub> sub1(new Sub);
 649   scoped_ptr<Sub> sub2(new Sub);
 650
 651   // Upcast with Pass() works.
 652   scoped_ptr<Super> super1 = sub1.Pass();
 653   super1 = sub2.Pass();
 654
 655   // Upcast with an rvalue works.
 656   scoped_ptr<Super> super2 = SubClassReturn();
 657   super2 = SubClassReturn();
 658 }
 659
 660 // Android death tests don't work properly with assert(). Yay.
 661 #if !defined(NDEBUG) && defined(GTEST_HAS_DEATH_TEST) && !defined(OS_ANDROID)
 662 TEST(ScopedPtrTest, SelfResetAbortsWithDefaultDeleter) {
 663   scoped_ptr<int> x(new int);
 664   EXPECT_DEATH(x.reset(x.get()), "");
 665 }
 666
 667 TEST(ScopedPtrTest, SelfResetAbortsWithDefaultArrayDeleter) {
 668   scoped_ptr<int[]> y(new int[4]);
 669   EXPECT_DEATH(y.reset(y.get()), "");
 670 }
 671
 672 TEST(ScopedPtrTest, SelfResetAbortsWithDefaultFreeDeleter) {
 673   scoped_ptr<int, base::FreeDeleter> z(static_cast<int*>(malloc(sizeof(int))));
 674   EXPECT_DEATH(z.reset(z.get()), "");
 675 }
 676
 677 // A custom deleter that doesn't opt out should still crash.
 678 TEST(ScopedPtrTest, SelfResetAbortsWithCustomDeleter) {
 679   struct CustomDeleter {
 680     inline void operator()(int* x) { delete x; }
 681   };
 682   scoped_ptr<int, CustomDeleter> x(new int);
 683   EXPECT_DEATH(x.reset(x.get()), "");
 684 }
 685 #endif
 686
 687 TEST(ScopedPtrTest, SelfResetWithCustomDeleterOptOut) {
 688   // A custom deleter should be able to opt out of self-reset abort behavior.
 689   struct NoOpDeleter {
 690     typedef void AllowSelfReset;
 691     inline void operator()(int*) {}
 692   };
 693   scoped_ptr<int> owner(new int);
 694   scoped_ptr<int, NoOpDeleter> x(owner.get());
 695   x.reset(x.get());
 696 }