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 static
 324 nsresult
 325 TestBloat_Raw_Unsafe()
 326         {
 327                 IBar* barP = 0;
 328                 nsresult result = CreateIBar(REINTERPRET_CAST(void**, &barP));
 329
 330                 if ( barP )
 331                         {
 332                                 IFoo* fooP = 0;
 333                                 if ( NS_SUCCEEDED( result = barP->QueryInterface(NS_GET_IID(IFoo), REINTERPRET_CAST(void**, &fooP)) ) )
 334                                         {
 335                                                 fooP->print_totals();
 336                                                 NS_RELEASE(fooP);
 337                                         }
 338
 339                                 NS_RELEASE(barP);
 340                         }
 341
 342                 return result;
 343         }
 344
 345
 346 static
 347 nsresult
 348 TestBloat_Smart()
 349         {
 350                 nsCOMPtr<IBar> barP;
 351                 nsresult result = CreateIBar( getter_AddRefs(barP) );
 352
 353                 nsCOMPtr<IFoo> fooP( do_QueryInterface(barP, &result) );
 354
 355                 if ( fooP )
 356                         fooP->print_totals();
 357
 358                 return result;
 359         }
 360
 361
 362
 363
 364 nsCOMPtr<IFoo> gFoop;
 365
 366 int
 367 main()
 368   {
 369     printf(">>main()\n");
 370
 371                 printf("sizeof(nsCOMPtr<IFoo>) --> %u\n", unsigned(sizeof(nsCOMPtr<IFoo>)));
 372
 373                 TestBloat_Raw_Unsafe();
 374                 TestBloat_Smart();
 375
 376
 377     {
 378       printf("\n### Test  1: will a |nsCOMPtr| call |AddRef| on a pointer assigned into it?\n");
 379       nsCOMPtr<IFoo> foop( do_QueryInterface(new IFoo) );
 380
 381       printf("\n### Test  2: will a |nsCOMPtr| |Release| its old pointer when a new one is assigned in?\n");
 382       foop = do_QueryInterface(new IFoo);
 383
 384         // [Shouldn't compile] Is it a compile time error to try to |AddRef| by hand?
 385       //foop->AddRef();
 386
 387         // [Shouldn't compile] Is it a compile time error to try to |Release| be hand?
 388       //foop->Release();
 389
 390                                 // [Shouldn't compile] Is it a compile time error to try to |delete| an |nsCOMPtr|?
 391                         //delete foop;
 392
 393       printf("\n### Test  3: can you |AddRef| if you must?\n");
 394       STATIC_CAST(IFoo*, foop)->AddRef();
 395
 396       printf("\n### Test  4: can you |Release| if you must?\n");
 397       STATIC_CAST(IFoo*, foop)->Release();
 398
 399       printf("\n### Test  5: will a |nsCOMPtr| |Release| when it goes out of scope?\n");
 400     }
 401
 402     {
 403       printf("\n### Test  6: will a |nsCOMPtr| call the correct destructor?\n");
 404       nsCOMPtr<IFoo> foop( do_QueryInterface(new IBar) );
 405     }
 406
 407     {
 408       printf("\n### Test  7: can you compare one |nsCOMPtr| with another [!=]?\n");
 409
 410       nsCOMPtr<IFoo> foo1p( do_QueryInterface(new IFoo) );
 411
 412         // [Shouldn't compile] Is it a compile time error to omit |getter_[doesnt_]AddRef[s]|?
 413       //AnIFooPtrPtrContext(&foo1p);
 414
 415         // [Shouldn't compile] Is it a compile time error to omit |getter_[doesnt_]AddRef[s]|?
 416       //AVoidPtrPtrContext(&foo1p);
 417
 418       nsCOMPtr<IFoo> foo2p( do_QueryInterface(new IFoo) );
 419
 420       if ( foo1p != foo2p )
 421         printf("foo1p != foo2p\n");
 422       else
 423         printf("foo1p == foo2p\n");
 424
 425       printf("\n### Test  7.5: can you compare a |nsCOMPtr| with NULL, 0, nsnull [!=]?\n");
 426       if ( foo1p != 0 )
 427         printf("foo1p != 0\n");
 428       if ( 0 != foo1p )
 429         printf("0 != foo1p\n");
 430       if ( foo1p == 0 )
 431         printf("foo1p == 0\n");
 432       if ( 0 == foo1p )
 433         printf("0 == foo1p\n");
 434
 435
 436       IFoo* raw_foo2p = foo2p.get();
 437
 438       printf("\n### Test  8: can you compare a |nsCOMPtr| with a raw interface pointer [!=]?\n");
 439       if ( foo1p.get() != raw_foo2p )
 440         printf("foo1p != raw_foo2p\n");
 441       else
 442         printf("foo1p == raw_foo2p\n");
 443
 444
 445       printf("\n### Test  9: can you assign one |nsCOMPtr| into another?\n");
 446       foo1p = foo2p;
 447
 448       printf("\n### Test 10: can you compare one |nsCOMPtr| with another [==]?\n");
 449       if ( foo1p == foo2p )
 450         printf("foo1p == foo2p\n");
 451       else
 452         printf("foo1p != foo2p\n");
 453
 454       printf("\n### Test 11: can you compare a |nsCOMPtr| with a raw interface pointer [==]?\n");
 455       if ( raw_foo2p == foo2p.get() )
 456         printf("raw_foo2p == foo2p\n");
 457       else
 458         printf("raw_foo2p != foo2p\n");
 459
 460 #if 1
 461       printf("\n### Test 11.5: can you compare a |nsCOMPtr| with a raw interface pointer [==]?\n");
 462       if ( nsCOMPtr<IFoo>( raw_foo2p ) == foo2p )
 463         printf("raw_foo2p == foo2p\n");
 464       else
 465         printf("raw_foo2p != foo2p\n");
 466 #endif
 467
 468       printf("\n### Test 12: bare pointer test?\n");
 469       if ( foo1p )
 470         printf("foo1p is not NULL\n");
 471       else
 472         printf("foo1p is NULL\n");
 473
 474       printf("\n### Test 13: numeric pointer test?\n");
 475       if ( foo1p == 0 )
 476         printf("foo1p is NULL\n");
 477       else
 478         printf("foo1p is not NULL\n");
 479
 480 #if 0
 481                         if ( foo1p == 1 )
 482                                 printf("foo1p allowed compare with in\n");
 483 #endif
 484
 485       printf("\n### Test 14: how about when two |nsCOMPtr|s referring to the same object go out of scope?\n");
 486     }
 487
 488     {
 489       printf("\n### Test 15,16 ...setup...\n");
 490       IFoo* raw_foo1p = new IFoo;
 491       raw_foo1p->AddRef();
 492
 493       IFoo* raw_foo2p = new IFoo;
 494       raw_foo2p->AddRef();
 495
 496       printf("\n### Test 15: what if I don't want to |AddRef| when I construct?\n");
 497       nsCOMPtr<IFoo> foo1p( dont_AddRef(raw_foo1p) );
 498       //nsCOMPtr<IFoo> foo1p = dont_AddRef(raw_foo1p);
 499
 500       printf("\n### Test 16: what if I don't want to |AddRef| when I assign in?\n");
 501       nsCOMPtr<IFoo> foo2p;
 502       foo2p = dont_AddRef(raw_foo2p);
 503     }
 504
 505
 506
 507
 508
 509
 510
 511     {
 512         printf("\n### setup for Test 17\n");
 513       nsCOMPtr<IFoo> foop;
 514       printf("### Test 17: basic parameter behavior?\n");
 515       CreateIFoo( nsGetterAddRefs<IFoo>(foop) );
 516     }
 517     printf("### End Test 17\n");
 518
 519
 520     {
 521         printf("\n### setup for Test 18\n");
 522       nsCOMPtr<IFoo> foop;
 523       printf("### Test 18: basic parameter behavior, using the short form?\n");
 524       CreateIFoo( getter_AddRefs(foop) );
 525     }
 526     printf("### End Test 18\n");
 527
 528
 529     {
 530         printf("\n### setup for Test 19, 20\n");
 531       nsCOMPtr<IFoo> foop;
 532       printf("### Test 19: reference parameter behavior?\n");
 533       set_a_IFoo(address_of(foop));
 534
 535       printf("### Test 20: return value behavior?\n");
 536       foop = return_a_IFoo();
 537     }
 538     printf("### End Test 19, 20\n");
 539
 540                 {
 541         printf("\n### setup for Test 21\n");
 542                         nsCOMPtr<IFoo> fooP;
 543
 544                         printf("### Test 21: is |QueryInterface| called on assigning in a raw pointer?\n");
 545                         fooP = do_QueryInterface(new IFoo);
 546                 }
 547     printf("### End Test 21\n");
 548
 549                 {
 550         printf("\n### setup for Test 22\n");
 551                         nsCOMPtr<IFoo> fooP;
 552                         fooP = do_QueryInterface(new IFoo);
 553
 554                         nsCOMPtr<IFoo> foo2P;
 555
 556                         printf("### Test 22: is |QueryInterface| _not_ called when assigning in a smart-pointer of the same type?\n");
 557                         foo2P = fooP;
 558                 }
 559     printf("### End Test 22\n");
 560
 561                 {
 562         printf("\n### setup for Test 23\n");
 563                         nsCOMPtr<IBar> barP( do_QueryInterface(new IBar) );
 564
 565                         printf("### Test 23: is |QueryInterface| called when assigning in a smart-pointer of a different type?\n");
 566
 567                         nsCOMPtr<IFoo> fooP( do_QueryInterface(barP) );
 568                         if ( fooP )
 569                                 printf("an IBar* is an IFoo*\n");
 570                 }
 571     printf("### End Test 23\n");
 572
 573
 574                 {
 575         printf("\n### setup for Test 24\n");
 576                         nsCOMPtr<IFoo> fooP( do_QueryInterface(new IFoo) );
 577
 578                         printf("### Test 24: does |forget| avoid an AddRef/Release when assigning to another nsCOMPtr?\n");
 579       nsCOMPtr<IFoo> fooP2( fooP.forget() );
 580                 }
 581     printf("### End Test 24\n");
 582
 583                 {
 584                         nsCOMPtr<IFoo> fooP;
 585
 586                         AnIFooPtrPtrContext( getter_AddRefs(fooP) );
 587                         AVoidPtrPtrContext( getter_AddRefs(fooP) );
 588                         AnISupportsPtrPtrContext( getter_AddRefs(fooP) );
 589                 }
 590
 591
 592                 {
 593                         nsCOMPtr<nsISupports> supportsP;
 594
 595                         AVoidPtrPtrContext( getter_AddRefs(supportsP) );
 596                         AnISupportsPtrPtrContext( getter_AddRefs(supportsP) );
 597                 }
 598
 599
 600     printf("\n### Test 25: will a static |nsCOMPtr| |Release| before program termination?\n");
 601     gFoop = do_QueryInterface(new IFoo);
 602
 603     printf("<<main()\n");
 604     return 0;
 605   }
 606