8 files changed, 204 insertions, 44 deletions

diff --git a/build.zig b/build.zig
index ce362ea..b555bd7 100644
--- a/build.zig
+++ b/build.zig
@@ -183,6 +183,14 @@ pub fn build(b: *std.Build) void {
         .optimize = optimize,
     });
 
+    const code_point_t = b.addTest(.{
+        .name = "code_point",
+        .root_module = code_point,
+        .target = target,
+        .optimize = optimize,
+    });
+    const code_point_tr = b.addRunArtifact(code_point_t);
+
     // Grapheme clusters
     const grapheme_data = b.createModule(.{
         .root_source_file = b.path("src/GraphemeData.zig"),
@@ -191,6 +199,14 @@ pub fn build(b: *std.Build) void {
     });
     grapheme_data.addAnonymousImport("gbp", .{ .root_source_file = gbp_gen_out });
 
+    const grapheme_data_t = b.addTest(.{
+        .name = "grapheme_data",
+        .root_module = grapheme_data,
+        .target = target,
+        .optimize = optimize,
+    });
+    const grapheme_data_tr = b.addRunArtifact(grapheme_data_t);
+
     const grapheme = b.addModule("grapheme", .{
         .root_source_file = b.path("src/grapheme.zig"),
         .target = target,
@@ -199,6 +215,14 @@ pub fn build(b: *std.Build) void {
     grapheme.addImport("code_point", code_point);
     grapheme.addImport("GraphemeData", grapheme_data);
 
+    const grapheme_t = b.addTest(.{
+        .name = "grapheme",
+        .root_module = grapheme,
+        .target = target,
+        .optimize = optimize,
+    });
+    const grapheme_tr = b.addRunArtifact(grapheme_t);
+
     // ASCII utilities
     const ascii = b.addModule("ascii", .{
         .root_source_file = b.path("src/ascii.zig"),
@@ -206,6 +230,14 @@ pub fn build(b: *std.Build) void {
         .optimize = optimize,
     });
 
+    const ascii_t = b.addTest(.{
+        .name = "ascii",
+        .root_module = ascii,
+        .target = target,
+        .optimize = optimize,
+    });
+    const ascii_tr = b.addRunArtifact(ascii_t);
+
     // Fixed pitch font display width
     const width_data = b.createModule(.{
         .root_source_file = b.path("src/WidthData.zig"),
@@ -215,6 +247,14 @@ pub fn build(b: *std.Build) void {
     width_data.addAnonymousImport("dwp", .{ .root_source_file = dwp_gen_out });
     width_data.addImport("GraphemeData", grapheme_data);
 
+    const width_data_t = b.addTest(.{
+        .name = "width_data",
+        .root_module = width_data,
+        .target = target,
+        .optimize = optimize,
+    });
+    const width_data_tr = b.addRunArtifact(width_data_t);
+
     const display_width = b.addModule("DisplayWidth", .{
         .root_source_file = b.path("src/DisplayWidth.zig"),
         .target = target,
@@ -226,6 +266,14 @@ pub fn build(b: *std.Build) void {
     display_width.addImport("DisplayWidthData", width_data);
     display_width.addOptions("options", options); // For testing
 
+    const display_width_t = b.addTest(.{
+        .name = "display_width",
+        .root_module = display_width,
+        .target = target,
+        .optimize = optimize,
+    });
+    const display_width_tr = b.addRunArtifact(display_width_t);
+
     // Normalization
     const ccc_data = b.createModule(.{
         .root_source_file = b.path("src/CombiningData.zig"),
@@ -234,6 +282,14 @@ pub fn build(b: *std.Build) void {
     });
     ccc_data.addAnonymousImport("ccc", .{ .root_source_file = ccc_gen_out });
 
+    const ccc_data_t = b.addTest(.{
+        .name = "ccc_data",
+        .root_module = ccc_data,
+        .target = target,
+        .optimize = optimize,
+    });
+    const ccc_data_tr = b.addRunArtifact(ccc_data_t);
+
     const canon_data = b.createModule(.{
         .root_source_file = b.path("src/CanonData.zig"),
         .target = target,
@@ -241,6 +297,14 @@ pub fn build(b: *std.Build) void {
     });
     canon_data.addAnonymousImport("canon", .{ .root_source_file = canon_gen_out });
 
+    const canon_data_t = b.addTest(.{
+        .name = "canon_data",
+        .root_module = canon_data,
+        .target = target,
+        .optimize = optimize,
+    });
+    const canon_data_tr = b.addRunArtifact(canon_data_t);
+
     const compat_data = b.createModule(.{
         .root_source_file = b.path("src/CompatData.zig"),
         .target = target,
@@ -248,6 +312,14 @@ pub fn build(b: *std.Build) void {
     });
     compat_data.addAnonymousImport("compat", .{ .root_source_file = compat_gen_out });
 
+    const compat_data_t = b.addTest(.{
+        .name = "compat_data",
+        .root_module = compat_data,
+        .target = target,
+        .optimize = optimize,
+    });
+    const compat_data_tr = b.addRunArtifact(compat_data_t);
+
     const hangul_data = b.createModule(.{
         .root_source_file = b.path("src/HangulData.zig"),
         .target = target,
@@ -255,6 +327,14 @@ pub fn build(b: *std.Build) void {
     });
     hangul_data.addAnonymousImport("hangul", .{ .root_source_file = hangul_gen_out });
 
+    const hangul_data_t = b.addTest(.{
+        .name = "hangul_data",
+        .root_module = hangul_data,
+        .target = target,
+        .optimize = optimize,
+    });
+    const hangul_data_tr = b.addRunArtifact(hangul_data_t);
+
     const normp_data = b.createModule(.{
         .root_source_file = b.path("src/NormPropsData.zig"),
         .target = target,
@@ -262,6 +342,14 @@ pub fn build(b: *std.Build) void {
     });
     normp_data.addAnonymousImport("normp", .{ .root_source_file = normp_gen_out });
 
+    const normp_data_t = b.addTest(.{
+        .name = "normp_data",
+        .root_module = normp_data,
+        .target = target,
+        .optimize = optimize,
+    });
+    const normp_data_tr = b.addRunArtifact(normp_data_t);
+
     const norm_data = b.createModule(.{
         .root_source_file = b.path("src/NormData.zig"),
         .target = target,
@@ -282,6 +370,14 @@ pub fn build(b: *std.Build) void {
     norm.addImport("code_point", code_point);
     norm.addImport("NormData", norm_data);
 
+    const norm_data_t = b.addTest(.{
+        .name = "norm_data",
+        .root_module = norm_data,
+        .target = target,
+        .optimize = optimize,
+    });
+    const norm_data_tr = b.addRunArtifact(norm_data_t);
+
     // General Category
     const gencat_data = b.addModule("GenCatData", .{
         .root_source_file = b.path("src/GenCatData.zig"),
@@ -290,6 +386,14 @@ pub fn build(b: *std.Build) void {
     });
     gencat_data.addAnonymousImport("gencat", .{ .root_source_file = gencat_gen_out });
 
+    const gencat_data_t = b.addTest(.{
+        .name = "gencat_data",
+        .root_module = gencat_data,
+        .target = target,
+        .optimize = optimize,
+    });
+    const gencat_data_tr = b.addRunArtifact(gencat_data_t);
+
     // Case folding
     const fold_data = b.createModule(.{
         .root_source_file = b.path("src/FoldData.zig"),
@@ -307,6 +411,14 @@ pub fn build(b: *std.Build) void {
     case_fold.addImport("FoldData", fold_data);
     case_fold.addImport("Normalize", norm);
 
+    const case_fold_t = b.addTest(.{
+        .name = "case_fold",
+        .root_module = case_fold,
+        .target = target,
+        .optimize = optimize,
+    });
+    const case_fold_tr = b.addRunArtifact(case_fold_t);
+
     // Letter case
     const case_data = b.addModule("CaseData", .{
         .root_source_file = b.path("src/CaseData.zig"),
@@ -318,6 +430,14 @@ pub fn build(b: *std.Build) void {
     case_data.addAnonymousImport("upper", .{ .root_source_file = upper_gen_out });
     case_data.addAnonymousImport("lower", .{ .root_source_file = lower_gen_out });
 
+    const case_data_t = b.addTest(.{
+        .name = "case_data",
+        .root_module = case_data,
+        .target = target,
+        .optimize = optimize,
+    });
+    const case_data_tr = b.addRunArtifact(case_data_t);
+
     // Scripts
     const scripts_data = b.addModule("ScriptsData", .{
         .root_source_file = b.path("src/ScriptsData.zig"),
@@ -326,6 +446,14 @@ pub fn build(b: *std.Build) void {
     });
     scripts_data.addAnonymousImport("scripts", .{ .root_source_file = scripts_gen_out });
 
+    const scripts_data_t = b.addTest(.{
+        .name = "scripts_data",
+        .root_module = scripts_data,
+        .target = target,
+        .optimize = optimize,
+    });
+    const scripts_data_tr = b.addRunArtifact(scripts_data_t);
+
     // Properties
     const props_data = b.addModule("PropsData", .{
         .root_source_file = b.path("src/PropsData.zig"),
@@ -336,6 +464,14 @@ pub fn build(b: *std.Build) void {
     props_data.addAnonymousImport("props", .{ .root_source_file = props_gen_out });
     props_data.addAnonymousImport("numeric", .{ .root_source_file = num_gen_out });
 
+    const props_data_t = b.addTest(.{
+        .name = "props_data",
+        .root_module = props_data,
+        .target = target,
+        .optimize = optimize,
+    });
+    const props_data_tr = b.addRunArtifact(props_data_t);
+
     // Unicode Tests
     const unicode_tests = b.addTest(.{
         .root_source_file = b.path("src/unicode_tests.zig"),
@@ -349,4 +485,23 @@ pub fn build(b: *std.Build) void {
 
     const unicode_test_step = b.step("unicode-test", "Run Unicode tests");
     unicode_test_step.dependOn(&run_unicode_tests.step);
+
+    const test_step = b.step("test", "Run general tests");
+    test_step.dependOn(&code_point_tr.step);
+    test_step.dependOn(&grapheme_data_tr.step);
+    test_step.dependOn(&width_data_tr.step);
+    test_step.dependOn(&display_width_tr.step);
+    test_step.dependOn(&grapheme_tr.step);
+    test_step.dependOn(&ascii_tr.step);
+    test_step.dependOn(&ccc_data_tr.step);
+    test_step.dependOn(&canon_data_tr.step);
+    test_step.dependOn(&compat_data_tr.step);
+    test_step.dependOn(&hangul_data_tr.step);
+    test_step.dependOn(&normp_data_tr.step);
+    test_step.dependOn(&norm_data_tr.step);
+    test_step.dependOn(&gencat_data_tr.step);
+    test_step.dependOn(&case_fold_tr.step);
+    test_step.dependOn(&case_data_tr.step);
+    test_step.dependOn(&scripts_data_tr.step);
+    test_step.dependOn(&props_data_tr.step);
 }
diff --git a/src/CaseData.zig b/src/CaseData.zig
index f05ac26..0a0acb1 100644
--- a/src/CaseData.zig
+++ b/src/CaseData.zig
@@ -99,7 +99,7 @@ pub fn isUpperStr(self: Self, str: []const u8) bool {
 
 test "isUpperStr" {
     const cd = try init(testing.allocator);
-    defer cd.deinit();
+    defer cd.deinit(testing.allocator);
 
     try testing.expect(cd.isUpperStr("HELLO, WORLD 2112!"));
     try testing.expect(!cd.isUpperStr("hello, world 2112!"));
@@ -134,7 +134,7 @@ pub fn toUpperStr(
 
 test "toUpperStr" {
     const cd = try init(testing.allocator);
-    defer cd.deinit();
+    defer cd.deinit(testing.allocator);
 
     const uppered = try cd.toUpperStr(testing.allocator, "Hello, World 2112!");
     defer testing.allocator.free(uppered);
@@ -157,7 +157,7 @@ pub fn isLowerStr(self: Self, str: []const u8) bool {
 
 test "isLowerStr" {
     const cd = try init(testing.allocator);
-    defer cd.deinit();
+    defer cd.deinit(testing.allocator);
 
     try testing.expect(cd.isLowerStr("hello, world 2112!"));
     try testing.expect(!cd.isLowerStr("HELLO, WORLD 2112!"));
@@ -192,7 +192,7 @@ pub fn toLowerStr(
 
 test "toLowerStr" {
     const cd = try init(testing.allocator);
-    defer cd.deinit();
+    defer cd.deinit(testing.allocator);
 
     const lowered = try cd.toLowerStr(testing.allocator, "Hello, World 2112!");
     defer testing.allocator.free(lowered);
diff --git a/src/CaseFold.zig b/src/CaseFold.zig
index 19c9da8..c84a420 100644
--- a/src/CaseFold.zig
+++ b/src/CaseFold.zig
@@ -95,12 +95,13 @@ pub fn compatCaselessMatch(
 test "compatCaselessMatch" {
     const allocator = testing.allocator;
 
-    const norm_data = try Normalize.NormData.init(allocator);
-    defer norm_data.deinit();
+    var norm_data = Normalize.NormData{};
+    try norm_data.init(allocator);
+    defer norm_data.deinit(allocator);
     const n = Normalize{ .norm_data = &norm_data };
 
     const fold_data = try FoldData.init(allocator);
-    defer fold_data.deinit();
+    defer fold_data.deinit(allocator);
     const caser = Self{ .fold_data = &fold_data };
 
     try testing.expect(try caser.compatCaselessMatch(allocator, &n, "ascii only!", "ASCII Only!"));
@@ -170,12 +171,13 @@ pub fn canonCaselessMatch(
 test "canonCaselessMatch" {
     const allocator = testing.allocator;
 
-    const norm_data = try Normalize.NormData.init(allocator);
-    defer norm_data.deinit();
+    var norm_data = Normalize.NormData{};
+    try norm_data.init(allocator);
+    defer norm_data.deinit(allocator);
     const n = Normalize{ .norm_data = &norm_data };
 
     const fold_data = try FoldData.init(allocator);
-    defer fold_data.deinit();
+    defer fold_data.deinit(allocator);
     const caser = Self{ .fold_data = &fold_data };
 
     try testing.expect(try caser.canonCaselessMatch(allocator, &n, "ascii only!", "ASCII Only!"));
diff --git a/src/DisplayWidth.zig b/src/DisplayWidth.zig
index 04e6b0c..8631bd4 100644
--- a/src/DisplayWidth.zig
+++ b/src/DisplayWidth.zig
@@ -59,7 +59,7 @@ pub fn strWidth(self: Self, str: []const u8) usize {
 
 test "strWidth" {
     const data = try DisplayWidthData.init(testing.allocator);
-    defer data.deinit();
+    defer data.deinit(testing.allocator);
     const self = Self{ .data = &data };
     const c0 = options.c0_width orelse 0;
 
@@ -166,7 +166,7 @@ pub fn center(
 test "center" {
     const allocator = testing.allocator;
     const data = try DisplayWidthData.init(allocator);
-    defer data.deinit();
+    defer data.deinit(allocator);
     const self = Self{ .data = &data };
 
     // Input and width both have odd length
@@ -245,7 +245,7 @@ pub fn padLeft(
 test "padLeft" {
     const allocator = testing.allocator;
     const data = try DisplayWidthData.init(allocator);
-    defer data.deinit();
+    defer data.deinit(allocator);
     const self = Self{ .data = &data };
 
     var right_aligned = try self.padLeft(allocator, "abc", 9, "*");
@@ -295,7 +295,7 @@ pub fn padRight(
 test "padRight" {
     const allocator = testing.allocator;
     const data = try DisplayWidthData.init(allocator);
-    defer data.deinit();
+    defer data.deinit(allocator);
     const self = Self{ .data = &data };
 
     var left_aligned = try self.padRight(allocator, "abc", 9, "*");
@@ -348,7 +348,7 @@ pub fn wrap(
 test "wrap" {
     const allocator = testing.allocator;
     const data = try DisplayWidthData.init(allocator);
-    defer data.deinit();
+    defer data.deinit(allocator);
     const self = Self{ .data = &data };
 
     const input = "The quick brown fox\r\njumped over the lazy dog!";
diff --git a/src/Normalize.zig b/src/Normalize.zig
index 97c2649..a28b708 100644
--- a/src/Normalize.zig
+++ b/src/Normalize.zig
@@ -229,7 +229,7 @@ pub const Result = struct {
 
     /// Ensures that the slice result is a copy of the input, by making a copy if it was not.
     pub fn toOwned(result: Result, allocator: mem.Allocator) error{OutOfMemory}!Result {
-        if (result.allocatod) return result;
+        if (result.allocated) return result;
         return .{ .allocated = true, .slice = try allocator.dupe(u8, result.slice) };
     }
 
@@ -571,9 +571,9 @@ test "nfkc" {
 /// Tests for equality of `a` and `b` after normalizing to NFC.
 pub fn eql(self: Self, allocator: mem.Allocator, a: []const u8, b: []const u8) !bool {
     const norm_result_a = try self.nfc(allocator, a);
-    defer norm_result_a.deinit();
+    defer norm_result_a.deinit(allocator);
     const norm_result_b = try self.nfc(allocator, b);
-    defer norm_result_b.deinit();
+    defer norm_result_b.deinit(allocator);
 
     return mem.eql(u8, norm_result_a.slice, norm_result_b.slice);
 }
@@ -628,4 +628,5 @@ test "isLatin1Only" {
     try testing.expect(isLatin1Only(latin1_only));
     const not_latin1_only = "Héllo, World! \u{3d3}";
     try testing.expect(!isLatin1Only(not_latin1_only));
+    try testing.expect(false);
 }
diff --git a/src/PropsData.zig b/src/PropsData.zig
index 09c69c7..46920be 100644
--- a/src/PropsData.zig
+++ b/src/PropsData.zig
@@ -141,7 +141,7 @@ pub fn isDecimal(self: Self, cp: u21) bool {
 
 test "Props" {
     const self = try init(testing.allocator);
-    defer self.deinit();
+    defer self.deinit(testing.allocator);
 
     try testing.expect(self.isHexDigit('F'));
     try testing.expect(self.isHexDigit('a'));
diff --git a/src/WidthData.zig b/src/WidthData.zig
index 4a49c80..b07a679 100644
--- a/src/WidthData.zig
+++ b/src/WidthData.zig
@@ -55,28 +55,30 @@ pub fn codePointWidth(self: Self, cp: u21) i4 {
 }
 
 test "codePointWidth" {
-    try testing.expectEqual(@as(i4, 0), codePointWidth(0x0000)); // null
-    try testing.expectEqual(@as(i4, -1), codePointWidth(0x8)); // \b
-    try testing.expectEqual(@as(i4, -1), codePointWidth(0x7f)); // DEL
-    try testing.expectEqual(@as(i4, 0), codePointWidth(0x0005)); // Cf
-    try testing.expectEqual(@as(i4, 0), codePointWidth(0x0007)); // \a BEL
-    try testing.expectEqual(@as(i4, 0), codePointWidth(0x000A)); // \n LF
-    try testing.expectEqual(@as(i4, 0), codePointWidth(0x000B)); // \v VT
-    try testing.expectEqual(@as(i4, 0), codePointWidth(0x000C)); // \f FF
-    try testing.expectEqual(@as(i4, 0), codePointWidth(0x000D)); // \r CR
-    try testing.expectEqual(@as(i4, 0), codePointWidth(0x000E)); // SQ
-    try testing.expectEqual(@as(i4, 0), codePointWidth(0x000F)); // SI
-
-    try testing.expectEqual(@as(i4, 0), codePointWidth(0x070F)); // Cf
-    try testing.expectEqual(@as(i4, 1), codePointWidth(0x0603)); // Cf Arabic
-
-    try testing.expectEqual(@as(i4, 1), codePointWidth(0x00AD)); // soft-hyphen
-    try testing.expectEqual(@as(i4, 2), codePointWidth(0x2E3A)); // two-em dash
-    try testing.expectEqual(@as(i4, 3), codePointWidth(0x2E3B)); // three-em dash
-
-    try testing.expectEqual(@as(i4, 1), codePointWidth(0x00BD)); // ambiguous halfwidth
-
-    try testing.expectEqual(@as(i4, 1), codePointWidth('é'));
-    try testing.expectEqual(@as(i4, 2), codePointWidth('😊'));
-    try testing.expectEqual(@as(i4, 2), codePointWidth('统'));
+    const wd = try Self.init(std.testing.allocator);
+    defer wd.deinit(std.testing.allocator);
+    try testing.expectEqual(@as(i4, 0), wd.codePointWidth(0x0000)); // null
+    try testing.expectEqual(@as(i4, -1), wd.codePointWidth(0x8)); // \b
+    try testing.expectEqual(@as(i4, -1), wd.codePointWidth(0x7f)); // DEL
+    try testing.expectEqual(@as(i4, 0), wd.codePointWidth(0x0005)); // Cf
+    try testing.expectEqual(@as(i4, 0), wd.codePointWidth(0x0007)); // \a BEL
+    try testing.expectEqual(@as(i4, 0), wd.codePointWidth(0x000A)); // \n LF
+    try testing.expectEqual(@as(i4, 0), wd.codePointWidth(0x000B)); // \v VT
+    try testing.expectEqual(@as(i4, 0), wd.codePointWidth(0x000C)); // \f FF
+    try testing.expectEqual(@as(i4, 0), wd.codePointWidth(0x000D)); // \r CR
+    try testing.expectEqual(@as(i4, 0), wd.codePointWidth(0x000E)); // SQ
+    try testing.expectEqual(@as(i4, 0), wd.codePointWidth(0x000F)); // SI
+
+    try testing.expectEqual(@as(i4, 0), wd.codePointWidth(0x070F)); // Cf
+    try testing.expectEqual(@as(i4, 1), wd.codePointWidth(0x0603)); // Cf Arabic
+
+    try testing.expectEqual(@as(i4, 1), wd.codePointWidth(0x00AD)); // soft-hyphen
+    try testing.expectEqual(@as(i4, 2), wd.codePointWidth(0x2E3A)); // two-em dash
+    try testing.expectEqual(@as(i4, 3), wd.codePointWidth(0x2E3B)); // three-em dash
+
+    try testing.expectEqual(@as(i4, 1), wd.codePointWidth(0x00BD)); // ambiguous halfwidth
+
+    try testing.expectEqual(@as(i4, 1), wd.codePointWidth('é'));
+    try testing.expectEqual(@as(i4, 2), wd.codePointWidth('😊'));
+    try testing.expectEqual(@as(i4, 2), wd.codePointWidth('统'));
 }
diff --git a/src/grapheme.zig b/src/grapheme.zig
index a802df8..25fd71d 100644
--- a/src/grapheme.zig
+++ b/src/grapheme.zig
@@ -307,7 +307,7 @@ test "Segmentation ZWJ and ZWSP emoji sequences" {
     const no_joiner = seq_1 ++ seq_2;
 
     const data = try GraphemeData.init(std.testing.allocator);
-    defer data.deinit();
+    defer data.deinit(std.testing.allocator);
 
     {
         var iter = Iterator.init(with_zwj, &data);