← Back to branch summary

~drgeo-developers/drgeo/trunk

« back to all changes in this revision

Viewing changes to VMs/iPad/source/iOS/plugins/SqueakObjectiveC/squeakSUnitTester.m

  • Committer: Hilaire Fernandes
  • Date: 2012-01-27 21:15:40 UTC
  • Revision ID: hilaire.fernandes@gmail.com-20120127211540-912spf97bhpx6mve
Initial additions

Show diffs side-by-side

added added

removed removed

Lines of Context:
VMs/iPad/source/iOS/plugins/SqueakObjectiveC/squeakSUnitTester.m
 
1
//
 
2
//  squeakSUnitTester.m
 
3
//  SqueakObjectiveC
 
4
//
 
5
//  Created by John M McIntosh on 9/25/08.
 
6
/* Some of this code was funded via a grant from the European Smalltalk User Group (ESUG)
 
7
 Copyright (c) 2008 Corporate Smalltalk Consulting Ltd. All rights reserved.
 
8
 MIT License
 
9
 Permission is hereby granted, free of charge, to any person
 
10
 obtaining a copy of this software and associated documentation
 
11
 files (the "Software"), to deal in the Software without
 
12
 restriction, including without limitation the rights to use,
 
13
 copy, modify, merge, publish, distribute, sublicense, and/or sell
 
14
 copies of the Software, and to permit persons to whom the
 
15
 Software is furnished to do so, subject to the following
 
16
 conditions:
 
17
 
 
18
 The above copyright notice and this permission notice shall be
 
19
 included in all copies or substantial portions of the Software.
 
20
 
 
21
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 
22
 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
 
23
 OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 
24
 NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
 
25
 HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
 
26
 WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 
27
 FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 
28
 OTHER DEALINGS IN THE SOFTWARE.
 
29
 
 
30
 The end-user documentation included with the redistribution, if any, must include the following acknowledgment: 
 
31
 "This product includes software developed by Corporate Smalltalk Consulting Ltd (http://www.smalltalkconsulting.com) 
 
32
 and its contributors", in the same place and form as other third-party acknowledgments. 
 
33
 Alternately, this acknowledgment may appear in the software itself, in the same form and location as other 
 
34
 such third-party acknowledgments.
 
35
 */
 
36
//
 
37
 
 
38
#import "squeakSUnitTester.h"
 
39
 
 
40
 
 
41
@implementation squeakSUnitTester
 
42
- (char) test0char {
 
43
        return 'A';
 
44
}
 
45
- (int) test0int {
 
46
        return -1;
 
47
}
 
48
- (short) test0short {
 
49
        return 0xFFFF;
 
50
}
 
51
- (long) test0long {
 
52
        return 0xFFFFFFFF;
 
53
}
 
54
- (long long) test0longlong {
 
55
        return 0xFFFFFFFFFFFFFFFFLL;
 
56
}
 
57
- (unsigned char) test0unsignedchar{
 
58
        return 'A';
 
59
}
 
60
- (unsigned int) test0unsignedint{
 
61
        return 0xFFFFFFFF;
 
62
}
 
63
- (unsigned short) test0unsignedshort {
 
64
        return 0xFFFF;
 
65
}
 
66
- (unsigned long) test0unsignedlong{
 
67
        return 0xFFFFFFFF;
 
68
}
 
69
- (unsigned long long) test0unsignedlonglong {
 
70
        return 0xFFFFFFFFFFFFFFFFLL;
 
71
}
 
72
- (float) test0float {
 
73
        return 8.8f;
 
74
}
 
75
- (double) test0double {
 
76
        return 8.8;
 
77
}
 
78
- (void) test0void {
 
79
}
 
80
- (char *) test0charpointer {
 
81
        static char* squeak = "squeak";
 
82
        return squeak;
 
83
}
 
84
- (squeakSUnitTester *) test0object {
 
85
        return [squeakSUnitTester new];
 
86
}
 
87
- (Class) test0class {
 
88
        return [squeakSUnitTester class];
 
89
}
 
90
- (SEL) test0methodselector {
 
91
        SEL selector;
 
92
        selector = NSSelectorFromString(
 
93
                                                                        @"initWithBitmapDataPlanes:pixelsWide:pixelsHigh:bitsPerSample:samplesPerPixel:hasAlpha:isPlanar:colorSpaceName:bytesPerRow:bitsPerPixel:");
 
94
        return selector;
 
95
}
 
96
- (CGRect) test0CGRect {
 
97
CGRect foo;
 
98
        foo.origin.x = 1.0;
 
99
foo.origin.y = 2.0;
 
100
foo.size.width = 3.0;
 
101
foo.size.height = 4.0;
 
102
return foo;
 
103
        }
 
104
        
 
105
        - (char) test0char: (char *)ignore {
 
106
return 'A';
 
107
                }
 
108
                - (int) test0int: (char *)ignore {
 
109
return -1;
 
110
}
 
111
- (short) test0short: (char *)ignore {
 
112
                        return 0xFFFF;
 
113
}
 
114
- (long) test0long: (char *)ignore {
 
115
return 0xFFFFFFFF;
 
116
                                }
 
117
                                - (long long) test0longlong: (char *)ignore {
 
118
          return 0xFFFFFFFFFFFFFFFFLL;
 
119
}
 
120
- (unsigned char) test0unsignedchar: (char *)ignore{
 
121
                  return 'A';
 
122
                  }
 
123
          - (unsigned int) test0unsignedint: (char *)ignore{
 
124
return 0xFFFFFFFF;
 
125
                  }
 
126
                  - (unsigned short) test0unsignedshort: (char *)ignore {
 
127
return 0xFFFF;
 
128
                          }
 
129
                          - (unsigned long) test0unsignedlong: (char *)ignore{
 
130
return 0xFFFFFFFF;
 
131
                                  }
 
132
                                  - (unsigned long long) test0unsignedlonglong: (char *)ignore {
 
133
return 0xFFFFFFFFFFFFFFFFLL;
 
134
}
 
135
- (float) test0float: (char *)ignore {
 
136
return 8.8f;
 
137
        }
 
138
        - (double) test0double: (char *)ignore {
 
139
        return 8.8;
 
140
}
 
141
- (void) test0void: (char *)ignore {
 
142
}
 
143
- (char *) test0charpointer: (char *)ignore {
 
144
static char* squeak = "squeak";
 
145
return squeak;
 
146
        }
 
147
        - (squeakSUnitTester *) test0object: (char *)ignore {
 
148
return [squeakSUnitTester new];
 
149
                }
 
150
                - (Class) test0class: (char *)ignore {
 
151
                return [squeakSUnitTester class];
 
152
                }
 
153
                - (SEL) test0methodselector: (char *)ignore {
 
154
                SEL selector;
 
155
                selector = NSSelectorFromString(
 
156
                @"initWithBitmapDataPlanes:pixelsWide:pixelsHigh:bitsPerSample:samplesPerPixel:hasAlpha:isPlanar:colorSpaceName:bytesPerRow:bitsPerPixel:");
 
157
return selector;
 
158
                        }
 
159
                        - (CGRect) test0CGRect: (char *)ignore {
 
160
                 CGRect foo;
 
161
                 foo.origin.x = 1.0;
 
162
                                foo.origin.y = 2.0;
 
163
foo.size.width = 3.0;
 
164
foo.size.height = 4.0;
 
165
                                        return foo;
 
166
                                        }
 
167
                                        
 
168
                                        - (char) test0char: (char *)ignore two: (char *) ignore2 {
 
169
return 'A';
 
170
}
 
171
- (int) test0int: (char *)ignore two: (char *) ignore2 {
 
172
return -1;
 
173
}
 
174
- (short) test0short: (char *)ignore  two: (char *) ignore2{
 
175
return 0xFFFF;
 
176
}
 
177
- (long) test0long: (char *)ignore  two: (char *) ignore2{
 
178
        return 0xFFFFFFFF;
 
179
}
 
180
- (long long) test0longlong: (char *)ignore  two: (char *) ignore2{
 
181
                return 0xFFFFFFFFFFFFFFFFLL;
 
182
}
 
183
- (unsigned char) test0unsignedchar: (char *)ignore two: (char *) ignore2{
 
184
                        return 'A';
 
185
}
 
186
- (unsigned int) test0unsignedint: (char *)ignore two: (char *) ignore2{
 
187
return 0xFFFFFFFF;
 
188
                                }
 
189
                                - (unsigned short) test0unsignedshort: (char *)ignore  two: (char *) ignore2{
 
190
                                        return 0xFFFF;
 
191
}
 
192
- (unsigned long) test0unsignedlong: (char *)ignore two: (char *) ignore2{
 
193
return 0xFFFFFFFF;
 
194
}
 
195
- (unsigned long long) test0unsignedlonglong: (char *)ignore  two: (char *) ignore2{
 
196
return 0xFFFFFFFFFFFFFFFFLL;
 
197
        }
 
198
        - (float) test0float: (char *)ignore  two: (char *) ignore2{
 
199
return 8.8f;
 
200
}
 
201
- (double) test0double: (char *)ignore  two: (char *) ignore2{
 
202
                return 8.8;
 
203
}
 
204
- (void) test0void: (char *)ignore  two: (char *) ignore2{
 
205
                        }
 
206
                        - (char *) test0charpointer: (char *)ignore  two: (char *) ignore2{
 
207
static char* squeak = "squeak";
 
208
                                return squeak;
 
209
                                }
 
210
                                - (squeakSUnitTester *) test0object: (char *)ignore two: (char *) ignore2 {
 
211
                                return [squeakSUnitTester new];
 
212
                                }
 
213
                                - (Class) test0class: (char *)ignore two: (char *) ignore2 {
 
214
                                return [squeakSUnitTester class];
 
215
}
 
216
- (SEL) test0methodselector: (char *)ignore  two: (char *) ignore2 {
 
217
                                        SEL selector;
 
218
selector = NSSelectorFromString(
 
219
 @"initWithBitmapDataPlanes:pixelsWide:pixelsHigh:bitsPerSample:samplesPerPixel:hasAlpha:isPlanar:colorSpaceName:bytesPerRow:bitsPerPixel:");
 
220
return selector;
 
221
         }
 
222
         - (CGRect) test0CGRect: (char *)ignore  two: (char *) ignore2 {
 
223
CGRect foo;
 
224
foo.origin.x = 1.0;
 
225
                 foo.origin.y = 2.0;
 
226
foo.size.width = 3.0;
 
227
foo.size.height = 4.0;
 
228
return foo;
 
229
}
 
230
 
 
231
- (char) test0char: (char *)ignore two: (char *) ignore2 three: (char *) ignore3 {
 
232
return 'A';
 
233
}
 
234
- (int) test0int: (char *)ignore two: (char *) ignore2  three: (char *) ignore3 {
 
235
return -1;
 
236
}
 
237
- (short) test0short: (char *)ignore  two: (char *) ignore2 three: (char *) ignore3 {
 
238
        return 0xFFFF;
 
239
}
 
240
- (long) test0long: (char *)ignore  two: (char *) ignore2 three: (char *) ignore3 {
 
241
return 0xFFFFFFFF;
 
242
                }
 
243
                - (long long) test0longlong: (char *)ignore  two: (char *) ignore2 three: (char *) ignore3 {
 
244
return 0xFFFFFFFFFFFFFFFFLL;
 
245
                        }
 
246
                        - (unsigned char) test0unsignedchar: (char *)ignore two: (char *) ignore2 three: (char *) ignore3 {
 
247
return 'A';
 
248
}
 
249
- (unsigned int) test0unsignedint: (char *)ignore two: (char *) ignore2 three: (char *) ignore3 {
 
250
return 0xFFFFFFFF;
 
251
}
 
252
        - (unsigned short) test0unsignedshort: (char *)ignore  two: (char *) ignore2 three: (char *) ignore3 {
 
253
                return 0xFFFF;
 
254
}
 
255
- (unsigned long) test0unsignedlong: (char *)ignore two: (char *) ignore2 three: (char *) ignore3 {
 
256
return 0xFFFFFFFF;
 
257
}
 
258
- (unsigned long long) test0unsignedlonglong: (char *)ignore  two: (char *) ignore2 three: (char *) ignore3 {
 
259
return 0xFFFFFFFFFFFFFFFFLL;
 
260
}
 
261
- (float) test0float: (char *)ignore  two: (char *) ignore2 three: (char *) ignore3 {
 
262
        return 8.8f;
 
263
}
 
264
- (double) test0double: (char *)ignore  two: (char *) ignore2 three: (char *) ignore3 {
 
265
                return 8.8;
 
266
                }
 
267
                - (void) test0void: (char *)ignore  two: (char *) ignore2 three: (char *) ignore3 {
 
268
}
 
269
- (char *) test0charpointer: (char *)ignore  two: (char *) ignore2 three: (char *) ignore3 {
 
270
                        static char* squeak = "squeak";
 
271
                        return squeak;
 
272
                        }
 
273
                        - (squeakSUnitTester *) test0object: (char *)ignore two: (char *) ignore2  three: (char *) ignore3 {
 
274
return [squeakSUnitTester new];
 
275
                                }
 
276
                                - (Class) test0class: (char *)ignore two: (char *) ignore2  three: (char *) ignore3 {
 
277
return [squeakSUnitTester class];
 
278
}
 
279
- (SEL) test0methodselector: (char *)ignore  two: (char *) ignore2  three: (char *) ignore3 {
 
280
SEL selector;
 
281
        selector = NSSelectorFromString(
 
282
@"initWithBitmapDataPlanes:pixelsWide:pixelsHigh:bitsPerSample:samplesPerPixel:hasAlpha:isPlanar:colorSpaceName:bytesPerRow:bitsPerPixel:");
 
283
return selector;
 
284
}
 
285
- (CGRect) test0CGRect: (char *)ignore  two: (char *) ignore2  three: (char *) ignore3  {
 
286
CGRect foo;
 
287
foo.origin.x = 1.0;
 
288
        foo.origin.y = 2.0;
 
289
foo.size.width = 3.0;
 
290
foo.size.height = 4.0;
 
291
return foo;
 
292
}
 
293
 
 
294
- (char) test1char: (char) ignore {
 
295
return ignore;
 
296
}
 
297
- (int) test1int: (int) ignore {
 
298
return ignore;
 
299
}
 
300
- (short) test1short: (short) ignore {
 
301
return ignore;
 
302
}
 
303
- (long) test1long: (long) ignore {
 
304
        return ignore;
 
305
}
 
306
- (long long) test1longlong: (long long) ignore {
 
307
return ignore;
 
308
                }
 
309
                - (unsigned char) test1unsignedchar: (unsigned char) ignore {
 
310
                        return ignore;
 
311
}
 
312
- (unsigned int) test1unsignedint: (unsigned int) ignore {
 
313
return ignore;
 
314
}
 
315
- (unsigned short) test1unsignedshort: (unsigned short) ignore {
 
316
        return ignore;
 
317
}
 
318
- (unsigned long) test1unsignedlong: (unsigned long) ignore {
 
319
return ignore;
 
320
                }
 
321
                - (unsigned long long) test1unsignedlonglong: (unsigned long long) ignore {
 
322
return ignore;
 
323
                        }
 
324
                        - (float) test1float: (float) ignore {
 
325
return ignore;
 
326
}
 
327
- (double) test1double: (double) ignore {
 
328
                                return ignore;
 
329
                                }
 
330
                        - (char *) test1charpointer: (char *) ignore {
 
331
return ignore;
 
332
}
 
333
- (squeakSUnitTester *) test1object: (squeakSUnitTester *) ignore {
 
334
return ignore;
 
335
}
 
336
- (Class) test1class: (Class) ignore {
 
337
return ignore;
 
338
}
 
339
- (SEL) test1methodselector: (SEL) ignore {
 
340
return ignore;
 
341
}
 
342
- (CGRect) test1CGRect: (CGRect) ignore {
 
343
return ignore;
 
344
}
 
345
 
 
346
- (char) test2char: (squeakSUnitTester *)ignore two: (squeakSUnitTester *) ignore2 {
 
347
return 'A';
 
348
}
 
349
- (int) test2int: (squeakSUnitTester *)ignore two: (squeakSUnitTester *) ignore2 {
 
350
return -1;
 
351
}
 
352
- (short) test2short: (squeakSUnitTester *)ignore  two: (squeakSUnitTester *) ignore2{
 
353
return 0xFFFF;
 
354
}
 
355
- (long) test2long: (squeakSUnitTester *)ignore  two: (squeakSUnitTester *) ignore2{
 
356
return 0xFFFFFFFF;
 
357
        }
 
358
        - (long long) test2longlong: (squeakSUnitTester *)ignore  two: (squeakSUnitTester *) ignore2{
 
359
return 0xFFFFFFFFFFFFFFFFLL;
 
360
}
 
361
- (unsigned char) test2unsignedchar: (squeakSUnitTester *)ignore two: (squeakSUnitTester *) ignore2{
 
362
return 'A';
 
363
}
 
364
- (unsigned int) test2unsignedint: (squeakSUnitTester *)ignore two: (squeakSUnitTester *) ignore2{
 
365
return 0xFFFFFFFF;
 
366
}
 
367
- (unsigned short) test2unsignedshort: (squeakSUnitTester *)ignore  two: (squeakSUnitTester *) ignore2{
 
368
return 0xFFFF;
 
369
}
 
370
- (unsigned long) test2unsignedlong: (squeakSUnitTester *)ignore two: (squeakSUnitTester *) ignore2{
 
371
        return 0xFFFFFFFF;
 
372
}
 
373
- (unsigned long long) test2unsignedlonglong: (squeakSUnitTester *)ignore  two: (squeakSUnitTester *) ignore2{
 
374
return 0xFFFFFFFFFFFFFFFFLL;
 
375
}
 
376
- (float) test2float: (squeakSUnitTester *)ignore  two: (squeakSUnitTester *) ignore2{
 
377
        return 8.8f;
 
378
        }
 
379
        - (double) test2double: (squeakSUnitTester *)ignore  two: (squeakSUnitTester *) ignore2{
 
380
        return 8.8;
 
381
        }
 
382
        - (void) test2void: (squeakSUnitTester *)ignore  two: (squeakSUnitTester *) ignore2{
 
383
}
 
384
- (char *) test2charpointer: (squeakSUnitTester *)ignore  two: (squeakSUnitTester *) ignore2{
 
385
static char* squeak = "squeak";
 
386
return squeak;
 
387
}
 
388
- (squeakSUnitTester *) test2object: (squeakSUnitTester *)ignore two: (squeakSUnitTester *) ignore2 {
 
389
return [squeakSUnitTester new];
 
390
}
 
391
- (Class) test2class: (squeakSUnitTester *)ignore two: (squeakSUnitTester *) ignore2 {
 
392
return [squeakSUnitTester class];
 
393
        }
 
394
        - (SEL) test2methodselector: (squeakSUnitTester *)ignore  two: (squeakSUnitTester *) ignore2 {
 
395
SEL selector;
 
396
selector = NSSelectorFromString(
 
397
                @"initWithBitmapDataPlanes:pixelsWide:pixelsHigh:bitsPerSample:samplesPerPixel:hasAlpha:isPlanar:colorSpaceName:bytesPerRow:bitsPerPixel:");
 
398
return selector;
 
399
}
 
400
- (CGRect) test2CGRect: (squeakSUnitTester *) ignore two: (squeakSUnitTester *) ignore2 {
 
401
CGRect foo;
 
402
        foo.origin.x = 1.0;
 
403
foo.origin.y = 2.0;
 
404
foo.size.width = 3.0;
 
405
foo.size.height = 4.0;
 
406
return foo;
 
407
}
 
408
 
 
409
- (oneway void) testQualifier0v {
 
410
                }
 
411
- (oneway void) testQualifier1v: (squeakSUnitTester *)ignore {
 
412
}
 
413
- (oneway void) testQualifier2v: (squeakSUnitTester *)ignore two:  (squeakSUnitTester *)ignore2;{
 
414
        }
 
415
        - (oneway void) testQualifier3v: (squeakSUnitTester *)ignore two:  (squeakSUnitTester *)ignore2  three: (squeakSUnitTester *)ignore3 {
 
416
}
 
417
- (squeakSUnitTester *) testQualifier1io: (inout squeakSUnitTester *)ignore {
 
418
                return ignore;
 
419
}
 
420
- (squeakSUnitTester *) testQualifier2io: (inout squeakSUnitTester *)ignore two:  (inout squeakSUnitTester *)ignore2  {
 
421
return ignore2;
 
422
}
 
423
- (squeakSUnitTester *) testQualifier3io: (inout squeakSUnitTester *)ignore two:  (inout squeakSUnitTester *)ignore2  three: (inout squeakSUnitTester *)ignore3
 
424
{
 
425
return ignore3;
 
426
}
 
427
- (squeakSUnitTester *) testQualifier1i: (in squeakSUnitTester *)ignore {
 
428
return ignore;
 
429
        }
 
430
        - (squeakSUnitTester *) testQualifier2i: (in squeakSUnitTester *)ignore two:  (in squeakSUnitTester *)ignore2  {
 
431
return ignore2;
 
432
}
 
433
- (squeakSUnitTester *) testQualifier3i: (in squeakSUnitTester *)ignore two:  (in squeakSUnitTester *)ignore2  three: (in squeakSUnitTester *)ignore3
 
434
{
 
435
return ignore3;
 
436
}
 
437
- (squeakSUnitTester *) testQualifier1o: (out squeakSUnitTester *)ignore {
 
438
return ignore;
 
439
}
 
440
- (squeakSUnitTester *) testQualifier2o: (out squeakSUnitTester *)ignore two:  (out squeakSUnitTester *)ignore2  {
 
441
return ignore2;
 
442
}
 
443
- (squeakSUnitTester *) testQualifier3o: (out squeakSUnitTester *)ignore two:  (out squeakSUnitTester *)ignore2  three: (out squeakSUnitTester *)ignore3
 
444
{
 
445
return ignore3;
 
446
}
 
447
- (squeakSUnitTester *) testQualifier1r: (inout byref  squeakSUnitTester *)ignore {
 
448
return ignore;
 
449
}
 
450
- (squeakSUnitTester *) testQualifier2r: (inout byref  squeakSUnitTester *)ignore two:  (inout byref  squeakSUnitTester *)ignore2  {
 
451
return ignore2;
 
452
}
 
453
- (squeakSUnitTester *) testQualifier3r: (inout byref  squeakSUnitTester *)ignore two:  (inout byref  squeakSUnitTester *)ignore2  three: (inout byref  squeakSUnitTester *)ignore3
 
454
{
 
455
return ignore3;
 
456
}
 
457
 
 
458
 
 
459
@end