upgrade runner to Zig 0.16.0 (#140)

keiravillekode · web-flow · commit 95607ae8569a · 2026-04-26T12:45:36.000+10:00
diff --git a/Dockerfile b/Dockerfile
@@ -2,7 +2,7 @@ ARG REPO=alpine
 ARG IMAGE=3.22.1@sha256:eafc1edb577d2e9b458664a15f23ea1c370214193226069eb22921169fc7e43f
 FROM ${REPO}:${IMAGE} AS builder
 
-ARG VERSION=0.15.2
+ARG VERSION=0.16.0
 ARG RELEASE=zig-x86_64-linux-${VERSION}
 
 # We can't reliably pin the package versions on Alpine, so we ignore the linter warning.
diff --git a/bin/run-tests.sh b/bin/run-tests.sh
@@ -34,7 +34,7 @@ for test_dir in "${tmp_dir}"/*; do
         # `expectError__anon_17425`), both of which vary between builds.
         # See: https://github.com/exercism/zig-test-runner/issues/26
         sed -E \
-            -e 's/0x[a-f0-9]{6}/<MEMHASH>/g' \
+            -e 's/0x[a-f0-9]+/<MEMHASH>/g' \
             -e 's/__anon_[0-9]+/__anon_<ANON>/g' \
             "${file}" > "${file}.tmp"
     done
diff --git a/tests/example-all-fail/expected_results.json b/tests/example-all-fail/expected_results.json
@@ -5,47 +5,47 @@
     {
       "name": "year not divisible by 4 in common year",
       "status": "fail",
-      "message": "/opt/zig/lib/std/testing.zig:607:14: <MEMHASH>9 in expect (std.zig)\n    if (!ok) return error.TestUnexpectedResult;\n             ^\ntest_example_all_fail.zig:7:5: <MEMHASH>a in test.year not divisible by 4 in common year (test_example_all_fail.zig)\n    try testing.expect(!leap.leap(2015));\n    ^"
+      "message": "/opt/zig/lib/std/testing.zig:615:14: <MEMHASH> in expect (std.zig)\n    if (!ok) return error.TestUnexpectedResult;\n             ^\ntest_example_all_fail.zig:7:5: <MEMHASH> in test.year not divisible by 4 in common year (test_example_all_fail.zig)\n    try testing.expect(!leap.leap(2015));\n    ^"
     },
     {
       "name": "year divisible by 2, not divisible by 4 in common year",
       "status": "fail",
-      "message": "/opt/zig/lib/std/testing.zig:607:14: <MEMHASH>9 in expect (std.zig)\n    if (!ok) return error.TestUnexpectedResult;\n             ^\ntest_example_all_fail.zig:11:5: <MEMHASH>a in test.year divisible by 2, not divisible by 4 in common year (test_example_all_fail.zig)\n    try testing.expect(!leap.leap(1970));\n    ^"
+      "message": "/opt/zig/lib/std/testing.zig:615:14: <MEMHASH> in expect (std.zig)\n    if (!ok) return error.TestUnexpectedResult;\n             ^\ntest_example_all_fail.zig:11:5: <MEMHASH> in test.year divisible by 2, not divisible by 4 in common year (test_example_all_fail.zig)\n    try testing.expect(!leap.leap(1970));\n    ^"
     },
     {
       "name": "year divisible by 4, not divisible by 100 in leap year",
       "status": "fail",
-      "message": "/opt/zig/lib/std/testing.zig:607:14: <MEMHASH>9 in expect (std.zig)\n    if (!ok) return error.TestUnexpectedResult;\n             ^\ntest_example_all_fail.zig:15:5: <MEMHASH>8 in test.year divisible by 4, not divisible by 100 in leap year (test_example_all_fail.zig)\n    try testing.expect(leap.leap(1996));\n    ^"
+      "message": "/opt/zig/lib/std/testing.zig:615:14: <MEMHASH> in expect (std.zig)\n    if (!ok) return error.TestUnexpectedResult;\n             ^\ntest_example_all_fail.zig:15:5: <MEMHASH> in test.year divisible by 4, not divisible by 100 in leap year (test_example_all_fail.zig)\n    try testing.expect(leap.leap(1996));\n    ^"
     },
     {
       "name": "year divisible by 4 and 5 is still a leap year",
       "status": "fail",
-      "message": "/opt/zig/lib/std/testing.zig:607:14: <MEMHASH>9 in expect (std.zig)\n    if (!ok) return error.TestUnexpectedResult;\n             ^\ntest_example_all_fail.zig:19:5: <MEMHASH>8 in test.year divisible by 4 and 5 is still a leap year (test_example_all_fail.zig)\n    try testing.expect(leap.leap(1960));\n    ^"
+      "message": "/opt/zig/lib/std/testing.zig:615:14: <MEMHASH> in expect (std.zig)\n    if (!ok) return error.TestUnexpectedResult;\n             ^\ntest_example_all_fail.zig:19:5: <MEMHASH> in test.year divisible by 4 and 5 is still a leap year (test_example_all_fail.zig)\n    try testing.expect(leap.leap(1960));\n    ^"
     },
     {
       "name": "year divisible by 100, not divisible by 400 in common year",
       "status": "fail",
-      "message": "/opt/zig/lib/std/testing.zig:607:14: <MEMHASH>9 in expect (std.zig)\n    if (!ok) return error.TestUnexpectedResult;\n             ^\ntest_example_all_fail.zig:23:5: <MEMHASH>a in test.year divisible by 100, not divisible by 400 in common year (test_example_all_fail.zig)\n    try testing.expect(!leap.leap(2100));\n    ^"
+      "message": "/opt/zig/lib/std/testing.zig:615:14: <MEMHASH> in expect (std.zig)\n    if (!ok) return error.TestUnexpectedResult;\n             ^\ntest_example_all_fail.zig:23:5: <MEMHASH> in test.year divisible by 100, not divisible by 400 in common year (test_example_all_fail.zig)\n    try testing.expect(!leap.leap(2100));\n    ^"
     },
     {
       "name": "year divisible by 100 but not by 3 is still not a leap year",
       "status": "fail",
-      "message": "/opt/zig/lib/std/testing.zig:607:14: <MEMHASH>9 in expect (std.zig)\n    if (!ok) return error.TestUnexpectedResult;\n             ^\ntest_example_all_fail.zig:27:5: <MEMHASH>a in test.year divisible by 100 but not by 3 is still not a leap year (test_example_all_fail.zig)\n    try testing.expect(!leap.leap(1900));\n    ^"
+      "message": "/opt/zig/lib/std/testing.zig:615:14: <MEMHASH> in expect (std.zig)\n    if (!ok) return error.TestUnexpectedResult;\n             ^\ntest_example_all_fail.zig:27:5: <MEMHASH> in test.year divisible by 100 but not by 3 is still not a leap year (test_example_all_fail.zig)\n    try testing.expect(!leap.leap(1900));\n    ^"
     },
     {
       "name": "year divisible by 400 is leap year",
       "status": "fail",
-      "message": "/opt/zig/lib/std/testing.zig:607:14: <MEMHASH>9 in expect (std.zig)\n    if (!ok) return error.TestUnexpectedResult;\n             ^\ntest_example_all_fail.zig:31:5: <MEMHASH>8 in test.year divisible by 400 is leap year (test_example_all_fail.zig)\n    try testing.expect(leap.leap(2000));\n    ^"
+      "message": "/opt/zig/lib/std/testing.zig:615:14: <MEMHASH> in expect (std.zig)\n    if (!ok) return error.TestUnexpectedResult;\n             ^\ntest_example_all_fail.zig:31:5: <MEMHASH> in test.year divisible by 400 is leap year (test_example_all_fail.zig)\n    try testing.expect(leap.leap(2000));\n    ^"
     },
     {
       "name": "year divisible by 400 but not by 125 is still a leap year",
       "status": "fail",
-      "message": "/opt/zig/lib/std/testing.zig:607:14: <MEMHASH>9 in expect (std.zig)\n    if (!ok) return error.TestUnexpectedResult;\n             ^\ntest_example_all_fail.zig:35:5: <MEMHASH>8 in test.year divisible by 400 but not by 125 is still a leap year (test_example_all_fail.zig)\n    try testing.expect(leap.leap(2400));\n    ^"
+      "message": "/opt/zig/lib/std/testing.zig:615:14: <MEMHASH> in expect (std.zig)\n    if (!ok) return error.TestUnexpectedResult;\n             ^\ntest_example_all_fail.zig:35:5: <MEMHASH> in test.year divisible by 400 but not by 125 is still a leap year (test_example_all_fail.zig)\n    try testing.expect(leap.leap(2400));\n    ^"
     },
     {
       "name": "year divisible by 200, not divisible by 400 in common year",
       "status": "fail",
-      "message": "/opt/zig/lib/std/testing.zig:607:14: <MEMHASH>9 in expect (std.zig)\n    if (!ok) return error.TestUnexpectedResult;\n             ^\ntest_example_all_fail.zig:39:5: <MEMHASH>a in test.year divisible by 200, not divisible by 400 in common year (test_example_all_fail.zig)\n    try testing.expect(!leap.leap(1800));\n    ^"
+      "message": "/opt/zig/lib/std/testing.zig:615:14: <MEMHASH> in expect (std.zig)\n    if (!ok) return error.TestUnexpectedResult;\n             ^\ntest_example_all_fail.zig:39:5: <MEMHASH> in test.year divisible by 200, not divisible by 400 in common year (test_example_all_fail.zig)\n    try testing.expect(!leap.leap(1800));\n    ^"
     }
   ]
 }
diff --git a/tests/example-error-exercise/expected_results.json b/tests/example-error-exercise/expected_results.json
@@ -21,7 +21,7 @@
     {
       "name": "zero is an error",
       "status": "fail",
-      "message": "FAIL (TestExpectedError)\n/opt/zig/lib/std/testing.zig:57:9: <MEMHASH>1 in expectError__anon_<ANON> (std.zig)\n        return error.TestExpectedError;\n        ^\ntest_example_error_exercise.zig:34:5: <MEMHASH>9 in test.zero is an error (test_example_error_exercise.zig)\n    try testing.expectError(expected, actual);\n    ^"
+      "message": "FAIL (TestExpectedError)\n/opt/zig/lib/std/testing.zig:65:9: <MEMHASH> in expectError__anon_<ANON> (std.zig)\n        return error.TestExpectedError;\n        ^\ntest_example_error_exercise.zig:34:5: <MEMHASH> in test.zero is an error (test_example_error_exercise.zig)\n    try testing.expectError(expected, actual);\n    ^"
     }
   ]
 }
diff --git a/tests/example-output-truncated/expected_results.json b/tests/example-output-truncated/expected_results.json
@@ -10,19 +10,19 @@
     {
       "name": "detects two anagrams",
       "status": "fail",
-      "message": "FAIL (TestExpectedEqual)\n/opt/zig/lib/std/testing.zig:110:17: <MEMHASH>9 in expectEqualInner__anon_<ANON> (std.zig)\n                return error.TestExpectedEqual;\n                ^\ntest_example_output_truncated.zig:14:5: <MEMHASH>d in testAnagrams (test_example_output_truncated.zig)\n    try testing.expectEqual(expected.len, actual.count());\n    ^\n/opt/zig/lib/std/testing.zig:1137:9: <MEMHASH>7 in checkAllAllocationFailures__anon_<ANON> (std.zig)\n        try @call(.auto, test_fn, args);\n        ^\ntest_example_output_truncated.zig:35:5: <MEMHASH>c in test.detects two anagrams (test_example_output_truncated.zig)\n    try std.testing.checkAllAllocationFailures(\n    ^",
+      "message": "FAIL (TestExpectedEqual)\n/opt/zig/lib/std/testing.zig:118:17: <MEMHASH> in expectEqualInner__anon_<ANON> (std.zig)\n                return error.TestExpectedEqual;\n                ^\n/opt/zig/lib/std/testing.zig:83:5: <MEMHASH> in expectEqual (test_example_output_truncated.zig)\n    return expectEqualInner(T, expected, actual);\n    ^\ntest_example_output_truncated.zig:14:5: <MEMHASH> in testAnagrams (test_example_output_truncated.zig)\n    try testing.expectEqual(expected.len, actual.count());\n    ^\n/opt/zig/lib/std/testing.zig:1124:9: <MEMHASH> in checkAllAllocationFailures__anon_<ANON> (std.zig)\n        try @call(.auto, test_fn, .{failing_allocator_inst.allocator()} ++ extra_args);\n        ^\ntest_example_output_truncated.zig:35:5: <MEMHASH> in test.detects two anagrams (test_example_output_truncated.zig)\n    try std.testing.checkAllAllocationFailures(\n    ^",
       "output": "lemons\ncherry\nmelons\nexpected 2, found 0"
     },
     {
       "name": "detects three anagrams",
       "status": "fail",
-      "message": "FAIL (TestExpectedEqual)\n/opt/zig/lib/std/testing.zig:110:17: <MEMHASH>9 in expectEqualInner__anon_<ANON> (std.zig)\n                return error.TestExpectedEqual;\n                ^\ntest_example_output_truncated.zig:14:5: <MEMHASH>d in testAnagrams (test_example_output_truncated.zig)\n    try testing.expectEqual(expected.len, actual.count());\n    ^\n/opt/zig/lib/std/testing.zig:1137:9: <MEMHASH>7 in checkAllAllocationFailures__anon_<ANON> (std.zig)\n        try @call(.auto, test_fn, args);\n        ^\ntest_example_output_truncated.zig:46:5: <MEMHASH>b in test.detects three anagrams (test_example_output_truncated.zig)\n    try std.testing.checkAllAllocationFailures(\n    ^",
+      "message": "FAIL (TestExpectedEqual)\n/opt/zig/lib/std/testing.zig:118:17: <MEMHASH> in expectEqualInner__anon_<ANON> (std.zig)\n                return error.TestExpectedEqual;\n                ^\n/opt/zig/lib/std/testing.zig:83:5: <MEMHASH> in expectEqual (test_example_output_truncated.zig)\n    return expectEqualInner(T, expected, actual);\n    ^\ntest_example_output_truncated.zig:14:5: <MEMHASH> in testAnagrams (test_example_output_truncated.zig)\n    try testing.expectEqual(expected.len, actual.count());\n    ^\n/opt/zig/lib/std/testing.zig:1124:9: <MEMHASH> in checkAllAllocationFailures__anon_<ANON> (std.zig)\n        try @call(.auto, test_fn, .{failing_allocator_inst.allocator()} ++ extra_args);\n        ^\ntest_example_output_truncated.zig:46:5: <MEMHASH> in test.detects three anagrams (test_example_output_truncated.zig)\n    try std.testing.checkAllAllocationFailures(\n    ^",
       "output": "gallery\nballerina\nregally\nclergy\nlargely\nleading\nexpected 3, found 0"
     },
     {
       "name": "detects anagrams case-insensitively",
       "status": "fail",
-      "message": "FAIL (TestExpectedEqual)\n/opt/zig/lib/std/testing.zig:110:17: <MEMHASH>9 in expectEqualInner__anon_<ANON> (std.zig)\n                return error.TestExpectedEqual;\n                ^\ntest_example_output_truncated.zig:14:5: <MEMHASH>d in testAnagrams (test_example_output_truncated.zig)\n    try testing.expectEqual(expected.len, actual.count());\n    ^\n/opt/zig/lib/std/testing.zig:1137:9: <MEMHASH>7 in checkAllAllocationFailures__anon_<ANON> (std.zig)\n        try @call(.auto, test_fn, args);\n        ^\ntest_example_output_truncated.zig:57:5: <MEMHASH>c in test.detects anagrams case-insensitively (test_example_output_truncated.zig)\n    try std.testing.checkAllAllocationFailures(\n    ^",
+      "message": "FAIL (TestExpectedEqual)\n/opt/zig/lib/std/testing.zig:118:17: <MEMHASH> in expectEqualInner__anon_<ANON> (std.zig)\n                return error.TestExpectedEqual;\n                ^\n/opt/zig/lib/std/testing.zig:83:5: <MEMHASH> in expectEqual (test_example_output_truncated.zig)\n    return expectEqualInner(T, expected, actual);\n    ^\ntest_example_output_truncated.zig:14:5: <MEMHASH> in testAnagrams (test_example_output_truncated.zig)\n    try testing.expectEqual(expected.len, actual.count());\n    ^\n/opt/zig/lib/std/testing.zig:1124:9: <MEMHASH> in checkAllAllocationFailures__anon_<ANON> (std.zig)\n        try @call(.auto, test_fn, .{failing_allocator_inst.allocator()} ++ extra_args);\n        ^\ntest_example_output_truncated.zig:57:5: <MEMHASH> in test.detects anagrams case-insensitively (test_example_output_truncated.zig)\n    try std.testing.checkAllAllocationFailures(\n    ^",
       "output": "cashregister\nCarthorse\nradishes\nexpected 1, found 0"
     },
     {
@@ -33,7 +33,7 @@
     {
       "name": "detects many anagrams of 26-letter words",
       "status": "fail",
-      "message": "FAIL (TestExpectedEqual)\n/opt/zig/lib/std/testing.zig:110:17: <MEMHASH>9 in expectEqualInner__anon_<ANON> (std.zig)\n                return error.TestExpectedEqual;\n                ^\ntest_example_output_truncated.zig:14:5: <MEMHASH>d in testAnagrams (test_example_output_truncated.zig)\n    try testing.expectEqual(expected.len, actual.count());\n    ^\n/opt/zig/lib/std/testing.zig:1137:9: <MEMHASH>7 in checkAllAllocationFailures__anon_<ANON> (std.zig)\n        try @call(.auto, test_fn, args);\n        ^\ntest_example_output_truncated.zig:99:5: <MEMHASH>b in test.detects many anagrams of 26-letter words (test_example_output_truncated.zig)\n    try std.testing.checkAllAllocationFailures(\n    ^",
+      "message": "FAIL (TestExpectedEqual)\n/opt/zig/lib/std/testing.zig:118:17: <MEMHASH> in expectEqualInner__anon_<ANON> (std.zig)\n                return error.TestExpectedEqual;\n                ^\n/opt/zig/lib/std/testing.zig:83:5: <MEMHASH> in expectEqual (test_example_output_truncated.zig)\n    return expectEqualInner(T, expected, actual);\n    ^\ntest_example_output_truncated.zig:14:5: <MEMHASH> in testAnagrams (test_example_output_truncated.zig)\n    try testing.expectEqual(expected.len, actual.count());\n    ^\n/opt/zig/lib/std/testing.zig:1124:9: <MEMHASH> in checkAllAllocationFailures__anon_<ANON> (std.zig)\n        try @call(.auto, test_fn, .{failing_allocator_inst.allocator()} ++ extra_args);\n        ^\ntest_example_output_truncated.zig:99:5: <MEMHASH> in test.detects many anagrams of 26-letter words (test_example_output_truncated.zig)\n    try std.testing.checkAllAllocationFailures(\n    ^",
       "output": "ZYXWVUTSRQPONMLKJIHGFEDCBA\nMNOPQRSTUVWXYZABCDEFGHIJKL\nBADCFEHGJILKNMPORQTSVUXWZY\nQWERTYUIOPASDFGHJKLZXCVBNM\nGHIJKLMNOPQRSTUVWXYZABCDEF\nSTUVWXYZABCDEFGHIJKLMNOPQR\nDCBAEFGHIJKLMNOPQRSTUVWXYZ\nAZBYCXDWEVFUGTHSIRJQKPLOMN\nZAYXBWCVDUESFTGRHQIPJOKLNM\nNMLKJIHGFEDCBAZYXWVUTSRQPO\nBDFHJLNPRTVXZACEGIKMOQSUWY\nYWUSQOMKIGECAXZVTRPNLJHFDB\nJKLMNOPQRSTUVWXYZABCDEFGHI\nPONMLKJIHGFEDCBAZYXWVUTSRQ\nLKJIHGFEDCBAZYXWVUTSRQPONM\nCDEFGHIJKLMNOPQRSTUVWXYZAB\nEFGHIJKLMNOPQRSTUVWXYZABCD\nIJKLMNOPQRSTUVWXYZABCD [output truncated]"
     }
   ]
diff --git a/tests/example-partial-fail/expected_results.json b/tests/example-partial-fail/expected_results.json
@@ -21,12 +21,12 @@
     {
       "name": "year divisible by 100, not divisible by 400 in common year",
       "status": "fail",
-      "message": "/opt/zig/lib/std/testing.zig:607:14: <MEMHASH>9 in expect (std.zig)\n    if (!ok) return error.TestUnexpectedResult;\n             ^\ntest_example_partial_fail.zig:23:5: <MEMHASH>a in test.year divisible by 100, not divisible by 400 in common year (test_example_partial_fail.zig)\n    try testing.expect(!leap.leap(2100));\n    ^"
+      "message": "/opt/zig/lib/std/testing.zig:615:14: <MEMHASH> in expect (std.zig)\n    if (!ok) return error.TestUnexpectedResult;\n             ^\ntest_example_partial_fail.zig:23:5: <MEMHASH> in test.year divisible by 100, not divisible by 400 in common year (test_example_partial_fail.zig)\n    try testing.expect(!leap.leap(2100));\n    ^"
     },
     {
       "name": "year divisible by 100 but not by 3 is still not a leap year",
       "status": "fail",
-      "message": "/opt/zig/lib/std/testing.zig:607:14: <MEMHASH>9 in expect (std.zig)\n    if (!ok) return error.TestUnexpectedResult;\n             ^\ntest_example_partial_fail.zig:27:5: <MEMHASH>a in test.year divisible by 100 but not by 3 is still not a leap year (test_example_partial_fail.zig)\n    try testing.expect(!leap.leap(1900));\n    ^"
+      "message": "/opt/zig/lib/std/testing.zig:615:14: <MEMHASH> in expect (std.zig)\n    if (!ok) return error.TestUnexpectedResult;\n             ^\ntest_example_partial_fail.zig:27:5: <MEMHASH> in test.year divisible by 100 but not by 3 is still not a leap year (test_example_partial_fail.zig)\n    try testing.expect(!leap.leap(1900));\n    ^"
     },
     {
       "name": "year divisible by 400 is leap year",
@@ -39,7 +39,7 @@
     {
       "name": "year divisible by 200, not divisible by 400 in common year",
       "status": "fail",
-      "message": "/opt/zig/lib/std/testing.zig:607:14: <MEMHASH>9 in expect (std.zig)\n    if (!ok) return error.TestUnexpectedResult;\n             ^\ntest_example_partial_fail.zig:39:5: <MEMHASH>a in test.year divisible by 200, not divisible by 400 in common year (test_example_partial_fail.zig)\n    try testing.expect(!leap.leap(1800));\n    ^"
+      "message": "/opt/zig/lib/std/testing.zig:615:14: <MEMHASH> in expect (std.zig)\n    if (!ok) return error.TestUnexpectedResult;\n             ^\ntest_example_partial_fail.zig:39:5: <MEMHASH> in test.year divisible by 200, not divisible by 400 in common year (test_example_partial_fail.zig)\n    try testing.expect(!leap.leap(1800));\n    ^"
     }
   ]
 }
diff --git a/tests/example-user-output/example_user_output.zig b/tests/example-user-output/example_user_output.zig
@@ -1,9 +1,6 @@
 const std = @import("std");
 
 pub fn greet() ![]const u8 {
-    var buf: [64]u8 = undefined;
-    var w = std.fs.File.stdout().writer(&buf);
-    try w.interface.writeAll("debug: computed bad greeting\n");
-    try w.interface.flush();
+    std.debug.print("debug: computed bad greeting\n", .{});
     return "Goodbye";
 }
diff --git a/tests/example-user-output/expected_results.json b/tests/example-user-output/expected_results.json
@@ -5,7 +5,7 @@
     {
       "name": "greet returns a five-letter greeting",
       "status": "fail",
-      "message": "FAIL (TestUnexpectedResult)\n/opt/zig/lib/std/testing.zig:607:14: <MEMHASH>9 in expect (std.zig)\n    if (!ok) return error.TestUnexpectedResult;\n             ^\ntest_example_user_output.zig:8:5: <MEMHASH>5 in test.greet returns a five-letter greeting (test_example_user_output.zig)\n    try testing.expect(result.len == 5);\n    ^",
+      "message": "FAIL (TestUnexpectedResult)\n/opt/zig/lib/std/testing.zig:615:14: <MEMHASH> in expect (std.zig)\n    if (!ok) return error.TestUnexpectedResult;\n             ^\ntest_example_user_output.zig:8:5: <MEMHASH> in test.greet returns a five-letter greeting (test_example_user_output.zig)\n    try testing.expect(result.len == 5);\n    ^",
       "output": "debug: computed bad greeting"
     }
   ]

Original file line number	Diff line number	Diff line change
`@@ -5,47 +5,47 @@`
`5`	`5`	`{`
`6`	`6`	`"name": "year not divisible by 4 in common year",`
`7`	`7`	`"status": "fail",`
`8`		`- "message": "/opt/zig/lib/std/testing.zig:607:14: <MEMHASH>9 in expect (std.zig)\n if (!ok) return error.TestUnexpectedResult;\n ^\ntest_example_all_fail.zig:7:5: <MEMHASH>a in test.year not divisible by 4 in common year (test_example_all_fail.zig)\n try testing.expect(!leap.leap(2015));\n ^"`
	`8`	`+ "message": "/opt/zig/lib/std/testing.zig:615:14: <MEMHASH> in expect (std.zig)\n if (!ok) return error.TestUnexpectedResult;\n ^\ntest_example_all_fail.zig:7:5: <MEMHASH> in test.year not divisible by 4 in common year (test_example_all_fail.zig)\n try testing.expect(!leap.leap(2015));\n ^"`
`9`	`9`	`},`
`10`	`10`	`{`
`11`	`11`	`"name": "year divisible by 2, not divisible by 4 in common year",`
`12`	`12`	`"status": "fail",`
`13`		`- "message": "/opt/zig/lib/std/testing.zig:607:14: <MEMHASH>9 in expect (std.zig)\n if (!ok) return error.TestUnexpectedResult;\n ^\ntest_example_all_fail.zig:11:5: <MEMHASH>a in test.year divisible by 2, not divisible by 4 in common year (test_example_all_fail.zig)\n try testing.expect(!leap.leap(1970));\n ^"`
	`13`	`+ "message": "/opt/zig/lib/std/testing.zig:615:14: <MEMHASH> in expect (std.zig)\n if (!ok) return error.TestUnexpectedResult;\n ^\ntest_example_all_fail.zig:11:5: <MEMHASH> in test.year divisible by 2, not divisible by 4 in common year (test_example_all_fail.zig)\n try testing.expect(!leap.leap(1970));\n ^"`
`14`	`14`	`},`
`15`	`15`	`{`
`16`	`16`	`"name": "year divisible by 4, not divisible by 100 in leap year",`
`17`	`17`	`"status": "fail",`
`18`		`- "message": "/opt/zig/lib/std/testing.zig:607:14: <MEMHASH>9 in expect (std.zig)\n if (!ok) return error.TestUnexpectedResult;\n ^\ntest_example_all_fail.zig:15:5: <MEMHASH>8 in test.year divisible by 4, not divisible by 100 in leap year (test_example_all_fail.zig)\n try testing.expect(leap.leap(1996));\n ^"`
	`18`	`+ "message": "/opt/zig/lib/std/testing.zig:615:14: <MEMHASH> in expect (std.zig)\n if (!ok) return error.TestUnexpectedResult;\n ^\ntest_example_all_fail.zig:15:5: <MEMHASH> in test.year divisible by 4, not divisible by 100 in leap year (test_example_all_fail.zig)\n try testing.expect(leap.leap(1996));\n ^"`
`19`	`19`	`},`
`20`	`20`	`{`
`21`	`21`	`"name": "year divisible by 4 and 5 is still a leap year",`
`22`	`22`	`"status": "fail",`
`23`		`- "message": "/opt/zig/lib/std/testing.zig:607:14: <MEMHASH>9 in expect (std.zig)\n if (!ok) return error.TestUnexpectedResult;\n ^\ntest_example_all_fail.zig:19:5: <MEMHASH>8 in test.year divisible by 4 and 5 is still a leap year (test_example_all_fail.zig)\n try testing.expect(leap.leap(1960));\n ^"`
	`23`	`+ "message": "/opt/zig/lib/std/testing.zig:615:14: <MEMHASH> in expect (std.zig)\n if (!ok) return error.TestUnexpectedResult;\n ^\ntest_example_all_fail.zig:19:5: <MEMHASH> in test.year divisible by 4 and 5 is still a leap year (test_example_all_fail.zig)\n try testing.expect(leap.leap(1960));\n ^"`
`24`	`24`	`},`
`25`	`25`	`{`
`26`	`26`	`"name": "year divisible by 100, not divisible by 400 in common year",`
`27`	`27`	`"status": "fail",`
`28`		`- "message": "/opt/zig/lib/std/testing.zig:607:14: <MEMHASH>9 in expect (std.zig)\n if (!ok) return error.TestUnexpectedResult;\n ^\ntest_example_all_fail.zig:23:5: <MEMHASH>a in test.year divisible by 100, not divisible by 400 in common year (test_example_all_fail.zig)\n try testing.expect(!leap.leap(2100));\n ^"`
	`28`	`+ "message": "/opt/zig/lib/std/testing.zig:615:14: <MEMHASH> in expect (std.zig)\n if (!ok) return error.TestUnexpectedResult;\n ^\ntest_example_all_fail.zig:23:5: <MEMHASH> in test.year divisible by 100, not divisible by 400 in common year (test_example_all_fail.zig)\n try testing.expect(!leap.leap(2100));\n ^"`
`29`	`29`	`},`
`30`	`30`	`{`
`31`	`31`	`"name": "year divisible by 100 but not by 3 is still not a leap year",`
`32`	`32`	`"status": "fail",`
`33`		`- "message": "/opt/zig/lib/std/testing.zig:607:14: <MEMHASH>9 in expect (std.zig)\n if (!ok) return error.TestUnexpectedResult;\n ^\ntest_example_all_fail.zig:27:5: <MEMHASH>a in test.year divisible by 100 but not by 3 is still not a leap year (test_example_all_fail.zig)\n try testing.expect(!leap.leap(1900));\n ^"`
	`33`	`+ "message": "/opt/zig/lib/std/testing.zig:615:14: <MEMHASH> in expect (std.zig)\n if (!ok) return error.TestUnexpectedResult;\n ^\ntest_example_all_fail.zig:27:5: <MEMHASH> in test.year divisible by 100 but not by 3 is still not a leap year (test_example_all_fail.zig)\n try testing.expect(!leap.leap(1900));\n ^"`
`34`	`34`	`},`
`35`	`35`	`{`
`36`	`36`	`"name": "year divisible by 400 is leap year",`
`37`	`37`	`"status": "fail",`
`38`		`- "message": "/opt/zig/lib/std/testing.zig:607:14: <MEMHASH>9 in expect (std.zig)\n if (!ok) return error.TestUnexpectedResult;\n ^\ntest_example_all_fail.zig:31:5: <MEMHASH>8 in test.year divisible by 400 is leap year (test_example_all_fail.zig)\n try testing.expect(leap.leap(2000));\n ^"`
	`38`	`+ "message": "/opt/zig/lib/std/testing.zig:615:14: <MEMHASH> in expect (std.zig)\n if (!ok) return error.TestUnexpectedResult;\n ^\ntest_example_all_fail.zig:31:5: <MEMHASH> in test.year divisible by 400 is leap year (test_example_all_fail.zig)\n try testing.expect(leap.leap(2000));\n ^"`
`39`	`39`	`},`
`40`	`40`	`{`
`41`	`41`	`"name": "year divisible by 400 but not by 125 is still a leap year",`
`42`	`42`	`"status": "fail",`
`43`		`- "message": "/opt/zig/lib/std/testing.zig:607:14: <MEMHASH>9 in expect (std.zig)\n if (!ok) return error.TestUnexpectedResult;\n ^\ntest_example_all_fail.zig:35:5: <MEMHASH>8 in test.year divisible by 400 but not by 125 is still a leap year (test_example_all_fail.zig)\n try testing.expect(leap.leap(2400));\n ^"`
	`43`	`+ "message": "/opt/zig/lib/std/testing.zig:615:14: <MEMHASH> in expect (std.zig)\n if (!ok) return error.TestUnexpectedResult;\n ^\ntest_example_all_fail.zig:35:5: <MEMHASH> in test.year divisible by 400 but not by 125 is still a leap year (test_example_all_fail.zig)\n try testing.expect(leap.leap(2400));\n ^"`
`44`	`44`	`},`
`45`	`45`	`{`
`46`	`46`	`"name": "year divisible by 200, not divisible by 400 in common year",`
`47`	`47`	`"status": "fail",`
`48`		`- "message": "/opt/zig/lib/std/testing.zig:607:14: <MEMHASH>9 in expect (std.zig)\n if (!ok) return error.TestUnexpectedResult;\n ^\ntest_example_all_fail.zig:39:5: <MEMHASH>a in test.year divisible by 200, not divisible by 400 in common year (test_example_all_fail.zig)\n try testing.expect(!leap.leap(1800));\n ^"`
	`48`	`+ "message": "/opt/zig/lib/std/testing.zig:615:14: <MEMHASH> in expect (std.zig)\n if (!ok) return error.TestUnexpectedResult;\n ^\ntest_example_all_fail.zig:39:5: <MEMHASH> in test.year divisible by 200, not divisible by 400 in common year (test_example_all_fail.zig)\n try testing.expect(!leap.leap(1800));\n ^"`
`49`	`49`	`}`
`50`	`50`	`]`
`51`	`51`	`}`
Original file line number	Diff line number	Diff line change
`@@ -21,7 +21,7 @@`
`21`	`21`	`{`
`22`	`22`	`"name": "zero is an error",`
`23`	`23`	`"status": "fail",`
`24`		`- "message": "FAIL (TestExpectedError)\n/opt/zig/lib/std/testing.zig:57:9: <MEMHASH>1 in expectError__anon_<ANON> (std.zig)\n return error.TestExpectedError;\n ^\ntest_example_error_exercise.zig:34:5: <MEMHASH>9 in test.zero is an error (test_example_error_exercise.zig)\n try testing.expectError(expected, actual);\n ^"`
	`24`	`+ "message": "FAIL (TestExpectedError)\n/opt/zig/lib/std/testing.zig:65:9: <MEMHASH> in expectError__anon_<ANON> (std.zig)\n return error.TestExpectedError;\n ^\ntest_example_error_exercise.zig:34:5: <MEMHASH> in test.zero is an error (test_example_error_exercise.zig)\n try testing.expectError(expected, actual);\n ^"`
`25`	`25`	`}`
`26`	`26`	`]`
`27`	`27`	`}`
Original file line number	Diff line number	Diff line change
`@@ -10,19 +10,19 @@`
`10`	`10`	`{`
`11`	`11`	`"name": "detects two anagrams",`
`12`	`12`	`"status": "fail",`
`13`		- "message": "FAIL (TestExpectedEqual)\n/opt/zig/lib/std/testing.zig:110:17: <MEMHASH>9 in expectEqualInner__anon_<ANON> (std.zig)\n return error.TestExpectedEqual;\n ^\ntest_example_output_truncated.zig:14:5: <MEMHASH>d in testAnagrams (test_example_output_truncated.zig)\n try testing.expectEqual(expected.len, actual.count());\n ^\n/opt/zig/lib/std/testing.zig:1137:9: <MEMHASH>7 in checkAllAllocationFailures__anon_<ANON> (std.zig)\n try @call(.auto, test_fn, args);\n ^\ntest_example_output_truncated.zig:35:5: <MEMHASH>c in test.detects two anagrams (test_example_output_truncated.zig)\n try std.testing.checkAllAllocationFailures(\n ^",
	`13`	+ "message": "FAIL (TestExpectedEqual)\n/opt/zig/lib/std/testing.zig:118:17: <MEMHASH> in expectEqualInner__anon_<ANON> (std.zig)\n return error.TestExpectedEqual;\n ^\n/opt/zig/lib/std/testing.zig:83:5: <MEMHASH> in expectEqual (test_example_output_truncated.zig)\n return expectEqualInner(T, expected, actual);\n ^\ntest_example_output_truncated.zig:14:5: <MEMHASH> in testAnagrams (test_example_output_truncated.zig)\n try testing.expectEqual(expected.len, actual.count());\n ^\n/opt/zig/lib/std/testing.zig:1124:9: <MEMHASH> in checkAllAllocationFailures__anon_<ANON> (std.zig)\n try @call(.auto, test_fn, .{failing_allocator_inst.allocator()} ++ extra_args);\n ^\ntest_example_output_truncated.zig:35:5: <MEMHASH> in test.detects two anagrams (test_example_output_truncated.zig)\n try std.testing.checkAllAllocationFailures(\n ^",
`14`	`14`	`"output": "lemons\ncherry\nmelons\nexpected 2, found 0"`
`15`	`15`	`},`
`16`	`16`	`{`
`17`	`17`	`"name": "detects three anagrams",`
`18`	`18`	`"status": "fail",`
`19`		- "message": "FAIL (TestExpectedEqual)\n/opt/zig/lib/std/testing.zig:110:17: <MEMHASH>9 in expectEqualInner__anon_<ANON> (std.zig)\n return error.TestExpectedEqual;\n ^\ntest_example_output_truncated.zig:14:5: <MEMHASH>d in testAnagrams (test_example_output_truncated.zig)\n try testing.expectEqual(expected.len, actual.count());\n ^\n/opt/zig/lib/std/testing.zig:1137:9: <MEMHASH>7 in checkAllAllocationFailures__anon_<ANON> (std.zig)\n try @call(.auto, test_fn, args);\n ^\ntest_example_output_truncated.zig:46:5: <MEMHASH>b in test.detects three anagrams (test_example_output_truncated.zig)\n try std.testing.checkAllAllocationFailures(\n ^",
	`19`	+ "message": "FAIL (TestExpectedEqual)\n/opt/zig/lib/std/testing.zig:118:17: <MEMHASH> in expectEqualInner__anon_<ANON> (std.zig)\n return error.TestExpectedEqual;\n ^\n/opt/zig/lib/std/testing.zig:83:5: <MEMHASH> in expectEqual (test_example_output_truncated.zig)\n return expectEqualInner(T, expected, actual);\n ^\ntest_example_output_truncated.zig:14:5: <MEMHASH> in testAnagrams (test_example_output_truncated.zig)\n try testing.expectEqual(expected.len, actual.count());\n ^\n/opt/zig/lib/std/testing.zig:1124:9: <MEMHASH> in checkAllAllocationFailures__anon_<ANON> (std.zig)\n try @call(.auto, test_fn, .{failing_allocator_inst.allocator()} ++ extra_args);\n ^\ntest_example_output_truncated.zig:46:5: <MEMHASH> in test.detects three anagrams (test_example_output_truncated.zig)\n try std.testing.checkAllAllocationFailures(\n ^",
`20`	`20`	`"output": "gallery\nballerina\nregally\nclergy\nlargely\nleading\nexpected 3, found 0"`
`21`	`21`	`},`
`22`	`22`	`{`
`23`	`23`	`"name": "detects anagrams case-insensitively",`
`24`	`24`	`"status": "fail",`
`25`		- "message": "FAIL (TestExpectedEqual)\n/opt/zig/lib/std/testing.zig:110:17: <MEMHASH>9 in expectEqualInner__anon_<ANON> (std.zig)\n return error.TestExpectedEqual;\n ^\ntest_example_output_truncated.zig:14:5: <MEMHASH>d in testAnagrams (test_example_output_truncated.zig)\n try testing.expectEqual(expected.len, actual.count());\n ^\n/opt/zig/lib/std/testing.zig:1137:9: <MEMHASH>7 in checkAllAllocationFailures__anon_<ANON> (std.zig)\n try @call(.auto, test_fn, args);\n ^\ntest_example_output_truncated.zig:57:5: <MEMHASH>c in test.detects anagrams case-insensitively (test_example_output_truncated.zig)\n try std.testing.checkAllAllocationFailures(\n ^",
	`25`	+ "message": "FAIL (TestExpectedEqual)\n/opt/zig/lib/std/testing.zig:118:17: <MEMHASH> in expectEqualInner__anon_<ANON> (std.zig)\n return error.TestExpectedEqual;\n ^\n/opt/zig/lib/std/testing.zig:83:5: <MEMHASH> in expectEqual (test_example_output_truncated.zig)\n return expectEqualInner(T, expected, actual);\n ^\ntest_example_output_truncated.zig:14:5: <MEMHASH> in testAnagrams (test_example_output_truncated.zig)\n try testing.expectEqual(expected.len, actual.count());\n ^\n/opt/zig/lib/std/testing.zig:1124:9: <MEMHASH> in checkAllAllocationFailures__anon_<ANON> (std.zig)\n try @call(.auto, test_fn, .{failing_allocator_inst.allocator()} ++ extra_args);\n ^\ntest_example_output_truncated.zig:57:5: <MEMHASH> in test.detects anagrams case-insensitively (test_example_output_truncated.zig)\n try std.testing.checkAllAllocationFailures(\n ^",
`26`	`26`	`"output": "cashregister\nCarthorse\nradishes\nexpected 1, found 0"`
`27`	`27`	`},`
`28`	`28`	`{`
`@@ -33,7 +33,7 @@`
`33`	`33`	`{`
`34`	`34`	`"name": "detects many anagrams of 26-letter words",`
`35`	`35`	`"status": "fail",`
`36`		- "message": "FAIL (TestExpectedEqual)\n/opt/zig/lib/std/testing.zig:110:17: <MEMHASH>9 in expectEqualInner__anon_<ANON> (std.zig)\n return error.TestExpectedEqual;\n ^\ntest_example_output_truncated.zig:14:5: <MEMHASH>d in testAnagrams (test_example_output_truncated.zig)\n try testing.expectEqual(expected.len, actual.count());\n ^\n/opt/zig/lib/std/testing.zig:1137:9: <MEMHASH>7 in checkAllAllocationFailures__anon_<ANON> (std.zig)\n try @call(.auto, test_fn, args);\n ^\ntest_example_output_truncated.zig:99:5: <MEMHASH>b in test.detects many anagrams of 26-letter words (test_example_output_truncated.zig)\n try std.testing.checkAllAllocationFailures(\n ^",
	`36`	+ "message": "FAIL (TestExpectedEqual)\n/opt/zig/lib/std/testing.zig:118:17: <MEMHASH> in expectEqualInner__anon_<ANON> (std.zig)\n return error.TestExpectedEqual;\n ^\n/opt/zig/lib/std/testing.zig:83:5: <MEMHASH> in expectEqual (test_example_output_truncated.zig)\n return expectEqualInner(T, expected, actual);\n ^\ntest_example_output_truncated.zig:14:5: <MEMHASH> in testAnagrams (test_example_output_truncated.zig)\n try testing.expectEqual(expected.len, actual.count());\n ^\n/opt/zig/lib/std/testing.zig:1124:9: <MEMHASH> in checkAllAllocationFailures__anon_<ANON> (std.zig)\n try @call(.auto, test_fn, .{failing_allocator_inst.allocator()} ++ extra_args);\n ^\ntest_example_output_truncated.zig:99:5: <MEMHASH> in test.detects many anagrams of 26-letter words (test_example_output_truncated.zig)\n try std.testing.checkAllAllocationFailures(\n ^",
`37`	`37`	"output": "ZYXWVUTSRQPONMLKJIHGFEDCBA\nMNOPQRSTUVWXYZABCDEFGHIJKL\nBADCFEHGJILKNMPORQTSVUXWZY\nQWERTYUIOPASDFGHJKLZXCVBNM\nGHIJKLMNOPQRSTUVWXYZABCDEF\nSTUVWXYZABCDEFGHIJKLMNOPQR\nDCBAEFGHIJKLMNOPQRSTUVWXYZ\nAZBYCXDWEVFUGTHSIRJQKPLOMN\nZAYXBWCVDUESFTGRHQIPJOKLNM\nNMLKJIHGFEDCBAZYXWVUTSRQPO\nBDFHJLNPRTVXZACEGIKMOQSUWY\nYWUSQOMKIGECAXZVTRPNLJHFDB\nJKLMNOPQRSTUVWXYZABCDEFGHI\nPONMLKJIHGFEDCBAZYXWVUTSRQ\nLKJIHGFEDCBAZYXWVUTSRQPONM\nCDEFGHIJKLMNOPQRSTUVWXYZAB\nEFGHIJKLMNOPQRSTUVWXYZABCD\nIJKLMNOPQRSTUVWXYZABCD [output truncated]"
`38`	`38`	`}`
`39`	`39`	`]`
Original file line number	Diff line number	Diff line change
`@@ -21,12 +21,12 @@`
`21`	`21`	`{`
`22`	`22`	`"name": "year divisible by 100, not divisible by 400 in common year",`
`23`	`23`	`"status": "fail",`
`24`		`- "message": "/opt/zig/lib/std/testing.zig:607:14: <MEMHASH>9 in expect (std.zig)\n if (!ok) return error.TestUnexpectedResult;\n ^\ntest_example_partial_fail.zig:23:5: <MEMHASH>a in test.year divisible by 100, not divisible by 400 in common year (test_example_partial_fail.zig)\n try testing.expect(!leap.leap(2100));\n ^"`
	`24`	`+ "message": "/opt/zig/lib/std/testing.zig:615:14: <MEMHASH> in expect (std.zig)\n if (!ok) return error.TestUnexpectedResult;\n ^\ntest_example_partial_fail.zig:23:5: <MEMHASH> in test.year divisible by 100, not divisible by 400 in common year (test_example_partial_fail.zig)\n try testing.expect(!leap.leap(2100));\n ^"`
`25`	`25`	`},`
`26`	`26`	`{`
`27`	`27`	`"name": "year divisible by 100 but not by 3 is still not a leap year",`
`28`	`28`	`"status": "fail",`
`29`		`- "message": "/opt/zig/lib/std/testing.zig:607:14: <MEMHASH>9 in expect (std.zig)\n if (!ok) return error.TestUnexpectedResult;\n ^\ntest_example_partial_fail.zig:27:5: <MEMHASH>a in test.year divisible by 100 but not by 3 is still not a leap year (test_example_partial_fail.zig)\n try testing.expect(!leap.leap(1900));\n ^"`
	`29`	`+ "message": "/opt/zig/lib/std/testing.zig:615:14: <MEMHASH> in expect (std.zig)\n if (!ok) return error.TestUnexpectedResult;\n ^\ntest_example_partial_fail.zig:27:5: <MEMHASH> in test.year divisible by 100 but not by 3 is still not a leap year (test_example_partial_fail.zig)\n try testing.expect(!leap.leap(1900));\n ^"`
`30`	`30`	`},`
`31`	`31`	`{`
`32`	`32`	`"name": "year divisible by 400 is leap year",`
`@@ -39,7 +39,7 @@`
`39`	`39`	`{`
`40`	`40`	`"name": "year divisible by 200, not divisible by 400 in common year",`
`41`	`41`	`"status": "fail",`
`42`		`- "message": "/opt/zig/lib/std/testing.zig:607:14: <MEMHASH>9 in expect (std.zig)\n if (!ok) return error.TestUnexpectedResult;\n ^\ntest_example_partial_fail.zig:39:5: <MEMHASH>a in test.year divisible by 200, not divisible by 400 in common year (test_example_partial_fail.zig)\n try testing.expect(!leap.leap(1800));\n ^"`
	`42`	`+ "message": "/opt/zig/lib/std/testing.zig:615:14: <MEMHASH> in expect (std.zig)\n if (!ok) return error.TestUnexpectedResult;\n ^\ntest_example_partial_fail.zig:39:5: <MEMHASH> in test.year divisible by 200, not divisible by 400 in common year (test_example_partial_fail.zig)\n try testing.expect(!leap.leap(1800));\n ^"`
`43`	`43`	`}`
`44`	`44`	`]`
`45`	`45`	`}`
Original file line number	Diff line number	Diff line change
`@@ -5,7 +5,7 @@`
`5`	`5`	`{`
`6`	`6`	`"name": "greet returns a five-letter greeting",`
`7`	`7`	`"status": "fail",`
`8`		`- "message": "FAIL (TestUnexpectedResult)\n/opt/zig/lib/std/testing.zig:607:14: <MEMHASH>9 in expect (std.zig)\n if (!ok) return error.TestUnexpectedResult;\n ^\ntest_example_user_output.zig:8:5: <MEMHASH>5 in test.greet returns a five-letter greeting (test_example_user_output.zig)\n try testing.expect(result.len == 5);\n ^",`
	`8`	`+ "message": "FAIL (TestUnexpectedResult)\n/opt/zig/lib/std/testing.zig:615:14: <MEMHASH> in expect (std.zig)\n if (!ok) return error.TestUnexpectedResult;\n ^\ntest_example_user_output.zig:8:5: <MEMHASH> in test.greet returns a five-letter greeting (test_example_user_output.zig)\n try testing.expect(result.len == 5);\n ^",`
`9`	`9`	`"output": "debug: computed bad greeting"`
`10`	`10`	`}`
`11`	`11`	`]`