![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to rettest.m CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple Darwin 0.x] / objc / Test / msgTest|
Return to rettest.m CVS log | Up to [Apple Darwin 0.x] / objc / Test / msgTest |
1.1 root 1: /*
2: * Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * "Portions Copyright (c) 1999 Apple Computer, Inc. All Rights
7: * Reserved. This file contains Original Code and/or Modifications of
8: * Original Code as defined in and that are subject to the Apple Public
9: * Source License Version 1.0 (the 'License'). You may not use this file
10: * except in compliance with the License. Please obtain a copy of the
11: * License at http://www.apple.com/publicsource and read it before using
12: * this file.
13: *
14: * The Original Code and all software distributed under the License are
15: * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
16: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
17: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
18: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
19: * License for the specific language governing rights and limitations
20: * under the License."
21: *
22: * @APPLE_LICENSE_HEADER_END@
23: */
24: // Test all possible Objective-C method return types
25: // This test exercises both _msg and _msgSuper to make sure that
26: // all possible return types and handled correctly. There are
27: // two classes used: MsgTest and SuperTest.
28: //
29: // Class MsgTest defines one method for each possible return type.
30: // Each method takes a single argument which is a pointer to a
31: // location to put a copy of the return value. Each method stores
32: // its return value in that location, then returns it. The caller
33: // verifies that the return value and the stored copy match.
34: //
35: // Class SuperTest does the same, and simply passes the message and
36: // argument on to the superclass via a message to "super".
37: //
38: // Usage:
39: // rettest [ msgFlag ]
40: //
41: // If invoked with an argument, the message trace flag is enabled.
42: //
43: // Diagnostics:
44: // ERROR: return value mismatch while testing '%s' in class %s
45: //
46: // A return value does not match what was expected.
47: //
48: // The first '%s' says which type is currently under test; the second
49: // names either "MsgTest" or "SuperTest" to indicate which message
50: // routine may be faulty. Note that because SuperTest simply passes
51: // the message on, if there is a problem in the _msg function, it will
52: // show up on both tests.
53: //
54: // This diagnostic will also be accompanied by "%V:%V", where "%V"
55: // indicates some representation of a value. The first is the value
56: // actually returned; the second is what was expected.
57: //
58: // Also printed is the filename and line number containing the test
59: // which failed.
60: //
61: // For example, if a method returning a double didn't match the expected
62: // value, you would see an error like:
63: //
64: // return value mismatch while testing 'double' in class MsgTest
65: // line 179 in file "rettest.m":
66: // 3.1416:2.9999935e+231
67: //
68: // ERROR: unexpected exit while processing test '%s' using %s.
69: //
70: // An unexpected exit was called during testing, most likely indicating
71: // a program fault. If so, the fault will also be diagnosed with a stack
72: // backtrace.
73: //
74: // As before, the first '%s' is the type currently under test; the
75: // second is either "MsgTest" or "SuperTest".
76:
77:
78: #include <objc/objc.h>
79: #include "rettest.h"
80: #include <objc/objc-class.h>
81: #include <stdio.h>
82:
83: int currentLine = 0;
84: char *currentTest = "", *currentFile = "";
85: id currentReceiver = nil;
86: int nErrors = 0;
87:
88:
89: #import "ret1.h"
90: #import "ret2.h"
91:
92:
93: // exit handler
94: // This prints a diagnostic if an exit is called in the middle of processing,
95: // for example if a segmentation violation resulted from one of the test
96: // methods.
97: myCleanup(estat,arg)
98: int estat;
99: char* arg;
100: {
101: if (estat != 0) {
102: fprintf (stderr,
103: "ERROR: unexpected exit while processing test '%s' using %s\n\t",
104: currentTest, [currentReceiver str]);
105: fprintf (stderr, "line %d in file \"%s\"\n", currentLine, currentFile);
106: }
107: }
108:
109: //extern id (*_objc_msgPreop)();
110: //extern void _objc_msgCollectStats();
111: //extern void _objc_msgPrintStats();
112:
113: main(argc, argv)
114: int argc;
115: char **argv;
116: {
117: id foo = 0;
118:
119: if (argc > 1)
120: {
121: // _objc_msgPreop = _objc_msgCollectStats;
122: }
123:
124: currentReceiver = [MsgTest new];
125:
126: doTests(currentReceiver);
127: // print hit/miss info.
128: // if (_objc_msgPreop)
129: // _objc_msgPrintStats();
130:
131: doTests(currentReceiver);
132: // print hit/miss info.
133: // if (_objc_msgPreop)
134: // _objc_msgPrintStats();
135:
136: if (nErrors == 0)
137: fprintf (stderr, "All return tests to `MsgTest' succeeded\n");
138: else
139: fprintf (stderr, "%d errors noted\n", nErrors);
140:
141: [foo bar];
142: #if 1
143: currentReceiver = [SuperTest new];
144: doTests(currentReceiver);
145:
146: // print hit/miss info.
147: // if (_objc_msgPreop)
148: // _objc_msgPrintStats();
149:
150: if (nErrors == 0)
151: fprintf (stderr, "All return tests to `SuperTest' succeeded\n");
152: else
153: fprintf (stderr, "%d errors noted\n", nErrors);
154:
155: #endif
156: exit (0); // OK exit
157: }
158:
159: // Function to call all the test methods for the argument
160: // instance.
161: doTests(retInstance)
162: id retInstance;
163: {
164: // scalars
165: RETDECL(char);
166: RETDECL(uchar_t);
167: RETDECL(short);
168: RETDECL(ushort_t);
169: RETDECL(int);
170: RETDECL(unsigned);
171: RETDECL(long);
172: RETDECL(ulong_t);
173: RETDECL(float);
174: RETDECL(double);
175: // pointers
176: RETDECL(id);
177: RETDECL(STR);
178: // structures
179: RETDECL(S_BITS_16_t);
180: RETDECL(S_BITS_32_t);
181: RETDECL(S_BITS_64_t);
182: RETDECL(S_BITS_BIG_t);
183: // unions
184: RETDECL(U_BITS_16_t);
185: RETDECL(U_BITS_32_t);
186: RETDECL(U_BITS_64_t);
187: RETDECL(U_BITS_BIG_t);
188: // enums
189: RETDECL(E_BITS_8_t);
190: RETDECL(E_BITS_16_t);
191: #ifdef INT_32
192: RETDECL(E_BITS_32_t);
193: #endif
194:
195:
196: NEXTTEST("char");
197: if (RETTEST(retInstance,char)) {
198: RETERR("%d:%d",char_value, char_refValue);
199: }
200:
201: NEXTTEST("unsigned char");
202: if (RETTEST(retInstance,uchar_t)) {
203: RETERR("%u:%u",uchar_t_value, uchar_t_refValue);
204: }
205:
206: NEXTTEST("short");
207: if (RETTEST(retInstance,short)) {
208: RETERR("%d:%d",short_value, short_refValue);
209: }
210:
211: NEXTTEST("unsigned short");
212: if (RETTEST(retInstance,ushort_t)) {
213: RETERR("%u:%u",ushort_t_value, ushort_t_refValue);
214: }
215:
216: NEXTTEST("int");
217: if (RETTEST(retInstance,int)) {
218: RETERR("%d:%d",int_value, int_refValue);
219: }
220:
221: NEXTTEST("unsigned int");
222: if (RETTEST(retInstance,unsigned)) {
223: RETERR("%u:%u",unsigned_value, unsigned_refValue);
224: }
225:
226: NEXTTEST("long");
227: if (RETTEST(retInstance,long)) {
228: RETERR("%ld:%ld",long_value, long_refValue);
229: }
230:
231: NEXTTEST("unsigned long");
232: if (RETTEST(retInstance,ulong_t)) {
233: RETERR("%lu:%lu",ulong_t_value, ulong_t_refValue);
234: }
235:
236: NEXTTEST("float");
237: if (RETTEST(retInstance,float)) {
238: RETERR("%.8g:%.8g",float_value, float_refValue);
239: }
240:
241: NEXTTEST("double");
242: if (RETTEST(retInstance,double)) {
243: RETERR("%.17g:%.17g",double_value, double_refValue);
244: }
245:
246: // pointer types
247: NEXTTEST("id");
248: if (RETTEST(retInstance,id)) {
249: RETERR("%lx:%lx",id_value, id_refValue);
250: }
251:
252: NEXTTEST("char*");
253: if (RETTEST(retInstance,STR)) {
254: RETERR4("%lx=%s:%lx=%s",STR_value, STR_value,
255: STR_refValue, STR_refValue);
256: }
257:
258: // Now test the aggregate types
259: NEXTTEST("struct S_BITS_16");
260: if (SRETTEST(retInstance,S_BITS_16_t)) {
261: RETERR("*%lx:*%lx",&S_BITS_16_t_value, &S_BITS_16_t_refValue);
262: }
263:
264: NEXTTEST("struct S_BITS_32");
265: if (SRETTEST(retInstance,S_BITS_32_t)) {
266: RETERR("*%lx:*%lx",&S_BITS_32_t_value, &S_BITS_32_t_refValue);
267: }
268:
269: NEXTTEST("struct S_BITS_64");
270: if (SRETTEST(retInstance,S_BITS_64_t)) {
271: RETERR("*%lx:*%lx",&S_BITS_64_t_value, &S_BITS_64_t_refValue);
272: }
273:
274: NEXTTEST("struct S_BITS_BIG");
275: if (SRETTEST(retInstance,S_BITS_BIG_t)) {
276: RETERR("*%lx:*%lx",&S_BITS_BIG_t_value, &S_BITS_BIG_t_refValue);
277: }
278:
279: // unions
280: NEXTTEST("union U_BITS_16");
281: if (SRETTEST(retInstance,U_BITS_16_t)) {
282: RETERR("*%lx:*%lx",&U_BITS_16_t_value, &U_BITS_16_t_refValue);
283: }
284:
285: NEXTTEST("union U_BITS_32");
286: if (SRETTEST(retInstance,U_BITS_32_t)) {
287: RETERR("*%lx:*%lx",&U_BITS_32_t_value, &U_BITS_32_t_refValue);
288: }
289:
290: NEXTTEST("union U_BITS_64");
291: if (SRETTEST(retInstance,U_BITS_64_t)) {
292: RETERR("*%lx:*%lx",&U_BITS_64_t_value, &U_BITS_64_t_refValue);
293: }
294:
295: NEXTTEST("union U_BITS_BIG");
296: if (SRETTEST(retInstance,U_BITS_BIG_t)) {
297: RETERR("*%lx:*%lx",&U_BITS_BIG_t_value, &U_BITS_BIG_t_refValue);
298: }
299:
300: NEXTTEST("enum E_BITS_8");
301: if (RETTEST(retInstance,E_BITS_8_t)) {
302: RETERR("*%d:*%d",E_BITS_8_t_value, E_BITS_8_t_refValue);
303: }
304:
305: NEXTTEST("enum E_BITS_16");
306: if (RETTEST(retInstance,E_BITS_16_t)) {
307: RETERR("*%d:*%d",E_BITS_16_t_value, E_BITS_16_t_refValue);
308: }
309:
310: #if 0
311: #ifdef INT_32
312: NEXTTEST("enum E_BITS_32");
313: if (RETTEST(retInstance,E_BITS_32_t)) {
314: RETERR("*%d:*%d",E_BITS_32_t_value, E_BITS_32_t_refValue);
315: }
316: #endif
317: #endif
318:
319: }
320:
321: // function to handle errors coming from return value
322: // mismatches. Print a standard tag and the received
323: // and expected values.
324: #import <stdarg.h>
325:
326: retError(char *fmt, char *file, int line, ...)
327: {
328: va_list vp;
329:
330: nErrors += 1;
331: fprintf (stderr, "ERROR: return value mismatch while testing '%s' in class %s\n\t",
332: currentTest, [currentReceiver str]);
333: fprintf (stderr, "line %d in file \"%s\":\n\t", line, file);
334: va_start(vp, line);
335: vfprintf(stderr,fmt,vp);
336: va_end(vp);
337: fputc('\n',stderr);
338: }
339:
340: doArgCheck(class,method,self,_cmd)
341: Class class;
342: SEL method;
343: id self;
344: SEL _cmd;
345: {
346: if (self->isa != class && self->isa->super_class != class)
347: error("bad 'self' argument in '%s.%s': 0x%lx",
348: class->name, SELNAME(method), self);
349: if (method != _cmd)
350: error("bad '_cmd' argument in '%s.%s': 0x%lx",
351: class->name, method, SELNAME(_cmd));
352: }
353:
354: // General error discovered in some class
355: error(char *fmt, ...)
356: {
357: va_list vp;
358:
359: nErrors += 1;
360: fprintf (stderr, "ERROR: ");
361: va_start(vp, fmt);
362: vfprintf(stderr,fmt,vp);
363: va_end(vp);
364: fputc('\n',stderr);
365: }
366:
367: // Compare two arbitrary sized objects one byte at a time.
368: retCompare(a1,a2,size)
369: char *a1, *a2;
370: int size;
371: {
372: while (size-- > 0)
373: if (*a1++ != *a2++)
374: return 1;
375: return 0;
376: }
377:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.