/[ascend]/trunk/ascend/utilities/test/test_ascPrint.c
ViewVC logotype

Annotation of /trunk/ascend/utilities/test/test_ascPrint.c

Parent Directory Parent Directory | Revision Log Revision Log

Revision 59 - (hide annotations) (download) (as text)
Sun Oct 30 01:38:20 2005 UTC (19 years, 4 months ago) by jds
Original Path: trunk/base/generic/utilities/test/test_ascPrint.c
File MIME type: text/x-csrc
File size: 20609 byte(s) 
- prototype unit test suite based on CUnit added.
- unit tests for base/generic/general and base/generic/utilites added.
- 2nd manual rework of doxygen documentation in general and utilities.
- bug fixes (mostly general & utilities) found during test development.
- added asc_assert prototype to redirect failures to Asc_Panic() and enable decoupling assertions from NDEBUG.
- some modifications of interface & implementation to facilitate testing.
- utilities/ascPrint & utilities/ascMalloc functions now always included in base libs to minimize recompilation when an interface chooses different options.
1 jds 59 /*
2     * Unit test functions for ASCEND: utilities/ascPrint.c
3     *
4     * Copyright (C) 2005 Jerry St.Clair
5     *
6     * This file is part of the Ascend Environment.
7     *
8     * The Ascend Environment is free software; you can redistribute it
9     * and/or modify it under the terms of the GNU General Public License as
10     * published by the Free Software Foundation; either version 2 of the
11     * License, or (at your option) any later version.
12     *
13     * The Ascend Environment is distributed in 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     * You should have received a copy of the GNU General Public License
19     * along with the program; if not, write to the Free Software Foundation,
20     * Inc., 675 Mass Ave, Cambridge, MA 02139 USA. Check the file named
21     * COPYING.
22     */
23    
24     #include <stdio.h>
25     #include <io.h>
26     #include <stdarg.h>
27     #include "utilities/ascConfig.h"
28     #include "utilities/ascMalloc.h"
29     #include "utilities/ascPrint.h"
30     #include "utilities/ascPrintType.h"
31     #include "CUnit/CUnit.h"
32     #include "test_ascPrint.h"
33     #include "printutil.h"
34    
35     #undef STR_LEN
36     #define STR_LEN 4096
37    
38     /* flag for whether test_print1() was called. */
39     static int test_print1_called = FALSE;
40     /* static string to hold result of call to test_print1() */
41     static char test_print1_str[STR_LEN];
42     /* static FILE * to hold result of call to test_print2() */
43     static FILE *test_print1_fp;
44     /* print function for test_ascPrint_vtable1 */
45     static int test_print1(FILE *fp, CONST char *format, va_list args)
46     {
47     int result;
48    
49     test_print1_called = TRUE;
50     test_print1_fp = fp;
51     result = vsnprintf(test_print1_str, STR_LEN, format, args);
52     test_print1_str[STR_LEN-1] = '\0';
53     return result;
54     }
55    
56     /* flag for whether test_flush1() was called. */
57     static int test_flush1_called = FALSE;
58     /* static FILE * to hold result of call to test_flush1() */
59     static FILE *test_flush1_fp;
60     /* flush function for test_ascPrint_vtable1 */
61     static int test_flush1(FILE *fp)
62     {
63     test_flush1_fp = fp;
64     test_flush1_called = TRUE;
65     return 0;
66     }
67    
68     /*
69     * Vtable for testing of ascPrint.
70     * print and flush point to special functions which record the
71     * fact and details of their invocation using static variables.
72     */
73     static struct Asc_PrintVTable f_test_ascPrint_vtable1 = { "test_vtable1", test_print1, test_flush1, NULL };
74    
75     /* flag for whether test_print2() was called. */
76     static int test_print2_called = FALSE;
77     /* static string to hold result of call to test_print2() */
78     static char test_print2_str[STR_LEN];
79     /* static FILE * to hold result of call to test_print2() */
80     static FILE *test_print2_fp;
81     /* print function for test_ascPrint_vtable2 */
82     static int test_print2(FILE *fp, CONST char *format, va_list args)
83     {
84     int result;
85    
86     test_print2_called = TRUE;
87     test_print2_fp = fp;
88     result = vsnprintf(test_print2_str, STR_LEN, format, args);
89     test_print2_str[STR_LEN-1] = '\0';
90     return result;
91     }
92    
93     /* flag for whether test_flush2() was called. */
94     static int test_flush2_called = FALSE;
95     /* static FILE * to hold result of call to test_flush2() */
96     static FILE *test_flush2_fp;
97     /* flush function for test_ascPrint_vtable1 */
98     static int test_flush2(FILE *fp)
99     {
100     test_flush2_fp = fp;
101     test_flush2_called = TRUE;
102     return 0;
103     }
104    
105     /*
106     * Another vtable for testing of ascPrint.
107     * print and flush point to special functions which record the
108     * fact and details of their invocation using static variables.
109     */
110     static struct Asc_PrintVTable f_test_ascPrint_vtable2 = { "test_vtable2", test_print2, test_flush2, NULL };
111    
112     static struct Asc_PrintVTable f_bad_vtable1 = { NULL, test_print1, test_flush1, NULL };
113     static struct Asc_PrintVTable f_bad_vtable2 = { "Bad_vtable", NULL, test_flush1, NULL };
114     static struct Asc_PrintVTable f_bad_vtable3 = { "Bad_vtable", test_print1, NULL, NULL };
115     static struct Asc_PrintVTable f_bad_vtable4 = { "Bad_vtable", test_print1, test_flush1, &f_bad_vtable1 };
116    
117     /*
118     * We direct output to to special functions that keep track of whether
119     * they were called and with which parameters. This allows checking
120     * the marshalling of output via the registered vtables.
121     */
122     static void test_ascPrint(void)
123     {
124     char str[STR_LEN];
125     int nchars;
126     int i_disabled_printing = FALSE;
127     unsigned long prior_meminuse;
128    
129     prior_meminuse = ascmeminuse(); /* save meminuse() at start of test function */
130    
131     if (test_printing_enabled()) { /* turn off printing (i.e. remove global vtable) */
132     i_disabled_printing = TRUE;
133     test_disable_printing();
134     }
135    
136     /* test Asc_PrintPushVTable() */
137    
138     CU_TEST(1 == Asc_PrintPushVTable(NULL)); /* error - NULL vtable */
139     CU_TEST(1 == Asc_PrintPushVTable(&f_bad_vtable1)); /* error - NULL name */
140     CU_TEST(1 == Asc_PrintPushVTable(&f_bad_vtable2)); /* error - NULL print */
141     CU_TEST(1 == Asc_PrintPushVTable(&f_bad_vtable3)); /* error - NULL flush */
142     CU_TEST(1 == Asc_PrintPushVTable(&f_bad_vtable4)); /* error - non-NULL next */
143     CU_TEST(FALSE == Asc_PrintHasVTable("Bad_vtable"));
144     CU_TEST(FALSE == Asc_PrintHasVTable("test_vtable1"));
145     CU_TEST(FALSE == Asc_PrintHasVTable("test_vtable2"));
146    
147     CU_TEST(0 == Asc_PrintPushVTable(&f_test_ascPrint_vtable1)); /* push a normal vtable */
148     CU_TEST(TRUE == Asc_PrintHasVTable("test_vtable1"));
149     CU_TEST(FALSE == Asc_PrintHasVTable("test_vtable2"));
150    
151     test_print1_called = FALSE;
152     test_print1_str[0] = '\0';
153     test_print1_fp = NULL;
154     test_print2_called = FALSE;
155     test_print2_str[0] = '\0';
156     test_print2_fp = NULL;
157    
158     Asc_Printf("This is test string #1."); /* print - should only go to 1st vtable */
159     CU_TEST(TRUE == test_print1_called);
160     CU_TEST(0 == strcmp(test_print1_str, "This is test string #1."));
161     CU_TEST(stdout == test_print1_fp);
162     CU_TEST(FALSE == test_print2_called);
163     CU_TEST(test_print2_str[0] == '\0');
164     CU_TEST(NULL == test_print2_fp);
165    
166     test_flush1_called = FALSE;
167     test_flush1_fp = NULL;
168     test_flush2_called = FALSE;
169     test_flush2_fp = NULL;
170    
171     Asc_FFlush(stdout); /* flush - should only go to 1st vtable */
172     CU_TEST(TRUE == test_flush1_called);
173     CU_TEST(stdout == test_flush1_fp);
174     CU_TEST(FALSE == test_flush2_called);
175     CU_TEST(NULL == test_flush2_fp);
176    
177     CU_TEST(0 == Asc_PrintPushVTable(&f_test_ascPrint_vtable2)); /* push another vtable */
178     CU_TEST(TRUE == Asc_PrintHasVTable("test_vtable1"));
179     CU_TEST(TRUE == Asc_PrintHasVTable("test_vtable2"));
180    
181     test_print1_called = FALSE;
182     test_print1_str[0] = '\0';
183     test_print1_fp = NULL;
184     test_print2_called = FALSE;
185     test_print2_str[0] = '\0';
186     test_print2_fp = NULL;
187    
188     Asc_Printf("This is test string #2."); /* print - should go to both vtables */
189     CU_TEST(TRUE == test_print1_called);
190     CU_TEST(0 == strcmp(test_print1_str, "This is test string #2."));
191     CU_TEST(stdout == test_print1_fp);
192     CU_TEST(TRUE == test_print2_called);
193     CU_TEST(0 == strcmp(test_print2_str, "This is test string #2."));
194     CU_TEST(stdout == test_print2_fp);
195    
196     test_flush1_called = FALSE;
197     test_flush1_fp = NULL;
198     test_flush2_called = FALSE;
199     test_flush2_fp = NULL;
200    
201     Asc_FFlush(stdout); /* flush - should go to both vtables */
202     CU_TEST(TRUE == test_flush1_called);
203     CU_TEST(stdout == test_flush1_fp);
204     CU_TEST(TRUE == test_flush2_called);
205     CU_TEST(stdout == test_flush2_fp);
206    
207     CU_TEST(&f_test_ascPrint_vtable1 == Asc_PrintRemoveVTable("test_vtable1")); /* remove a vtable */
208     f_test_ascPrint_vtable1.next = NULL;
209     CU_TEST(FALSE == Asc_PrintHasVTable("test_vtable1"));
210     CU_TEST(TRUE == Asc_PrintHasVTable("test_vtable2"));
211    
212     test_print1_called = FALSE;
213     test_print1_str[0] = '\0';
214     test_print1_fp = NULL;
215     test_print2_called = FALSE;
216     test_print2_str[0] = '\0';
217     test_print2_fp = NULL;
218    
219     Asc_Printf("This is test string last."); /* print - should only go to 2nd vtable */
220     CU_TEST(FALSE == test_print1_called);
221     CU_TEST(test_print1_str[0] == '\0');
222     CU_TEST(NULL == test_print1_fp);
223     CU_TEST(TRUE == test_print2_called);
224     CU_TEST(0 == strcmp(test_print2_str, "This is test string last."));
225     CU_TEST(stdout == test_print2_fp);
226    
227     test_flush1_called = FALSE;
228     test_flush1_fp = NULL;
229     test_flush2_called = FALSE;
230     test_flush2_fp = NULL;
231    
232     Asc_FFlush(stdout); /* flush - should only go to 2nd vtable */
233     CU_TEST(FALSE == test_flush1_called);
234     CU_TEST(NULL == test_flush1_fp);
235     CU_TEST(TRUE == test_flush2_called);
236     CU_TEST(stdout == test_flush2_fp);
237    
238     CU_TEST(&f_test_ascPrint_vtable2 == Asc_PrintRemoveVTable("test_vtable2")); /* remove a vtable */
239     f_test_ascPrint_vtable2.next = NULL;
240     CU_TEST(FALSE == Asc_PrintHasVTable("test_vtable1"));
241     CU_TEST(FALSE == Asc_PrintHasVTable("test_vtable2"));
242    
243     test_print1_called = FALSE;
244     test_print1_str[0] = '\0';
245     test_print1_fp = NULL;
246     test_print2_called = FALSE;
247     test_print2_str[0] = '\0';
248     test_print2_fp = NULL;
249    
250     Asc_Printf("No one should get this one."); /* print - no printing should occur */
251     CU_TEST(FALSE == test_print1_called);
252     CU_TEST(test_print1_str[0] == '\0');
253     CU_TEST(NULL == test_print1_fp);
254     CU_TEST(FALSE == test_print2_called);
255     CU_TEST(test_print2_str[0] == '\0');
256     CU_TEST(NULL == test_print2_fp);
257    
258     test_flush1_called = FALSE;
259     test_flush1_fp = NULL;
260     test_flush2_called = FALSE;
261     test_flush2_fp = NULL;
262    
263     Asc_FFlush(stdout); /* flush - no flushing should occur */
264     CU_TEST(FALSE == test_flush1_called);
265     CU_TEST(NULL == test_flush1_fp);
266     CU_TEST(FALSE == test_flush2_called);
267     CU_TEST(NULL == test_flush2_fp);
268    
269     /* test Asc_PrintRemoveVTable() */
270     /* basic functionality tested in other sections - focus on error conditions */
271    
272     CU_TEST(NULL == Asc_PrintRemoveVTable(NULL)); /* error - NULL name */
273     CU_TEST(NULL == Asc_PrintRemoveVTable("test_vtable1"));/* name not registered */
274     CU_TEST(NULL == Asc_PrintRemoveVTable("test_vtable2"));/* name not registered */
275    
276     CU_TEST(0 == Asc_PrintPushVTable(&f_test_ascPrint_vtable2)); /* push a vtable */
277     CU_TEST(FALSE == Asc_PrintHasVTable("test_vtable1"));
278     CU_TEST(TRUE == Asc_PrintHasVTable("test_vtable2"));
279     CU_TEST(NULL == Asc_PrintRemoveVTable(NULL)); /* error - NULL name */
280     CU_TEST(NULL == Asc_PrintRemoveVTable("test_vtable1"));/* name not registered */
281     CU_TEST(NULL == Asc_PrintRemoveVTable("")); /* name empty (not registered) */
282     CU_TEST(&f_test_ascPrint_vtable2 == Asc_PrintRemoveVTable("test_vtable2")); /* normal removal */
283     f_test_ascPrint_vtable2.next = NULL;
284     CU_TEST(FALSE == Asc_PrintHasVTable("test_vtable1"));
285     CU_TEST(FALSE == Asc_PrintHasVTable("test_vtable2"));
286    
287     /* test Asc_PrintHasVTable() */
288     /* basic functionality tested in other sections - focus on error conditions */
289    
290     CU_TEST(FALSE == Asc_PrintHasVTable(NULL)); /* error - NULL name */
291     CU_TEST(FALSE == Asc_PrintHasVTable("")); /* empty name */
292     CU_TEST(FALSE == Asc_PrintHasVTable("test_vtable1")); /* name not registered */
293     CU_TEST(FALSE == Asc_PrintHasVTable("test_vtable2")); /* name not registered */
294    
295     CU_TEST(0 == Asc_PrintPushVTable(&f_test_ascPrint_vtable1)); /* push vtables */
296     CU_TEST(0 == Asc_PrintPushVTable(&f_test_ascPrint_vtable2));
297    
298     CU_TEST(FALSE == Asc_PrintHasVTable(NULL)); /* error - NULL name */
299     CU_TEST(FALSE == Asc_PrintHasVTable("")); /* empty name */
300     CU_TEST(TRUE == Asc_PrintHasVTable("test_vtable1")); /* name registered */
301     CU_TEST(TRUE == Asc_PrintHasVTable("test_vtable2")); /* name registered */
302    
303     CU_TEST(&f_test_ascPrint_vtable2 == Asc_PrintRemoveVTable("test_vtable2")); /* normal removal */
304     CU_TEST(&f_test_ascPrint_vtable1 == Asc_PrintRemoveVTable("test_vtable1")); /* normal removal */
305     f_test_ascPrint_vtable1.next = NULL;
306     f_test_ascPrint_vtable2.next = NULL;
307    
308     CU_TEST(FALSE == Asc_PrintHasVTable(NULL)); /* error - NULL name */
309     CU_TEST(FALSE == Asc_PrintHasVTable("")); /* empty name */
310     CU_TEST(FALSE == Asc_PrintHasVTable("test_vtable1")); /* name not registered */
311     CU_TEST(FALSE == Asc_PrintHasVTable("test_vtable2")); /* name not registered */
312    
313     /* test Asc_Printf() */
314    
315     test_print1_called = FALSE;
316     test_print1_str[0] = '\0';
317     test_print1_fp = NULL;
318     test_print2_called = FALSE;
319     test_print2_str[0] = '\0';
320     test_print2_fp = NULL;
321    
322     nchars = snprintf(str, STR_LEN, "%s%d%c%s%f", "my_float[", 7, ']', " = ", 8.12);
323     CU_TEST(0 == Asc_Printf("%s%d%c%s%f", "my_float[", 7, ']', " = ", 8.12)); /* no vtables registered */
324     CU_TEST(FALSE == test_print1_called);
325     CU_TEST('\0' == test_print1_str[0]);
326     CU_TEST(NULL == test_print1_fp);
327     CU_TEST(FALSE == test_print2_called);
328     CU_TEST('\0' == test_print2_str[0]);
329     CU_TEST(NULL == test_print2_fp);
330    
331     CU_TEST(0 == Asc_PrintPushVTable(&f_test_ascPrint_vtable1)); /* push vtables */
332     CU_TEST(0 == Asc_PrintPushVTable(&f_test_ascPrint_vtable2));
333    
334     test_print1_called = FALSE;
335     test_print1_str[0] = '\0';
336     test_print1_fp = NULL;
337     test_print2_called = FALSE;
338     test_print2_str[0] = '\0';
339     test_print2_fp = NULL;
340    
341     nchars = snprintf(str, STR_LEN, "%s%d%c%s%f", "my_float[", 7, ']', " = ", 8.12);
342     CU_TEST(nchars == Asc_Printf("%s%d%c%s%f", "my_float[", 7, ']', " = ", 8.12)); /* print something */
343     CU_TEST(TRUE == test_print1_called);
344     CU_TEST(0 == strcmp(test_print1_str, str));
345     CU_TEST(stdout == test_print1_fp);
346     CU_TEST(TRUE == test_print2_called);
347     CU_TEST(0 == strcmp(test_print2_str, str));
348     CU_TEST(stdout == test_print2_fp);
349    
350     CU_TEST(&f_test_ascPrint_vtable2 == Asc_PrintRemoveVTable("test_vtable2")); /* cleanup */
351     CU_TEST(&f_test_ascPrint_vtable1 == Asc_PrintRemoveVTable("test_vtable1"));
352     f_test_ascPrint_vtable1.next = NULL;
353     f_test_ascPrint_vtable2.next = NULL;
354    
355     /* test Asc_FPrintf() */
356    
357     test_print1_called = FALSE;
358     test_print1_str[0] = '\0';
359     test_print1_fp = NULL;
360     test_print2_called = FALSE;
361     test_print2_str[0] = '\0';
362     test_print2_fp = NULL;
363    
364     nchars = snprintf(str, STR_LEN, "%s%d%c%s%f", "my_float[", 7, ']', " = ", 8.12);
365     CU_TEST(0 == Asc_FPrintf((FILE *)10, "%s%d%c%s%f", "my_float[", 7, ']', " = ", 8.12)); /* no vtables registered */
366     CU_TEST(FALSE == test_print1_called);
367     CU_TEST('\0' == test_print1_str[0]);
368     CU_TEST(NULL == test_print1_fp);
369     CU_TEST(FALSE == test_print2_called);
370     CU_TEST('\0' == test_print2_str[0]);
371     CU_TEST(NULL == test_print2_fp);
372    
373     CU_TEST(0 == Asc_PrintPushVTable(&f_test_ascPrint_vtable1)); /* push vtables */
374     CU_TEST(0 == Asc_PrintPushVTable(&f_test_ascPrint_vtable2));
375    
376     test_print1_called = FALSE;
377     test_print1_str[0] = '\0';
378     test_print1_fp = NULL;
379     test_print2_called = FALSE;
380     test_print2_str[0] = '\0';
381     test_print2_fp = NULL;
382    
383     memset(str, '?', STR_LEN-1);
384     str[STR_LEN-1] = '\0';
385     CU_TEST(STR_LEN-1 == Asc_FPrintf(stderr, "%s", str));/* print something */
386     CU_TEST(TRUE == test_print1_called);
387     CU_TEST(0 == strcmp(test_print1_str, str));
388     CU_TEST(stderr == test_print1_fp);
389     CU_TEST(TRUE == test_print2_called);
390     CU_TEST(0 == strcmp(test_print2_str, str));
391     CU_TEST(stderr == test_print2_fp);
392    
393     test_print1_called = FALSE;
394     test_print1_str[0] = '\0';
395     test_print1_fp = NULL;
396     test_print2_called = FALSE;
397     test_print2_str[0] = '\0';
398     test_print2_fp = NULL;
399    
400     nchars = snprintf(str, STR_LEN, "%s%d%c%s%f", "my_float[", 7, ']', " = ", 8.12);
401     CU_TEST(nchars == Asc_FPrintf((FILE *)10, "%s%d%c%s%f", "my_float[", 7, ']', " = ", 8.12)); /* print something */
402     CU_TEST(TRUE == test_print1_called);
403     CU_TEST(0 == strcmp(test_print1_str, str));
404     CU_TEST((FILE *)10 == test_print1_fp);
405     CU_TEST(TRUE == test_print2_called);
406     CU_TEST(0 == strcmp(test_print2_str, str));
407     CU_TEST((FILE *)10 == test_print2_fp);
408    
409     CU_TEST(&f_test_ascPrint_vtable2 == Asc_PrintRemoveVTable("test_vtable2")); /* cleanup */
410     CU_TEST(&f_test_ascPrint_vtable1 == Asc_PrintRemoveVTable("test_vtable1"));
411     f_test_ascPrint_vtable1.next = NULL;
412     f_test_ascPrint_vtable2.next = NULL;
413    
414     /* test Asc_FFlush() */
415    
416     test_flush1_called = FALSE;
417     test_flush1_fp = NULL;
418     test_flush2_called = FALSE;
419     test_flush2_fp = NULL;
420    
421     CU_TEST(0 == Asc_FFlush(stderr)); /* no vtables registered */
422     CU_TEST(FALSE == test_flush1_called);
423     CU_TEST(NULL == test_flush1_fp);
424     CU_TEST(FALSE == test_flush2_called);
425     CU_TEST(NULL == test_flush2_fp);
426    
427     CU_TEST(0 == Asc_PrintPushVTable(&f_test_ascPrint_vtable1)); /* push vtables */
428     CU_TEST(0 == Asc_PrintPushVTable(&f_test_ascPrint_vtable2));
429    
430     test_flush1_called = FALSE;
431     test_flush1_fp = NULL;
432     test_flush2_called = FALSE;
433     test_flush2_fp = NULL;
434    
435     CU_TEST(0 == Asc_FFlush((FILE *)100)); /* flush a (FILE *) */
436     CU_TEST(TRUE == test_flush1_called);
437     CU_TEST((FILE *)100 == test_flush1_fp);
438     CU_TEST(TRUE == test_flush2_called);
439     CU_TEST((FILE *)100 == test_flush2_fp);
440    
441     CU_TEST(&f_test_ascPrint_vtable2 == Asc_PrintRemoveVTable("test_vtable2")); /* cleanup */
442     CU_TEST(&f_test_ascPrint_vtable1 == Asc_PrintRemoveVTable("test_vtable1"));
443     f_test_ascPrint_vtable1.next = NULL;
444     f_test_ascPrint_vtable2.next = NULL;
445    
446     /* test Asc_FPutc() */
447    
448     test_print1_called = FALSE;
449     test_print1_str[0] = '\0';
450     test_print1_fp = NULL;
451     test_print2_called = FALSE;
452     test_print2_str[0] = '\0';
453     test_print2_fp = NULL;
454    
455     CU_TEST(0 == Asc_FPutc('Y', stdout)); /* no vtables registered */
456     CU_TEST(FALSE == test_print1_called);
457     CU_TEST('\0' == test_print1_str[0]);
458     CU_TEST(NULL == test_print1_fp);
459     CU_TEST(FALSE == test_print2_called);
460     CU_TEST('\0' == test_print2_str[0]);
461     CU_TEST(NULL == test_print2_fp);
462    
463     CU_TEST(0 == Asc_PrintPushVTable(&f_test_ascPrint_vtable1)); /* push vtables */
464     CU_TEST(0 == Asc_PrintPushVTable(&f_test_ascPrint_vtable2));
465    
466     test_print1_called = FALSE;
467     test_print1_str[0] = '\0';
468     test_print1_fp = NULL;
469     test_print2_called = FALSE;
470     test_print2_str[0] = '\0';
471     test_print2_fp = NULL;
472    
473     CU_TEST(0 != Asc_FPutc('Y', stderr)); /* print a char */
474     CU_TEST(TRUE == test_print1_called);
475     CU_TEST(0 == strcmp("Y", test_print1_str));
476     CU_TEST(stderr == test_print1_fp);
477     CU_TEST(TRUE == test_print2_called);
478     CU_TEST(0 == strcmp("Y", test_print2_str));
479     CU_TEST(stderr == test_print2_fp);
480    
481     CU_TEST(&f_test_ascPrint_vtable2 == Asc_PrintRemoveVTable("test_vtable2")); /* cleanup */
482     CU_TEST(&f_test_ascPrint_vtable1 == Asc_PrintRemoveVTable("test_vtable1"));
483     f_test_ascPrint_vtable1.next = NULL;
484     f_test_ascPrint_vtable2.next = NULL;
485    
486     /* test Asc_FPutc() */
487    
488     test_print1_called = FALSE;
489     test_print1_str[0] = '\0';
490     test_print1_fp = NULL;
491     test_print2_called = FALSE;
492     test_print2_str[0] = '\0';
493     test_print2_fp = NULL;
494    
495     CU_TEST(0 == Asc_Putchar('N')); /* no vtables registered */
496     CU_TEST(FALSE == test_print1_called);
497     CU_TEST('\0' == test_print1_str[0]);
498     CU_TEST(NULL == test_print1_fp);
499     CU_TEST(FALSE == test_print2_called);
500     CU_TEST('\0' == test_print2_str[0]);
501     CU_TEST(NULL == test_print2_fp);
502    
503     CU_TEST(0 == Asc_PrintPushVTable(&f_test_ascPrint_vtable1)); /* push vtables */
504     CU_TEST(0 == Asc_PrintPushVTable(&f_test_ascPrint_vtable2));
505    
506     test_print1_called = FALSE;
507     test_print1_str[0] = '\0';
508     test_print1_fp = NULL;
509     test_print2_called = FALSE;
510     test_print2_str[0] = '\0';
511     test_print2_fp = NULL;
512    
513     CU_TEST(1 == Asc_Putchar('N')); /* print a char */
514     CU_TEST(TRUE == test_print1_called);
515     CU_TEST(0 == strcmp("N", test_print1_str));
516     CU_TEST(stdout == test_print1_fp);
517     CU_TEST(TRUE == test_print2_called);
518     CU_TEST(0 == strcmp("N", test_print2_str));
519     CU_TEST(stdout == test_print2_fp);
520    
521     CU_TEST(&f_test_ascPrint_vtable2 == Asc_PrintRemoveVTable("test_vtable2")); /* cleanup */
522     CU_TEST(&f_test_ascPrint_vtable1 == Asc_PrintRemoveVTable("test_vtable1"));
523     f_test_ascPrint_vtable1.next = NULL;
524     f_test_ascPrint_vtable2.next = NULL;
525    
526     if (TRUE == i_disabled_printing) { /* restore global vtable if necessary */
527     test_enable_printing();
528     }
529    
530     CU_TEST(prior_meminuse == ascmeminuse()); /* make sure we cleaned up after ourselves */
531     }
532    
533     /*===========================================================================*/
534     /* Registration information */
535    
536     static CU_TestInfo ascPrint_test_list[] = {
537     {"test_ascPrint", test_ascPrint},
538     CU_TEST_INFO_NULL
539     };
540    
541     static CU_SuiteInfo suites[] = {
542     {"test_utilities_ascPrint", NULL, NULL, ascPrint_test_list},
543     CU_SUITE_INFO_NULL
544     };
545    
546     /*-------------------------------------------------------------------*/
547     CU_ErrorCode test_register_utilities_ascPrint(void)
548     {
549     return CU_register_suites(suites);
550     }
john.pye@anu.edu.au
 ViewVC Help
Powered by ViewVC 1.1.22