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