Compare commits
No commits in common. "b2d93a466e3171a7eca2186756b2317f6e776244" and "113f49f6a4a9054ecd07b83600375a0277173664" have entirely different histories.
b2d93a466e
...
113f49f6a4
14 changed files with 53 additions and 735 deletions
|
|
@ -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 },
|
||||
.binary => Object{ .binary = s },
|
||||
.str => Object{ .raw = .{ .string = 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 };
|
||||
},
|
||||
|
|
|
|||
76
src/root.zig
76
src/root.zig
|
|
@ -1,19 +1,18 @@
|
|||
const std = @import("std");
|
||||
|
||||
pub const deserialise = @import("deserialise.zig").deserialise;
|
||||
pub const serialise = @import("serialise.zig").serialise;
|
||||
pub const deserialise = @import("deserialise.zig");
|
||||
|
||||
// pub const Raw = union(enum) {
|
||||
// string: []u8,
|
||||
// binary: []u8,
|
||||
pub const Raw = union(enum) {
|
||||
string: []u8,
|
||||
binary: []u8,
|
||||
|
||||
// pub fn deinit(self: Raw, alloc: std.mem.Allocator) void {
|
||||
// switch (self) {
|
||||
// .string => |s| alloc.free(s),
|
||||
// .binary => |b| alloc.free(b),
|
||||
// }
|
||||
// }
|
||||
// };
|
||||
pub fn deinit(self: Raw, alloc: std.mem.Allocator) void {
|
||||
switch (self) {
|
||||
.string => |s| alloc.free(s),
|
||||
.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,
|
||||
float64: f64,
|
||||
string: []const u8,
|
||||
binary: []const u8,
|
||||
array: []const Object,
|
||||
map: []const MapEntry,
|
||||
float: f64,
|
||||
raw: Raw,
|
||||
array: []Object,
|
||||
map: []MapEntry,
|
||||
extension: struct { type: u8, bytes: []u8 },
|
||||
|
||||
pub fn deinit(self: Object, alloc: std.mem.Allocator) void {
|
||||
switch (self) {
|
||||
.string => |s| alloc.free(s),
|
||||
.binary => |b| alloc.free(b),
|
||||
.raw => |raw| raw.deinit(alloc),
|
||||
.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;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
}
|
||||
|
|
@ -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;
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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");
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
|
|
|
|||
|
|
@ -1,5 +1,4 @@
|
|||
pub const deserialise = @import("deserialise/root.zig");
|
||||
pub const serialise = @import("serialise/root.zig");
|
||||
|
||||
test {
|
||||
@import("std").testing.refAllDecls(@This());
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
}
|
||||
|
|
@ -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));
|
||||
}
|
||||
|
|
@ -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);
|
||||
}
|
||||
}
|
||||
|
|
@ -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");
|
||||
// }
|
||||
|
|
@ -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));
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue