From 0a4f58490f518a8d139a7c69773276bcc2441825 Mon Sep 17 00:00:00 2001 From: Andrew Kelley Date: Thu, 3 Mar 2022 01:23:50 -0700 Subject: [PATCH] behavior tests cleanup: promote math.zig --- test/behavior.zig | 2 +- test/behavior/math.zig | 196 +++++++++++++++++++++++++++++++++++++---- 2 files changed, 182 insertions(+), 16 deletions(-) diff --git a/test/behavior.zig b/test/behavior.zig index 85023a7469..7be45e638c 100644 --- a/test/behavior.zig +++ b/test/behavior.zig @@ -65,6 +65,7 @@ test { _ = @import("behavior/int_div.zig"); _ = @import("behavior/inttoptr.zig"); _ = @import("behavior/ir_block_deps.zig"); + _ = @import("behavior/math.zig"); _ = @import("behavior/member_func.zig"); _ = @import("behavior/muladd.zig"); _ = @import("behavior/namespace_depends_on_compile_var.zig"); @@ -117,7 +118,6 @@ test { if (builtin.zig_backend != .stage2_c) { // Tests that pass for stage1 and the llvm backend. _ = @import("behavior/atomics.zig"); - _ = @import("behavior/math.zig"); _ = @import("behavior/maximum_minimum.zig"); _ = @import("behavior/popcount.zig"); _ = @import("behavior/saturating_arithmetic.zig"); diff --git a/test/behavior/math.zig b/test/behavior/math.zig index 597d004262..13a6f59cba 100644 --- a/test/behavior/math.zig +++ b/test/behavior/math.zig @@ -9,6 +9,10 @@ const mem = std.mem; const has_f80_rt = builtin.cpu.arch == .x86_64; test "assignment operators" { + if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO + var i: u32 = 0; i += 5; try expect(i == 5); @@ -57,6 +61,12 @@ fn assertFalse(b: bool) !void { } test "@clz" { + if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO + try testClz(); comptime try testClz(); } @@ -75,6 +85,12 @@ fn testOneClz(comptime T: type, x: T) u32 { } test "@clz vectors" { + if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO + try testClzVectors(); comptime try testClzVectors(); } @@ -110,6 +126,12 @@ fn expectVectorsEqual(a: anytype, b: anytype) !void { } test "@ctz" { + if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO + try testCtz(); comptime try testCtz(); } @@ -126,6 +148,12 @@ fn testOneCtz(comptime T: type, x: T) u32 { } test "@ctz vectors" { + if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .aarch64) { // TODO this is tripping an LLVM assert: // zig: /home/andy/Downloads/llvm-project-13/llvm/lib/CodeGen/GlobalISel/LegalizerInfo.cpp:198: llvm::LegalizeActionStep llvm::LegalizeRuleSet::apply(const llvm::LegalityQuery&) const: Assertion `mutationIsSane(Rule, Query, Mutation) && "legality mutation invalid for match"' failed. @@ -163,6 +191,11 @@ test "const number literal" { const ten = 10; test "float equality" { + if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO + const x: f64 = 0.012; const y: f64 = x + 1.0; @@ -179,6 +212,15 @@ test "hex float literal parsing" { comptime try expect(0x1.0 == 1.0); } +test "hex float literal within range" { + const a = 0x1.0p16383; + const b = 0x0.1p16387; + const c = 0x1.0p-16382; + _ = a; + _ = b; + _ = c; +} + test "quad hex float literal parsing in range" { const a = 0x1.af23456789bbaaab347645365cdep+5; const b = 0x1.dedafcff354b6ae9758763545432p-9; @@ -218,15 +260,6 @@ test "underscore separator parsing" { try expect(0x1_2_3_4_5_6_7_8.9_A_B_C_D_E_F_0p-0_0_0_1_0 == 0x12345678.9ABCDEF0p-10); } -test "hex float literal within range" { - const a = 0x1.0p16383; - const b = 0x0.1p16387; - const c = 0x1.0p-16382; - _ = a; - _ = b; - _ = c; -} - test "comptime_int addition" { comptime { try expect(35361831660712422535336160538497375248 + 101752735581729509668353361206450473702 == 137114567242441932203689521744947848950); @@ -277,6 +310,11 @@ test "comptime_int multi-limb partial shift right" { } test "xor" { + if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO + try test_xor(); comptime try test_xor(); } @@ -319,6 +357,11 @@ fn comptimeAdd(comptime a: comptime_int, comptime b: comptime_int) comptime_int } test "binary not" { + if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO + try expect(comptime x: { break :x ~@as(u16, 0b1010101010101010) == 0b0101010101010101; }); @@ -333,6 +376,12 @@ fn testBinaryNot(x: u16) !void { } test "division" { + if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO + try testDivision(); comptime try testDivision(); } @@ -427,6 +476,10 @@ fn mod(comptime T: type, a: T, b: T) T { } test "unsigned wrapping" { + if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO + try testUnsignedWrappingEval(maxInt(u32)); comptime try testUnsignedWrappingEval(maxInt(u32)); } @@ -438,6 +491,10 @@ fn testUnsignedWrappingEval(x: u32) !void { } test "signed wrapping" { + if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO + try testSignedWrappingEval(maxInt(i32)); comptime try testSignedWrappingEval(maxInt(i32)); } @@ -449,6 +506,10 @@ fn testSignedWrappingEval(x: i32) !void { } test "signed negation wrapping" { + if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO + try testSignedNegationWrappingEval(minInt(i16)); comptime try testSignedNegationWrappingEval(minInt(i16)); } @@ -459,6 +520,10 @@ fn testSignedNegationWrappingEval(x: i16) !void { } test "unsigned negation wrapping" { + if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO + try testUnsignedNegationWrappingEval(1); comptime try testUnsignedNegationWrappingEval(1); } @@ -469,6 +534,9 @@ fn testUnsignedNegationWrappingEval(x: u16) !void { } test "unsigned 64-bit division" { + if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO + try test_u64_div(); comptime try test_u64_div(); } @@ -495,6 +563,10 @@ test "bit shift a u1" { } test "truncating shift right" { + if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO + try testShrTrunc(maxInt(u16)); comptime try testShrTrunc(maxInt(u16)); } @@ -504,6 +576,12 @@ fn testShrTrunc(x: u16) !void { } test "f128" { + if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO + try test_f128(); comptime try test_f128(); } @@ -527,6 +605,12 @@ fn should_not_be_zero(x: f128) !void { } test "128-bit multiplication" { + if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO + var a: i128 = 3; var b: i128 = 2; var c = a * b; @@ -534,6 +618,12 @@ test "128-bit multiplication" { } test "@addWithOverflow" { + if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO + var result: u8 = undefined; try expect(@addWithOverflow(u8, 250, 100, &result)); try expect(result == 94); @@ -550,6 +640,12 @@ test "@addWithOverflow" { } test "small int addition" { + if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO + var x: u2 = 0; try expect(x == 0); @@ -569,6 +665,12 @@ test "small int addition" { } test "@mulWithOverflow" { + if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO + var result: u8 = undefined; try expect(@mulWithOverflow(u8, 86, 3, &result)); try expect(result == 2); @@ -585,6 +687,12 @@ test "@mulWithOverflow" { } test "@subWithOverflow" { + if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO + var result: u8 = undefined; try expect(@subWithOverflow(u8, 1, 2, &result)); try expect(result == 255); @@ -601,6 +709,12 @@ test "@subWithOverflow" { } test "@shlWithOverflow" { + if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO + var result: u16 = undefined; try expect(@shlWithOverflow(u16, 0b0010111111111111, 3, &result)); try expect(result == 0b0111111111111000); @@ -617,6 +731,12 @@ test "@shlWithOverflow" { } test "overflow arithmetic with u0 values" { + if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO + var result: u0 = undefined; try expect(!@addWithOverflow(u0, 0, 0, &result)); try expect(result == 0); @@ -629,6 +749,8 @@ test "overflow arithmetic with u0 values" { } test "allow signed integer division/remainder when values are comptime known and positive or exact" { + if (builtin.zig_backend == .stage1) return error.SkipZigTest; + try expect(5 / 3 == 1); try expect(-5 / -3 == 1); try expect(-6 / 3 == -2); @@ -636,15 +758,19 @@ test "allow signed integer division/remainder when values are comptime known and try expect(5 % 3 == 2); try expect(-6 % 3 == 0); - if (builtin.zig_backend != .stage1) { - var undef: i32 = undefined; - if (0 % undef != 0) { - @compileError("0 as numerator should return comptime zero independent of denominator"); - } + var undef: i32 = undefined; + if (0 % undef != 0) { + @compileError("0 as numerator should return comptime zero independent of denominator"); } } test "quad hex float literal parsing accurate" { + if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO + const a: f128 = 0x1.1111222233334444555566667777p+0; // implied 1 is dropped, with an exponent of 0 (0x3fff) after biasing. @@ -735,6 +861,10 @@ test "quad hex float literal parsing accurate" { } test "truncating shift left" { + if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO + try testShlTrunc(maxInt(u16)); comptime try testShlTrunc(maxInt(u16)); } @@ -744,6 +874,10 @@ fn testShlTrunc(x: u16) !void { } test "exact shift left" { + if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO + try testShlExact(0b00110101); comptime try testShlExact(0b00110101); } @@ -753,6 +887,10 @@ fn testShlExact(x: u8) !void { } test "exact shift right" { + if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO + try testShrExact(0b10110100); comptime try testShrExact(0b10110100); } @@ -762,6 +900,10 @@ fn testShrExact(x: u8) !void { } test "shift left/right on u0 operand" { + if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO + const S = struct { fn doTheTest() !void { var x: u0 = 0; @@ -803,6 +945,12 @@ fn remdiv(comptime T: type) !void { } test "float remainder division using @rem" { + if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO + comptime try frem(f16); comptime try frem(f32); comptime try frem(f64); @@ -832,6 +980,12 @@ fn frem(comptime T: type) !void { } test "float modulo division using @mod" { + if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO + comptime try fmod(f16); comptime try fmod(f32); comptime try fmod(f64); @@ -861,6 +1015,12 @@ fn fmod(comptime T: type) !void { } test "@sqrt" { + if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO + try testSqrt(f64, 12.0); comptime try testSqrt(f64, 12.0); try testSqrt(f32, 13.0); @@ -1046,6 +1206,12 @@ test "vector integer addition" { } test "NaN comparison" { + if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO + try testNanEqNan(f16); try testNanEqNan(f32); try testNanEqNan(f64); @@ -1055,7 +1221,7 @@ test "NaN comparison" { comptime try testNanEqNan(f64); comptime try testNanEqNan(f128); - // TODO make this pass on all targets + // TODO https://github.com/ziglang/zig/issues/11030 // try testNanEqNan(f80); // comptime try testNanEqNan(f80); }