1 /*
2 * test7.c
3 *
4 * DJ (c) 1996
5 *
6 * USUAL DISCLAIMER: THIS EXAMPLE IS PROVIDED AS IS
7 * WITH NO WARRANTY FOR ANY PURPOSE.
8 */
9
10 #if defined(__GNUC__)
11 #include <libc.h>
12
13 #define assert(_x_) _assert((_x_),__FILE__,__LINE__)
14 extern void _assert(int,const char*,int);
15 #else
16 #include <stdio.h>
17 #include <assert.h>
18 extern itoa(unsigned short value, char* s);
19 #endif
20
21 #if defined(__GNUC__) && defined(DEBUG)
22 extern void breakpoint(void);
23 extern void set_debug_traps(void);
24 #endif
25
26 /*---------------------------------------------------------------*/
test_arithmetic(void)27 void test_arithmetic(void)
28 /*---------------------------------------------------------------*/
29 {
30 #ifdef mc68000
31 /* lacking correct '___mulsi3'... functions */
32 puts("--- testing arithmetic: DISABLED\n");
33 #else
34 register int i,j;
35
36 puts("--- testing arithmetic\n");
37
38 i=0;
39 j=0;
40 assert(i+j==0);
41 assert(i-j==0);
42 assert(i*j==0);
43 assert(i/2==0);
44
45 i=1;
46 j=1;
47 assert(i+j==2);
48 assert(i-j==0);
49 assert(i*j==1);
50 assert(i/2==0);
51 assert(i%2==1);
52
53 i=2;
54 j=2;
55 assert(i+j==4);
56 assert(2*i-j==2);
57 assert(i*j==4);
58 assert(i/2==1);
59 assert(i%2==0);
60
61 i=179;
62 j=10;
63 assert(i*j==1790);
64 assert(i/j==17);
65 assert(i%j==9);
66
67 i=1;
68 j=-1;
69 assert(i+j==0);
70 assert(i-j==2);
71 assert(i*j==-1);
72 assert(j*j==1);
73
74 i=30000;
75 j=-5;
76 assert(i*j==-150000);
77 assert(i/j==-6000);
78 assert(i%j==0);
79
80 i=-179;
81 j=10;
82 assert(i*j==-1790);
83 assert(i/j==-17);
84 assert(i%j==-9);
85 #endif
86 }
87
88 /*---------------------------------------------------------------*/
test_itoa(void)89 void test_itoa(void)
90 /*---------------------------------------------------------------*/
91 {
92 char s[12];
93 /* register int i; */
94
95 puts("--- testing itoa\n");
96
97 itoa(0,s);
98 assert(s[0]=='0');
99 assert(s[1]==0);
100
101 itoa(1,s);
102 assert(s[0]=='1');
103 assert(s[1]==0);
104
105 itoa(10,s);
106 assert(s[0]=='1');
107 assert(s[1]=='0');
108 assert(s[2]==0);
109 }
110
111 /*---------------------------------------------------------------*/
test_array_i(char * out_a)112 void test_array_i(char *out_a)
113 /*---------------------------------------------------------------*/
114 {
115 out_a[0] = 0;
116 out_a[1] = 1;
117 out_a[2] = 2;
118 out_a[3] = 3;
119 }
120
121 /*---------------------------------------------------------------*/
test_array(void)122 void test_array(void)
123 /*---------------------------------------------------------------*/
124 {
125 static char ca1[12];
126 int ia1[12];
127 char *cptr;
128 int *iptr;
129 register int i;
130 char ca2[4];
131
132 puts("--- testing arrays\n");
133 for(i=0;i<12;i++)
134 {
135 ca1[i]=i;
136 }
137 cptr=(char*)ca1;
138 assert(*cptr++==0x0);
139 assert(*cptr++==0x1);
140 assert(*cptr++==0x2);
141 assert(*cptr++==0x3);
142 for(i=0;i<12;i++)
143 {
144 assert(ca1[i]==i);
145 }
146
147 assert(sizeof(ia1)==12*sizeof(int));
148 for(i=0;i<12;i++)
149 {
150 ia1[i]=0x1000000*i;
151 /*ia1[i]=0xcafe;*/
152 }
153 iptr=(int*)ia1;
154 assert(*iptr++==0);
155 assert(*iptr++==0x1000000);
156 assert(*iptr++==0x2000000);
157 for(i=0;i<12;i++)
158 {
159 assert(ia1[i]==0x1000000*i);
160 }
161
162 test_array_i(ca2);
163 assert(ca2[0]==0);
164 assert(ca2[1]==1);
165 assert(ca2[2]==2);
166 assert(ca2[3]==3);
167
168 }
169
170 /*---------------------------------------------------------------*/
test_switch(void)171 void test_switch(void)
172 /*---------------------------------------------------------------*/
173 {
174 int i;
175 char c;
176
177 puts("--- testing switch\n");
178
179 switch(1)
180 {
181 case 1: break;
182 default: assert(0); break;
183 }
184
185 for(i=0;i<100;i+=10)
186 {
187 switch(i)
188 {
189 case 0:
190 assert(i==0);
191 break;
192 case 10:
193 assert(i==10);
194 break;
195 case 20:
196 assert(i==20);
197 break;
198 case 30:
199 assert(i==30);
200 break;
201 case 40:
202 assert(i==40);
203 break;
204 case 50:
205 assert(i==50);
206 break;
207 case 60:
208 assert(i==60);
209 break;
210 case 70:
211 assert(i==70);
212 break;
213 case 80:
214 assert(i==80);
215 break;
216 case 90:
217 assert(i==90);
218 break;
219
220 default:
221 assert(0);
222 break;
223 }
224 } /* end of for */
225
226 for(c='a';c<='j';c++)
227 {
228 switch(c)
229 {
230 case 'a':
231 assert(c=='a');
232 break;
233 case 'b':
234 assert(c=='b');
235 break;
236 case 'c':
237 assert(c=='c');
238 break;
239 case 'd':
240 assert(c=='d');
241 break;
242 case 'e':
243 assert(c=='e');
244 break;
245 case 'f':
246 assert(c=='f');
247 break;
248 case 'g':
249 assert(c=='g');
250 break;
251 case 'h':
252 assert(c=='h');
253 break;
254 case 'i':
255 assert(c=='i');
256 break;
257 case 'j':
258 assert(c=='j');
259 break;
260
261 default:
262 puts("switch failed on character: ");
263 putchar(c);
264 puts("\n");
265 assert(0);
266 break;
267 }
268 } /* end of for */
269
270
271 }
272
273 /*---------------------------------------------------------------*/
test_if(void)274 void test_if(void)
275 /*---------------------------------------------------------------*/
276 {
277 int i;
278
279 puts("--- testing if\n");
280 i=0;
281 if(i==0)
282 {
283 i=1;
284 }
285 else
286 {
287 assert(0);
288 }
289 if(i==1)
290 {
291 i=2;
292 }
293 else
294 {
295 assert(0);
296 }
297 if((i>1)&&(i<3))
298 {
299 i=3;
300 }
301 else
302 {
303 assert(0);
304 }
305 if((i<4)||(i==99))
306 {
307 /* second expression not tested. */
308 i=4;
309 }
310 else
311 {
312 assert(0);
313 }
314 if((i<0)&&(i==4))
315 {
316 /* second expression not tested. */
317 assert(0);
318 }
319 else
320 {
321 i=5;
322 }
323
324
325 }
326
327 /*---------------------------------------------------------------*/
test_bit_operations(void)328 void test_bit_operations(void)
329 /*---------------------------------------------------------------*/
330 {
331 long i;
332 unsigned long u, v;
333 puts("--- testing bit operations\n");
334
335 i=0;
336 assert((~i)==-1);
337
338 u=0xFF;
339 assert((~u)==0xFFFFFF00);
340
341 i=-1;
342 assert(((unsigned long)i)==0xFFFFFFFF);
343
344 u=2;
345 assert((u>>1)==1);
346 assert((u>>2)==0);
347 assert((u<<1)==4);
348 assert((u<<2)==8);
349
350 u=0xFF;
351 assert((u<<8)==0xFF00);
352
353 u=0xFF;
354 v=0xFF0;
355 assert((u^v)==0xF0F);
356
357 }
358
359 typedef struct
360 {
361 unsigned char one;
362 char two;
363 unsigned short three;
364 short four;
365 unsigned long five;
366 long six;
367 char seven[7];
368 short eight[8];
369 } T_S;
370
371 /*---------------------------------------------------------------*/
test_struct_i1(T_S s)372 void test_struct_i1(T_S s)
373 /*---------------------------------------------------------------*/
374 {
375 assert(s.one==1);
376 assert(s.two==-2);
377 assert(s.three==0x3333);
378 assert(s.four==-4444);
379 assert(s.five==0xF555555);
380 assert(s.six==-666666);
381 assert(s.seven[0]==7);
382 assert(s.seven[1]==77);
383 assert(s.seven[2]==-7);
384 assert(s.eight[0]==8);
385 assert(s.eight[1]==88);
386 assert(s.eight[2]==888);
387 assert(s.eight[3]==8888);
388 }
389
390 /*---------------------------------------------------------------*/
test_struct_i2(T_S * p_s)391 void test_struct_i2(T_S *p_s)
392 /*---------------------------------------------------------------*/
393 {
394 assert(p_s->one==1);
395 assert(p_s->two==-2);
396 assert(p_s->three==0x3333);
397 assert(p_s->four==-4444);
398 assert(p_s->five==0xF555555);
399 assert(p_s->six==-666666);
400 assert(p_s->seven[0]==7);
401 assert(p_s->seven[1]==77);
402 assert(p_s->seven[2]==-7);
403 assert(p_s->eight[0]==8);
404 assert(p_s->eight[1]==88);
405 assert(p_s->eight[2]==888);
406 assert(p_s->eight[3]==8888);
407 }
408
409 /*---------------------------------------------------------------*/
test_struct_i3(T_S * p_s)410 void test_struct_i3(T_S *p_s)
411 /*---------------------------------------------------------------*/
412 {
413 p_s->one=10;
414 p_s->two=20;
415 p_s->three=30;
416 p_s->four=40;
417 p_s->five=50;
418 p_s->six=60;
419 p_s->seven[0]=70;
420 p_s->seven[1]=70;
421 p_s->seven[2]=70;
422 p_s->eight[0]=80;
423 p_s->eight[1]=80;
424 p_s->eight[2]=80;
425 p_s->eight[3]=80;
426 }
427
428 #if 0
429 /*---------------------------------------------------------------*/
430 void test_struct_i4(const T_S *p_s)
431 /*---------------------------------------------------------------*/
432 {
433 /* test 'const' --> OK */
434 p_s->one=10;
435 }
436 #endif
437
438
439 /*---------------------------------------------------------------*/
test_struct(void)440 void test_struct(void)
441 /*---------------------------------------------------------------*/
442 {
443 T_S s;
444
445 puts("--- testing struct\n");
446
447 s.one=1;
448 s.two=-2;
449 s.three=0x3333;
450 s.four=-4444;
451 s.five=0xF555555;
452 s.six=-666666;
453 s.seven[0]=7;
454 s.seven[1]=77;
455 s.seven[2]=-7;
456 s.eight[0]=8;
457 s.eight[1]=88;
458 s.eight[2]=888;
459 s.eight[3]=8888;
460
461 assert(s.one==1);
462 assert(s.two==-2);
463 assert(s.three==0x3333);
464 assert(s.four==-4444);
465 assert(s.five==0xF555555);
466 assert(s.six==-666666);
467 assert(s.seven[0]==7);
468 assert(s.seven[1]==77);
469 assert(s.seven[2]==-7);
470 assert(s.eight[0]==8);
471 assert(s.eight[1]==88);
472 assert(s.eight[2]==888);
473 assert(s.eight[3]==8888);
474
475
476 test_struct_i1(s);
477 test_struct_i2(&s);
478 test_struct_i3(&s);
479
480 assert(s.one==10);
481 assert(s.two==20);
482 assert(s.three==30);
483 assert(s.four==40);
484 assert(s.five==50);
485 assert(s.six==60);
486 assert(s.seven[0]==70);
487 assert(s.seven[1]==70);
488 assert(s.seven[2]==70);
489 assert(s.eight[0]==80);
490 assert(s.eight[1]==80);
491 assert(s.eight[2]==80);
492 assert(s.eight[3]==80);
493
494 }
495
496 typedef struct
497 {
498 unsigned bit0:1;
499 unsigned bit1:1;
500 unsigned bit2:1;
501 unsigned bit3_4:2;
502 unsigned bit5_7:3;
503 unsigned bit8_15:8;
504 unsigned bit16_31:16;
505 } T_BF;
506
507 /*---------------------------------------------------------------*/
test_bit_field(void)508 void test_bit_field(void)
509 /*---------------------------------------------------------------*/
510 {
511 T_BF data;
512
513 puts("--- testing bit fields\n");
514
515 data.bit0=0;
516 data.bit1=0;
517 data.bit2=0;
518 data.bit3_4=0;
519 data.bit5_7=0;
520 data.bit8_15=0;
521 data.bit16_31=0;
522
523 assert(data.bit0==0);
524 assert(data.bit1==0);
525 assert(data.bit2==0);
526 assert(data.bit3_4==0);
527 assert(data.bit5_7==0);
528 assert(data.bit8_15==0);
529 assert(data.bit16_31==0);
530
531 data.bit0=1;
532 assert(data.bit0==1);
533 assert(data.bit1==0);
534
535 data.bit1=1;
536 assert(data.bit0==1);
537 assert(data.bit1==1);
538
539 data.bit0=0;
540 data.bit1=0;
541 assert(data.bit0==0);
542 assert(data.bit1==0);
543
544 data.bit3_4=2;
545 assert(data.bit0==0);
546 assert(data.bit1==0);
547 assert(data.bit2==0);
548 assert(data.bit3_4==2);
549 assert(data.bit5_7==0);
550
551 data.bit3_4=3;
552 assert(data.bit0==0);
553 assert(data.bit1==0);
554 assert(data.bit2==0);
555 assert(data.bit3_4==3);
556 assert(data.bit5_7==0);
557
558 data.bit16_31=0xabcd;
559 assert(data.bit0==0);
560 assert(data.bit1==0);
561 assert(data.bit2==0);
562 assert(data.bit3_4==3);
563 assert(data.bit5_7==0);
564 assert(data.bit8_15==0);
565 assert(data.bit16_31==0xabcd);
566
567 }
568
569 jmp_buf context;
570 /*--------------------------------------------------*/
j1()571 void j1()
572 /*--------------------------------------------------*/
573 {
574 /* puts("jumping..."); */
575 longjmp(context,1);
576 }
577 /*--------------------------------------------------*/
j2()578 void j2()
579 /*--------------------------------------------------*/
580 {
581 /* puts("jumping..."); */
582 longjmp(context,0x12000);
583 }
584
585 /*---------------------------------------------------------------*/
test_jump()586 void test_jump()
587 /*---------------------------------------------------------------*/
588 {
589 int v,w;
590 int a=0;
591 int b=12;
592 register unsigned long r1=0xC0CAC0CA;
593 register unsigned short r2=0xCAFE;
594
595 puts("--- testing jump\n");
596
597 v=setjmp(context);
598 if(v==0)
599 {
600 /* puts("normal path <1> OK\n"); */
601 j1();
602 }
603 else if(v==1)
604 {
605 /* puts(" jump <1> OK\n"); */
606 assert(a==0);
607 assert(b==12);
608 assert(r1==0xC0CAC0CA);
609 assert(r2==0xCAFE);
610
611 /* jumping again */
612 w=setjmp(context);
613 if(w==0)
614 {
615 /* puts("normal path <2> OK\n"); */
616 j2();
617 }
618 else if(w==0x12000)
619 {
620 /* puts(" jump <2> OK\n"); */
621 assert(a==0);
622 assert(b==12);
623 assert(r1==0xC0CAC0CA);
624 assert(r2==0xCAFE);
625 }
626 else
627 {
628 puts("ERROR: bad 'longjmp' <2> value\n");
629 assert(0);
630 }
631 }
632 else
633 {
634 puts("ERROR: bad 'longjmp' <1> value\n");
635 assert(0);
636 }
637
638 }
639
640 /*---------------------------------------------------------------*/
main()641 void main()
642 /*---------------------------------------------------------------*/
643 {
644 extern void DUART_INIT(void);
645 DUART_INIT();
646 puts("WELCOME in BSVC-M68K\n");
647
648 #if defined(__GNUC__) && defined(DEBUG)
649 set_debug_traps();
650 breakpoint();
651 #endif
652
653 test_arithmetic();
654 test_itoa();
655 test_array();
656 test_switch();
657 test_if();
658 test_bit_operations();
659 test_struct();
660 test_bit_field();
661 test_jump();
662
663 puts("--- ALL TESTS OK\n");
664 #if defined(__GNUC__)
665 while(1);
666 #endif
667 }
668
669 #if defined(__GNUC__)
670 /*---------------------------------------------------------------*/
_assert(int expr,const char * the_file,int the_line)671 void _assert(int expr, const char *the_file, int the_line)
672 /*---------------------------------------------------------------*/
673 {
674 char buf[16];
675 if(!expr)
676 {
677 puts("assert failed in ");
678 puts(the_file);
679 puts(" ");
680 itoa(the_line,buf);
681 puts((const char*)buf);
682 puts("\n");
683 while(1);
684 }
685 }
686 #endif
687
688