tiny.hypothesis.ConjectureData

1pub const ConjectureData = struct {2    choices: std.ArrayListUnmanaged(ChoiceNode) = .empty,3    spans: std.ArrayListUnmanaged(Span) = .empty,4    byte_blocks: std.ArrayListUnmanaged(u8) = .empty,5    targets: std.ArrayListUnmanaged(TargetObservation) = .empty,6    span_depth: usize = 0,7    status: Status = .valid,8    max_choices: usize = 4096,9    max_input_bytes: usize = default_max_input_bytes,1011    prng: std.Random.DefaultPrng,1213    replay_choices: ?[]const ChoiceNode = null,14    replay_byte_blocks: ?[]const u8 = null,15    replay_index: usize = 0,16    replay_byte_offset: usize = 0,1718    allocator: Allocator,1920    pub fn init(allocator: Allocator, seed: u64) ConjectureData {21        return .{22            .prng = std.Random.DefaultPrng.init(seed),23            .allocator = allocator,24        };25    }2627    pub fn initReplay(28        allocator: Allocator,29        replay_choices: []const ChoiceNode,30        replay_byte_blocks: ?[]const u8,31    ) ConjectureData {32        return .{33            .prng = std.Random.DefaultPrng.init(0),34            .replay_choices = replay_choices,35            .replay_byte_blocks = replay_byte_blocks,36            .allocator = allocator,37        };38    }3940    pub fn deinit(self: *ConjectureData) void {41        self.clearTargets();42        self.choices.deinit(self.allocator);43        self.spans.deinit(self.allocator);44        self.byte_blocks.deinit(self.allocator);45        self.targets.deinit(self.allocator);46    }4748    pub fn beginSpan(self: *ConjectureData, label: []const u8) !void {49        try self.spans.append(self.allocator, .{50            .label = label,51            .start = self.choices.items.len,52            .end = 0,53            .depth = self.span_depth,54        });55        self.span_depth += 1;56    }5758    pub fn endSpan(self: *ConjectureData) void {59        std.debug.assert(self.span_depth > 0);60        self.span_depth -= 1;61        var i = self.spans.items.len;62        while (i > 0) {63            i -= 1;64            if (self.spans.items[i].depth == self.span_depth and65                self.spans.items[i].end == 0)66            {67                self.spans.items[i].end = self.choices.items.len;68                return;69            }70        }71    }7273    pub fn drawInteger(74        self: *ConjectureData,75        min: u64,76        max: u64,77        shrink_towards: u64,78    ) DrawError!u64 {79        if (self.choices.items.len >= self.max_choices) {80            self.status = .overrun;81            return DrawError.Overrun;82        }8384        const value = if (self.replay_choices) |replay| blk: {85            if (self.replay_index >= replay.len) {86                self.status = .overrun;87                return DrawError.Overrun;88            }89            const node = replay[self.replay_index];90            self.replay_index += 1;91            break :blk node.value;92        } else blk: {93            if (min == max) break :blk min;94            const range = max -% min;95            break :blk min +% self.prng.random().intRangeAtMost(u64, 0, range);96        };9798        const clamped = @min(@max(value, min), max);99100        try self.choices.append(self.allocator, .{101            .kind = .integer,102            .value = clamped,103            .min = min,104            .max = max,105            .shrink_towards = shrink_towards,106        });107108        return clamped;109    }110111    pub fn drawBoolean(self: *ConjectureData) DrawError!bool {112        const value = try self.drawInteger(0, 1, 0);113        return value != 0;114    }115116    pub fn drawFloat(117        self: *ConjectureData,118        min: f64,119        max: f64,120    ) DrawError!f64 {121        if (self.choices.items.len >= self.max_choices) {122            self.status = .overrun;123            return DrawError.Overrun;124        }125126        const value = if (self.replay_choices) |replay| blk: {127            if (self.replay_index >= replay.len) {128                self.status = .overrun;129                return DrawError.Overrun;130            }131            const node = replay[self.replay_index];132            self.replay_index += 1;133            break :blk @as(f64, @bitCast(node.value));134        } else blk: {135            const r = self.prng.random();136            const unit: f64 = @as(f64, @floatFromInt(r.int(u52))) /137                @as(f64, @floatFromInt(@as(u52, std.math.maxInt(u52))));138            break :blk min + unit * (max - min);139        };140141        const clamped = @min(@max(value, min), max);142143        try self.choices.append(self.allocator, .{144            .kind = .float,145            .value = @bitCast(clamped),146            .min = @bitCast(min),147            .max = @bitCast(max),148            .shrink_towards = @bitCast(@as(f64, 0.0)),149        });150151        return clamped;152    }153154    pub fn drawBytes(155        self: *ConjectureData,156        min_size: usize,157        max_size: usize,158    ) DrawError![]const u8 {159        const len = try self.drawInteger(160            @intCast(min_size),161            @intCast(max_size),162            @intCast(min_size),163        );164165        const start = self.byte_blocks.items.len;166        const size: usize = @intCast(len);167        std.debug.assert(start <= self.max_input_bytes);168        if (size > self.max_input_bytes - start) {169            self.status = .overrun;170            return DrawError.Overrun;171        }172173        if (self.replay_byte_blocks) |replay_bytes| {174            if (self.replay_byte_offset + size > replay_bytes.len) {175                self.status = .overrun;176                return DrawError.Overrun;177            }178            try self.byte_blocks.appendSlice(179                self.allocator,180                replay_bytes[self.replay_byte_offset..][0..size],181            );182            self.replay_byte_offset += size;183        } else {184            try self.byte_blocks.ensureUnusedCapacity(self.allocator, size);185            for (0..size) |_| {186                self.byte_blocks.appendAssumeCapacity(187                    self.prng.random().int(u8),188                );189            }190        }191192        return self.byte_blocks.items[start..][0..size];193    }194195    pub fn forceInteger(self: *ConjectureData, value: u64) DrawError!void {196        if (self.choices.items.len >= self.max_choices) {197            self.status = .overrun;198            return DrawError.Overrun;199        }200        try self.choices.append(self.allocator, .{201            .kind = .integer,202            .value = value,203            .min = value,204            .max = value,205            .shrink_towards = value,206            .was_forced = true,207        });208    }209210    pub fn target(self: *ConjectureData, observation: anytype, label: []const u8) TargetError!void {211        const value = targetValue(@TypeOf(observation), observation);212        if (!std.math.isFinite(value)) return TargetError.NonFiniteTarget;213        for (self.targets.items) |existing| {214            if (std.mem.eql(u8, existing.label, label)) {215                return TargetError.DuplicateTargetLabel;216            }217        }218        const owned_label = try self.allocator.dupe(u8, label);219        errdefer self.allocator.free(owned_label);220        try self.targets.append(self.allocator, .{221            .label = owned_label,222            .value = value,223        });224    }225226    pub fn targetDefault(self: *ConjectureData, observation: anytype) TargetError!void {227        return self.target(observation, "");228    }229230    pub fn markInteresting(self: *ConjectureData) void {231        self.status = .interesting;232    }233234    pub fn markInvalid(self: *ConjectureData) void {235        self.status = .invalid;236    }237238    pub fn reset(self: *ConjectureData, seed: u64) void {239        self.clearTargets();240        self.choices.clearRetainingCapacity();241        self.spans.clearRetainingCapacity();242        self.byte_blocks.clearRetainingCapacity();243        self.span_depth = 0;244        self.status = .valid;245        self.prng = std.Random.DefaultPrng.init(seed);246        self.replay_choices = null;247        self.replay_byte_blocks = null;248        self.replay_index = 0;249        self.replay_byte_offset = 0;250    }251252    pub fn resetReplay(253        self: *ConjectureData,254        replay_choices: []const ChoiceNode,255        replay_byte_blocks: ?[]const u8,256    ) void {257        self.clearTargets();258        self.choices.clearRetainingCapacity();259        self.spans.clearRetainingCapacity();260        self.byte_blocks.clearRetainingCapacity();261        self.span_depth = 0;262        self.status = .valid;263        self.replay_choices = replay_choices;264        self.replay_byte_blocks = replay_byte_blocks;265        self.replay_index = 0;266        self.replay_byte_offset = 0;267    }268269    fn clearTargets(self: *ConjectureData) void {270        for (self.targets.items) |target_observation| {271            self.allocator.free(target_observation.label);272        }273        self.targets.clearRetainingCapacity();274    }275};

1pub const ConjectureData = conjecture.ConjectureData;