From a1d0efbb3e97764e36caf81ac8f9ac93bb1e8a84 Mon Sep 17 00:00:00 2001
From: Meghan Denny <hello@nektro.net>
Date: Sun, 28 Jan 2024 22:02:48 -0800
Subject: [PATCH] add more tests

---
 src/AnyReader.zig         |  4 ++++
 src/OneBiggerInt.zig      | 31 +++++++++++++++++++++++++++++++
 src/Partial.zig           | 18 ++++++++++++++++++
 src/ReverseFields.zig     | 12 ++++++++++++
 src/RingBuffer.zig        |  4 ++++
 src/base64DecodeAlloc.zig |  4 ++++
 src/base64EncodeAlloc.zig |  4 ++++
 src/coalescePartial.zig   | 16 +++++++++++++++-
 src/containsAggregate.zig | 23 +++++++++++++++++++++++
 src/fmtByteCountIEC.zig   | 28 +++++++++++++++++++++++++++-
 src/randomSlice.zig       |  8 ++++++++
 src/reduceNumber.zig      | 30 +++++++++++++++++++++++++++++-
 src/stringToEnum.zig      | 13 +++++++++++++
 src/sum.zig               | 19 +++++++++++++++++++
 src/trimPrefix.zig        |  7 +++++++
 src/trimPrefixEnsure.zig  |  7 +++++++
 src/trimSuffix.zig        |  7 +++++++
 src/trimSuffixEnsure.zig  |  7 +++++++
 18 files changed, 239 insertions(+), 3 deletions(-)

diff --git a/src/AnyReader.zig b/src/AnyReader.zig
index 037bc91707fb0c6418de9ff1cf47ccfdf09efeef..62571a6330d347eabb6b3e198e93f43a05d36a0d 100644
--- a/src/AnyReader.zig
+++ b/src/AnyReader.zig
@@ -121,3 +121,7 @@ pub const AnyReader = struct {
         }
     }
 };
+
+test {
+    std.testing.refAllDecls(AnyReader);
+}
diff --git a/src/OneBiggerInt.zig b/src/OneBiggerInt.zig
index da908cb9a5bf747d9d22633bd0dc73784c7a4321..2da7b12b61cdd5399cf4fd2e9cd6f71d4020ccc2 100644
--- a/src/OneBiggerInt.zig
+++ b/src/OneBiggerInt.zig
@@ -7,3 +7,34 @@ pub fn OneBiggerInt(comptime T: type) type {
     info.Int.bits += 1;
     return @Type(info);
 }
+
+test {
+    try std.testing.expect(OneBiggerInt(u0) == u1);
+}
+test {
+    try std.testing.expect(OneBiggerInt(u1) == u2);
+}
+test {
+    try std.testing.expect(OneBiggerInt(u2) == u3);
+}
+test {
+    try std.testing.expect(OneBiggerInt(u3) == u4);
+}
+test {
+    try std.testing.expect(OneBiggerInt(u4) == u5);
+}
+test {
+    try std.testing.expect(OneBiggerInt(i0) == i1);
+}
+test {
+    try std.testing.expect(OneBiggerInt(i1) == i2);
+}
+test {
+    try std.testing.expect(OneBiggerInt(i2) == i3);
+}
+test {
+    try std.testing.expect(OneBiggerInt(i3) == i4);
+}
+test {
+    try std.testing.expect(OneBiggerInt(i4) == i5);
+}
diff --git a/src/Partial.zig b/src/Partial.zig
index 27e5fb12ccf099747b9945b497f52c577954706e..28b6ed1a39761a0adf49edf74308563227defbbc 100644
--- a/src/Partial.zig
+++ b/src/Partial.zig
@@ -1,7 +1,10 @@
 const std = @import("std");
 const string = []const u8;
 const extras = @import("./lib.zig");
+const expectSimilarType = extras.expectSimilarType;
 
+/// Creates a new version of struct T where all fields are optional.
+/// Name inspried by https://www.typescriptlang.org/docs/handbook/utility-types.html#partialtype.
 pub fn Partial(comptime T: type) type {
     const fields_before = std.meta.fields(T);
     var fields_after: [fields_before.len]std.builtin.Type.StructField = undefined;
@@ -22,3 +25,18 @@ pub fn Partial(comptime T: type) type {
         .is_tuple = false,
     }));
 }
+
+test {
+    try expectSimilarType(
+        Partial(struct {
+            a: u32,
+            b: u8,
+            c: u16,
+        }),
+        struct {
+            a: ?u32,
+            b: ?u8,
+            c: ?u16,
+        },
+    );
+}
diff --git a/src/ReverseFields.zig b/src/ReverseFields.zig
index c00bb28072b62a4b4f4d5973908f2f9031871566..a864883c18d92e5751e1c9e2752978b4d4e3f8d6 100644
--- a/src/ReverseFields.zig
+++ b/src/ReverseFields.zig
@@ -12,3 +12,15 @@ pub fn ReverseFields(comptime T: type) type {
     info.fields = &fields;
     return @Type(.{ .Struct = info });
 }
+
+test {
+    const A = struct { x: u8, y: u16 };
+    const B = ReverseFields(A);
+    const fields = std.meta.fields(B);
+
+    try std.testing.expect(fields.len == 2);
+    try std.testing.expect(fields[0].type == u16);
+    try std.testing.expect(std.mem.eql(u8, fields[0].name, "y"));
+    try std.testing.expect(fields[1].type == u8);
+    try std.testing.expect(std.mem.eql(u8, fields[1].name, "x"));
+}
diff --git a/src/RingBuffer.zig b/src/RingBuffer.zig
index f7256d8e2e367b7dd8bf5daaf185f1e5d01e6a15..1e1f414903ea4e3624ce96ba8fa9298582ee6ee5 100644
--- a/src/RingBuffer.zig
+++ b/src/RingBuffer.zig
@@ -20,3 +20,7 @@ pub fn RingBuffer(comptime T: type, comptime capacity: usize) type {
         }
     };
 }
+
+test {
+    std.testing.refAllDecls(RingBuffer(u8, 16));
+}
diff --git a/src/base64DecodeAlloc.zig b/src/base64DecodeAlloc.zig
index 4c89c2eed3f773a448521e16ec16431f9731d303..2e297e82b0751064f2ff19d823fe814c8c647c18 100644
--- a/src/base64DecodeAlloc.zig
+++ b/src/base64DecodeAlloc.zig
@@ -8,3 +8,7 @@ pub fn base64DecodeAlloc(alloc: std.mem.Allocator, input: string) !string {
     try base64.decode(buf, input);
     return buf;
 }
+
+test {
+    std.testing.refAllDecls(@This());
+}
diff --git a/src/base64EncodeAlloc.zig b/src/base64EncodeAlloc.zig
index a3f4fbbed30a92c42fe4cca90ae4ea8781301e0d..39bba1ca5c493d1ac7f0a2f14243eabdff19181b 100644
--- a/src/base64EncodeAlloc.zig
+++ b/src/base64EncodeAlloc.zig
@@ -7,3 +7,7 @@ pub fn base64EncodeAlloc(alloc: std.mem.Allocator, input: string) !string {
     var buf = try alloc.alloc(u8, base64.calcSize(input.len));
     return base64.encode(buf, input);
 }
+
+test {
+    std.testing.refAllDecls(@This());
+}
diff --git a/src/coalescePartial.zig b/src/coalescePartial.zig
index e27e85fd37ebe49ce92277ba287b262d11031cd6..ce4062d58f6a775f39f6d94398b3d8d7d25f723c 100644
--- a/src/coalescePartial.zig
+++ b/src/coalescePartial.zig
@@ -1,11 +1,25 @@
 const std = @import("std");
 const string = []const u8;
 const extras = @import("./lib.zig");
+const Partial = extras.Partial;
 
-pub fn coalescePartial(comptime T: type, into: T, from: extras.Partial(T)) T {
+pub fn coalescePartial(comptime T: type, into: T, from: Partial(T)) T {
     var temp = into;
     inline for (comptime std.meta.fieldNames(T)) |name| {
         if (@field(from, name)) |val| @field(temp, name) = val;
     }
     return temp;
 }
+
+test {
+    const S = struct {
+        a: u8 = 4,
+        b: u8 = 7,
+        c: u8 = 1,
+    };
+    try std.testing.expect(std.meta.eql(coalescePartial(S, .{}, .{ .b = 9 }), .{
+        .a = 4,
+        .b = 9,
+        .c = 1,
+    }));
+}
diff --git a/src/containsAggregate.zig b/src/containsAggregate.zig
index b2cae38095a05148875a569305427d5cfb4057f6..b931fcbffc9a8a7df22d249595a3cf5e2749494d 100644
--- a/src/containsAggregate.zig
+++ b/src/containsAggregate.zig
@@ -10,3 +10,26 @@ pub fn containsAggregate(comptime T: type, haystack: []const T, needle: T) bool
     }
     return false;
 }
+
+test {
+    const S = struct {
+        a: u8,
+
+        fn eql(this: @This(), other: @This()) bool {
+            return this.a == other.a;
+        }
+    };
+    const data = [_]S{
+        .{ .a = 8 },
+        .{ .a = 6 },
+        .{ .a = 7 },
+        .{ .a = 2 },
+        .{ .a = 4 },
+        .{ .a = 1 },
+        .{ .a = 9 },
+        .{ .a = 3 },
+        .{ .a = 5 },
+    };
+    try std.testing.expect(containsAggregate(S, &data, .{ .a = 4 }));
+    try std.testing.expect(!containsAggregate(S, &data, .{ .a = 0 }));
+}
diff --git a/src/fmtByteCountIEC.zig b/src/fmtByteCountIEC.zig
index 726b996279df89785e474cf622ad3714eca27d81..0ca9067906dfe9f71185cb3711c70f8a36cffd4f 100644
--- a/src/fmtByteCountIEC.zig
+++ b/src/fmtByteCountIEC.zig
@@ -1,7 +1,33 @@
 const std = @import("std");
 const string = []const u8;
 const extras = @import("./lib.zig");
+const reduceNumber = extras.reduceNumber;
 
 pub fn fmtByteCountIEC(alloc: std.mem.Allocator, b: u64) !string {
-    return try extras.reduceNumber(alloc, b, 1024, "B", "KMGTPEZYRQ");
+    return try reduceNumber(alloc, b, 1024, "B", "KMGTPEZYRQ");
+}
+
+test {
+    const allocator = std.testing.allocator;
+    const actual = try fmtByteCountIEC(allocator, std.math.pow(u64, 1024, 0));
+    defer allocator.free(actual);
+    try std.testing.expect(std.mem.eql(u8, actual, "1 B"));
+}
+test {
+    const allocator = std.testing.allocator;
+    const actual = try fmtByteCountIEC(allocator, std.math.pow(u64, 1024, 1));
+    defer allocator.free(actual);
+    try std.testing.expect(std.mem.eql(u8, actual, "1.000 KB"));
+}
+test {
+    const allocator = std.testing.allocator;
+    const actual = try fmtByteCountIEC(allocator, std.math.pow(u64, 1024, 2));
+    defer allocator.free(actual);
+    try std.testing.expect(std.mem.eql(u8, actual, "1.000 MB"));
+}
+test {
+    const allocator = std.testing.allocator;
+    const actual = try fmtByteCountIEC(allocator, std.math.pow(u64, 1024, 3));
+    defer allocator.free(actual);
+    try std.testing.expect(std.mem.eql(u8, actual, "1.000 GB"));
 }
diff --git a/src/randomSlice.zig b/src/randomSlice.zig
index 65d6adfa75bf604506637e7a169e483b6a4b939e..0014d24c9983cdf76a3d4d5e7be041b8b4f63e5c 100644
--- a/src/randomSlice.zig
+++ b/src/randomSlice.zig
@@ -12,3 +12,11 @@ pub fn randomSlice(alloc: std.mem.Allocator, rand: std.rand.Random, comptime T:
     }
     return buf;
 }
+
+test {
+    const allocator = std.testing.allocator;
+    const rand = std.crypto.random;
+    const slice = try randomSlice(allocator, rand, u8, 10);
+    defer allocator.free(slice);
+    try std.testing.expect(slice.len == 10);
+}
diff --git a/src/reduceNumber.zig b/src/reduceNumber.zig
index 071fe0e24f346ec7b2880b830a068b398df6f46d..972b9b9939d5de4341a2c8ef83a31263bd5fe11c 100644
--- a/src/reduceNumber.zig
+++ b/src/reduceNumber.zig
@@ -12,6 +12,34 @@ pub fn reduceNumber(alloc: std.mem.Allocator, input: u64, comptime unit: u64, co
     while (n >= unit) : (n /= unit) {
         div *= unit;
         exp += 1;
+        if (exp == prefixes.len - 1) break;
     }
-    return try std.fmt.allocPrint(alloc, "{d:.3} {s}{s}", .{ @as(f64, @floatFromInt(input)) / @as(f64, @floatFromInt(div)), prefixes[exp .. exp + 1], base });
+    const input_f: f64 = @floatFromInt(input);
+    const div_f: f64 = @floatFromInt(div);
+    return try std.fmt.allocPrint(alloc, "{d:.3} {s}{s}", .{ input_f / div_f, prefixes[exp..][0..1], base });
+}
+
+test {
+    const allocator = std.testing.allocator;
+    const actual = try reduceNumber(allocator, 1, 60, "s", "mh");
+    defer allocator.free(actual);
+    try std.testing.expect(std.mem.eql(u8, actual, "1 s"));
+}
+test {
+    const allocator = std.testing.allocator;
+    const actual = try reduceNumber(allocator, 60, 60, "s", "mh");
+    defer allocator.free(actual);
+    try std.testing.expect(std.mem.eql(u8, actual, "1.000 ms"));
+}
+test {
+    const allocator = std.testing.allocator;
+    const actual = try reduceNumber(allocator, 3600, 60, "s", "mh");
+    defer allocator.free(actual);
+    try std.testing.expect(std.mem.eql(u8, actual, "1.000 hs"));
+}
+test {
+    const allocator = std.testing.allocator;
+    const actual = try reduceNumber(allocator, 216000, 60, "s", "mh");
+    defer allocator.free(actual);
+    try std.testing.expect(std.mem.eql(u8, actual, "60.000 hs"));
 }
diff --git a/src/stringToEnum.zig b/src/stringToEnum.zig
index c2eec2a42aebfbe2f59ee93fda26df1abb5829ef..8ba3521454b5b2a7dbef62fbfbf6d01173ef70f7 100644
--- a/src/stringToEnum.zig
+++ b/src/stringToEnum.zig
@@ -5,3 +5,16 @@ const extras = @import("./lib.zig");
 pub fn stringToEnum(comptime E: type, str: ?string) ?E {
     return std.meta.stringToEnum(E, str orelse return null);
 }
+
+test {
+    try std.testing.expect(stringToEnum(enum { A, B }, "A") == .A);
+}
+test {
+    try std.testing.expect(stringToEnum(enum { A, B }, "B") == .B);
+}
+test {
+    try std.testing.expect(stringToEnum(enum { A, B }, "C") == null);
+}
+test {
+    try std.testing.expect(stringToEnum(enum { A, B }, null) == null);
+}
diff --git a/src/sum.zig b/src/sum.zig
index dff27a768ac5300cd5295fb6509188baab2cc4ef..9525779cca871203680b6977c4b5d508b9f76caf 100644
--- a/src/sum.zig
+++ b/src/sum.zig
@@ -7,3 +7,22 @@ pub fn sum(comptime T: type, slice: []const T) T {
     for (slice) |item| res += item;
     return res;
 }
+
+test {
+    try std.testing.expect(sum(u8, &.{ 4, 3, 0, 9, 6, 7, 1, 2, 5, 8 }) == 45);
+}
+test {
+    try std.testing.expect(sum(u16, &.{ 8, 6, 7, 3, 2, 1, 5, 0, 9, 4 }) == 45);
+}
+test {
+    try std.testing.expect(sum(u21, &.{ 5, 4, 6, 1, 8, 3, 2, 9, 0, 7 }) == 45);
+}
+test {
+    try std.testing.expect(sum(u32, &.{ 3, 4, 5, 1, 9, 0, 6, 2, 7, 8 }) == 45);
+}
+test {
+    try std.testing.expect(sum(u40, &.{ 0, 5, 6, 7, 1, 2, 4, 9, 3, 8 }) == 45);
+}
+test {
+    try std.testing.expect(sum(u64, &.{ 5, 4, 3, 9, 1, 7, 6, 2, 0, 8 }) == 45);
+}
diff --git a/src/trimPrefix.zig b/src/trimPrefix.zig
index b19d2110e228a11f2029edbde552733a84f716a4..e580d9a78a2ab62568c8632f8b8b0cdaf1769357 100644
--- a/src/trimPrefix.zig
+++ b/src/trimPrefix.zig
@@ -8,3 +8,10 @@ pub fn trimPrefix(in: string, prefix: string) string {
     }
     return in;
 }
+
+test {
+    try std.testing.expect(std.mem.eql(u8, trimPrefix("abaabbaaba", "c"), "abaabbaaba"));
+}
+test {
+    try std.testing.expect(std.mem.eql(u8, trimPrefix("abaabbaaba", "aba"), "abbaaba"));
+}
diff --git a/src/trimPrefixEnsure.zig b/src/trimPrefixEnsure.zig
index 8fcb497764af1cb3d245cd2df4f74ec1927b533c..73b39bb16a7ac2096ce8de8738cd8f392163ad13 100644
--- a/src/trimPrefixEnsure.zig
+++ b/src/trimPrefixEnsure.zig
@@ -6,3 +6,10 @@ pub fn trimPrefixEnsure(in: string, prefix: string) ?string {
     if (!std.mem.startsWith(u8, in, prefix)) return null;
     return in[prefix.len..];
 }
+
+test {
+    try std.testing.expect(trimPrefixEnsure("abaabbaaba", "c") == null);
+}
+test {
+    try std.testing.expect(std.mem.eql(u8, trimPrefixEnsure("abaabbaaba", "aba").?, "abbaaba"));
+}
diff --git a/src/trimSuffix.zig b/src/trimSuffix.zig
index 588828c7e6ad00e187c953bfd48e488350176d27..b9dec69e8a414a788ccd727401504a7e78942f9e 100644
--- a/src/trimSuffix.zig
+++ b/src/trimSuffix.zig
@@ -8,3 +8,10 @@ pub fn trimSuffix(in: string, suffix: string) string {
     }
     return in;
 }
+
+test {
+    try std.testing.expect(std.mem.eql(u8, trimSuffix("abaabbaaba", "c"), "abaabbaaba"));
+}
+test {
+    try std.testing.expect(std.mem.eql(u8, trimSuffix("abaabbaaba", "aba"), "abaabba"));
+}
diff --git a/src/trimSuffixEnsure.zig b/src/trimSuffixEnsure.zig
index 2b8772bf3dd32adf51e5db87ca6581f4fdfd9bb2..5ff87284ad3953c07ba91da621f8ba23f6a3f693 100644
--- a/src/trimSuffixEnsure.zig
+++ b/src/trimSuffixEnsure.zig
@@ -6,3 +6,10 @@ pub fn trimSuffixEnsure(in: string, suffix: string) ?string {
     if (!std.mem.endsWith(u8, in, suffix)) return null;
     return in[0 .. in.len - suffix.len];
 }
+
+test {
+    try std.testing.expect(trimSuffixEnsure("abaabbaaba", "c") == null);
+}
+test {
+    try std.testing.expect(std.mem.eql(u8, trimSuffixEnsure("abaabbaaba", "aba").?, "abaabba"));
+}
-- 
2.54.0