QuasselClient/src/qtshit/test.zig

const std = @import("std");
const expect = std.testing.expect;
const global_allocator = std.testing.allocator;

const read = @import("./read.zig");
const write = @import("./write.zig");
const qvar = @import("./qvariant.zig");

test "read/write int" {
    var byteList = std.ArrayList(u8).init(global_allocator);
    defer byteList.deinit();

    try write.add_int(byteList.writer(), 4242);

    var fBS = std.io.fixedBufferStream(byteList.items);
    var val = try read.get_int(fBS.reader());

    try expect(val == 4242);
}

test "read/write short" {
    var byteList = std.ArrayList(u8).init(global_allocator);
    defer byteList.deinit();

    try write.add_short(byteList.writer(), 6969);

    var fBS = std.io.fixedBufferStream(byteList.items);
    var val = try read.get_short(fBS.reader());

    try expect(val == 6969);
}

test "read/write byte" {
    var byteList = std.ArrayList(u8).init(global_allocator);
    defer byteList.deinit();

    try write.add_byte(byteList.writer(), 'a');

    var fBS = std.io.fixedBufferStream(byteList.items);
    var val = try read.get_byte(fBS.reader());

    try expect(val == 'a');
}

test "read/write string" {
    var byteList = std.ArrayList(u8).init(global_allocator);
    defer byteList.deinit();

    var arr = "Hello World!".*;

    try write.add_string(byteList.writer(), global_allocator, &arr);

    var fBS = std.io.fixedBufferStream(byteList.items);
    var val = try read.get_string(fBS.reader(), global_allocator);
    defer global_allocator.free(val);

    try expect(std.mem.eql(u8, val, "Hello World!"));
}

test "read/write bytearray" {
    var byteList = std.ArrayList(u8).init(global_allocator);
    defer byteList.deinit();

    var arr = std.ArrayList(u8).init(global_allocator);
    defer arr.deinit();
    try arr.append(13);
    try arr.append(12);

    try write.add_bytearray(byteList.writer(), arr);

    var fBS = std.io.fixedBufferStream(byteList.items);
    var val = try read.get_bytearray(fBS.reader(), global_allocator);
    defer val.deinit();

    try expect(arr.items.len == val.items.len);
    for (arr.items) |item, index| {
        try std.testing.expect(item == val.items[index]);
    }
}

test "read/write stringlist" {
    var byteList = std.ArrayList(u8).init(global_allocator);
    defer byteList.deinit();

    var arr = std.ArrayList([]const u8).init(global_allocator);
    defer arr.deinit();
    try arr.append("Hewwo");
    try arr.append("World");

    try write.add_stringlist(byteList.writer(), global_allocator, arr);

    var fBS = std.io.fixedBufferStream(byteList.items);
    var val = try read.get_stringlist(fBS.reader(), global_allocator);
    defer {
        for (val.items) |str| {
            global_allocator.free(str);
        }
        val.deinit();
    }

    try expect(arr.items.len == val.items.len);
    for (arr.items) |str, index| {
        try std.testing.expectEqualStrings(str, val.items[index]);
    }
}

test "read/write byte variant" {
    var byteList = std.ArrayList(u8).init(global_allocator);
    defer byteList.deinit();

    try write.add_qvariant_with_id(byteList.writer(), @enumToInt(qvar.QVariantTypes.byte));
    try write.add_byte(byteList.writer(), 'a');

    var fBS = std.io.fixedBufferStream(byteList.items);
    var val = try read.get_variant(fBS.reader(), global_allocator);

    try expect(val.byte == 'a');
}

test "read/write int variant" {
    var byteList = std.ArrayList(u8).init(global_allocator);
    defer byteList.deinit();

    try write.add_qvariant_with_id(byteList.writer(), @enumToInt(qvar.QVariantTypes.int_2));
    try write.add_int(byteList.writer(), 1312);

    var fBS = std.io.fixedBufferStream(byteList.items);
    var val = try read.get_variant(fBS.reader(), global_allocator);

    try expect(val.int == 1312);
}

test "read/write qvariantmap" {
    var byteList = std.ArrayList(u8).init(global_allocator);
    defer byteList.deinit();

    var map = std.StringHashMap(qvar.QVariant).init(global_allocator);
    defer map.deinit();
    try map.put("testkey", .{ .int = 1337 });
    try write.add_qvariantmap(byteList.writer(), global_allocator, map);

    var fBS = std.io.fixedBufferStream(byteList.items);
    var val = try read.get_variant(fBS.reader(), global_allocator);
    var qmap = val.qmap;

    var testKey = qmap.get("testkey");
    if (testKey) |key| {
        try expect(key.int == 1337);
        var qMapIter = qmap.iterator();
        while (qMapIter.next()) |a| {
            global_allocator.free(a.key);
        }
        qmap.deinit();
    } else {
        try expect(!true);
    }
}