1 /* test66: test a whole bunch of basic comparisons. 2 * 3 * this test can be used both to generate test cases and run the test 4 * case. all the results to be computed are in myresults[] on each iteration. 5 * invoke the test with an argument, e.g. "./test66 gen" to generate 6 * test66expected.h. then recompile, and run the result. so all you 7 * have to do to add a (integer-valued) test expression as a function 8 * of an int, float or double, is increase SUBRESULTS, add the expression 9 * to myresults[], and regenerate the desired results file. 10 */ 11 12 #include <stdio.h> 13 #include <assert.h> 14 15 int max_error = 10; 16 #include "common.h" 17 18 19 20 #define RESULTSNAME desired 21 #define SUBRESULTS 131 22 23 int desired[][SUBRESULTS] = { 24 #include "test66expected.h" 25 }; 26 27 #define CASES (sizeof(desired)/sizeof(desired[0])) 28 29 int main(int argc, char *argv[]) 30 { 31 int a, b; 32 int gen = 0; 33 int n = 0; 34 35 if(argc != 1) gen = 1; 36 else start(66); 37 38 for(a = -10; a < 10; a++) { 39 for(b = -10; b < 10; b++) { 40 float fa = a/4.0, fb = b/4.0; 41 double da = a/4.0, db = b/4.0; 42 signed long long a64s = a, b64s = b, ds, ms; 43 unsigned long long a64u = a, b64u = b, mu; 44 signed long a32s = a, b32s = b, ds32, ms32; 45 unsigned long a32u = a, b32u = b, mu32; 46 47 /* indicate no result */ 48 mu32 = ds32 = ms32 = mu = ds = ms = 31337; 49 50 if(b64s != 0) { 51 /* some 64-bit arithmetic */ 52 ds = a64s/b64s; ms = a64s%b64s; 53 mu = a64u%b64u; 54 ds32 = a32s/b32s; ms32 = a32s%b32s; 55 mu32 = a32u%b32u; 56 } 57 58 int myresults[SUBRESULTS] = { 59 /* these results lots of combinations of float, double, int 60 * and signed and unsigned 64-bit comparisons (and therefore 61 * also conversions). 62 */ 63 a < b, a <= b, a == b, a >= b, a > b, a < fb, a <= fb, a == fb, 64 a >= fb, a > fb, a < db, a <= db, a == db, a >= db, a > db, a < b64s, 65 a <= b64s, a == b64s, a >= b64s, a > b64s, a < b64u, a <= b64u, a == b64u, 66 a >= b64u, a > b64u, fa < b, fa <= b, fa == b, fa >= b, fa > b, fa < fb, 67 fa <= fb, fa == fb, fa >= fb, fa > fb, fa < db, fa <= db, fa == db, 68 fa >= db, fa > db, fa < b64s, fa <= b64s, fa == b64s, fa >= b64s, 69 fa > b64s, fa < b64u, fa <= b64u, fa == b64u, fa >= b64u, fa > b64u, 70 da < b, da <= b, da == b, da >= b, da > b, da < fb, da <= fb, da == fb, 71 da >= fb, da > fb, da < db, da <= db, da == db, da >= db, da > db, 72 da < b64s, da <= b64s, da == b64s, da >= b64s, da > b64s, da < b64u, 73 da <= b64u, da == b64u, da >= b64u, da > b64u, a64s < b, a64s <= b, a64s == b, 74 a64s >= b, a64s > b, a64s < fb, a64s <= fb, a64s == fb, a64s >= fb, 75 a64s > fb, a64s < db, a64s <= db, a64s == db, a64s >= db, a64s > db, 76 a64s < b64s, a64s <= b64s, a64s == b64s, a64s >= b64s, a64s > b64s, 77 a64s < b64u, a64s <= b64u, a64s == b64u, a64s >= b64u, a64s > b64u, a64u < b, 78 a64u <= b, a64u == b, a64u >= b, a64u > b, a64u < fb, a64u <= fb, 79 a64u == fb, a64u >= fb, a64u > fb, a64u < db, a64u <= db, a64u == db, 80 a64u >= db, a64u > db, a64u < b64s, a64u <= b64s, a64u == b64s, 81 a64u >= b64s, a64u > b64s, a64u < b64u, a64u <= b64u, a64u == b64u, 82 a64u >= b64u, a64u > b64u, 83 84 /* 64-bit divison, modulo operations */ 85 (int) ds, (int) ms, (int) mu, 86 87 /* 32-bit divison, modulo operations */ 88 (int) ds32, (int) ms32, (int) mu32 89 90 }; 91 92 if(gen) { 93 int r; 94 printf("{ "); 95 for(r = 0; r < SUBRESULTS; r++) { 96 printf("%d, ", myresults[r]); 97 } 98 printf(" }, \n"); 99 } else { 100 int subresults; 101 int s; 102 subresults = sizeof(desired[n])/ 103 sizeof(desired[n][0]); 104 assert(subresults == SUBRESULTS); 105 for(s = 0; s < subresults; s++) { 106 if(desired[n][s] != myresults[s]) { 107 printf("a, b = %d, %d: %d != %d\n", 108 a, b, desired[n][s], 109 myresults[s]); 110 e(n); 111 } else { 112 assert(desired[n][s] == myresults[s]); 113 } 114 } 115 } 116 117 n++; 118 } 119 } 120 121 if(!gen) { 122 assert(n == CASES); 123 quit(); 124 } 125 126 return 0; 127 } 128 129