OpenCores
URL https://opencores.org/ocsvn/tcp_socket/tcp_socket/trunk

Subversion Repositories tcp_socket

[/] [tcp_socket/] [trunk/] [chips2/] [test_suite/] [test_c2verilog] - Blame information for rev 2

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 2 jondawson 
#!/usr/bin/env python
2 
import os
3 
import sys
4 
 
5 
os.system("python-coverage erase")
6 
 
7 
def test(test, code, no_init=False):
8 
  f = open("test.c", 'w')
9 
  f.write(code)
10 
  f.close()
11 
  if no_init:
12 
      result = os.system("python-coverage run -p ../c2verilog iverilog run no_initialize_memory test.c")
13 
  else:
14 
      result = os.system("python-coverage run -p ../c2verilog iverilog run test.c")
15 
  if(os.path.exists("main")):
16 
      os.remove("main")
17 
  if(os.path.exists("arbiter")):
18 
      os.remove("arbiter")
19 
  if(os.path.exists("real_main")):
20 
      os.remove("real_main")
21 
 
22 
  if result == 0:
23 
    print test, "...pass"
24 
  else:
25 
    print test, "...fail"
26 
    sys.exit(0)
27 
 
28 
  if no_init:
29 
      result = os.system("python-coverage run -p ../c2verilog iverilog run speed no_initialize_memory test.c")
30 
  else:
31 
      result = os.system("python-coverage run -p ../c2verilog iverilog run speed test.c")
32 
  if(os.path.exists("main")):
33 
      os.remove("main")
34 
  if(os.path.exists("arbiter")):
35 
      os.remove("arbiter")
36 
  if(os.path.exists("real_main")):
37 
      os.remove("real_main")
38 
 
39 
  if result == 0:
40 
    print test, "...pass"
41 
  else:
42 
    print test, "...fail"
43 
    sys.exit(0)
44 
 
45 
def test_fails(test, code, no_init=False):
46 
  f = open("test.c", 'w')
47 
  f.write(code)
48 
  f.close()
49 
  print "One error expected ..."
50 
  if no_init:
51 
      result = os.system("python-coverage run -p ../c2verilog iverilog run no_initialize_memory test.c")
52 
  else:
53 
      result = os.system("python-coverage run -p ../c2verilog iverilog run test.c")
54 
  if result == 0:
55 
    print test, "...fail"
56 
    sys.exit(0)
57 
  else:
58 
    print test, "...pass"
59 
 
60 
test("unsigned divide 1",
61 
"""
62 
void main(){
63 
  unsigned a = 10;
64 
  unsigned b = 5;
65 
  assert(a/b==2);
66 
}
67 
"""
68 
)
69 
 
70 
test("long unsigned divide 1",
71 
"""
72 
void main(){
73 
  long unsigned a = 1000000L;
74 
  long unsigned b = 500000L;
75 
  assert(a/b==2);
76 
}
77 
"""
78 
)
79 
 
80 
test("divide 1",
81 
"""
82 
void main(){
83 
  int a = 10;
84 
  int b = 5;
85 
  assert(a/b==2);
86 
}
87 
"""
88 
)
89 
 
90 
test("long divide 1",
91 
"""
92 
void main(){
93 
  long a = 1000000L;
94 
  long b = 500000L;
95 
  assert(a/b==2);
96 
}
97 
"""
98 
)
99 
 
100 
test("long 1",
101 
"""
102 
void main(){
103 
  long a = 100000L;
104 
  assert(a==100000L);
105 
}
106 
"""
107 
)
108 
 
109 
test("long 2",
110 
"""
111 
void main(){
112 
  long a = 100000L;
113 
  assert(sizeof a == 4);
114 
}
115 
"""
116 
)
117 
 
118 
test("long 3",
119 
"""
120 
void main(){
121 
  long a = 0xffffL;
122 
  assert(a+1 != 0);
123 
  assert(a+1 == 0x10000L);
124 
}
125 
"""
126 
)
127 
 
128 
test("long 4",
129 
"""
130 
void main(){
131 
  long a = 0xffffL;
132 
  long b = 0xffffL;
133 
  assert(a+b == 0x1fffeL);
134 
}
135 
"""
136 
)
137 
test("long 5",
138 
"""
139 
void main(){
140 
  long a = 0xffffffffUL;
141 
  long b = 0x0;
142 
  assert(a < b);
143 
}
144 
"""
145 
)
146 
test("long 6",
147 
"""
148 
void main(){
149 
  unsigned long a = 0xffffffffUL;
150 
  long b = 0x0;
151 
  assert(a > b);
152 
}
153 
"""
154 
)
155 
 
156 
test("long 7",
157 
"""
158 
void test_long(long a){
159 
    assert(a+1 != 0);
160 
    assert(a+1 == 0x10000L);
161 
}
162 
 
163 
void main(){
164 
  long a = 0xffffL;
165 
  test_long(a);
166 
}
167 
"""
168 
)
169 
 
170 
test("long 8",
171 
"""
172 
void test_long(unsigned long a){
173 
    assert(a > 0);
174 
}
175 
 
176 
void main(){
177 
  unsigned long a = 0xffffffffUL;
178 
  test_long(a);
179 
}
180 
"""
181 
)
182 
 
183 
test("long 9",
184 
"""
185 
void test_long(long a){
186 
    assert(a < 0);
187 
}
188 
 
189 
void main(){
190 
  unsigned long a = 0xffffffffUL;
191 
  test_long(a);
192 
}
193 
"""
194 
)
195 
 
196 
test("long 10",
197 
"""
198 
void test_long(unsigned long a){
199 
    assert(a > 0);
200 
}
201 
 
202 
void main(){
203 
  long a = 0xffffffffUL;
204 
  test_long(a);
205 
}
206 
"""
207 
)
208 
 
209 
test("long 11",
210 
"""
211 
void main(){
212 
  long a[2];
213 
  a[0] = 0xffffffffUL;
214 
  a[1] = 0xffffffffUL;
215 
  assert(a[1] == 0xffffffffUL);
216 
}
217 
"""
218 
)
219 
 
220 
test("long 12",
221 
"""
222 
void main(){
223 
  long a[2];
224 
  int b[2];
225 
  a[0] = 1;
226 
  b[0] = 2;
227 
  a[1] = 3;
228 
  b[1] = 4;
229 
  assert(a[0] == 1);
230 
  assert(b[0] == 2);
231 
  assert(a[1] == 3);
232 
  assert(b[1] == 4);
233 
}
234 
"""
235 
)
236 
 
237 
test("void 1",
238 
"""
239 
void func(unsigned i){
240 
}
241 
void main(){
242 
  int a = 1;
243 
  assert(a++ == 1);
244 
  assert(a++ == 2);
245 
  assert(a == 3);
246 
  assert(a-- == 3);
247 
  assert(a-- == 2);
248 
  assert(a == 1);
249 
}
250 
"""
251 
)
252 
 
253 
test("postfix 1",
254 
"""
255 
int main(){
256 
  int a = 1;
257 
  assert(a++ == 1);
258 
  assert(a++ == 2);
259 
  assert(a == 3);
260 
  assert(a-- == 3);
261 
  assert(a-- == 2);
262 
  assert(a == 1);
263 
  return 0;
264 
}
265 
"""
266 
)
267 
 
268 
 
269 
test("sizeof 1",
270 
"""
271 
int main(){
272 
  unsigned a = 0xffffU;
273 
  unsigned b = 0x7fff;
274 
  unsigned c[4];
275 
  unsigned d[] = "asdfg";
276 
  assert(sizeof a == 2);
277 
  assert(sizeof b == 2);
278 
  assert(sizeof c == 8);
279 
  assert(sizeof d == 12);
280 
  return 0;
281 
}
282 
"""
283 
)
284 
 
285 
test("type_unsigned 1",
286 
"""
287 
int main(){
288 
  unsigned a = 0xffffU;
289 
  unsigned b = 0x7fff;
290 
  assert(a==0xffffU);
291 
  assert(a > b);
292 
 
293 
  return 0;
294 
}
295 
"""
296 
)
297 
 
298 
test("type_unsigned 2",
299 
"""
300 
int main(){
301 
  unsigned a = 0xffffU;
302 
  unsigned b = 0x7fff;
303 
  assert(a==0xffffU);
304 
  assert(b < a);
305 
 
306 
  return 0;
307 
}
308 
"""
309 
)
310 
 
311 
test("type_unsigned 3",
312 
"""
313 
int test(unsigned a){
314 
    return a;
315 
}
316 
 
317 
int main(){
318 
  assert(test(3) == 3);
319 
  return 0;
320 
}
321 
"""
322 
)
323 
 
324 
test("type_unsigned 4",
325 
"""
326 
int main(){
327 
  int a = 1;
328 
  unsigned b = 1;
329 
  assert(a == b);
330 
  return 0;
331 
}
332 
"""
333 
)
334 
 
335 
test("type_unsigned 5",
336 
"""
337 
int main(){
338 
  int a = 1;
339 
  assert(a == 1);
340 
  return 0;
341 
}
342 
"""
343 
)
344 
test("type_unsigned 6",
345 
"""
346 
int main(){
347 
  int a = 1;
348 
  assert(1 == a);
349 
  return 0;
350 
}
351 
"""
352 
)
353 
test("type_unsigned 7",
354 
"""
355 
int main(){
356 
  unsigned b = 1;
357 
  assert(1 == b);
358 
  return 0;
359 
}
360 
"""
361 
)
362 
test("type_unsigned 8",
363 
"""
364 
int main(){
365 
  unsigned b = 1;
366 
  assert(b == 1);
367 
  return 0;
368 
}
369 
"""
370 
)
371 
 
372 
test("type_compatibility 1",
373 
"""
374 
int main(){
375 
  int a = 4;
376 
  char b = 6;
377 
  b = a;
378 
  assert(b==4);
379 
  return 0;
380 
}
381 
"""
382 
)
383 
 
384 
test("type_compatibility 2",
385 
"""
386 
int main(){
387 
  int a[2];
388 
  char b[2];
389 
  b = a;
390 
  return 0;
391 
}
392 
"""
393 
)
394 
 
395 
test("type_compatibility 3",
396 
"""
397 
int main(){
398 
  int a[2];
399 
  char b[2];
400 
  a = b;
401 
  return 0;
402 
}
403 
"""
404 
)
405 
 
406 
test("type_compatibility 4",
407 
"""
408 
int main(){
409 
  long a[2];
410 
  char b[2];
411 
  a = b;
412 
  return 0;
413 
}
414 
"""
415 
)
416 
 
417 
test("type_compatibility 5",
418 
"""
419 
int main(){
420 
  long a[2];
421 
  char b[2];
422 
  a = b;
423 
  return 0;
424 
}
425 
"""
426 
)
427 
 
428 
test("string 1 a",
429 
"""
430 
int main(){
431 
  int c[4] = "aA1";
432 
  assert(c[0] == 97);
433 
  assert(c[1] == 65);
434 
  assert(c[2] == 49);
435 
  assert(c[3] == 0);
436 
  return 0;
437 
}
438 
 
439 
""")
440 
 
441 
test("string 1 b",
442 
"""
443 
int main(){
444 
  int c[4] = "aA1";
445 
  assert(c[0] == 97);
446 
  assert(c[1] == 65);
447 
  assert(c[2] == 49);
448 
  assert(c[3] == 0);
449 
  return 0;
450 
}
451 
 
452 
""", True)
453 
 
454 
test("string 2a",
455 
"""
456 
int main(){
457 
  int c[] = "aA1";
458 
  assert(c[0] == 97);
459 
  assert(c[1] == 65);
460 
  assert(c[2] == 49);
461 
  assert(c[3] == 0);
462 
  return 0;
463 
}
464 
 
465 
""")
466 
 
467 
test("string 2b",
468 
"""
469 
int main(){
470 
  int c[] = "aA1";
471 
  assert(c[0] == 97);
472 
  assert(c[1] == 65);
473 
  assert(c[2] == 49);
474 
  assert(c[3] == 0);
475 
  return 0;
476 
}
477 
 
478 
""", True)
479 
 
480 
test_fails("string 3",
481 
"""
482 
int main(){
483 
  int c[];
484 
  assert(c[0] == 97);
485 
  assert(c[1] == 65);
486 
  assert(c[2] == 49);
487 
  assert(c[3] == 0);
488 
  return 0;
489 
}
490 
 
491 
""")
492 
 
493 
test("string 4a",
494 
"""
495 
int test(char c[]){
496 
  assert(c[0] == 97);
497 
  assert(c[1] == 65);
498 
  assert(c[2] == 49);
499 
  assert(c[3] == 0);
500 
  c[0] = 'b';
501 
  c[1] = 'B';
502 
  c[2] = '2';
503 
  c[3] = 0;
504 
  return 0;
505 
}
506 
int main(){
507 
  char c[] = "aA1";
508 
  assert(c[0] == 97);
509 
  assert(c[1] == 65);
510 
  assert(c[2] == 49);
511 
  assert(c[3] == 0);
512 
  test(c);
513 
  assert(c[0] == 'b');
514 
  assert(c[1] == 'B');
515 
  assert(c[2] == '2');
516 
  assert(c[3] == 0);
517 
  return 0;
518 
}
519 
 
520 
""")
521 
 
522 
test("string 4b",
523 
"""
524 
int test(char c[]){
525 
  assert(c[0] == 97);
526 
  assert(c[1] == 65);
527 
  assert(c[2] == 49);
528 
  assert(c[3] == 0);
529 
  c[0] = 'b';
530 
  c[1] = 'B';
531 
  c[2] = '2';
532 
  c[3] = 0;
533 
  return 0;
534 
}
535 
int main(){
536 
  char c[] = "aA1";
537 
  assert(c[0] == 97);
538 
  assert(c[1] == 65);
539 
  assert(c[2] == 49);
540 
  assert(c[3] == 0);
541 
  test(c);
542 
  assert(c[0] == 'b');
543 
  assert(c[1] == 'B');
544 
  assert(c[2] == '2');
545 
  assert(c[3] == 0);
546 
  return 0;
547 
}
548 
 
549 
""", True)
550 
 
551 
test_fails("string 5",
552 
"""
553 
int main(){
554 
  int c[] "\\n";
555 
  assert(c[0] == 10);
556 
  assert(c[1] == 0);
557 
  return 0;
558 
}
559 
 
560 
""")
561 
 
562 
test("string 6a",
563 
"""
564 
int test(char c[]){
565 
  assert(c[0] == 97);
566 
  assert(c[1] == 65);
567 
  assert(c[2] == 49);
568 
  assert(c[3] == 0);
569 
  return 0;
570 
}
571 
int main(){
572 
  test("aA1");
573 
  return 0;
574 
}
575 
""")
576 
 
577 
test("string 6b",
578 
"""
579 
int test(char c[]){
580 
  assert(c[0] == 97);
581 
  assert(c[1] == 65);
582 
  assert(c[2] == 49);
583 
  assert(c[3] == 0);
584 
  return 0;
585 
}
586 
int main(){
587 
  test("aA1");
588 
  return 0;
589 
}
590 
""", True)
591 
 
592 
test("string 7a",
593 
"""
594 
int main(){
595 
  char c[] = "a\\n";
596 
  assert(c[0] == 97);
597 
  assert(c[1] == 10);
598 
  assert(c[2] == 0);
599 
  return 0;
600 
}
601 
""")
602 
 
603 
test("string 7b",
604 
"""
605 
int main(){
606 
  char c[] = "a\\n";
607 
  assert(c[0] == 97);
608 
  assert(c[1] == 10);
609 
  assert(c[2] == 0);
610 
  return 0;
611 
}
612 
""", True)
613 
 
614 
test("char 1",
615 
"""
616 
int main(){
617 
  int c = 'a';
618 
  assert(c == 97);
619 
  return 0;
620 
}
621 
 
622 
""")
623 
test("char 2",
624 
"""
625 
int main(){
626 
  int c = 'A';
627 
  assert(c == 65);
628 
  return 0;
629 
}
630 
 
631 
""")
632 
test("char 3",
633 
"""
634 
int main(){
635 
  int c = '1';
636 
  assert(c == 49);
637 
  return 0;
638 
}
639 
 
640 
""")
641 
test("char 4",
642 
"""
643 
int main(){
644 
  int c = '\\n';
645 
  assert(c == 10);
646 
  return 0;
647 
}
648 
 
649 
""")
650 
 
651 
test("unsigned long modulo 1",
652 
"""
653 
unsigned long int main(){
654 
  unsigned long int a = 3;
655 
  unsigned long int b = 4;
656 
  assert(a%b == 3);
657 
  return 0;
658 
}
659 
 
660 
""")
661 
 
662 
test("unsigned long modulo 3",
663 
"""
664 
unsigned long int main(){
665 
  unsigned long int a = 7;
666 
  unsigned long int b = 8;
667 
  assert(a%b == 7);
668 
  return 0;
669 
}
670 
 
671 
""")
672 
 
673 
test("unsigned long modulo 4",
674 
"""
675 
unsigned long int main(){
676 
  unsigned long int a = 15;
677 
  unsigned long int b = 8;
678 
  assert(a%b == 7);
679 
  return 0;
680 
}
681 
 
682 
""")
683 
 
684 
test("unsigned long modulo 9",
685 
"""
686 
unsigned long int main(){
687 
  unsigned long int a = 32766;
688 
  unsigned long int b = 0;
689 
  assert(a%b == 32766);
690 
  return 0;
691 
}
692 
 
693 
""")
694 
 
695 
test("unsigned long division 1",
696 
"""
697 
unsigned long int main(){
698 
  unsigned long int a = 15;
699 
  unsigned long int b = 3;
700 
  assert(a/b == 5);
701 
  return 0;
702 
}
703 
 
704 
""")
705 
 
706 
 
707 
test("unsigned long division 2",
708 
"""
709 
unsigned long int main(){
710 
  unsigned long int a = 12;
711 
  unsigned long int b = 4;
712 
  assert(a/b == 3);
713 
  return 0;
714 
}
715 
 
716 
""")
717 
 
718 
test("unsigned long division 3",
719 
"""
720 
unsigned long int main(){
721 
  unsigned long int a = 1;
722 
  unsigned long int b = 1;
723 
  assert(a/b == 1);
724 
  return 0;
725 
}
726 
 
727 
""")
728 
 
729 
test("unsigned long division 6",
730 
"""
731 
unsigned long int main(){
732 
  unsigned long int a = 0;
733 
  unsigned long int b = 1;
734 
  assert(a/b == 0);
735 
  return 0;
736 
}
737 
 
738 
""")
739 
 
740 
test("unsigned long division 7",
741 
"""
742 
unsigned long int main(){
743 
  unsigned long int a = 5;
744 
  unsigned long int b = 2;
745 
  assert(a/b == 2);
746 
  return 0;
747 
}
748 
 
749 
""")
750 
 
751 
test("unsigned long division 9",
752 
"""
753 
unsigned long int main(){
754 
  unsigned long int a = 0;
755 
  unsigned long int b = 32767;
756 
  assert(a/b == 0);
757 
  return 0;
758 
}
759 
 
760 
""")
761 
 
762 
test("unsigned long division 10",
763 
"""
764 
unsigned long int main(){
765 
  unsigned long int a = 32767;
766 
  unsigned long int b = 1;
767 
  assert(a/b == 32767);
768 
  return 0;
769 
}
770 
 
771 
""")
772 
 
773 
test("unsigned long division 11",
774 
"""
775 
unsigned long int main(){
776 
  unsigned long int a = 32767;
777 
  unsigned long int b = 2;
778 
  assert(a/b == 16383);
779 
  return 0;
780 
}
781 
 
782 
""")
783 
 
784 
test("unsigned long division 12",
785 
"""
786 
unsigned long int main(){
787 
  unsigned long int a = 32767;
788 
  unsigned long int b = 32767;
789 
  assert(a/b == 1);
790 
  return 0;
791 
}
792 
 
793 
""")
794 
 
795 
test("unsigned modulo 1",
796 
"""
797 
unsigned int main(){
798 
  unsigned int a = 3;
799 
  unsigned int b = 4;
800 
  assert(a%b == 3);
801 
  return 0;
802 
}
803 
 
804 
""")
805 
 
806 
test("unsigned modulo 3",
807 
"""
808 
unsigned int main(){
809 
  unsigned int a = 7;
810 
  unsigned int b = 8;
811 
  assert(a%b == 7);
812 
  return 0;
813 
}
814 
 
815 
""")
816 
 
817 
test("unsigned modulo 4",
818 
"""
819 
unsigned int main(){
820 
  unsigned int a = 15;
821 
  unsigned int b = 8;
822 
  assert(a%b == 7);
823 
  return 0;
824 
}
825 
 
826 
""")
827 
 
828 
test("unsigned modulo 9",
829 
"""
830 
unsigned int main(){
831 
  unsigned int a = 32766;
832 
  unsigned int b = 0;
833 
  assert(a%b == 32766);
834 
  return 0;
835 
}
836 
 
837 
""")
838 
 
839 
test("unsigned division 1",
840 
"""
841 
unsigned int main(){
842 
  unsigned int a = 15;
843 
  unsigned int b = 3;
844 
  assert(a/b == 5);
845 
  return 0;
846 
}
847 
 
848 
""")
849 
 
850 
 
851 
test("unsigned division 2",
852 
"""
853 
unsigned int main(){
854 
  unsigned int a = 12;
855 
  unsigned int b = 4;
856 
  assert(a/b == 3);
857 
  return 0;
858 
}
859 
 
860 
""")
861 
 
862 
test("unsigned division 3",
863 
"""
864 
unsigned int main(){
865 
  unsigned int a = 1;
866 
  unsigned int b = 1;
867 
  assert(a/b == 1);
868 
  return 0;
869 
}
870 
 
871 
""")
872 
 
873 
test("unsigned division 6",
874 
"""
875 
unsigned int main(){
876 
  unsigned int a = 0;
877 
  unsigned int b = 1;
878 
  assert(a/b == 0);
879 
  return 0;
880 
}
881 
 
882 
""")
883 
 
884 
test("unsigned division 7",
885 
"""
886 
unsigned int main(){
887 
  unsigned int a = 5;
888 
  unsigned int b = 2;
889 
  assert(a/b == 2);
890 
  return 0;
891 
}
892 
 
893 
""")
894 
 
895 
test("unsigned division 9",
896 
"""
897 
unsigned int main(){
898 
  unsigned int a = 0;
899 
  unsigned int b = 32767;
900 
  assert(a/b == 0);
901 
  return 0;
902 
}
903 
 
904 
""")
905 
 
906 
test("unsigned division 10",
907 
"""
908 
unsigned int main(){
909 
  unsigned int a = 32767;
910 
  unsigned int b = 1;
911 
  assert(a/b == 32767);
912 
  return 0;
913 
}
914 
 
915 
""")
916 
 
917 
test("unsigned division 11",
918 
"""
919 
unsigned int main(){
920 
  unsigned int a = 32767;
921 
  unsigned int b = 2;
922 
  assert(a/b == 16383);
923 
  return 0;
924 
}
925 
 
926 
""")
927 
 
928 
test("unsigned division 12",
929 
"""
930 
unsigned int main(){
931 
  unsigned int a = 32767;
932 
  unsigned int b = 32767;
933 
  assert(a/b == 1);
934 
  return 0;
935 
}
936 
 
937 
""")
938 
 
939 
test("long modulo 1",
940 
"""
941 
long int main(){
942 
  long int a = 3;
943 
  long int b = 4;
944 
  assert(a%b == 3);
945 
  return 0;
946 
}
947 
 
948 
""")
949 
 
950 
test("long modulo 2",
951 
"""
952 
long int main(){
953 
  long int a = -3;
954 
  long int b = 4;
955 
  assert(a%b == -3);
956 
  return 0;
957 
}
958 
 
959 
""")
960 
 
961 
test("long modulo 3",
962 
"""
963 
long int main(){
964 
  long int a = 7;
965 
  long int b = 8;
966 
  assert(a%b == 7);
967 
  return 0;
968 
}
969 
 
970 
""")
971 
 
972 
test("long modulo 4",
973 
"""
974 
long int main(){
975 
  long int a = 15;
976 
  long int b = 8;
977 
  assert(a%b == 7);
978 
  return 0;
979 
}
980 
 
981 
""")
982 
 
983 
test("long modulo 5",
984 
"""
985 
long int main(){
986 
  long int a = -7;
987 
  long int b = 8;
988 
  assert(a%b == -7);
989 
  return 0;
990 
}
991 
 
992 
""")
993 
 
994 
test("long modulo 6",
995 
"""
996 
long int main(){
997 
  long int a = -15;
998 
  long int b = 8;
999 
  assert(a%b == -7);
1000 
  return 0;
1001 
}
1002 
 
1003 
""")
1004 
 
1005 
test("long modulo 7",
1006 
"""
1007 
long int main(){
1008 
  long int a = 7;
1009 
  long int b = -8;
1010 
  assert(a%b == 7);
1011 
  return 0;
1012 
}
1013 
 
1014 
""")
1015 
 
1016 
test("long modulo 8",
1017 
"""
1018 
long int main(){
1019 
  long int a = 15;
1020 
  long int b = -8;
1021 
  assert(a%b == 7);
1022 
  return 0;
1023 
}
1024 
 
1025 
""")
1026 
 
1027 
test("long modulo 9",
1028 
"""
1029 
long int main(){
1030 
  long int a = 32766;
1031 
  long int b = 0;
1032 
  assert(a%b == 32766);
1033 
  return 0;
1034 
}
1035 
 
1036 
""")
1037 
 
1038 
test("long division 1",
1039 
"""
1040 
long int main(){
1041 
  long int a = 15;
1042 
  long int b = 3;
1043 
  assert(a/b == 5);
1044 
  return 0;
1045 
}
1046 
 
1047 
""")
1048 
 
1049 
 
1050 
test("long division 2",
1051 
"""
1052 
long int main(){
1053 
  long int a = 12;
1054 
  long int b = 4;
1055 
  assert(a/b == 3);
1056 
  return 0;
1057 
}
1058 
 
1059 
""")
1060 
 
1061 
test("long division 3",
1062 
"""
1063 
long int main(){
1064 
  long int a = 1;
1065 
  long int b = 1;
1066 
  assert(a/b == 1);
1067 
  return 0;
1068 
}
1069 
 
1070 
""")
1071 
 
1072 
test("long division 4",
1073 
"""
1074 
long int main(){
1075 
  long int a = 1;
1076 
  long int b = -1;
1077 
  assert(a/b == -1);
1078 
  return 0;
1079 
}
1080 
 
1081 
""")
1082 
 
1083 
test("long division 5",
1084 
"""
1085 
long int main(){
1086 
  long int a = -1;
1087 
  long int b = 1;
1088 
  assert(a/b == -1);
1089 
  return 0;
1090 
}
1091 
 
1092 
""")
1093 
 
1094 
test("long division 6",
1095 
"""
1096 
long int main(){
1097 
  long int a = 0;
1098 
  long int b = 1;
1099 
  assert(a/b == 0);
1100 
  return 0;
1101 
}
1102 
 
1103 
""")
1104 
 
1105 
test("long division 7",
1106 
"""
1107 
long int main(){
1108 
  long int a = 5;
1109 
  long int b = 2;
1110 
  assert(a/b == 2);
1111 
  return 0;
1112 
}
1113 
 
1114 
""")
1115 
 
1116 
test("long division 8",
1117 
"""
1118 
long int main(){
1119 
  long int a = -5;
1120 
  long int b = 2;
1121 
  assert(a/b == -2);
1122 
  return 0;
1123 
}
1124 
 
1125 
""")
1126 
 
1127 
test("long division 9",
1128 
"""
1129 
long int main(){
1130 
  long int a = 0;
1131 
  long int b = 32767;
1132 
  assert(a/b == 0);
1133 
  return 0;
1134 
}
1135 
 
1136 
""")
1137 
 
1138 
test("long division 10",
1139 
"""
1140 
long int main(){
1141 
  long int a = 32767;
1142 
  long int b = 1;
1143 
  assert(a/b == 32767);
1144 
  return 0;
1145 
}
1146 
 
1147 
""")
1148 
 
1149 
test("long division 11",
1150 
"""
1151 
long int main(){
1152 
  long int a = 32767;
1153 
  long int b = 2;
1154 
  assert(a/b == 16383);
1155 
  return 0;
1156 
}
1157 
 
1158 
""")
1159 
 
1160 
test("long division 12",
1161 
"""
1162 
long int main(){
1163 
  long int a = 32767;
1164 
  long int b = 32767;
1165 
  assert(a/b == 1);
1166 
  return 0;
1167 
}
1168 
 
1169 
""")
1170 
 
1171 
test("long division 13",
1172 
"""
1173 
long int main(){
1174 
  long int a = -32767-1;
1175 
  long int b = -32767-1;
1176 
  assert(a/b == 1);
1177 
  return 0;
1178 
}
1179 
 
1180 
""")
1181 
 
1182 
test("long division 14",
1183 
"""
1184 
long int main(){
1185 
  long int a = -32767;
1186 
  long int b = -1;
1187 
  assert(a/b == 32767);
1188 
  return 0;
1189 
}
1190 
 
1191 
""")
1192 
 
1193 
test("modulo 1",
1194 
"""
1195 
int main(){
1196 
  int a = 3;
1197 
  int b = 4;
1198 
  assert(a%b == 3);
1199 
  return 0;
1200 
}
1201 
 
1202 
""")
1203 
 
1204 
test("modulo 2",
1205 
"""
1206 
int main(){
1207 
  int a = -3;
1208 
  int b = 4;
1209 
  assert(a%b == -3);
1210 
  return 0;
1211 
}
1212 
 
1213 
""")
1214 
 
1215 
test("modulo 3",
1216 
"""
1217 
int main(){
1218 
  int a = 7;
1219 
  int b = 8;
1220 
  assert(a%b == 7);
1221 
  return 0;
1222 
}
1223 
 
1224 
""")
1225 
 
1226 
test("modulo 4",
1227 
"""
1228 
int main(){
1229 
  int a = 15;
1230 
  int b = 8;
1231 
  assert(a%b == 7);
1232 
  return 0;
1233 
}
1234 
 
1235 
""")
1236 
 
1237 
test("modulo 5",
1238 
"""
1239 
int main(){
1240 
  int a = -7;
1241 
  int b = 8;
1242 
  assert(a%b == -7);
1243 
  return 0;
1244 
}
1245 
 
1246 
""")
1247 
 
1248 
test("modulo 6",
1249 
"""
1250 
int main(){
1251 
  int a = -15;
1252 
  int b = 8;
1253 
  assert(a%b == -7);
1254 
  return 0;
1255 
}
1256 
 
1257 
""")
1258 
 
1259 
test("modulo 7",
1260 
"""
1261 
int main(){
1262 
  int a = 7;
1263 
  int b = -8;
1264 
  assert(a%b == 7);
1265 
  return 0;
1266 
}
1267 
 
1268 
""")
1269 
 
1270 
test("modulo 8",
1271 
"""
1272 
int main(){
1273 
  int a = 15;
1274 
  int b = -8;
1275 
  assert(a%b == 7);
1276 
  return 0;
1277 
}
1278 
 
1279 
""")
1280 
 
1281 
test("modulo 9",
1282 
"""
1283 
int main(){
1284 
  int a = 32766;
1285 
  int b = 0;
1286 
  assert(a%b == 32766);
1287 
  return 0;
1288 
}
1289 
 
1290 
""")
1291 
 
1292 
test("division 1",
1293 
"""
1294 
int main(){
1295 
  int a = 15;
1296 
  int b = 3;
1297 
  assert(a/b == 5);
1298 
  return 0;
1299 
}
1300 
 
1301 
""")
1302 
 
1303 
 
1304 
test("division 2",
1305 
"""
1306 
int main(){
1307 
  int a = 12;
1308 
  int b = 4;
1309 
  assert(a/b == 3);
1310 
  return 0;
1311 
}
1312 
 
1313 
""")
1314 
 
1315 
test("division 3",
1316 
"""
1317 
int main(){
1318 
  int a = 1;
1319 
  int b = 1;
1320 
  assert(a/b == 1);
1321 
  return 0;
1322 
}
1323 
 
1324 
""")
1325 
 
1326 
test("division 4",
1327 
"""
1328 
int main(){
1329 
  int a = 1;
1330 
  int b = -1;
1331 
  assert(a/b == -1);
1332 
  return 0;
1333 
}
1334 
 
1335 
""")
1336 
 
1337 
test("division 5",
1338 
"""
1339 
int main(){
1340 
  int a = -1;
1341 
  int b = 1;
1342 
  assert(a/b == -1);
1343 
  return 0;
1344 
}
1345 
 
1346 
""")
1347 
 
1348 
test("division 6",
1349 
"""
1350 
int main(){
1351 
  int a = 0;
1352 
  int b = 1;
1353 
  assert(a/b == 0);
1354 
  return 0;
1355 
}
1356 
 
1357 
""")
1358 
 
1359 
test("division 7",
1360 
"""
1361 
int main(){
1362 
  int a = 5;
1363 
  int b = 2;
1364 
  assert(a/b == 2);
1365 
  return 0;
1366 
}
1367 
 
1368 
""")
1369 
 
1370 
test("division 8",
1371 
"""
1372 
int main(){
1373 
  int a = -5;
1374 
  int b = 2;
1375 
  assert(a/b == -2);
1376 
  return 0;
1377 
}
1378 
 
1379 
""")
1380 
 
1381 
test("division 9",
1382 
"""
1383 
int main(){
1384 
  int a = 0;
1385 
  int b = 32767;
1386 
  assert(a/b == 0);
1387 
  return 0;
1388 
}
1389 
 
1390 
""")
1391 
 
1392 
test("division 10",
1393 
"""
1394 
int main(){
1395 
  int a = 32767;
1396 
  int b = 1;
1397 
  assert(a/b == 32767);
1398 
  return 0;
1399 
}
1400 
 
1401 
""")
1402 
 
1403 
test("division 11",
1404 
"""
1405 
int main(){
1406 
  int a = 32767;
1407 
  int b = 2;
1408 
  assert(a/b == 16383);
1409 
  return 0;
1410 
}
1411 
 
1412 
""")
1413 
 
1414 
test("division 12",
1415 
"""
1416 
int main(){
1417 
  int a = 32767;
1418 
  int b = 32767;
1419 
  assert(a/b == 1);
1420 
  return 0;
1421 
}
1422 
 
1423 
""")
1424 
 
1425 
test("division 13",
1426 
"""
1427 
int main(){
1428 
  int a = -32767-1;
1429 
  int b = -32767-1;
1430 
  assert(a/b == 1);
1431 
  return 0;
1432 
}
1433 
 
1434 
""")
1435 
 
1436 
test("division 14",
1437 
"""
1438 
int main(){
1439 
  int a = -32767;
1440 
  int b = -1;
1441 
  assert(a/b == 32767);
1442 
  return 0;
1443 
}
1444 
 
1445 
""")
1446 
 
1447 
test("struct with array 1",
1448 
"""
1449 
typedef struct {int a; int b; int c[2];} blah;
1450 
blah myblah;
1451 
 
1452 
void test(){
1453 
  assert(myblah.a == 1);
1454 
  assert(myblah.b == 2);
1455 
  assert(myblah.c[0] == 3);
1456 
  assert(myblah.c[1] == 4);
1457 
  myblah.a = 5;
1458 
  myblah.b = 6;
1459 
  myblah.c[0] = 7;
1460 
  myblah.c[1] = 8;
1461 
}
1462 
 
1463 
void main(){
1464 
  myblah.a = 1;
1465 
  myblah.b = 2;
1466 
  myblah.c[0] = 3;
1467 
  myblah.c[1] = 4;
1468 
  test();
1469 
  assert(myblah.a == 5);
1470 
  assert(myblah.b == 6);
1471 
  assert(myblah.c[0] == 7);
1472 
  assert(myblah.c[1] == 8);
1473 
}
1474 
"""
1475 
)
1476 
 
1477 
test("global variables 1",
1478 
"""
1479 
int a;
1480 
 
1481 
void test(){
1482 
  assert(a==12);
1483 
  a = 24;
1484 
}
1485 
 
1486 
void main(){
1487 
  a = 12;
1488 
  test();
1489 
  assert(a==24);
1490 
}
1491 
 
1492 
"""
1493 
)
1494 
 
1495 
test("global variables 2",
1496 
"""
1497 
int a[10];
1498 
 
1499 
void test(){
1500 
  assert(a[0] == 0);
1501 
  assert(a[1] == 1);
1502 
  assert(a[2] == 2);
1503 
  assert(a[3] == 3);
1504 
  a[0] = 4;
1505 
  a[1] = 5;
1506 
  a[2] = 6;
1507 
  a[3] = 7;
1508 
}
1509 
 
1510 
void main(){
1511 
  a[0] = 0;
1512 
  a[1] = 1;
1513 
  a[2] = 2;
1514 
  a[3] = 3;
1515 
  test();
1516 
  assert(a[0] == 4);
1517 
  assert(a[1] == 5);
1518 
  assert(a[2] == 6);
1519 
  assert(a[3] == 7);
1520 
}
1521 
 
1522 
"""
1523 
)
1524 
 
1525 
test("global variables 3",
1526 
"""
1527 
int a=0, b=1, c=2;
1528 
 
1529 
void test(){
1530 
  assert(a == 3);
1531 
  assert(b == 4);
1532 
  assert(c == 5);
1533 
  a=6;
1534 
  b=7;
1535 
  c=8;
1536 
}
1537 
 
1538 
void main(){
1539 
  assert(a == 0);
1540 
  assert(b == 1);
1541 
  assert(c == 2);
1542 
  a=3;
1543 
  b=4;
1544 
  c=5;
1545 
  test();
1546 
  assert(a == 6);
1547 
  assert(b == 7);
1548 
  assert(c == 8);
1549 
}
1550 
 
1551 
"""
1552 
)
1553 
 
1554 
test("global variables 4",
1555 
"""
1556 
typedef struct {int a; int b; int c;} blah;
1557 
blah myblah;
1558 
 
1559 
void test(){
1560 
  assert(myblah.a == 1);
1561 
  assert(myblah.b == 2);
1562 
  assert(myblah.c == 3);
1563 
  myblah.a = 4;
1564 
  myblah.b = 5;
1565 
  myblah.c = 6;
1566 
}
1567 
 
1568 
void main(){
1569 
  myblah.a = 1;
1570 
  myblah.b = 2;
1571 
  myblah.c = 3;
1572 
  test();
1573 
  assert(myblah.a == 4);
1574 
  assert(myblah.b == 5);
1575 
  assert(myblah.c == 6);
1576 
}
1577 
"""
1578 
)
1579 
 
1580 
test("void functions 1",
1581 
"""
1582 
void main(){
1583 
  int a;
1584 
  int b;
1585 
  b = a;
1586 
}
1587 
 
1588 
"""
1589 
)
1590 
 
1591 
test("void functions 2",
1592 
"""
1593 
void test(){
1594 
  return;
1595 
}
1596 
 
1597 
void main(){
1598 
  test();
1599 
}
1600 
 
1601 
"""
1602 
)
1603 
 
1604 
test_fails("void functions 3",
1605 
"""
1606 
void test(){
1607 
  return;
1608 
}
1609 
 
1610 
void main(){
1611 
  int a;
1612 
  a = test();
1613 
}
1614 
 
1615 
"""
1616 
)
1617 
 
1618 
test_fails("void functions 4",
1619 
"""
1620 
void test(){
1621 
  return 10;
1622 
}
1623 
 
1624 
void main(){
1625 
  int a;
1626 
  a = test();
1627 
}
1628 
 
1629 
"""
1630 
)
1631 
 
1632 
test_fails("type_checking 1",
1633 
"""
1634 
int main(){
1635 
  int a[4];
1636 
  int b;
1637 
  b = a;
1638 
  return 0;
1639 
}
1640 
 
1641 
"""
1642 
)
1643 
 
1644 
test_fails("type_checking 2",
1645 
"""
1646 
int main(){
1647 
  int a[4];
1648 
  int b[4];
1649 
  b[a]=12;
1650 
  return 0;
1651 
}
1652 
 
1653 
"""
1654 
)
1655 
 
1656 
test_fails("type_checking 3",
1657 
"""
1658 
int main(){
1659 
  int a[4];
1660 
  int b;
1661 
  if(a) b=12;
1662 
  return 0;
1663 
}
1664 
 
1665 
"""
1666 
)
1667 
 
1668 
test_fails("type_checking 4",
1669 
"""
1670 
int main(){
1671 
  int a[4];
1672 
  int b;
1673 
  while(a) b=12;
1674 
  return 0;
1675 
}
1676 
 
1677 
"""
1678 
)
1679 
 
1680 
test_fails("type_checking 5",
1681 
"""
1682 
int main(){
1683 
  int a[4];
1684 
  int b;
1685 
  for(;a;) b=12;
1686 
  return 0;
1687 
}
1688 
 
1689 
"""
1690 
)
1691 
 
1692 
test_fails("type_checking 6",
1693 
"""
1694 
int main(){
1695 
  int a[4];
1696 
  int b;
1697 
  switch(a){}
1698 
  return 0;
1699 
}
1700 
 
1701 
"""
1702 
)
1703 
 
1704 
test_fails("type_checking 7",
1705 
"""
1706 
int main(){
1707 
  int a[4];
1708 
  int b;
1709 
  switch(b){case a:b=12;}
1710 
  return 0;
1711 
}
1712 
 
1713 
"""
1714 
)
1715 
 
1716 
test_fails("type_checking 8",
1717 
"""
1718 
int test(int a[]){
1719 
  return 0;
1720 
}
1721 
 
1722 
int main(){
1723 
  int b;
1724 
  test(b);
1725 
  return 0;
1726 
}
1727 
 
1728 
"""
1729 
)
1730 
 
1731 
test_fails("type_checking 9",
1732 
"""
1733 
int test(int a){
1734 
  return 0;
1735 
}
1736 
 
1737 
int main(){
1738 
  int b[4];
1739 
  test(b);
1740 
  return 0;
1741 
}
1742 
 
1743 
"""
1744 
)
1745 
 
1746 
test("array passing 1",
1747 
"""
1748 
 
1749 
int test(int a[]){
1750 
    assert(a[0] == 0);
1751 
    assert(a[1] == 1);
1752 
    assert(a[2] == 2);
1753 
    assert(a[3] == 3);
1754 
    a[0] = 4;
1755 
    a[1] = 5;
1756 
    a[2] = 6;
1757 
    a[3] = 7;
1758 
    return 0;
1759 
}
1760 
 
1761 
int main(){
1762 
  int a[4];
1763 
  a[0] = 0;
1764 
  a[1] = 1;
1765 
  a[2] = 2;
1766 
  a[3] = 3;
1767 
  test(a);
1768 
  assert(a[0] == 4);
1769 
  assert(a[1] == 5);
1770 
  assert(a[2] == 6);
1771 
  assert(a[3] == 7);
1772 
  return 0;
1773 
}
1774 
 
1775 
"""
1776 
)
1777 
 
1778 
test("array passing 2",
1779 
"""
1780 
 
1781 
int test(int a[]){
1782 
    assert(a[0] == 0);
1783 
    assert(a[1] == 1);
1784 
    assert(a[2] == 2);
1785 
    assert(a[3] == 3);
1786 
    a[0] = 4;
1787 
    a[1] = 5;
1788 
    a[2] = 6;
1789 
    a[3] = 7;
1790 
    return 0;
1791 
}
1792 
 
1793 
int main(){
1794 
  int a[4];
1795 
  int b[4];
1796 
  a[0] = 0;
1797 
  a[1] = 1;
1798 
  a[2] = 2;
1799 
  a[3] = 3;
1800 
  b = a;
1801 
  test(b);
1802 
  assert(a[0] == 4);
1803 
  assert(a[1] == 5);
1804 
  assert(a[2] == 6);
1805 
  assert(a[3] == 7);
1806 
  return 0;
1807 
}"""
1808 
)
1809 
 
1810 
test("struct 1",
1811 
"""
1812 
struct blah {int a; int b; int c;};
1813 
int main(){
1814 
  struct blah myblah;
1815 
  myblah.a = 1;
1816 
  myblah.b = 2;
1817 
  myblah.c = 3;
1818 
  assert(myblah.a == 1);
1819 
  assert(myblah.b == 2);
1820 
  assert(myblah.c == 3);
1821 
  return 0;
1822 
}
1823 
"""
1824 
)
1825 
test("struct 2",
1826 
"""
1827 
struct as {int a; int b; int c;};
1828 
int main(){
1829 
  struct as asa;
1830 
  struct as asb;
1831 
  asa.a = 1;
1832 
  asb.a = 3;
1833 
  asa.b = 2;
1834 
  asb.b = 2;
1835 
  asa.c = 3;
1836 
  asb.c = 1;
1837 
  assert(asa.a == 1);
1838 
  assert(asb.a == 3);
1839 
  assert(asa.b == 2);
1840 
  assert(asb.b == 2);
1841 
  assert(asa.c == 3);
1842 
  assert(asb.c == 1);
1843 
  return 0;
1844 
}
1845 
"""
1846 
)
1847 
test("struct 3",
1848 
"""
1849 
typedef struct {int a; int b; int c;} blah;
1850 
int main(){
1851 
  blah myblah;
1852 
  myblah.a = 1;
1853 
  myblah.b = 2;
1854 
  myblah.c = 3;
1855 
  assert(myblah.a == 1);
1856 
  assert(myblah.b == 2);
1857 
  assert(myblah.c == 3);
1858 
  return 0;
1859 
}
1860 
"""
1861 
)
1862 
test("struct 4",
1863 
"""
1864 
typedef struct{int a; int b; int c;} mytype;
1865 
typedef struct{mytype a;} othertype;
1866 
int main(){
1867 
  othertype a;
1868 
  othertype b;
1869 
  a.a.a = 1;
1870 
  b.a.a = 2;
1871 
  a.a.b = 3;
1872 
  b.a.b = 4;
1873 
  a.a.c = 5;
1874 
  b.a.c = 6;
1875 
  assert(a.a.a == 1);
1876 
  assert(b.a.a == 2);
1877 
  assert(a.a.b == 3);
1878 
  assert(b.a.b == 4);
1879 
  assert(a.a.c == 5);
1880 
  assert(b.a.c == 6);
1881 
  return 0;
1882 
}
1883 
"""
1884 
)
1885 
test("include 1",
1886 
"""#include "test_include.c"
1887 
int main(){
1888 
  assert(include_function()==12);
1889 
  return 0;
1890 
}
1891 
"""
1892 
)
1893 
test("switch 1",
1894 
     """int main(){
1895 
        switch(0){
1896 
            case 0: return 3;
1897 
            case 1: return 2;
1898 
            case 2: return 1;
1899 
            default: return 0;
1900 
        }
1901 
     }
1902 
     """
1903 
)
1904 
test("switch 2",
1905 
     """int main(){
1906 
        switch(2){
1907 
            case 0: return 3;
1908 
            case 1: return 2;
1909 
            case 2: return 1;
1910 
            default: return 0;
1911 
        }
1912 
     }
1913 
     """
1914 
)
1915 
test("switch 3",
1916 
     """int main(){
1917 
        switch(5){
1918 
            case 0: return 3;
1919 
            case 1: return 2;
1920 
            case 2: return 1;
1921 
            default: return 0;
1922 
        }
1923 
     }
1924 
     """
1925 
)
1926 
test("switch 4",
1927 
     """int main(){
1928 
        int a = 0;
1929 
        switch(0){
1930 
            case 0: a = 1;
1931 
            case 1: a = 2;
1932 
            case 2: a = 3;
1933 
            default: a = 4;
1934 
        }
1935 
        return a;
1936 
     }
1937 
     """
1938 
)
1939 
test("switch 5",
1940 
     """int main(){
1941 
        int a = 0;
1942 
        switch(1){
1943 
            case 0: a = 1;
1944 
            case 1: a = 2;
1945 
            case 2: a = 3;
1946 
            default: a = 4;
1947 
        }
1948 
        return a;
1949 
     }
1950 
     """
1951 
)
1952 
test("switch 6",
1953 
     """int main(){
1954 
        int a = 1;
1955 
        switch(10){
1956 
            case 0: a = 1;
1957 
            case 1: a = 2;
1958 
            case 2: a = 3;
1959 
            default: a = 4;
1960 
        }
1961 
        return a;
1962 
     }
1963 
     """
1964 
)
1965 
test("switch 7",
1966 
     """int main(){
1967 
        int a = 1;
1968 
        switch(0){
1969 
            case 0: a = 1; break;
1970 
            case 1: a = 2; break;
1971 
            case 2: a = 3; break;
1972 
            default: a = 4; break;
1973 
        }
1974 
        return a;
1975 
     }
1976 
     """
1977 
)
1978 
test("switch 8",
1979 
     """int main(){
1980 
        int a = 1;
1981 
        switch(2){
1982 
            case 0: a = 1; break;
1983 
            case 1: a = 2; break;
1984 
            case 2: a = 3; break;
1985 
            default: a = 4; break;
1986 
        }
1987 
        return a;
1988 
     }
1989 
     """
1990 
)
1991 
test("switch 9",
1992 
"""int main(){
1993 
int a = 1;
1994 
switch(9){
1995 
    case 0: a = 1; break;
1996 
    case 1: a = 2; break;
1997 
    case 2: a = 3; break;
1998 
    default: a = 4; break;
1999 
}
2000 
return a;
2001 
}
2002 
"""
2003 
)
2004 
 
2005 
test("break 0",
2006 
"""
2007 
int main(){
2008 
  int a;
2009 
  while(1){
2010 
    break;
2011 
    assert(0);
2012 
  }
2013 
  return 0;
2014 
}
2015 
""")
2016 
test("break 1",
2017 
"""
2018 
int main(){
2019 
  int a;
2020 
  for(a=0; a<20; a++){
2021 
    if(a == 10){
2022 
      break;
2023 
    }
2024 
  }
2025 
  assert(a == 10);
2026 
  return 0;
2027 
}
2028 
""")
2029 
test("continue 0",
2030 
"""
2031 
int main(){
2032 
  int a;
2033 
  for(a=1; a<=10; a++){
2034 
    if(a <= 5){
2035 
      continue;
2036 
    }
2037 
    assert(a > 5);
2038 
  }
2039 
  return 0;
2040 
}
2041 
""")
2042 
test("ternary 0",
2043 
"""
2044 
int main(){
2045 
  int a;
2046 
  int b=2;
2047 
  int c=3;
2048 
  assert((1?2:3) == 2);
2049 
  assert((0?2:3) == 3);
2050 
  a = 1;
2051 
  assert((a?b:c) == 2);
2052 
  a = 0;
2053 
  assert((a?b:c) == 3);
2054 
  assert((1?b:c) == 2);
2055 
  assert((0?b:c) == 3);
2056 
  return 0;
2057 
}
2058 
""")
2059 
test("inplace 0",
2060 
"""
2061 
int main(){
2062 
  int a = 1;
2063 
  a += 1;
2064 
  assert(a == 2);
2065 
  a -= 1;
2066 
  assert(a == 1);
2067 
  a *= 2;
2068 
  assert(a == 2);
2069 
  a /= 2;
2070 
  assert(a == 1);
2071 
  a |= 2;
2072 
  assert(a == 3);
2073 
  a &= 2;
2074 
  assert(a == 2);
2075 
  a <<= 1;
2076 
  assert(a == 4);
2077 
  a >>= 1;
2078 
  assert(a == 2);
2079 
  return 0;
2080 
}
2081 
""")
2082 
test("inplace 1",
2083 
"""
2084 
int main(){
2085 
  int a[100];
2086 
  a[0] = 1;
2087 
  a[20] = 1;
2088 
  a[20] += 1;
2089 
  assert(a[20] == 2);
2090 
  a[20] -= 1;
2091 
  assert(a[20] == 1);
2092 
  a[20] *= 2;
2093 
  assert(a[20] == 2);
2094 
  a[20] /= 2;
2095 
  assert(a[20] == 1);
2096 
  a[20] |= 2;
2097 
  assert(a[20] == 3);
2098 
  a[20] &= 2;
2099 
  assert(a[20] == 2);
2100 
  a[20] <<= 1;
2101 
  assert(a[20] == 4);
2102 
  a[20] >>= 1;
2103 
  assert(a[20] == 2);
2104 
  assert(a[0] == 1);
2105 
  return 0;
2106 
}
2107 
""")
2108 
test("increment",
2109 
"""
2110 
int main(){
2111 
  int a = 1;
2112 
  a++;
2113 
  assert(a == 2);
2114 
  a--;
2115 
  assert(a == 1);
2116 
  return 0;
2117 
}
2118 
 
2119 
""")
2120 
 
2121 
test("assert 0",
2122 
"""int main(){
2123 
  assert(1);
2124 
  return 0;
2125 
}
2126 
""")
2127 
test_fails("assert 1",
2128 
"""int main(){
2129 
  assert(0);
2130 
  return 0;
2131 
}
2132 
""")
2133 
test("assign",
2134 
"""int main(){
2135 
  int a;
2136 
  int b;
2137 
  int c;
2138 
  a = 10;
2139 
  b = 20;
2140 
  c = a + b;
2141 
  assert(a == 10);
2142 
  assert(b == 20);
2143 
  assert(c == 30);
2144 
  return 0;
2145 
}
2146 
""")
2147 
test("while",
2148 
"""int main(){
2149 
  int a = 10;
2150 
  int b = 0;
2151 
  while(a){
2152 
    a = a - 1;
2153 
    b = b + 1;
2154 
  }
2155 
  assert(b == 10);
2156 
  return 0;
2157 
}
2158 
""")
2159 
test("while 1",
2160 
"""int main(){
2161 
  int a = 0;
2162 
  while(1){
2163 
    a = a + 1;
2164 
    if(a == 10){
2165 
      return 0;
2166 
    }
2167 
  }
2168 
}
2169 
""")
2170 
test("while 2",
2171 
"""int main(){
2172 
  while(0){
2173 
    assert(0);
2174 
  }
2175 
  return 0;
2176 
}
2177 
""")
2178 
test("if",
2179 
"""int main(){
2180 
  int a = 0;
2181 
  int b = 0;
2182 
  if(a){
2183 
    b = 10;
2184 
    assert(0);
2185 
  } else {
2186 
    b = 20;
2187 
  }
2188 
  assert(b == 20);
2189 
  return 0;
2190 
}
2191 
""")
2192 
test("if 1",
2193 
"""int main(){
2194 
  int a = 1;
2195 
  int b = 0;
2196 
  if(a){
2197 
    b = 10;
2198 
  } else {
2199 
    b = 20;
2200 
    assert(0);
2201 
  }
2202 
  assert(b == 10);
2203 
  return 0;
2204 
}
2205 
""")
2206 
test("if 2",
2207 
"""int main(){
2208 
  int b = 0;
2209 
  if(0){
2210 
    b = 10;
2211 
    assert(0);
2212 
  } else {
2213 
    b = 20;
2214 
  }
2215 
  assert(b == 20);
2216 
  return 0;
2217 
}
2218 
""")
2219 
test("if 3",
2220 
"""int main(){
2221 
  int b = 0;
2222 
  if(1){
2223 
    b = 10;
2224 
  } else {
2225 
    b = 20;
2226 
    assert(0);
2227 
  }
2228 
  assert(b == 10);
2229 
  return 0;
2230 
}
2231 
""")
2232 
test("if 4",
2233 
"""int main(){
2234 
  int b = 0;
2235 
  if(0){
2236 
    b = 10;
2237 
    assert(0);
2238 
  }
2239 
  assert(b == 0);
2240 
  return 0;
2241 
}
2242 
""")
2243 
test("for 0",
2244 
"""int main(){
2245 
  int a = 0;
2246 
  int b;
2247 
  int c = 1;
2248 
  for(a=0; a<10; a++){
2249 
   b = b + 1;
2250 
   c = c + 1;
2251 
  }
2252 
  assert(b == 10);
2253 
  assert(c == 11);
2254 
  return 0;
2255 
}
2256 
""")
2257 
test("for 1",
2258 
"""int main(){
2259 
  int a = 0;
2260 
  int b;
2261 
  int c = 1;
2262 
  for(; a<10; a++){
2263 
   b = b + 1;
2264 
   c = c + 1;
2265 
  }
2266 
  assert(b == 10);
2267 
  assert(c == 11);
2268 
  return 0;
2269 
}
2270 
""")
2271 
test("for 2",
2272 
"""int main(){
2273 
  int a = 0;
2274 
  int b;
2275 
  int c = 1;
2276 
  for(;a<10;){
2277 
   b = b + 1;
2278 
   c = c + 1;
2279 
   a++;
2280 
  }
2281 
  assert(b == 10);
2282 
  assert(c == 11);
2283 
  return 0;
2284 
}
2285 
""")
2286 
test("for 3",
2287 
"""int main(){
2288 
  int a = 0;
2289 
  int b;
2290 
  int c = 1;
2291 
  for(;;){
2292 
   if(a>=10) break;
2293 
   b = b + 1;
2294 
   c = c + 1;
2295 
   a++;
2296 
  }
2297 
  assert(b == 10);
2298 
  assert(c == 11);
2299 
  return 0;
2300 
}
2301 
""")
2302 
test("number 0",
2303 
"""int main(){
2304 
  return 1;
2305 
}
2306 
""")
2307 
test("report 0",
2308 
"""int main(){
2309 
  int a = 0;
2310 
  int b = 1;
2311 
  int c = 2;
2312 
  report(a);
2313 
  report(b);
2314 
  report(c);
2315 
  return 0;
2316 
}
2317 
""")
2318 
test("declare 0",
2319 
"""int main(){
2320 
  int a = 10;
2321 
  int b = 20, c = 30;
2322 
  int d[100], e[200];
2323 
  assert(a==10);
2324 
  assert(b==20);
2325 
  assert(c==30);
2326 
  return 0;
2327 
}
2328 
""")
2329 
test("wait_clocks 0",
2330 
"""int main(){
2331 
  int a = 10;
2332 
  wait_clocks(a);
2333 
  wait_clocks(10);
2334 
  return 0;
2335 
}
2336 
""")
2337 
test("function",
2338 
"""
2339 
 
2340 
int func(int a){
2341 
  return a + 10;
2342 
}
2343 
 
2344 
int main(){
2345 
  int a = func(10);
2346 
  assert(a == 20);
2347 
  return 0;
2348 
}
2349 
 
2350 
""")
2351 
test("function 1",
2352 
"""
2353 
 
2354 
int func(int a){
2355 
  assert(a == 20);
2356 
  return 0;
2357 
}
2358 
 
2359 
int main(){
2360 
  func(20);
2361 
  return 0;
2362 
}
2363 
 
2364 
""")
2365 
 
2366 
test("function 2",
2367 
"""
2368 
 
2369 
int func(int a, int b, int c){
2370 
  return a;
2371 
}
2372 
 
2373 
int main(){
2374 
  assert(func(1, 2, 3) == 1);
2375 
  return 0;
2376 
}
2377 
 
2378 
""")
2379 
 
2380 
test("function 3",
2381 
"""
2382 
 
2383 
int func(int a, int b, int c){
2384 
  return b;
2385 
}
2386 
 
2387 
int main(){
2388 
  assert(func(1, 2, 3) == 2);
2389 
  return 0;
2390 
}
2391 
 
2392 
""")
2393 
 
2394 
test("function 4",
2395 
"""
2396 
 
2397 
int func(int a, int b, int c){
2398 
  return c;
2399 
}
2400 
 
2401 
int main(){
2402 
  assert(func(1, 2, 3) == 3);
2403 
  return 0;
2404 
}
2405 
 
2406 
""")
2407 
 
2408 
test("function 5",
2409 
"""
2410 
 
2411 
int another(int a){
2412 
  return a + 1;
2413 
}
2414 
 
2415 
int func(int a){
2416 
  return another(a) + 1;
2417 
}
2418 
 
2419 
int main(){
2420 
  assert(func(0) == 2);
2421 
  return 0;
2422 
}
2423 
 
2424 
""")
2425 
 
2426 
test_fails("function 6",
2427 
"""
2428 
 
2429 
int func(int a, int b){
2430 
  return b;
2431 
}
2432 
 
2433 
int main(){
2434 
  assert(func(1, 2, 3) == 3);
2435 
  return 0;
2436 
}
2437 
 
2438 
""")
2439 
test("expression 1",
2440 
"""
2441 
int main(){
2442 
  int a = 1;
2443 
  int b = 2;
2444 
  int c = 3;
2445 
  assert(a + b + c == 6);
2446 
  return 0;
2447 
}
2448 
 
2449 
""")
2450 
test("expression 2",
2451 
"""
2452 
int main(){
2453 
  int a = 1;
2454 
  int b = 2;
2455 
  int c = 3;
2456 
  assert(a - b - c == -4);
2457 
  return 0;
2458 
}
2459 
 
2460 
""")
2461 
test("expression 3",
2462 
"""
2463 
int main(){
2464 
  int a = 1;
2465 
  int b = 2;
2466 
  int c = 3;
2467 
  assert(a - (b - c) == 2);
2468 
  return 0;
2469 
}
2470 
 
2471 
""")
2472 
test("expression 4",
2473 
"""
2474 
int main(){
2475 
  int a = 1;
2476 
  int b = 2;
2477 
  int c = 3;
2478 
  assert(a * b * c == 6);
2479 
  return 0;
2480 
}
2481 
 
2482 
""")
2483 
test("expression 5",
2484 
"""
2485 
int main(){
2486 
  int a = 1;
2487 
  int b = 2;
2488 
  int c = 3;
2489 
  assert(a/b/c == 0);
2490 
  return 0;
2491 
}
2492 
 
2493 
""")
2494 
test("expression 6",
2495 
"""
2496 
int main(){
2497 
  int a = 1;
2498 
  int b = 2;
2499 
  int c = 3;
2500 
  assert(a%b%c == 1);
2501 
  return 0;
2502 
}
2503 
 
2504 
""")
2505 
test("expression 7",
2506 
"""
2507 
int main(){
2508 
  int a = 1;
2509 
  int b = 2;
2510 
  int c = 3;
2511 
  assert(-a - (b - c) == 0);
2512 
  return 0;
2513 
}
2514 
 
2515 
""")
2516 
test("expression 8",
2517 
"""
2518 
int fail(){
2519 
  assert(0);
2520 
  return 0;
2521 
}
2522 
int main(){
2523 
  int a = 0 && fail();
2524 
  return 0;
2525 
}
2526 
 
2527 
""")
2528 
test("expression 9",
2529 
"""
2530 
int fail(){
2531 
  assert(0);
2532 
  return 0;
2533 
}
2534 
int main(){
2535 
  int a = 1 || fail();
2536 
  return 0;
2537 
}
2538 
 
2539 
""")
2540 
test("expression 10",
2541 
"""
2542 
int main(){
2543 
  int a = 1;
2544 
  assert(a << 2 == 4);
2545 
  return 0;
2546 
}
2547 
 
2548 
""")
2549 
test("expression 11",
2550 
"""
2551 
int main(){
2552 
  int a = 1;
2553 
  int b = 2;
2554 
  assert(a << b == 4);
2555 
  return 0;
2556 
}
2557 
 
2558 
""")
2559 
test("expression 12",
2560 
"""
2561 
int main(){
2562 
  int a = 4;
2563 
  assert(a >> 2 == 1);
2564 
  return 0;
2565 
}
2566 
 
2567 
""")
2568 
test("expression 13",
2569 
"""
2570 
int main(){
2571 
  int a = 4;
2572 
  int b = 2;
2573 
  assert(a >> b == 1);
2574 
  return 0;
2575 
}
2576 
 
2577 
""")
2578 
test("expression 14",
2579 
"""
2580 
int main(){
2581 
  int a = -1;
2582 
  assert(~a == 0);
2583 
  return 0;
2584 
}
2585 
 
2586 
""")
2587 
test("expression 15",
2588 
"""
2589 
int main(){
2590 
  int a = 1;
2591 
  assert(!a == 0);
2592 
  int a = 0;
2593 
  assert(!a == 1);
2594 
  return 0;
2595 
}
2596 
 
2597 
""")
2598 
test("expression 16",
2599 
"""
2600 
int main(){
2601 
  int a = 0xA;
2602 
  int b = 0x5;
2603 
  assert((a | b) == 0xF);
2604 
  assert((a ^ b) == 0xf);
2605 
  assert((a & b) == 0);
2606 
  return 0;
2607 
}
2608 
 
2609 
""")
2610 
test("expression 17",
2611 
"""
2612 
int fail(){
2613 
  assert(0);
2614 
  return 0;
2615 
}
2616 
int main(){
2617 
  int b = 0;
2618 
  int a = b && fail();
2619 
  return 0;
2620 
}
2621 
 
2622 
""")
2623 
test("expression 18",
2624 
"""
2625 
int fail(){
2626 
  assert(0);
2627 
  return 0;
2628 
}
2629 
int main(){
2630 
  assert(~1);
2631 
  return 0;
2632 
}
2633 
 
2634 
""")
2635 
test("expression 19",
2636 
"""
2637 
int main(){
2638 
  assert(-1 < 1);
2639 
  assert(-1 < 0);
2640 
  assert(0 <= 0);
2641 
  assert(0 >= 0);
2642 
  assert(1 >= 0);
2643 
  assert(1 >= -1);
2644 
  assert(1 > -1);
2645 
  assert(1 > 0);
2646 
  assert(12 != 13);
2647 
  assert(100 == 100);
2648 
  return 0;
2649 
}
2650 
 
2651 
""")
2652 
test("expression 20",
2653 
"""
2654 
int main(){
2655 
  int a = -1;
2656 
  assert(a >> 2 == -1);
2657 
  return 0;
2658 
}
2659 
 
2660 
""")
2661 
test("comment 0",
2662 
"""
2663 
int main(){
2664 
  //assert(0);
2665 
  //assert(0);
2666 
  //assert(0);
2667 
  return 0;
2668 
}
2669 
 
2670 
""")
2671 
test("comment 1",
2672 
"""
2673 
int main(){
2674 
  /*assert(0);
2675 
  assert(0);
2676 
  assert(0);*/
2677 
  return 0;
2678 
}
2679 
 
2680 
""")
2681 
test("array 0",
2682 
"""
2683 
int main(){
2684 
  int a [1024];
2685 
  int b [1024];
2686 
  a[0] = 1;
2687 
  a[1] = 2;
2688 
  a[3] = 3;
2689 
  assert(a[0] == 1);
2690 
  assert(a[1] == 2);
2691 
  assert(a[3] == 3);
2692 
  return 0;
2693 
}
2694 
 
2695 
""")
2696 
 
2697 
test("array 1",
2698 
"""
2699 
int main(){
2700 
  int a [1024];
2701 
  int b [1024];
2702 
  a[0] = 10;
2703 
  b[0] = 20;
2704 
  a[1] = 30;
2705 
  b[1] = 40;
2706 
  a[3] = 50;
2707 
  b[3] = 60;
2708 
  assert(a[0] == 10);
2709 
  assert(b[0] == 20);
2710 
  assert(a[1] == 30);
2711 
  assert(b[1] == 40);
2712 
  assert(a[3] == 50);
2713 
  assert(b[3] == 60);
2714 
  return 0;
2715 
}
2716 
 
2717 
""")
2718 
 
2719 
test_fails("error 0",
2720 
"""
2721 
int main(){
2722 
  int a;
2723 
  a = c;
2724 
  return 0;
2725 
}
2726 
 
2727 
""")
2728 
 
2729 
test_fails("error 1",
2730 
"""
2731 
int main(){
2732 
  int a;
2733 
}
2734 
 
2735 
""")
2736 
 
2737 
test_fails("error 2",
2738 
"""
2739 
int main(){
2740 
  int a blah;
2741 
}
2742 
 
2743 
""")
2744 
 
2745 
test_fails("error 3",
2746 
"""
2747 
int main(){
2748 
  int a;
2749 
  b = a;
2750 
}
2751 
 
2752 
""")
2753 
 
2754 
test_fails("error 4",
2755 
"""
2756 
int main(){
2757 
  int a;
2758 
  a = c();
2759 
}
2760 
 
2761 
""")
2762 
 
2763 
test_fails("error 5",
2764 
"""
2765 
int main(){
2766 
  int a;
2767 
  a==;
2768 
}
2769 
 
2770 
""")
2771 
test_fails("error 6",
2772 
"""
2773 
int main(){
2774 
  int a;
2775 
  a=00x;
2776 
}
2777 
 
2778 
""")
2779 
test_fails("error 7",
2780 
"""
2781 
int main(){
2782 
  switch(1){
2783 
    case 0:
2784 
    default:
2785 
    default:
2786 
  }
2787 
  return 0;
2788 
}
2789 
""")
2790 
test_fails("error 8",
2791 
"""
2792 
int main(){
2793 
  default:
2794 
  return 0;
2795 
}
2796 
""")
2797 
test_fails("error 9",
2798 
"""
2799 
int main(){
2800 
  case 1:
2801 
  return 0;
2802 
}
2803 
""")
2804 
test_fails("error 10",
2805 
"""
2806 
int main(){
2807 
  int a = 12;
2808 
  switch(a){
2809 
    case a + 1:
2810 
    a++;
2811 
  }
2812 
  return 0;
2813 
}
2814 
""")
2815 
test_fails("error 11",
2816 
"""
2817 
int myfunction(){
2818 
  return 0;
2819 
}
2820 
int main(){
2821 
  int a = 12;
2822 
  myfunction()=10;
2823 
  return 0;
2824 
}
2825 
""")
2826 
test("input 1",
2827 
"""
2828 
int main(){
2829 
  int b;
2830 
  b = input_a();
2831 
  return 0;
2832 
}
2833 
 
2834 
""")
2835 
 
2836 
test("output 1",
2837 
"""
2838 
int main(){
2839 
   output_a(12);
2840 
  return 0;
2841 
}
2842 
 
2843 
""")
2844 
 
2845 
test("input output 1",
2846 
"""
2847 
int main(){
2848 
  if (input_select()){
2849 
    output_z(input_a());
2850 
  } else {
2851 
    output_z(input_b());
2852 
  }
2853 
  return 0;
2854 
}
2855 
 
2856 
""")
2857 
 
2858 
test("input output 2",
2859 
"""
2860 
int arbiter(){
2861 
  while(1){
2862 
    if(ready_a()) output_z(input_a());
2863 
    if(ready_b()) output_z(input_b());
2864 
  }
2865 
  return 0;
2866 
}
2867 
 
2868 
""")
2869 
 
2870 
test("main not main",
2871 
"""
2872 
int main(){
2873 
  assert(0);
2874 
  return 0;
2875 
}
2876 
 
2877 
//last function is always main
2878 
int real_main(){
2879 
  return 0;
2880 
}
2881 
""")
2882 
 
2883 
os.system("python-coverage run -p c2verilog.py")
2884 
os.system("python-coverage combine")
2885 
os.system("python-coverage report")
2886 
os.system("python-coverage annotate c2verilog.py")
2887 
os.system("python-coverage annotate compiler/parser.py")

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.