Try to figure out which tests are causing the LLVM assertion

Author: jedisct1

lib/std/math/egcd.zig

@@ -241,6 +241,7 @@ test "coprime numbers" {
 }
 
 test "powers of 2" {
+    if (true) return error.SkipZigTest;
     const result1 = egcd(@as(u32, 16), @as(u32, 24));
     try std.testing.expectEqual(@as(u32, 8), result1.gcd);
 
@@ -249,6 +250,7 @@ test "powers of 2" {
 }
 
 test "one is 1" {
+    if (true) return error.SkipZigTest;
     const result1 = egcd(@as(u32, 1), @as(u32, 100));
     try std.testing.expectEqual(@as(u32, 1), result1.gcd);
     try std.testing.expectEqual(@as(i33, 1), result1.x);
@@ -259,6 +261,7 @@ test "one is 1" {
 }
 
 test "same values" {
+    if (true) return error.SkipZigTest;
     const result1 = egcd(@as(u32, 42), @as(u32, 42));
     try std.testing.expectEqual(@as(u32, 42), result1.gcd);
 
@@ -267,6 +270,7 @@ test "same values" {
 }
 
 test "Fibonacci numbers" {
+    if (true) return error.SkipZigTest;
     // Consecutive Fibonacci numbers are coprime
     const result = egcd(@as(u32, 89), @as(u32, 144));
     try std.testing.expectEqual(@as(u32, 1), result.gcd);
@@ -275,6 +279,7 @@ test "Fibonacci numbers" {
 }
 
 test "u3 type" {
+    if (true) return error.SkipZigTest;
     // u3 can hold 0-7
     const result = egcd(@as(u3, 6), @as(u3, 4));
     try std.testing.expectEqual(@as(u3, 2), result.gcd);
@@ -283,6 +288,7 @@ test "u3 type" {
 }
 
 test "i3 type" {
+    if (true) return error.SkipZigTest;
     // i3 can hold -4 to 3
     const result = egcd(@as(i3, -3), @as(i3, 2));
     try std.testing.expectEqual(@as(i3, 1), result.gcd);
@@ -291,6 +297,7 @@ test "i3 type" {
 }
 
 test "u7 type" {
+    if (true) return error.SkipZigTest;
     // u7 can hold 0-127
     const result = egcd(@as(u7, 120), @as(u7, 45));
     try std.testing.expectEqual(@as(u7, 15), result.gcd);
@@ -299,6 +306,7 @@ test "u7 type" {
 }
 
 test "modular inverse use case" {
+    if (true) return error.SkipZigTest;
     // Common use case: finding modular inverse
     // If gcd(a, m) = 1, then x is the modular inverse of a mod m
     const a: u32 = 17;
@@ -313,6 +321,7 @@ test "modular inverse use case" {
     try std.testing.expectEqual(@as(u64, 1), verify);
 }
 test "u256 type" {
+    if (true) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO: C backend missing big integer helpers
     const a: u256 = 123456789012345678901234567890123456789012345678901234567890;
     const b: u256 = 987654321098765432109876543210987654321098765432109876543210;
@@ -327,6 +336,7 @@ test "u256 type" {
 }
 
 test "u512 type" {
+    if (true) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO: C backend missing big integer helpers
     const a: u512 = 999999999999999999;
     const b: u512 = 888888888888888888;
@@ -338,6 +348,7 @@ test "u512 type" {
 }
 
 test "i256 type" {
+    if (true) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO: C backend missing big integer helpers
     const a: i256 = -123456789012345678901234567890;
     const b: i256 = 987654321098765432109876543210;
@@ -352,6 +363,7 @@ test "i256 type" {
 }
 
 test "u1024 type" {
+    if (true) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO: C backend missing big integer helpers
     // Test that very large types compile and work
     const a: u1024 = 12345678901234567890;
@@ -364,6 +376,7 @@ test "u1024 type" {
 }
 
 test "u4096" {
+    if (true) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO: C backend missing big integer helpers
     const a: u4096 = 100;
     const b: u4096 = 50;
@@ -372,6 +385,7 @@ test "u4096" {
 }
 
 test "Bezout identity for a=0, b<0" {
+    if (true) return error.SkipZigTest;
     // When a=0 and b<0, the GCD is normalized to positive
     const result = egcd(@as(i32, 0), @as(i32, -5));
     try std.testing.expectEqual(@as(i32, 5), result.gcd);
@@ -384,6 +398,7 @@ test "Bezout identity for a=0, b<0" {
 }
 
 test "Bezout identity for a<0, b=0" {
+    if (true) return error.SkipZigTest;
     // Verify the symmetric case: when a<0 and b=0, GCD is normalized to positive
     const result = egcd(@as(i32, -7), @as(i32, 0));
     try std.testing.expectEqual(@as(i32, 7), result.gcd);
@@ -396,6 +411,7 @@ test "Bezout identity for a<0, b=0" {
 }
 
 test "Bezout identity for all zero-argument cases" {
+    if (true) return error.SkipZigTest;
     // Positive b
     {
         const result = egcd(@as(i16, 0), @as(i16, 10));