Add Set-Cookie parsing

src/testing.zig

@@ -0,0 +1,134 @@
+const std = @import("std");
+
+pub const allocator = std.testing.allocator;
+pub const expectError = std.testing.expectError;
+pub const expectString = std.testing.expectEqualStrings;
+
+// Merged std.testing.expectEqual and std.testing.expectString
+// can be useful when testing fields of an anytype an you don't know
+// exactly how to assert equality
+pub fn expectEqual(expected: anytype, actual: anytype) !void {
+    switch (@typeInfo(@TypeOf(actual))) {
+        .Array => |arr| if (arr.child == u8) {
+            return std.testing.expectEqualStrings(expected, &actual);
+        },
+        .Pointer => |ptr| if (ptr.child == u8) {
+            return std.testing.expectEqualStrings(expected, actual);
+        } else if (comptime isStringArray(ptr.child)) {
+            return std.testing.expectEqualStrings(expected, actual);
+        } else if (ptr.child == []u8 or ptr.child == []const u8) {
+            return expectString(expected, actual);
+        },
+        .Struct => |structType| {
+            inline for (structType.fields) |field| {
+                try expectEqual(@field(expected, field.name), @field(actual, field.name));
+            }
+            return;
+        },
+        .Optional => {
+            if (actual == null) {
+                return std.testing.expectEqual(null, expected);
+            }
+            return expectEqual(expected, actual.?);
+        },
+        .Union => |union_info| {
+            if (union_info.tag_type == null) {
+                @compileError("Unable to compare untagged union values");
+            }
+            const Tag = std.meta.Tag(@TypeOf(expected));
+
+            const expectedTag = @as(Tag, expected);
+            const actualTag = @as(Tag, actual);
+            try expectEqual(expectedTag, actualTag);
+
+            inline for (std.meta.fields(@TypeOf(actual))) |fld| {
+                if (std.mem.eql(u8, fld.name, @tagName(actualTag))) {
+                    try expectEqual(@field(expected, fld.name), @field(actual, fld.name));
+                    return;
+                }
+            }
+            unreachable;
+        },
+        else => {},
+    }
+    return std.testing.expectEqual(expected, actual);
+}
+
+pub fn expectDelta(expected: anytype, actual: anytype, delta: anytype) !void {
+    if (@typeInfo(@TypeOf(expected)) == .Null) {
+        return std.testing.expectEqual(null, actual);
+    }
+
+    switch (@typeInfo(@TypeOf(actual))) {
+        .Optional => {
+            if (actual) |value| {
+                return expectDelta(expected, value, delta);
+            }
+            return std.testing.expectEqual(null, expected);
+        },
+        else => {},
+    }
+
+    switch (@typeInfo(@TypeOf(expected))) {
+        .Optional => {
+            if (expected) |value| {
+                return expectDelta(value, actual, delta);
+            }
+            return std.testing.expectEqual(null, actual);
+        },
+        else => {},
+    }
+
+    var diff = expected - actual;
+    if (diff < 0) {
+        diff = -diff;
+    }
+    if (diff <= delta) {
+        return;
+    }
+
+    print("Expected {} to be within {} of {}. Actual diff: {}", .{ expected, delta, actual, diff });
+    return error.NotWithinDelta;
+}
+
+fn isStringArray(comptime T: type) bool {
+    if (!is(.array)(T) and !isPtrTo(.array)(T)) {
+        return false;
+    }
+    return std.meta.Elem(T) == u8;
+}
+
+pub const TraitFn = fn (type) bool;
+pub fn is(comptime id: std.builtin.TypeId) TraitFn {
+    const Closure = struct {
+        pub fn trait(comptime T: type) bool {
+            return id == @typeInfo(T);
+        }
+    };
+    return Closure.trait;
+}
+
+pub fn isPtrTo(comptime id: std.builtin.TypeId) TraitFn {
+    const Closure = struct {
+        pub fn trait(comptime T: type) bool {
+            if (!comptime isSingleItemPtr(T)) return false;
+            return id == @typeInfo(std.meta.Child(T));
+        }
+    };
+    return Closure.trait;
+}
+
+pub fn isSingleItemPtr(comptime T: type) bool {
+    if (comptime is(.pointer)(T)) {
+        return @typeInfo(T).Pointer.size == .one;
+    }
+    return false;
+}
+
+pub fn print(comptime fmt: []const u8, args: anytype) void {
+    if (@inComptime()) {
+        @compileError(std.fmt.comptimePrint(fmt, args));
+    } else {
+        std.debug.print(fmt, args);
+    }
+}