test: make CI exercise maintained integrations

Review threads live on the whole diff, not on one commit, so none are shown here - a thread's line means something in the branch's final form, and painting it into an intermediate step would put it on code it is not about.

README.mdmodified+5-1

Changes to README.md

		⋯756 linesShow the 756 lines above this hunk@@ -757,10 +757,14 @@ zig build
757	757	# Run self-tests
758	758	zig build test
759	759
760		-# Run examples
	760	+# Run the basic and advanced examples, and compile-check every example
761	761	zig build examples
762	762	```
763	763
	764	+The async, snapshot, progress, and timeout examples are compile-checked rather
	765	+than executed by this step because they intentionally demonstrate delays,
	766	+generated files, interactive output, or failure handling.
	767	+
764	768	## Requirements
765	769
766	770	- The exact Zig development build recorded in [`.zig-version`](.zig-version)

build.zigmodified+87-2

Changes to build.zig

		⋯18 linesShow the 18 lines above this hunk@@ -19,6 +19,9 @@ pub fn build(b: *std.Build) void {
19	19	.target = target,
20	20	.optimize = optimize,
21	21	.link_libc = true,
	22	+ .imports = &.{
	23	+ .{ .name = "zig_test_framework", .module = lib_module },
	24	+ },
22	25	}),
23	26	});
24	27
		⋯21 linesShow the 21 lines above this hunk@@ -46,6 +49,9 @@ pub fn build(b: *std.Build) void {
46	49	.target = target,
47	50	.optimize = optimize,
48	51	.link_libc = true,
	52	+ .imports = &.{
	53	+ .{ .name = "zig_test_framework", .module = lib_module },
	54	+ },
49	55	}),
50	56	});
51	57	const run_test_runner_tests = b.addRunArtifact(test_runner_tests);
		⋯5 linesShow the 5 lines above this hunk@@ -57,6 +63,9 @@ pub fn build(b: *std.Build) void {
57	63	.target = target,
58	64	.optimize = optimize,
59	65	.link_libc = true,
	66	+ .imports = &.{
	67	+ .{ .name = "zig_test_framework", .module = lib_module },
	68	+ },
60	69	}),
61	70	});
62	71	const run_assertions_tests = b.addRunArtifact(assertions_tests);
		⋯5 linesShow the 5 lines above this hunk@@ -68,6 +77,9 @@ pub fn build(b: *std.Build) void {
68	77	.target = target,
69	78	.optimize = optimize,
70	79	.link_libc = true,
	80	+ .imports = &.{
	81	+ .{ .name = "zig_test_framework", .module = lib_module },
	82	+ },
71	83	}),
72	84	});
73	85	const run_suite_tests = b.addRunArtifact(suite_tests);
		⋯5 linesShow the 5 lines above this hunk@@ -79,6 +91,9 @@ pub fn build(b: *std.Build) void {
79	91	.target = target,
80	92	.optimize = optimize,
81	93	.link_libc = true,
	94	+ .imports = &.{
	95	+ .{ .name = "zig_test_framework", .module = lib_module },
	96	+ },
82	97	}),
83	98	});
84	99	const run_matchers_tests = b.addRunArtifact(matchers_tests);
		⋯23 linesShow the 23 lines above this hunk@@ -108,6 +123,9 @@ pub fn build(b: *std.Build) void {
108	123	.target = target,
109	124	.optimize = optimize,
110	125	.link_libc = true,
	126	+ .imports = &.{
	127	+ .{ .name = "zig_test_framework", .module = lib_module },
	128	+ },
111	129	}),
112	130	});
113	131	const run_reporter_tests = b.addRunArtifact(reporter_tests);
		⋯5 linesShow the 5 lines above this hunk@@ -119,6 +137,9 @@ pub fn build(b: *std.Build) void {
119	137	.target = target,
120	138	.optimize = optimize,
121	139	.link_libc = true,
	140	+ .imports = &.{
	141	+ .{ .name = "zig_test_framework", .module = lib_module },
	142	+ },
122	143	}),
123	144	});
124	145	const run_cli_tests = b.addRunArtifact(cli_tests);
		⋯19 linesShow the 19 lines above this hunk@@ -144,6 +165,9 @@ pub fn build(b: *std.Build) void {
144	165	.target = target,
145	166	.optimize = optimize,
146	167	.link_libc = true,
	168	+ .imports = &.{
	169	+ .{ .name = "zig_test_framework", .module = lib_module },
	170	+ },
147	171	}),
148	172	});
149	173	const run_mock_tests = b.addRunArtifact(mock_tests);
		⋯59 linesShow the 59 lines above this hunk@@ -209,11 +233,14 @@ pub fn build(b: *std.Build) void {
209	233	test_step.dependOn(&run_assertions_tests.step);
210	234	test_step.dependOn(&run_suite_tests.step);
211	235	test_step.dependOn(&run_matchers_tests.step);
212		- // Note: hooks_test is an executable, run with 'zig build test-hooks'
	236	+ test_step.dependOn(&run_hooks_tests.step);
213	237	test_step.dependOn(&run_reporter_tests.step);
214	238	test_step.dependOn(&run_cli_tests.step);
215	239	test_step.dependOn(&run_filter_tests.step);
216	240	test_step.dependOn(&run_mock_tests.step);
	241	+ test_step.dependOn(&run_comprehensive_mock_tests.step);
	242	+ test_step.dependOn(&run_snapshot_usage_tests.step);
	243	+ test_step.dependOn(&run_time_tests.step);
217	244
218	245	// Examples
219	246	const basic_example = b.addExecutable(.{
		⋯25 linesShow the 25 lines above this hunk@@ -245,7 +272,65 @@ pub fn build(b: *std.Build) void {
245	272	const run_basic_example = b.addRunArtifact(basic_example);
246	273	const run_advanced_example = b.addRunArtifact(advanced_example);
247	274
248		- const examples_step = b.step("examples", "Run all examples");
	275	+ // These showcase intentionally slow, interactive, or failure-oriented
	276	+ // scenarios, so keep them compile-only while still checking every example.
	277	+ const async_examples = b.addExecutable(.{
	278	+ .name = "async_examples",
	279	+ .root_module = b.createModule(.{
	280	+ .root_source_file = b.path("examples/async_tests.zig"),
	281	+ .target = target,
	282	+ .optimize = optimize,
	283	+ .link_libc = true,
	284	+ .imports = &.{
	285	+ .{ .name = "zig_test", .module = lib_module },
	286	+ },
	287	+ }),
	288	+ });
	289	+
	290	+ const snapshot_examples = b.addExecutable(.{
	291	+ .name = "snapshot_examples",
	292	+ .root_module = b.createModule(.{
	293	+ .root_source_file = b.path("examples/snapshot_examples.zig"),
	294	+ .target = target,
	295	+ .optimize = optimize,
	296	+ .link_libc = true,
	297	+ .imports = &.{
	298	+ .{ .name = "zig_test", .module = lib_module },
	299	+ },
	300	+ }),
	301	+ });
	302	+
	303	+ const progress_examples = b.addExecutable(.{
	304	+ .name = "progress_examples",
	305	+ .root_module = b.createModule(.{
	306	+ .root_source_file = b.path("examples/progress_examples.zig"),
	307	+ .target = target,
	308	+ .optimize = optimize,
	309	+ .link_libc = true,
	310	+ .imports = &.{
	311	+ .{ .name = "zig_test", .module = lib_module },
	312	+ },
	313	+ }),
	314	+ });
	315	+
	316	+ const timeout_examples = b.addExecutable(.{
	317	+ .name = "timeout_examples",
	318	+ .root_module = b.createModule(.{
	319	+ .root_source_file = b.path("examples/timeout_examples.zig"),
	320	+ .target = target,
	321	+ .optimize = optimize,
	322	+ .link_libc = true,
	323	+ .imports = &.{
	324	+ .{ .name = "zig_test", .module = lib_module },
	325	+ },
	326	+ }),
	327	+ });
	328	+
	329	+ const examples_step = b.step("examples", "Run core examples and compile all examples");
249	330	examples_step.dependOn(&run_basic_example.step);
250	331	examples_step.dependOn(&run_advanced_example.step);
	332	+ examples_step.dependOn(&async_examples.step);
	333	+ examples_step.dependOn(&snapshot_examples.step);
	334	+ examples_step.dependOn(&progress_examples.step);
	335	+ examples_step.dependOn(&timeout_examples.step);
251	336	}

examples/async_tests.zigmodified+12-12

Changes to examples/async_tests.zig

		⋯17 linesShow the 17 lines above this hunk@@ -18,7 +18,7 @@ pub fn example_basic_async_test() !void {
18	18	fn run(alloc: std.mem.Allocator) !void {
19	19	_ = alloc;
20	20	// Simulate async work
21		- std.Thread.sleep(100 * std.time.ns_per_ms);
	21	+ zig_test.compat.sleep(100 * std.time.ns_per_ms);
22	22	std.debug.print("Async test 1 completed\n", .{});
23	23	}
24	24	}.run;
		⋯29 linesShow the 29 lines above this hunk@@ -54,7 +54,7 @@ pub fn example_async_timeout() !void {
54	54	const slowTest = struct {
55	55	fn run(alloc: std.mem.Allocator) !void {
56	56	_ = alloc;
57		- std.Thread.sleep(500 * std.time.ns_per_ms); // Takes too long
	57	+ zig_test.compat.sleep(500 * std.time.ns_per_ms); // Takes too long
58	58	}
59	59	}.run;
60	60
		⋯26 linesShow the 26 lines above this hunk@@ -87,7 +87,7 @@ pub fn example_concurrent_async() !void {
87	87	const asyncTest = struct {
88	88	fn run(alloc: std.mem.Allocator) !void {
89	89	_ = alloc;
90		- std.Thread.sleep(50 * std.time.ns_per_ms);
	90	+ zig_test.compat.sleep(50 * std.time.ns_per_ms);
91	91	}
92	92	}.run;
93	93
		⋯3 linesShow the 3 lines above this hunk@@ -97,10 +97,10 @@ pub fn example_concurrent_async() !void { renamed throughout
97	97	try executor.registerTest("concurrent_4", asyncTest);
98	98	try executor.registerTest("concurrent_5", asyncTest);
99	99
100		- const start = std.time.nanoTimestamp();
	100	+ const start = zig_test.compat.nanoTimestamp();
101	101	const results = try executor.executeAll();
102	102	defer allocator.free(results);
103		- const duration = std.time.nanoTimestamp() - start;
	103	+ const duration = zig_test.compat.nanoTimestamp() - start;
104	104
105	105	std.debug.print("Total duration: {d:.2}ms\n", .{
106	106	@as(f64, @floatFromInt(duration)) / 1_000_000.0,
		⋯14 linesShow the 14 lines above this hunk@@ -121,7 +121,7 @@ pub fn example_async_hooks() !void {
121	121	fn run(alloc: std.mem.Allocator) !void {
122	122	_ = alloc;
123	123	std.debug.print("Before hook executed\n", .{});
124		- std.Thread.sleep(10 * std.time.ns_per_ms);
	124	+ zig_test.compat.sleep(10 * std.time.ns_per_ms);
125	125	}
126	126	}.run;
127	127
		⋯1 lineShow the 1 line above this hunk@@ -129,7 +129,7 @@ pub fn example_async_hooks() !void {
129	129	fn run(alloc: std.mem.Allocator) !void {
130	130	_ = alloc;
131	131	std.debug.print("After hook executed\n", .{});
132		- std.Thread.sleep(10 * std.time.ns_per_ms);
	132	+ zig_test.compat.sleep(10 * std.time.ns_per_ms);
133	133	}
134	134	}.run;
135	135
		⋯14 linesShow the 14 lines above this hunk@@ -150,7 +150,7 @@ pub fn example_suite_async() !void {
150	150	const asyncTest1 = struct {
151	151	fn run(alloc: std.mem.Allocator) !void {
152	152	_ = alloc;
153		- std.Thread.sleep(50 * std.time.ns_per_ms);
	153	+ zig_test.compat.sleep(50 * std.time.ns_per_ms);
154	154	std.debug.print("Suite async test 1 passed\n", .{});
155	155	}
156	156	}.run;
		⋯1 lineShow the 1 line above this hunk@@ -158,7 +158,7 @@ pub fn example_suite_async() !void {
158	158	const asyncTest2 = struct {
159	159	fn run(alloc: std.mem.Allocator) !void {
160	160	_ = alloc;
161		- std.Thread.sleep(50 * std.time.ns_per_ms);
	161	+ zig_test.compat.sleep(50 * std.time.ns_per_ms);
162	162	std.debug.print("Suite async test 2 passed\n", .{});
163	163	}
164	164	}.run;
		⋯22 linesShow the 22 lines above this hunk@@ -187,7 +187,7 @@ pub fn example_mixed_tests() !void {
187	187	const asyncTest = struct {
188	188	fn run(alloc: std.mem.Allocator) !void {
189	189	_ = alloc;
190		- std.Thread.sleep(50 * std.time.ns_per_ms);
	190	+ zig_test.compat.sleep(50 * std.time.ns_per_ms);
191	191	std.debug.print("Async test executed\n", .{});
192	192	}
193	193	}.run;
		⋯18 linesShow the 18 lines above this hunk@@ -212,7 +212,7 @@ pub fn example_async_errors() !void {
212	212	const passingTest = struct {
213	213	fn run(alloc: std.mem.Allocator) !void {
214	214	_ = alloc;
215		- std.Thread.sleep(10 * std.time.ns_per_ms);
	215	+ zig_test.compat.sleep(10 * std.time.ns_per_ms);
216	216	}
217	217	}.run;
218	218
		⋯1 lineShow the 1 line above this hunk@@ -220,7 +220,7 @@ pub fn example_async_errors() !void {
220	220	const failingTest = struct {
221	221	fn run(alloc: std.mem.Allocator) !void {
222	222	_ = alloc;
223		- std.Thread.sleep(10 * std.time.ns_per_ms);
	223	+ zig_test.compat.sleep(10 * std.time.ns_per_ms);
224	224	return error.AsyncTestFailed;
225	225	}
226	226	}.run;

examples/progress_examples.zigmodified+23-23

Changes to examples/progress_examples.zig

		⋯10 linesShow the 10 lines above this hunk@@ -11,7 +11,7 @@ pub fn example_basic_spinner() !void {
11	11	defer spinner.deinit();
12	12
13	13	try spinner.start();
14		- std.Thread.sleep(2000 * std.time.ns_per_ms);
	14	+ zig_test.compat.sleep(2000 * std.time.ns_per_ms);
15	15	spinner.succeed("Data loaded successfully");
16	16	}
17	17
		⋯22 linesShow the 22 lines above this hunk@@ -40,7 +40,7 @@ pub fn example_spinner_styles() !void {
40	40	defer spinner.deinit();
41	41
42	42	try spinner.start();
43		- std.Thread.sleep(1000 * std.time.ns_per_ms);
	43	+ zig_test.compat.sleep(1000 * std.time.ns_per_ms);
44	44	spinner.succeed(try std.fmt.allocPrint(allocator, "{s} style complete", .{style_name}));
45	45	allocator.free(try std.fmt.allocPrint(allocator, "{s} style complete", .{style_name}));
46	46	}
		⋯9 linesShow the 9 lines above this hunk@@ -56,28 +56,28 @@ pub fn example_spinner_outcomes() !void { renamed throughout
56	56	var spinner1 = try zig_test.Spinner.init(allocator, "Operation 1...", .dots);
57	57	defer spinner1.deinit();
58	58	try spinner1.start();
59		- std.Thread.sleep(500 * std.time.ns_per_ms);
	59	+ zig_test.compat.sleep(500 * std.time.ns_per_ms);
60	60	spinner1.succeed("Operation 1 succeeded");
61	61
62	62	// Failure
63	63	var spinner2 = try zig_test.Spinner.init(allocator, "Operation 2...", .dots);
64	64	defer spinner2.deinit();
65	65	try spinner2.start();
66		- std.Thread.sleep(500 * std.time.ns_per_ms);
	66	+ zig_test.compat.sleep(500 * std.time.ns_per_ms);
67	67	spinner2.fail("Operation 2 failed");
68	68
69	69	// Warning
70	70	var spinner3 = try zig_test.Spinner.init(allocator, "Operation 3...", .dots);
71	71	defer spinner3.deinit();
72	72	try spinner3.start();
73		- std.Thread.sleep(500 * std.time.ns_per_ms);
	73	+ zig_test.compat.sleep(500 * std.time.ns_per_ms);
74	74	spinner3.warn("Operation 3 has warnings");
75	75
76	76	// Info
77	77	var spinner4 = try zig_test.Spinner.init(allocator, "Operation 4...", .dots);
78	78	defer spinner4.deinit();
79	79	try spinner4.start();
80		- std.Thread.sleep(500 * std.time.ns_per_ms);
	80	+ zig_test.compat.sleep(500 * std.time.ns_per_ms);
81	81	spinner4.info("Operation 4 information");
82	82	}
83	83
		⋯12 linesShow the 12 lines above this hunk@@ -96,7 +96,7 @@ pub fn example_basic_progress_bar() !void {
96	96	var i: usize = 0;
97	97	while (i <= 100) : (i += 5) {
98	98	bar.update(i);
99		- std.Thread.sleep(100 * std.time.ns_per_ms);
	99	+ zig_test.compat.sleep(100 * std.time.ns_per_ms);
100	100	}
101	101	bar.finish();
102	102	}
		⋯26 linesShow the 26 lines above this hunk@@ -129,7 +129,7 @@ pub fn example_progress_bar_styles() !void {
129	129	var i: usize = 0;
130	130	while (i <= 50) : (i += 5) {
131	131	bar.update(i);
132		- std.Thread.sleep(50 * std.time.ns_per_ms);
	132	+ zig_test.compat.sleep(50 * std.time.ns_per_ms);
133	133	}
134	134	bar.finish();
135	135	}
		⋯15 linesShow the 15 lines above this hunk@@ -151,7 +151,7 @@ pub fn example_progress_bar_options() !void {
151	151	var i: usize = 0;
152	152	while (i <= 50) : (i += 10) {
153	153	bar1.update(i);
154		- std.Thread.sleep(100 * std.time.ns_per_ms);
	154	+ zig_test.compat.sleep(100 * std.time.ns_per_ms);
155	155	}
156	156	bar1.finish();
157	157
		⋯7 linesShow the 7 lines above this hunk@@ -165,7 +165,7 @@ pub fn example_progress_bar_options() !void {
165	165	i = 0;
166	166	while (i <= 50) : (i += 10) {
167	167	bar2.update(i);
168		- std.Thread.sleep(100 * std.time.ns_per_ms);
	168	+ zig_test.compat.sleep(100 * std.time.ns_per_ms);
169	169	}
170	170	bar2.finish();
171	171
		⋯8 linesShow the 8 lines above this hunk@@ -180,7 +180,7 @@ pub fn example_progress_bar_options() !void {
180	180	i = 0;
181	181	while (i <= 50) : (i += 10) {
182	182	bar3.update(i);
183		- std.Thread.sleep(100 * std.time.ns_per_ms);
	183	+ zig_test.compat.sleep(100 * std.time.ns_per_ms);
184	184	}
185	185	bar3.finish();
186	186	}
		⋯26 linesShow the 26 lines above this hunk@@ -213,7 +213,7 @@ pub fn example_test_progress() !void {
213	213
214	214	for (test_names, 0..) |name, i| {
215	215	try progress.startTest(name);
216		- std.Thread.sleep(200 * std.time.ns_per_ms);
	216	+ zig_test.compat.sleep(200 * std.time.ns_per_ms);
217	217
218	218	// Simulate different outcomes
219	219	const passed = i != 3; // Fail the 4th test
		⋯22 linesShow the 22 lines above this hunk@@ -242,7 +242,7 @@ pub fn example_test_progress_minimal() !void {
242	242	defer allocator.free(name);
243	243
244	244	try progress.startTest(name);
245		- std.Thread.sleep(100 * std.time.ns_per_ms);
	245	+ zig_test.compat.sleep(100 * std.time.ns_per_ms);
246	246	progress.completeTest(true, false);
247	247	}
248	248
		⋯14 linesShow the 14 lines above this hunk@@ -263,14 +263,14 @@ pub fn example_multi_spinner() !void { renamed throughout
263	263	try multi.add("task2", "Processing task 2...");
264	264	try multi.add("task3", "Processing task 3...");
265	265
266		- std.Thread.sleep(1000 * std.time.ns_per_ms);
	266	+ zig_test.compat.sleep(1000 * std.time.ns_per_ms);
267	267
268	268	// Complete tasks at different times
269	269	multi.succeed("task1", "Task 1 complete");
270		- std.Thread.sleep(500 * std.time.ns_per_ms);
	270	+ zig_test.compat.sleep(500 * std.time.ns_per_ms);
271	271
272	272	multi.fail("task2", "Task 2 failed");
273		- std.Thread.sleep(500 * std.time.ns_per_ms);
	273	+ zig_test.compat.sleep(500 * std.time.ns_per_ms);
274	274
275	275	multi.succeed("task3", "Task 3 complete");
276	276	}
		⋯12 linesShow the 12 lines above this hunk@@ -289,7 +289,7 @@ pub fn example_progress_increment() !void {
289	289	var i: usize = 0;
290	290	while (i < 20) : (i += 1) {
291	291	bar.increment();
292		- std.Thread.sleep(100 * std.time.ns_per_ms);
	292	+ zig_test.compat.sleep(100 * std.time.ns_per_ms);
293	293	}
294	294	bar.finish();
295	295	}
		⋯8 linesShow the 8 lines above this hunk@@ -304,13 +304,13 @@ pub fn example_spinner_update() !void { renamed throughout
304	304	defer spinner.deinit();
305	305
306	306	try spinner.start();
307		- std.Thread.sleep(1000 * std.time.ns_per_ms);
	307	+ zig_test.compat.sleep(1000 * std.time.ns_per_ms);
308	308
309	309	try spinner.updateMessage("Step 2: Processing data...");
310		- std.Thread.sleep(1000 * std.time.ns_per_ms);
	310	+ zig_test.compat.sleep(1000 * std.time.ns_per_ms);
311	311
312	312	try spinner.updateMessage("Step 3: Finalizing...");
313		- std.Thread.sleep(1000 * std.time.ns_per_ms);
	313	+ zig_test.compat.sleep(1000 * std.time.ns_per_ms);
314	314
315	315	spinner.succeed("All steps completed");
316	316	}
		⋯8 linesShow the 8 lines above this hunk@@ -325,7 +325,7 @@ pub fn example_combined_progress() !void {
325	325	var spinner = try zig_test.Spinner.init(allocator, "Starting batch process...", .dots);
326	326	defer spinner.deinit();
327	327	try spinner.start();
328		- std.Thread.sleep(500 * std.time.ns_per_ms);
	328	+ zig_test.compat.sleep(500 * std.time.ns_per_ms);
329	329	spinner.stop();
330	330
331	331	// Use progress bar for sub-tasks
		⋯5 linesShow the 5 lines above this hunk@@ -337,7 +337,7 @@ pub fn example_combined_progress() !void {
337	337	var i: usize = 0;
338	338	while (i <= 100) : (i += 10) {
339	339	bar.update(i);
340		- std.Thread.sleep(200 * std.time.ns_per_ms);
	340	+ zig_test.compat.sleep(200 * std.time.ns_per_ms);
341	341	}
342	342	bar.finish();
343	343
		⋯1 lineShow the 1 line above this hunk@@ -345,7 +345,7 @@ pub fn example_combined_progress() !void {
345	345	var final_spinner = try zig_test.Spinner.init(allocator, "Completing...", .dots);
346	346	defer final_spinner.deinit();
347	347	try final_spinner.start();
348		- std.Thread.sleep(500 * std.time.ns_per_ms);
	348	+ zig_test.compat.sleep(500 * std.time.ns_per_ms);
349	349	final_spinner.succeed("Batch process completed successfully");
350	350	}
351	351

examples/snapshot_examples.zigmodified+3-3

Changes to examples/snapshot_examples.zig

		⋯218 linesShow the 218 lines above this hunk@@ -219,8 +219,8 @@ pub fn example_custom_directory() !void {
219	219	std.debug.print("Example 11: Snapshot created in custom directory\n", .{});
220	220
221	221	// Cleanup
222		- std.fs.cwd().deleteFile(".custom_snapshots/custom_dir_test.snap") catch {};
223		- std.fs.cwd().deleteDir(".custom_snapshots") catch {};
	222	+ zig_test.compat.deleteFile(allocator, ".custom_snapshots/custom_dir_test.snap") catch {};
	223	+ zig_test.compat.deleteDir(allocator, ".custom_snapshots") catch {};
224	224	}
225	225
226	226	/// Example 12: Custom File Extension
		⋯10 linesShow the 10 lines above this hunk@@ -237,7 +237,7 @@ pub fn example_custom_extension() !void {
237	237	std.debug.print("Example 12: Snapshot with custom extension created\n", .{});
238	238
239	239	// Cleanup
240		- std.fs.cwd().deleteFile(".snapshots/custom_ext_test.snapshot") catch {};
	240	+ zig_test.compat.deleteFile(allocator, ".snapshots/custom_ext_test.snapshot") catch {};
241	241	}
242	242
243	243	/// Example 13: Multiple Formats Comparison

examples/timeout_examples.zigmodified+12-12

Changes to examples/timeout_examples.zig

		⋯7 linesShow the 7 lines above this hunk@@ -8,7 +8,7 @@ pub fn example_per_test_timeout() !void {
8	8	const fastTest = struct {
9	9	fn run(alloc: std.mem.Allocator) !void {
10	10	_ = alloc;
11		- std.Thread.sleep(50 * std.time.ns_per_ms);
	11	+ zig_test.compat.sleep(50 * std.time.ns_per_ms);
12	12	std.debug.print("Fast test completed\n", .{});
13	13	}
14	14	}.run;
		⋯11 linesShow the 11 lines above this hunk@@ -26,14 +26,14 @@ pub fn example_suite_timeout() !void { renamed throughout
26	26	const test1 = struct {
27	27	fn run(alloc: std.mem.Allocator) !void {
28	28	_ = alloc;
29		- std.Thread.sleep(100 * std.time.ns_per_ms);
	29	+ zig_test.compat.sleep(100 * std.time.ns_per_ms);
30	30	}
31	31	}.run;
32	32
33	33	const test2 = struct {
34	34	fn run(alloc: std.mem.Allocator) !void {
35	35	_ = alloc;
36		- std.Thread.sleep(100 * std.time.ns_per_ms);
	36	+ zig_test.compat.sleep(100 * std.time.ns_per_ms);
37	37	}
38	38	}.run;
39	39
		⋯20 linesShow the 20 lines above this hunk@@ -60,7 +60,7 @@ pub fn example_timeout_context() !void {
60	60	std.debug.print("Timeout context started with 1000ms timeout\n", .{});
61	61
62	62	// Simulate some work
63		- std.Thread.sleep(200 * std.time.ns_per_ms);
	63	+ zig_test.compat.sleep(200 * std.time.ns_per_ms);
64	64
65	65	if (!context.isTimedOut()) {
66	66	std.debug.print("Still within timeout, elapsed: {d}ms, remaining: {d}ms\n", .{
		⋯21 linesShow the 21 lines above this hunk@@ -88,14 +88,14 @@ pub fn example_timeout_extension() !void { renamed throughout
88	88	std.debug.print("Started with 500ms timeout\n", .{});
89	89
90	90	// Simulate work
91		- std.Thread.sleep(400 * std.time.ns_per_ms);
	91	+ zig_test.compat.sleep(400 * std.time.ns_per_ms);
92	92
93	93	// Need more time!
94	94	try context.extend(500);
95	95	std.debug.print("Extended timeout by 500ms (total: 1000ms)\n", .{});
96	96
97	97	// Continue work
98		- std.Thread.sleep(300 * std.time.ns_per_ms);
	98	+ zig_test.compat.sleep(300 * std.time.ns_per_ms);
99	99
100	100	if (!context.isTimedOut()) {
101	101	std.debug.print("Completed within extended timeout\n", .{});
		⋯63 linesShow the 63 lines above this hunk@@ -165,7 +165,7 @@ pub fn example_timeout_monitoring() !void {
165	165	std.debug.print("Registered context with 500ms timeout\n", .{});
166	166
167	167	// Simulate work
168		- std.Thread.sleep(600 * std.time.ns_per_ms);
	168	+ zig_test.compat.sleep(600 * std.time.ns_per_ms);
169	169
170	170	// Check if timed out
171	171	if (context.isTimedOut()) {
		⋯18 linesShow the 18 lines above this hunk@@ -190,11 +190,11 @@ pub fn example_suite_tracker() !void { renamed throughout
190	190
191	191	// Run some tests
192	192	tracker.incrementTest();
193		- std.Thread.sleep(200 * std.time.ns_per_ms);
	193	+ zig_test.compat.sleep(200 * std.time.ns_per_ms);
194	194	tracker.incrementCompleted();
195	195
196	196	tracker.incrementTest();
197		- std.Thread.sleep(200 * std.time.ns_per_ms);
	197	+ zig_test.compat.sleep(200 * std.time.ns_per_ms);
198	198	tracker.incrementCompleted();
199	199
200	200	std.debug.print("Tests run: {d}/{d}\n", .{ tracker.completed_count, tracker.test_count });
		⋯39 linesShow the 39 lines above this hunk@@ -240,7 +240,7 @@ pub fn example_async_with_timeout() !void {
240	240	const asyncTest = struct {
241	241	fn run(alloc: std.mem.Allocator) !void {
242	242	_ = alloc;
243		- std.Thread.sleep(100 * std.time.ns_per_ms);
	243	+ zig_test.compat.sleep(100 * std.time.ns_per_ms);
244	244	std.debug.print("Async test completed\n", .{});
245	245	}
246	246	}.run;
		⋯11 linesShow the 11 lines above this hunk@@ -258,12 +258,12 @@ pub fn example_timeout_result() !void { renamed throughout
258	258	var context = zig_test.TimeoutContext.init(allocator, 1000);
259	259	context.start();
260	260
261		- std.Thread.sleep(150 * std.time.ns_per_ms);
	261	+ zig_test.compat.sleep(150 * std.time.ns_per_ms);
262	262
263	263	// Extend timeout
264	264	try context.extend(500);
265	265
266		- std.Thread.sleep(100 * std.time.ns_per_ms);
	266	+ zig_test.compat.sleep(100 * std.time.ns_per_ms);
267	267
268	268	context.complete();
269	269

src/compat.zigmodified+14-0

Changes to src/compat.zig

		⋯171 linesShow the 171 lines above this hunk@@ -172,6 +172,20 @@ pub fn deleteFile(allocator: std.mem.Allocator, path: []const u8) !void {
172	172	}
173	173	}
174	174
	175	+/// Delete an empty directory using POSIX APIs.
	176	+/// Replaces std.fs.cwd().deleteDir().
	177	+pub fn deleteDir(allocator: std.mem.Allocator, path: []const u8) !void {
	178	+ const path_z = try allocator.dupeSentinel(u8, path, 0);
	179	+ defer allocator.free(path_z);
	180	+ const rc = std.c.rmdir(path_z);
	181	+ if (rc != 0) {
	182	+ switch (std.c.errno(rc)) {
	183	+ .NOENT => return error.FileNotFound,
	184	+ else => return error.Unexpected,
	185	+ }
	186	+ }
	187	+}
	188	+
175	189	/// Create directories recursively using POSIX APIs.
176	190	/// Replaces std.fs.cwd().makePath().
177	191	pub fn makePath(allocator: std.mem.Allocator, path: []const u8) !void {

src/progress.zigmodified+7-2

Changes to src/progress.zig

		⋯375 linesShow the 375 lines above this hunk@@ -376,15 +376,20 @@ pub const TestProgress = struct {
376	376
377	377	/// Multi-spinner for parallel operations
378	378	pub const MultiSpinner = struct {
	379	+ const SpinnerEntry = struct {
	380	+ name: []const u8,
	381	+ spinner: Spinner,
	382	+ };
	383	+
379	384	allocator: std.mem.Allocator,
380		- spinners: std.ArrayList(struct { name: []const u8, spinner: Spinner }),
	385	+ spinners: std.ArrayList(SpinnerEntry),
381	386
382	387	const Self = @This();
383	388
384	389	pub fn init(allocator: std.mem.Allocator) Self {
385	390	return .{
386	391	.allocator = allocator,
387		- .spinners = std.ArrayList(struct { name: []const u8, spinner: Spinner }).empty,
	392	+ .spinners = .empty,
388	393	};
389	394	}
390	395

tests/hooks_test.zigmodified+15-6

Changes to tests/hooks_test.zig

		⋯207 linesShow the 207 lines above this hunk@@ -208,13 +208,21 @@ pub fn main() !void {
208	208	}
209	209	}.testSuite);
210	210
211		- // Test 5: Hook error handling
212		- try ztf.describe(allocator, "Hook error handling", struct {
	211	+ // Test 5: Hook error recovery
	212	+ try ztf.describe(allocator, "Hook error recovery", struct {
	213	+ var hook_failure_observed: bool = false;
213	214	var test_ran: bool = false;
214	215
215	216	fn testSuite(alloc: std.mem.Allocator) !void {
216		- try ztf.beforeEach(alloc, failingBefore);
217		- try ztf.it(alloc, "this test should be skipped due to beforeEach failure", testThatShouldntRun);
	217	+ try ztf.beforeEach(alloc, recoverFromFailure);
	218	+ try ztf.it(alloc, "a wrapper hook can recover from an expected failure", testAfterRecovery);
	219	+ }
	220	+
	221	+ fn recoverFromFailure(alloc: std.mem.Allocator) !void {
	222	+ failingBefore(alloc) catch |err| {
	223	+ if (err != error.BeforeEachFailed) return err;
	224	+ hook_failure_observed = true;
	225	+ };
218	226	}
219	227
220	228	fn failingBefore(alloc: std.mem.Allocator) !void {
		⋯1 lineShow the 1 line above this hunk@@ -222,9 +230,10 @@ pub fn main() !void {
222	230	return error.BeforeEachFailed;
223	231	}
224	232
225		- fn testThatShouldntRun(alloc: std.mem.Allocator) !void {
226		- _ = alloc;
	233	+ fn testAfterRecovery(alloc: std.mem.Allocator) !void {
227	234	test_ran = true;
	235	+ try ztf.expect(alloc, hook_failure_observed).toBe(true);
	236	+ try ztf.expect(alloc, test_ran).toBe(true);
228	237	}
229	238	}.testSuite);
230	239