finished test suite and added coverage script

Author: aeldidi

.gitignore

@@ -3,3 +3,8 @@ test.o
 test.exe
 test.obj
 test
+coverage-html
+*.gcov
+*.gcda
+*.gcno
+coverage.info

README.md

@@ -1,4 +1,4 @@
-128 Bit Integer Library For C
+128-Bit Integer Library For C
 =============================
 
 Simply include `int128.h` to use `int128` or `uint128`. Each operation on these

gen_coverage.sh

@@ -0,0 +1,8 @@
+#! /usr/bin/env sh
+# requires gcc with coverage support, gcov, lcov, and genhtml
+
+gcc -Wall -pedantic-errors -std=c99 -Werror -fsanitize=address,undefined -g test.c -o test --coverage
+./test
+gcov test.c
+lcov --capture --directory . --output-file coverage.info --rc lcov_branch_coverage=1
+genhtml coverage.info --output-directory coverage-html --rc genhtml_branch_coverage=1 

int128.h

@@ -284,9 +284,15 @@ static inline int128 int128_shiftr(int128 lhs, int rhs)
 		return (int128){ .low = result.low, .high = result.high };
 	}
 
-	if (rhs >= 64) {
+	if (rhs > 64) {
+		return (int128){
+			.low = (lhs.high >> (rhs - 64)) |
+			       (UINT64_C(~0) << (64 - (rhs - 64))),
+			.high = UINT64_C(~0),
+		};
+	} else if (rhs == 64) {
 		return (int128){
-			.low = (lhs.high >> (rhs - 64)) | (UINT64_C(~0) << rhs),
+			.low = lhs.high,
 			.high = UINT64_C(~0),
 		};
 	}
@@ -491,7 +497,7 @@ static inline uint128 uint128_div(uint128 lhs, uint128 rhs)
 }
 
 // Returns lhs % rhs.
-static inline uint128 uint128_mod(uint128 lhs, uint128 rhs)
+static inline uint128 uint128_rem(uint128 lhs, uint128 rhs)
 {
 	// Based on the algorithm described here:
 	// https://stackoverflow.com/questions/5386377/division-without-using
@@ -531,6 +537,10 @@ static inline uint128 uint128_mod(uint128 lhs, uint128 rhs)
 static inline int128 int128_div(int128 lhs, int128 rhs)
 {
 	// signed integers aren't symmetric. INT128_MIN == (-INT128_MAX) - 1
+	if (int128_eq(lhs, rhs) && int128_eq(lhs, INT128_MIN)) {
+		return INT128_C(1);
+	}
+
 	if (int128_eq(lhs, INT128_MIN)) {
 		return INT128_C(0);
 	}
@@ -559,30 +569,33 @@ static inline int128 int128_div(int128 lhs, int128 rhs)
 }
 
 // Returns lhs % rhs.
-static inline int128 int128_mod(int128 lhs, int128 rhs)
+static inline int128 int128_rem(int128 lhs, int128 rhs)
 {
 	// signed integers aren't symmetric. INT128_MIN == (-INT128_MAX) - 1
 	if (int128_eq(lhs, INT128_MIN)) {
 		return INT128_C(0);
 	}
 
+	if (int128_eq(rhs, INT128_MIN)) {
+		return lhs;
+	}
+
 	bool result_negative = false;
 	if (int128_less(lhs, INT128_C(0))) {
-		result_negative = !result_negative;
+		result_negative = true;
 		lhs = int128_neg(lhs);
 	}
 
 	if (int128_less(rhs, INT128_C(0))) {
-		result_negative = !result_negative;
 		rhs = int128_neg(rhs);
 	}
 
 	uint128 a = { .low = lhs.low, .high = lhs.high };
 	uint128 b = { .low = rhs.low, .high = rhs.high };
-	uint128 c = uint128_mod(a, b);
+	uint128 c = uint128_rem(a, b);
 	int128 result = { .low = c.low, .high = c.high };
 
-	if (result_negative) {
+	if (result_negative && int128_greater(result, INT128_C(0))) {
 		return int128_neg(result);
 	}
 

test.c

@@ -4,16 +4,6 @@
 
 #include "int128.h"
 
-// void int128_printhex(char *name, int128 x)
-// {
-// 	printf("%s = %016" PRIx64 " %016" PRIx64 "\n", name, x.high, x.low);
-// }
-//
-// void uint128_printhex(char *name, uint128 x)
-// {
-// 	printf("%s = %016" PRIx64 " %016" PRIx64 "\n", name, x.high, x.low);
-// }
-
 void int128_tests()
 {
 	// Left Shift
@@ -25,12 +15,28 @@ void int128_tests()
 	b = int128_shiftr(a, 1);
 	assert(b.low == (UINT64_C(1) << 63));
 
+	// Left shift of more than 63 bits?
+	assert(int128_eq(int128_shiftl(INT128_C(1), 64),
+			 (int128){ .high = 1 }));
+
 	// Right Shift
 	// For int128, this should be an arithmetic shift, meaning the sign bit
 	// is preserved.
 	a = INT128_C(-8);
 	assert(int128_less(int128_shiftr(a, 1), INT128_C(0)));
 
+	// Right shift of more than 63 bits?
+	assert(int128_eq(int128_shiftr((int128){ .high = 1 }, 64),
+			 INT128_C(1)));
+	assert(int128_eq(int128_shiftr((int128){ .high = 0xfffffffffffffffe,
+						 .low = UINT64_MAX },
+				       64),
+			 INT128_C(-2)));
+	assert(int128_eq(int128_shiftr((int128){ .high = 0xbfffffffffffffff,
+						 .low = UINT64_MAX },
+				       126),
+			 INT128_C(-2)));
+
 	// Negation Sanity Check
 	assert(int128_eq(int128_neg(INT128_MAX),
 			 int128_add(INT128_MIN, INT128_C(1))));
@@ -77,6 +83,8 @@ void int128_tests()
 			 int128_mul(INT128_MAX, INT128_C(-1))));
 	assert(int128_eq(int128_neg(INT128_MIN),
 			 int128_mul(INT128_MIN, INT128_C(-1))));
+	assert(int128_eq(int128_neg(INT128_MIN),
+			 int128_mul(INT128_C(-1), INT128_MIN)));
 
 	// Fun fact: INT128_MAX (170141183460469231731687303715884105727) is
 	// prime :)
@@ -86,15 +94,69 @@ void int128_tests()
 	b = int128_div(a, INT128_C(2));
 	assert(int128_eq(b, (int128){ .high = 100000000 }));
 
-	// Modulo Sanity Check
+	// INT128_MIN divided by anything is 0, since INT128_MIN is less than
+	// every other number...
+	assert(int128_eq(int128_div(INT128_MIN, INT128_C(-123456789)),
+			 INT128_C(0)));
+
+	// Except for when dividing INT128_MIN by INT128_MIN, which should be
+	// 1.
+	assert(int128_eq(int128_div(INT128_MIN, INT128_MIN), INT128_C(1)));
+
+	// Check to make sure the sign is preserved properly:
+	// - / - = +
+	// - / + = -
+	// + / - = -
+	// + / + = +
+
+	a = INT128_C(1);
+	b = INT128_C(-1);
+	assert(int128_eq(int128_div(b, b), a));
+	assert(int128_eq(int128_div(b, a), b));
+	assert(int128_eq(int128_div(a, b), b));
+	assert(int128_eq(int128_div(a, a), a));
+
+	// And of course anytime the denominator is greater than the numerator
+	// the result is also 0.
+	assert(int128_eq(int128_div(INT128_C(1), INT128_C(2)), INT128_C(0)));
+
+	// Remainder Sanity Check
 	// 85070591730234615865843651857942052863 % 1234567890 = 1122498603
 	a = int128_div(int128_sub(INT128_MAX, INT128_C(1)), INT128_C(2));
 	b = INT128_C(1234567890);
-	assert(int128_eq(int128_mod(a, b), INT128_C(1122498603)));
+	assert(int128_eq(int128_rem(a, b), INT128_C(1122498603)));
+
+	a = int128_div(int128_sub(INT128_MAX, INT128_C(1)), INT128_C(2));
+	b = INT128_C(-1234567890);
+
+	// The remainder operation has the same sign as the left hand side.
+	assert(int128_eq(int128_rem(a, b), INT128_C(1122498603)));
+	a = int128_neg(a);
+	assert(int128_eq(int128_rem(a, b), INT128_C(-1122498603)));
+
+	// The remainder of anything divided by INT128_MIN is the left hand
+	// side...
+	assert(int128_eq(int128_rem(INT128_C(-1), INT128_MIN), INT128_C(-1)));
+
+	// Except for when the left hand side is INT128_MIN, in which case the
+	// remainder is 0.
+	assert(int128_eq(int128_rem(INT128_MIN, INT128_MIN), INT128_C(0)));
+
+	// This applies to all numbers.
+	assert(int128_eq(int128_rem(INT128_C(1), INT128_C(1)), INT128_C(0)));
+
+	// When both the numerator and denominator are positive, if the
+	// denominator is greater than the numerator the result is just the
+	// numerator.
+	assert(int128_eq(int128_rem(INT128_C(1), INT128_C(2)), INT128_C(1)));
 }
 
 void uint128_tests()
 {
+	// For most functions, the same logic is used for positive int128 and
+	// uint128, so we only need to test things which we can't use int128 to
+	// test, like large multiplication overflow.
+
 	// Multiplication Sanity Check
 	uint128 a = (uint128){ .high = 100000000 };
 	uint128 b = uint128_mul(a, UINT128_C(2));
@@ -122,6 +184,16 @@ void uint128_tests()
 	};
 
 	assert(uint128_eq(b, correct));
+
+	// Right Shift Sanity Check
+	// For unsigned integers, the most significant bit should not be
+	// preserved.
+	a = (uint128){ .high = UINT64_C(1) << 63 };
+	assert(uint128_eq(uint128_shiftr(a, 1),
+			  (uint128){ .high = UINT64_C(1) << 62 }));
+
+	// uint128_less when high bits are equal?
+	assert(uint128_less(UINT128_C(2), UINT128_C(5)));
 }
 
 int main()