authorgravatar for liljaanton2001@gmail.comantlilja <liljaanton2001@gmail.com> 2023-07-18 01:52:14+02:00
committergravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2023-09-27 11:24:36-07:00
logfcdb7d9e4706179f65aa7e206f1d99c61724d722
tree5e39692586b09f7d9fda89037bf448b9fa614e07
parent15cc008bf8fed09379cca1b51c177a4ebcd7fe72

Add behavior tests for `@abs` builtin

2 files changed, 372 insertions(+), 0 deletions(-)

test/behavior.zig+1
......@@ -237,6 +237,7 @@ test {
237237 _ = @import("behavior/void.zig");
238238 _ = @import("behavior/while.zig");
239239 _ = @import("behavior/widening.zig");
240 _ = @import("behavior/abs.zig");
240241
241242 if (builtin.cpu.arch == .wasm32) {
242243 _ = @import("behavior/wasm.zig");
test/behavior/abs.zig created+371
......@@ -0,0 +1,371 @@
1const builtin = @import("builtin");
2const std = @import("std");
3const expect = std.testing.expect;
4
5test "@abs integers" {
6 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
7 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
8 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
9 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
10 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
11
12 try comptime testAbsIntegers();
13 try testAbsIntegers();
14}
15
16fn testAbsIntegers() !void {
17 {
18 var x: i32 = -1000;
19 try expect(@abs(x) == 1000);
20 }
21 {
22 var x: i32 = 0;
23 try expect(@abs(x) == 0);
24 }
25 {
26 var x: i32 = 1000;
27 try expect(@abs(x) == 1000);
28 }
29 {
30 var x: i64 = std.math.minInt(i64);
31 try expect(@abs(x) == @as(u64, -std.math.minInt(i64)));
32 }
33 {
34 var x: i5 = -1;
35 try expect(@abs(x) == 1);
36 }
37 {
38 var x: i5 = -5;
39 try expect(@abs(x) == 5);
40 }
41 comptime {
42 try expect(@abs(@as(i2, -2)) == 2);
43 }
44}
45
46test "@abs unsigned integers" {
47 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
48 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
49 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
50 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
51 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
52
53 try comptime testAbsUnsignedIntegers();
54 try testAbsUnsignedIntegers();
55}
56
57fn testAbsUnsignedIntegers() !void {
58 {
59 var x: u32 = 1000;
60 try expect(@abs(x) == 1000);
61 }
62 {
63 var x: u32 = 0;
64 try expect(@abs(x) == 0);
65 }
66 {
67 var x: u32 = 1000;
68 try expect(@abs(x) == 1000);
69 }
70 {
71 var x: u5 = 1;
72 try expect(@abs(x) == 1);
73 }
74 {
75 var x: u5 = 5;
76 try expect(@abs(x) == 5);
77 }
78 comptime {
79 try expect(@abs(@as(u2, 2)) == 2);
80 }
81}
82
83test "@abs floats" {
84 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
85 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
86 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
87 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
88 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
89
90 try comptime testAbsFloats(f16);
91 if (builtin.zig_backend != .stage2_x86_64) try testAbsFloats(f16);
92 try comptime testAbsFloats(f32);
93 try testAbsFloats(f32);
94 try comptime testAbsFloats(f64);
95 try testAbsFloats(f64);
96 try comptime testAbsFloats(f80);
97 if (builtin.zig_backend != .stage2_x86_64 and builtin.zig_backend != .stage2_wasm) try testAbsFloats(f80);
98 try comptime testAbsFloats(f128);
99 if (builtin.zig_backend != .stage2_x86_64 and builtin.zig_backend != .stage2_wasm) try testAbsFloats(f128);
100}
101
102fn testAbsFloats(comptime T: type) !void {
103 {
104 var x: T = -2.62;
105 try expect(@abs(x) == 2.62);
106 }
107 {
108 var x: T = 2.62;
109 try expect(@abs(x) == 2.62);
110 }
111 {
112 var x: T = 0.0;
113 try expect(@abs(x) == 0.0);
114 }
115 {
116 var x: T = -std.math.pi;
117 try expect(@abs(x) == std.math.pi);
118 }
119
120 {
121 var x: T = -std.math.inf(T);
122 try expect(@abs(x) == std.math.inf(T));
123 }
124 {
125 var x: T = std.math.inf(T);
126 try expect(@abs(x) == std.math.inf(T));
127 }
128 comptime {
129 try expect(@abs(@as(T, -std.math.e)) == std.math.e);
130 }
131}
132
133test "@abs int vectors" {
134 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
135 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
136 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
137 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
138 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
139 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
140 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
141 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
142
143 try comptime testAbsIntVectors(1);
144 try testAbsIntVectors(1);
145 try comptime testAbsIntVectors(2);
146 try testAbsIntVectors(2);
147 try comptime testAbsIntVectors(3);
148 try testAbsIntVectors(3);
149 try comptime testAbsIntVectors(4);
150 try testAbsIntVectors(4);
151 try comptime testAbsIntVectors(8);
152 try testAbsIntVectors(8);
153 try comptime testAbsIntVectors(16);
154 try testAbsIntVectors(16);
155 try comptime testAbsIntVectors(17);
156 try testAbsIntVectors(17);
157}
158
159fn testAbsIntVectors(comptime len: comptime_int) !void {
160 const I32 = @Vector(len, i32);
161 const U32 = @Vector(len, u32);
162 const I64 = @Vector(len, i64);
163 const U64 = @Vector(len, u64);
164 {
165 var x: I32 = @splat(-10);
166 var y: U32 = @splat(10);
167 try expect(std.mem.eql(u32, &@as([len]u32, y), &@as([len]u32, @abs(x))));
168 }
169 {
170 var x: I32 = @splat(10);
171 var y: U32 = @splat(10);
172 try expect(std.mem.eql(u32, &@as([len]u32, y), &@as([len]u32, @abs(x))));
173 }
174 {
175 var x: I32 = @splat(0);
176 var y: U32 = @splat(0);
177 try expect(std.mem.eql(u32, &@as([len]u32, y), &@as([len]u32, @abs(x))));
178 }
179 {
180 var x: I64 = @splat(-10);
181 var y: U64 = @splat(10);
182 try expect(std.mem.eql(u64, &@as([len]u64, y), &@as([len]u64, @abs(x))));
183 }
184 {
185 var x: I64 = @splat(std.math.minInt(i64));
186 var y: U64 = @splat(-std.math.minInt(i64));
187 try expect(std.mem.eql(u64, &@as([len]u64, y), &@as([len]u64, @abs(x))));
188 }
189 {
190 var x = std.simd.repeat(len, @Vector(4, i32){ -2, 5, std.math.minInt(i32), -7 });
191 var y = std.simd.repeat(len, @Vector(4, u32){ 2, 5, -std.math.minInt(i32), 7 });
192 try expect(std.mem.eql(u32, &@as([len]u32, y), &@as([len]u32, @abs(x))));
193 }
194}
195
196test "@abs unsigned int vectors" {
197 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
198 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
199 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
200 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
201 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
202 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
203 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
204 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
205
206 try comptime testAbsUnsignedIntVectors(1);
207 try testAbsUnsignedIntVectors(1);
208 try comptime testAbsUnsignedIntVectors(2);
209 try testAbsUnsignedIntVectors(2);
210 try comptime testAbsUnsignedIntVectors(3);
211 try testAbsUnsignedIntVectors(3);
212 try comptime testAbsUnsignedIntVectors(4);
213 try testAbsUnsignedIntVectors(4);
214 try comptime testAbsUnsignedIntVectors(8);
215 try testAbsUnsignedIntVectors(8);
216 try comptime testAbsUnsignedIntVectors(16);
217 try testAbsUnsignedIntVectors(16);
218 try comptime testAbsUnsignedIntVectors(17);
219 try testAbsUnsignedIntVectors(17);
220}
221
222fn testAbsUnsignedIntVectors(comptime len: comptime_int) !void {
223 const U32 = @Vector(len, u32);
224 const U64 = @Vector(len, u64);
225 {
226 var x: U32 = @splat(10);
227 var y: U32 = @splat(10);
228 try expect(std.mem.eql(u32, &@as([len]u32, y), &@as([len]u32, @abs(x))));
229 }
230 {
231 var x: U32 = @splat(10);
232 var y: U32 = @splat(10);
233 try expect(std.mem.eql(u32, &@as([len]u32, y), &@as([len]u32, @abs(x))));
234 }
235 {
236 var x: U32 = @splat(0);
237 var y: U32 = @splat(0);
238 try expect(std.mem.eql(u32, &@as([len]u32, y), &@as([len]u32, @abs(x))));
239 }
240 {
241 var x: U64 = @splat(10);
242 var y: U64 = @splat(10);
243 try expect(std.mem.eql(u64, &@as([len]u64, y), &@as([len]u64, @abs(x))));
244 }
245 {
246 var x = std.simd.repeat(len, @Vector(3, u32){ 2, 5, 7 });
247 var y = std.simd.repeat(len, @Vector(3, u32){ 2, 5, 7 });
248 try expect(std.mem.eql(u32, &@as([len]u32, y), &@as([len]u32, @abs(x))));
249 }
250}
251
252test "@abs float vectors" {
253 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
254 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
255 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
256 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
257 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
258 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
259 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
260 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
261
262 // https://github.com/ziglang/zig/issues/12827
263 if (builtin.zig_backend == .stage2_llvm and
264 builtin.os.tag == .macos and
265 builtin.target.cpu.arch == .x86_64) return error.SkipZigTest;
266
267 @setEvalBranchQuota(2000);
268 try comptime testAbsFloatVectors(f16, 1);
269 try testAbsFloatVectors(f16, 1);
270 try comptime testAbsFloatVectors(f16, 2);
271 try testAbsFloatVectors(f16, 2);
272 try comptime testAbsFloatVectors(f16, 3);
273 try testAbsFloatVectors(f16, 3);
274 try comptime testAbsFloatVectors(f16, 4);
275 try testAbsFloatVectors(f16, 4);
276 try comptime testAbsFloatVectors(f16, 8);
277 try testAbsFloatVectors(f16, 8);
278 try comptime testAbsFloatVectors(f16, 16);
279 try testAbsFloatVectors(f16, 16);
280 try comptime testAbsFloatVectors(f16, 17);
281
282 try testAbsFloatVectors(f32, 17);
283 try comptime testAbsFloatVectors(f32, 1);
284 try testAbsFloatVectors(f32, 1);
285 try comptime testAbsFloatVectors(f32, 2);
286 try testAbsFloatVectors(f32, 2);
287 try comptime testAbsFloatVectors(f32, 3);
288 try testAbsFloatVectors(f32, 3);
289 try comptime testAbsFloatVectors(f32, 4);
290 try testAbsFloatVectors(f32, 4);
291 try comptime testAbsFloatVectors(f32, 8);
292 try testAbsFloatVectors(f32, 8);
293 try comptime testAbsFloatVectors(f32, 16);
294 try testAbsFloatVectors(f32, 16);
295 try comptime testAbsFloatVectors(f32, 17);
296 try testAbsFloatVectors(f32, 17);
297
298 try comptime testAbsFloatVectors(f64, 1);
299 try testAbsFloatVectors(f64, 1);
300 try comptime testAbsFloatVectors(f64, 2);
301 try testAbsFloatVectors(f64, 2);
302 try comptime testAbsFloatVectors(f64, 3);
303 try testAbsFloatVectors(f64, 3);
304 try comptime testAbsFloatVectors(f64, 4);
305 try testAbsFloatVectors(f64, 4);
306 try comptime testAbsFloatVectors(f64, 8);
307 try testAbsFloatVectors(f64, 8);
308 try comptime testAbsFloatVectors(f64, 16);
309 try testAbsFloatVectors(f64, 16);
310 try comptime testAbsFloatVectors(f64, 17);
311 try testAbsFloatVectors(f64, 17);
312
313 try comptime testAbsFloatVectors(f80, 1);
314 try testAbsFloatVectors(f80, 1);
315 try comptime testAbsFloatVectors(f80, 2);
316 try testAbsFloatVectors(f80, 2);
317 try comptime testAbsFloatVectors(f80, 3);
318 try testAbsFloatVectors(f80, 3);
319 try comptime testAbsFloatVectors(f80, 4);
320 try testAbsFloatVectors(f80, 4);
321 try comptime testAbsFloatVectors(f80, 8);
322 try testAbsFloatVectors(f80, 8);
323 try comptime testAbsFloatVectors(f80, 16);
324 try testAbsFloatVectors(f80, 16);
325 try comptime testAbsFloatVectors(f80, 17);
326 try testAbsFloatVectors(f80, 17);
327
328 try comptime testAbsFloatVectors(f128, 1);
329 try testAbsFloatVectors(f128, 1);
330 try comptime testAbsFloatVectors(f128, 2);
331 try testAbsFloatVectors(f128, 2);
332 try comptime testAbsFloatVectors(f128, 3);
333 try testAbsFloatVectors(f128, 3);
334 try comptime testAbsFloatVectors(f128, 4);
335 try testAbsFloatVectors(f128, 4);
336 try comptime testAbsFloatVectors(f128, 8);
337 try testAbsFloatVectors(f128, 8);
338 try comptime testAbsFloatVectors(f128, 16);
339 try testAbsFloatVectors(f128, 16);
340 try comptime testAbsFloatVectors(f128, 17);
341 try testAbsFloatVectors(f128, 17);
342}
343
344fn testAbsFloatVectors(comptime T: type, comptime len: comptime_int) !void {
345 const V = @Vector(len, T);
346 {
347 var x: V = @splat(-7.5);
348 var y: V = @splat(7.5);
349 try expect(std.mem.eql(T, &@as([len]T, y), &@as([len]T, @abs(x))));
350 }
351 {
352 var x: V = @splat(7.5);
353 var y: V = @splat(7.5);
354 try expect(std.mem.eql(T, &@as([len]T, y), &@as([len]T, @abs(x))));
355 }
356 {
357 var x: V = @splat(0.0);
358 var y: V = @splat(0.0);
359 try expect(std.mem.eql(T, &@as([len]T, y), &@as([len]T, @abs(x))));
360 }
361 {
362 var x: V = @splat(-std.math.pi);
363 var y: V = @splat(std.math.pi);
364 try expect(std.mem.eql(T, &@as([len]T, y), &@as([len]T, @abs(x))));
365 }
366 {
367 var x: V = @splat(std.math.pi);
368 var y: V = @splat(std.math.pi);
369 try expect(std.mem.eql(T, &@as([len]T, y), &@as([len]T, @abs(x))));
370 }
371}