Adds new tests and fixes a few issues

Author: RomarQ

src/decoder.zig

@@ -29,7 +29,18 @@ pub fn decodeAlloc(comptime T: type, allocator: std.mem.Allocator, data: []const
         .optional => |info| decodeOption(info.child, allocator, data, decodeAlloc),
         .pointer => |info| {
             if (info.size == .slice) {
-                return decodeSlice(info.child, allocator, data, decodeAlloc);
+                if (info.child == u8) {
+                    // Handle string slices - decode as []u8 and convert if needed
+                    const result = try decodeSlice(u8, allocator, data, decodeAlloc);
+                    if (T == []const u8) {
+                        // Convert []u8 to []const u8
+                        return .{ .value = result.value, .bytes_read = result.bytes_read };
+                    } else {
+                        return result;
+                    }
+                } else {
+                    return decodeSlice(info.child, allocator, data, decodeAlloc);
+                }
             } else {
                 return error.UnsupportedType;
             }
@@ -97,7 +108,7 @@ pub fn decodeCompact(comptime T: type, data: []const u8) !DecodeResult(T) {
     }
 }
 
-pub fn decodeSlice(comptime T: type, allocator: std.mem.Allocator, data: []const u8, decoder: anytype) !DecodeResult(if (T == u8) []const u8 else []T) {
+pub fn decodeSlice(comptime T: type, allocator: std.mem.Allocator, data: []const u8, decoder: anytype) !DecodeResult(if (T == u8) []u8 else []T) {
     const length = try decodeCompact(u32, data);
     var offset = length.bytes_read;
 

src/encoder.zig

@@ -187,7 +187,7 @@ pub fn encode(value: anytype, buffer: []u8) !usize {
                 const array_info = @typeInfo(info.child).array;
                 // Convert pointer to array into a slice
                 const slice = value[0..array_info.len];
-                return encodeFixedArray(info.child, info.len, slice, buffer, encode);
+                return encodeArray(array_info.child, slice, buffer, encode);
             }
 
             std.debug.print("Unsupported type: {s}\n", .{@typeName(T)});

src/tests.zig

@@ -2,7 +2,46 @@ const std = @import("std");
 const encoder = @import("encoder.zig");
 const decoder = @import("decoder.zig");
 
-test "encode-and-decode-array" {
+test "encode-and-decode-vector-of-strings" {
+    const allocator = std.testing.allocator;
+
+    var strings = [_][]const u8{ "Hello", "World" };
+
+    const test_cases = [_]struct {
+        value: [][]const u8,
+        encoded: []const u8,
+    }{
+        .{
+            .value = strings[0..],
+            .encoded = &[_]u8{
+                0x08, // Compact length (2)
+                0x14, // Compact length (5) for "Hello"
+                0x48, 0x65, 0x6c, 0x6c, 0x6f, // "Hello"
+                0x14, // Compact length (5) for "World"
+                0x57, 0x6f, 0x72, 0x6c, 0x64, // "World"
+            },
+        },
+    };
+
+    for (test_cases) |tc| {
+        // Test encoding
+        const buffer = try encoder.encodeAlloc(allocator, tc.value);
+        defer allocator.free(buffer);
+        try std.testing.expectEqualSlices(u8, tc.encoded, buffer);
+
+        // Test decoding
+        const result = try decoder.decodeAlloc([][]const u8, allocator, tc.encoded);
+        defer allocator.free(result.value);
+        defer for (result.value) |str| allocator.free(str);
+        try std.testing.expectEqual(result.bytes_read, tc.encoded.len);
+        try std.testing.expectEqual(result.value.len, tc.value.len);
+        for (result.value, tc.value) |decoded_str, expected_str| {
+            try std.testing.expectEqualStrings(expected_str, decoded_str);
+        }
+    }
+}
+
+test "encode-and-decode-vector-of-u32" {
     const allocator = std.testing.allocator;
 
     const test_cases = [_]struct {
@@ -137,20 +176,61 @@ test "encode-and-decode-option" {
 }
 
 test "encode-and-decode-string" {
+    // Test both []const u8 and []u8 string types for SCALE encoding/decoding
     const allocator = std.testing.allocator;
 
-    const test_cases = [_]struct {
+    // Test cases for []const u8 (immutable strings)
+    const const_test_cases = [_]struct {
         decoded: []const u8,
         encoded: []const u8,
     }{
         .{
             .decoded = "Hello World",
             .encoded = &[_]u8{ 0x2c, 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x20, 0x57, 0x6f, 0x72, 0x6c, 0x64 },
         },
-        // TODO: Add more test cases
+        .{
+            .decoded = "",
+            .encoded = &[_]u8{0x00},
+        },
+        .{
+            .decoded = "A",
+            .encoded = &[_]u8{ 0x04, 0x41 },
+        },
+        .{
+            .decoded = "Hello",
+            .encoded = &[_]u8{ 0x14, 0x48, 0x65, 0x6c, 0x6c, 0x6f },
+        },
+        .{
+            .decoded = "This is a longer string for testing",
+            .encoded = &[_]u8{ 0x8c, 0x54, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20, 0x61, 0x20, 0x6c, 0x6f, 0x6e, 0x67, 0x65, 0x72, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x65, 0x73, 0x74, 0x69, 0x6e, 0x67 },
+        },
     };
 
-    for (test_cases) |tc| {
+    // Test cases for []u8 (mutable strings)
+    const mutable_test_cases = [_]struct {
+        decoded: []u8,
+        encoded: []const u8,
+    }{
+        .{
+            .decoded = try allocator.dupe(u8, "Hello World"),
+            .encoded = &[_]u8{ 0x2c, 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x20, 0x57, 0x6f, 0x72, 0x6c, 0x64 },
+        },
+        .{
+            .decoded = try allocator.dupe(u8, ""),
+            .encoded = &[_]u8{0x00},
+        },
+        .{
+            .decoded = try allocator.dupe(u8, "Test"),
+            .encoded = &[_]u8{ 0x10, 0x54, 0x65, 0x73, 0x74 },
+        },
+        .{
+            .decoded = try allocator.dupe(u8, "Mutable String"),
+            .encoded = &[_]u8{ 0x38, 0x4d, 0x75, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x20, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67 },
+        },
+    };
+
+    // Test []const u8 encoding and decoding
+    for (const_test_cases) |tc| {
         // Test encoding
         const buffer = try encoder.encodeAlloc(allocator, tc.decoded);
         defer allocator.free(buffer);
@@ -162,6 +242,22 @@ test "encode-and-decode-string" {
         try std.testing.expectEqual(result.bytes_read, tc.encoded.len);
         try std.testing.expectEqualStrings(tc.decoded, result.value);
     }
+
+    // Test []u8 encoding and decoding
+    for (mutable_test_cases) |tc| {
+        defer allocator.free(tc.decoded);
+
+        // Test encoding
+        const buffer = try encoder.encodeAlloc(allocator, tc.decoded);
+        defer allocator.free(buffer);
+        try std.testing.expectEqualSlices(u8, tc.encoded, buffer);
+
+        // Test decoding
+        const result = try decoder.decodeAlloc([]u8, allocator, tc.encoded);
+        defer allocator.free(result.value);
+        try std.testing.expectEqual(result.bytes_read, tc.encoded.len);
+        try std.testing.expectEqualStrings(tc.decoded, result.value);
+    }
 }
 
 test "encode-and-decode-bool" {

src/util.zig

@@ -22,15 +22,23 @@ pub fn calculateEncodedSize(value: anytype) !usize {
                 if (info.child == u8) {
                     return calculateCompactSize(@intCast(value.len)) + value.len;
                 } else {
-                    return calculateCompactSize(@intCast(value.len)) + (value.len * @sizeOf(info.child));
+                    var size = calculateCompactSize(@intCast(value.len));
+                    for (value) |item| {
+                        size += try calculateEncodedSize(item);
+                    }
+                    return size;
                 }
             } else if (info.size == .one and @typeInfo(info.child) == .array) {
                 // Handle pointers to arrays (like string literals)
                 const array_info = @typeInfo(info.child).array;
                 if (array_info.child == u8) {
                     return calculateCompactSize(@intCast(array_info.len)) + array_info.len;
                 } else {
-                    return calculateCompactSize(@intCast(array_info.len)) + (array_info.len * @sizeOf(array_info.child));
+                    var size = calculateCompactSize(@intCast(array_info.len));
+                    for (value) |item| {
+                        size += try calculateEncodedSize(item);
+                    }
+                    return size;
                 }
             }