various fixes made when working with older gcc 3.2.3
[dyninst.git] / testsuite / src / test0.mutatee.C
1 /*
2  * Copyright (c) 1996-2004 Barton P. Miller
3  * 
4  * We provide the Paradyn Parallel Performance Tools (below
5  * described as "Paradyn") on an AS IS basis, and do not warrant its
6  * validity or performance.  We reserve the right to update, modify,
7  * or discontinue this software at any time.  We shall have no
8  * obligation to supply such updates or modifications or any other
9  * form of support to you.
10  * 
11  * This license is for research uses.  For such uses, there is no
12  * charge. We define "research use" to mean you may freely use it
13  * inside your organization for whatever purposes you see fit. But you
14  * may not re-distribute Paradyn or parts of Paradyn, in any form
15  * source or binary (including derivatives), electronic or otherwise,
16  * to any other organization or entity without our permission.
17  * 
18  * (for other uses, please contact us at paradyn@cs.wisc.edu)
19  * 
20  * All warranties, including without limitation, any warranty of
21  * merchantability or fitness for a particular purpose, are hereby
22  * excluded.
23  * 
24  * By your use of Paradyn, you understand and agree that we (or any
25  * other person or entity with proprietary rights in Paradyn) are
26  * under no obligation to provide either maintenance services,
27  * update services, notices of latent defects, or correction of
28  * defects for Paradyn.
29  * 
30  * Even if advised of the possibility of such damages, under no
31  * circumstances shall we (or any other person or entity with
32  * proprietary rights in the software licensed hereunder) be liable
33  * to you or any third party for direct, indirect, or consequential
34  * damages of any character regardless of type of action, including,
35  * without limitation, loss of profits, loss of use, loss of good
36  * will, or computer failure or malfunction.  You agree to indemnify
37  * us (and any other person or entity with proprietary rights in the
38  * software licensed hereunder) for any and all liability it may
39  * incur to third parties resulting from your use of Paradyn.
40  */
41
42 /* Test application (Mutatee) */
43
44 /* $Id: test0.mutatee.C,v 1.3 2008/09/19 00:56:11 jaw Exp $ */
45
46 #include <stdio.h>
47 #include <assert.h>
48 #include <sys/types.h>
49 #include <signal.h>
50 #include <string.h>
51 #include <stdlib.h>
52
53 #include "../../common/h/serialize.h"
54
55 #include "mutatee_util.h"
56 #include "test0.h"
57
58 #if defined(i386_unknown_nt4_0) && !defined(__GNUC__)
59 #define WIN32_LEAN_AND_MEAN
60 #include <windows.h>
61 #include <process.h>
62 #define getpid _getpid
63 #else
64 #include <unistd.h>
65 #endif
66
67 #ifdef __cplusplus
68 int mutateeCplusplus = 1;
69 #else
70 #error
71 #endif
72
73 #if 0
74 #ifndef FILE__
75 #define FILE__ strrchr(__FILE__, '/') ? strrchr(__FILE__, '/') + 1 : __FILE__
76 #endif
77 #endif
78
79 #ifndef COMPILER
80 #define COMPILER ""
81 #endif
82 const char *Builder_id=COMPILER; /* defined on compile line */
83
84 /* control debug printf statements */
85 #define dprintf if (debugPrint) printf
86 int debugPrint = 0;
87 bool verbose = false;
88 const char *prog_name;
89
90 //////////////////////////////////////////////////////////////////
91 //////////////////////////////////////////////////////////////////
92 ///////////
93 ///////////  Test 1 --
94 ///////////
95 //////////////////////////////////////////////////////////////////
96 //////////////////////////////////////////////////////////////////
97
98 class ZeroOne : public Serializable {
99
100    public:
101
102       int zero_one_int;
103       unsigned int zero_one_unsigned_int;
104       long zero_one_long;
105       unsigned long zero_one_unsigned_long;
106 #if 0
107       short zero_one_short;
108 #endif
109       //unsigned short zero_two_unsigned_short;
110       char zero_one_char;
111       //unsigned char zero_two_unsigned_char;
112
113       bool operator==(const ZeroOne &cmp) 
114       {
115          if (zero_one_int != cmp.zero_one_int) return false;
116          if (zero_one_long != cmp.zero_one_long) return false;
117 #if 0
118          if (zero_one_short != cmp.zero_one_short) return false;
119 #endif
120          if (zero_one_char != cmp.zero_one_char) return false;
121
122          return true;
123       }
124
125       bool operator!=(const ZeroOne &cmp) 
126       {
127          return (! (*this == cmp));
128       }
129
130       void printcmp(const ZeroOne &cmp) 
131       {
132          fprintf(stderr, "%s[%d]: %d %s %d\n", __FILE__, __LINE__,
133                zero_one_int, 
134                zero_one_int == cmp.zero_one_int ? "==" : "!=", 
135                cmp.zero_one_int);
136          fprintf(stderr, "%s[%d]: %lu %s %lu\n", __FILE__, __LINE__,
137                (long) zero_one_long, 
138                (const char *) (zero_one_long == cmp.zero_one_long ? "==" : "!="), 
139                (long) cmp.zero_one_long);
140 #if 0
141          fprintf(stderr, "%s[%d]: %hu %s %hu\n", __FILE__, __LINE__, 
142                zero_one_short, 
143                zero_one_short == cmp.zero_one_short ? "==" : "!=", 
144                cmp.zero_one_short);
145 #endif
146          fprintf(stderr, "%s[%d]: %c %s %c\n", __FILE__, __LINE__,
147                zero_one_char, 
148                zero_one_char == cmp.zero_one_char ? "==" : "!=", 
149                cmp.zero_one_char);
150       }
151
152       void serialize(SerializerBase *sb, const char *) 
153       {
154          try 
155          {
156             gtranslate(sb, zero_one_int, NULL);
157             gtranslate(sb, zero_one_unsigned_int, NULL);
158             gtranslate(sb, zero_one_long, NULL);
159             gtranslate(sb, zero_one_unsigned_long, NULL);
160 #if 0
161             gtranslate(sb, zero_one_short, NULL);
162 #endif
163             gtranslate(sb, zero_one_char, NULL);
164          } 
165          SER_CATCH("ZeroOne");
166       }
167 };
168
169 bool setup_control(ZeroOne &zero1)
170 {
171    zero1.zero_one_int = -1237843;
172    zero1.zero_one_unsigned_int = 1237843;
173    zero1.zero_one_long = -12378434L;
174    zero1.zero_one_unsigned_long = 12378434L;
175    zero1.zero_one_char = 'a';
176 #if 0
177    zero1.zero_one_short = -12;
178    //zero1.zero_two_unsigned_char= 12;
179    zero1.zero_one_short = -1 * 'a';
180 #endif
181    //zero1.zero_two_unsigned_short = 'a';
182    return true;
183 }
184
185 bool test1b(const char *cachefile)
186 {
187    if (!cachefile) 
188    {
189       fprintf(stderr, "%s[%d]:  NULL param\n", FILE__, __LINE__);
190       abort();
191    }
192
193    bool res = deserialize_verify<ZeroOne>(cachefile);
194
195    if (!res) 
196    {
197       fprintf(stderr, "%s[%d]:  test1b failed\n", FILE__, __LINE__);
198    }
199
200    return res;
201 }
202
203 bool test1()
204 {
205    bool res = serialize_test<ZeroOne>(1, prog_name);
206
207    if (!res) 
208    {
209       fprintf(stderr, "%s[%d]:  test1 failed\n", FILE__, __LINE__);
210    }
211
212    return res;
213 }
214
215 /* 
216  * Test #2 
217  */
218
219 class ZeroTwo : public Serializable {
220    public:
221    std::string zero_two_string1;
222    std::string zero_two_string2;
223    std::string zero_two_string3;
224    std::string zero_two_string4;
225    std::string zero_two_string5;
226    int zero_two_int1;
227    int zero_two_int2;
228    int zero_two_int3;
229    int zero_two_int4;
230    int zero_two_int5;
231    float zero_two_float1;
232    float zero_two_float2;
233    float zero_two_float3;
234    float zero_two_float4;
235    float zero_two_float5;
236
237    public:
238
239       bool operator==(const ZeroTwo &cmp) 
240       {
241          if (zero_two_int1 != cmp.zero_two_int1) return false;
242          if (zero_two_int2 != cmp.zero_two_int2) return false;
243          if (zero_two_int3 != cmp.zero_two_int3) return false;
244          if (zero_two_int4 != cmp.zero_two_int4) return false;
245          if (zero_two_int5 != cmp.zero_two_int5) return false;
246          if (zero_two_float1 != cmp.zero_two_float1) return false;
247          if (zero_two_float2 != cmp.zero_two_float2) return false;
248          if (zero_two_float3 != cmp.zero_two_float3) return false;
249          if (zero_two_float4 != cmp.zero_two_float4) return false;
250          if (zero_two_float5 != cmp.zero_two_float5) return false;
251          if (zero_two_string1 != cmp.zero_two_string1) return false;
252          if (zero_two_string2 != cmp.zero_two_string2) return false;
253          if (zero_two_string3 != cmp.zero_two_string3) return false;
254          if (zero_two_string4 != cmp.zero_two_string4) return false;
255          if (zero_two_string5 != cmp.zero_two_string5) return false;
256          return true;
257       }
258
259       bool operator!=(const ZeroTwo &cmp) 
260       {
261          return (! (*this == cmp));
262       }
263
264       void printcmp(const ZeroTwo &cmp) 
265       {
266          if (zero_two_int1 != cmp.zero_two_int1) 
267             fprintf(stderr, "%s[%d]: fail here\n", FILE__, __LINE__);
268          if (zero_two_int2 != cmp.zero_two_int2) 
269             fprintf(stderr, "%s[%d]: fail here\n", FILE__, __LINE__);
270          if (zero_two_int3 != cmp.zero_two_int3) 
271             fprintf(stderr, "%s[%d]: fail here\n", FILE__, __LINE__);
272          if (zero_two_int4 != cmp.zero_two_int4)
273             fprintf(stderr, "%s[%d]: fail here\n", FILE__, __LINE__);
274          if (zero_two_int5 != cmp.zero_two_int5) 
275             fprintf(stderr, "%s[%d]: fail here\n", FILE__, __LINE__);
276          if (zero_two_float1 != cmp.zero_two_float1) 
277             fprintf(stderr, "%s[%d]: fail here\n", FILE__, __LINE__);
278          if (zero_two_float2 != cmp.zero_two_float2)
279             fprintf(stderr, "%s[%d]: fail here\n", FILE__, __LINE__);
280          if (zero_two_float3 != cmp.zero_two_float3) 
281             fprintf(stderr, "%s[%d]: fail here\n", FILE__, __LINE__);
282          if (zero_two_float4 != cmp.zero_two_float4) 
283             fprintf(stderr, "%s[%d]: fail here\n", FILE__, __LINE__);
284          if (zero_two_float5 != cmp.zero_two_float5) 
285             fprintf(stderr, "%s[%d]: fail here\n", FILE__, __LINE__);
286          if (zero_two_string1 != cmp.zero_two_string1) 
287             fprintf(stderr, "%s[%d]: fail here\n", FILE__, __LINE__);
288          if (zero_two_string2 != cmp.zero_two_string2) 
289             fprintf(stderr, "%s[%d]: fail here\n", FILE__, __LINE__);
290          if (zero_two_string3 != cmp.zero_two_string3) 
291             fprintf(stderr, "%s[%d]: fail here\n", FILE__, __LINE__);
292          if (zero_two_string4 != cmp.zero_two_string4) 
293             fprintf(stderr, "%s[%d]: fail here\n", FILE__, __LINE__);
294          if (zero_two_string5 != cmp.zero_two_string5) 
295             fprintf(stderr, "%s[%d]: fail here\n", FILE__, __LINE__);
296       }
297
298       void serialize(SerializerBase *sb, const char *)
299       {
300          try 
301          {
302             gtranslate(sb, zero_two_int1);
303             gtranslate(sb, zero_two_int2);
304             gtranslate(sb, zero_two_int3);
305             gtranslate(sb, zero_two_int4);
306             gtranslate(sb, zero_two_int5);
307             gtranslate(sb, zero_two_float1);
308             gtranslate(sb, zero_two_float2);
309             gtranslate(sb, zero_two_float3);
310             gtranslate(sb, zero_two_float4);
311             gtranslate(sb, zero_two_float5);
312             gtranslate(sb, zero_two_string1);
313             gtranslate(sb, zero_two_string2);
314             gtranslate(sb, zero_two_string3);
315             gtranslate(sb, zero_two_string4);
316             gtranslate(sb, zero_two_string5);
317          } 
318          SER_CATCH("ZeroTwo");
319       }
320 };
321
322 bool setup_control(ZeroTwo &control)
323 {
324    control.zero_two_int1 = 0xdeadbeef;
325    control.zero_two_int2 = 0xbeeffeed;
326    control.zero_two_int3 = 0xdeadfeed;
327    control.zero_two_int4 = 0xfeedbeef;
328    control.zero_two_int5 = 0xdadabaca;
329    control.zero_two_float1 = 0.1;
330    control.zero_two_float2 = 1e23;
331    control.zero_two_float3 = 1.38742e5;
332    control.zero_two_float4 = 5.5;
333    control.zero_two_float5 = 6.6;
334    control.zero_two_string1 = std::string("hello world");
335    control.zero_two_string2 = std::string("This is not a test");
336    control.zero_two_string3 = std::string("This is a test");
337    control.zero_two_string4 = std::string("The world was beginning to flower into wounds");
338    control.zero_two_string5 = std::string("The aggressive stylization of this mass-produced cockpit, the exaggerated mouldings of the instrument binnacles emphasized my growing sense of a new junction between my own body and the automobile, closer than my feelings for Renata's broad hips and strong legs stowed out of sight beneath her red plastic raincoat");
339    return true;
340 }
341
342
343 bool test2()
344 {
345    bool res = serialize_test<ZeroTwo>(2, prog_name);
346
347    if (!res) 
348    {
349       fprintf(stderr, "%s[%d]:  test2 failed\n", FILE__, __LINE__);
350    }
351
352    return res;
353 }
354
355 bool test2b(const char *cachefile)
356 {
357    if (!cachefile) 
358    {
359       fprintf(stderr, "%s[%d]:  NULL param\n", FILE__, __LINE__);
360       abort();
361    }
362
363    bool res = deserialize_verify<ZeroTwo>(cachefile);
364
365    if (!res) 
366    {
367       fprintf(stderr, "%s[%d]:  test2b failed\n", FILE__, __LINE__);
368    }
369
370    return res;
371 }
372
373 /*
374  * Test #3 
375  */
376
377 class ZeroThree : public Serializable {
378    public:
379       std::vector<int> zero_three_ints;
380
381       bool operator==(const ZeroThree &cmp) 
382       {
383          if (zero_three_ints.size() != cmp.zero_three_ints.size()) 
384          {
385             return false;
386          }
387
388          for (unsigned int i = 0; i < cmp.zero_three_ints.size(); ++i) 
389          {
390             if ((zero_three_ints[i] != cmp.zero_three_ints[i])) 
391                   return false;
392          }
393          return true;
394       }
395
396       bool operator!=(const ZeroThree &cmp) 
397       {
398          return (! (*this == cmp));
399       }
400
401       void printcmp(const ZeroThree &cmp) 
402       {
403          if (zero_three_ints.size() != cmp.zero_three_ints.size()) 
404          {
405             fprintf(stderr, "%s[%d]:  vectors have sizes %lu and %lu\n", 
406                   FILE__, __LINE__, cmp.zero_three_ints.size(), zero_three_ints.size());
407          }
408
409          for (unsigned int i = 0; i < cmp.zero_three_ints.size(); ++i) 
410          {
411             if ((zero_three_ints[i] != cmp.zero_three_ints[i])) 
412                fprintf(stderr, "elem %d: %d -- %d\n", i, zero_three_ints[i], 
413                      cmp.zero_three_ints[i]);
414          }
415       }
416
417       void serialize(SerializerBase *sb, const char *)
418       {
419          try 
420          {
421             gtranslate(sb, zero_three_ints);
422          } 
423          SER_CATCH("ZeroThree");
424       }
425 };
426
427 bool setup_control(ZeroThree &param)
428 {
429    for (unsigned int i = 0; i < 50; ++i) 
430    {
431       param.zero_three_ints.push_back(i*100 + 2077);
432    }
433
434    return true;
435 }
436
437 bool test3()
438 {
439    bool res  = serialize_test<ZeroThree>(3, prog_name);
440
441    if (!res) 
442    {
443       fprintf(stderr, "%s[%d]:  test3 failed\n", FILE__, __LINE__);
444    }
445
446    return res;
447 }
448
449 bool test3b(const char *cachefile)
450 {
451    if (!cachefile) 
452    {
453       fprintf(stderr, "%s[%d]:  NULL param\n", FILE__, __LINE__);
454       abort();
455    }
456
457    bool res = deserialize_verify<ZeroThree>(cachefile);
458
459    if (!res) 
460    {
461       fprintf(stderr, "%s[%d]:  test3b failed\n", FILE__, __LINE__);
462    }
463
464    return res;
465 }
466
467 /*
468  * Test #4 
469  */
470
471 class ZeroFour : public Serializable {
472    public:
473       std::vector<std::vector<int> > zero_four_ints;
474
475       bool operator==(const ZeroFour &cmp) 
476       {
477          if (zero_four_ints.size() != cmp.zero_four_ints.size()) 
478          {
479             return false;
480          }
481
482          for (unsigned int i = 0; i < cmp.zero_four_ints.size(); ++i) 
483          {
484             if ((zero_four_ints[i] != cmp.zero_four_ints[i])) 
485                   return false;
486          }
487
488          return true;
489       }
490
491       bool operator!=(const ZeroFour &cmp) 
492       {
493          return (! (*this == cmp));
494       }
495
496       void printcmp(const ZeroFour &cmp) 
497       {
498          if (zero_four_ints.size() != cmp.zero_four_ints.size()) 
499          {
500             fprintf(stderr, "%s[%d]:  vectors have sizes %lu and %lu\n", 
501                   FILE__, __LINE__, cmp.zero_four_ints.size(), zero_four_ints.size());
502          }
503
504          for (unsigned int i = 0; i < cmp.zero_four_ints.size(); ++i) 
505          {
506             const std::vector<int> &v1 = cmp.zero_four_ints[i];
507             const std::vector<int> &v2 = zero_four_ints[i];
508
509             for (unsigned int j = 0; j < v1.size(); ++j) 
510             {
511                if ((v1[j] != v2[j])) 
512                   fprintf(stderr, "elem %d: %d -- %d\n", j, v1[j], v2[j]);
513             }
514          }
515       }
516
517       void serialize(SerializerBase *sb, const char *)
518       {
519          try 
520          {
521             gtranslate(sb, zero_four_ints);
522          } 
523          SER_CATCH("ZeroFour");
524       }
525
526 };
527
528 bool setup_control(ZeroFour &param)
529 {
530    param.zero_four_ints.resize(50);
531
532    for (unsigned int i = 0; i < 50; ++i) 
533    {
534       std::vector <int> &v  = param.zero_four_ints[i];
535       v.resize(50);
536
537       for (unsigned j = 0; j < 50; ++j) 
538       {
539          v[j] = i*j + 2077;
540       }
541    }
542
543    return true;
544 }
545
546 bool test4()
547 {
548    bool res = serialize_test<ZeroFour>(4, prog_name);
549
550    if (!res) 
551    {
552       fprintf(stderr, "%s[%d]:  test4 failed\n", FILE__, __LINE__);
553    }
554
555    return res;
556 }
557
558 bool test4b(const char *cachefile)
559 {
560    if (!cachefile) 
561    {
562       fprintf(stderr, "%s[%d]:  NULL param\n", FILE__, __LINE__);
563       abort();
564    }
565
566    bool res = deserialize_verify<ZeroFour>(cachefile);
567
568    if (!res) 
569    {
570       fprintf(stderr, "%s[%d]:  test4b failed\n", FILE__, __LINE__);
571    }
572
573    return res;
574 }
575
576 /* 
577  * Test #5 
578  */
579
580 class ZeroFive : public Serializable {
581    public:
582       std::vector<int *> zero_five_ints;
583
584       bool operator==(const ZeroFive &cmp) 
585       {
586          if (zero_five_ints.size() != cmp.zero_five_ints.size()) 
587          {
588             return false;
589          }
590
591          for (unsigned int i = 0; i < cmp.zero_five_ints.size(); ++i) 
592          {
593             assert(zero_five_ints[i]);
594             assert(cmp.zero_five_ints[i]);
595
596             if ((*zero_five_ints[i] != *cmp.zero_five_ints[i])) 
597                   return false;
598          }
599
600          return true;
601       }
602
603       bool operator!=(const ZeroFive &cmp) 
604       {
605          return (! (*this == cmp));
606       }
607
608       void printcmp(const ZeroFive &cmp) 
609       {
610          if (zero_five_ints.size() != cmp.zero_five_ints.size()) 
611          {
612             fprintf(stderr, "%s[%d]:  vectors have sizes %lu and %lu\n", 
613                   FILE__, __LINE__, cmp.zero_five_ints.size(), zero_five_ints.size());
614          }
615
616          for (unsigned int i = 0; i < cmp.zero_five_ints.size(); ++i) 
617          {
618             assert(zero_five_ints[i]);
619             if ((*zero_five_ints[i] != *cmp.zero_five_ints[i])) 
620                fprintf(stderr, "elem %d: %d -- %d\n", i, *zero_five_ints[i], 
621                      *cmp.zero_five_ints[i]);
622          }
623       }
624
625       void serialize(SerializerBase *sb, const char *)
626       {
627          try 
628          {
629             gtranslate(sb,zero_five_ints);
630          } 
631          SER_CATCH("ZeroFive");
632       }
633
634 };
635
636 bool setup_control(ZeroFive &param)
637 {
638    for (unsigned int i = 0; i < 50; ++i) 
639    {
640       int *newint = new int[1];
641       assert(newint);
642       *newint = i*100 + 2077;
643       param.zero_five_ints.push_back(newint);
644    }
645
646    return true;
647 }
648
649 bool test5()
650 {
651    bool res = serialize_test<ZeroFive>(5, prog_name);
652
653    if (!res) 
654    {
655       fprintf(stderr, "%s[%d]:  test5 failed\n", FILE__, __LINE__);
656    }
657
658    return res;
659 }
660
661 bool test5b(const char *cachefile)
662 {
663    if (!cachefile) 
664    {
665       fprintf(stderr, "%s[%d]:  NULL param\n", FILE__, __LINE__);
666       abort();
667    }
668
669    bool res = deserialize_verify<ZeroFive>(cachefile);
670
671    if (!res) 
672    {
673       fprintf(stderr, "%s[%d]:  test5b failed\n", FILE__, __LINE__);
674    }
675    return res;
676 }
677
678 /* 
679  * Test #6 
680  */
681
682
683 class ZeroSix : public Serializable {
684    public:
685       hash_map<char, std::string> dictionary6;
686
687       bool operator==(ZeroSix &cmp) 
688       {
689          if (dictionary6.size() != cmp.dictionary6.size()) 
690          {
691             return false;
692          }
693
694          hash_map<char, std::string>::iterator iter1 = dictionary6.begin();
695          hash_map<char, std::string>::iterator iter2 = cmp.dictionary6.begin();
696
697          while ((iter1 != dictionary6.end()) && (iter2 != cmp.dictionary6.end())) 
698          {
699             char key1 = iter1->first;
700             char key2 = iter2->first;
701             std::string &val1 = iter1->second;
702             std::string &val2 = iter2->second;
703
704             if (key1 != key2) 
705             {
706                fprintf(stderr, "%s[%d]: keys differ: %c != %c\n", 
707                      FILE__, __LINE__, key1, key2);
708                return false;
709             }
710
711             if (val1 != val2) 
712             {
713                fprintf(stderr, "%s[%d]: vals differ: '%s' != '%s'\n", 
714                      FILE__, __LINE__, val1.c_str(), val2.c_str());
715                return false;
716             }
717
718             iter1++;
719             iter2++;
720          }
721
722          return true;
723       }
724
725       bool operator!=(ZeroSix &cmp) 
726       {
727          return (! (*this == cmp));
728       }
729
730       void printcmp(ZeroSix &cmp) 
731       {
732          if (dictionary6.size() != cmp.dictionary6.size()) 
733          {
734             fprintf(stderr, "%s[%d]:  hashes have sizes %lu and %lu\n", 
735                   FILE__, __LINE__, cmp.dictionary6.size(), dictionary6.size());
736          }
737
738          hash_map<char, std::string>::iterator iter1 = dictionary6.begin();
739          hash_map<char, std::string>::iterator iter2 = cmp.dictionary6.begin();
740
741          while (iter1 != dictionary6.end() && iter2 != cmp.dictionary6.end()) 
742          {
743             char key1 = iter1->first;
744             char key2 = iter2->first;
745             std::string val1 = iter1->second;
746             std::string val2 = iter2->second;
747             fprintf(stderr, "%s[%d]:  key1:  %c, val1: '%s'\n", 
748                   FILE__, __LINE__, key1, val1.c_str());
749             fprintf(stderr, "%s[%d]:  key2:  %c, val2: '%s'\n", 
750                   FILE__, __LINE__, key2, val2.c_str());
751             iter1++;
752             iter2++;
753          }
754       }
755
756       void serialize(SerializerBase *sb, const char *) 
757       {
758          try 
759          {
760             fprintf(stderr, "%s[%d]:  before gtranslate:  hash size = %lu\n", 
761                   FILE__, __LINE__, dictionary6.size());
762             gtranslate(sb,dictionary6);
763          } 
764          SER_CATCH("ZeroSix");
765       }
766
767 };
768
769 bool setup_control(ZeroSix &param)
770 {
771    assert(param.dictionary6.size() == 0);
772    param.dictionary6['a'] = "aardvark";
773    param.dictionary6['b'] = "bollocks";
774    param.dictionary6['c'] = "cro-magnon";
775    param.dictionary6['d'] = "deadbeat";
776    param.dictionary6['e'] = "elephant";
777    param.dictionary6['f'] = "farce";
778    param.dictionary6['g'] = "guardian";
779    param.dictionary6['h'] = "heresy";
780    param.dictionary6['i'] = "ipsedixit";
781    param.dictionary6['j'] = "jovian";
782    param.dictionary6['k'] = "killface";
783    param.dictionary6['l'] = "lavatory";
784    param.dictionary6['m'] = "masonic";
785    param.dictionary6['n'] = "newbie";
786    param.dictionary6['o'] = "oddity";
787    param.dictionary6['p'] = "paternal";
788    param.dictionary6['q'] = "quack";
789    param.dictionary6['r'] = "restaurant";
790    param.dictionary6['s'] = "salami";
791    param.dictionary6['t'] = "twonky";
792    param.dictionary6['u'] = "usurper";
793    param.dictionary6['v'] = "velocity";
794    param.dictionary6['w'] = "wherabouts";
795    param.dictionary6['x'] = "xray-spex";
796    param.dictionary6['y'] = "yosemite";
797    param.dictionary6['z'] = "zeus";
798    return true;
799 }
800
801 bool test6()
802 {
803    bool res = serialize_test<ZeroSix>(6, prog_name);
804
805    if (!res) 
806    {
807       fprintf(stderr, "%s[%d]:  test6 failed\n", FILE__, __LINE__);
808    }
809
810    return res;
811 }
812
813 bool test6b(const char *cachefile)
814 {
815    if (!cachefile) 
816    {
817       fprintf(stderr, "%s[%d]:  NULL param\n", FILE__, __LINE__);
818       abort();
819    }
820
821    bool res = deserialize_verify<ZeroSix>(cachefile);
822
823    if (!res) 
824    {
825       fprintf(stderr, "%s[%d]:  test6b failed\n", FILE__, __LINE__);
826    }
827
828    return res;
829 }
830
831
832 class AuxSeven : public Serializable {
833    public:
834       int a7_int;
835       std::string a7_string;
836
837       bool operator==(AuxSeven &cmp) 
838       {
839          if (a7_int != cmp.a7_int)
840             return false;
841
842          if (a7_string != cmp.a7_string)
843             return false;
844
845          return true;
846       }
847
848       bool operator!=(AuxSeven &cmp) 
849       {
850          return (! (*this == cmp));
851       }
852
853       void printcmp(AuxSeven &cmp) 
854       {
855          fprintf(stderr, "[%d %s %d][%s %s %s]\n", a7_int, 
856                (a7_int == cmp.a7_int) ? "==" : "!=", 
857                cmp.a7_int, a7_string.c_str(), 
858                (a7_string == cmp.a7_string) ? "==" : "!=",
859                cmp.a7_string.c_str());
860       }
861
862       void serialize(SerializerBase *sb, const char *) 
863       {
864          try 
865          {
866             gtranslate(sb,a7_int);
867             gtranslate(sb,a7_string);
868          } 
869          SER_CATCH("AuxSeven");
870       }
871 };
872
873 bool setup_control(AuxSeven &param, int x)
874 {
875    char buf[12];
876    sprintf(buf, "%d", x);
877    param.a7_int = x;
878    param.a7_string = std::string(buf);
879    return true;
880 }
881
882 class ZeroSeven : public Serializable {
883    public:
884       AuxSeven a7_1;
885       AuxSeven a7_2;
886       AuxSeven a7_3;
887       AuxSeven a7_4;
888       AuxSeven a7_5;
889       AuxSeven a7_6;
890       AuxSeven a7_7;
891       AuxSeven a7_8;
892       AuxSeven a7_9;
893       AuxSeven a7_10;
894
895       bool operator==(ZeroSeven &cmp) 
896       {
897          if (a7_1 != cmp.a7_1) return false;
898          if (a7_2 != cmp.a7_2) return false;
899          if (a7_3 != cmp.a7_3) return false;
900          if (a7_4 != cmp.a7_4) return false;
901          if (a7_5 != cmp.a7_5) return false;
902          if (a7_6 != cmp.a7_6) return false;
903          if (a7_7 != cmp.a7_7) return false;
904          if (a7_8 != cmp.a7_8) return false;
905          if (a7_9 != cmp.a7_9) return false;
906          if (a7_10 != cmp.a7_10) return false;
907          return true;
908       }
909
910       bool operator!=(ZeroSeven &cmp) 
911       {
912          return (! (*this == cmp));
913       }
914
915       void printcmp(ZeroSeven &cmp) 
916       {
917          a7_1.printcmp(cmp.a7_1);
918          a7_2.printcmp(cmp.a7_2);
919          a7_3.printcmp(cmp.a7_3);
920          a7_4.printcmp(cmp.a7_4);
921          a7_5.printcmp(cmp.a7_5);
922          a7_6.printcmp(cmp.a7_6);
923          a7_7.printcmp(cmp.a7_7);
924          a7_8.printcmp(cmp.a7_8);
925          a7_9.printcmp(cmp.a7_9);
926          a7_10.printcmp(cmp.a7_10);
927       }
928
929       void serialize(SerializerBase *sb, const char *) 
930       {
931          try 
932          {
933             gtranslate(sb,a7_1);
934             gtranslate(sb,a7_2);
935             gtranslate(sb,a7_3);
936             gtranslate(sb,a7_4);
937             gtranslate(sb,a7_5);
938             gtranslate(sb,a7_6);
939             gtranslate(sb,a7_7);
940             gtranslate(sb,a7_8);
941             gtranslate(sb,a7_9);
942             gtranslate(sb,a7_10);
943          } 
944          SER_CATCH("ZeroSeven");
945       }
946 };
947
948 bool setup_control(ZeroSeven &param, int mult = 1)
949 {
950    setup_control(param.a7_1,1 *mult);
951    setup_control(param.a7_2,11 *mult);
952    setup_control(param.a7_3,111 *mult);
953    setup_control(param.a7_4,1111 *mult);
954    setup_control(param.a7_5,11111 *mult);
955    setup_control(param.a7_6,111111 *mult);
956    setup_control(param.a7_7,1111111 *mult);
957    setup_control(param.a7_8,11111111 *mult);
958    setup_control(param.a7_9,111111111 *mult);
959    setup_control(param.a7_10,1111111111 *mult);
960    return true;
961 }
962
963 bool test7()
964 {
965    bool res = serialize_test<ZeroSeven>(7, prog_name);
966
967    if (!res) 
968    {
969       fprintf(stderr, "%s[%d]:  test7 failed\n", FILE__, __LINE__);
970    }
971
972    return res;
973 }
974
975 bool test7b(const char *cachefile)
976 {
977    
978    if (!cachefile) {
979       fprintf(stderr, "%s[%d]:  NULL param\n", FILE__, __LINE__);
980       abort();
981    }
982
983    bool res = deserialize_verify<ZeroSeven>(cachefile);
984
985    if (!res) 
986    {
987       fprintf(stderr, "%s[%d]:  test7b failed\n", FILE__, __LINE__);
988    }
989
990    return res;
991 }
992
993 class ZeroEight : public Serializable {
994    public:
995       std::vector<ZeroSeven> v8;
996
997       bool operator==(ZeroEight &cmp) 
998       {
999          if (v8.size() != cmp.v8.size())
1000             return false;
1001
1002          for (unsigned int i = 0; i < v8.size(); ++i) 
1003          {
1004             if (v8[i] != cmp.v8[i]) return false;
1005          }
1006
1007          return true;
1008       }
1009
1010       bool operator!=(ZeroEight &cmp) 
1011       {
1012          return (! (*this == cmp));
1013       }
1014
1015       void printcmp(ZeroEight &cmp) 
1016       {
1017          if (v8.size() != cmp.v8.size()) 
1018          {
1019             fprintf(stderr, "%s[%d]:  vector sizes differ %lu -- %lu\n", 
1020                   FILE__, __LINE__, v8.size(), cmp.v8.size());
1021
1022             return;
1023          }
1024
1025          for (unsigned int i = 0; i < v8.size(); ++i) 
1026          {
1027             v8[i].printcmp(cmp.v8[i]);
1028          }
1029       }
1030
1031       void serialize(SerializerBase *sb, const char *) 
1032       {
1033          try 
1034          {
1035             gtranslate(sb,v8);
1036          } SER_CATCH("ZeroEight");
1037       }
1038 };
1039
1040 bool setup_control(ZeroEight &param)
1041 {
1042    ZeroSeven z7_1;
1043    ZeroSeven z7_2;
1044    ZeroSeven z7_3;
1045    ZeroSeven z7_4;
1046    ZeroSeven z7_5;
1047    ZeroSeven z7_6;
1048    
1049    setup_control(z7_1, 1);
1050    setup_control(z7_2, 2);
1051    setup_control(z7_3, 3);
1052    setup_control(z7_4, 4);
1053    setup_control(z7_5, 5);
1054    setup_control(z7_6, 6);
1055
1056    param.v8.push_back(z7_1);
1057    param.v8.push_back(z7_2);
1058    param.v8.push_back(z7_3);
1059    param.v8.push_back(z7_4);
1060    param.v8.push_back(z7_5);
1061    param.v8.push_back(z7_6);
1062
1063    return true;
1064 }
1065
1066 bool test8()
1067 {
1068    bool res = serialize_test<ZeroEight>(8,prog_name);
1069    
1070    if (!res) 
1071    {
1072       fprintf(stderr, "%s[%d]:  test8 failed\n", FILE__, __LINE__);
1073    }
1074
1075    return res;
1076 }
1077
1078 bool test8b(const char *cachefile)
1079 {
1080    if (!cachefile) 
1081    {
1082       fprintf(stderr, "%s[%d]:  NULL param\n", FILE__, __LINE__);
1083       abort();
1084    }
1085
1086    bool res = deserialize_verify<ZeroEight>(cachefile);
1087
1088    if (!res) 
1089    {
1090       fprintf(stderr, "%s[%d]:  test8b failed\n", FILE__, __LINE__);
1091    }
1092
1093    return res;
1094 }
1095
1096 typedef struct {} zero_nine_anno;
1097
1098 #if 0
1099 class ZeroNine : public Serializable,
1100                  public AnnotatableSparse 
1101 {
1102    public:
1103       ZeroNine() : AnnotatableSparse() {}
1104       int i9;
1105
1106       bool operator==(ZeroNine &cmp) 
1107       {
1108          if (i9 != cmp.i9)
1109             return false;
1110
1111          Annotatable<int, zero_nine_anno, true> &z9_anno = *this;
1112          Annotatable<int, zero_nine_anno, true> &z9_anno_cmp = cmp;
1113
1114          if (z9_anno.size() != z9_anno_cmp.size()) 
1115          {
1116             return false;
1117          }
1118
1119          for (unsigned int i = 0; i < z9_anno.size(); ++i) 
1120          {
1121             if (z9_anno[i] != z9_anno_cmp[i])
1122                return false;
1123          }
1124
1125          return true;
1126       }
1127
1128       bool operator!=(ZeroNine &cmp) 
1129       {
1130          return (! (*this == cmp));
1131       }
1132
1133       void printcmp(ZeroNine &cmp) 
1134       {
1135          fprintf(stderr, "%s[%d]:  %d ?= %d\n", FILE__, __LINE__, i9, cmp.i9);
1136
1137          Annotatable<int, zero_nine_anno, true> &z9_anno = *this;
1138          Annotatable<int, zero_nine_anno, true> &z9_anno_cmp = cmp;
1139
1140          if (z9_anno.size() != z9_anno_cmp.size()) 
1141          {
1142             fprintf(stderr, "%s[%d]:  mismatched annotations count %d vs %d\n", 
1143                   FILE__, __LINE__, z9_anno.size(), z9_anno_cmp.size());
1144             return;
1145          }
1146
1147          for (unsigned int i = 0; i < z9_anno.size(); ++i) 
1148          {
1149             fprintf(stderr, "%s[%d]:  Annotation %d -- %d ?= %d\n", 
1150                   FILE__, __LINE__, i, z9_anno[i], z9_anno_cmp[i]);
1151          }
1152       }
1153
1154       void serialize(SerializerBase *sb, const char *) 
1155       {
1156
1157          Annotatable<int, zero_nine_anno, true> &z9_anno = *this;
1158
1159          try 
1160          {
1161             gtranslate(sb,i9);
1162             fprintf(stderr, "%s[%d]:  before gtranslate_annotations\n", FILE__, __LINE__);
1163             fprintf(stderr, "%s[%d]:    annotations.size() = %d\n", FILE__, __LINE__, 
1164                   z9_anno.size());
1165             bool res = z9_anno.gtranslate_annotations(sb);
1166             if (!res) 
1167             {
1168                fprintf(stderr, "%s[%d]:  FAILED TO %sSERIALIZE ANNOTATION\n", FILE__, __LINE__,
1169                      sb->iomode() == sd_serialize ? "" : "DE");
1170                abort();
1171             }
1172             else {
1173                fprintf(stderr, "%s[%d]:  %sSERIALIZE ANNOTATION SUCCEEDED\n", FILE__, __LINE__,
1174                      sb->iomode() == sd_serialize ? "" : "DE");
1175                fprintf(stderr, "%s[%d]:    annotations.size() = %d\n", FILE__, __LINE__, 
1176                      z9_anno.size());
1177             }
1178          } SER_CATCH("ZeroNine");
1179       }
1180 };
1181
1182 bool setup_control(ZeroNine &param)
1183 {
1184    param.i9 = 9;
1185    Annotatable<int, zero_nine_anno, true> &z9_anno = param;
1186    z9_anno.addAnnotation(55);
1187    z9_anno.addAnnotation(66);
1188    z9_anno.addAnnotation(77);
1189    z9_anno.addAnnotation(88);
1190    fprintf(stderr, "%s[%d]:  setup_control:  annotations.size() = %d\n", FILE__, __LINE__, 
1191          z9_anno.size());
1192    return true;
1193 }
1194 #endif
1195
1196 bool test9()
1197 {
1198 #if 0
1199    bool res = serialize_test<ZeroNine>(9, prog_name);
1200
1201    if (!res) 
1202    {
1203       fprintf(stderr, "%s[%d]:  test9 failed\n", FILE__, __LINE__);
1204    }
1205
1206    return res;
1207
1208 #else
1209    fprintf(stderr, "%s[%d]:  skipping test9\n", FILE__, __LINE__);
1210    return true;
1211 #endif
1212 }
1213
1214 bool test9b(const char *cachefile)
1215 {
1216    if (!cachefile) 
1217    {
1218       fprintf(stderr, "%s[%d]:  NULL param\n", FILE__, __LINE__);
1219       abort();
1220    }
1221
1222 #if 0
1223    bool res = deserialize_verify<ZeroNine>(cachefile);
1224
1225    if (!res) 
1226    {
1227       fprintf(stderr, "%s[%d]:  test9b failed\n", FILE__, __LINE__);
1228    }
1229
1230    return res;
1231 #else
1232
1233    fprintf(stderr, "%s[%d]:  skipping test9b: %s\n", FILE__, __LINE__, cachefile);
1234    return true;
1235 #endif
1236 }
1237
1238 class ZeroTen : public Serializable {
1239    public:
1240
1241       bool operator==(ZeroTen &cmp) 
1242       {
1243          return true;
1244       }
1245
1246       bool operator!=(ZeroTen &cmp) 
1247       {
1248          return (! (*this == cmp));
1249       }
1250
1251       void printcmp(ZeroTen &cmp) 
1252       {
1253       }
1254
1255       void serialize(SerializerBase *sb, const char *) 
1256       {
1257          try 
1258          {
1259             //gtranslate(sb,dictionary6);
1260          } 
1261          SER_CATCH("ZeroTen");
1262       }
1263 };
1264
1265 bool setup_control(ZeroTen &param)
1266 {
1267    return true;
1268 }
1269
1270 bool test10()
1271 {
1272 #if 0
1273    bool res = serialize_test<ZeroTen>(10, prog_name);
1274    if (!res) 
1275    {
1276       fprintf(stderr, "%s[%d]:  test10 failed\n", FILE__, __LINE__);
1277    }
1278
1279    return res;
1280 #endif
1281
1282    fprintf(stderr, "%s[%d]:  skipping test10\n", FILE__, __LINE__);
1283    return true;
1284 }
1285
1286 bool test10b(const char *cachefile)
1287 {
1288 #if 0
1289    if (!cachefile) 
1290    {
1291       fprintf(stderr, "%s[%d]:  NULL param\n", FILE__, __LINE__);
1292       abort();
1293    }
1294
1295    bool res = deserialize_verify<ZeroTen>(cachefile);
1296    if (!res) 
1297    {
1298       fprintf(stderr, "%s[%d]:  test10b failed\n", FILE__, __LINE__);
1299    }
1300
1301    return res;
1302 #endif
1303
1304    fprintf(stderr, "%s[%d]:  skipping test10b\n", FILE__, __LINE__);
1305    return true;
1306 }
1307
1308 int main(int iargc, char *argv[])
1309 {                                       /* despite different conventions */
1310    unsigned argc=(unsigned)iargc;      /* make argc consistently unsigned */
1311    unsigned int i;
1312    unsigned long testNum=0;
1313    char *modifier = NULL;
1314    char *aux_file_name = NULL;
1315    char *logfilename = NULL;
1316    prog_name = argv[0];
1317
1318    fprintf(stderr, "%s[%d]:  welcome to \"%s", __FILE__, __LINE__, argv[0]);
1319    for (unsigned int ii=1; ii < argc; ++ii) 
1320    {
1321       fprintf(stderr, " %s", argv[ii]);
1322    }
1323    fprintf(stderr, "\"\n");
1324
1325    for (i = 1; i < argc; ++i) 
1326    {
1327       if (!strcmp(argv[i], "-verbose")) 
1328       {
1329          debugPrint = TRUE;
1330       } 
1331       else if (!strcmp(argv[i], "-log")) 
1332       {
1333          if ((i + 1) >= argc) 
1334          {
1335             fprintf(stderr, "Missing log file name\n");
1336             exit(-1);
1337          }
1338          i += 1;
1339          logfilename = argv[i];
1340       } 
1341       else if (!strcmp(argv[i], "-run")) 
1342       {
1343          char *str_end_ptr = NULL;
1344          testNum = strtoul(argv[i+1], &str_end_ptr,10);
1345          if (*str_end_ptr != '\0') 
1346          {
1347             //  catch subtests that are exec'd automatically (eg, 1b, 1c)
1348             modifier = str_end_ptr;
1349             aux_file_name = argv[i+2];
1350             fprintf(stderr, "%s[%d]:  have test modifier %s, testNum = %d\n", 
1351                   FILE__, __LINE__, modifier, testNum);
1352             i += 1;
1353          }
1354           else 
1355           {
1356             /* end of test list */
1357             break;
1358          }
1359          i++;
1360       } 
1361       else 
1362       {
1363          fprintf(stderr, "Usage: %s [-verbose] -run <num>\n", argv[0]);
1364          fprintf(stderr, "\n\nyou asked for:\n\t\"");
1365
1366          for (unsigned int i = 0; i < argc; ++i) 
1367          {
1368             fprintf(stderr, "%s ", argv[i]);
1369          }
1370
1371          fprintf(stderr, "\"\n");
1372          exit(-1);
1373       }
1374    }
1375
1376    if ((logfilename != NULL) && (strcmp(logfilename, "-") != 0)) 
1377    {
1378       outlog = fopen(logfilename, "a");
1379
1380       if (NULL == outlog) 
1381       {
1382          fprintf(stderr, "Error opening log file %s\n", logfilename);
1383          exit(-1);
1384       }
1385       errlog = outlog;
1386    }
1387    else 
1388    {
1389       outlog = stdout;
1390       errlog = stderr;
1391    }
1392
1393    if ((argc==1) || debugPrint)
1394       logstatus("Mutatee %s [C++]:\"%s\"\n", argv[0], Builder_id);
1395
1396    if (argc==1) exit(0);
1397
1398    bool test_ok = false;
1399
1400    switch (testNum) 
1401    {
1402       case 1:
1403          if (!modifier)
1404             test_ok = test1();
1405          else 
1406          {
1407             switch (*modifier) 
1408             {
1409                case 'b':  
1410                   if (!aux_file_name) 
1411                   {
1412                      fprintf(stderr, "%s[%d]:  no aux file name\n", FILE__, __LINE__);
1413                      abort();
1414                   }
1415
1416                   fprintf(stderr, "%s[%d]:  process %d about to run test1b\n", 
1417                         FILE__, __LINE__, getpid());
1418
1419                   test_ok = test1b(aux_file_name); 
1420
1421                   fprintf(stderr, "%s[%d]:  process %d ran test1b\n", 
1422                         FILE__, __LINE__, getpid());
1423
1424                   break;
1425
1426                default:
1427                   fprintf(stderr, "%s[%d]:  bad modifier! %s\n", 
1428                         FILE__, __LINE__, modifier);
1429             };
1430          }
1431          break;
1432
1433       case 2:
1434          if (!modifier)
1435             test_ok = test2();
1436          else 
1437          {
1438             switch (*modifier) 
1439             {
1440                case 'b':  test_ok = test2b(aux_file_name); break;
1441                default:
1442                   fprintf(stderr, "%s[%d]:  bad modifier! %s\n", 
1443                         FILE__, __LINE__, modifier);
1444             };
1445          }
1446          break;
1447
1448       case 3:
1449          if (!modifier)
1450             test_ok = test3();
1451          else 
1452          {
1453             switch (*modifier) 
1454             {
1455                case 'b':  test_ok = test3b(aux_file_name); break;
1456                default:
1457                   fprintf(stderr, "%s[%d]:  bad modifier! %s\n", 
1458                         FILE__, __LINE__, modifier);
1459             };
1460          }
1461          break;
1462
1463       case 4:
1464          if (!modifier)
1465             test_ok = test4();
1466          else 
1467          {
1468             switch (*modifier) 
1469             {
1470                case 'b':  test_ok = test4b(aux_file_name); break;
1471                default:
1472                   fprintf(stderr, "%s[%d]:  bad modifier! %s\n", 
1473                         FILE__, __LINE__, modifier);
1474             };
1475          }
1476          break;
1477
1478       case 5:
1479          if (!modifier)
1480             test_ok = test5();
1481          else 
1482          {
1483             switch (*modifier) 
1484             {
1485                case 'b':  test_ok = test5b(aux_file_name); break;
1486                default:
1487                   fprintf(stderr, "%s[%d]:  bad modifier! %s\n", 
1488                         FILE__, __LINE__, modifier);
1489             };
1490          }
1491          break;
1492
1493       case 6:
1494          if (!modifier)
1495             test_ok = test6();
1496          else 
1497          {
1498             switch (*modifier) 
1499             {
1500                case 'b':  test_ok = test6b(aux_file_name); break;
1501                default:
1502                   fprintf(stderr, "%s[%d]:  bad modifier! %s\n", 
1503                         FILE__, __LINE__, modifier);
1504             };
1505          }
1506          break;
1507       case 7:
1508          if (!modifier)
1509             test_ok = test7();
1510          else 
1511          {
1512             switch (*modifier) 
1513             {
1514                case 'b':  test_ok = test7b(aux_file_name); break;
1515                default:
1516                   fprintf(stderr, "%s[%d]:  bad modifier! %s\n", 
1517                         FILE__, __LINE__, modifier);
1518             };
1519          }
1520          break;
1521       case 8:
1522          if (!modifier)
1523             test_ok = test8();
1524          else 
1525          {
1526             switch (*modifier) 
1527             {
1528                case 'b':  test_ok = test8b(aux_file_name); break;
1529                default:
1530                   fprintf(stderr, "%s[%d]:  bad modifier! %s\n", 
1531                         FILE__, __LINE__, modifier);
1532             };
1533          }
1534          break;
1535       case 9:
1536          if (!modifier)
1537             test_ok = test9();
1538          else 
1539          {
1540             switch (*modifier) 
1541             {
1542                case 'b':  test_ok = test9b(aux_file_name); break;
1543                default:
1544                   fprintf(stderr, "%s[%d]:  bad modifier! %s\n", 
1545                         FILE__, __LINE__, modifier);
1546             };
1547          }
1548          break;
1549       case 10:
1550          if (!modifier)
1551             test_ok = test10();
1552          else 
1553          {
1554             switch (*modifier) 
1555             {
1556                case 'b':  test_ok = test10b(aux_file_name); break;
1557                default:
1558                   fprintf(stderr, "%s[%d]:  bad modifier! %s\n", 
1559                         FILE__, __LINE__, modifier);
1560             };
1561          }
1562          break;
1563       default:
1564          fprintf(stderr, "%s[%d]: invalid test number %d in mutatee\n", 
1565                FILE__, __LINE__, testNum);
1566          break;
1567    }
1568
1569    dprintf("Mutatee %s terminating.\n", argv[0]);
1570
1571    if ((outlog != NULL) && (outlog != stdout)) 
1572    {
1573       fclose(outlog);
1574    }
1575
1576    if (test_ok) 
1577    {
1578       return 0; /* true == no error, so return zero */
1579    }
1580
1581    return -1;
1582 }