diff --git a/src/asciiUpper.zig b/src/asciiUpper.zig
index 94d39d22a4517d049f4fdc40c050bd28d6c5c0c3..57e2e292df9230e6314a28dff88b3ed9d720d0f1 100644
--- a/src/asciiUpper.zig
+++ b/src/asciiUpper.zig
@@ -9,3 +9,19 @@ pub fn asciiUpper(alloc: std.mem.Allocator, input: string) ![]u8 {
     }
     return buf;
 }
+
+test {
+    const allocator = std.testing.allocator;
+    const input = "hello";
+    const upper = try asciiUpper(allocator, input);
+    defer allocator.free(upper);
+    try std.testing.expect(std.mem.eql(u8, upper, "HELLO"));
+}
+
+test {
+    const allocator = std.testing.allocator;
+    const input = "bUtTer?!";
+    const upper = try asciiUpper(allocator, input);
+    defer allocator.free(upper);
+    try std.testing.expect(std.mem.eql(u8, upper, "BUTTER?!"));
+}
diff --git a/src/dirSize.zig b/src/dirSize.zig
index c497129d1b13b73c0346dd5ef31f994de3b2bc7d..ebd1cf62c72597d1e38ee42b737c6ba57c108efb 100644
--- a/src/dirSize.zig
+++ b/src/dirSize.zig
@@ -1,6 +1,7 @@
 const std = @import("std");
 const string = []const u8;
 const extras = @import("./lib.zig");
+const fileSize = extras.fileSize;
 
 pub fn dirSize(alloc: std.mem.Allocator, dir: std.fs.IterableDir) !u64 {
     var res: u64 = 0;
@@ -8,8 +9,12 @@ pub fn dirSize(alloc: std.mem.Allocator, dir: std.fs.IterableDir) !u64 {
     var walk = try dir.walk(alloc);
     defer walk.deinit();
     while (try walk.next()) |entry| {
-        if (entry.kind != .File) continue;
-        res += try extras.fileSize(dir.dir, entry.path);
+        if (entry.kind != .file) continue;
+        res += try fileSize(dir.dir, entry.path);
     }
     return res;
 }
+
+test {
+    std.testing.refAllDecls(@This());
+}
diff --git a/src/doesFileExist.zig b/src/doesFileExist.zig
index 636a05d7f6dd4aedcb402fa3edba2523c3d991ab..63b28019269dd082ab47d9e1aa7afb2f6cde7364 100644
--- a/src/doesFileExist.zig
+++ b/src/doesFileExist.zig
@@ -11,3 +11,7 @@ pub fn doesFileExist(dir: ?std.fs.Dir, fpath: []const u8) !bool {
     defer file.close();
     return true;
 }
+
+test {
+    std.testing.refAllDecls(@This());
+}
diff --git a/src/doesFolderExist.zig b/src/doesFolderExist.zig
index ab120e14f6b14c0ae1d9bfc90f88108cfba23244..2fdb739a8760a142e1da1e6b57609288a04f7975 100644
--- a/src/doesFolderExist.zig
+++ b/src/doesFolderExist.zig
@@ -15,3 +15,7 @@ pub fn doesFolderExist(dir: ?std.fs.Dir, fpath: []const u8) !bool {
     }
     return true;
 }
+
+test {
+    std.testing.refAllDecls(@This());
+}
diff --git a/src/fileList.zig b/src/fileList.zig
index 6e80bf06a4d56ffaa4fc981fa4a7433e72cdc7e3..f6e0961ffbd82b767cf425543b476e6ed7797fbe 100644
--- a/src/fileList.zig
+++ b/src/fileList.zig
@@ -14,3 +14,7 @@ pub fn fileList(alloc: std.mem.Allocator, dir: std.fs.IterableDir) ![]string {
     }
     return list.toOwnedSlice();
 }
+
+test {
+    std.testing.refAllDecls(@This());
+}
diff --git a/src/fileSize.zig b/src/fileSize.zig
index 1c4df45361162bf89d1514ed77d4e1e9b357408b..1bb8f7c368bd32a11aba6a73c15c56ddfa1d7ed7 100644
--- a/src/fileSize.zig
+++ b/src/fileSize.zig
@@ -8,3 +8,7 @@ pub fn fileSize(dir: std.fs.Dir, sub_path: string) !u64 {
     const s = try f.stat();
     return s.size;
 }
+
+test {
+    std.testing.refAllDecls(@This());
+}
diff --git a/src/hashFile.zig b/src/hashFile.zig
index e4861ddb614f57651e94e77280fc5dc1917eb75d..3ad16eb15d5fa36a5dc4992e231452e3b9d81aa6 100644
--- a/src/hashFile.zig
+++ b/src/hashFile.zig
@@ -1,16 +1,26 @@
 const std = @import("std");
 const string = []const u8;
 const extras = @import("./lib.zig");
+const pipe = extras.pipe;
+const rawInt = extras.rawInt;
 
 pub fn hashFile(dir: std.fs.Dir, sub_path: string, comptime Algo: type) ![Algo.digest_length * 2]u8 {
     const file = try dir.openFile(sub_path, .{});
     defer file.close();
     var h = Algo.init(.{});
     var out: [Algo.digest_length]u8 = undefined;
-    try extras.pipe(file.reader(), h.writer());
+    try pipe(file.reader(), h.writer());
     h.final(&out);
     var res: [Algo.digest_length * 2]u8 = undefined;
     var fbs = std.io.fixedBufferStream(&res);
     try std.fmt.format(fbs.writer(), "{x}", .{std.fmt.fmtSliceHexLower(&out)});
     return res;
 }
+
+test {
+    const tdir = std.testing.tmpDir(.{}).dir;
+    try tdir.writeFile("yo.txt", "hello");
+    const A = std.crypto.hash.sha2.Sha256;
+    const expected = "2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824".*;
+    try std.testing.expect(std.mem.eql(u8, &try hashFile(tdir, "yo.txt", A), &expected));
+}
diff --git a/src/pipe.zig b/src/pipe.zig
index 4d12079c7e409baf0aea9f9e7f0728c8f1d81d04..50ce7a3603b7292421c5f99edacac63066ccdb95 100644
--- a/src/pipe.zig
+++ b/src/pipe.zig
@@ -8,3 +8,13 @@ pub fn pipe(reader_from: anytype, writer_to: anytype) !void {
     defer fifo.deinit();
     try fifo.pump(reader_from, writer_to);
 }
+
+test {
+    const bytes = "abcdefghijklmnopqrstuvwxyz".*;
+    var fba = std.io.fixedBufferStream(&bytes);
+    const allocator = std.testing.allocator;
+    var list = std.ArrayList(u8).init(allocator);
+    defer list.deinit();
+    try pipe(fba.reader(), list.writer());
+    try std.testing.expect(std.mem.eql(u8, &bytes, list.items));
+}
diff --git a/src/sliceToInt.zig b/src/sliceToInt.zig
index fc5ee09934626e916a01d636db29701c307d2d9d..fda2609b1a5cb814c9c3a00486a0e5f7d430c899 100644
--- a/src/sliceToInt.zig
+++ b/src/sliceToInt.zig
@@ -14,3 +14,13 @@ pub fn sliceToInt(comptime T: type, comptime E: type, slice: []const E) !T {
     }
     return n;
 }
+
+test {
+    try std.testing.expect(try sliceToInt(u32, u4, &.{ 0x4, 0xe, 0x5, 0xa, 0x7, 0xd, 0xa, 0x9 }) == 0x4e5a7da9);
+}
+test {
+    try std.testing.expect(try sliceToInt(u30, u3, &.{ 0b010, 0b011, 0b100, 0b101, 0b101, 0b001, 0b111, 0b101, 0b101, 0b010 }) == 0b010011100101101001111101101010);
+}
+test {
+    try std.testing.expect(try sliceToInt(u30, u5, &.{ 0b01001, 0b11001, 0b01101, 0b00111, 0b11011, 0b01010 }) == 0b010011100101101001111101101010);
+}