Adding test files to build system

Help
, ,
1

For past few days I have been experimenting with zig lang and tried solving simple problems. I have two files, main.zig and multiply_string.zig.

const std = @import("std");
const print = std.debug.print;

const multiply_string = @import("multiply_string.zig");

pub fn main() !void {
    const start_total = std.time.microTimestamp();

    try multiply_string.test_multiply_string();

    const end_total = std.time.microTimestamp();

    print("Total time taken: {d} microseconds\n", .{end_total - start_total});
}

below is the multiply_string.zig file.

const std = @import("std");

const assert = std.debug.assert;
const print = std.debug.print;
const mem = std.mem;
const testing = std.testing;

inline fn multiply_string(allocator: std.mem.Allocator, num1: [:0]const u8, num2: [:0]const u8) ![]const u8 {
    var result: []u8 = try allocator.alloc(u8, num1.len + num2.len);
    defer allocator.free(result);
    @memset(result, '0');

    var index: usize = undefined;

    for (0..num1.len) |i| {
        const d1 = num1[num1.len - i - 1] - '0';

        for (0..num2.len) |j| {
            const d2 = num2[num2.len - j - 1] - '0';

            index = (num1.len - i) + (num2.len - j);

            const product = d1 * d2;

            const sum = product + (result[index - 1] - '0');

            result[index - 1] = (sum % 10) + '0';
            result[index - 2] = (sum / 10) + (result[index - 2] - '0') + '0';
        }
    }

    const trimmed_result = std.mem.trimLeft(u8, result, "0");

    if (trimmed_result.len == 0) {
        return try allocator.dupe(u8, "0");
    }

    return try allocator.dupe(u8, trimmed_result);
}

const inputs = [_]struct { [:0]const u8, [:0]const u8, [:0]const u8 }{
    .{ "2", "3", "6" },
    .{ "123", "456", "56088" },
    .{ "123", "0", "0" },
    .{ "123", "123", "15129" },
    .{ "999", "999", "998001" },
    .{ "1000", "1000", "1000000" },
    .{ "6706", "3400940902083792", "22806709689373909152" },
};

pub inline fn test_multiply_string() !void {
    const start = std.time.microTimestamp();

    var buffer: [1100]u8 = undefined;

    var fba = std.heap.FixedBufferAllocator.init(&buffer);
    defer fba.reset();

    var arena = std.heap.ArenaAllocator.init(fba.allocator());
    defer arena.deinit();

    const allocator = arena.allocator();

    var array_list = std.ArrayList(u8).init(allocator);
    defer array_list.deinit();

    inline for (inputs) |input| {
        const result = try multiply_string(allocator, input[0], input[1]);

        try array_list.writer().print("{s} * {s} = {s}\n", .{ input[0], input[1], result });

        allocator.free(result);
    }

    const end = std.time.microTimestamp();

    print("Time taken: {d} microseconds\n\n{s}\n", .{ end - start, array_list.items });
}

test "multiply string" {
    const expect = testing.expect;
    const allocator = testing.allocator;

    for (inputs) |input| {
        const result = try multiply_string(allocator, input[0], input[1]);
        try expect(mem.eql(u8, result, input[2]));
        allocator.free(result);
    }
}

I tried adding an obvious failure test case in the inputs, and tried running zig build test and the test passes without throwing any error. I tried adding usingnamespace @import("multiply_string.zig"); and run, it works.

Here is my build.zig file

const std = @import("std");

pub fn build(b: *std.Build) void {
    const target = b.standardTargetOptions(.{});

    const optimize = b.standardOptimizeOption(.{});

    const exe = b.addExecutable(.{
        .name = "zig_project_02",
        .root_source_file = b.path("src/main.zig"),
        .target = target,
        .optimize = optimize,
    });
    b.installArtifact(exe);

    const run_cmd = b.addRunArtifact(exe);

    run_cmd.step.dependOn(b.getInstallStep());

    if (b.args) |args| {
        run_cmd.addArgs(args);
    }

    const run_step = b.step("run", "Run the app");
    run_step.dependOn(&run_cmd.step);

    const exe_unit_tests = b.addTest(.{
        .root_source_file = b.path("src/main.zig"),
        .target = target,
        .optimize = optimize,
    });

    var run_exe_unit_tests = b.addRunArtifact(exe_unit_tests);

    run_exe_unit_tests.addFileInput(b.path("src/multiply_string.zig"));

    const test_step = b.step("test", "Run unit tests");
    test_step.dependOn(&run_exe_unit_tests.step);
}

What modifications should I make in my build.zig so that zig build test runs as it I expect it to. Or the only way is to use zig test src/multiply_string.zig to run every file individually?

2

In your build.zig you don’t need the line:

run_exe_unit_tests.addFileInput(b.path("src/multiply_string.zig"));

In your main.zig add a test case that references the other module:

test {
    _ = multiply_string;
}

see also: How do I get zig build to Run all the tests? - #2 by n0s4

1 Like
3

This works, but I have to explicitly add each and every files in same or subdirectories for the test runner to run it. I had to write a recursive function and add it to the test step.

const std = @import("std");

pub fn build(b: *std.Build) void {
    const target = b.standardTargetOptions(.{});

    const optimize = b.standardOptimizeOption(.{});

    const exe = b.addExecutable(.{
        .name = "zig_project_02",
        .root_source_file = b.path("src/main.zig"),
        .target = target,
        .optimize = optimize,
    });

    exe.want_lto = true;

    b.installArtifact(exe);

    const run_cmd = b.addRunArtifact(exe);

    run_cmd.step.dependOn(b.getInstallStep());

    if (b.args) |args| {
        run_cmd.addArgs(args);
    }

    const run_step = b.step("run", "Run the app");
    run_step.dependOn(&run_cmd.step);

    const test_step = b.step("test", "Run all tests");

    var dir = std.fs.cwd().openDir("src", .{ .iterate = true }) catch unreachable;
    defer dir.close();

    const allocator = std.heap.page_allocator;

    iterate_dir(b, allocator, dir, "src", target, optimize, test_step) catch unreachable;
}

fn iterate_dir(
    b: *std.Build,
    allocator: std.mem.Allocator,
    dir: std.fs.Dir,
    dir_path: []const u8,
    target: std.Build.ResolvedTarget,
    optimize: std.builtin.OptimizeMode,
    test_step: *std.Build.Step,
) !void {
    var walker = try dir.walk(allocator);
    defer walker.deinit();

    while (try walker.next()) |entry| {
        if (entry.kind == .directory) {
            var subdir = try dir.openDir(entry.path, .{ .iterate = true });
            defer subdir.close();

            const created_path = try std.fs.path.join(allocator, &.{ dir_path, entry.path });
            defer allocator.free(created_path);

            try iterate_dir(b, allocator, subdir, created_path, target, optimize, test_step);
        } else if (entry.kind == .file and std.mem.eql(u8, std.fs.path.extension(entry.path), ".zig")) {
            // Construct the correct path relative to src directory
            const full_path = try std.fs.path.join(allocator, &.{ dir_path, entry.path });
            defer allocator.free(full_path);

            const test_cmd = b.addTest(.{
                .root_source_file = b.path(full_path),
                .target = target,
                .optimize = optimize,
            });

            test_step.dependOn(&(b.addRunArtifact(test_cmd).step));
        }
    }
}

I am brute forcing, but it should automatically add all the files to the test step. Is there a better approach to adding it recursively like this rather than using a workaround like std.testing.refAllDecls(@This());?