Use filename_extension() and filename_sans_extension().
[synfig.git] / ETL / trunk / test / handle.cpp
1 /*! ========================================================================
2 ** Extended Template and Library Test Suite
3 ** Handle Template Class Test
4 ** $Id$
5 **
6 ** Copyright (c) 2002 Robert B. Quattlebaum Jr.
7 **
8 ** This package is free software; you can redistribute it and/or
9 ** modify it under the terms of the GNU General Public License as
10 ** published by the Free Software Foundation; either version 2 of
11 ** the License, or (at your option) any later version.
12 **
13 ** This package is distributed in the hope that it will be useful,
14 ** but WITHOUT ANY WARRANTY; without even the implied warranty of
15 ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16 ** General Public License for more details.
17 **
18 ** === N O T E S ===========================================================
19 **
20 ** ========================================================================= */
21
22 /* === H E A D E R S ======================================================= */
23
24 #include <ETL/handle>
25 #include <list>
26 #include <stdio.h>
27 #include <stdlib.h>
28 #include <string>
29 #include <map>
30 #include <vector>
31
32 /* === M A C R O S ========================================================= */
33
34 #define NUMBER_OF_OBJECTS       40000
35 using namespace std;
36
37 /* === C L A S S E S ======================================================= */
38
39 struct my_test_obj : public etl::rshared_object
40 {
41         static int instance_count;
42         int my_id;
43         my_test_obj(int my_id=0):my_id(my_id)
44         {
45                 instance_count++;
46         }
47
48         virtual ~my_test_obj()
49         {
50                 if(instance_count==0)
51                         printf("Error, instance count is going past zero!\n");
52                 instance_count--;
53         }
54
55         bool operator<(const my_test_obj &rhs)const
56         {
57                 return my_id<rhs.my_id;
58         }
59 };
60
61 struct my_other_test_obj : public my_test_obj
62 {
63         static int instance_count;
64         my_other_test_obj(int my_id=0):my_test_obj(my_id)
65         {
66                 instance_count++;
67         }
68         virtual ~my_other_test_obj()
69         {
70                 if(instance_count==0)
71                         printf("Error, instance count is going past zero!\n");
72                 instance_count--;
73         }
74 };
75
76 int my_test_obj::instance_count=0;
77 int my_other_test_obj::instance_count=0;
78
79 typedef etl::handle<my_test_obj> obj_handle;
80 typedef etl::rhandle<my_test_obj> robj_handle;
81 typedef etl::handle<my_other_test_obj> other_obj_handle;
82 typedef list< obj_handle > obj_list;
83 typedef list< other_obj_handle > other_obj_list;
84 typedef list< robj_handle > robj_list;
85
86 int handle_basic_test()
87 {
88         printf("handle: Size of a handle: %u\n",(unsigned int)sizeof(etl::handle<int>));
89         printf("handle: Size of a loose_handle: %u\n",(unsigned int)sizeof(etl::loose_handle<int>));
90         printf("handle: Size of a rhandle: %u\n",(unsigned int)sizeof(etl::rhandle<int>));
91         printf("handle: Size of a shared_object: %u\n",(unsigned int)sizeof(etl::shared_object));
92         printf("handle: Size of a rshared_object: %u\n",(unsigned int)sizeof(etl::rshared_object));
93
94         printf("handle: Basic test: ");
95         my_test_obj::instance_count=0;
96
97         {
98                 etl::handle<my_test_obj> obj_handle(new my_test_obj(rand()));
99         }
100
101         if(my_test_obj::instance_count!=0)
102         {
103                 printf("FAILED!\n");
104                 printf(__FILE__":%d: on create/distroy, instance count=%d, should be zero.\n",__LINE__,my_test_obj::instance_count);
105                 return 1;
106         }
107
108         {
109                 map<string,etl::handle<my_test_obj> > my_map;
110                 etl::handle<my_test_obj> obj_handle(new my_test_obj(rand()));
111                 my_map["bleh"]=obj_handle;
112         }
113
114         if(my_test_obj::instance_count!=0)
115         {
116                 printf("FAILED!\n");
117                 printf(__FILE__":%d: on create/distroy, instance count=%d, should be zero.\n",__LINE__,my_test_obj::instance_count);
118                 return 1;
119         }
120
121         etl::handle<my_test_obj> obj_handle(new my_test_obj(rand()));
122
123         if(obj_handle != obj_handle.constant())
124         {
125                 printf("FAILED!\n");
126                 printf(__FILE__":%d: on call to handle<>::constant().\n",__LINE__);
127                 return 1;
128         }
129
130         printf("PASSED\n");
131
132         return 0;
133 }
134
135 int handle_general_use_test(void)
136 {
137         printf("handle: General-use test: ");
138         my_test_obj::instance_count=0;
139
140         obj_list my_list, my_other_list;
141         int i;
142
143         for(i=0;i<NUMBER_OF_OBJECTS;i++)
144                 my_list.push_back( obj_handle(new my_test_obj(rand())) );
145
146         my_other_list=my_list;
147         if(my_test_obj::instance_count!=NUMBER_OF_OBJECTS)
148         {
149                 printf("FAILED!\n");
150                 printf(__FILE__":%d: On copy, instance count=%d, should be %d.\n",__LINE__,my_test_obj::instance_count,NUMBER_OF_OBJECTS);
151                 return 1;
152         }
153
154         my_list.sort();
155         if(my_test_obj::instance_count!=NUMBER_OF_OBJECTS)
156         {
157                 printf("FAILED!\n");
158                 printf(__FILE__":%d: On copy, instance count=%d, should be %d.\n",__LINE__,my_test_obj::instance_count,NUMBER_OF_OBJECTS);
159                 return 1;
160         }
161
162         my_list.clear();
163         if(my_test_obj::instance_count!=NUMBER_OF_OBJECTS)
164         {
165                 printf("FAILED!\n");
166                 printf(__FILE__":%d: On copy's clear, instance count=%d, should be %d.\n",__LINE__,my_test_obj::instance_count,NUMBER_OF_OBJECTS);
167                 return 1;
168         }
169
170         my_other_list.clear();
171         if(my_test_obj::instance_count)
172         {
173                 printf("FAILED!\n");
174                 printf(__FILE__":%d: On clear, instance count=%d, should be zero.\n",__LINE__,my_test_obj::instance_count);
175                 return 1;
176         }
177
178         printf("PASSED\n");
179
180         return 0;
181 }
182
183         struct ListItem
184         {
185                 robj_handle obj;
186                 int bleh;
187                 int blah;
188                 ListItem(robj_handle obj,int bleh=1, int blah=2):
189                         obj(obj),bleh(bleh),blah(blah) { }
190         };
191
192 int rhandle_general_use_test(void)
193 {
194
195
196         printf("rhandle: General-use test: ");
197         my_test_obj::instance_count=0;
198
199         robj_list my_list;
200         int i;
201
202         robj_handle obj=        new my_test_obj(rand());
203         for(i=0;i<NUMBER_OF_OBJECTS;i++)
204                 my_list.push_back(obj);
205
206         obj_list my_other_list(my_list.begin(),my_list.end());
207
208
209
210         if(obj.count()!=NUMBER_OF_OBJECTS*2+1)
211         {
212                 printf("FAILED!\n");
213                 printf(__FILE__":%d: On copy, handle count=%d, should be %d.\n",__LINE__,obj.count(),NUMBER_OF_OBJECTS*2+1);
214                 return 1;
215         }
216
217         if(obj.rcount()!=NUMBER_OF_OBJECTS+1)
218         {
219                 printf("FAILED!\n");
220                 printf(__FILE__":%d: On copy, rhandle count=%d, should be %d.\n",__LINE__,obj.rcount(),NUMBER_OF_OBJECTS+1);
221                 return 1;
222         }
223
224         my_list.sort();
225         if(obj.rcount()!=NUMBER_OF_OBJECTS+1)
226         {
227                 printf("FAILED!\n");
228                 printf(__FILE__":%d: On copy, instance count=%d, should be %d.\n",__LINE__,obj.rcount(),NUMBER_OF_OBJECTS+1);
229                 return 1;
230         }
231
232         {robj_handle bleh(obj);}
233
234         if(obj.rcount()!=NUMBER_OF_OBJECTS+1)
235         {
236                 printf("FAILED!\n");
237                 printf(__FILE__":%d: On copy, instance count=%d, should be %d.\n",__LINE__,obj.rcount(),NUMBER_OF_OBJECTS+1);
238                 return 1;
239         }
240
241         my_other_list.clear();
242
243         if(obj.rcount()!=obj.count())
244         {
245                 printf("FAILED!\n");
246                 printf(__FILE__":%d: On copy's clear, handle count (%d) != rhandle count (%d)\n",__LINE__,obj.count(),obj.rcount());
247                 return 1;
248         }
249
250         if(obj.rcount()!=NUMBER_OF_OBJECTS+1)
251         {
252                 printf("FAILED!\n");
253                 printf(__FILE__":%d: On copy's clear, instance count=%d, should be %d.\n",__LINE__,obj.rcount(),NUMBER_OF_OBJECTS+1);
254                 return 1;
255         }
256
257         robj_handle new_obj=    new my_test_obj(rand());
258
259         int replacements=obj.replace(new_obj);
260
261         if(replacements!=NUMBER_OF_OBJECTS+1)
262         {
263                 printf("FAILED!\n");
264                 printf(__FILE__":%d: Only managed to replace %d, should have replaced %d\n",__LINE__,replacements,NUMBER_OF_OBJECTS+1);
265                 return 1;
266         }
267
268         if(obj!=new_obj)
269         {
270                 printf("FAILED!\n");
271                 printf(__FILE__":%d: On replace, handles should be equal.\n",__LINE__);
272                 return 1;
273         }
274
275         {
276                 robj_handle bleh(obj);
277                 robj_handle blah(obj.get());
278         }
279
280
281         my_list.clear();
282         obj.detach();
283         new_obj.detach();
284
285         if(my_test_obj::instance_count)
286         {
287                 printf("FAILED!\n");
288                 printf(__FILE__":%d: On clear, instance count=%d, should be zero.\n",__LINE__,my_test_obj::instance_count);
289                 return 1;
290         }
291
292
293
294         std::vector<ListItem> my_item_list;
295         for(i=0;i<NUMBER_OF_OBJECTS;i++)
296                 my_item_list.push_back(ListItem(new my_test_obj(rand()),3,4));
297
298
299         for(i=0;i<100;i++)
300         {
301                 int src,dest;
302                 src=rand()%NUMBER_OF_OBJECTS;
303                 dest=rand()%NUMBER_OF_OBJECTS;
304                 ListItem tmp(my_item_list[src]);
305                 assert(tmp.obj.rcount()>=2);
306                 my_item_list.erase(my_item_list.begin()+src);
307                 assert(tmp.obj.rcount()>=1);
308                 my_item_list.insert(my_item_list.begin()+dest,tmp);
309                 assert(tmp.obj.rcount()>=2);
310         }
311
312         my_item_list.clear();
313
314         if(my_test_obj::instance_count)
315         {
316                 printf("FAILED!\n");
317                 printf(__FILE__":%d: On clear, instance count=%d, should be zero.\n",__LINE__,my_test_obj::instance_count);
318                 return 1;
319         }
320
321         printf("PASSED\n");
322
323         return 0;
324 }
325
326 int handle_inheritance_test(void)
327 {
328         printf("handle: Inheritance test: ");
329         my_test_obj::instance_count=0;
330         my_other_test_obj::instance_count=0;
331
332         other_obj_list my_other_list;
333         int i;
334
335         for(i=0;i<NUMBER_OF_OBJECTS;i++)
336                 my_other_list.push_back( other_obj_handle(new my_other_test_obj(rand())) );
337
338         obj_list my_list(my_other_list.begin(),my_other_list.end());
339         if(my_test_obj::instance_count!=NUMBER_OF_OBJECTS)
340         {
341                 printf("FAILED!\n");
342                 printf(__FILE__":%d: On copy, instance count=%d, should be %d.\n",__LINE__,my_test_obj::instance_count,NUMBER_OF_OBJECTS);
343                 return 1;
344         }
345
346         for(i=0;i<NUMBER_OF_OBJECTS;i++)
347                 my_list.push_back( other_obj_handle(new my_other_test_obj(rand())) );
348         if(my_other_test_obj::instance_count!=NUMBER_OF_OBJECTS*2 ||
349            my_test_obj::instance_count!=my_other_test_obj::instance_count)
350         {
351                 printf("FAILED!\n");
352                 printf(__FILE__":%d: On inherited copy, instance count=%d, should be %d.\n",__LINE__,my_test_obj::instance_count,NUMBER_OF_OBJECTS*2);
353                 return 1;
354         }
355
356         my_list.sort();
357         my_other_list.sort();
358         if(my_test_obj::instance_count!=NUMBER_OF_OBJECTS*2)
359         {
360                 printf("FAILED!\n");
361                 printf(__FILE__":%d: On sort, instance count=%d, should be %d.\n",__LINE__,my_test_obj::instance_count,NUMBER_OF_OBJECTS*2);
362                 return 1;
363         }
364
365         my_list.clear();
366         if(my_test_obj::instance_count!=NUMBER_OF_OBJECTS)
367         {
368                 printf("FAILED!\n");
369                 printf(__FILE__":%d: On clear, instance count=%d, should be %d.\n",__LINE__,my_test_obj::instance_count,NUMBER_OF_OBJECTS);
370                 return 1;
371         }
372
373         my_other_list.clear();
374         if(my_test_obj::instance_count)
375         {
376                 printf("FAILED!\n");
377                 printf(__FILE__":%d: On clear, instance count=%d, should be zero.\n",__LINE__,my_test_obj::instance_count);
378                 return 1;
379         }
380
381         printf("PASSED\n");
382
383         return 0;
384 }
385
386 void test_func(etl::handle<my_test_obj> handle)
387 {
388         if(handle) { int i=handle.count(); i++; }
389 }
390
391 int loose_handle_test(void)
392 {
393         printf("handle: loose_handle test: ");
394         my_test_obj::instance_count=0;
395
396         etl::loose_handle<my_test_obj> obj_handle_loose;
397         etl::handle<my_test_obj> obj_handle2;
398
399         {
400                 etl::handle<my_test_obj> obj_handle(new my_test_obj(rand()));
401                 if(my_test_obj::instance_count!=1)
402                 {
403                         printf("FAILED!\n");
404                         printf(__FILE__":%d: on handle assignment from new object, instance count=%d, should be 1.\n",__LINE__,my_test_obj::instance_count);
405                         return 1;
406                 }
407
408                 obj_handle_loose=obj_handle;
409                 if(obj_handle!=obj_handle_loose)
410                 {
411                         printf("FAILED!\n");
412                         printf(__FILE__":%d: on loose_handle assignment\n",__LINE__);
413                         return 1;
414                 }
415
416                 obj_handle2=obj_handle_loose;
417                 if(my_test_obj::instance_count!=1)
418                 {
419                         printf("FAILED!\n");
420                         printf(__FILE__":%d: on handle assignment from loose_handle, instance count=%d, should be 1.\n",__LINE__,my_test_obj::instance_count);
421                         return 1;
422                 }
423
424                 test_func(obj_handle_loose);
425                 if(my_test_obj::instance_count!=1)
426                 {
427                         printf("FAILED!\n");
428                         printf(__FILE__":%d: on handle assignment from loose_handle, instance count=%d, should be 1.\n",__LINE__,my_test_obj::instance_count);
429                         return 1;
430                 }
431         }
432
433         if(my_test_obj::instance_count!=1)
434         {
435                 printf("FAILED!\n");
436                 printf(__FILE__":%d: on create/destroy, instance count=%d, should be 1.\n",__LINE__,my_test_obj::instance_count);
437                 return 1;
438         }
439
440         printf("PASSED\n");
441         return 0;
442 }
443
444 int handle_cast_test()
445 {
446         printf("handle: casting test: ");
447
448         etl::handle<my_test_obj> obj;
449         etl::handle<my_other_test_obj> other_obj;
450         etl::loose_handle<my_other_test_obj> loose_obj;
451
452         other_obj.spawn();
453         loose_obj=other_obj;
454
455         obj=etl::handle<my_test_obj>::cast_dynamic(loose_obj);
456
457         if(obj!=other_obj)
458         {
459                 printf("FAILED!\n");
460                 printf(__FILE__":%d: on handle assignment from loose_handle.\n",__LINE__);
461                 return 1;
462         }
463
464         printf("PASSED\n");
465         return 0;
466 }
467
468 /* === E N T R Y P O I N T ================================================= */
469
470 int main()
471 {
472         int error=0;
473
474         error+=handle_basic_test();
475         error+=handle_cast_test();
476         error+=handle_general_use_test();
477         error+=handle_inheritance_test();
478         error+=loose_handle_test();
479         error+=rhandle_general_use_test();
480
481         return error;
482 }