Fix a few bugs (#1)

Author: habedi

README.md

@@ -38,7 +38,7 @@ following steps:
 2. Finding cases where the input causes the property to fail.
 3. Finding smaller subsets of the failing input that still cause the failure (this is called "shrinking").
 
-For example, consider the property of a `reverse(s: []const u8)` function that states that reversing
+For example, consider the property of a `reverse` function that states that reversing
 a string twice should return the original string.
 In property-based testing, you would define this property and let the framework generate a lot of random strings to
 test it.
@@ -112,6 +112,15 @@ const std = @import("std");
 const minish = @import("minish");
 const gen = minish.gen;
 
+// Helper function to reverse a string
+fn reverse(allocator: std.mem.Allocator, s: []const u8) ![]u8 {
+    const result = try allocator.alloc(u8, s.len);
+    for (s, 0..) |c, i| {
+        result[s.len - 1 - i] = c;
+    }
+    return result;
+}
+
 // Property: reversing a string twice returns the original
 fn reverse_twice_is_identity(s: []const u8) !void {
     var gpa = std.heap.GeneralPurposeAllocator(.{}){};

build.zig.zon

@@ -1,6 +1,6 @@
 .{
     .name = .minish,
-    .version = "0.1.0-alpha.1",
+    .version = "0.1.0",
     .fingerprint = 0x4a0e1bdb4d520b49, // Changing this has security and trust implications.
     .minimum_zig_version = "0.15.2",
     .dependencies = .{ .chilli = .{

logo.svg

@@ -2,9 +2,10 @@
 //!
 //! A property-based testing framework for Zig, inspired by [QuickCheck](https://hackage.haskell.org/package/QuickCheck) and [Hypothesis](https://hypothesis.readthedocs.io/en/latest/).
 //!
-//! Minish automatically generates random test cases and, on failure, minimises (shrinks)
+//! Minish automatically generates random test cases and, on failure, minimises (or shrinks)
 //! the input to the smallest value that still reproduces the failure. This makes debugging
 //! property violations a lot easier.
+//!
 //! ## Quick Start
 //!
 //! ```zig
@@ -49,7 +50,7 @@ pub const TestCase = @import("minish/core.zig").TestCase;
 /// Errors that can occur during generation.
 pub const GenError = @import("minish/core.zig").GenError;
 
-/// Run property-based tests with the given generator and property function.
+/// Run the tests with the given generator and property function.
 pub const check = @import("minish/runner.zig").check;
 
 /// Configuration options for property tests.

src/lib.zig

@@ -24,6 +24,10 @@ const Generator = gen.Generator;
 /// // Convert generated integers to strings
 /// const string_gen = combinators.map(i32, []const u8, gen.int(i32), intToString);
 /// ```
+///
+/// Note: If base_gen allocates memory and map_fn transforms to a different type,
+/// the base value is freed after transformation. If map_fn returns a type that
+/// also needs freeing, you must provide that through the result generator.
 pub fn map(
     comptime T: type,
     comptime U: type,
@@ -33,9 +37,16 @@ pub fn map(
     const MapGenerator = struct {
         fn generate(tc: *TestCase) core.GenError!U {
             const base_value = try base_gen.generateFn(tc);
-            return map_fn(base_value);
+            const result = map_fn(base_value);
+            // Free the base value after transformation if it was allocated
+            if (base_gen.freeFn) |freeFn| {
+                freeFn(tc.allocator, base_value);
+            }
+            return result;
         }
     };
+    // Note: freeFn is null because the mapped result U may have different
+    // memory semantics. Users should use a wrapper if U needs freeing.
     return .{ .generateFn = MapGenerator.generate, .shrinkFn = null, .freeFn = null };
 }
 
@@ -50,6 +61,8 @@ pub fn map(
 /// // Generate a length, then a list of that length
 /// const list_gen = combinators.flatMap(usize, []const u8, gen.intRange(usize, 1, 10), makeListGen);
 /// ```
+///
+/// Note: The base value is freed after the next generator is created and produces a result.
 pub fn flatMap(
     comptime T: type,
     comptime U: type,
@@ -60,7 +73,20 @@ pub fn flatMap(
         fn generate(tc: *TestCase) core.GenError!U {
             const base_value = try base_gen.generateFn(tc);
             const next_gen = flat_fn(base_value);
-            return next_gen.generateFn(tc);
+            const result = try next_gen.generateFn(tc);
+            // Free the base value after we're done using it
+            if (base_gen.freeFn) |freeFn| {
+                freeFn(tc.allocator, base_value);
+            }
+            return result;
+        }
+
+        fn free(allocator: std.mem.Allocator, value: U) void {
+            // Try to free using the result generator's freeFn
+            // Note: This is a best-effort approach since we don't know which
+            // specific generator was used (depends on base_value at runtime)
+            _ = allocator;
+            _ = value;
         }
     };
     return .{ .generateFn = FlatMapGenerator.generate, .shrinkFn = null, .freeFn = null };
@@ -219,3 +245,66 @@ test "filter memory leak regression test" {
 
     try runner.check(allocator, filtered_gen, Props.prop_no_op, opts);
 }
+
+test "regression: map combinator frees base value" {
+    // Bug: Map combinator didn't free the base value after transformation
+    // Fix: Added freeFn call after map_fn is applied
+    const runner = @import("runner.zig");
+    const allocator = std.testing.allocator;
+
+    // Generate a string (which allocates) and map it to its length (which doesn't)
+    const str_gen = comptime gen.string(.{ .min_len = 1, .max_len = 10 });
+
+    const getLen = struct {
+        fn func(s: []const u8) usize {
+            return s.len;
+        }
+    }.func;
+
+    const len_gen = map([]const u8, usize, str_gen, getLen);
+
+    const opts = runner.Options{ .seed = 222, .num_runs = 20 };
+
+    const Props = struct {
+        fn prop_check_len(len: usize) !void {
+            // Just verify the length is in expected range
+            try std.testing.expect(len >= 1 and len <= 10);
+        }
+    };
+
+    // If map doesn't free the base string, this will leak memory
+    // and the test allocator will catch it
+    try runner.check(allocator, len_gen, Props.prop_check_len, opts);
+}
+
+test "flatMap combinator chains generators" {
+    const runner = @import("runner.zig");
+    const allocator = std.testing.allocator;
+
+    // Generate a number, then use it to determine which generator to use
+    const makeGen = struct {
+        fn make(x: i32) gen.Generator(i32) {
+            // If x is even, return 0; if odd, return 1
+            if (@mod(x, 2) == 0) {
+                return gen.constant(@as(i32, 0));
+            } else {
+                return gen.constant(@as(i32, 1));
+            }
+        }
+    }.make;
+
+    const flat_gen = flatMap(i32, i32, gen.intRange(i32, 0, 10), makeGen);
+
+    const Props = struct {
+        fn prop(x: i32) !void {
+            // Result should be either 0 or 1
+            try std.testing.expect(x == 0 or x == 1);
+        }
+    };
+
+    try runner.check(allocator, flat_gen, Props.prop, .{ .seed = 333, .num_runs = 20 });
+}
+
+// Note: sized combinator not tested because it requires generators that take
+// runtime size parameters, but most generators use comptime parameters.
+// It's primarily for custom use cases.