Update to Zig 0.15.1

Author: cryptocode

.github/workflows/zig.yml

@@ -18,14 +18,14 @@ jobs:
           - macos-latest
           - windows-latest
           - ubuntu-24.04-arm
-        zig_version: [ "0.14.0-dev.3187+d4c85079c", "master" ]
+        zig_version: [ "master" ]
 
     steps:      
       - name: Check out repository
         uses: actions/checkout@v4
 
       - name: Install Zig
-        uses: mlugg/setup-zig@v1
+        uses: mlugg/setup-zig@v2
         with:
           version: ${{ matrix.zig_version }}
 

README.md

@@ -2,7 +2,7 @@
 
 Marble is a [metamorphic testing](https://en.wikipedia.org/wiki/Metamorphic_testing) library for Zig.
 
-This library tracks Zig master and was last tested on `0.14.0-dev.3187+d4c85079c`
+The main branch tracks Zig master. Use a tagged release to target a specific Zig version.
 
 Metamorphic testing is a powerful technique that provides additional test coverage by applying a number of transformations to test input, and then checking if certain relations still hold between the outputs. Marble will automatically run through all possible combinations of these transformations.
 
@@ -30,13 +30,6 @@ zig build
 zig build test
 ```
 
-## Importing the library
-Add Marble as a Zig package in your build file, or simply import it directly after vendoring/adding a submodule:
-
-```zig
-const marble = @import("marble/main.zig");
-```
-
 ## Writing tests
 
 A metamorphic Zig test looks something like this:
@@ -73,12 +66,12 @@ const SinusTest = struct {
     }
 };
 
-test "sinus" {
-    var i: f64 = 1;
-    while (i < 100) : (i += 1) {
-        var t = SinusTest{ .value = i };
-        try std.testing.expect(try marble.run(SinusTest, &t, .{}));
-    }
+...
+
+var i: f64 = 1;
+while (i < 100) : (i += 1) {
+    var t = SinusTest{ .value = i };
+    try std.testing.expect(try marble.run(SinusTest, &t, allocator, .{}));
 }
 ```
 

build.zig

@@ -8,19 +8,23 @@ pub fn build(b: *std.Build) void {
         .root_source_file = b.path("src/main.zig"),
     });
 
-    const lib = b.addStaticLibrary(.{
+    const lib = b.addLibrary(.{
         .name = "marble",
-        .root_source_file = b.path("src/main.zig"),
-        .target = target,
-        .optimize = optimize,
+        .root_module = b.createModule(.{
+            .root_source_file = b.path("src/main.zig"),
+            .target = target,
+            .optimize = optimize,
+        }),
     });
     b.installArtifact(lib);
 
     const tests = b.addTest(.{
         .name = "example_tests",
-        .root_source_file = b.path("src/example_tests.zig"),
-        .target = target,
-        .optimize = optimize,
+        .root_module = b.createModule(.{
+            .root_source_file = b.path("src/example_tests.zig"),
+            .target = target,
+            .optimize = optimize,
+        }),
     });
     tests.root_module.addImport("marble", marble_mod);
 

src/example_tests.zig

@@ -37,7 +37,7 @@ test "sinus" {
     var i: f64 = 1;
     while (i < 100) : (i += 1) {
         var t = SinusTest{ .value = i };
-        try std.testing.expect(try marble.run(SinusTest, &t, .{}));
+        try std.testing.expect(try marble.run(SinusTest, &t, std.testing.allocator, .{}));
     }
 }
 
@@ -98,7 +98,7 @@ const QueryTest = struct {
 
 test "query" {
     var query_test = QueryTest{ .value = .{} };
-    try std.testing.expect(try marble.run(QueryTest, &query_test, .{ .skip_combinations = false, .verbose = false }));
+    try std.testing.expect(try marble.run(QueryTest, &query_test, std.testing.allocator, .{ .skip_combinations = false, .verbose = false }));
 }
 
 /// Test some metamorphic relations of binary search
@@ -161,6 +161,6 @@ test "std.sort.binarySearch" {
     var i: usize = 0;
     while (i < array.len) : (i += 1) {
         var bs_test = BinarySearchTest{ .value = i, .arr = array };
-        try std.testing.expect(try marble.run(BinarySearchTest, &bs_test, .{ .skip_combinations = true }));
+        try std.testing.expect(try marble.run(BinarySearchTest, &bs_test, std.testing.allocator, .{ .skip_combinations = true }));
     }
 }

src/main.zig

@@ -6,19 +6,19 @@ const std = @import("std");
 /// Generate an (n take r) list of transformer indices
 /// Number of combinations returned is n! / (r! (n-r)!)
 fn generateCombinations(n: usize, r: usize, allocator: std.mem.Allocator) !std.ArrayList(std.ArrayList(usize)) {
-    var combinations = std.ArrayList(std.ArrayList(usize)).init(allocator);
-    var combination = std.ArrayList(usize).init(allocator);
+    var combinations = std.ArrayList(std.ArrayList(usize)).empty;
+    var combination = std.ArrayList(usize).empty;
 
     // Start with the smallest lexicographic combination
     {
         var i: usize = 0;
         while (i < r) : (i += 1) {
-            try combination.append(i);
+            try combination.append(allocator, i);
         }
     }
 
     while (combination.items[r - 1] < n) {
-        try combinations.append(try combination.clone());
+        try combinations.append(allocator, try combination.clone(allocator));
 
         // Next combination in lexicographic order
         var k = r - 1;
@@ -38,10 +38,10 @@ fn generateCombinations(n: usize, r: usize, allocator: std.mem.Allocator) !std.A
 
 /// Generate the combinations for every n = 0..count-1 and r = 1..count
 fn generateAllCombinations(transformation_count: usize, allocator: std.mem.Allocator) !std.ArrayList(std.ArrayList(usize)) {
-    var res = std.ArrayList(std.ArrayList(usize)).init(allocator);
+    var res = std.ArrayList(std.ArrayList(usize)).empty;
     var i: usize = 1;
     while (i <= transformation_count) : (i += 1) {
-        try res.appendSlice((try generateCombinations(transformation_count, i, allocator)).items[0..]);
+        try res.appendSlice(allocator, (try generateCombinations(transformation_count, i, allocator)).items[0..]);
     }
     return res;
 }
@@ -88,7 +88,7 @@ pub const RunConfiguration = struct {
 };
 
 /// Run a testcase, returns true if all succeed
-pub fn run(comptime T: type, testcase: *T, config: RunConfiguration) !bool {
+pub fn run(comptime T: type, testcase: *T, allocator: std.mem.Allocator, config: RunConfiguration) !bool {
     if (config.verbose) std.debug.print("\n", .{});
     const metamorphicTest = comptime findTransformers(T);
     if (@hasDecl(T, "before")) testcase.before(Phase.Test);
@@ -99,9 +99,9 @@ pub fn run(comptime T: type, testcase: *T, config: RunConfiguration) !bool {
     // holds after transformations.
     const org_output = testcase.execute();
 
-    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    var arena = std.heap.ArenaAllocator.init(allocator);
     defer arena.deinit();
-    var combinations = try generateAllCombinations(metamorphicTest.len, arena.allocator());
+    const combinations = try generateAllCombinations(metamorphicTest.len, arena.allocator());
     for (combinations.items) |combination| {
         if (combination.items.len > 1 and config.skip_combinations) {
             if (config.verbose) std.debug.print("Skipping transformation combinations\n", .{});
@@ -143,9 +143,5 @@ pub fn run(comptime T: type, testcase: *T, config: RunConfiguration) !bool {
 
     if (@hasDecl(T, "after")) testcase.after(Phase.Test);
 
-    for (combinations.items) |*combination| {
-        combination.deinit();
-    }
-    combinations.deinit();
     return true;
 }