disable failing CBE behavior tests failing on aarch64-windows

Also start to move redundant tests next to each other to make them
slightly more obvious that they need to be cleaned up.

See tracking issue #13876

1 files changed, 276 insertions, 0 deletions

diff --git a/test/behavior/floatop.zig b/test/behavior/floatop.zig
index ed3ff983b3..7befa41380 100644
--- a/test/behavior/floatop.zig
+++ b/test/behavior/floatop.zig
@@ -185,6 +185,32 @@ test "more @sqrt f16 tests" {
     try expect(math.isNan(@sqrt(@as(f16, math.nan(f16)))));
 }
 
+test "another, possibly redundant @sqrt test" {
+    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 testSqrtLegacy(f64, 12.0);
+    comptime try testSqrtLegacy(f64, 12.0);
+    try testSqrtLegacy(f32, 13.0);
+    comptime try testSqrtLegacy(f32, 13.0);
+    try testSqrtLegacy(f16, 13.0);
+    comptime try testSqrtLegacy(f16, 13.0);
+
+    // TODO: make this pass
+    if (false) {
+        const x = 14.0;
+        const y = x * x;
+        const z = @sqrt(y);
+        comptime try expect(z == x);
+    }
+}
+
+fn testSqrtLegacy(comptime T: type, x: T) !void {
+    try expect(@sqrt(x * x) == x);
+}
+
 test "@sin" {
     if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
@@ -529,6 +555,85 @@ fn testFabsWithVectors() !void {
     try expect(math.approxEqAbs(f32, @fabs(@as(f32, -0.4)), result[3], epsilon));
 }
 
+test "another, possibly redundant, @fabs test" {
+    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.os.tag == .windows and builtin.cpu.arch == .aarch64 and
+        builtin.zig_backend == .stage2_c)
+    {
+        // https://github.com/ziglang/zig/issues/13876
+        return error.SkipZigTest;
+    }
+
+    try testFabsLegacy(f128, 12.0);
+    comptime try testFabsLegacy(f128, 12.0);
+    try testFabsLegacy(f64, 12.0);
+    comptime try testFabsLegacy(f64, 12.0);
+    try testFabsLegacy(f32, 12.0);
+    comptime try testFabsLegacy(f32, 12.0);
+    try testFabsLegacy(f16, 12.0);
+    comptime try testFabsLegacy(f16, 12.0);
+
+    const x = 14.0;
+    const y = -x;
+    const z = @fabs(y);
+    comptime try std.testing.expectEqual(x, z);
+}
+
+test "@fabs f80" {
+    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 testFabsLegacy(f80, 12.0);
+    comptime try testFabsLegacy(f80, 12.0);
+}
+
+fn testFabsLegacy(comptime T: type, x: T) !void {
+    const y = -x;
+    const z = @fabs(y);
+    try expect(x == z);
+}
+
+test "a third @fabs test, surely there should not be three fabs tests" {
+    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.os.tag == .windows and builtin.cpu.arch == .aarch64 and
+        builtin.zig_backend == .stage2_c)
+    {
+        // https://github.com/ziglang/zig/issues/13876
+        return error.SkipZigTest;
+    }
+
+    inline for ([_]type{ f16, f32, f64, f80, f128, c_longdouble }) |T| {
+        // normals
+        try expect(@fabs(@as(T, 1.0)) == 1.0);
+        try expect(@fabs(@as(T, -1.0)) == 1.0);
+        try expect(@fabs(math.floatMin(T)) == math.floatMin(T));
+        try expect(@fabs(-math.floatMin(T)) == math.floatMin(T));
+        try expect(@fabs(math.floatMax(T)) == math.floatMax(T));
+        try expect(@fabs(-math.floatMax(T)) == math.floatMax(T));
+
+        // subnormals
+        try expect(@fabs(@as(T, 0.0)) == 0.0);
+        try expect(@fabs(@as(T, -0.0)) == 0.0);
+        try expect(@fabs(math.floatTrueMin(T)) == math.floatTrueMin(T));
+        try expect(@fabs(-math.floatTrueMin(T)) == math.floatTrueMin(T));
+
+        // non-finite numbers
+        try expect(math.isPositiveInf(@fabs(math.inf(T))));
+        try expect(math.isPositiveInf(@fabs(-math.inf(T))));
+        try expect(math.isNan(@fabs(math.nan(T))));
+    }
+}
+
 test "@floor" {
     if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
@@ -573,6 +678,56 @@ fn testFloorWithVectors() !void {
     try expect(math.approxEqAbs(f32, @floor(@as(f32, -0.4)), result[3], epsilon));
 }
 
+test "another, possibly redundant, @floor test" {
+    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 testFloorLegacy(f64, 12.0);
+    comptime try testFloorLegacy(f64, 12.0);
+    try testFloorLegacy(f32, 12.0);
+    comptime try testFloorLegacy(f32, 12.0);
+    try testFloorLegacy(f16, 12.0);
+    comptime try testFloorLegacy(f16, 12.0);
+
+    const x = 14.0;
+    const y = x + 0.7;
+    const z = @floor(y);
+    comptime try expect(x == z);
+}
+
+test "@floor f80" {
+    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_llvm and builtin.os.tag == .windows) {
+        // https://github.com/ziglang/zig/issues/12602
+        return error.SkipZigTest;
+    }
+
+    try testFloorLegacy(f80, 12.0);
+    comptime try testFloorLegacy(f80, 12.0);
+}
+
+test "@floor f128" {
+    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 testFloorLegacy(f128, 12.0);
+    comptime try testFloorLegacy(f128, 12.0);
+}
+
+fn testFloorLegacy(comptime T: type, x: T) !void {
+    const y = x + 0.6;
+    const z = @floor(y);
+    try expect(x == z);
+}
+
 test "@ceil" {
     if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
@@ -617,6 +772,56 @@ fn testCeilWithVectors() !void {
     try expect(math.approxEqAbs(f32, @ceil(@as(f32, -0.4)), result[3], epsilon));
 }
 
+test "another, possibly redundant, @ceil test" {
+    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 testCeilLegacy(f64, 12.0);
+    comptime try testCeilLegacy(f64, 12.0);
+    try testCeilLegacy(f32, 12.0);
+    comptime try testCeilLegacy(f32, 12.0);
+    try testCeilLegacy(f16, 12.0);
+    comptime try testCeilLegacy(f16, 12.0);
+
+    const x = 14.0;
+    const y = x - 0.7;
+    const z = @ceil(y);
+    comptime try expect(x == z);
+}
+
+test "@ceil f80" {
+    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_llvm and builtin.os.tag == .windows) {
+        // https://github.com/ziglang/zig/issues/12602
+        return error.SkipZigTest;
+    }
+
+    try testCeilLegacy(f80, 12.0);
+    comptime try testCeilLegacy(f80, 12.0);
+}
+
+test "@ceil f128" {
+    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 testCeilLegacy(f128, 12.0);
+    comptime try testCeilLegacy(f128, 12.0);
+}
+
+fn testCeilLegacy(comptime T: type, x: T) !void {
+    const y = x - 0.8;
+    const z = @ceil(y);
+    try expect(x == z);
+}
+
 test "@trunc" {
     if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
@@ -661,6 +866,70 @@ fn testTruncWithVectors() !void {
     try expect(math.approxEqAbs(f32, @trunc(@as(f32, -0.4)), result[3], epsilon));
 }
 
+test "another, possibly redundant, @trunc test" {
+    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 testTruncLegacy(f64, 12.0);
+    comptime try testTruncLegacy(f64, 12.0);
+    try testTruncLegacy(f32, 12.0);
+    comptime try testTruncLegacy(f32, 12.0);
+    try testTruncLegacy(f16, 12.0);
+    comptime try testTruncLegacy(f16, 12.0);
+
+    const x = 14.0;
+    const y = x + 0.7;
+    const z = @trunc(y);
+    comptime try expect(x == z);
+}
+
+test "@trunc f80" {
+    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_llvm and builtin.os.tag == .windows) {
+        // https://github.com/ziglang/zig/issues/12602
+        return error.SkipZigTest;
+    }
+
+    try testTruncLegacy(f80, 12.0);
+    comptime try testTruncLegacy(f80, 12.0);
+    comptime {
+        const x: f80 = 12.0;
+        const y = x + 0.8;
+        const z = @trunc(y);
+        try expect(x == z);
+    }
+}
+
+test "@trunc f128" {
+    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 testTruncLegacy(f128, 12.0);
+    comptime try testTruncLegacy(f128, 12.0);
+}
+
+fn testTruncLegacy(comptime T: type, x: T) !void {
+    {
+        const y = x + 0.8;
+        const z = @trunc(y);
+        try expect(x == z);
+    }
+
+    {
+        const y = -x - 0.8;
+        const z = @trunc(y);
+        try expect(-x == z);
+    }
+}
+
 test "negation f16" {
     if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
@@ -757,6 +1026,13 @@ test "negation f128" {
     if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
+    if (builtin.os.tag == .windows and builtin.cpu.arch == .aarch64 and
+        builtin.zig_backend == .stage2_c)
+    {
+        // https://github.com/ziglang/zig/issues/13876
+        return error.SkipZigTest;
+    }
+
     const S = struct {
         fn doTheTest() !void {
             var a: f128 = 1;