Add some tests and fix mistakes

Signed-off-by: Mattias Andrée <m@maandree.se>

10 files changed, 832 insertions, 23 deletions

diff --git a/libj2/mixed-comparsion.h b/libj2/mixed-comparsion.h
index 2d07956..dedf18d 100644
--- a/libj2/mixed-comparsion.h
+++ b/libj2/mixed-comparsion.h
@@ -427,7 +427,7 @@ libj2_ji_cmp_j2u(intmax_t a, const struct libj2_j2u *b)
 LIBJ2_PURE_ inline int
 libj2_ju_lt_j2i(uintmax_t a, const struct libj2_j2i *b)
 {
-	return libj2_j2i_is_negative(b) < 0 ? 0 : libj2_ju_lt_j2u(a, (const void *)b);
+	return libj2_j2i_is_negative(b) ? 0 : libj2_ju_lt_j2u(a, (const void *)b);
 }
 
 
@@ -446,7 +446,7 @@ libj2_ju_lt_j2i(uintmax_t a, const struct libj2_j2i *b)
 LIBJ2_PURE_ inline int
 libj2_ju_le_j2i(uintmax_t a, const struct libj2_j2i *b)
 {
-	return libj2_j2i_is_negative(b) < 0 ? 0 : libj2_ju_le_j2u(a, (const void *)b);
+	return libj2_j2i_is_negative(b) ? 0 : libj2_ju_le_j2u(a, (const void *)b);
 }
 
 
@@ -465,7 +465,7 @@ libj2_ju_le_j2i(uintmax_t a, const struct libj2_j2i *b)
 LIBJ2_PURE_ inline int
 libj2_ju_gt_j2i(uintmax_t a, const struct libj2_j2i *b)
 {
-	return libj2_j2i_is_negative(b) < 0 ? 1 : libj2_ju_gt_j2u(a, (const void *)b);
+	return libj2_j2i_is_negative(b) ? 1 : libj2_ju_gt_j2u(a, (const void *)b);
 }
 
 
@@ -484,7 +484,7 @@ libj2_ju_gt_j2i(uintmax_t a, const struct libj2_j2i *b)
 LIBJ2_PURE_ inline int
 libj2_ju_ge_j2i(uintmax_t a, const struct libj2_j2i *b)
 {
-	return libj2_j2i_is_negative(b) < 0 ? 1 : libj2_ju_ge_j2u(a, (const void *)b);
+	return libj2_j2i_is_negative(b) ? 1 : libj2_ju_ge_j2u(a, (const void *)b);
 }
 
 
@@ -503,7 +503,7 @@ libj2_ju_ge_j2i(uintmax_t a, const struct libj2_j2i *b)
 LIBJ2_PURE_ inline int
 libj2_ju_eq_j2i(uintmax_t a, const struct libj2_j2i *b)
 {
-	return libj2_j2i_is_negative(b) < 0 ? 0 : libj2_ju_eq_j2u(a, (const void *)b);
+	return libj2_j2i_is_negative(b) ? 0 : libj2_ju_eq_j2u(a, (const void *)b);
 }
 
 
@@ -522,7 +522,7 @@ libj2_ju_eq_j2i(uintmax_t a, const struct libj2_j2i *b)
 LIBJ2_PURE_ inline int
 libj2_ju_ne_j2i(uintmax_t a, const struct libj2_j2i *b)
 {
-	return libj2_j2i_is_negative(b) < 0 ? 1 : libj2_ju_ne_j2u(a, (const void *)b);
+	return libj2_j2i_is_negative(b) ? 1 : libj2_ju_ne_j2u(a, (const void *)b);
 }
 
 
@@ -544,7 +544,7 @@ libj2_ju_ne_j2i(uintmax_t a, const struct libj2_j2i *b)
 LIBJ2_PURE_ inline int
 libj2_ju_cmp_j2i(uintmax_t a, const struct libj2_j2i *b)
 {
-	return libj2_j2i_is_negative(b) < 0 ? +1 : libj2_ju_cmp_j2u(a, (const void *)b);
+	return libj2_j2i_is_negative(b) ? +1 : libj2_ju_cmp_j2u(a, (const void *)b);
 }
 
 
diff --git a/libj2_abs_j2i.c b/libj2_abs_j2i.c
index 253f44d..999ff8b 100644
--- a/libj2_abs_j2i.c
+++ b/libj2_abs_j2i.c
@@ -8,7 +8,153 @@ extern inline void libj2_abs_j2i(struct libj2_j2i *a);
 
 #else
 
-CONST int main(void) { return 0; }
-/* TODO test libj2_abs_j2i{,_to_j2i,_to_j2u} libj2_minus_abs_j2i{,_to_j2i} */
+
+static void
+check(uintmax_t high, uintmax_t low)
+{
+	struct libj2_j2i a, r;
+	struct libj2_j2u u;
+
+	a.high = high;
+	a.low = low;
+	libj2_abs_j2i(&a);
+	EXPECT(a.high == high);
+	EXPECT(a.low == low);
+	libj2_minus_j2i(&a);
+	libj2_abs_j2i(&a);
+	EXPECT(a.high == high);
+	EXPECT(a.low == low);
+
+	r = (struct libj2_j2i){111, 222};
+	a.high = high;
+	a.low = low;
+	libj2_abs_j2i_to_j2i((const struct libj2_j2i *)&a, &r);
+	EXPECT(a.high == high);
+	EXPECT(a.low == low);
+	EXPECT(libj2_j2i_eq_j2i(&a, &r));
+	libj2_minus_j2i(&a);
+	libj2_abs_j2i_to_j2i((const struct libj2_j2i *)&a, &r);
+	libj2_minus_j2i(&a);
+	EXPECT(a.high == high);
+	EXPECT(a.low == low);
+	EXPECT(libj2_j2i_eq_j2i(&a, &r));
+
+	u = (struct libj2_j2u){111, 222};
+	a.high = high;
+	a.low = low;
+	libj2_abs_j2i_to_j2u((const struct libj2_j2i *)&a, &u);
+	EXPECT(a.high == high);
+	EXPECT(a.low == low);
+	EXPECT(libj2_j2i_eq_j2u(&a, &u));
+	libj2_minus_j2i(&a);
+	libj2_abs_j2i_to_j2u((const struct libj2_j2i *)&a, &u);
+	libj2_minus_j2i(&a);
+	EXPECT(a.high == high);
+	EXPECT(a.low == low);
+	EXPECT(libj2_j2i_eq_j2u(&a, &u));
+
+	a.high = high;
+	a.low = low;
+	libj2_minus_abs_j2i(&a);
+	libj2_minus_j2i(&a);
+	EXPECT(a.high == high);
+	EXPECT(a.low == low);
+	libj2_minus_j2i(&a);
+	libj2_minus_abs_j2i(&a);
+	libj2_minus_j2i(&a);
+	EXPECT(a.high == high);
+	EXPECT(a.low == low);
+
+	r = (struct libj2_j2i){111, 222};
+	a.high = high;
+	a.low = low;
+	libj2_minus_abs_j2i_to_j2i((const struct libj2_j2i *)&a, &r);
+	libj2_minus_j2i(&r);
+	EXPECT(a.high == high);
+	EXPECT(a.low == low);
+	EXPECT(libj2_j2i_eq_j2i(&a, &r));
+	libj2_minus_j2i(&a);
+	libj2_minus_abs_j2i_to_j2i((const struct libj2_j2i *)&a, &r);
+	libj2_minus_j2i(&a);
+	libj2_minus_j2i(&r);
+	EXPECT(a.high == high);
+	EXPECT(a.low == low);
+	EXPECT(libj2_j2i_eq_j2i(&a, &r));
+}
+
+
+static void
+check_min(void)
+{
+	const uintmax_t high = ~(UINTMAX_MAX >> 1);
+	const uintmax_t low = 0;
+	struct libj2_j2i a, r;
+	struct libj2_j2u u;
+
+	a.high = high;
+	a.low = low;
+	libj2_abs_j2i(&a);
+	EXPECT(a.high == high);
+	EXPECT(a.low == low);
+
+	r = (struct libj2_j2i){111, 222};
+	a.high = high;
+	a.low = low;
+	libj2_abs_j2i_to_j2i((const struct libj2_j2i *)&a, &r);
+	EXPECT(a.high == high);
+	EXPECT(a.low == low);
+	EXPECT(libj2_j2i_eq_j2i(&a, &r));
+
+	u = (struct libj2_j2u){111, 222};
+	a.high = high;
+	a.low = low;
+	libj2_abs_j2i_to_j2u((const struct libj2_j2i *)&a, &u);
+	EXPECT(a.high == high);
+	EXPECT(a.low == low);
+	EXPECT(libj2_j2u_eq_j2u((const void *)&a, &u));
+
+	a.high = high;
+	a.low = low;
+	libj2_minus_abs_j2i(&a);
+	libj2_minus_j2i(&a);
+	EXPECT(a.high == high);
+	EXPECT(a.low == low);
+
+	r = (struct libj2_j2i){111, 222};
+	a.high = high;
+	a.low = low;
+	libj2_minus_abs_j2i_to_j2i((const struct libj2_j2i *)&a, &r);
+	libj2_minus_j2i(&r);
+	EXPECT(a.high == high);
+	EXPECT(a.low == low);
+	EXPECT(libj2_j2i_eq_j2i(&a, &r));
+}
+
+
+int
+main(void)
+{
+	check(0, 0);
+	check(0, 1);
+	check(1, 0);
+	check(1, 1);
+	check(1, 2);
+	check(0, UINTMAX_MAX - 0U);
+	check(0, UINTMAX_MAX - 1U);
+	check(1, UINTMAX_MAX - 0U);
+	check(1, UINTMAX_MAX - 1U);
+	check((UINTMAX_MAX >> 1) - 0U, 0);
+	check((UINTMAX_MAX >> 1) - 0U, 1);
+	check((UINTMAX_MAX >> 1) - 0U, UINTMAX_MAX - 0U);
+	check((UINTMAX_MAX >> 1) - 0U, UINTMAX_MAX - 1U);
+	check((UINTMAX_MAX >> 1) - 1U, 0);
+	check((UINTMAX_MAX >> 1) - 1U, 01);
+	check((UINTMAX_MAX >> 1) - 1U, UINTMAX_MAX - 0U);
+	check((UINTMAX_MAX >> 1) - 1U, UINTMAX_MAX - 1U);
+
+	check_min();
+
+	return 0;
+}
 
 #endif
diff --git a/libj2_j2i_cmp_j2u.c b/libj2_j2i_cmp_j2u.c
index 9e59d12..d8071a7 100644
--- a/libj2_j2i_cmp_j2u.c
+++ b/libj2_j2i_cmp_j2u.c
@@ -8,7 +8,242 @@ extern inline int libj2_j2i_cmp_j2u(const struct libj2_j2i *a, const struct libj
 
 #else
 
-CONST int main(void) { return 0; }
-/* TODO test libj2_j2u_cmp_j2i, libj2_j2i_cmp_j2u */
+static int
+cmp_(uintmax_t a_high, uintmax_t a_low, uintmax_t b_high, uintmax_t b_low)
+{
+	struct libj2_j2i a;
+	struct libj2_j2u b;
+	int ret;
+
+	a.high = a_high;
+	a.low = a_low;
+	b.high = b_high;
+	b.low = b_low;
+
+	ret = libj2_j2i_cmp_j2u(&a, &b);
+	EXPECT(a.high == a_high);
+	EXPECT(a.low == a_low);
+	EXPECT(b.high == b_high);
+	EXPECT(b.low == b_low);
+
+	EXPECT(libj2_j2i_lt_j2u(&a, &b) == (ret < 0));
+	EXPECT(a.high == a_high);
+	EXPECT(a.low == a_low);
+	EXPECT(b.high == b_high);
+	EXPECT(b.low == b_low);
+
+	EXPECT(libj2_j2i_le_j2u(&a, &b) == (ret <= 0));
+	EXPECT(a.high == a_high);
+	EXPECT(a.low == a_low);
+	EXPECT(b.high == b_high);
+	EXPECT(b.low == b_low);
+
+	EXPECT(libj2_j2i_gt_j2u(&a, &b) == (ret > 0));
+	EXPECT(a.high == a_high);
+	EXPECT(a.low == a_low);
+	EXPECT(b.high == b_high);
+	EXPECT(b.low == b_low);
+
+	EXPECT(libj2_j2i_ge_j2u(&a, &b) == (ret >= 0));
+	EXPECT(a.high == a_high);
+	EXPECT(a.low == a_low);
+	EXPECT(b.high == b_high);
+	EXPECT(b.low == b_low);
+
+	EXPECT(libj2_j2i_eq_j2u(&a, &b) == (ret == 0));
+	EXPECT(a.high == a_high);
+	EXPECT(a.low == a_low);
+	EXPECT(b.high == b_high);
+	EXPECT(b.low == b_low);
+
+	EXPECT(libj2_j2i_ne_j2u(&a, &b) == (ret != 0));
+	EXPECT(a.high == a_high);
+	EXPECT(a.low == a_low);
+	EXPECT(b.high == b_high);
+	EXPECT(b.low == b_low);
+
+	EXPECT(libj2_j2u_cmp_j2i(&b, &a) == (ret ? -ret : 0));
+	EXPECT(a.high == a_high);
+	EXPECT(a.low == a_low);
+	EXPECT(b.high == b_high);
+	EXPECT(b.low == b_low);
+
+	EXPECT(libj2_j2u_lt_j2i(&b, &a) == (ret > 0));
+	EXPECT(a.high == a_high);
+	EXPECT(a.low == a_low);
+	EXPECT(b.high == b_high);
+	EXPECT(b.low == b_low);
+
+	EXPECT(libj2_j2u_le_j2i(&b, &a) == (ret >= 0));
+	EXPECT(a.high == a_high);
+	EXPECT(a.low == a_low);
+	EXPECT(b.high == b_high);
+	EXPECT(b.low == b_low);
+
+	EXPECT(libj2_j2u_gt_j2i(&b, &a) == (ret < 0));
+	EXPECT(a.high == a_high);
+	EXPECT(a.low == a_low);
+	EXPECT(b.high == b_high);
+	EXPECT(b.low == b_low);
+
+	EXPECT(libj2_j2u_ge_j2i(&b, &a) == (ret <= 0));
+	EXPECT(a.high == a_high);
+	EXPECT(a.low == a_low);
+	EXPECT(b.high == b_high);
+	EXPECT(b.low == b_low);
+
+	EXPECT(libj2_j2u_eq_j2i(&b, &a) == (ret == 0));
+	EXPECT(a.high == a_high);
+	EXPECT(a.low == a_low);
+	EXPECT(b.high == b_high);
+	EXPECT(b.low == b_low);
+
+	EXPECT(libj2_j2u_ne_j2i(&b, &a) == (ret != 0));
+	EXPECT(a.high == a_high);
+	EXPECT(a.low == a_low);
+	EXPECT(b.high == b_high);
+	EXPECT(b.low == b_low);
+
+	return ret;
+}
+
+
+static int
+cmp(uintmax_t a_high, uintmax_t a_low, uintmax_t b_high, uintmax_t b_low)
+{
+	struct libj2_j2i a;
+	int ret;
+
+	a.high = a_high;
+	a.low = a_low;
+
+	ret = cmp_(a.high, a.low, b_high, b_low);
+
+	if (a.high || a.low) {
+		libj2_minus_j2i(&a);
+		EXPECT(cmp_(a.high, a.low, b_high, b_low) == -1);
+	}
+
+	return ret;
+}
+
+
+int
+main(void)
+{
+	const uintmax_t umax = UINTMAX_MAX;
+	const uintmax_t max = UINTMAX_MAX >> 1;
+
+	EXPECT(cmp(0, 0, 0, 0) == 0);
+	EXPECT(cmp(0, 0, 0, 1) == -1);
+	EXPECT(cmp(0, 0, 1, 0) == -1);
+	EXPECT(cmp(0, 0, 1, 1) == -1);
+	EXPECT(cmp(0, 0, 0, umax) == -1);
+	EXPECT(cmp(0, 0, max, 0) == -1);
+	EXPECT(cmp(0, 0, max, umax) == -1);
+	EXPECT(cmp(0, 0, max, umax - 1U) == -1);
+	EXPECT(cmp(0, 0, umax, 0) == -1);
+	EXPECT(cmp(0, 0, umax, umax) == -1);
+	EXPECT(cmp(0, 0, umax, umax - 1U) == -1);
+
+	EXPECT(cmp(0, 1, 0, 0) == +1);
+	EXPECT(cmp(0, 1, 0, 1) == 0);
+	EXPECT(cmp(0, 1, 1, 0) == -1);
+	EXPECT(cmp(0, 1, 1, 1) == -1);
+	EXPECT(cmp(0, 1, 0, umax) == -1);
+	EXPECT(cmp(0, 1, max, 0) == -1);
+	EXPECT(cmp(0, 1, max, umax) == -1);
+	EXPECT(cmp(0, 1, max, umax - 1U) == -1);
+	EXPECT(cmp(0, 1, umax, 0) == -1);
+	EXPECT(cmp(0, 1, umax, umax) == -1);
+	EXPECT(cmp(0, 1, umax, umax - 1U) == -1);
+
+	EXPECT(cmp(1, 0, 0, 0) == +1);
+	EXPECT(cmp(1, 0, 0, 1) == +1);
+	EXPECT(cmp(1, 0, 1, 0) == 0);
+	EXPECT(cmp(1, 0, 1, 1) == -1);
+	EXPECT(cmp(1, 0, 0, umax) == +1);
+	EXPECT(cmp(1, 0, max, 0) == -1);
+	EXPECT(cmp(1, 0, max, umax) == -1);
+	EXPECT(cmp(1, 0, max, umax - 1U) == -1);
+	EXPECT(cmp(1, 0, umax, 0) == -1);
+	EXPECT(cmp(1, 0, umax, umax) == -1);
+	EXPECT(cmp(1, 0, umax, umax - 1U) == -1);
+
+	EXPECT(cmp(1, 1, 0, 0) == +1);
+	EXPECT(cmp(1, 1, 0, 1) == +1);
+	EXPECT(cmp(1, 1, 1, 0) == +1);
+	EXPECT(cmp(1, 1, 1, 1) == 0);
+	EXPECT(cmp(1, 1, 0, umax) == +1);
+	EXPECT(cmp(1, 1, max, 0) == -1);
+	EXPECT(cmp(1, 1, max, umax) == -1);
+	EXPECT(cmp(1, 1, max, umax - 1U) == -1);
+	EXPECT(cmp(1, 1, umax, 0) == -1);
+	EXPECT(cmp(1, 1, umax, umax) == -1);
+	EXPECT(cmp(1, 1, umax, umax - 1U) == -1);
+
+	EXPECT(cmp(0, umax, 0, 0) == +1);
+	EXPECT(cmp(0, umax, 0, 1) == +1);
+	EXPECT(cmp(0, umax, 1, 0) == -1);
+	EXPECT(cmp(0, umax, 1, 1) == -1);
+	EXPECT(cmp(0, umax, 0, umax) == 0);
+	EXPECT(cmp(0, umax, max, 0) == -1);
+	EXPECT(cmp(0, umax, max, umax) == -1);
+	EXPECT(cmp(0, umax, max, umax - 1U) == -1);
+	EXPECT(cmp(0, umax, umax, 0) == -1);
+	EXPECT(cmp(0, umax, umax, umax) == -1);
+	EXPECT(cmp(0, umax, umax, umax - 1U) == -1);
+
+	EXPECT(cmp(max, 0, 0, 0) == +1);
+	EXPECT(cmp(max, 0, 0, 1) == +1);
+	EXPECT(cmp(max, 0, 1, 0) == +1);
+	EXPECT(cmp(max, 0, 1, 1) == +1);
+	EXPECT(cmp(max, 0, 0, umax) == +1);
+	EXPECT(cmp(max, 0, max, 0) == 0);
+	EXPECT(cmp(max, 0, max, umax) == -1);
+	EXPECT(cmp(max, 0, max, umax - 1U) == -1);
+	EXPECT(cmp(max, 0, umax, 0) == -1);
+	EXPECT(cmp(max, 0, umax, umax) == -1);
+	EXPECT(cmp(max, 0, umax, umax - 1U) == -1);
+
+	EXPECT(cmp(max, umax, 0, 0) == +1);
+	EXPECT(cmp(max, umax, 0, 1) == +1);
+	EXPECT(cmp(max, umax, 1, 0) == +1);
+	EXPECT(cmp(max, umax, 1, 1) == +1);
+	EXPECT(cmp(max, umax, 0, umax) == +1);
+	EXPECT(cmp(max, umax, max, 0) == +1);
+	EXPECT(cmp(max, umax, max, umax) == 0);
+	EXPECT(cmp(max, umax, max, umax - 1U) == +1);
+	EXPECT(cmp(max, umax, umax, 0) == -1);
+	EXPECT(cmp(max, umax, umax, umax) == -1);
+	EXPECT(cmp(max, umax, umax, umax - 1U) == -1);
+
+	EXPECT(cmp(max, umax - 1U, 0, 0) == +1);
+	EXPECT(cmp(max, umax - 1U, 0, 1) == +1);
+	EXPECT(cmp(max, umax - 1U, 1, 0) == +1);
+	EXPECT(cmp(max, umax - 1U, 1, 1) == +1);
+	EXPECT(cmp(max, umax - 1U, 0, umax) == +1);
+	EXPECT(cmp(max, umax - 1U, max, 0) == +1);
+	EXPECT(cmp(max, umax - 1U, max, umax) == -1);
+	EXPECT(cmp(max, umax - 1U, max, umax - 1U) == 0);
+	EXPECT(cmp(max, umax - 1U, umax, 0) == -1);
+	EXPECT(cmp(max, umax - 1U, umax, umax) == -1);
+	EXPECT(cmp(max, umax - 1U, umax, umax - 1U) == -1);
+
+	EXPECT(cmp_(~max, 0, 0, 0) == -1);
+	EXPECT(cmp_(~max, 0, 0, 1) == -1);
+	EXPECT(cmp_(~max, 0, 1, 0) == -1);
+	EXPECT(cmp_(~max, 0, 1, 1) == -1);
+	EXPECT(cmp_(~max, 0, 0, umax) == -1);
+	EXPECT(cmp_(~max, 0, max, 0) == -1);
+	EXPECT(cmp_(~max, 0, max, umax) == -1);
+	EXPECT(cmp_(~max, 0, max, umax - 1U) == -1);
+	EXPECT(cmp_(~max, 0, umax, 0) == -1);
+	EXPECT(cmp_(~max, 0, umax, umax) == -1);
+	EXPECT(cmp_(~max, 0, umax, umax - 1U) == -1);
+	EXPECT(cmp_(~max, 0, ~max, 0) == -1);
+
+	return 0;
+}
 
 #endif
diff --git a/libj2_j2i_cmp_ju.c b/libj2_j2i_cmp_ju.c
index 2d334f8..aa29cb8 100644
--- a/libj2_j2i_cmp_ju.c
+++ b/libj2_j2i_cmp_ju.c
@@ -8,7 +8,138 @@ extern inline int libj2_j2i_cmp_ju(const struct libj2_j2i *a, uintmax_t b);
 
 #else
 
-CONST int main(void) { return 0; }
-/* TODO test libj2_j2i_cmp_ju, libj2_ju_cmp_j2i */
+static int
+cmp_(uintmax_t a_high, uintmax_t a_low, uintmax_t b)
+{
+	struct libj2_j2i a;
+	int ret;
+
+	a.high = a_high;
+	a.low = a_low;
+
+	ret = libj2_j2i_cmp_ju(&a, b);
+	EXPECT(a.high == a_high);
+	EXPECT(a.low == a_low);
+
+	EXPECT(libj2_j2i_lt_ju(&a, b) == (ret < 0));
+	EXPECT(a.high == a_high);
+	EXPECT(a.low == a_low);
+
+	EXPECT(libj2_j2i_le_ju(&a, b) == (ret <= 0));
+	EXPECT(a.high == a_high);
+	EXPECT(a.low == a_low);
+
+	EXPECT(libj2_j2i_gt_ju(&a, b) == (ret > 0));
+	EXPECT(a.high == a_high);
+	EXPECT(a.low == a_low);
+
+	EXPECT(libj2_j2i_ge_ju(&a, b) == (ret >= 0));
+	EXPECT(a.high == a_high);
+	EXPECT(a.low == a_low);
+
+	EXPECT(libj2_j2i_eq_ju(&a, b) == (ret == 0));
+	EXPECT(a.high == a_high);
+	EXPECT(a.low == a_low);
+
+	EXPECT(libj2_j2i_ne_ju(&a, b) == (ret != 0));
+	EXPECT(a.high == a_high);
+	EXPECT(a.low == a_low);
+
+	EXPECT(libj2_ju_cmp_j2i(b, &a) == (ret ? -ret : 0));
+	EXPECT(a.high == a_high);
+	EXPECT(a.low == a_low);
+
+	EXPECT(libj2_ju_lt_j2i(b, &a) == (ret > 0));
+	EXPECT(a.high == a_high);
+	EXPECT(a.low == a_low);
+
+	EXPECT(libj2_ju_le_j2i(b, &a) == (ret >= 0));
+	EXPECT(a.high == a_high);
+	EXPECT(a.low == a_low);
+
+	EXPECT(libj2_ju_gt_j2i(b, &a) == (ret < 0));
+	EXPECT(a.high == a_high);
+	EXPECT(a.low == a_low);
+
+	EXPECT(libj2_ju_ge_j2i(b, &a) == (ret <= 0));
+	EXPECT(a.high == a_high);
+	EXPECT(a.low == a_low);
+
+	EXPECT(libj2_ju_eq_j2i(b, &a) == (ret == 0));
+	EXPECT(a.high == a_high);
+	EXPECT(a.low == a_low);
+
+	EXPECT(libj2_ju_ne_j2i(b, &a) == (ret != 0));
+	EXPECT(a.high == a_high);
+	EXPECT(a.low == a_low);
+
+	return ret;
+}
+
+
+static int
+cmp(uintmax_t a_high, uintmax_t a_low, uintmax_t b)
+{
+	struct libj2_j2i a;
+	int ret;
+
+	a.high = a_high;
+	a.low = a_low;
+
+	ret = cmp_(a.high, a.low, b);
+
+	if (a.high || a.low) {
+		libj2_minus_j2i(&a);
+		EXPECT(cmp_(a.high, a.low, b) == -1);
+	}
+
+	return ret;
+}
+
+
+int
+main(void)
+{
+	const uintmax_t umax = UINTMAX_MAX;
+	const uintmax_t max = UINTMAX_MAX >> 1;
+
+	EXPECT(cmp(0, 0, 0) == 0);
+	EXPECT(cmp(0, 0, 1) == -1);
+	EXPECT(cmp(0, 0, umax) == -1);
+
+	EXPECT(cmp(0, 1, 0) == +1);
+	EXPECT(cmp(0, 1, 1) == 0);
+	EXPECT(cmp(0, 1, umax) == -1);
+
+	EXPECT(cmp(1, 0, 0) == +1);
+	EXPECT(cmp(1, 0, 1) == +1);
+	EXPECT(cmp(1, 0, umax) == +1);
+
+	EXPECT(cmp(1, 1, 0) == +1);
+	EXPECT(cmp(1, 1, 1) == +1);
+	EXPECT(cmp(1, 1, umax) == +1);
+
+	EXPECT(cmp(0, umax, 0) == +1);
+	EXPECT(cmp(0, umax, 1) == +1);
+	EXPECT(cmp(0, umax, umax) == 0);
+
+	EXPECT(cmp(max, 0, 0) == +1);
+	EXPECT(cmp(max, 0, 1) == +1);
+	EXPECT(cmp(max, 0, umax) == +1);
+
+	EXPECT(cmp(max, umax, 0) == +1);
+	EXPECT(cmp(max, umax, 1) == +1);
+	EXPECT(cmp(max, umax, umax) == +1);
+
+	EXPECT(cmp(max, umax - 1U, 0) == +1);
+	EXPECT(cmp(max, umax - 1U, 1) == +1);
+	EXPECT(cmp(max, umax - 1U, umax) == +1);
+
+	EXPECT(cmp_(~max, 0, 0) == -1);
+	EXPECT(cmp_(~max, 0, 1) == -1);
+	EXPECT(cmp_(~max, 0, umax) == -1);
+
+	return 0;
+}
 
 #endif
diff --git a/libj2_j2i_xor_sign.c b/libj2_j2i_xor_sign.c
index fd29268..6935c57 100644
--- a/libj2_j2i_xor_sign.c
+++ b/libj2_j2i_xor_sign.c
@@ -8,7 +8,105 @@ extern inline void libj2_j2i_xor_sign(struct libj2_j2i *a);
 
 #else
 
-CONST int main(void) { return 0; }
-/* TODO test libj2_j2i_xor_sign{,_to_j2i,_to_j2u} */
+static uintmax_t
+random_ju(void)
+{
+	size_t n = LIBJ2_JU_BIT;
+	uintmax_t r = 0;
+	while (n--)
+		if (rand() < rand())
+			r |= (uintmax_t)1 << n;
+	return r;
+}
+
+
+static void
+check(struct libj2_j2i *a)
+{
+	struct libj2_j2i r, saved, x;
+
+	saved = *a;
+
+	r = (struct libj2_j2i){111, 222};
+	libj2_j2i_xor_sign_to_j2i((const struct libj2_j2i *)a, &r);
+	EXPECT(libj2_j2i_eq_j2i(a, &saved));
+	EXPECT(libj2_j2i_eq_j2i(&r, &saved));
+
+	r = (struct libj2_j2i){111, 222};
+	libj2_j2i_xor_sign_to_j2u((const struct libj2_j2i *)a, (struct libj2_j2u *)&r);
+	EXPECT(libj2_j2i_eq_j2i(a, &saved));
+	EXPECT(libj2_j2i_eq_j2i(&r, &saved));
+
+	r = *a;
+	libj2_j2i_xor_sign(&r);
+	EXPECT(libj2_j2i_eq_j2i(&r, &saved));
+
+	libj2_not_j2u((void *)a);
+	x = *a;
+
+	r = (struct libj2_j2i){111, 222};
+	libj2_j2i_xor_sign_to_j2i((const struct libj2_j2i *)a, &r);
+	EXPECT(libj2_j2i_eq_j2i(a, &x));
+	EXPECT(libj2_j2i_eq_j2i(&r, &saved));
+
+	r = (struct libj2_j2i){111, 222};
+	libj2_j2i_xor_sign_to_j2u((const struct libj2_j2i *)a, (struct libj2_j2u *)&r);
+	EXPECT(libj2_j2i_eq_j2i(a, &x));
+	EXPECT(libj2_j2i_eq_j2i(&r, &saved));
+
+	r = x;
+	libj2_j2i_xor_sign(&r);
+	EXPECT(libj2_j2i_eq_j2i(&r, &saved));
+}
+
+
+int
+main(void)
+{
+	struct libj2_j2i a;
+	unsigned i;
+
+	srand((unsigned)time(NULL));
+
+	for (i = 0; i < 256; i++) {
+		a.high = random_ju() >> 1;
+		a.low = random_ju();
+		check(&a);
+
+		a.high = random_ju() >> 1;
+		a.low = 0;
+		check(&a);
+
+		a.high = 0;
+		a.low = random_ju();
+		check(&a);
+
+		a.high = random_ju() >> 1;
+		a.low = UINTMAX_MAX;
+		check(&a);
+
+		a.high = random_ju() >> 1;
+		a.low = 1;
+		check(&a);
+
+		a.high = 1U;
+		a.low = random_ju();
+		check(&a);
+
+		a.high = UINTMAX_MAX >> 1;
+		a.low = random_ju();
+		check(&a);
+	}
+
+	a.high = 0;
+	a.low = 0;
+	check(&a);
+
+	a.high = UINTMAX_MAX >> 1;
+	a.low = UINTMAX_MAX;
+	check(&a);
+
+	return 0;
+}
 
 #endif
diff --git a/libj2_j2u_cmp_ji.c b/libj2_j2u_cmp_ji.c
index 5ed427f..e851830 100644
--- a/libj2_j2u_cmp_ji.c
+++ b/libj2_j2u_cmp_ji.c
@@ -8,7 +8,6 @@ extern inline int libj2_j2u_cmp_ji(const struct libj2_j2u *a, intmax_t b);
 
 #else
 
-CONST int main(void) { return 0; }
-/* TODO test libj2_j2u_cmp_ji, libj2_ji_cmp_j2u */
+CONST int main(void) { return 0; } /* Tested in libj2_ji_cmp_j2u.c */
 
 #endif
diff --git a/libj2_ji_cmp_j2u.c b/libj2_ji_cmp_j2u.c
index e0bbf04..11a8d0d 100644
--- a/libj2_ji_cmp_j2u.c
+++ b/libj2_ji_cmp_j2u.c
@@ -8,6 +8,148 @@ extern inline int libj2_ji_cmp_j2u(intmax_t a, const struct libj2_j2u *b);
 
 #else
 
-CONST int main(void) { return 0; } /* Tested in libj2_j2u_cmp_ji.c */
+static int
+cmp_(intmax_t a, uintmax_t b_high, uintmax_t b_low)
+{
+	struct libj2_j2u b;
+	int ret;
+
+	b.high = b_high;
+	b.low = b_low;
+
+	ret = libj2_ji_cmp_j2u(a, &b);
+	EXPECT(b.high == b_high);
+	EXPECT(b.low == b_low);
+
+	EXPECT(libj2_ji_lt_j2u(a, &b) == (ret < 0));
+	EXPECT(b.high == b_high);
+	EXPECT(b.low == b_low);
+
+	EXPECT(libj2_ji_le_j2u(a, &b) == (ret <= 0));
+	EXPECT(b.high == b_high);
+	EXPECT(b.low == b_low);
+
+	EXPECT(libj2_ji_gt_j2u(a, &b) == (ret > 0));
+	EXPECT(b.high == b_high);
+	EXPECT(b.low == b_low);
+
+	EXPECT(libj2_ji_ge_j2u(a, &b) == (ret >= 0));
+	EXPECT(b.high == b_high);
+	EXPECT(b.low == b_low);
+
+	EXPECT(libj2_ji_eq_j2u(a, &b) == (ret == 0));
+	EXPECT(b.high == b_high);
+	EXPECT(b.low == b_low);
+
+	EXPECT(libj2_ji_ne_j2u(a, &b) == (ret != 0));
+	EXPECT(b.high == b_high);
+	EXPECT(b.low == b_low);
+
+	EXPECT(libj2_j2u_cmp_ji(&b, a) == (ret ? -ret : 0));
+	EXPECT(b.high == b_high);
+	EXPECT(b.low == b_low);
+
+	EXPECT(libj2_j2u_lt_ji(&b, a) == (ret > 0));
+	EXPECT(b.high == b_high);
+	EXPECT(b.low == b_low);
+
+	EXPECT(libj2_j2u_le_ji(&b, a) == (ret >= 0));
+	EXPECT(b.high == b_high);
+	EXPECT(b.low == b_low);
+
+	EXPECT(libj2_j2u_gt_ji(&b, a) == (ret < 0));
+	EXPECT(b.high == b_high);
+	EXPECT(b.low == b_low);
+
+	EXPECT(libj2_j2u_ge_ji(&b, a) == (ret <= 0));
+	EXPECT(b.high == b_high);
+	EXPECT(b.low == b_low);
+
+	EXPECT(libj2_j2u_eq_ji(&b, a) == (ret == 0));
+	EXPECT(b.high == b_high);
+	EXPECT(b.low == b_low);
+
+	EXPECT(libj2_j2u_ne_ji(&b, a) == (ret != 0));
+	EXPECT(b.high == b_high);
+	EXPECT(b.low == b_low);
+
+	return ret;
+}
+
+
+static int
+cmp(uintmax_t a_unsigned, uintmax_t b_high, uintmax_t b_low)
+{
+	intmax_t a = (intmax_t)a_unsigned;
+	int ret;
+
+	ret = cmp_(a, b_high, b_low);
+
+	if (a)
+		EXPECT(cmp_(-a, b_high, b_low) == -1);
+
+	return ret;
+}
+
+
+int
+main(void)
+{
+	const uintmax_t umax = UINTMAX_MAX;
+	const uintmax_t max = UINTMAX_MAX >> 1;
+
+	EXPECT(cmp(0, 0, 0) == 0);
+	EXPECT(cmp(0, 0, 1) == -1);
+	EXPECT(cmp(0, 1, 0) == -1);
+	EXPECT(cmp(0, 1, 1) == -1);
+	EXPECT(cmp(0, 0, umax) == -1);
+	EXPECT(cmp(0, max, 0) == -1);
+	EXPECT(cmp(0, max, umax) == -1);
+	EXPECT(cmp(0, max, umax - 1U) == -1);
+	EXPECT(cmp(0, umax, 0) == -1);
+	EXPECT(cmp(0, umax, umax) == -1);
+	EXPECT(cmp(0, umax, umax - 1U) == -1);
+
+	EXPECT(cmp(1, 0, 0) == +1);
+	EXPECT(cmp(1, 0, 1) == 0);
+	EXPECT(cmp(1, 1, 0) == -1);
+	EXPECT(cmp(1, 1, 1) == -1);
+	EXPECT(cmp(1, 0, umax) == -1);
+	EXPECT(cmp(1, max, 0) == -1);
+	EXPECT(cmp(1, max, umax) == -1);
+	EXPECT(cmp(1, max, umax - 1U) == -1);
+	EXPECT(cmp(1, umax, 0) == -1);
+	EXPECT(cmp(1, umax, umax) == -1);
+	EXPECT(cmp(1, umax, umax - 1U) == -1);
+
+	EXPECT(cmp(max, 0, 0) == +1);
+	EXPECT(cmp(max, 0, 1) == +1);
+	EXPECT(cmp(max, 1, 0) == -1);
+	EXPECT(cmp(max, 1, 1) == -1);
+	EXPECT(cmp(max, 0, max) == 0);
+	EXPECT(cmp(max, 0, umax) == -1);
+	EXPECT(cmp(max, max, 0) == -1);
+	EXPECT(cmp(max, max, umax) == -1);
+	EXPECT(cmp(max, max, umax - 1U) == -1);
+	EXPECT(cmp(max, umax, 0) == -1);
+	EXPECT(cmp(max, umax, umax) == -1);
+	EXPECT(cmp(max, umax, umax - 1U) == -1);
+
+	EXPECT(cmp_(INTMAX_MIN, 0, 0) == -1);
+	EXPECT(cmp_(INTMAX_MIN, 0, 1) == -1);
+	EXPECT(cmp_(INTMAX_MIN, 1, 0) == -1);
+	EXPECT(cmp_(INTMAX_MIN, 1, 1) == -1);
+	EXPECT(cmp_(INTMAX_MIN, 0, umax) == -1);
+	EXPECT(cmp_(INTMAX_MIN, max, 0) == -1);
+	EXPECT(cmp_(INTMAX_MIN, max, umax) == -1);
+	EXPECT(cmp_(INTMAX_MIN, max, umax - 1U) == -1);
+	EXPECT(cmp_(INTMAX_MIN, umax, 0) == -1);
+	EXPECT(cmp_(INTMAX_MIN, umax, umax) == -1);
+	EXPECT(cmp_(INTMAX_MIN, umax, umax - 1U) == -1);
+	EXPECT(cmp_(INTMAX_MIN, ~max, 0) == -1);
+	EXPECT(cmp_(INTMAX_MIN, 0, ~max) == -1);
+
+	return 0;
+}
 
 #endif
diff --git a/libj2_ji_lsh_to_j2i.c b/libj2_ji_lsh_to_j2i.c
index cc61b01..88b2379 100644
--- a/libj2_ji_lsh_to_j2i.c
+++ b/libj2_ji_lsh_to_j2i.c
@@ -8,7 +8,7 @@ extern inline void libj2_ji_lsh_to_j2i(intmax_t a, unsigned b, struct libj2_j2i
 
 #else
 
-CONST int main(void) { return 0; };
+CONST int main(void) { return 0; }
 /* TODO test libj2_ji_lsh_to_j2i, libj2_ji_lsh_to_j2i_overflow, libj2_ji_lsh_overflow_p */
 
 #endif
diff --git a/libj2_minus_j2i_to_j2u.c b/libj2_minus_j2i_to_j2u.c
index a5fb3d1..5e570a5 100644
--- a/libj2_minus_j2i_to_j2u.c
+++ b/libj2_minus_j2i_to_j2u.c
@@ -8,7 +8,66 @@ extern inline void libj2_minus_j2i_to_j2u(const struct libj2_j2i *a, struct libj
 
 #else
 
-CONST int main(void) { return 0; }
-/* TODO test */
+static void
+check_ji_ju(intmax_t ji, uintmax_t ju)
+{
+	struct libj2_j2i a, a_saved, b;
+	struct libj2_j2u r;
+
+	r = (struct libj2_j2u){111, 222};
+	libj2_ji_to_j2i(ji, &a);
+	a_saved = a;
+	libj2_minus_j2i_to_j2u((const struct libj2_j2i *)&a, &r);
+	EXPECT(libj2_j2i_eq_j2i(&a, &a_saved));
+	EXPECT(libj2_j2u_eq_ju(&r, ju));
+
+	b = (struct libj2_j2i){111, 222};
+	libj2_minus_j2u_to_j2i((const struct libj2_j2u *)&r, &b);
+	EXPECT(libj2_j2u_eq_ju(&r, ju));
+	EXPECT(libj2_j2i_eq_j2i(&b, &a_saved));
+}
+
+
+static void
+check_j2i_j2u(uintmax_t a_high, uintmax_t a_low, int a_minus, uintmax_t r_high, uintmax_t r_low)
+{
+	struct libj2_j2i a, a_saved, b;
+	struct libj2_j2u r;
+
+	r = (struct libj2_j2u){111, 222};
+	a.high = a_high;
+	a.low = a_low;
+	if (a_minus)
+		libj2_minus_j2i(&a);
+	a_saved = a;
+	libj2_minus_j2i_to_j2u((const struct libj2_j2i *)&a, &r);
+	EXPECT(libj2_j2i_eq_j2i(&a, &a_saved));
+	EXPECT(r.high == r_high);
+	EXPECT(r.low == r_low);
+
+	b = (struct libj2_j2i){111, 222};
+	libj2_minus_j2u_to_j2i((const struct libj2_j2u *)&r, &b);
+	EXPECT(r.high == r_high);
+	EXPECT(r.low == r_low);
+	EXPECT(libj2_j2i_eq_j2i(&b, &a_saved));
+}
+
+
+int
+main(void)
+{
+	check_ji_ju(0, 0);
+	check_ji_ju(-1, 1);
+	check_ji_ju(-2, 2);
+
+	check_j2i_j2u(UINTMAX_MAX >> 1, UINTMAX_MAX, 1, UINTMAX_MAX >> 1, UINTMAX_MAX);
+	check_j2i_j2u(UINTMAX_MAX ^ (UINTMAX_MAX >> 1), 0, 0, UINTMAX_MAX ^ (UINTMAX_MAX >> 1), 0);
+	check_j2i_j2u(0, 1, 0, UINTMAX_MAX, UINTMAX_MAX);
+	check_j2i_j2u(0, 2, 0, UINTMAX_MAX, UINTMAX_MAX - 1U);
+	check_j2i_j2u(UINTMAX_MAX >> 1, UINTMAX_MAX, 0, UINTMAX_MAX ^ (UINTMAX_MAX >> 1), 1);
+	check_j2i_j2u(UINTMAX_MAX ^ (UINTMAX_MAX >> 1), 0, 0, UINTMAX_MAX ^ (UINTMAX_MAX >> 1), 0);
+
+	return 0;
+}
 
 #endif
diff --git a/libj2_minus_j2u_to_j2i.c b/libj2_minus_j2u_to_j2i.c
index efda5d5..b453bfb 100644
--- a/libj2_minus_j2u_to_j2i.c
+++ b/libj2_minus_j2u_to_j2i.c
@@ -8,7 +8,6 @@ extern inline void libj2_minus_j2u_to_j2i(const struct libj2_j2u *a, struct libj
 
 #else
 
-CONST int main(void) { return 0; }
-/* TODO test */
+CONST int main(void) { return 0; } /* Testedin libj2_minus_j2i_to_j2u.c */
 
 #endif