break :blk field.field_type;

                        break :blk field.type;

                        break :blk field.field_type;

                        break :blk field.type;

        skiplist: SkipList.Lazy(K, V, {}, std.sort.asc(K)),

        skiplist: SkipList.Lazy(.{ .items = MY_SIZE }, K, V, {}, std.sort.asc(K)),

            sq.skiplist = try SkipList.Lazy(K, V, {}, comptime std.sort.asc(K))
                .init(allocator, SkipList.DEFAULT_SKIP_SIZE, MY_SIZE);

            sq.skiplist = try SkipList.Lazy(.{ .items = MY_SIZE }, K, V, {}, comptime std.sort.asc(K))
                .init(allocator);

        pub fn deinit(self: @This()) void {
            self.skiplist.deinit();

        pub fn deinit(self: @This(), allocator: std.mem.Allocator) void {
            self.skiplist.deinit(allocator);

        pub fn add(self: *@This(), item: T) !void {
            _ = try self.skiplist.insert(item.key, item.value);

        pub fn add(self: *@This(), allocator: std.mem.Allocator, item: T) !void {
            _ = try self.skiplist.insert(allocator, item.key, item.value);

        pub fn remove(self: *@This()) !?T {

        pub fn remove(self: *@This(), allocator: std.mem.Allocator) !?T {

                const held = item.lock.acquire();
                defer held.release();

                item.lock.lock();
                defer item.lock.unlock();

                _ = try self.skiplist.remove(ret.?.key);

                _ = try self.skiplist.remove(allocator, ret.?.key);

                std.mem.set(?*Node, n.forward, null);

                @memset(n.forward, null);

            return @floatToInt(usize, std.math.log(f32, self.skip_size, @intToFloat(f32, n)));

            return @as(usize, @intFromFloat(
                std.math.log(f32, self.skip_size, @as(f32, @floatFromInt(n))),
            ));

                .rnd = std.rand.DefaultPrng.init(@intCast(u64, std.time.milliTimestamp())),

                .rnd = std.rand.DefaultPrng.init(@intCast(std.time.milliTimestamp())),

            _ = self;

            std.mem.set(?*Node, update, null);

            @memset(update, null);

            std.debug.print("SkipList structure - P:{d}, max_level: {d}\n", .{ 1 / self.skip_size, self.max_level });

            std.debug.print("SkipList(Pugh) structure - P:{d}, max_level: {d}\n", .{ 1 / self.skip_size, self.max_level });

            std.mem.set(?*Node, update, null);

            @memset(update, null);

const THREADS = 8;
const SL = SkipList.Lazy(BENCH_KEY, BENCH_VALUE, {}, std.sort.asc(BENCH_KEY));

const SL = SkipList.Lazy(.{ .items = BENCH_ITEMS, .skip_size = BENCH_SKIP_SIZE }, BENCH_KEY, BENCH_VALUE, {}, std.sort.asc(BENCH_KEY));

    // try benchPugh();

    try benchPugh();

    var rand = std.rand.DefaultPrng.init(@intCast(u64, std.time.milliTimestamp()));

    var rand = std.rand.DefaultPrng.init(@intCast(std.time.milliTimestamp()));

    std.debug.print("{d} ms\n", .{timer.read() / std.time.ns_per_ms});

    std.debug.print("Pugh: {d} ms\n", .{timer.read() / std.time.ns_per_ms});

    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    var arena = std.heap.ArenaAllocator.init(gpa.allocator());

    var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);

    // var tsa = std.heap.ThreadSafeAllocator{ .child_allocator = std.heap.page_allocator };

    var sl = try SL.init(arena.allocator(), BENCH_SKIP_SIZE, BENCH_ITEMS);
    defer sl.deinit();

    var sl = try SL.init(arena.allocator());
    defer sl.deinit(arena.allocator());

    var rand = std.rand.DefaultPrng.init(@intCast(u64, std.time.milliTimestamp()));

    var rand = std.rand.DefaultPrng.init(@intCast(std.time.milliTimestamp()));

    var batch = std.event.Batch(anyerror!void, THREADS, .auto_async).init();

    // { // single thread
    //     var timer = try std.time.Timer.start();

    // var frames: [BENCH_ITEMS]@Frame(testInsert) = undefined;
    var frames = try std.ArrayList(@Frame(testInsert)).initCapacity(arena.allocator(), BENCH_ITEMS);
    defer frames.deinit();

    //     var i: usize = 0;
    //     while (i < BENCH_ITEMS) : (i += 1) {
    //         const key = rnd.intRangeAtMostBiased(BENCH_KEY, std.math.minInt(BENCH_KEY), std.math.maxInt(BENCH_KEY));
    //         _ = try sl.insert(tsa.allocator(), key, {});
    //     }

    var timer = try std.time.Timer.start();

    //     std.debug.print("Lazy 1 thread: {d} ms\n", .{timer.read() / std.time.ns_per_ms});
    // }
    { // multithread
        const THREADS = 4;
        var pool: std.Thread.Pool = undefined;
        try pool.init(std.Thread.Pool.Options{
            .allocator = arena.allocator(),
            .n_jobs = THREADS,
        });
        defer pool.deinit();
        var wg = std.Thread.WaitGroup{};
        var timer = try std.time.Timer.start();

    var job: usize = 0;
    while (job < BENCH_ITEMS) : (job += 1) {
        const key = rnd.intRangeAtMostBiased(
            BENCH_KEY,
            std.math.minInt(BENCH_KEY),
            std.math.maxInt(BENCH_KEY),
        );
        // frames[job] = async testInsert(&sl, key, {});
        // batch.add(&frames[job]);
        const frame = async testInsert(&sl, key, {});
        frames.appendAssumeCapacity(frame);
        batch.add(&frames.items[job]);
    }

        for (0..BENCH_ITEMS) |_| {
            const key = rnd.intRangeAtMostBiased(
                BENCH_KEY,
                std.math.minInt(BENCH_KEY),
                std.math.maxInt(BENCH_KEY),
            );
            pool.spawnWg(&wg, testIns, .{ std.heap.page_allocator, &sl, key, {} });
        }

    try batch.wait();

        pool.waitAndWork(&wg);

    std.debug.print("Total time: {d} ms\n", .{timer.read() / std.time.ns_per_ms});

        std.debug.print("Lazy {d} threads: {d} ms\n", .{ THREADS, timer.read() / std.time.ns_per_ms });
    }

fn testInsert(skiplist: *SL, key: BENCH_KEY, val: BENCH_VALUE) anyerror!void {
    if (@call(.{}, skiplist.insert, .{ key, val })) {
        // std.debug.print("Adding {d} done.\n", .{key});
        return;
    } else |err| return err;

fn testIns(allocator: std.mem.Allocator, skiplist: *SL, key: BENCH_KEY, val: BENCH_VALUE) void {
    _ = @call(std.builtin.CallModifier.auto, SL.insert, .{ skiplist, allocator, key, val }) catch unreachable;

    defer sq.deinit();

    defer sq.deinit(std.heap.page_allocator);

    try sq.add(.{ .key = 1, .value = 1 });
    try sq.add(.{ .key = 2, .value = 2 });
    try sq.add(.{ .key = 3, .value = 3 });
    try sq.add(.{ .key = 0, .value = 4 });

    try sq.add(std.heap.page_allocator, .{ .key = 1, .value = 1 });
    try sq.add(std.heap.page_allocator, .{ .key = 2, .value = 2 });
    try sq.add(std.heap.page_allocator, .{ .key = 3, .value = 3 });
    try sq.add(std.heap.page_allocator, .{ .key = 0, .value = 4 });

    std.debug.assert((try sq.remove()).?.value == 4);
    std.debug.assert((try sq.remove()).?.value == 1);
    std.debug.assert((try sq.remove()).?.value == 2);
    std.debug.assert((try sq.remove()).?.value == 3);
    std.debug.assert((try sq.remove()) == null);

    std.debug.assert((try sq.remove(std.heap.page_allocator)).?.value == 4);
    std.debug.assert((try sq.remove(std.heap.page_allocator)).?.value == 1);
    std.debug.assert((try sq.remove(std.heap.page_allocator)).?.value == 2);
    std.debug.assert((try sq.remove(std.heap.page_allocator)).?.value == 3);
    std.debug.assert((try sq.remove(std.heap.page_allocator)) == null);

pub const DEFAULT_SKIP_SIZE = 4;

pub const Options = struct {
    /// Maximum number of items to be stored in the SkipList.
    /// This is not a hard limit, but SkipList performance will degrade when badly choosen.
    items: usize,
    /// Number of items to skip with each level. This is a probabilistic value.
    skip_size: f32 = 4,
    /// Maximum number of levels in the SkipList.
    max_level: ?usize = null,
};

    comptime opts: Options,

    if (opts.skip_size <= 1) {
        @compileError("Skip size must be >= 1!\n");
    }

        // XXX: these should be hidden!

        allocator: std.mem.Allocator,
        /// Determines average skip size for each level of SkipList. Equals `1/P`.
        skip_size: f32,
        /// Maximum number of levels in the SkipList.
        max_level: usize = undefined,

        const max_level = opts.max_level orelse
            @as(usize, @intFromFloat(std.math.log(f32, opts.skip_size, @as(f32, @floatFromInt(opts.items)))));

            lock: std.event.Lock,

            lock: std.Thread.Mutex,

                std.mem.set(?*Node, n.nexts, null);
                n.lock = std.event.Lock{};

                @memset(n.nexts, null);
                n.lock = std.Thread.Mutex{};

        fn getMaxLevel(self: @This(), n: usize) usize {
            return @floatToInt(usize, std.math.log(f32, self.skip_size, @intToFloat(f32, n)));
        }

            std.debug.print("SkipList structure - P:{d}, max_level: {d}\n", .{ 1 / self.skip_size, self.max_level });
            var level: usize = self.max_level + 1;

            std.debug.print("SkipList(Lazy) structure - P:{d}, max_level: {d}\n", .{ 1 / opts.skip_size, max_level });
            var level: usize = max_level + 1;

            /// Make sure it is threadsafe if You want to use the SkipList from multiple threads!

            /// Number of items to skip with each level. This is a probabilistic value.
            skip_size: f32,
            /// Maximum number of items to be stored in the SkipList.
            /// This is not a hard limit, but SkipList performance will degrade when badly choosen.
            n_max: usize,

            if (skip_size <= 1) {
                std.log.err("skip_size {d} not allowed, must be > 1", .{skip_size});
                return error.InvalidSkipSize;
            }

                .rnd = std.rand.DefaultPrng.init(@intCast(u64, std.time.milliTimestamp())),
                .skip_size = skip_size,
                .allocator = allocator,

                .rnd = std.rand.DefaultPrng.init(@intCast(std.time.milliTimestamp())),

            sl.max_level = sl.getMaxLevel(n_max);
            sl.head = try Node.init(sl.allocator, 0, sl.max_level);

            sl.head = try Node.init(allocator, 0, max_level);

        pub fn deinit(self: @This()) void {
            _ = self;

        pub fn deinit(self: @This(), allocator: std.mem.Allocator) void {

                self.allocator.free(current.nexts);
                self.allocator.destroy(current);

                allocator.free(current.nexts);
                allocator.destroy(current);

            self.allocator.free(current.nexts);
            self.allocator.destroy(current);

            allocator.free(current.nexts);
            allocator.destroy(current);

        /// findNode finds the node with the matching `key` value. It also fills in preds and succs slices
        /// in the process.

            var level: usize = self.max_level + 1;

            var level: usize = max_level + 1;

                // XXX: compiler bug!
                if (found_level == null) {
                    if (curr != null) {
                        if (key == curr.?.key) {
                            found_level = level - 1;
                        }
                    }

                if (found_level == null and curr != null and key == curr.?.key) {
                    found_level = level - 1;
                    // NOTE: We could return at this point, but see Section 3.4
                    // for optimizations based on this lazy method.

        // XXX: do we really need preds and succs here?

        // TODO: do we really need preds and succs here?
        // findNode fills them, but it is unused here

            var preds = try self.allocator.alloc(?*Node, self.max_level + 1);
            std.mem.set(?*Node, preds, null);
            defer self.allocator.free(preds);

            var preds: [max_level + 1]?*Node = undefined;
            @memset(&preds, null);

            var succs = try self.allocator.alloc(?*Node, self.max_level + 1);
            std.mem.set(?*Node, succs, null);
            defer self.allocator.free(succs);

            var succs: [max_level + 1]?*Node = undefined;
            @memset(&succs, null);

            const found_level = self.findNode(search_key, preds, succs) orelse return null;

            const found_level = self.findNode(search_key, &preds, &succs) orelse return null;

            while (random.float(f32) < (1 / self.skip_size) and
                level < self.max_level) level += 1;

            while (random.float(f32) < (1 / opts.skip_size) and
                level < max_level) level += 1;

        pub fn insert(self: *@This(), insert_key: K, insert_value: V) !bool {

        pub fn insert(self: *@This(), allocator: std.mem.Allocator, insert_key: K, insert_value: V) !bool {

            var preds = try self.allocator.alloc(?*Node, self.max_level + 1);
            std.mem.set(?*Node, preds, null);
            defer self.allocator.free(preds);

            var preds: [max_level + 1]?*Node = undefined;
            // @memset(&preds, null);

            var succs = try self.allocator.alloc(?*Node, self.max_level + 1);
            std.mem.set(?*Node, succs, null);
            defer self.allocator.free(succs);

            var succs: [max_level + 1]?*Node = undefined;
            // @memset(&succs, null);

                const found_level = self.findNode(insert_key, preds, succs);
                // We have found the key we are trying to insert...
                if (found_level != null) {
                    const node = succs[found_level.?].?;

                if (self.findNode(insert_key, &preds, &succs)) |fl| {
                    // We have found the key we are trying to insert...
                    const node = succs[fl].?;

                // Lock handling part
                var helds = try std.ArrayList(std.event.Lock.Held).initCapacity(self.allocator, rlevel + 1);
                defer {
                    for (helds.items) |held| {
                        held.release();
                    }
                    helds.deinit();
                }

                // FIXME: hardcoded!
                const bits = comptime blk: {
                    break :blk @as(usize, @intFromFloat(std.math.log(f32, 4, @as(f32, @floatFromInt(100_000)))));
                };
                var locks = std.StaticBitSet(bits + 1).initEmpty();

                // var highest_locked: ?usize = null;

                // Find the new-node's place
                PLACE: while (true) {
                    var pred: ?*Node = undefined;
                    var succ: ?*Node = undefined;
                    var prev_pred: ?*Node = null;

                var pred: ?*Node = undefined;
                var succ: ?*Node = undefined;
                var prev_pred: ?*Node = null;

                    var valid: bool = true;

                var valid: bool = true;

                    // std.debug.print("\n{any} locks:\n", .{std.Thread.getCurrentId()});

                var level: usize = 0;
                while (valid and level <= rlevel) : (level += 1) {
                    pred = preds[level];
                    succ = succs[level];

                    for (0..rlevel + 1) |level| {
                        pred = preds[level];
                        succ = succs[level];

                    if (pred != prev_pred) {
                        helds.appendAssumeCapacity(pred.?.lock.acquire());
                        // highest_locked = level;
                        prev_pred = pred;

                        if (pred != prev_pred) { // only count multilayer items once
                            // std.debug.print("\t{d} {any}\n", .{ level, pred.?.key });
                            pred.?.lock.lock();
                            locks.set(level);
                            prev_pred = pred;
                        }
                        std.debug.assert(pred != null);
                        // Validation checks that for each layer:
                        // 1) level ≤ rlevel
                        // 2) preds[level] and succs[level] are still adjacent at `level`, and
                        // 3) neither is marked.
                        // If validation fails, the thread encountered a conflicting operation, so it releases
                        // the locks it acquired and restarts place finding.
                        valid = !pred.?.marked and (succ == null or !succ.?.marked) and
                            pred.?.nexts[level] == succ;
                        // If !valid cleanup and go to PLACE
                        if (!valid) {
                            // cleanup the locks
                            var lit = locks.iterator(.{});
                            while (lit.next()) |lvl| {
                                preds[lvl].?.lock.unlock();
                            }
                            break :PLACE;
                        }

                    std.debug.assert(pred != null);
                    // Validation checks that for each layer:
                    // 1) level ≤ rlevel
                    // 2) preds[level] and succs[level] are still adjacent at `level`, and
                    // 3) neither is marked.
                    // If validation fails, the thread encountered a conflicting operation, so it releases
                    // the locks it acquired (defer) and retries.
                    valid = !pred.?.marked and (succ == null or !succ.?.marked) and
                        pred.?.nexts[level] == succ;
                }
                if (!valid) continue;

                    // At this point everything is set for adding the new Node.

                // At this point everything is set for adding the new Node.

                    var node = try Node.init(allocator, insert_key, rlevel);
                    node.value = insert_value;

                var node = try Node.init(self.allocator, insert_key, rlevel);
                node.value = insert_value;

                    for (0..rlevel + 1) |level| {
                        node.nexts[level] = succs[level]; // unlocked, but safe, as not linked yet
                        preds[level].?.nexts[level] = node;
                    }
                    node.fully_linked = true;

                level = 0;
                while (level <= rlevel) : (level += 1) {
                    node.nexts[level] = succs[level]; // unlocked, but safe, as not linked yet
                    preds[level].?.nexts[level] = node;
                }
                node.fully_linked = true;

                    // cleanup the locks
                    var lit = locks.iterator(.{});
                    while (lit.next()) |lvl| {
                        // std.debug.print("\tfinal unlocks {d} {any}\n", .{ lvl, preds[lvl].?.key });
                        preds[lvl].?.lock.unlock();
                    }

                return true;

                    return true;
                }

        pub fn remove(self: @This(), remove_key: K) !bool {

        pub fn remove(self: @This(), allocator: std.mem.Allocator, remove_key: K) !bool {

            var node_lock: std.event.Lock.Held = undefined;

            var node_lock = std.Thread.Mutex{};

            var preds = try self.allocator.alloc(?*Node, self.max_level + 1);
            std.mem.set(?*Node, preds, null);
            defer self.allocator.free(preds);

            var preds = try allocator.alloc(?*Node, max_level + 1);
            @memset(preds, null);
            defer allocator.free(preds);

            var succs = try self.allocator.alloc(?*Node, self.max_level + 1);
            std.mem.set(?*Node, succs, null);
            defer self.allocator.free(succs);

            const succs = try allocator.alloc(?*Node, max_level + 1);
            @memset(succs, null);
            defer allocator.free(succs);

                        node_lock = node_delete.?.lock.acquire();

                        node_lock.lock();

                            node_lock.release();

                            node_lock.unlock();

                    var helds = try std.ArrayList(std.event.Lock.Held).initCapacity(self.allocator, node_height.? + 1);

                    var helds = try std.ArrayList(std.Thread.Mutex).initCapacity(allocator, node_height.? + 1);

                        for (helds.items) |held| {
                            held.release();

                        for (helds.items) |*held| {
                            held.unlock();

                            helds.appendAssumeCapacity(pred.?.lock.acquire());

                            pred.?.lock.lock();
                            helds.appendAssumeCapacity(pred.?.lock);

                    node_lock.release();
                    node_delete.?.deinit(self.allocator);

                    node_lock.unlock();
                    node_delete.?.deinit(allocator);

// run tests with zig test --test-evented-io -fstage1

    const SL = Lazy(KeyType, void, {}, comptime std.sort.asc(KeyType));
    var sl = try SL.init(std.testing.allocator, 4, 16);
    defer sl.deinit();

    const SL = Lazy(Options{ .items = 16, .skip_size = 4 }, KeyType, void, {}, comptime std.sort.asc(KeyType));
    var sl = try SL.init(std.testing.allocator);
    defer sl.deinit(std.testing.allocator);
    errdefer sl.deinit(std.testing.allocator);

    try std.testing.expect((try sl.insert(3, {})) == true);
    try std.testing.expect((try sl.insert(6, {})) == true);
    try std.testing.expect((try sl.insert(7, {})) == true);
    try std.testing.expect((try sl.insert(9, {})) == true);
    try std.testing.expect((try sl.insert(12, {})) == true);
    try std.testing.expect((try sl.insert(12, {})) == false);
    try std.testing.expect((try sl.insert(12, {})) == false);
    try std.testing.expect((try sl.insert(19, {})) == true);
    try std.testing.expect((try sl.insert(17, {})) == true);
    try std.testing.expect((try sl.insert(26, {})) == true);
    try std.testing.expect((try sl.insert(21, {})) == true);
    try std.testing.expect((try sl.insert(25, {})) == true);
    try std.testing.expect((try sl.insert(8, {})) == true);
    try std.testing.expect((try sl.insert(42, {})) == true);
    try std.testing.expect((try sl.insert(88, {})) == true);
    try std.testing.expect((try sl.insert(22, {})) == true);
    try std.testing.expect((try sl.insert(66, {})) == true);

    try std.testing.expect((try sl.insert(std.testing.allocator, 3, {})) == true);
    try std.testing.expect((try sl.insert(std.testing.allocator, 6, {})) == true);
    try std.testing.expect((try sl.insert(std.testing.allocator, 7, {})) == true);
    try std.testing.expect((try sl.insert(std.testing.allocator, 9, {})) == true);
    try std.testing.expect((try sl.insert(std.testing.allocator, 12, {})) == true);
    try std.testing.expect((try sl.insert(std.testing.allocator, 12, {})) == false);
    try std.testing.expect((try sl.insert(std.testing.allocator, 12, {})) == false);
    try std.testing.expect((try sl.insert(std.testing.allocator, 19, {})) == true);
    try std.testing.expect((try sl.insert(std.testing.allocator, 8, {})) == true);
    try std.testing.expect((try sl.insert(std.testing.allocator, 17, {})) == true);
    try std.testing.expect((try sl.insert(std.testing.allocator, 26, {})) == true);
    try std.testing.expect((try sl.insert(std.testing.allocator, 21, {})) == true);
    try std.testing.expect((try sl.insert(std.testing.allocator, 25, {})) == true);
    try std.testing.expect((try sl.insert(std.testing.allocator, 42, {})) == true);
    try std.testing.expect((try sl.insert(std.testing.allocator, 88, {})) == true);
    try std.testing.expect((try sl.insert(std.testing.allocator, 22, {})) == true);
    try std.testing.expect((try sl.insert(std.testing.allocator, 66, {})) == true);

    try std.testing.expect((try sl.insert(std.math.minInt(KeyType), {})) == true);

    try std.testing.expect((try sl.insert(std.testing.allocator, std.math.minInt(KeyType), {})) == true);

    try std.testing.expect((try sl.remove(13)) == false);
    try std.testing.expect((try sl.remove(12)) == true);
    try std.testing.expect((try sl.remove(12)) == false);
    try std.testing.expect((try sl.remove(std.math.minInt(KeyType))) == true);

    try std.testing.expect((try sl.remove(std.testing.allocator, 13)) == false);
    try std.testing.expect((try sl.remove(std.testing.allocator, 12)) == true);
    try std.testing.expect((try sl.remove(std.testing.allocator, 12)) == false);
    try std.testing.expect((try sl.remove(std.testing.allocator, std.math.minInt(KeyType))) == true);

pub fn build(b: *std.build.Builder) void {
    // Standard target options allows the person running `zig build` to choose
    // what target to build for. Here we do not override the defaults, which
    // means any target is allowed, and the default is native. Other options
    // for restricting supported target set are available.

pub fn build(b: *std.Build) void {

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

    // Standard release options allow the person running `zig build` to select
    // between Debug, ReleaseSafe, ReleaseFast, and ReleaseSmall.
    const mode = b.standardReleaseOptions();

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

    const exe = b.addExecutable("skiplist.zig", "src/main.zig");
    exe.setTarget(target);
    exe.setBuildMode(mode);
    exe.use_stage1 = true;
    exe.install();

    // This declares intent for the executable to be installed into the
    // standard location when the user invokes the "install" step (the default
    // step when running `zig build`).
    b.installArtifact(exe);

    const run_cmd = exe.run();

    // This *creates* a Run step in the build graph, to be executed when another
    // step is evaluated that depends on it. The next line below will establish
    // such a dependency.
    const run_cmd = b.addRunArtifact(exe);
    // By making the run step depend on the install step, it will be run from the
    // installation directory rather than directly from within the cache directory.
    // This is not necessary, however, if the application depends on other installed
    // files, this ensures they will be present and in the expected location.

    // This allows the user to pass arguments to the application in the build
    // command itself, like this: `zig build run -- arg1 arg2 etc`

    // This creates a build step. It will be visible in the `zig build --help` menu,
    // and can be selected like this: `zig build run`
    // This will evaluate the `run` step rather than the default, which is "install".

    const exe_tests = b.addTest("src/main.zig");
    exe_tests.setTarget(target);
    exe_tests.setBuildMode(mode);
    exe_tests.use_stage1 = true;
    exe_tests.test_evented_io = true;

    // Creates a step for unit testing. This only builds the test executable
    // but does not run it.
    const exe_unit_tests = b.addTest(.{
        .root_source_file = b.path("src/lib.zig"),
        .target = target,
        .optimize = optimize,
    });
    const run_exe_unit_tests = b.addRunArtifact(exe_unit_tests);

    // Similar to creating the run step earlier, this exposes a `test` step to
    // the `zig build --help` menu, providing a way for the user to request
    // running the unit tests.

    test_step.dependOn(&exe_tests.step);

    test_step.dependOn(&run_exe_unit_tests.step);