Annotation of OpenXM_contrib2/asir2000/gc5.3/test_cpp.cc, Revision 1.1
1.1 ! noro 1: /****************************************************************************
! 2: Copyright (c) 1994 by Xerox Corporation. All rights reserved.
! 3:
! 4: THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
! 5: OR IMPLIED. ANY USE IS AT YOUR OWN RISK.
! 6:
! 7: Permission is hereby granted to use or copy this program for any
! 8: purpose, provided the above notices are retained on all copies.
! 9: Permission to modify the code and to distribute modified code is
! 10: granted, provided the above notices are retained, and a notice that
! 11: the code was modified is included with the above copyright notice.
! 12: ****************************************************************************
! 13: Last modified on Mon Jul 10 21:06:03 PDT 1995 by ellis
! 14: modified on December 20, 1994 7:27 pm PST by boehm
! 15:
! 16: usage: test_cpp number-of-iterations
! 17:
! 18: This program tries to test the specific C++ functionality provided by
! 19: gc_c++.h that isn't tested by the more general test routines of the
! 20: collector.
! 21:
! 22: A recommended value for number-of-iterations is 10, which will take a
! 23: few minutes to complete.
! 24:
! 25: ***************************************************************************/
! 26:
! 27: #include "gc_cpp.h"
! 28: #include <stdio.h>
! 29: #include <stdlib.h>
! 30: #include <string.h>
! 31: #ifndef __GNUC__
! 32: # include "gc_alloc.h"
! 33: #endif
! 34: extern "C" {
! 35: #include "gc_priv.h"
! 36: }
! 37: #ifdef MSWIN32
! 38: # include <windows.h>
! 39: #endif
! 40: #ifdef GC_NAME_CONFLICT
! 41: # define USE_GC UseGC
! 42: struct foo * GC;
! 43: #else
! 44: # define USE_GC GC
! 45: #endif
! 46:
! 47:
! 48: #define my_assert( e ) \
! 49: if (! (e)) { \
! 50: GC_printf1( "Assertion failure in " __FILE__ ", line %d: " #e "\n", \
! 51: __LINE__ ); \
! 52: exit( 1 ); }
! 53:
! 54:
! 55: class A {public:
! 56: /* An uncollectable class. */
! 57:
! 58: A( int iArg ): i( iArg ) {}
! 59: void Test( int iArg ) {
! 60: my_assert( i == iArg );}
! 61: int i;};
! 62:
! 63:
! 64: class B: public gc, public A {public:
! 65: /* A collectable class. */
! 66:
! 67: B( int j ): A( j ) {}
! 68: ~B() {
! 69: my_assert( deleting );}
! 70: static void Deleting( int on ) {
! 71: deleting = on;}
! 72: static int deleting;};
! 73:
! 74: int B::deleting = 0;
! 75:
! 76:
! 77: class C: public gc_cleanup, public A {public:
! 78: /* A collectable class with cleanup and virtual multiple inheritance. */
! 79:
! 80: C( int levelArg ): A( levelArg ), level( levelArg ) {
! 81: nAllocated++;
! 82: if (level > 0) {
! 83: left = new C( level - 1 );
! 84: right = new C( level - 1 );}
! 85: else {
! 86: left = right = 0;}}
! 87: ~C() {
! 88: this->A::Test( level );
! 89: nFreed++;
! 90: my_assert( level == 0 ?
! 91: left == 0 && right == 0 :
! 92: level == left->level + 1 && level == right->level + 1 );
! 93: left = right = 0;
! 94: level = -123456;}
! 95: static void Test() {
! 96: my_assert( nFreed <= nAllocated && nFreed >= .8 * nAllocated );}
! 97:
! 98: static int nFreed;
! 99: static int nAllocated;
! 100: int level;
! 101: C* left;
! 102: C* right;};
! 103:
! 104: int C::nFreed = 0;
! 105: int C::nAllocated = 0;
! 106:
! 107:
! 108: class D: public gc {public:
! 109: /* A collectable class with a static member function to be used as
! 110: an explicit clean-up function supplied to ::new. */
! 111:
! 112: D( int iArg ): i( iArg ) {
! 113: nAllocated++;}
! 114: static void CleanUp( void* obj, void* data ) {
! 115: D* self = (D*) obj;
! 116: nFreed++;
! 117: my_assert( self->i == (int) (long) data );}
! 118: static void Test() {
! 119: my_assert( nFreed >= .8 * nAllocated );}
! 120:
! 121: int i;
! 122: static int nFreed;
! 123: static int nAllocated;};
! 124:
! 125: int D::nFreed = 0;
! 126: int D::nAllocated = 0;
! 127:
! 128:
! 129: class E: public gc_cleanup {public:
! 130: /* A collectable class with clean-up for use by F. */
! 131:
! 132: E() {
! 133: nAllocated++;}
! 134: ~E() {
! 135: nFreed++;}
! 136:
! 137: static int nFreed;
! 138: static int nAllocated;};
! 139:
! 140: int E::nFreed = 0;
! 141: int E::nAllocated = 0;
! 142:
! 143:
! 144: class F: public E {public:
! 145: /* A collectable class with clean-up, a base with clean-up, and a
! 146: member with clean-up. */
! 147:
! 148: F() {
! 149: nAllocated++;}
! 150: ~F() {
! 151: nFreed++;}
! 152: static void Test() {
! 153: my_assert( nFreed >= .8 * nAllocated );
! 154: my_assert( 2 * nFreed == E::nFreed );}
! 155:
! 156: E e;
! 157: static int nFreed;
! 158: static int nAllocated;};
! 159:
! 160: int F::nFreed = 0;
! 161: int F::nAllocated = 0;
! 162:
! 163:
! 164: long Disguise( void* p ) {
! 165: return ~ (long) p;}
! 166:
! 167: void* Undisguise( long i ) {
! 168: return (void*) ~ i;}
! 169:
! 170:
! 171: #ifdef MSWIN32
! 172: int APIENTRY WinMain(
! 173: HINSTANCE instance, HINSTANCE prev, LPSTR cmd, int cmdShow )
! 174: {
! 175: int argc;
! 176: char* argv[ 3 ];
! 177:
! 178: for (argc = 1; argc < sizeof( argv ) / sizeof( argv[ 0 ] ); argc++) {
! 179: argv[ argc ] = strtok( argc == 1 ? cmd : 0, " \t" );
! 180: if (0 == argv[ argc ]) break;}
! 181:
! 182: #else
! 183: # ifdef MACOS
! 184: int main() {
! 185: # else
! 186: int main( int argc, char* argv[] ) {
! 187: # endif
! 188: #endif
! 189:
! 190: # if defined(MACOS) // MacOS
! 191: char* argv_[] = {"test_cpp", "10"}; // doesn't
! 192: argv = argv_; // have a
! 193: argc = sizeof(argv_)/sizeof(argv_[0]); // commandline
! 194: # endif
! 195: int i, iters, n;
! 196: # if !defined(__GNUC__) && !defined(MACOS)
! 197: int *x = (int *)alloc::allocate(sizeof(int));
! 198:
! 199: *x = 29;
! 200: x -= 3;
! 201: # endif
! 202: if (argc != 2 || (0 >= (n = atoi( argv[ 1 ] )))) {
! 203: GC_printf0( "usage: test_cpp number-of-iterations\n" );
! 204: exit( 1 );}
! 205:
! 206: for (iters = 1; iters <= n; iters++) {
! 207: GC_printf1( "Starting iteration %d\n", iters );
! 208:
! 209: /* Allocate some uncollectable As and disguise their pointers.
! 210: Later we'll check to see if the objects are still there. We're
! 211: checking to make sure these objects really are uncollectable. */
! 212: long as[ 1000 ];
! 213: long bs[ 1000 ];
! 214: for (i = 0; i < 1000; i++) {
! 215: as[ i ] = Disguise( new (NoGC) A( i ) );
! 216: bs[ i ] = Disguise( new (NoGC) B( i ) );}
! 217:
! 218: /* Allocate a fair number of finalizable Cs, Ds, and Fs.
! 219: Later we'll check to make sure they've gone away. */
! 220: for (i = 0; i < 1000; i++) {
! 221: C* c = new C( 2 );
! 222: C c1( 2 ); /* stack allocation should work too */
! 223: D* d = ::new (USE_GC, D::CleanUp, (void*) i) D( i );
! 224: F* f = new F;
! 225: if (0 == i % 10) delete c;}
! 226:
! 227: /* Allocate a very large number of collectable As and Bs and
! 228: drop the references to them immediately, forcing many
! 229: collections. */
! 230: for (i = 0; i < 1000000; i++) {
! 231: A* a = new (USE_GC) A( i );
! 232: B* b = new B( i );
! 233: b = new (USE_GC) B( i );
! 234: if (0 == i % 10) {
! 235: B::Deleting( 1 );
! 236: delete b;
! 237: B::Deleting( 0 );}
! 238: # ifdef FINALIZE_ON_DEMAND
! 239: GC_invoke_finalizers();
! 240: # endif
! 241: }
! 242:
! 243: /* Make sure the uncollectable As and Bs are still there. */
! 244: for (i = 0; i < 1000; i++) {
! 245: A* a = (A*) Undisguise( as[ i ] );
! 246: B* b = (B*) Undisguise( bs[ i ] );
! 247: a->Test( i );
! 248: delete a;
! 249: b->Test( i );
! 250: B::Deleting( 1 );
! 251: delete b;
! 252: B::Deleting( 0 );
! 253: # ifdef FINALIZE_ON_DEMAND
! 254: GC_invoke_finalizers();
! 255: # endif
! 256:
! 257: }
! 258:
! 259: /* Make sure most of the finalizable Cs, Ds, and Fs have
! 260: gone away. */
! 261: C::Test();
! 262: D::Test();
! 263: F::Test();}
! 264:
! 265: # if !defined(__GNUC__) && !defined(MACOS)
! 266: my_assert (29 == x[3]);
! 267: # endif
! 268: GC_printf0( "The test appears to have succeeded.\n" );
! 269: return( 0 );}
! 270:
! 271:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to test_cpp.cc CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [local] / OpenXM_contrib2 / asir2000 / gc5.3