test: run integration suites and check every example

Author: glennmichael123

README.md

@@ -757,10 +757,14 @@ zig build
 # Run self-tests
 zig build test
 
-# Run examples
+# Run the basic and advanced examples, and compile-check every example
 zig build examples
 ```
 
+The async, snapshot, progress, and timeout examples are compile-checked rather
+than executed by this step because they intentionally demonstrate delays,
+generated files, interactive output, or failure handling.
+
 ## Requirements
 
 - The exact Zig development build recorded in [`.zig-version`](.zig-version)

build.zig

@@ -19,6 +19,9 @@ pub fn build(b: *std.Build) void {
             .target = target,
             .optimize = optimize,
             .link_libc = true,
+            .imports = &.{
+                .{ .name = "zig_test_framework", .module = lib_module },
+            },
         }),
     });
 
@@ -46,6 +49,9 @@ pub fn build(b: *std.Build) void {
             .target = target,
             .optimize = optimize,
             .link_libc = true,
+            .imports = &.{
+                .{ .name = "zig_test_framework", .module = lib_module },
+            },
         }),
     });
     const run_test_runner_tests = b.addRunArtifact(test_runner_tests);
@@ -57,6 +63,9 @@ pub fn build(b: *std.Build) void {
             .target = target,
             .optimize = optimize,
             .link_libc = true,
+            .imports = &.{
+                .{ .name = "zig_test_framework", .module = lib_module },
+            },
         }),
     });
     const run_assertions_tests = b.addRunArtifact(assertions_tests);
@@ -68,6 +77,9 @@ pub fn build(b: *std.Build) void {
             .target = target,
             .optimize = optimize,
             .link_libc = true,
+            .imports = &.{
+                .{ .name = "zig_test_framework", .module = lib_module },
+            },
         }),
     });
     const run_suite_tests = b.addRunArtifact(suite_tests);
@@ -79,6 +91,9 @@ pub fn build(b: *std.Build) void {
             .target = target,
             .optimize = optimize,
             .link_libc = true,
+            .imports = &.{
+                .{ .name = "zig_test_framework", .module = lib_module },
+            },
         }),
     });
     const run_matchers_tests = b.addRunArtifact(matchers_tests);
@@ -108,6 +123,9 @@ pub fn build(b: *std.Build) void {
             .target = target,
             .optimize = optimize,
             .link_libc = true,
+            .imports = &.{
+                .{ .name = "zig_test_framework", .module = lib_module },
+            },
         }),
     });
     const run_reporter_tests = b.addRunArtifact(reporter_tests);
@@ -119,6 +137,9 @@ pub fn build(b: *std.Build) void {
             .target = target,
             .optimize = optimize,
             .link_libc = true,
+            .imports = &.{
+                .{ .name = "zig_test_framework", .module = lib_module },
+            },
         }),
     });
     const run_cli_tests = b.addRunArtifact(cli_tests);
@@ -144,6 +165,9 @@ pub fn build(b: *std.Build) void {
             .target = target,
             .optimize = optimize,
             .link_libc = true,
+            .imports = &.{
+                .{ .name = "zig_test_framework", .module = lib_module },
+            },
         }),
     });
     const run_mock_tests = b.addRunArtifact(mock_tests);
@@ -209,11 +233,14 @@ pub fn build(b: *std.Build) void {
     test_step.dependOn(&run_assertions_tests.step);
     test_step.dependOn(&run_suite_tests.step);
     test_step.dependOn(&run_matchers_tests.step);
-    // Note: hooks_test is an executable, run with 'zig build test-hooks'
+    test_step.dependOn(&run_hooks_tests.step);
     test_step.dependOn(&run_reporter_tests.step);
     test_step.dependOn(&run_cli_tests.step);
     test_step.dependOn(&run_filter_tests.step);
     test_step.dependOn(&run_mock_tests.step);
+    test_step.dependOn(&run_comprehensive_mock_tests.step);
+    test_step.dependOn(&run_snapshot_usage_tests.step);
+    test_step.dependOn(&run_time_tests.step);
 
     // Examples
     const basic_example = b.addExecutable(.{
@@ -245,7 +272,65 @@ pub fn build(b: *std.Build) void {
     const run_basic_example = b.addRunArtifact(basic_example);
     const run_advanced_example = b.addRunArtifact(advanced_example);
 
-    const examples_step = b.step("examples", "Run all examples");
+    // These showcase intentionally slow, interactive, or failure-oriented
+    // scenarios, so keep them compile-only while still checking every example.
+    const async_examples = b.addExecutable(.{
+        .name = "async_examples",
+        .root_module = b.createModule(.{
+            .root_source_file = b.path("examples/async_tests.zig"),
+            .target = target,
+            .optimize = optimize,
+            .link_libc = true,
+            .imports = &.{
+                .{ .name = "zig_test", .module = lib_module },
+            },
+        }),
+    });
+
+    const snapshot_examples = b.addExecutable(.{
+        .name = "snapshot_examples",
+        .root_module = b.createModule(.{
+            .root_source_file = b.path("examples/snapshot_examples.zig"),
+            .target = target,
+            .optimize = optimize,
+            .link_libc = true,
+            .imports = &.{
+                .{ .name = "zig_test", .module = lib_module },
+            },
+        }),
+    });
+
+    const progress_examples = b.addExecutable(.{
+        .name = "progress_examples",
+        .root_module = b.createModule(.{
+            .root_source_file = b.path("examples/progress_examples.zig"),
+            .target = target,
+            .optimize = optimize,
+            .link_libc = true,
+            .imports = &.{
+                .{ .name = "zig_test", .module = lib_module },
+            },
+        }),
+    });
+
+    const timeout_examples = b.addExecutable(.{
+        .name = "timeout_examples",
+        .root_module = b.createModule(.{
+            .root_source_file = b.path("examples/timeout_examples.zig"),
+            .target = target,
+            .optimize = optimize,
+            .link_libc = true,
+            .imports = &.{
+                .{ .name = "zig_test", .module = lib_module },
+            },
+        }),
+    });
+
+    const examples_step = b.step("examples", "Run core examples and compile all examples");
     examples_step.dependOn(&run_basic_example.step);
     examples_step.dependOn(&run_advanced_example.step);
+    examples_step.dependOn(&async_examples.step);
+    examples_step.dependOn(&snapshot_examples.step);
+    examples_step.dependOn(&progress_examples.step);
+    examples_step.dependOn(&timeout_examples.step);
 }

examples/async_tests.zig

@@ -18,7 +18,7 @@ pub fn example_basic_async_test() !void {
         fn run(alloc: std.mem.Allocator) !void {
             _ = alloc;
             // Simulate async work
-            std.Thread.sleep(100 * std.time.ns_per_ms);
+            zig_test.compat.sleep(100 * std.time.ns_per_ms);
             std.debug.print("Async test 1 completed\n", .{});
         }
     }.run;
@@ -54,7 +54,7 @@ pub fn example_async_timeout() !void {
     const slowTest = struct {
         fn run(alloc: std.mem.Allocator) !void {
             _ = alloc;
-            std.Thread.sleep(500 * std.time.ns_per_ms); // Takes too long
+            zig_test.compat.sleep(500 * std.time.ns_per_ms); // Takes too long
         }
     }.run;
 
@@ -87,7 +87,7 @@ pub fn example_concurrent_async() !void {
     const asyncTest = struct {
         fn run(alloc: std.mem.Allocator) !void {
             _ = alloc;
-            std.Thread.sleep(50 * std.time.ns_per_ms);
+            zig_test.compat.sleep(50 * std.time.ns_per_ms);
         }
     }.run;
 
@@ -97,10 +97,10 @@ pub fn example_concurrent_async() !void {
     try executor.registerTest("concurrent_4", asyncTest);
     try executor.registerTest("concurrent_5", asyncTest);
 
-    const start = std.time.nanoTimestamp();
+    const start = zig_test.compat.nanoTimestamp();
     const results = try executor.executeAll();
     defer allocator.free(results);
-    const duration = std.time.nanoTimestamp() - start;
+    const duration = zig_test.compat.nanoTimestamp() - start;
 
     std.debug.print("Total duration: {d:.2}ms\n", .{
         @as(f64, @floatFromInt(duration)) / 1_000_000.0,
@@ -121,15 +121,15 @@ pub fn example_async_hooks() !void {
         fn run(alloc: std.mem.Allocator) !void {
             _ = alloc;
             std.debug.print("Before hook executed\n", .{});
-            std.Thread.sleep(10 * std.time.ns_per_ms);
+            zig_test.compat.sleep(10 * std.time.ns_per_ms);
         }
     }.run;
 
     const afterHook = struct {
         fn run(alloc: std.mem.Allocator) !void {
             _ = alloc;
             std.debug.print("After hook executed\n", .{});
-            std.Thread.sleep(10 * std.time.ns_per_ms);
+            zig_test.compat.sleep(10 * std.time.ns_per_ms);
         }
     }.run;
 
@@ -150,15 +150,15 @@ pub fn example_suite_async() !void {
     const asyncTest1 = struct {
         fn run(alloc: std.mem.Allocator) !void {
             _ = alloc;
-            std.Thread.sleep(50 * std.time.ns_per_ms);
+            zig_test.compat.sleep(50 * std.time.ns_per_ms);
             std.debug.print("Suite async test 1 passed\n", .{});
         }
     }.run;
 
     const asyncTest2 = struct {
         fn run(alloc: std.mem.Allocator) !void {
             _ = alloc;
-            std.Thread.sleep(50 * std.time.ns_per_ms);
+            zig_test.compat.sleep(50 * std.time.ns_per_ms);
             std.debug.print("Suite async test 2 passed\n", .{});
         }
     }.run;
@@ -187,7 +187,7 @@ pub fn example_mixed_tests() !void {
     const asyncTest = struct {
         fn run(alloc: std.mem.Allocator) !void {
             _ = alloc;
-            std.Thread.sleep(50 * std.time.ns_per_ms);
+            zig_test.compat.sleep(50 * std.time.ns_per_ms);
             std.debug.print("Async test executed\n", .{});
         }
     }.run;
@@ -212,15 +212,15 @@ pub fn example_async_errors() !void {
     const passingTest = struct {
         fn run(alloc: std.mem.Allocator) !void {
             _ = alloc;
-            std.Thread.sleep(10 * std.time.ns_per_ms);
+            zig_test.compat.sleep(10 * std.time.ns_per_ms);
         }
     }.run;
 
     // Test that fails
     const failingTest = struct {
         fn run(alloc: std.mem.Allocator) !void {
             _ = alloc;
-            std.Thread.sleep(10 * std.time.ns_per_ms);
+            zig_test.compat.sleep(10 * std.time.ns_per_ms);
             return error.AsyncTestFailed;
         }
     }.run;