xpcom/tests/TestCOMPtr.cpp

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* ***** BEGIN LICENSE BLOCK *****
   3  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
   4  *
   5  * The contents of this file are subject to the Mozilla Public License Version
   6  * 1.1 (the "License"); you may not use this file except in compliance with
   7  * the License. You may obtain a copy of the License at
   8  * http://www.mozilla.org/MPL/
   9  *
  10  * Software distributed under the License is distributed on an "AS IS" basis,
  11  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  12  * for the specific language governing rights and limitations under the
  13  * License.
  14  *
  15  * The Original Code is mozilla.org code.
  16  *
  17  * The Initial Developer of the Original Code is
  18  * Netscape Communications Corporation.
  19  * Portions created by the Initial Developer are Copyright (C) 1998
  20  * the Initial Developer. All Rights Reserved.
  21  *
  22  * Contributor(s):
  23  *   Pierre Phaneuf <pp@ludusdesign.com>
  24  *
  25  * Alternatively, the contents of this file may be used under the terms of
  26  * either of the GNU General Public License Version 2 or later (the "GPL"),
  27  * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  28  * in which case the provisions of the GPL or the LGPL are applicable instead
  29  * of those above. If you wish to allow use of your version of this file only
  30  * under the terms of either the GPL or the LGPL, and not to allow others to
  31  * use your version of this file under the terms of the MPL, indicate your
  32  * decision by deleting the provisions above and replace them with the notice
  33  * and other provisions required by the GPL or the LGPL. If you do not delete
  34  * the provisions above, a recipient may use your version of this file under
  35  * the terms of any one of the MPL, the GPL or the LGPL.
  36  *
  37  * ***** END LICENSE BLOCK ***** */
  38
  39 #include <assert.h>
  40 #include <stdio.h>
  41 #include "nsCOMPtr.h"
  42 #include "nsISupports.h"
  43
  44 #ifdef HAVE_CPP_NEW_CASTS
  45   #define STATIC_CAST(T,x)  static_cast<T>(x)
  46   #define REINTERPRET_CAST(T,x) reinterpret_cast<T>(x)
  47 #else
  48   #define STATIC_CAST(T,x)  ((T)(x))
  49   #define REINTERPRET_CAST(T,x) ((T)(x))
  50 #endif
  51
  52
  53 #define NS_IFOO_IID \
  54 { 0x6f7652e0,  0xee43, 0x11d1, \
  55  { 0x9c, 0xc3, 0x00, 0x60, 0x08, 0x8c, 0xa6, 0xb3 } }
  56
  57 class IFoo : public nsISupports
  58   {
  59                 public:
  60                         NS_DECLARE_STATIC_IID_ACCESSOR(NS_IFOO_IID)
  61
  62                 public:
  63       IFoo();
  64       // virtual dtor because IBar uses our Release()
  65       virtual ~IFoo();
  66
  67       NS_IMETHOD_(nsrefcnt) AddRef();
  68       NS_IMETHOD_(nsrefcnt) Release();
  69       NS_IMETHOD QueryInterface( const nsIID&, void** );
  70
  71       static void print_totals();
  72
  73     private:
  74       unsigned int refcount_;
  75
  76       static unsigned int total_constructions_;
  77       static unsigned int total_destructions_;
  78   };
  79
  80 NS_DEFINE_STATIC_IID_ACCESSOR(IFoo, NS_IFOO_IID)
  81
  82 class IBar;
  83
  84   // some types I'll need
  85 typedef unsigned long NS_RESULT;
  86
  87   // some functions I'll need (and define below)
  88           nsresult  CreateIFoo( void** );
  89           nsresult  CreateIBar( void** result );
  90               void  AnIFooPtrPtrContext( IFoo** );
  91               void      AnISupportsPtrPtrContext( nsISupports** );
  92               void  AVoidPtrPtrContext( void** );
  93               void  set_a_IFoo( nsCOMPtr<IFoo>* result );
  94 nsCOMPtr<IFoo>  return_a_IFoo();
  95
  96
  97
  98
  99 unsigned int IFoo::total_constructions_;
 100 unsigned int IFoo::total_destructions_;
 101
 102 class test_message
 103   {
 104     public:
 105       test_message()
 106         {
 107           printf("BEGIN unit tests for |nsCOMPtr|, compiled " __DATE__ "\n");
 108         }
 109
 110      ~test_message()
 111         {
 112           IFoo::print_totals();
 113           printf("END unit tests for |nsCOMPtr|.\n");
 114         }
 115   };
 116
 117 test_message gTestMessage;
 118
 119
 120   /*
 121     ...
 122   */
 123
 124 void
 125 IFoo::print_totals()
 126   {
 127     printf("total constructions/destructions --> %d/%d\n",
 128            total_constructions_, total_destructions_);
 129   }
 130
 131 IFoo::IFoo()
 132     : refcount_(0)
 133   {
 134     ++total_constructions_;
 135     printf("  new IFoo@%p [#%d]\n",
 136            STATIC_CAST(void*, this), total_constructions_);
 137   }
 138
 139 IFoo::~IFoo()
 140   {
 141     ++total_destructions_;
 142     printf("IFoo@%p::~IFoo() [#%d]\n",
 143            STATIC_CAST(void*, this), total_destructions_);
 144   }
 145
 146 nsrefcnt
 147 IFoo::AddRef()
 148   {
 149     ++refcount_;
 150     printf("IFoo@%p::AddRef(), refcount --> %d\n",
 151            STATIC_CAST(void*, this), refcount_);
 152     return refcount_;
 153   }
 154
 155 nsrefcnt
 156 IFoo::Release()
 157   {
 158     int newcount = --refcount_;
 159     if ( newcount == 0 )
 160       printf(">>");
 161
 162     printf("IFoo@%p::Release(), refcount --> %d\n",
 163            STATIC_CAST(void*, this), refcount_);
 164
 165     if ( newcount == 0 )
 166       {
 167         printf("  delete IFoo@%p\n", STATIC_CAST(void*, this));
 168         printf("<<IFoo@%p::Release()\n", STATIC_CAST(void*, this));
 169         delete this;
 170       }
 171
 172     return newcount;
 173   }
 174
 175 nsresult
 176 IFoo::QueryInterface( const nsIID& aIID, void** aResult )
 177         {
 178     printf("IFoo@%p::QueryInterface()\n", STATIC_CAST(void*, this));
 179                 nsISupports* rawPtr = 0;
 180                 nsresult status = NS_OK;
 181
 182                 if ( aIID.Equals(GetIID()) )
 183                         rawPtr = this;
 184                 else
 185                         {
 186                                 nsID iid_of_ISupports = NS_ISUPPORTS_IID;
 187                                 if ( aIID.Equals(iid_of_ISupports) )
 188                                         rawPtr = STATIC_CAST(nsISupports*, this);
 189                                 else
 190                                         status = NS_ERROR_NO_INTERFACE;
 191                         }
 192
 193                 NS_IF_ADDREF(rawPtr);
 194                 *aResult = rawPtr;
 195
 196                 return status;
 197         }
 198
 199 nsresult
 200 CreateIFoo( void** result )
 201     // a typical factory function (that calls AddRef)
 202   {
 203     printf(">>CreateIFoo() --> ");
 204     IFoo* foop = new IFoo;
 205     printf("IFoo@%p\n", STATIC_CAST(void*, foop));
 206
 207     foop->AddRef();
 208     *result = foop;
 209
 210     printf("<<CreateIFoo()\n");
 211     return 0;
 212   }
 213
 214 void
 215 set_a_IFoo( nsCOMPtr<IFoo>* result )
 216   {
 217     printf(">>set_a_IFoo()\n");
 218     assert(result);
 219
 220     nsCOMPtr<IFoo> foop( do_QueryInterface(new IFoo) );
 221     *result = foop;
 222     printf("<<set_a_IFoo()\n");
 223   }
 224
 225 nsCOMPtr<IFoo>
 226 return_a_IFoo()
 227   {
 228     printf(">>return_a_IFoo()\n");
 229     nsCOMPtr<IFoo> foop( do_QueryInterface(new IFoo) );
 230     printf("<<return_a_IFoo()\n");
 231     return foop;
 232   }
 233
 234
 235
 236
 237 #define NS_IBAR_IID \
 238 { 0x6f7652e1,  0xee43, 0x11d1, \
 239  { 0x9c, 0xc3, 0x00, 0x60, 0x08, 0x8c, 0xa6, 0xb3 } }
 240
 241 class IBar : public IFoo
 242   {
 243         public:
 244                 NS_DECLARE_STATIC_IID_ACCESSOR(NS_IBAR_IID)
 245
 246     public:
 247       IBar();
 248       virtual ~IBar();
 249
 250       NS_IMETHOD QueryInterface( const nsIID&, void** );
 251   };
 252
 253 NS_DEFINE_STATIC_IID_ACCESSOR(IBar, NS_IBAR_IID)
 254
 255 IBar::IBar()
 256   {
 257     printf("  new IBar@%p\n", STATIC_CAST(void*, this));
 258   }
 259
 260 IBar::~IBar()
 261   {
 262     printf("IBar@%p::~IBar()\n", STATIC_CAST(void*, this));
 263   }
 264
 265 nsresult
 266 IBar::QueryInterface( const nsID& aIID, void** aResult )
 267         {
 268     printf("IBar@%p::QueryInterface()\n", STATIC_CAST(void*, this));
 269                 nsISupports* rawPtr = 0;
 270                 nsresult status = NS_OK;
 271
 272                 if ( aIID.Equals(GetIID()) )
 273                         rawPtr = this;
 274                 else if ( aIID.Equals(NS_GET_IID(IFoo)) )
 275                         rawPtr = STATIC_CAST(IFoo*, this);
 276                 else
 277                         {
 278                                 nsID iid_of_ISupports = NS_ISUPPORTS_IID;
 279                                 if ( aIID.Equals(iid_of_ISupports) )
 280                                         rawPtr = STATIC_CAST(nsISupports*, this);
 281                                 else
 282                                         status = NS_ERROR_NO_INTERFACE;
 283                         }
 284
 285                 NS_IF_ADDREF(rawPtr);
 286                 *aResult = rawPtr;
 287
 288                 return status;
 289         }
 290
 291
 292
 293 nsresult
 294 CreateIBar( void** result )
 295     // a typical factory function (that calls AddRef)
 296   {
 297     printf(">>CreateIBar() --> ");
 298     IBar* barp = new IBar;
 299     printf("IBar@%p\n", STATIC_CAST(void*, barp));
 300
 301     barp->AddRef();
 302     *result = barp;
 303
 304     printf("<<CreateIBar()\n");
 305     return 0;
 306   }
 307
 308 void
 309 AnIFooPtrPtrContext( IFoo** )
 310   {
 311   }
 312
 313 void
 314 AVoidPtrPtrContext( void** )
 315   {
 316   }
 317
 318 void
 319 AnISupportsPtrPtrContext( nsISupports** )
 320         {
 321         }
 322
 323
 324 // Optimism
 325 #define TEST_EXCEPTIONS 1
 326
 327 // HAVE_CPP_EXCEPTIONS is defined automagically on unix
 328 #if defined(XP_UNIX) || defined(XP_BEOS) || defined(XP_OS2)
 329 #if !defined(HAVE_CPP_EXCEPTIONS)
 330 #undef TEST_EXCEPTIONS
 331 #endif
 332 #endif
 333
 334 #ifdef TEST_EXCEPTIONS
 335 static
 336 nsresult
 337 TestBloat_Raw()
 338         {
 339                 IBar* barP = 0;
 340                 nsresult result = CreateIBar(REINTERPRET_CAST(void**, &barP));
 341
 342                 if ( barP )
 343                         {
 344                                 try
 345                                         {
 346                                                 IFoo* fooP = 0;
 347                                                 if ( NS_SUCCEEDED( result = barP->QueryInterface(NS_GET_IID(IFoo), REINTERPRET_CAST(void**, &fooP)) ) )
 348                                                         {
 349                                                                 try
 350                                                                         {
 351                                                                                 fooP->print_totals();
 352                                                                         }
 353                                                                 catch( ... )
 354                                                                         {
 355                                                                                 NS_RELEASE(fooP);
 356                                                                                 throw;
 357                                                                         }
 358
 359                                                                 NS_RELEASE(fooP);
 360                                                         }
 361                                         }
 362                                 catch( ... )
 363                                         {
 364                                                 NS_RELEASE(barP);
 365                                                 throw;
 366                                         }
 367
 368                                 NS_RELEASE(barP);
 369                         }
 370
 371                 return result;
 372         }
 373 #endif // TEST_EXCEPTIONS
 374
 375 static
 376 nsresult
 377 TestBloat_Raw_Unsafe()
 378         {
 379                 IBar* barP = 0;
 380                 nsresult result = CreateIBar(REINTERPRET_CAST(void**, &barP));
 381
 382                 if ( barP )
 383                         {
 384                                 IFoo* fooP = 0;
 385                                 if ( NS_SUCCEEDED( result = barP->QueryInterface(NS_GET_IID(IFoo), REINTERPRET_CAST(void**, &fooP)) ) )
 386                                         {
 387                                                 fooP->print_totals();
 388                                                 NS_RELEASE(fooP);
 389                                         }
 390
 391                                 NS_RELEASE(barP);
 392                         }
 393
 394                 return result;
 395         }
 396
 397
 398 static
 399 nsresult
 400 TestBloat_Smart()
 401         {
 402                 nsCOMPtr<IBar> barP;
 403                 nsresult result = CreateIBar( getter_AddRefs(barP) );
 404
 405                 nsCOMPtr<IFoo> fooP( do_QueryInterface(barP, &result) );
 406
 407                 if ( fooP )
 408                         fooP->print_totals();
 409
 410                 return result;
 411         }
 412
 413
 414
 415
 416 nsCOMPtr<IFoo> gFoop;
 417
 418 int
 419 main()
 420   {
 421     printf(">>main()\n");
 422
 423                 printf("sizeof(nsCOMPtr<IFoo>) --> %d\n", sizeof(nsCOMPtr<IFoo>));
 424
 425 #ifdef TEST_EXCEPTIONS
 426                 TestBloat_Raw();
 427 #endif // TEST_EXCEPTIONS
 428                 TestBloat_Raw_Unsafe();
 429                 TestBloat_Smart();
 430
 431
 432     {
 433       printf("\n### Test  1: will a |nsCOMPtr| call |AddRef| on a pointer assigned into it?\n");
 434       nsCOMPtr<IFoo> foop( do_QueryInterface(new IFoo) );
 435
 436       printf("\n### Test  2: will a |nsCOMPtr| |Release| its old pointer when a new one is assigned in?\n");
 437       foop = do_QueryInterface(new IFoo);
 438
 439         // [Shouldn't compile] Is it a compile time error to try to |AddRef| by hand?
 440       //foop->AddRef();
 441
 442         // [Shouldn't compile] Is it a compile time error to try to |Release| be hand?
 443       //foop->Release();
 444
 445                                 // [Shouldn't compile] Is it a compile time error to try to |delete| an |nsCOMPtr|?
 446                         //delete foop;
 447
 448       printf("\n### Test  3: can you |AddRef| if you must?\n");
 449       STATIC_CAST(IFoo*, foop)->AddRef();
 450
 451       printf("\n### Test  4: can you |Release| if you must?\n");
 452       STATIC_CAST(IFoo*, foop)->Release();
 453
 454       printf("\n### Test  5: will a |nsCOMPtr| |Release| when it goes out of scope?\n");
 455     }
 456
 457     {
 458       printf("\n### Test  6: will a |nsCOMPtr| call the correct destructor?\n");
 459       nsCOMPtr<IFoo> foop( do_QueryInterface(new IBar) );
 460     }
 461
 462     {
 463       printf("\n### Test  7: can you compare one |nsCOMPtr| with another [!=]?\n");
 464
 465       nsCOMPtr<IFoo> foo1p( do_QueryInterface(new IFoo) );
 466
 467         // [Shouldn't compile] Is it a compile time error to omit |getter_[doesnt_]AddRef[s]|?
 468       //AnIFooPtrPtrContext(&foo1p);
 469
 470         // [Shouldn't compile] Is it a compile time error to omit |getter_[doesnt_]AddRef[s]|?
 471       //AVoidPtrPtrContext(&foo1p);
 472
 473       nsCOMPtr<IFoo> foo2p( do_QueryInterface(new IFoo) );
 474
 475       if ( foo1p != foo2p )
 476         printf("foo1p != foo2p\n");
 477       else
 478         printf("foo1p == foo2p\n");
 479
 480       printf("\n### Test  7.5: can you compare a |nsCOMPtr| with NULL, 0, nsnull [!=]?\n");
 481       if ( foo1p != 0 )
 482         printf("foo1p != 0\n");
 483       if ( 0 != foo1p )
 484         printf("0 != foo1p\n");
 485       if ( foo1p == 0 )
 486         printf("foo1p == 0\n");
 487       if ( 0 == foo1p )
 488         printf("0 == foo1p\n");
 489
 490
 491       IFoo* raw_foo2p = foo2p.get();
 492
 493       printf("\n### Test  8: can you compare a |nsCOMPtr| with a raw interface pointer [!=]?\n");
 494       if ( foo1p.get() != raw_foo2p )
 495         printf("foo1p != raw_foo2p\n");
 496       else
 497         printf("foo1p == raw_foo2p\n");
 498
 499
 500       printf("\n### Test  9: can you assign one |nsCOMPtr| into another?\n");
 501       foo1p = foo2p;
 502
 503       printf("\n### Test 10: can you compare one |nsCOMPtr| with another [==]?\n");
 504       if ( foo1p == foo2p )
 505         printf("foo1p == foo2p\n");
 506       else
 507         printf("foo1p != foo2p\n");
 508
 509       printf("\n### Test 11: can you compare a |nsCOMPtr| with a raw interface pointer [==]?\n");
 510       if ( raw_foo2p == foo2p.get() )
 511         printf("raw_foo2p == foo2p\n");
 512       else
 513         printf("raw_foo2p != foo2p\n");
 514
 515 #if 1
 516       printf("\n### Test 11.5: can you compare a |nsCOMPtr| with a raw interface pointer [==]?\n");
 517       if ( nsCOMPtr<IFoo>( raw_foo2p ) == foo2p )
 518         printf("raw_foo2p == foo2p\n");
 519       else
 520         printf("raw_foo2p != foo2p\n");
 521 #endif
 522
 523       printf("\n### Test 12: bare pointer test?\n");
 524       if ( foo1p )
 525         printf("foo1p is not NULL\n");
 526       else
 527         printf("foo1p is NULL\n");
 528
 529       printf("\n### Test 13: numeric pointer test?\n");
 530       if ( foo1p == 0 )
 531         printf("foo1p is NULL\n");
 532       else
 533         printf("foo1p is not NULL\n");
 534
 535 #if 0
 536                         if ( foo1p == 1 )
 537                                 printf("foo1p allowed compare with in\n");
 538 #endif
 539
 540       printf("\n### Test 14: how about when two |nsCOMPtr|s referring to the same object go out of scope?\n");
 541     }
 542
 543     {
 544       printf("\n### Test 15,16 ...setup...\n");
 545       IFoo* raw_foo1p = new IFoo;
 546       raw_foo1p->AddRef();
 547
 548       IFoo* raw_foo2p = new IFoo;
 549       raw_foo2p->AddRef();
 550
 551       printf("\n### Test 15: what if I don't want to |AddRef| when I construct?\n");
 552       nsCOMPtr<IFoo> foo1p( dont_AddRef(raw_foo1p) );
 553       //nsCOMPtr<IFoo> foo1p = dont_AddRef(raw_foo1p);
 554
 555       printf("\n### Test 16: what if I don't want to |AddRef| when I assign in?\n");
 556       nsCOMPtr<IFoo> foo2p;
 557       foo2p = dont_AddRef(raw_foo2p);
 558     }
 559
 560
 561
 562
 563
 564
 565
 566     {
 567         printf("\n### setup for Test 17\n");
 568       nsCOMPtr<IFoo> foop;
 569       printf("### Test 17: basic parameter behavior?\n");
 570       CreateIFoo( nsGetterAddRefs<IFoo>(foop) );
 571     }
 572     printf("### End Test 17\n");
 573
 574
 575     {
 576         printf("\n### setup for Test 18\n");
 577       nsCOMPtr<IFoo> foop;
 578       printf("### Test 18: basic parameter behavior, using the short form?\n");
 579       CreateIFoo( getter_AddRefs(foop) );
 580     }
 581     printf("### End Test 18\n");
 582
 583
 584     {
 585         printf("\n### setup for Test 19, 20\n");
 586       nsCOMPtr<IFoo> foop;
 587       printf("### Test 19: reference parameter behavior?\n");
 588       set_a_IFoo(address_of(foop));
 589
 590       printf("### Test 20: return value behavior?\n");
 591       foop = return_a_IFoo();
 592     }
 593     printf("### End Test 19, 20\n");
 594
 595                 {
 596         printf("\n### setup for Test 21\n");
 597                         nsCOMPtr<IFoo> fooP;
 598
 599                         printf("### Test 21: is |QueryInterface| called on assigning in a raw pointer?\n");
 600                         fooP = do_QueryInterface(new IFoo);
 601                 }
 602     printf("### End Test 21\n");
 603
 604                 {
 605         printf("\n### setup for Test 22\n");
 606                         nsCOMPtr<IFoo> fooP;
 607                         fooP = do_QueryInterface(new IFoo);
 608
 609                         nsCOMPtr<IFoo> foo2P;
 610
 611                         printf("### Test 22: is |QueryInterface| _not_ called when assigning in a smart-pointer of the same type?\n");
 612                         foo2P = fooP;
 613                 }
 614     printf("### End Test 22\n");
 615
 616                 {
 617         printf("\n### setup for Test 23\n");
 618                         nsCOMPtr<IBar> barP( do_QueryInterface(new IBar) );
 619
 620                         printf("### Test 23: is |QueryInterface| called when assigning in a smart-pointer of a different type?\n");
 621
 622                         nsCOMPtr<IFoo> fooP( do_QueryInterface(barP) );
 623                         if ( fooP )
 624                                 printf("an IBar* is an IFoo*\n");
 625                 }
 626     printf("### End Test 23\n");
 627
 628
 629                 {
 630         printf("\n### setup for Test 24\n");
 631                         nsCOMPtr<IFoo> fooP( do_QueryInterface(new IFoo) );
 632
 633                         printf("### Test 24: does |forget| avoid an AddRef/Release when assigning to another nsCOMPtr?\n");
 634       nsCOMPtr<IFoo> fooP2( fooP.forget() );
 635                 }
 636     printf("### End Test 24\n");
 637
 638                 {
 639                         nsCOMPtr<IFoo> fooP;
 640
 641                         AnIFooPtrPtrContext( getter_AddRefs(fooP) );
 642                         AVoidPtrPtrContext( getter_AddRefs(fooP) );
 643                         AnISupportsPtrPtrContext( getter_AddRefs(fooP) );
 644                 }
 645
 646
 647                 {
 648                         nsCOMPtr<nsISupports> supportsP;
 649
 650                         AVoidPtrPtrContext( getter_AddRefs(supportsP) );
 651                         AnISupportsPtrPtrContext( getter_AddRefs(supportsP) );
 652                 }
 653
 654
 655     printf("\n### Test 25: will a static |nsCOMPtr| |Release| before program termination?\n");
 656     gFoop = do_QueryInterface(new IFoo);
 657
 658     printf("<<main()\n");
 659     return 0;
 660   }
 661