test-suite/refcount.cc

   1
   2 /*
   3  * $Id$
   4  *
   5  * DEBUG: section xx    Refcount allocator
   6  * AUTHOR:  Robert Collins
   7  *
   8  * SQUID Web Proxy Cache          http://www.squid-cache.org/
   9  * ----------------------------------------------------------
  10  *
  11  *  Squid is the result of efforts by numerous individuals from
  12  *  the Internet community; see the CONTRIBUTORS file for full
  13  *  details.   Many organizations have provided support for Squid's
  14  *  development; see the SPONSORS file for full details.  Squid is
  15  *  Copyrighted (C) 2001 by the Regents of the University of
  16  *  California; see the COPYRIGHT file for full details.  Squid
  17  *  incorporates software developed and/or copyrighted by other
  18  *  sources; see the CREDITS file for full details.
  19  *
  20  *  This program is free software; you can redistribute it and/or modify
  21  *  it under the terms of the GNU General Public License as published by
  22  *  the Free Software Foundation; either version 2 of the License, or
  23  *  (at your option) any later version.
  24  *
  25  *  This program is distributed in the hope that it will be useful,
  26  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  27  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  28  *  GNU General Public License for more details.
  29  *
  30  *  You should have received a copy of the GNU General Public License
  31  *  along with this program; if not, write to the Free Software
  32  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111, USA.
  33  *
  34  */
  35
  36 #include "squid.h"
  37 #include "RefCount.h"
  38
  39 class _ToRefCount :public RefCountable
  40 {
  41
  42 public:
  43     _ToRefCount () {++Instances;}
  44
  45     ~_ToRefCount() {--Instances;}
  46
  47     int someMethod() {
  48         if (!this)
  49             exit(1);
  50
  51         return 1;
  52     }
  53
  54     static int Instances;
  55
  56 private:
  57 };
  58
  59 typedef RefCount<_ToRefCount> ToRefCount;
  60
  61 /* Must be zero at the end for the test to pass. */
  62 int _ToRefCount::Instances = 0;
  63
  64 class AlsoRefCountable : public RefCountable, public _ToRefCount
  65 {
  66
  67 public:
  68     typedef RefCount<AlsoRefCountable> Pointer;
  69
  70     int doSomething() {
  71         if (!this)
  72             exit (1);
  73         return 1;
  74     }
  75 };
  76
  77 int
  78 main (int argc, char **argv)
  79 {
  80     {
  81         ToRefCount anObject(new _ToRefCount);
  82         anObject->someMethod();
  83         anObject = anObject;
  84         ToRefCount objectTwo (anObject);
  85         anObject = objectTwo;
  86         {
  87             ToRefCount anotherObject(new _ToRefCount);
  88             anObject = anotherObject;
  89         }
  90
  91         {
  92             ToRefCount aForthObject (anObject);
  93             anObject = ToRefCount(NULL);
  94             aForthObject->someMethod();
  95             aForthObject = NULL;
  96         }
  97     }
  98
  99     /* Test creating an object, using it , and then making available as a
 100      * refcounted one:
 101      */
 102     {
 103         _ToRefCount *aPointer = new _ToRefCount;
 104         aPointer->someMethod();
 105         ToRefCount anObject(aPointer);
 106     }
 107     /* standalone pointers should be usable */
 108     {
 109         ToRefCount anObject;
 110     }
 111     /* Can we check pointers for equality */
 112     {
 113         ToRefCount anObject;
 114         ToRefCount anotherObject(new _ToRefCount);
 115
 116         if (anObject == anotherObject)
 117             exit (1);
 118
 119         anotherObject = NULL;
 120
 121         if (!(anObject == anotherObject))
 122             exit (1);
 123     }
 124     /* Can we get the pointer for a const object */
 125     {
 126         ToRefCount anObject (new _ToRefCount);
 127         ToRefCount const aConstObject (anObject);
 128         _ToRefCount const *aPointer = aConstObject.getRaw();
 129
 130         if (aPointer != anObject.getRaw())
 131             exit (2);
 132     }
 133     /* Can we get a refcounted pointer from a const object */
 134     {
 135         _ToRefCount const * aPointer = new _ToRefCount;
 136         ToRefCount anObject (aPointer);
 137     }
 138     /* Can we get a pointer to nonconst from a nonconst refcounter */
 139     {
 140         ToRefCount anObject (new _ToRefCount);
 141         _ToRefCount *aPointer = anObject.getRaw();
 142         aPointer = NULL;
 143     }
 144     /* Create a doubley inheriting refcount instance,
 145      * cast to a single inheritance instance,
 146      * then hope :}
 147      */
 148     {
 149         ToRefCount aBaseObject;
 150         {
 151             AlsoRefCountable::Pointer anObject (new AlsoRefCountable);
 152             aBaseObject = anObject.getRaw();
 153         }
 154     }
 155     return _ToRefCount::Instances == 0 ? 0 : 1;
 156 }