refactor(tests): generalize doTest and doTestError

3 files changed, 29 insertions, 24 deletions

diff --git a/src/paragraph.zig b/src/paragraph.zig
index caee73e..a164b1d 100644
--- a/src/paragraph.zig
+++ b/src/paragraph.zig
@@ -4,6 +4,7 @@ const Lexed = @import("lexer/Lexed.zig");
 const Lexer = @import("lexer/Lexer.zig");
 const Element = @import("dom/Element.zig");
 const parser = @import("parser.zig");
+const testing = @import("testing.zig");
 
 pub const Error = error{ ModifierNotClosed, IllegalPlacement } || Lexer.Error;
 
@@ -79,21 +80,11 @@ fn parseModifier(alloc: Allocator, l: *Lexer, knd: Lexed.Kind, tag: []const u8)
 }
 
 fn doTest(alloc: Allocator, t: []const u8, v: []const u8) !void {
-    var l = try Lexer.init(t);
-    var p = try parse(alloc, &l);
-    defer p.deinit();
-    const g = try p.render(alloc);
-    defer alloc.free(g);
-    std.testing.expect(std.mem.eql(u8, g, v)) catch |err| {
-        std.debug.print("{s}\n", .{g});
-        return err;
-    };
+    return testing.do(parse, alloc, t, v);
 }
 
 fn doTestError(alloc: Allocator, t: []const u8, err: Error) !void {
-    var l = try Lexer.init(t);
-    _ = parse(alloc, &l) catch |e| return std.testing.expect(err == e);
-    return std.testing.expect(false);
+    return testing.doError(parse, alloc, t, err);
 }
 
 test "parse paragraphs" {
diff --git a/src/testing.zig b/src/testing.zig
new file mode 100644
index 0000000..ecf6eb3
--- /dev/null
+++ b/src/testing.zig
@@ -0,0 +1,23 @@
+const std = @import("std");
+const Allocator = std.mem.Allocator;
+const Lexer = @import("lexer/Lexer.zig");
+const Element = @import("dom/Element.zig");
+const parser = @import("parser.zig");
+
+pub fn do(comptime parse: fn(Allocator, *Lexer) parser.Error!Element, alloc: Allocator, t: []const u8, v: []const u8) !void {
+    var l = try Lexer.init(t);
+    var p = try parse(alloc, &l);
+    defer p.deinit();
+    const g = try p.render(alloc);
+    defer alloc.free(g);
+    std.testing.expect(std.mem.eql(u8, g, v)) catch |err| {
+        std.debug.print("{s}\n", .{g});
+        return err;
+    };
+}
+
+pub fn doError(comptime parse: fn(Allocator, *Lexer) parser.Error!Element, alloc: Allocator, t: []const u8, err: parser.Error) !void {
+    var l = try Lexer.init(t);
+    _ = parse(alloc, &l) catch |e| return std.testing.expect(err == e);
+    return std.testing.expect(false);
+}
diff --git a/src/title.zig b/src/title.zig
index 62d7929..a29cece 100644
--- a/src/title.zig
+++ b/src/title.zig
@@ -4,6 +4,7 @@ const Lexed = @import("lexer/Lexed.zig");
 const Lexer = @import("lexer/Lexer.zig");
 const Element = @import("dom/Element.zig");
 const paragraph = @import("paragraph.zig");
+const testing = @import("testing.zig");
 
 pub const Error = error{InvalidTitleContent} || paragraph.Error || Lexer.Error;
 
@@ -31,21 +32,11 @@ pub fn parse(alloc: Allocator, l: *Lexer) Error!Element {
 }
 
 fn doTest(alloc: Allocator, t: []const u8, v: []const u8) !void {
-    var l = try Lexer.init(t);
-    var p = try parse(alloc, &l);
-    defer p.deinit();
-    const g = try p.render(alloc);
-    defer alloc.free(g);
-    std.testing.expect(std.mem.eql(u8, g, v)) catch |err| {
-        std.debug.print("{s}\n", .{g});
-        return err;
-    };
+    return testing.do(parse, alloc, t, v);
 }
 
 fn doTestError(alloc: Allocator, t: []const u8, err: Error) !void {
-    var l = try Lexer.init(t);
-    _ = parse(alloc, &l) catch |e| return std.testing.expect(err == e);
-    return std.testing.expect(false);
+    return testing.doError(parse, alloc, t, err);
 }
 
 test "parse title" {