src/deserialise.zig

@@ -36,7 +36,7 @@ fn deserialise_float(bytes: []const u8) DeserialiseError!ObjectLen {
 
             const f: f32 = @bitCast(std.mem.readInt(u32, payload[0..4], .big));
 
-            return .{ .bytes_read = 5, .obj = .{ .float32 = f } };
+            return .{ .bytes_read = 5, .obj = .{ .float = f } };
         },
         0b1 => { // float 64
             if (payload.len != 8) {
@@ -45,7 +45,7 @@ fn deserialise_float(bytes: []const u8) DeserialiseError!ObjectLen {
 
             const f: f64 = @bitCast(std.mem.readInt(u64, payload[0..8], .big));
 
-            return .{ .bytes_read = 9, .obj = .{ .float64 = f } };
+            return .{ .bytes_read = 9, .obj = .{ .float = f } };
         },
     }
 }
@@ -154,7 +154,7 @@ fn deserialise_int(bytes: []const u8) DeserialiseError!ObjectLen {
     }
 }
 
-fn deserialise_raw(alloc: std.mem.Allocator, bytes: []const u8, len: usize, comptime kind: enum { string, binary }) DeserialiseError!Object {
+fn deserialise_raw(alloc: std.mem.Allocator, bytes: []const u8, len: usize, comptime kind: enum { str, binary }) DeserialiseError!Object {
     std.debug.assert(bytes.len == len);
 
     if (!utils.validateUtf8(bytes)) {
@@ -164,8 +164,8 @@ fn deserialise_raw(alloc: std.mem.Allocator, bytes: []const u8, len: usize, comp
     const s = try alloc.dupe(u8, bytes);
 
     const obj = switch (kind) {
-        .string => Object{ .string = s },
+        .str => Object{ .raw = .{ .string = s } },
-        .binary => Object{ .binary = s },
+        .binary => Object{ .raw = .{ .binary = s } },
     };
 
     return obj;
@@ -280,7 +280,7 @@ pub fn deserialise_with_length(alloc: std.mem.Allocator, bytes: []const u8) Dese
                 return error.BadLength;
             }
 
-            const obj = try deserialise_raw(alloc, payload[0..len], len, .string);
+            const obj = try deserialise_raw(alloc, payload[0..len], len, .str);
 
             return .{ .bytes_read = 1 + len, .obj = obj };
         }
@@ -468,7 +468,7 @@ pub fn deserialise_with_length(alloc: std.mem.Allocator, bytes: []const u8) Dese
 
             const len: usize = payload[0];
 
-            const obj = try deserialise_raw(alloc, payload[1..], len, .string);
+            const obj = try deserialise_raw(alloc, payload[1..], len, .str);
 
             return .{ .bytes_read = 1 + 1 + len, .obj = obj };
         },
@@ -479,7 +479,7 @@ pub fn deserialise_with_length(alloc: std.mem.Allocator, bytes: []const u8) Dese
 
             const len: usize = std.mem.readInt(u16, payload[0..2], .big);
 
-            const obj = try deserialise_raw(alloc, payload[2..], len, .string);
+            const obj = try deserialise_raw(alloc, payload[2..], len, .str);
 
             return .{ .bytes_read = 1 + 2 + len, .obj = obj };
         },
@@ -490,7 +490,7 @@ pub fn deserialise_with_length(alloc: std.mem.Allocator, bytes: []const u8) Dese
 
             const len: usize = std.mem.readInt(u32, payload[0..4], .big);
 
-            const obj = try deserialise_raw(alloc, payload[4..], len, .string);
+            const obj = try deserialise_raw(alloc, payload[4..], len, .str);
 
             return .{ .bytes_read = 1 + 4 + len, .obj = obj };
         },

src/root.zig

@@ -1,19 +1,18 @@
 const std = @import("std");
 
-pub const deserialise = @import("deserialise.zig").deserialise;
+pub const deserialise = @import("deserialise.zig");
-pub const serialise = @import("serialise.zig").serialise;
 
-// pub const Raw = union(enum) {
+pub const Raw = union(enum) {
-//     string: []u8,
+    string: []u8,
-//     binary: []u8,
+    binary: []u8,
 
-//     pub fn deinit(self: Raw, alloc: std.mem.Allocator) void {
+    pub fn deinit(self: Raw, alloc: std.mem.Allocator) void {
-//         switch (self) {
+        switch (self) {
-//             .string => |s| alloc.free(s),
+            .string => |s| alloc.free(s),
-//             .binary => |b| alloc.free(b),
+            .binary => |b| alloc.free(b),
-//         }
+        }
-//     }
+    }
-// };
+};
 
 pub const MapEntry = struct {
     key: Object,
@@ -30,18 +29,15 @@ pub const Object = union(enum) {
     bool: bool,
     integer: i64,
     uinteger: u64,
-    float32: f32,
+    float: f64,
-    float64: f64,
+    raw: Raw,
-    string: []const u8,
+    array: []Object,
-    binary: []const u8,
+    map: []MapEntry,
-    array: []const Object,
-    map: []const MapEntry,
     extension: struct { type: u8, bytes: []u8 },
 
     pub fn deinit(self: Object, alloc: std.mem.Allocator) void {
         switch (self) {
-            .string => |s| alloc.free(s),
+            .raw => |raw| raw.deinit(alloc),
-            .binary => |b| alloc.free(b),
             .array => |array| {
                 for (array) |x| {
                     x.deinit(alloc);
@@ -63,40 +59,12 @@ pub const Object = union(enum) {
     }
 };
 
-pub const Tag = enum(u8) {
-    nil = 0xc0,
-    false = 0xc2,
-    tru = 0xc3,
-    bin8 = 0xc4,
-    bin16 = 0xc5,
-    bin32 = 0xc6,
-    ext8 = 0xc7,
-    ext16 = 0xc8,
-    ext32 = 0xc9,
-    float32 = 0xca,
-    float64 = 0xcb,
-    uint8 = 0xcc,
-    uint16 = 0xcd,
-    uint32 = 0xce,
-    uint64 = 0xcf,
-    int8 = 0xd0,
-    int16 = 0xd1,
-    int32 = 0xd2,
-    int64 = 0xd3,
-    fixext1 = 0xd4,
-    fixext2 = 0xd5,
-    fixext4 = 0xd6,
-    fixext8 = 0xd7,
-    fixext16 = 0xd8,
-    str8 = 0xd9,
-    str16 = 0xda,
-    str32 = 0xdb,
-    array16 = 0xdc,
-    array32 = 0xdd,
-    map16 = 0xde,
-    map32 = 0xdf,
-};
-
 test {
     std.testing.refAllDecls(@This());
 }
+
+test {
+    const o: Object = .nil;
+
+    _ = o;
+}

src/serialise.zig

@@ -1,219 +0,0 @@
-const std = @import("std");
-
-const Object = @import("root.zig").Object;
-
-const MapEntry = @import("root.zig").MapEntry;
-
-const SerialiseError = error{
-    OutOfMemory,
-    StringTooLong,
-    BinaryTooLong,
-    ArrayTooLong,
-    MapTooLong,
-    ExtTooLong,
-};
-
-fn intInRange(comptime T: type, i: i64) bool {
-    return std.math.minInt(T) <= i and i <= std.math.maxInt(T);
-}
-
-fn serialise_int(alloc: std.mem.Allocator, buf: *std.ArrayListUnmanaged(u8), i: i64) SerialiseError!void {
-    if (i < 0 and i >= std.math.minInt(i6)) { // neg fixint
-        std.mem.writeInt(i8, try buf.addManyAsArray(alloc, 1), @intCast(i), .big);
-
-        return;
-    }
-
-    inline for (0.., &[_]type{ i8, i16, i32, i64 }) |n, T| {
-        if (intInRange(T, i)) {
-            try buf.ensureUnusedCapacity(alloc, 1 + @sizeOf(T));
-
-            try buf.append(alloc, 0xd0 + n);
-
-            std.mem.writeInt(T, try buf.addManyAsArray(alloc, @sizeOf(T)), @intCast(i), .big);
-
-            return;
-        }
-    }
-
-    unreachable;
-}
-
-fn uintInRange(comptime T: type, u: u64) bool {
-    return u <= std.math.maxInt(T);
-}
-
-fn serialise_uint(alloc: std.mem.Allocator, buf: *std.ArrayListUnmanaged(u8), u: u64) SerialiseError!void {
-    if (uintInRange(u7, u)) { // pos fixint
-        std.mem.writeInt(u8, try buf.addManyAsArray(alloc, 1), @intCast(u), .big);
-
-        return;
-    }
-
-    inline for (0.., &[_]type{ u8, u16, u32, u64 }) |n, T| {
-        if (uintInRange(T, u)) {
-            try buf.ensureUnusedCapacity(alloc, 1 + @sizeOf(T));
-
-            try buf.append(alloc, 0xcc + n);
-
-            std.mem.writeInt(T, try buf.addManyAsArray(alloc, @sizeOf(T)), @intCast(u), .big);
-
-            return;
-        }
-    }
-
-    unreachable;
-}
-
-fn serialise_raw(alloc: std.mem.Allocator, buf: *std.ArrayListUnmanaged(u8), s: []const u8, comptime kind: enum { string, binary }) SerialiseError!void {
-    // TODO: should we validate that `s` is UTF-8 here?
-
-    if (kind == .string and s.len <= 31) { // fixstr
-        try buf.ensureUnusedCapacity(alloc, 1 + s.len);
-
-        try buf.append(alloc, 0b101_00000 | @as(u8, @intCast(s.len)));
-
-        try buf.appendSlice(alloc, s);
-
-        return;
-    }
-
-    inline for (0.., &[_]type{ u8, u16, u32 }) |i, T| {
-        if (s.len <= std.math.maxInt(T)) {
-            try buf.ensureUnusedCapacity(alloc, 1 + @sizeOf(T) + s.len);
-
-            switch (kind) {
-                .string => try buf.append(alloc, 0xd9 + i),
-                .binary => try buf.append(alloc, 0xc4 + i),
-            }
-
-            std.mem.writeInt(T, try buf.addManyAsArray(alloc, @sizeOf(T)), @intCast(s.len), .big);
-
-            try buf.appendSlice(alloc, s);
-
-            return;
-        }
-    }
-
-    return switch (kind) {
-        .string => error.StringTooLong,
-        .binary => error.BinaryTooLong,
-    };
-}
-
-fn serialise_array(alloc: std.mem.Allocator, buf: *std.ArrayListUnmanaged(u8), array: []const Object) SerialiseError!void {
-    if (array.len <= 15) {
-        try buf.append(alloc, 0b1001_0000 | @as(u8, @intCast(array.len)));
-    } else if (array.len <= std.math.maxInt(u16)) {
-        try buf.append(alloc, 0xdc);
-
-        std.mem.writeInt(u16, try buf.addManyAsArray(alloc, @sizeOf(u16)), @intCast(array.len), .big);
-    } else if (array.len <= std.math.maxInt(u32)) {
-        try buf.append(alloc, 0xdd);
-
-        std.mem.writeInt(u32, try buf.addManyAsArray(alloc, @sizeOf(u32)), @intCast(array.len), .big);
-    } else {
-        return error.ArrayTooLong;
-    }
-
-    for (array) |obj| {
-        try serialise_into_buf(alloc, buf, obj);
-    }
-}
-
-fn serialise_map(alloc: std.mem.Allocator, buf: *std.ArrayListUnmanaged(u8), map: []const MapEntry) SerialiseError!void {
-    if (map.len <= 15) {
-        try buf.append(alloc, 0b1000_0000 | @as(u8, @intCast(map.len)));
-    } else if (map.len <= std.math.maxInt(u16)) {
-        try buf.append(alloc, 0xde);
-
-        std.mem.writeInt(u16, try buf.addManyAsArray(alloc, @sizeOf(u16)), @intCast(map.len), .big);
-    } else if (map.len <= std.math.maxInt(u32)) {
-        try buf.append(alloc, 0xdf);
-
-        std.mem.writeInt(u32, try buf.addManyAsArray(alloc, @sizeOf(u32)), @intCast(map.len), .big);
-    } else {
-        return error.MapTooLong;
-    }
-
-    for (map) |entry| {
-        try serialise_into_buf(alloc, buf, entry.key);
-        try serialise_into_buf(alloc, buf, entry.value);
-    }
-}
-
-fn serialise_ext(alloc: std.mem.Allocator, buf: *std.ArrayListUnmanaged(u8), type_: u8, bytes: []u8) SerialiseError!void {
-    // fixext
-    for (0.., [_]usize{ 1, 2, 4, 8, 16 }) |n, len| {
-        if (bytes.len == len) {
-            try buf.ensureUnusedCapacity(alloc, 1 + 1 + len);
-
-            try buf.append(alloc, 0xd4 + @as(u8, @intCast(n)));
-            try buf.append(alloc, type_);
-
-            try buf.appendSlice(alloc, bytes);
-
-            return;
-        }
-    }
-
-    // ext
-    inline for (0.., [_]type{ u8, u16, u32 }) |n, T| {
-        if (bytes.len <= std.math.maxInt(T)) {
-            try buf.ensureUnusedCapacity(alloc, 1 + @sizeOf(T) + bytes.len);
-
-            try buf.append(alloc, 0xc7 + n);
-
-            std.mem.writeInt(T, try buf.addManyAsArray(alloc, @sizeOf(T)), @intCast(bytes.len), .big);
-
-            try buf.append(alloc, type_);
-
-            try buf.appendSlice(alloc, bytes);
-
-            return;
-        }
-    }
-
-    return error.ExtTooLong;
-}
-
-fn serialise_into_buf(alloc: std.mem.Allocator, buf: *std.ArrayListUnmanaged(u8), obj: Object) SerialiseError!void {
-    switch (obj) {
-        .nil => try buf.append(alloc, 0xc0),
-        .bool => |b| if (b) {
-            try buf.append(alloc, 0xc3);
-        } else {
-            try buf.append(alloc, 0xc2);
-        },
-        .integer => |i| try serialise_int(alloc, buf, i),
-        .uinteger => |u| try serialise_uint(alloc, buf, u),
-        .float32 => |f| {
-            try buf.ensureUnusedCapacity(alloc, 1 + 4);
-
-            try buf.append(alloc, 0xca);
-
-            std.mem.writeInt(u32, try buf.addManyAsArray(alloc, 4), @bitCast(f), .big);
-        },
-        .float64 => |f| {
-            try buf.ensureUnusedCapacity(alloc, 1 + 8);
-
-            try buf.append(alloc, 0xcb);
-
-            std.mem.writeInt(u64, try buf.addManyAsArray(alloc, 8), @bitCast(f), .big);
-        },
-        .string => |s| try serialise_raw(alloc, buf, s, .string),
-        .binary => |b| try serialise_raw(alloc, buf, b, .binary),
-        .array => |array| try serialise_array(alloc, buf, array),
-        .map => |map| try serialise_map(alloc, buf, map),
-        .extension => |ext| try serialise_ext(alloc, buf, ext.type, ext.bytes),
-    }
-}
-
-pub fn serialise(alloc: std.mem.Allocator, obj: Object) SerialiseError![]u8 {
-    var buf = std.ArrayListUnmanaged(u8){};
-    defer buf.deinit(alloc);
-
-    try serialise_into_buf(alloc, &buf, obj);
-
-    return try buf.toOwnedSlice(alloc);
-}

tests/deserialise/binary.zig

@@ -2,7 +2,7 @@ const std = @import("std");
 
 const msgpack = @import("msgpack");
 
-const deserialise = msgpack.deserialise;
+const deserialise = msgpack.deserialise.deserialise;
 
 fn test_binary(bytes: []const u8, expected: []const u8) !void {
     const alloc = std.testing.allocator;
@@ -10,22 +10,22 @@ fn test_binary(bytes: []const u8, expected: []const u8) !void {
     const obj = try deserialise(alloc, bytes);
     defer obj.deinit(alloc);
 
-    try std.testing.expectEqualStrings(expected, obj.binary);
+    try std.testing.expectEqualStrings(expected, obj.raw.binary);
 }
 
-test "fixbin" {
+test "binary 1" {
     const bytes = [_]u8{ 0xc4, 0x03, 'A', 'B', 'C' };
 
     try test_binary(&bytes, "ABC");
 }
 
-test "empty bin" {
+test "binary 2" {
     const bytes = [_]u8{ 0xc4, 0x00 };
 
     try test_binary(&bytes, "");
 }
 
-test "bin8" {
+test "binary 3" {
     var bytes: [2 + 255]u8 = undefined;
 
     bytes[0] = 0xc4;
@@ -38,7 +38,7 @@ test "bin8" {
     try test_binary(&bytes, "A" ** 255);
 }
 
-test "bin16 1" {
+test "binary 4" {
     var bytes: [3 + 256]u8 = undefined;
 
     bytes[0] = 0xc5;
@@ -52,7 +52,7 @@ test "bin16 1" {
     try test_binary(&bytes, "A" ** 256);
 }
 
-test "bin16 2" {
+test "binary 5" {
     var bytes: [3 + 65535]u8 = undefined;
 
     bytes[0] = 0xc5;
@@ -66,7 +66,7 @@ test "bin16 2" {
     try test_binary(&bytes, "A" ** 65535);
 }
 
-test "bin32" {
+test "binary 6" {
     var bytes: [5 + 65536]u8 = undefined;
 
     bytes[0] = 0xc6;

tests/deserialise/int.zig

@@ -2,7 +2,7 @@ const std = @import("std");
 
 pub const msgpack = @import("msgpack");
 
-const deserialise = msgpack.deserialise;
+const deserialise = msgpack.deserialise.deserialise;
 
 fn test_int(bytes: []const u8, expected: i64) !void {
     const alloc = std.testing.allocator;

tests/deserialise/root.zig

@@ -1,13 +1,13 @@
 const std = @import("std");
 
-pub const msgpack = @import("msgpack");
-
 pub const binary = @import("binary.zig");
 pub const string = @import("string.zig");
 pub const int = @import("int.zig");
 pub const uint = @import("uint.zig");
 
-const deserialise = msgpack.deserialise;
+pub const msgpack = @import("msgpack");
+
+const deserialise = msgpack.deserialise.deserialise;
 
 test {
     @import("std").testing.refAllDecls(@This());
@@ -39,64 +39,3 @@ test "bool" {
         try std.testing.expectEqualDeep(msgpack.Object{ .bool = true }, obj);
     }
 }
-
-test "f32" {
-    const alloc = std.testing.allocator;
-
-    {
-        const obj = try deserialise(alloc, &[_]u8{ 0xca, 0x7f, 0x7f, 0xff, 0xff });
-        defer obj.deinit(alloc);
-
-        // try std.testing.expectEqualDeep(msgpack.Object{ .float = 3.4028234e38 }, obj);
-        try std.testing.expectEqual(3.4028234e38, obj.float32);
-    }
-}
-
-test "f64" {
-    const alloc = std.testing.allocator;
-
-    {
-        const obj = try deserialise(alloc, &[_]u8{ 0xcb, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 });
-        defer obj.deinit(alloc);
-
-        try std.testing.expectEqualDeep(msgpack.Object{ .float64 = 0.0 }, obj);
-    }
-
-    {
-        const obj = try deserialise(alloc, &[_]u8{ 0xcb, 0x40, 0x45, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 });
-        defer obj.deinit(alloc);
-
-        try std.testing.expectEqualDeep(msgpack.Object{ .float64 = 42.0 }, obj);
-    }
-}
-
-test "array" {
-    const alloc = std.testing.allocator;
-
-    {
-        const obj = try deserialise(alloc, &[_]u8{ 0x92, 0xa2, 0x6c, 0x65, 0xa4, 0x73, 0x68, 0x69, 0x74 });
-        defer obj.deinit(alloc);
-
-        try std.testing.expectEqual(2, obj.array.len);
-
-        try std.testing.expectEqualStrings("le", obj.array[0].string);
-        try std.testing.expectEqualStrings("shit", obj.array[1].string);
-    }
-}
-
-test "map" {
-    const alloc = std.testing.allocator;
-
-    {
-        const obj = try deserialise(alloc, &[_]u8{ 0x82, 0x00, 0xa2, 0x6c, 0x65, 0x01, 0xa4, 0x73, 0x68, 0x69, 0x74 });
-        defer obj.deinit(alloc);
-
-        try std.testing.expectEqual(2, obj.map.len);
-
-        try std.testing.expectEqual(0, obj.map[0].key.uinteger);
-        try std.testing.expectEqualStrings("le", obj.map[0].value.string);
-
-        try std.testing.expectEqual(1, obj.map[1].key.uinteger);
-        try std.testing.expectEqualStrings("shit", obj.map[1].value.string);
-    }
-}

tests/deserialise/string.zig

@@ -2,7 +2,7 @@ const std = @import("std");
 
 const msgpack = @import("msgpack");
 
-const deserialise = msgpack.deserialise;
+const deserialise = msgpack.deserialise.deserialise;
 
 fn test_string(bytes: []const u8, expected: []const u8) !void {
     const alloc = std.testing.allocator;
@@ -10,26 +10,26 @@ fn test_string(bytes: []const u8, expected: []const u8) !void {
     const obj = try deserialise(alloc, bytes);
     defer obj.deinit(alloc);
 
-    try std.testing.expectEqualStrings(expected, obj.string);
+    try std.testing.expectEqualStrings(expected, obj.raw.string);
 }
 
-test "fixstr 1" {
+test "string 1" {
     const bytes = [_]u8{ 0b101_00000 | 0x03, 'A', 'B', 'C' };
 
     try test_string(&bytes, "ABC");
 }
 
-test "str8 1" {
+test "string 2" {
     const bytes = [_]u8{ 0xd9, 0x03, 'A', 'B', 'C' };
 
     try test_string(&bytes, "ABC");
 }
-test "empty string" {
+test "string 3" {
     const bytes = [_]u8{ 0xd9, 0x00 };
 
     try test_string(&bytes, "");
 }
-test "str8 2" {
+test "string 4" {
     var bytes: [2 + 255]u8 = undefined;
 
     bytes[0] = 0xd9;
@@ -41,7 +41,7 @@ test "str8 2" {
 
     try test_string(&bytes, "A" ** 255);
 }
-test "str16 1" {
+test "string 5" {
     var bytes: [3 + 256]u8 = undefined;
 
     bytes[0] = 0xda;
@@ -54,7 +54,7 @@ test "str16 1" {
 
     try test_string(&bytes, "A" ** 256);
 }
-test "str16 2" {
+test "string 6" {
     var bytes: [3 + 65535]u8 = undefined;
 
     bytes[0] = 0xda;
@@ -67,7 +67,7 @@ test "str16 2" {
 
     try test_string(&bytes, "A" ** 65535);
 }
-test "str32 1" {
+test "string 7" {
     var bytes: [5 + 65536]u8 = undefined;
 
     bytes[0] = 0xdb;
@@ -82,6 +82,3 @@ test "str32 1" {
 
     try test_string(&bytes, "A" ** 65536);
 }
-test "fixstr 2" {
-    try test_string(&[_]u8{ 0xaa, 0x6c, 0x65, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65 }, "le message");
-}

tests/deserialise/uint.zig

@@ -2,7 +2,7 @@ const std = @import("std");
 
 pub const msgpack = @import("msgpack");
 
-const deserialise = msgpack.deserialise;
+const deserialise = msgpack.deserialise.deserialise;
 
 fn test_uint(bytes: []const u8, expected: u64) !void {
     const alloc = std.testing.allocator;

tests/root.zig

@@ -1,5 +1,4 @@
 pub const deserialise = @import("deserialise/root.zig");
-pub const serialise = @import("serialise/root.zig");
 
 test {
     @import("std").testing.refAllDecls(@This());

tests/serialise/binary.zig

@@ -1,82 +0,0 @@
-test "fixbin" {
-    const bytes = [_]u8{ 0xc4, 0x03, 'A', 'B', 'C' };
-
-    try test_binary(&bytes, "ABC");
-}
-
-test "empty bin" {
-    const bytes = [_]u8{ 0xc4, 0x00 };
-
-    try test_binary(&bytes, "");
-}
-
-test "bin8" {
-    var bytes: [2 + 255]u8 = undefined;
-
-    bytes[0] = 0xc4;
-    bytes[1] = 0xff;
-
-    for (bytes[2..]) |*c| {
-        c.* = 'A';
-    }
-
-    try test_binary(&bytes, "A" ** 255);
-}
-const std = @import("std");
-
-const msgpack = @import("msgpack");
-
-const serialise = msgpack.serialise;
-
-fn test_binary(expected: []const u8, s: []const u8) !void {
-    const alloc = std.testing.allocator;
-
-    const bytes = try serialise(alloc, .{ .binary = s });
-    defer alloc.free(bytes);
-
-    try std.testing.expectEqualSlices(u8, expected, bytes);
-}
-
-test "bin16 1" {
-    var bytes: [3 + 256]u8 = undefined;
-
-    bytes[0] = 0xc5;
-    bytes[1] = 0x01;
-    bytes[2] = 0x00;
-
-    for (bytes[3..]) |*c| {
-        c.* = 'A';
-    }
-
-    try test_binary(&bytes, "A" ** 256);
-}
-
-test "bin16 2" {
-    var bytes: [3 + 65535]u8 = undefined;
-
-    bytes[0] = 0xc5;
-    bytes[1] = 0xff;
-    bytes[2] = 0xff;
-
-    for (bytes[3..]) |*c| {
-        c.* = 'A';
-    }
-
-    try test_binary(&bytes, "A" ** 65535);
-}
-
-test "bin32" {
-    var bytes: [5 + 65536]u8 = undefined;
-
-    bytes[0] = 0xc6;
-    bytes[1] = 0x00;
-    bytes[2] = 0x01;
-    bytes[3] = 0x00;
-    bytes[4] = 0x00;
-
-    for (bytes[5..]) |*c| {
-        c.* = 'A';
-    }
-
-    try test_binary(&bytes, "A" ** 65536);
-}

tests/serialise/int.zig

@@ -1,43 +0,0 @@
-const std = @import("std");
-
-const msgpack = @import("msgpack");
-
-const Object = msgpack.Object;
-const serialise = msgpack.serialise;
-
-fn test_int(expected: []const u8, i: i64) !void {
-    const alloc = std.testing.allocator;
-
-    const bytes = try serialise(alloc, .{ .integer = i });
-    defer alloc.free(bytes);
-
-    try std.testing.expectEqualSlices(u8, expected, bytes);
-}
-
-test "neg fixint" {
-    try test_int(&[_]u8{0xFF}, -1);
-}
-
-test "int i8" {
-    try test_int(&[_]u8{ 0xd0, 0x80 }, std.math.minInt(i8));
-
-    try test_int(&[_]u8{ 0xd0, 0x7F }, std.math.maxInt(i8));
-}
-
-test "int i16" {
-    try test_int(&[_]u8{ 0xd1, 0x80, 0x00 }, std.math.minInt(i16));
-
-    try test_int(&[_]u8{ 0xd1, 0x7f, 0xff }, std.math.maxInt(i16));
-}
-
-test "int i32" {
-    try test_int(&[_]u8{ 0xd2, 0x80, 0x00, 0x00, 0x00 }, std.math.minInt(i32));
-
-    try test_int(&[_]u8{ 0xd2, 0x7f, 0xff, 0xff, 0xff }, std.math.maxInt(i32));
-}
-
-test "int i64" {
-    try test_int(&[_]u8{ 0xd3, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, std.math.minInt(i64));
-
-    try test_int(&[_]u8{ 0xd3, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }, std.math.maxInt(i64));
-}

tests/serialise/root.zig

@@ -1,118 +0,0 @@
-const std = @import("std");
-
-pub const msgpack = @import("msgpack");
-
-pub const binary = @import("binary.zig");
-pub const string = @import("string.zig");
-pub const int = @import("int.zig");
-pub const uint = @import("uint.zig");
-
-test {
-    @import("std").testing.refAllDecls(@This());
-}
-
-const Object = msgpack.Object;
-const serialise = msgpack.serialise;
-
-test "nil" {
-    const alloc = std.testing.allocator;
-
-    const obj: Object = .nil;
-    defer obj.deinit(alloc);
-
-    const bytes = try serialise(alloc, obj);
-    defer alloc.free(bytes);
-
-    try std.testing.expectEqualSlices(u8, &[_]u8{0xc0}, bytes);
-}
-
-test "bool" {
-    const alloc = std.testing.allocator;
-
-    {
-        const obj = Object{ .bool = false };
-        defer obj.deinit(alloc);
-
-        const bytes = try serialise(alloc, obj);
-        defer alloc.free(bytes);
-
-        try std.testing.expectEqualSlices(u8, &[_]u8{0xc2}, bytes);
-    }
-
-    {
-        const obj = Object{ .bool = true };
-        defer obj.deinit(alloc);
-
-        const bytes = try serialise(alloc, obj);
-        defer alloc.free(bytes);
-
-        try std.testing.expectEqualSlices(u8, &[_]u8{0xc3}, bytes);
-    }
-}
-
-test "f32" {
-    const alloc = std.testing.allocator;
-
-    {
-        const bytes = try serialise(alloc, .{ .float32 = 3.4028234e38 });
-        defer alloc.free(bytes);
-
-        // try std.testing.expectEqual(3.4028234e38, obj.float32);
-        try std.testing.expectEqualSlices(u8, &[_]u8{ 0xca, 0x7f, 0x7f, 0xff, 0xff }, bytes);
-    }
-}
-
-test "f64" {
-    const alloc = std.testing.allocator;
-
-    {
-        const bytes = try serialise(alloc, .{ .float64 = 0.0 });
-        defer alloc.free(bytes);
-
-        // try std.testing.expectEqual(3.4028234e38, obj.float32);
-        try std.testing.expectEqualSlices(u8, &[_]u8{ 0xcb, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, bytes);
-    }
-
-    {
-        const bytes = try serialise(alloc, .{ .float64 = 42.0 });
-        defer alloc.free(bytes);
-
-        // try std.testing.expectEqual(3.4028234e38, obj.float32);
-        try std.testing.expectEqualSlices(u8, &[_]u8{ 0xcb, 0x40, 0x45, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, bytes);
-    }
-}
-
-test "array" {
-    const alloc = std.testing.allocator;
-
-    {
-        // const obj = try deserialise(alloc, &[_]u8{ 0x92, 0xa2, 0x6c, 0x65, 0xa4, 0x73, 0x68, 0x69, 0x74 });
-        // defer obj.deinit(alloc);
-
-        // try std.testing.expectEqual(2, obj.array.len);
-
-        // try std.testing.expectEqualStrings("le", obj.array[0].string);
-        // try std.testing.expectEqualStrings("shit", obj.array[1].string);
-
-        const bytes = try serialise(alloc, .{ .array = &[_]Object{ .{ .string = "le" }, .{ .string = "shit" } } });
-        defer alloc.free(bytes);
-
-        try std.testing.expectEqualSlices(u8, &[_]u8{ 0x92, 0xa2, 0x6c, 0x65, 0xa4, 0x73, 0x68, 0x69, 0x74 }, bytes);
-    }
-}
-
-test "map" {
-    const alloc = std.testing.allocator;
-
-    const MapEntry = msgpack.MapEntry;
-
-    {
-        const bytes = try serialise(alloc, .{ .map = &[_]MapEntry{
-            .{ .key = .{ .uinteger = 0 }, .value = .{ .string = "le" } },
-            .{ .key = .{ .uinteger = 1 }, .value = .{ .string = "shit" } },
-        } });
-        defer alloc.free(bytes);
-
-        try std.testing.expectEqualSlices(u8, &[_]u8{ 0x82, 0x00, 0xa2, 0x6c, 0x65, 0x01, 0xa4, 0x73, 0x68, 0x69, 0x74 }, bytes);
-    }
-}

tests/serialise/string.zig

@@ -1,84 +0,0 @@
-const std = @import("std");
-
-const msgpack = @import("msgpack");
-
-const serialise = msgpack.serialise;
-
-fn test_string(expected: []const u8, s: []const u8) !void {
-    const alloc = std.testing.allocator;
-
-    const bytes = try serialise(alloc, .{ .string = s });
-    defer alloc.free(bytes);
-
-    try std.testing.expectEqualSlices(u8, expected, bytes);
-}
-
-test "fixstr" {
-    const bytes = [_]u8{ 0b101_00000 | 0x03, 'A', 'B', 'C' };
-
-    try test_string(&bytes, "ABC");
-}
-
-test "empty str" {
-    const bytes = [_]u8{0b101_00000};
-
-    try test_string(&bytes, "");
-}
-
-test "string 4" {
-    var bytes: [2 + 255]u8 = undefined;
-
-    bytes[0] = 0xd9;
-    bytes[1] = 0xff;
-
-    for (bytes[2..]) |*c| {
-        c.* = 'A';
-    }
-
-    try test_string(&bytes, "A" ** 255);
-}
-
-// test "string 5" {
-//     var bytes: [3 + 256]u8 = undefined;
-
-//     bytes[0] = 0xda;
-//     bytes[1] = 0x01;
-//     bytes[2] = 0x00;
-
-//     for (bytes[3..]) |*c| {
-//         c.* = 'A';
-//     }
-
-//     try test_string(&bytes, "A" ** 256);
-// }
-// test "string 6" {
-//     var bytes: [3 + 65535]u8 = undefined;
-
-//     bytes[0] = 0xda;
-//     bytes[1] = 0xff;
-//     bytes[2] = 0xff;
-
-//     for (bytes[3..]) |*c| {
-//         c.* = 'A';
-//     }
-
-//     try test_string(&bytes, "A" ** 65535);
-// }
-// test "string 7" {
-//     var bytes: [5 + 65536]u8 = undefined;
-
-//     bytes[0] = 0xdb;
-//     bytes[1] = 0x00;
-//     bytes[2] = 0x01;
-//     bytes[3] = 0x00;
-//     bytes[4] = 0x00;
-
-//     for (bytes[5..]) |*c| {
-//         c.* = 'A';
-//     }
-
-//     try test_string(&bytes, "A" ** 65536);
-// }
-// test "string 8" {
-//     try test_string(&[_]u8{ 0xaa, 0x6c, 0x65, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65 }, "le message");
-// }

tests/serialise/uint.zig

@@ -1,39 +0,0 @@
-const std = @import("std");
-
-const msgpack = @import("msgpack");
-
-const Object = msgpack.Object;
-const serialise = msgpack.serialise;
-
-fn test_uint(expected: []const u8, u: u64) !void {
-    const alloc = std.testing.allocator;
-
-    const bytes = try serialise(alloc, .{ .uinteger = u });
-    defer alloc.free(bytes);
-
-    try std.testing.expectEqualSlices(u8, expected, bytes);
-}
-
-test "pos fixint" {
-    try test_uint(&[_]u8{0x00}, 0);
-
-    try test_uint(&[_]u8{0x07}, 0x07);
-
-    try test_uint(&[_]u8{0x7F}, 0x7F);
-}
-
-test "int u8" {
-    try test_uint(&[_]u8{ 0xcc, 0xff }, std.math.maxInt(u8));
-}
-
-test "int u16" {
-    try test_uint(&[_]u8{ 0xcd, 0xff, 0xff }, std.math.maxInt(u16));
-}
-
-test "int u32" {
-    try test_uint(&[_]u8{ 0xce, 0xff, 0xff, 0xff, 0xff }, std.math.maxInt(u32));
-}
-
-test "int u64" {
-    try test_uint(&[_]u8{ 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }, std.math.maxInt(u64));
-}