Annotation of OpenXM_contrib/gc/test_cpp.cc, Revision 1.1.1.1
1.1 maekawa 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:
41:
42: #define my_assert( e ) \
43: if (! (e)) { \
44: GC_printf1( "Assertion failure in " __FILE__ ", line %d: " #e "\n", \
45: __LINE__ ); \
46: exit( 1 ); }
47:
48:
49: class A {public:
50: /* An uncollectable class. */
51:
52: A( int iArg ): i( iArg ) {}
53: void Test( int iArg ) {
54: my_assert( i == iArg );}
55: int i;};
56:
57:
58: class B: public gc, public A {public:
59: /* A collectable class. */
60:
61: B( int j ): A( j ) {}
62: ~B() {
63: my_assert( deleting );}
64: static void Deleting( int on ) {
65: deleting = on;}
66: static int deleting;};
67:
68: int B::deleting = 0;
69:
70:
71: class C: public gc_cleanup, public A {public:
72: /* A collectable class with cleanup and virtual multiple inheritance. */
73:
74: C( int levelArg ): A( levelArg ), level( levelArg ) {
75: nAllocated++;
76: if (level > 0) {
77: left = new C( level - 1 );
78: right = new C( level - 1 );}
79: else {
80: left = right = 0;}}
81: ~C() {
82: this->A::Test( level );
83: nFreed++;
84: my_assert( level == 0 ?
85: left == 0 && right == 0 :
86: level == left->level + 1 && level == right->level + 1 );
87: left = right = 0;
88: level = -123456;}
89: static void Test() {
90: my_assert( nFreed <= nAllocated && nFreed >= .8 * nAllocated );}
91:
92: static int nFreed;
93: static int nAllocated;
94: int level;
95: C* left;
96: C* right;};
97:
98: int C::nFreed = 0;
99: int C::nAllocated = 0;
100:
101:
102: class D: public gc {public:
103: /* A collectable class with a static member function to be used as
104: an explicit clean-up function supplied to ::new. */
105:
106: D( int iArg ): i( iArg ) {
107: nAllocated++;}
108: static void CleanUp( void* obj, void* data ) {
109: D* self = (D*) obj;
110: nFreed++;
111: my_assert( self->i == (int) (long) data );}
112: static void Test() {
113: my_assert( nFreed >= .8 * nAllocated );}
114:
115: int i;
116: static int nFreed;
117: static int nAllocated;};
118:
119: int D::nFreed = 0;
120: int D::nAllocated = 0;
121:
122:
123: class E: public gc_cleanup {public:
124: /* A collectable class with clean-up for use by F. */
125:
126: E() {
127: nAllocated++;}
128: ~E() {
129: nFreed++;}
130:
131: static int nFreed;
132: static int nAllocated;};
133:
134: int E::nFreed = 0;
135: int E::nAllocated = 0;
136:
137:
138: class F: public E {public:
139: /* A collectable class with clean-up, a base with clean-up, and a
140: member with clean-up. */
141:
142: F() {
143: nAllocated++;}
144: ~F() {
145: nFreed++;}
146: static void Test() {
147: my_assert( nFreed >= .8 * nAllocated );
148: my_assert( 2 * nFreed == E::nFreed );}
149:
150: E e;
151: static int nFreed;
152: static int nAllocated;};
153:
154: int F::nFreed = 0;
155: int F::nAllocated = 0;
156:
157:
158: long Disguise( void* p ) {
159: return ~ (long) p;}
160:
161: void* Undisguise( long i ) {
162: return (void*) ~ i;}
163:
164:
165: #ifdef MSWIN32
166: int APIENTRY WinMain(
167: HINSTANCE instance, HINSTANCE prev, LPSTR cmd, int cmdShow )
168: {
169: int argc;
170: char* argv[ 3 ];
171:
172: for (argc = 1; argc < sizeof( argv ) / sizeof( argv[ 0 ] ); argc++) {
173: argv[ argc ] = strtok( argc == 1 ? cmd : 0, " \t" );
174: if (0 == argv[ argc ]) break;}
175:
176: #else
177: # ifdef MACOS
178: int main() {
179: # else
180: int main( int argc, char* argv[] ) {
181: # endif
182: #endif
183:
184: # if defined(MACOS) // MacOS
185: char* argv_[] = {"test_cpp", "10"}; // doesn't
186: argv = argv_; // have a
187: argc = sizeof(argv_)/sizeof(argv_[0]); // commandline
188: # endif
189: int i, iters, n;
190: # if !defined(__GNUC__) && !defined(MACOS)
191: int *x = (int *)alloc::allocate(sizeof(int));
192:
193: *x = 29;
194: x -= 3;
195: # endif
196: if (argc != 2 || (0 >= (n = atoi( argv[ 1 ] )))) {
197: GC_printf0( "usage: test_cpp number-of-iterations\n" );
198: exit( 1 );}
199:
200: for (iters = 1; iters <= n; iters++) {
201: GC_printf1( "Starting iteration %d\n", iters );
202:
203: /* Allocate some uncollectable As and disguise their pointers.
204: Later we'll check to see if the objects are still there. We're
205: checking to make sure these objects really are uncollectable. */
206: long as[ 1000 ];
207: long bs[ 1000 ];
208: for (i = 0; i < 1000; i++) {
209: as[ i ] = Disguise( new (NoGC) A( i ) );
210: bs[ i ] = Disguise( new (NoGC) B( i ) );}
211:
212: /* Allocate a fair number of finalizable Cs, Ds, and Fs.
213: Later we'll check to make sure they've gone away. */
214: for (i = 0; i < 1000; i++) {
215: C* c = new C( 2 );
216: C c1( 2 ); /* stack allocation should work too */
217: D* d = ::new (GC, D::CleanUp, (void*) i) D( i );
218: F* f = new F;
219: if (0 == i % 10) delete c;}
220:
221: /* Allocate a very large number of collectable As and Bs and
222: drop the references to them immediately, forcing many
223: collections. */
224: for (i = 0; i < 1000000; i++) {
225: A* a = new (GC) A( i );
226: B* b = new B( i );
227: b = new (GC) B( i );
228: if (0 == i % 10) {
229: B::Deleting( 1 );
230: delete b;
231: B::Deleting( 0 );}
232: # ifdef FINALIZE_ON_DEMAND
233: GC_invoke_finalizers();
234: # endif
235: }
236:
237: /* Make sure the uncollectable As and Bs are still there. */
238: for (i = 0; i < 1000; i++) {
239: A* a = (A*) Undisguise( as[ i ] );
240: B* b = (B*) Undisguise( bs[ i ] );
241: a->Test( i );
242: delete a;
243: b->Test( i );
244: B::Deleting( 1 );
245: delete b;
246: B::Deleting( 0 );
247: # ifdef FINALIZE_ON_DEMAND
248: GC_invoke_finalizers();
249: # endif
250:
251: }
252:
253: /* Make sure most of the finalizable Cs, Ds, and Fs have
254: gone away. */
255: C::Test();
256: D::Test();
257: F::Test();}
258:
259: # if !defined(__GNUC__) && !defined(MACOS)
260: my_assert (29 == x[3]);
261: # endif
262: GC_printf0( "The test appears to have succeeded.\n" );
263: return( 0 );}
264:
265:
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_contrib / gc