diff --git a/lua/tests/gmod/unit/libraries/bit/arshift.lua b/lua/tests/gmod/unit/libraries/bit/arshift.lua
new file mode 100644
index 0000000..82826c0
--- /dev/null
+++ b/lua/tests/gmod/unit/libraries/bit/arshift.lua
@@ -0,0 +1,47 @@
+--- @type GLuaTest_TestGroup
+return {
+    groupName = "bit.arshift",
+    cases = {
+        {
+            name = "Functions exists",
+            func = function()
+                expect( bit.arshift ).to.beA( "function" )
+            end
+        },
+
+        {
+            name = "Correctly shifts positive numbers",
+            func = function()
+                expect( bit.arshift( 8, 1 ) ).to.equal( 4 )
+                expect( bit.arshift( 16, 2 ) ).to.equal( 4 )
+                expect( bit.arshift( 0, 1 ) ).to.equal( 0 )
+                expect( bit.arshift( 312, 0 ) ).to.equal( 312 )
+                expect( bit.arshift( 123, 32 ) ).to.equal( 123 )
+            end
+        },
+
+        {
+            name = "Correctly shifts negative numbers",
+            func = function()
+                expect( bit.arshift( -8, 1 ) ).to.equal( -4 )
+                expect( bit.arshift( -16, 2 ) ).to.equal( -4 )
+                expect( bit.arshift( -12345, 5 ) ).to.equal( -386 )
+                expect( bit.arshift( -1, 10 ) ).to.equal( -1 )
+            end
+        },
+
+        {
+            name = "Throws error when not given a number",
+            func = function()
+                expect( bit.arshift, nil, 1 ).to.errWith( [[bad argument #1 to '?' (number expected, got nil)]] )
+                expect( bit.arshift, 1, nil ).to.errWith( [[bad argument #2 to '?' (number expected, got no value)]] )
+
+                expect( bit.arshift, "abc", 1 ).to.errWith( [[bad argument #1 to '?' (number expected, got string)]] )
+                expect( bit.arshift, 1, "def" ).to.errWith( [[bad argument #2 to '?' (number expected, got string)]] )
+
+                expect( bit.arshift, {}, 1 ).to.errWith( [[bad argument #1 to '?' (number expected, got table)]] )
+                expect( bit.arshift, 1, {} ).to.errWith( [[bad argument #2 to '?' (number expected, got table)]] )
+            end
+        },
+    }
+}
\ No newline at end of file
diff --git a/lua/tests/gmod/unit/libraries/bit/band.lua b/lua/tests/gmod/unit/libraries/bit/band.lua
new file mode 100644
index 0000000..c7b3b56
--- /dev/null
+++ b/lua/tests/gmod/unit/libraries/bit/band.lua
@@ -0,0 +1,60 @@
+--- @type GLuaTest_TestGroup
+return {
+    groupName = "bit.band",
+    cases = {
+        {
+            name = "Function exists",
+            func = function()
+                expect( bit.band ).to.beA( "function" )
+            end
+        },
+
+        {
+            name = "Returns correct values",
+            func = function()
+                expect( bit.band( 8, 8 ) ).to.equal( 8 )
+                expect( bit.band( 8, 1 ) ).to.equal( 0 )
+                expect( bit.band( 42, 17 ) ).to.equal( 0 )
+                expect( bit.band( 0, 0 ) ).to.equal( 0 )
+            end
+        },
+
+        {
+            name = "Returns correct values with negative inputs",
+            func = function()
+                expect( bit.band( -8, 8 ) ).to.equal( 8 )
+                expect( bit.band( -8, 1 ) ).to.equal( 0 )
+            end
+        },
+
+        {
+            name = "Functions properly with more than 2 args",
+            func = function()
+                expect( bit.band( 0, 0, 0 ) ).to.equal( 0 )
+                expect( bit.band( 300, 200, 300 ) ).to.equal( 8 )
+                expect( bit.band( 1, 2, 4, 8, 16, 32, 64 ) ).to.equal( 0 )
+            end
+        },
+
+        {
+            name = "Returns same result when args are flipped",
+            func = function()
+                expect( bit.band( 123, 456 ) ).to.equal( bit.band( 456, 123 ) )
+            end
+        },
+
+        {
+            name = "Throws error when not given a number",
+            func = function()
+                expect( bit.band, nil, 1 ).to.errWith( [[bad argument #1 to '?' (number expected, got nil)]] )
+                expect( bit.band, 1, nil ).toNot.err()
+
+                expect( bit.band, "abc", 1 ).to.errWith( [[bad argument #1 to '?' (number expected, got string)]] )
+                expect( bit.band, 1, "def" ).to.errWith( [[bad argument #2 to '?' (number expected, got string)]] )
+
+                expect( bit.band, {}, 1 ).to.errWith( [[bad argument #1 to '?' (number expected, got table)]] )
+                expect( bit.band, 1, {} ).to.errWith( [[bad argument #2 to '?' (number expected, got table)]] )
+            end
+        },
+    }
+}
\ No newline at end of file
diff --git a/lua/tests/gmod/unit/libraries/bit/bnot.lua b/lua/tests/gmod/unit/libraries/bit/bnot.lua
new file mode 100644
index 0000000..fdbf7fb
--- /dev/null
+++ b/lua/tests/gmod/unit/libraries/bit/bnot.lua
@@ -0,0 +1,47 @@
+--- @type GLuaTest_TestGroup
+return {
+    groupName = "bit.bnot",
+    cases = {
+        {
+            name = "Function exists",
+            func = function()
+                expect( bit.bnot ).to.beA( "function" )
+            end
+        },
+
+        {
+            name = "Correctly inverts input number",
+            func = function()
+                expect( bit.bnot( 8 ) ).to.equal( -9 )
+                expect( bit.bnot( 32 ) ).to.equal( -33 )
+                expect( bit.bnot( -27534 ) ).to.equal( 27533 )
+                expect( bit.bnot( -69 ) ).to.equal( 68 )
+            end
+        },
+
+        {
+            name = "Correctly inverts 0 and -1",
+            func = function()
+                expect( bit.bnot( 0 ) ).to.equal( -1 )
+                expect( bit.bnot( -1 ) ).to.equal( 0 )
+            end
+        },
+
+        {
+            name = "Correctly handles min and max values",
+            func = function()
+                expect( bit.bnot( 2147483647 ) ).to.equal( -2147483648 )
+                expect( bit.bnot( -2147483648 ) ).to.equal( 2147483647 )
+            end
+        },
+
+        {
+            name = "Throws error when not given a number",
+            func = function()
+                expect( bit.bnot, nil ).to.errWith( [[bad argument #1 to '?' (number expected, got no value)]] )
+                expect( bit.bnot, "abc" ).to.errWith( [[bad argument #1 to '?' (number expected, got string)]] )
+                expect( bit.bnot, {} ).to.errWith( [[bad argument #1 to '?' (number expected, got table)]] )
+            end
+        },
+    }
+}
\ No newline at end of file
diff --git a/lua/tests/gmod/unit/libraries/bit/bor.lua b/lua/tests/gmod/unit/libraries/bit/bor.lua
new file mode 100644
index 0000000..2d974ee
--- /dev/null
+++ b/lua/tests/gmod/unit/libraries/bit/bor.lua
@@ -0,0 +1,66 @@
+--- @type GLuaTest_TestGroup
+return {
+    groupName = "bit.bor",
+    cases = {
+        {
+            name = "Function exists",
+            func = function()
+                expect( bit.bor ).to.beA( "function" )
+            end
+        },
+
+        {
+            name = "Correctly handles positive OR operations",
+            func = function()
+                expect( bit.bor( 8, 8 ) ).to.equal( 8 )
+                expect( bit.bor( 8, 1 ) ).to.equal( 9 )
+                expect( bit.bor( 27533, 17 ) ).to.equal( 27549 )
+            end
+        },
+
+        {
+            name = "Correctly handles negative OR operations",
+            func = function()
+                expect( bit.bor( -1, 0 ) ).to.equal( -1 )
+                expect( bit.bor( -8, 1 ) ).to.equal( -7 )
+                expect( bit.bor( -100, 50 ) ).to.equal( -66 )
+            end
+        },
+
+        {
+            name = "Correctly handles or operation with 0",
+            func = function()
+                expect( bit.bor( 0, 69 ) ).to.equal( 69 )
+            end
+        },
+
+        {
+            name = "Correctly returns result with mutliple args",
+            func = function()
+                expect( bit.bor( 1, 2, 4, 8 ) ).to.equal( 15 )
+            end
+        },
+
+        {
+            name = "Correctly handles min and max values",
+            func = function()
+                expect( bit.bor( 2147483647, 2147483648 ) ).to.equal( -1 )
+                expect( bit.bor( -2147483648, 0 ) ).to.equal( -2147483648 )
+            end
+        },
+
+        {
+            name = "Throws error when not given a number",
+            func = function()
+                expect( bit.bor, nil, 1 ).to.errWith( [[bad argument #1 to '?' (number expected, got nil)]] )
+                expect( bit.bor, 1, nil ).toNot.err()
+
+                expect( bit.bor, "abc", 1 ).to.errWith( [[bad argument #1 to '?' (number expected, got string)]] )
+                expect( bit.bor, 1, "def" ).to.errWith( [[bad argument #2 to '?' (number expected, got string)]] )
+
+                expect( bit.bor, {}, 1 ).to.errWith( [[bad argument #1 to '?' (number expected, got table)]] )
+                expect( bit.bor, 1, {} ).to.errWith( [[bad argument #2 to '?' (number expected, got table)]] )
+            end
+        },
+    }
+}
\ No newline at end of file
diff --git a/lua/tests/gmod/unit/libraries/bit/bswap.lua b/lua/tests/gmod/unit/libraries/bit/bswap.lua
new file mode 100644
index 0000000..f85c137
--- /dev/null
+++ b/lua/tests/gmod/unit/libraries/bit/bswap.lua
@@ -0,0 +1,37 @@
+--- @type GLuaTest_TestGroup
+return {
+    groupName = "bit.bswap",
+    cases = {
+        {
+            name = "Functions exists",
+            func = function()
+                expect( bit.bswap ).to.beA( "function" )
+            end
+        },
+
+        {
+            name = "Correctly returns swapped value",
+            func = function()
+                expect( bit.bswap( 327 ) ).to.equal( 1191247872 )
+                expect( bit.bswap( 8 ) ).to.equal( 134217728 )
+            end
+        },
+
+        {
+            name = "Correctly handles swapping 0 and -1",
+            func = function()
+                expect( bit.bswap( 0 ) ).to.equal( 0 )
+                expect( bit.bswap( -1 ) ).to.equal( -1 )
+            end
+        },
+
+        {
+            name = "Fails on invalid input",
+            func = function()
+                expect( bit.bswap, nil ).to.errWith( [[bad argument #1 to '?' (number expected, got no value)]] )
+                expect( bit.bswap, "abc" ).to.errWith( [[bad argument #1 to '?' (number expected, got string)]] )
+                expect( bit.bswap, {} ).to.errWith( [[bad argument #1 to '?' (number expected, got table)]] )
+            end
+        },
+    }
+}
\ No newline at end of file
diff --git a/lua/tests/gmod/unit/libraries/bit/bxor.lua b/lua/tests/gmod/unit/libraries/bit/bxor.lua
new file mode 100644
index 0000000..63c0291
--- /dev/null
+++ b/lua/tests/gmod/unit/libraries/bit/bxor.lua
@@ -0,0 +1,58 @@
+--- @type GLuaTest_TestGroup
+return {
+    groupName = "bit.bxor",
+    cases = {
+        {
+            name = "Functions exists",
+            func = function()
+                expect( bit.bxor ).to.beA( "function" )
+            end
+        },
+
+        {
+            name = "Correctly handles positive XOR operations",
+            func = function()
+                expect( bit.bxor( 19, 82 ) ).to.equal( 65 )
+                expect( bit.bxor( 327, 63 ) ).to.equal( 376 )
+                expect( bit.bxor( 234, 0 ) ).to.equal( 234 )
+            end
+        },
+
+        {
+            name = "Correctly handles negative XOR operations",
+            func = function()
+                expect( bit.bxor( -99, -55 ) ).to.equal( 84 )
+                expect( bit.bxor( -420, -67 ) ).to.equal( 481 )
+                expect( bit.bxor( -32, 0 ) ).to.equal( -32 )
+            end
+        },
+
+        {
+            name = "Correctly handles same number input",
+            func = function()
+                expect( bit.bxor( 32, 32 ) ).to.equal( 0 )
+            end
+        },
+
+        {
+            name = "Correctly handles multiple args as input",
+            func = function()
+                expect( bit.bxor( 1, 2, 3, 4, 5 ) ).to.equal( 1 )
+            end
+        },
+
+        {
+            name = "Throws error when not given a number",
+            func = function()
+                expect( bit.bxor, nil, 1 ).to.errWith( [[bad argument #1 to '?' (number expected, got nil)]] )
+                expect( bit.bxor, 1, nil ).toNot.err()
+
+                expect( bit.bxor, "abc", 1 ).to.errWith( [[bad argument #1 to '?' (number expected, got string)]] )
+                expect( bit.bxor, 1, "def" ).to.errWith( [[bad argument #2 to '?' (number expected, got string)]] )
+
+                expect( bit.bxor, {}, 1 ).to.errWith( [[bad argument #1 to '?' (number expected, got table)]] )
+                expect( bit.bxor, 1, {} ).to.errWith( [[bad argument #2 to '?' (number expected, got table)]] )
+            end
+        },
+    }
+}
\ No newline at end of file
diff --git a/lua/tests/gmod/unit/libraries/bit/lshift.lua b/lua/tests/gmod/unit/libraries/bit/lshift.lua
new file mode 100644
index 0000000..980d121
--- /dev/null
+++ b/lua/tests/gmod/unit/libraries/bit/lshift.lua
@@ -0,0 +1,50 @@
+--- @type GLuaTest_TestGroup
+return {
+    groupName = "bit.lshift",
+    cases = {
+        {
+            name = "Functions exists",
+            func = function()
+                expect( bit.lshift ).to.beA( "function" )
+            end
+        },
+
+        {
+            name = "Correctly lshifts numbers",
+            func = function()
+                expect( bit.lshift( 15, 4 ) ).to.equal( 240 )
+                expect( bit.lshift( 96, 4 ) ).to.equal( 1536 )
+                expect( bit.lshift( 63, 2 ) ).to.equal( 252 )
+            end
+        },
+
+        {
+            name = "Values are getting clamped over the signed 32-bit int limit",
+            func = function()
+                expect( bit.lshift( 4294967295, 1 ) ).to.equal( -2 )
+                expect( bit.lshift( -1, 1 ) ).to.equal( -2 )
+            end
+        },
+
+        {
+            name = "Shifting 0 times should return the same value",
+            func = function()
+                expect( bit.lshift( 1, 0 ) ).to.equal( 1 )
+            end
+        },
+
+        {
+            name = "Throws error when not given a number",
+            func = function()
+                expect( bit.lshift, nil, 1 ).to.errWith( [[bad argument #1 to '?' (number expected, got nil)]] )
+                expect( bit.lshift, 1, nil ).to.errWith( [[bad argument #2 to '?' (number expected, got no value)]] )
+
+                expect( bit.lshift, "abc", 1 ).to.errWith( [[bad argument #1 to '?' (number expected, got string)]] )
+                expect( bit.lshift, 1, "def" ).to.errWith( [[bad argument #2 to '?' (number expected, got string)]] )
+
+                expect( bit.lshift, {}, 1 ).to.errWith( [[bad argument #1 to '?' (number expected, got table)]] )
+                expect( bit.lshift, 1, {} ).to.errWith( [[bad argument #2 to '?' (number expected, got table)]] )
+            end
+        },
+    }
+}
\ No newline at end of file
diff --git a/lua/tests/gmod/unit/libraries/bit/rol.lua b/lua/tests/gmod/unit/libraries/bit/rol.lua
new file mode 100644
index 0000000..76288f1
--- /dev/null
+++ b/lua/tests/gmod/unit/libraries/bit/rol.lua
@@ -0,0 +1,59 @@
+--- @type GLuaTest_TestGroup
+return {
+    groupName = "bit.rol",
+    cases = {
+        {
+            name = "Function exists",
+            func = function()
+                expect( bit.rol ).to.beA( "function" )
+            end
+        },
+
+        {
+            name = "Rotating positive numbers returning the correct values",
+            func = function()
+                expect( bit.rol( 8, 1 ) ).to.equal( 16 )
+                expect( bit.rol( 16, 1 ) ).to.equal( 32 )
+                expect( bit.rol( 469, 4 ) ).to.equal( 7504 )
+            end
+        },
+
+        {
+            name = "Rotating negative numbers returning the correct values",
+            func = function()
+                expect( bit.rol( -8, 1 ) ).to.equal( -15 )
+                expect( bit.rol( -16, 1 ) ).to.equal( -31 )
+                expect( bit.rol( -469, 4 ) ).to.equal( -7489 )
+            end
+        },
+
+        {
+            name = "Returning input value on 0 rotations",
+            func = function()
+                expect( bit.rol( 412, 0 ) ).to.equal( 412 )
+            end
+        },
+
+        {
+            name = "Functions properly when rotating over the limit",
+            func = function()
+                expect( bit.rol( 1, 32 ) ).to.equal( 1 )
+                expect( bit.rol( 16, 16 ) ).to.equal( 1048576 )
+            end
+        },
+
+        {
+            name = "Throws error when not given a number",
+            func = function()
+                expect( bit.rol, nil, 1 ).to.errWith( [[bad argument #1 to '?' (number expected, got nil)]] )
+                expect( bit.rol, 1, nil ).to.errWith( [[bad argument #2 to '?' (number expected, got no value)]] )
+
+                expect( bit.rol, "abc", 1 ).to.errWith( [[bad argument #1 to '?' (number expected, got string)]] )
+                expect( bit.rol, 1, "def" ).to.errWith( [[bad argument #2 to '?' (number expected, got string)]] )
+
+                expect( bit.rol, {}, 1 ).to.errWith( [[bad argument #1 to '?' (number expected, got table)]] )
+                expect( bit.rol, 1, {} ).to.errWith( [[bad argument #2 to '?' (number expected, got table)]] )
+            end
+        },
+    }
+}
\ No newline at end of file
diff --git a/lua/tests/gmod/unit/libraries/bit/ror.lua b/lua/tests/gmod/unit/libraries/bit/ror.lua
new file mode 100644
index 0000000..2b5168c
--- /dev/null
+++ b/lua/tests/gmod/unit/libraries/bit/ror.lua
@@ -0,0 +1,59 @@
+--- @type GLuaTest_TestGroup
+return {
+    groupName = "bit.ror",
+    cases = {
+        {
+            name = "Function exists",
+            func = function()
+                expect( bit.ror ).to.beA( "function" )
+            end
+        },
+
+        {
+            name = "Rotating positive numbers returning the correct values",
+            func = function()
+                expect( bit.ror( 8, 1 ) ).to.equal( 4 )
+                expect( bit.ror( 16, 1 ) ).to.equal( 8 )
+                expect( bit.ror( 469, 4 ) ).to.equal( 1342177309 )
+            end
+        },
+
+        {
+            name = "Rotating negative numbers returning the correct values",
+            func = function()
+                expect( bit.ror( -8, 1 ) ).to.equal( 2147483644 )
+                expect( bit.ror( -16, 1 ) ).to.equal( 2147483640 )
+                expect( bit.ror( -469, 4 ) ).to.equal( -1073741854 )
+            end
+        },
+
+        {
+            name = "Returning input value on 0 rotations",
+            func = function()
+                expect( bit.ror( 412, 0 ) ).to.equal( 412 )
+            end
+        },
+
+        {
+            name = "Functions properly when rotating over the limit",
+            func = function()
+                expect( bit.ror( 1, 32 ) ).to.equal( 1 )
+                expect( bit.ror( 16, 16 ) ).to.equal( 1048576 )
+            end
+        },
+
+        {
+            name = "Throws error when not given a number",
+            func = function()
+                expect( bit.ror, nil, 1 ).to.errWith( [[bad argument #1 to '?' (number expected, got nil)]] )
+                expect( bit.ror, 1, nil ).to.errWith( [[bad argument #2 to '?' (number expected, got no value)]] )
+
+                expect( bit.ror, "abc", 1 ).to.errWith( [[bad argument #1 to '?' (number expected, got string)]] )
+                expect( bit.ror, 1, "def" ).to.errWith( [[bad argument #2 to '?' (number expected, got string)]] )
+
+                expect( bit.ror, {}, 1 ).to.errWith( [[bad argument #1 to '?' (number expected, got table)]] )
+                expect( bit.ror, 1, {} ).to.errWith( [[bad argument #2 to '?' (number expected, got table)]] )
+            end
+        },
+    }
+}
\ No newline at end of file
diff --git a/lua/tests/gmod/unit/libraries/bit/rshift.lua b/lua/tests/gmod/unit/libraries/bit/rshift.lua
new file mode 100644
index 0000000..ec548d5
--- /dev/null
+++ b/lua/tests/gmod/unit/libraries/bit/rshift.lua
@@ -0,0 +1,56 @@
+--- @type GLuaTest_TestGroup
+return {
+    groupName = "bit.rshift",
+    cases = {
+        {
+            name = "Functions exists",
+            func = function()
+                expect( bit.rshift ).to.beA( "function" )
+            end
+        },
+
+        {
+            name = "Returns the correct values",
+            func = function()
+                expect( bit.rshift( 8, 1 ) ).to.equal( 4 )
+                expect( bit.rshift( 16, 2 ) ).to.equal( 4 )
+            end
+        },
+
+        {
+            name = "Returns the correct valueswith negative input numbers",
+            func = function()
+                expect( bit.rshift( -8, 1 ) ).to.equal( 2147483644 )
+                expect( bit.rshift( -16, 2 ) ).to.equal( 1073741820 )
+            end
+        },
+
+        {
+            name = "Correctly handles shifting the number 0",
+            func = function()
+                expect( bit.rshift( 0, 1 ) ).to.equal( 0 )
+            end
+        },
+
+        {
+            name = "Correctly handles shifting a number 0 times",
+            func = function()
+                expect( bit.rshift( 312, 0 ) ).to.equal( 312 )
+            end
+        },
+
+        {
+            name = "Throws error when not given a number",
+            func = function()
+                expect( bit.rshift, nil, 1 ).to.errWith( [[bad argument #1 to '?' (number expected, got nil)]] )
+                expect( bit.rshift, 1, nil ).to.errWith( [[bad argument #2 to '?' (number expected, got no value)]] )
+
+                expect( bit.rshift, "abc", 1 ).to.errWith( [[bad argument #1 to '?' (number expected, got string)]] )
+                expect( bit.rshift, 1, "def" ).to.errWith( [[bad argument #2 to '?' (number expected, got string)]] )
+
+                expect( bit.rshift, {}, 1 ).to.errWith( [[bad argument #1 to '?' (number expected, got table)]] )
+                expect( bit.rshift, 1, {} ).to.errWith( [[bad argument #2 to '?' (number expected, got table)]] )
+            end
+        },
+    }
+}
\ No newline at end of file
diff --git a/lua/tests/gmod/unit/libraries/bit/tobit.lua b/lua/tests/gmod/unit/libraries/bit/tobit.lua
new file mode 100644
index 0000000..ebe103c
--- /dev/null
+++ b/lua/tests/gmod/unit/libraries/bit/tobit.lua
@@ -0,0 +1,45 @@
+--- @type GLuaTest_TestGroup
+return {
+    groupName = "bit.tobit",
+    cases = {
+        {
+            name = "Functions exists",
+            func = function()
+                expect( bit.tobit ).to.beA( "function" )
+            end
+        },
+
+        {
+            name = "Correctly returns unchanged values",
+            func = function()
+                expect( bit.tobit( 1 ) ).to.equal(1)
+                expect( bit.tobit( -1 ) ).to.equal(-1)
+            end
+        },
+
+        {
+            name = "Behaves correctly when handling large numbers",
+            func = function()
+                expect( bit.tobit( 2147483647 ) ).to.equal(2147483647)
+                expect( bit.tobit( 2147483648 ) ).to.equal(-2147483648)
+            end
+        },
+
+        {
+            name = "Handles Non-integer values",
+            func = function()
+                expect( bit.tobit( 1.1 ) ).to.equal(1)
+                expect( bit.tobit( -1 ) ).to.equal(-1)
+            end
+        },
+
+        {
+            name = "Throws error when not given a number",
+            func = function()
+                expect( bit.tobit, nil ).to.errWith( [[bad argument #1 to '?' (number expected, got no value)]] )
+                expect( bit.tobit, "abc" ).to.errWith( [[bad argument #1 to '?' (number expected, got string)]] )
+                expect( bit.tobit, {} ).to.errWith( [[bad argument #1 to '?' (number expected, got table)]] )
+            end
+        },
+    }
+}
\ No newline at end of file
diff --git a/lua/tests/gmod/unit/libraries/bit/tohex.lua b/lua/tests/gmod/unit/libraries/bit/tohex.lua
new file mode 100644
index 0000000..fa9d233
--- /dev/null
+++ b/lua/tests/gmod/unit/libraries/bit/tohex.lua
@@ -0,0 +1,42 @@
+--- @type GLuaTest_TestGroup
+return {
+    groupName = "bit.tohex",
+    cases = {
+        {
+            name = "Functions exists",
+            func = function()
+                expect( bit.tohex ).to.beA( "function" )
+            end
+        },
+
+        {
+            name = "Correctly handles positive numbers",
+            func = function()
+                expect( bit.tohex( 255 ) ).to.equal( "000000ff" )
+                expect( bit.tohex( 255, 4 ) ).to.equal( "00ff" )
+            end
+        },
+
+        {
+            name = "Correctly handles negative numbers",
+            func = function()
+                expect( bit.tohex( -1 ) ).to.equal( "ffffffff" )
+                expect( bit.tohex( -2 ) ).to.equal( "fffffffe" )
+            end
+        },
+
+        {
+            name = "Throws error when not given a number",
+            func = function()
+                expect( bit.tohex, nil, 1 ).to.errWith( [[bad argument #1 to '?' (number expected, got nil)]] )
+                expect( bit.tohex, 1, nil ).toNot.err()
+
+                expect( bit.tohex, "abc", 1 ).to.errWith( [[bad argument #1 to '?' (number expected, got string)]] )
+                expect( bit.tohex, 1, "def" ).to.errWith( [[bad argument #2 to '?' (number expected, got string)]] )
+
+                expect( bit.tohex, {}, 1 ).to.errWith( [[bad argument #1 to '?' (number expected, got table)]] )
+                expect( bit.tohex, 1, {} ).to.errWith( [[bad argument #2 to '?' (number expected, got table)]] )
+            end
+        },
+    }
+}
\ No newline at end of file