Add a new unittest build step

Makefile

@@ -3,6 +3,8 @@
 
 ZIG := zig
 BC := $(dir $(abspath $(lastword $(MAKEFILE_LIST))))
+# option test filter make unittest F="server"
+F=
 
 # OS and ARCH
 kernel = $(shell uname -ms)
@@ -42,7 +44,7 @@ help:
 
 # $(ZIG) commands
 # ------------
-.PHONY: build build-dev run run-release shell test bench download-zig wpt
+.PHONY: build build-dev run run-release shell test bench download-zig wpt unittest
 
 zig_version = $(shell grep 'recommended_zig_version = "' "vendor/zig-js-runtime/build.zig" | cut -d'"' -f2)
 
@@ -91,6 +93,9 @@ test:
 	@$(ZIG) build test -Dengine=v8 || (printf "\e[33mTest ERROR\e[0m\n"; exit 1;)
 	@printf "\e[33mTest OK\e[0m\n"
 
+unittest:
+	@TEST_FILTER='${F}' $(ZIG) build unittest -freference-trace --summary all
+
 # Install and build required dependencies commands
 # ------------
 .PHONY: install-submodule

build.zig

@@ -98,8 +98,8 @@ pub fn build(b: *std.Build) !void {
 
     // compile
     const tests = b.addTest(.{
-        .root_source_file = b.path("src/run_tests.zig"),
-        .test_runner = b.path("src/test_runner.zig"),
+        .root_source_file = b.path("src/main_tests.zig"),
+        .test_runner = b.path("src/main_tests.zig"),
         .target = target,
         .optimize = mode,
     });
@@ -119,6 +119,27 @@ pub fn build(b: *std.Build) !void {
     const test_step = b.step("test", "Run unit tests");
     test_step.dependOn(&run_tests.step);
 
+    // unittest
+    // ----
+
+    // compile
+    const unit_tests = b.addTest(.{
+        .root_source_file = b.path("src/unit_tests.zig"),
+        .test_runner = b.path("src/unit_tests.zig"),
+        .target = target,
+        .optimize = mode,
+    });
+    try common(b, unit_tests, options);
+
+    const run_unit_tests = b.addRunArtifact(unit_tests);
+    if (b.args) |args| {
+        run_unit_tests.addArgs(args);
+    }
+
+    // step
+    const unit_test_step = b.step("unittest", "Run unit tests");
+    unit_test_step.dependOn(&run_unit_tests.step);
+
     // wpt
     // -----
 

src/browser/loader.zig

@@ -79,13 +79,19 @@ pub const Loader = struct {
     }
 };
 
-test "basic url get" {
+test "loader: get" {
     const alloc = std.testing.allocator;
     var loader = Loader.init(alloc);
     defer loader.deinit();
 
-    var result = try loader.get(alloc, "https://en.wikipedia.org/wiki/Main_Page");
+    const uri = try std.Uri.parse("http://localhost:9582/loader");
+    var result = try loader.get(alloc, uri);
     defer result.deinit();
 
-    try std.testing.expect(result.req.response.status == std.http.Status.ok);
+    try std.testing.expectEqual(.ok, result.req.response.status);
+
+    var res: [128]u8 = undefined;
+    const size = try result.req.readAll(&res);
+    try std.testing.expectEqual(6, size);
+    try std.testing.expectEqualStrings("Hello!", res[0..6]);
 }

src/iterator/iterator.zig

@@ -15,19 +15,39 @@ pub const U32Iterator = struct {
         done: bool,
     };
 
-    pub fn _next(self: *U32Iterator) !Return {
+    pub fn _next(self: *U32Iterator) Return {
         const i = self.index;
         if (i >= self.length) {
-            return Return{
+            return .{
                 .value = 0,
                 .done = true,
             };
         }
 
-        self.index += 1;
-        return Return{
+        self.index = i + 1;
+        return .{
             .value = i,
             .done = false,
         };
     }
 };
+
+const testing = std.testing;
+test "U32Iterator" {
+    const Return = U32Iterator.Return;
+
+    {
+        var it = U32Iterator{ .length = 0 };
+        try testing.expectEqual(Return{ .value = 0, .done = true }, it._next());
+        try testing.expectEqual(Return{ .value = 0, .done = true }, it._next());
+    }
+
+    {
+        var it = U32Iterator{ .length = 3 };
+        try testing.expectEqual(Return{ .value = 0, .done = false }, it._next());
+        try testing.expectEqual(Return{ .value = 1, .done = false }, it._next());
+        try testing.expectEqual(Return{ .value = 2, .done = false }, it._next());
+        try testing.expectEqual(Return{ .value = 0, .done = true }, it._next());
+        try testing.expectEqual(Return{ .value = 0, .done = true }, it._next());
+    }
+}

src/run_tests.zig → src/main_tests.zig

@@ -223,8 +223,14 @@ pub fn main() !void {
             try parser.init();
             defer parser.deinit();
 
+            std.testing.allocator_instance = .{};
             try test_fn.func();
-            std.debug.print("{s}\tOK\n", .{test_fn.name});
+
+            if (std.testing.allocator_instance.deinit() == .leak) {
+                std.debug.print("======Memory Leak: {s}======\n", .{test_fn.name});
+            } else {
+                std.debug.print("{s}\tOK\n", .{test_fn.name});
+            }
         }
     }
 }

src/storage/storage.zig

@@ -149,20 +149,22 @@ pub const Bottle = struct {
     }
 
     pub fn _setItem(self: *Bottle, k: []const u8, v: []const u8) !void {
-        const old = self.map.get(k);
-        if (old != null and std.mem.eql(u8, v, old.?)) return;
-
-        // owns k and v by copying them.
-        const kk = try self.alloc.dupe(u8, k);
-        errdefer self.alloc.free(kk);
-        const vv = try self.alloc.dupe(u8, v);
-        errdefer self.alloc.free(vv);
-
-        self.map.put(self.alloc, kk, vv) catch |e| {
+        const gop = self.map.getOrPut(self.alloc, k) catch |e| {
             log.debug("set item: {any}", .{e});
             return DOMError.QuotaExceeded;
         };
 
+        if (gop.found_existing == false) {
+            gop.key_ptr.* = try self.alloc.dupe(u8, k);
+            gop.value_ptr.* = try self.alloc.dupe(u8, v);
+            return;
+        }
+
+        if (std.mem.eql(u8, v, gop.value_ptr.*) == false) {
+            self.alloc.free(gop.value_ptr.*);
+            gop.value_ptr.* = try self.alloc.dupe(u8, v);
+        }
+
         // > Broadcast this with key, oldValue, and value.
         // https://html.spec.whatwg.org/multipage/webstorage.html#the-storageevent-interface
         //
@@ -175,8 +177,10 @@ pub const Bottle = struct {
     }
 
     pub fn _removeItem(self: *Bottle, k: []const u8) !void {
-        const old = self.map.fetchRemove(k);
-        if (old == null) return;
+        if (self.map.fetchRemove(k)) |kv| {
+            self.alloc.free(kv.key);
+            self.alloc.free(kv.value);
+        }
 
         // > Broadcast this with key, oldValue, and null.
         // https://html.spec.whatwg.org/multipage/webstorage.html#the-storageevent-interface
@@ -235,14 +239,17 @@ test "storage bottle" {
     var bottle = Bottle.init(std.testing.allocator);
     defer bottle.deinit();
 
-    try std.testing.expect(0 == bottle.get_length());
-    try std.testing.expect(null == bottle._getItem("foo"));
+    try std.testing.expectEqual(0, bottle.get_length());
+    try std.testing.expectEqual(null, bottle._getItem("foo"));
 
     try bottle._setItem("foo", "bar");
-    try std.testing.expect(std.mem.eql(u8, "bar", bottle._getItem("foo").?));
+    try std.testing.expectEqualStrings("bar", bottle._getItem("foo").?);
+
+    try bottle._setItem("foo", "other");
+    try std.testing.expectEqualStrings("other", bottle._getItem("foo").?);
 
     try bottle._removeItem("foo");
 
-    try std.testing.expect(0 == bottle.get_length());
-    try std.testing.expect(null == bottle._getItem("foo"));
+    try std.testing.expectEqual(0, bottle.get_length());
+    try std.testing.expectEqual(null, bottle._getItem("foo"));
 }