Back to index

lightning-sunbird  0.9+nobinonly
Classes | Defines | Typedefs | Functions | Variables
TestCOMPtr.cpp File Reference
#include <assert.h>
#include <stdio.h>
#include "nsCOMPtr.h"
#include "nsISupports.h"

Go to the source code of this file.

Classes

class  IFoo
class  test_message
class  IBar

Defines

#define STATIC_CAST(T, x)   ((T)(x))
#define REINTERPRET_CAST(T, x)   ((T)(x))
#define NS_IFOO_IID
#define NS_IBAR_IID
#define TEST_EXCEPTIONS   1

Typedefs

typedef unsigned long NS_RESULT

Functions

nsresult CreateIFoo (void **)
nsresult CreateIBar (void **result)
void AnIFooPtrPtrContext (IFoo **)
void AnISupportsPtrPtrContext (nsISupports **)
void AVoidPtrPtrContext (void **)
void set_a_IFoo (nsCOMPtr< IFoo > *result)
nsCOMPtr< IFooreturn_a_IFoo ()
static nsresult TestBloat_Raw ()
static nsresult TestBloat_Raw_Unsafe ()
static nsresult TestBloat_Smart ()
int main ()
 main()

Variables

test_message gTestMessage
nsCOMPtr< IFoogFoop

Define Documentation

Value:
{ 0x6f7652e1,  0xee43, 0x11d1, \
 { 0x9c, 0xc3, 0x00, 0x60, 0x08, 0x8c, 0xa6, 0xb3 } }

Definition at line 238 of file TestCOMPtr.cpp.

Value:
{ 0x6f7652e0,  0xee43, 0x11d1, \
 { 0x9c, 0xc3, 0x00, 0x60, 0x08, 0x8c, 0xa6, 0xb3 } }

Definition at line 53 of file TestCOMPtr.cpp.

#define REINTERPRET_CAST (   T,
  x 
)    ((T)(x))

Definition at line 49 of file TestCOMPtr.cpp.

#define STATIC_CAST (   T,
  x 
)    ((T)(x))

Definition at line 48 of file TestCOMPtr.cpp.

Definition at line 324 of file TestCOMPtr.cpp.


Typedef Documentation

typedef unsigned long NS_RESULT

Definition at line 80 of file TestCOMPtr.cpp.


Function Documentation

Definition at line 308 of file TestCOMPtr.cpp.

  {
  }

Here is the caller graph for this function:

void AnISupportsPtrPtrContext ( nsISupports **  )

Definition at line 318 of file TestCOMPtr.cpp.

       {
       }

Here is the caller graph for this function:

Definition at line 313 of file TestCOMPtr.cpp.

  {
  }

Here is the caller graph for this function:

nsresult CreateIBar ( void **  result)

Definition at line 293 of file TestCOMPtr.cpp.

  {
    printf(">>CreateIBar() --> ");
    IBar* barp = new IBar;
    printf("IBar@%p\n", STATIC_CAST(void*, barp));

    barp->AddRef();
    *result = barp;

    printf("<<CreateIBar()\n");
    return 0;
  }

Here is the caller graph for this function:

nsresult CreateIFoo ( void **  result)

Definition at line 201 of file TestCOMPtr.cpp.

  {
    printf(">>CreateIFoo() --> ");
    IFoo* foop = new IFoo;
    printf("IFoo@%p\n", STATIC_CAST(void*, foop));

    foop->AddRef();
    *result = foop;

    printf("<<CreateIFoo()\n");
    return 0;
  }

Here is the caller graph for this function:

int main ( void  )

main()

Definition at line 418 of file TestCOMPtr.cpp.

  {
    printf(">>main()\n");

              printf("sizeof(nsCOMPtr<IFoo>) --> %d\n", sizeof(nsCOMPtr<IFoo>));

#ifdef TEST_EXCEPTIONS
              TestBloat_Raw();
#endif // TEST_EXCEPTIONS
              TestBloat_Raw_Unsafe();
              TestBloat_Smart();


    {
      printf("\n### Test  1: will a |nsCOMPtr| call |AddRef| on a pointer assigned into it?\n");
      nsCOMPtr<IFoo> foop( do_QueryInterface(new IFoo) );

      printf("\n### Test  2: will a |nsCOMPtr| |Release| its old pointer when a new one is assigned in?\n");
      foop = do_QueryInterface(new IFoo);

        // [Shouldn't compile] Is it a compile time error to try to |AddRef| by hand?
      //foop->AddRef();

        // [Shouldn't compile] Is it a compile time error to try to |Release| be hand?
      //foop->Release();

                            // [Shouldn't compile] Is it a compile time error to try to |delete| an |nsCOMPtr|?
                     //delete foop;

      printf("\n### Test  3: can you |AddRef| if you must?\n");
      STATIC_CAST(IFoo*, foop)->AddRef();

      printf("\n### Test  4: can you |Release| if you must?\n");
      STATIC_CAST(IFoo*, foop)->Release();

      printf("\n### Test  5: will a |nsCOMPtr| |Release| when it goes out of scope?\n");
    }

    {
      printf("\n### Test  6: will a |nsCOMPtr| call the correct destructor?\n");
      nsCOMPtr<IFoo> foop( do_QueryInterface(new IBar) );
    }

    {
      printf("\n### Test  7: can you compare one |nsCOMPtr| with another [!=]?\n");

      nsCOMPtr<IFoo> foo1p( do_QueryInterface(new IFoo) );

        // [Shouldn't compile] Is it a compile time error to omit |getter_[doesnt_]AddRef[s]|?
      //AnIFooPtrPtrContext(&foo1p);

        // [Shouldn't compile] Is it a compile time error to omit |getter_[doesnt_]AddRef[s]|?
      //AVoidPtrPtrContext(&foo1p);

      nsCOMPtr<IFoo> foo2p( do_QueryInterface(new IFoo) );

      if ( foo1p != foo2p )
        printf("foo1p != foo2p\n");
      else
        printf("foo1p == foo2p\n");

      printf("\n### Test  7.5: can you compare a |nsCOMPtr| with NULL, 0, nsnull [!=]?\n");
      if ( foo1p != 0 )
       printf("foo1p != 0\n");
      if ( 0 != foo1p )
       printf("0 != foo1p\n");
      if ( foo1p == 0 )
       printf("foo1p == 0\n");
      if ( 0 == foo1p )
       printf("0 == foo1p\n");
                     

      IFoo* raw_foo2p = foo2p.get();

      printf("\n### Test  8: can you compare a |nsCOMPtr| with a raw interface pointer [!=]?\n");
      if ( foo1p.get() != raw_foo2p )
        printf("foo1p != raw_foo2p\n");
      else
        printf("foo1p == raw_foo2p\n");


      printf("\n### Test  9: can you assign one |nsCOMPtr| into another?\n");
      foo1p = foo2p;

      printf("\n### Test 10: can you compare one |nsCOMPtr| with another [==]?\n");
      if ( foo1p == foo2p )
        printf("foo1p == foo2p\n");
      else
        printf("foo1p != foo2p\n");

      printf("\n### Test 11: can you compare a |nsCOMPtr| with a raw interface pointer [==]?\n");
      if ( raw_foo2p == foo2p.get() )
        printf("raw_foo2p == foo2p\n");
      else
        printf("raw_foo2p != foo2p\n");

#if 1
      printf("\n### Test 11.5: can you compare a |nsCOMPtr| with a raw interface pointer [==]?\n");
      if ( nsCOMPtr<IFoo>( raw_foo2p ) == foo2p )
        printf("raw_foo2p == foo2p\n");
      else
        printf("raw_foo2p != foo2p\n");
#endif

      printf("\n### Test 12: bare pointer test?\n");
      if ( foo1p )
        printf("foo1p is not NULL\n");
      else
        printf("foo1p is NULL\n");

      printf("\n### Test 13: numeric pointer test?\n");
      if ( foo1p == 0 )
        printf("foo1p is NULL\n");
      else
        printf("foo1p is not NULL\n");

#if 0
                     if ( foo1p == 1 )
                            printf("foo1p allowed compare with in\n");
#endif

      printf("\n### Test 14: how about when two |nsCOMPtr|s referring to the same object go out of scope?\n");
    }

    {
      printf("\n### Test 15,16 ...setup...\n");
      IFoo* raw_foo1p = new IFoo;
      raw_foo1p->AddRef();

      IFoo* raw_foo2p = new IFoo;
      raw_foo2p->AddRef();

      printf("\n### Test 15: what if I don't want to |AddRef| when I construct?\n");
      nsCOMPtr<IFoo> foo1p( dont_AddRef(raw_foo1p) );
      //nsCOMPtr<IFoo> foo1p = dont_AddRef(raw_foo1p);

      printf("\n### Test 16: what if I don't want to |AddRef| when I assign in?\n");
      nsCOMPtr<IFoo> foo2p;
      foo2p = dont_AddRef(raw_foo2p);
    }







    {
       printf("\n### setup for Test 17\n");
      nsCOMPtr<IFoo> foop;
      printf("### Test 17: basic parameter behavior?\n");
      CreateIFoo( nsGetterAddRefs<IFoo>(foop) );
    }
    printf("### End Test 17\n");


    {
       printf("\n### setup for Test 18\n");
      nsCOMPtr<IFoo> foop;
      printf("### Test 18: basic parameter behavior, using the short form?\n");
      CreateIFoo( getter_AddRefs(foop) );
    }
    printf("### End Test 18\n");


    {
       printf("\n### setup for Test 19, 20\n");
      nsCOMPtr<IFoo> foop;
      printf("### Test 19: reference parameter behavior?\n");
      set_a_IFoo(address_of(foop));

      printf("### Test 20: return value behavior?\n");
      foop = return_a_IFoo();
    }
    printf("### End Test 19, 20\n");

              {
       printf("\n### setup for Test 21\n");
                     nsCOMPtr<IFoo> fooP;

                     printf("### Test 21: is |QueryInterface| called on assigning in a raw pointer?\n");
                     fooP = do_QueryInterface(new IFoo);
              }
    printf("### End Test 21\n");

              {
       printf("\n### setup for Test 22\n");
                     nsCOMPtr<IFoo> fooP;
                     fooP = do_QueryInterface(new IFoo);

                     nsCOMPtr<IFoo> foo2P;

                     printf("### Test 22: is |QueryInterface| _not_ called when assigning in a smart-pointer of the same type?\n");
                     foo2P = fooP;
              }
    printf("### End Test 22\n");

              {
       printf("\n### setup for Test 23\n");
                     nsCOMPtr<IBar> barP( do_QueryInterface(new IBar) );

                     printf("### Test 23: is |QueryInterface| called when assigning in a smart-pointer of a different type?\n");

                     nsCOMPtr<IFoo> fooP( do_QueryInterface(barP) );
                     if ( fooP )
                            printf("an IBar* is an IFoo*\n");
              }
    printf("### End Test 23\n");


              {
                     nsCOMPtr<IFoo> fooP;

                     AnIFooPtrPtrContext( getter_AddRefs(fooP) );
                     AVoidPtrPtrContext( getter_AddRefs(fooP) );
                     AnISupportsPtrPtrContext( getter_AddRefs(fooP) );
              }


              {
                     nsCOMPtr<nsISupports> supportsP;

                     AVoidPtrPtrContext( getter_AddRefs(supportsP) );
                     AnISupportsPtrPtrContext( getter_AddRefs(supportsP) );
              }


    printf("\n### Test 24: will a static |nsCOMPtr| |Release| before program termination?\n");
    gFoop = do_QueryInterface(new IFoo);
    
    printf("<<main()\n");
    return 0;
  }

Here is the call graph for this function:

Definition at line 227 of file TestCOMPtr.cpp.

  {
    printf(">>return_a_IFoo()\n");
    nsCOMPtr<IFoo> foop( do_QueryInterface(new IFoo) );
    printf("<<return_a_IFoo()\n");
    return foop;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

void set_a_IFoo ( nsCOMPtr< IFoo > *  result)

Definition at line 216 of file TestCOMPtr.cpp.

  {
    printf(">>set_a_IFoo()\n");
    assert(result);

    nsCOMPtr<IFoo> foop( do_QueryInterface(new IFoo) );
    *result = foop;
    printf("<<set_a_IFoo()\n");
  }

Here is the call graph for this function:

Here is the caller graph for this function:

static nsresult TestBloat_Raw ( ) [static]

Definition at line 336 of file TestCOMPtr.cpp.

       {
              IBar* barP = 0;
              nsresult result = CreateIBar(REINTERPRET_CAST(void**, &barP));

              if ( barP )
                     {
                            try
                                   {
                                          IFoo* fooP = 0;
                                          if ( NS_SUCCEEDED( result = barP->QueryInterface(NS_GET_IID(IFoo), REINTERPRET_CAST(void**, &fooP)) ) )
                                                 {
                                                        try
                                                               {
                                                                      fooP->print_totals();
                                                               }
                                                        catch( ... )
                                                               {
                                                                      NS_RELEASE(fooP);
                                                                      throw;
                                                               }

                                                        NS_RELEASE(fooP);
                                                 }
                                   }
                            catch( ... )
                                   {
                                          NS_RELEASE(barP);
                                          throw;
                                   }

                            NS_RELEASE(barP);
                     }

              return result;
       }

Here is the call graph for this function:

Here is the caller graph for this function:

static nsresult TestBloat_Raw_Unsafe ( ) [static]

Definition at line 376 of file TestCOMPtr.cpp.

       {
              IBar* barP = 0;
              nsresult result = CreateIBar(REINTERPRET_CAST(void**, &barP));

              if ( barP )
                     {
                            IFoo* fooP = 0;
                            if ( NS_SUCCEEDED( result = barP->QueryInterface(NS_GET_IID(IFoo), REINTERPRET_CAST(void**, &fooP)) ) )
                                   {
                                          fooP->print_totals();
                                          NS_RELEASE(fooP);
                                   }

                            NS_RELEASE(barP);
                     }

              return result;
       }

Here is the call graph for this function:

Here is the caller graph for this function:

static nsresult TestBloat_Smart ( ) [static]

Definition at line 399 of file TestCOMPtr.cpp.

       {
              nsCOMPtr<IBar> barP;
              nsresult result = CreateIBar( getter_AddRefs(barP) );

              nsCOMPtr<IFoo> fooP( do_QueryInterface(barP, &result) );

              if ( fooP )
                     fooP->print_totals();

              return result;
       }

Here is the call graph for this function:

Here is the caller graph for this function:


Variable Documentation

Definition at line 415 of file TestCOMPtr.cpp.

Definition at line 115 of file TestCOMPtr.cpp.