thodg/libgit2

diff --git a/tests-clar/attr/attr_expect.h b/tests-clar/attr/attr_expect.h
index b064eac..df1e104 100644
--- a/tests-clar/attr/attr_expect.h
+++ b/tests-clar/attr/attr_expect.h
@@ -34,7 +34,7 @@ GIT_INLINE(void) attr_check_expected(
 		break;
 
 	case EXPECT_STRING:
-		cl_assert_strequal(expected_str, value);
+		cl_assert_equal_s(expected_str, value);
 		break;
 	}
 }
diff --git a/tests-clar/attr/file.c b/tests-clar/attr/file.c
index 6aeaa51..7fede50 100644
--- a/tests-clar/attr/file.c
+++ b/tests-clar/attr/file.c
@@ -13,19 +13,19 @@ void test_attr_file__simple_read(void)
 
 	cl_git_pass(git_attr_file__new(&file));
 	cl_git_pass(git_attr_file__from_file(NULL, cl_fixture("attr/attr0"), file));
-	cl_assert_strequal(cl_fixture("attr/attr0"), file->path);
+	cl_assert_equal_s(cl_fixture("attr/attr0"), file->path);
 	cl_assert(file->rules.length == 1);
 
 	rule = get_rule(0);
 	cl_assert(rule != NULL);
-	cl_assert_strequal("*", rule->match.pattern);
+	cl_assert_equal_s("*", rule->match.pattern);
 	cl_assert(rule->match.length == 1);
 	cl_assert((rule->match.flags & GIT_ATTR_FNMATCH_HASWILD) != 0);
 
 	cl_assert(rule->assigns.length == 1);
 	assign = get_assign(rule, 0);
 	cl_assert(assign != NULL);
-	cl_assert_strequal("binary", assign->name);
+	cl_assert_equal_s("binary", assign->name);
 	cl_assert(GIT_ATTR_TRUE(assign->value));
 	cl_assert(!assign->is_allocated);
 
@@ -40,7 +40,7 @@ void test_attr_file__match_variants(void)
 
 	cl_git_pass(git_attr_file__new(&file));
 	cl_git_pass(git_attr_file__from_file(NULL, cl_fixture("attr/attr1"), file));
-	cl_assert_strequal(cl_fixture("attr/attr1"), file->path);
+	cl_assert_equal_s(cl_fixture("attr/attr1"), file->path);
 	cl_assert(file->rules.length == 10);
 
 	/* let's do a thorough check of this rule, then just verify
@@ -48,53 +48,53 @@ void test_attr_file__match_variants(void)
 	 */
 	rule = get_rule(0);
 	cl_assert(rule);
-	cl_assert_strequal("pat0", rule->match.pattern);
+	cl_assert_equal_s("pat0", rule->match.pattern);
 	cl_assert(rule->match.length == strlen("pat0"));
 	cl_assert(rule->match.flags == 0);
 	cl_assert(rule->assigns.length == 1);
 	assign = get_assign(rule,0);
-	cl_assert_strequal("attr0", assign->name);
+	cl_assert_equal_s("attr0", assign->name);
 	cl_assert(assign->name_hash == git_attr_file__name_hash(assign->name));
 	cl_assert(GIT_ATTR_TRUE(assign->value));
 	cl_assert(!assign->is_allocated);
 
 	rule = get_rule(1);
-	cl_assert_strequal("pat1", rule->match.pattern);
+	cl_assert_equal_s("pat1", rule->match.pattern);
 	cl_assert(rule->match.length == strlen("pat1"));
 	cl_assert(rule->match.flags == GIT_ATTR_FNMATCH_NEGATIVE);
 
 	rule = get_rule(2);
-	cl_assert_strequal("pat2", rule->match.pattern);
+	cl_assert_equal_s("pat2", rule->match.pattern);
 	cl_assert(rule->match.length == strlen("pat2"));
 	cl_assert(rule->match.flags == GIT_ATTR_FNMATCH_DIRECTORY);
 
 	rule = get_rule(3);
-	cl_assert_strequal("pat3dir/pat3file", rule->match.pattern);
+	cl_assert_equal_s("pat3dir/pat3file", rule->match.pattern);
 	cl_assert(rule->match.flags == GIT_ATTR_FNMATCH_FULLPATH);
 
 	rule = get_rule(4);
-	cl_assert_strequal("pat4.*", rule->match.pattern);
+	cl_assert_equal_s("pat4.*", rule->match.pattern);
 	cl_assert((rule->match.flags & GIT_ATTR_FNMATCH_HASWILD) != 0);
 
 	rule = get_rule(5);
-	cl_assert_strequal("*.pat5", rule->match.pattern);
+	cl_assert_equal_s("*.pat5", rule->match.pattern);
 	cl_assert((rule->match.flags & GIT_ATTR_FNMATCH_HASWILD) != 0);
 
 	rule = get_rule(7);
-	cl_assert_strequal("pat7[a-e]??[xyz]", rule->match.pattern);
+	cl_assert_equal_s("pat7[a-e]??[xyz]", rule->match.pattern);
 	cl_assert(rule->assigns.length == 1);
 	cl_assert((rule->match.flags & GIT_ATTR_FNMATCH_HASWILD) != 0);
 	assign = get_assign(rule,0);
-	cl_assert_strequal("attr7", assign->name);
+	cl_assert_equal_s("attr7", assign->name);
 	cl_assert(GIT_ATTR_TRUE(assign->value));
 
 	rule = get_rule(8);
-	cl_assert_strequal("pat8 with spaces", rule->match.pattern);
+	cl_assert_equal_s("pat8 with spaces", rule->match.pattern);
 	cl_assert(rule->match.length == strlen("pat8 with spaces"));
 	cl_assert(rule->match.flags == 0);
 
 	rule = get_rule(9);
-	cl_assert_strequal("pat9", rule->match.pattern);
+	cl_assert_equal_s("pat9", rule->match.pattern);
 
 	git_attr_file__free(file);
 }
@@ -111,9 +111,9 @@ static void check_one_assign(
 	git_attr_rule *rule = get_rule(rule_idx);
 	git_attr_assignment *assign = get_assign(rule, assign_idx);
 
-	cl_assert_strequal(pattern, rule->match.pattern);
+	cl_assert_equal_s(pattern, rule->match.pattern);
 	cl_assert(rule->assigns.length == 1);
-	cl_assert_strequal(name, assign->name);
+	cl_assert_equal_s(name, assign->name);
 	cl_assert(assign->name_hash == git_attr_file__name_hash(assign->name));
 
 	attr_check_expected(expected, expected_str, assign->value);
@@ -127,7 +127,7 @@ void test_attr_file__assign_variants(void)
 
 	cl_git_pass(git_attr_file__new(&file));
 	cl_git_pass(git_attr_file__from_file(NULL, cl_fixture("attr/attr2"), file));
-	cl_assert_strequal(cl_fixture("attr/attr2"), file->path);
+	cl_assert_equal_s(cl_fixture("attr/attr2"), file->path);
 	cl_assert(file->rules.length == 11);
 
 	check_one_assign(file, 0, 0, "pat0", "simple", EXPECT_TRUE, NULL);
@@ -140,45 +140,45 @@ void test_attr_file__assign_variants(void)
 	check_one_assign(file, 7, 0, "pat6", "negempty", EXPECT_FALSE, NULL);
 
 	rule = get_rule(8);
-	cl_assert_strequal("pat7", rule->match.pattern);
+	cl_assert_equal_s("pat7", rule->match.pattern);
 	cl_assert(rule->assigns.length == 5);
 	/* assignments will be sorted by hash value, so we have to do
 	 * lookups by search instead of by position
 	 */
 	assign = git_attr_rule__lookup_assignment(rule, "multiple");
 	cl_assert(assign);
-	cl_assert_strequal("multiple", assign->name);
+	cl_assert_equal_s("multiple", assign->name);
 	cl_assert(GIT_ATTR_TRUE(assign->value));
 	assign = git_attr_rule__lookup_assignment(rule, "single");
 	cl_assert(assign);
-	cl_assert_strequal("single", assign->name);
+	cl_assert_equal_s("single", assign->name);
 	cl_assert(GIT_ATTR_FALSE(assign->value));
 	assign = git_attr_rule__lookup_assignment(rule, "values");
 	cl_assert(assign);
-	cl_assert_strequal("values", assign->name);
-	cl_assert_strequal("1", assign->value);
+	cl_assert_equal_s("values", assign->name);
+	cl_assert_equal_s("1", assign->value);
 	assign = git_attr_rule__lookup_assignment(rule, "also");
 	cl_assert(assign);
-	cl_assert_strequal("also", assign->name);
-	cl_assert_strequal("a-really-long-value/*", assign->value);
+	cl_assert_equal_s("also", assign->name);
+	cl_assert_equal_s("a-really-long-value/*", assign->value);
 	assign = git_attr_rule__lookup_assignment(rule, "happy");
 	cl_assert(assign);
-	cl_assert_strequal("happy", assign->name);
-	cl_assert_strequal("yes!", assign->value);
+	cl_assert_equal_s("happy", assign->name);
+	cl_assert_equal_s("yes!", assign->value);
 	assign = git_attr_rule__lookup_assignment(rule, "other");
 	cl_assert(!assign);
 
 	rule = get_rule(9);
-	cl_assert_strequal("pat8", rule->match.pattern);
+	cl_assert_equal_s("pat8", rule->match.pattern);
 	cl_assert(rule->assigns.length == 2);
 	assign = git_attr_rule__lookup_assignment(rule, "again");
 	cl_assert(assign);
-	cl_assert_strequal("again", assign->name);
+	cl_assert_equal_s("again", assign->name);
 	cl_assert(GIT_ATTR_TRUE(assign->value));
 	assign = git_attr_rule__lookup_assignment(rule, "another");
 	cl_assert(assign);
-	cl_assert_strequal("another", assign->name);
-	cl_assert_strequal("12321", assign->value);
+	cl_assert_equal_s("another", assign->name);
+	cl_assert_equal_s("12321", assign->value);
 
 	check_one_assign(file, 10, 0, "pat9", "at-eof", EXPECT_FALSE, NULL);
 
@@ -193,37 +193,37 @@ void test_attr_file__check_attr_examples(void)
 
 	cl_git_pass(git_attr_file__new(&file));
 	cl_git_pass(git_attr_file__from_file(NULL, cl_fixture("attr/attr3"), file));
-	cl_assert_strequal(cl_fixture("attr/attr3"), file->path);
+	cl_assert_equal_s(cl_fixture("attr/attr3"), file->path);
 	cl_assert(file->rules.length == 3);
 
 	rule = get_rule(0);
-	cl_assert_strequal("*.java", rule->match.pattern);
+	cl_assert_equal_s("*.java", rule->match.pattern);
 	cl_assert(rule->assigns.length == 3);
 	assign = git_attr_rule__lookup_assignment(rule, "diff");
-	cl_assert_strequal("diff", assign->name);
-	cl_assert_strequal("java", assign->value);
+	cl_assert_equal_s("diff", assign->name);
+	cl_assert_equal_s("java", assign->value);
 	assign = git_attr_rule__lookup_assignment(rule, "crlf");
-	cl_assert_strequal("crlf", assign->name);
+	cl_assert_equal_s("crlf", assign->name);
 	cl_assert(GIT_ATTR_FALSE(assign->value));
 	assign = git_attr_rule__lookup_assignment(rule, "myAttr");
-	cl_assert_strequal("myAttr", assign->name);
+	cl_assert_equal_s("myAttr", assign->name);
 	cl_assert(GIT_ATTR_TRUE(assign->value));
 	assign = git_attr_rule__lookup_assignment(rule, "missing");
 	cl_assert(assign == NULL);
 
 	rule = get_rule(1);
-	cl_assert_strequal("NoMyAttr.java", rule->match.pattern);
+	cl_assert_equal_s("NoMyAttr.java", rule->match.pattern);
 	cl_assert(rule->assigns.length == 1);
 	assign = get_assign(rule, 0);
-	cl_assert_strequal("myAttr", assign->name);
+	cl_assert_equal_s("myAttr", assign->name);
 	cl_assert(assign->value == NULL);
 
 	rule = get_rule(2);
-	cl_assert_strequal("README", rule->match.pattern);
+	cl_assert_equal_s("README", rule->match.pattern);
 	cl_assert(rule->assigns.length == 1);
 	assign = get_assign(rule, 0);
-	cl_assert_strequal("caveat", assign->name);
-	cl_assert_strequal("unspecified", assign->value);
+	cl_assert_equal_s("caveat", assign->name);
+	cl_assert_equal_s("unspecified", assign->value);
 
 	git_attr_file__free(file);
 }
diff --git a/tests-clar/attr/lookup.c b/tests-clar/attr/lookup.c
index 1939618..4ce80e9 100644
--- a/tests-clar/attr/lookup.c
+++ b/tests-clar/attr/lookup.c
@@ -11,12 +11,12 @@ void test_attr_lookup__simple(void)
 
 	cl_git_pass(git_attr_file__new(&file));
 	cl_git_pass(git_attr_file__from_file(NULL, cl_fixture("attr/attr0"), file));
-	cl_assert_strequal(cl_fixture("attr/attr0"), file->path);
+	cl_assert_equal_s(cl_fixture("attr/attr0"), file->path);
 	cl_assert(file->rules.length == 1);
 
 	cl_git_pass(git_attr_path__init(&path, "test", NULL));
-	cl_assert_strequal("test", path.path);
-	cl_assert_strequal("test", path.basename);
+	cl_assert_equal_s("test", path.path);
+	cl_assert_equal_s("test", path.basename);
 	cl_assert(!path.is_dir);
 
 	cl_git_pass(git_attr_file__lookup_one(file,&path,"binary",&value));
@@ -129,11 +129,11 @@ void test_attr_lookup__match_variants(void)
 
 	cl_git_pass(git_attr_file__new(&file));
 	cl_git_pass(git_attr_file__from_file(NULL, cl_fixture("attr/attr1"), file));
-	cl_assert_strequal(cl_fixture("attr/attr1"), file->path);
+	cl_assert_equal_s(cl_fixture("attr/attr1"), file->path);
 	cl_assert(file->rules.length == 10);
 
 	cl_git_pass(git_attr_path__init(&path, "/testing/for/pat0", NULL));
-	cl_assert_strequal("pat0", path.basename);
+	cl_assert_equal_s("pat0", path.basename);
 
 	run_test_cases(file, cases, 0);
 	run_test_cases(file, dir_cases, 1);
diff --git a/tests-clar/attr/repo.c b/tests-clar/attr/repo.c
index 5ff33d1..6dc13aa 100644
--- a/tests-clar/attr/repo.c
+++ b/tests-clar/attr/repo.c
@@ -101,7 +101,7 @@ void test_attr_repo__get_many(void)
 	cl_assert(GIT_ATTR_TRUE(values[0]));
 	cl_assert(GIT_ATTR_TRUE(values[1]));
 	cl_assert(GIT_ATTR_UNSPECIFIED(values[2]));
-	cl_assert_strequal("yes", values[3]);
+	cl_assert_equal_s("yes", values[3]);
 }
 
 static int count_attrs(
@@ -150,7 +150,7 @@ void test_attr_repo__manpage_example(void)
 	cl_assert(GIT_ATTR_FALSE(value));
 
 	cl_git_pass(git_attr_get(g_repo, "sub/abc", "merge", &value));
-	cl_assert_strequal("filfre", value);
+	cl_assert_equal_s("filfre", value);
 
 	cl_git_pass(git_attr_get(g_repo, "sub/abc", "frotz", &value));
 	cl_assert(GIT_ATTR_UNSPECIFIED(value));
@@ -177,13 +177,13 @@ void test_attr_repo__macros(void)
 	cl_assert(GIT_ATTR_TRUE(values[1]));
 	cl_assert(GIT_ATTR_FALSE(values[2]));
 	cl_assert(GIT_ATTR_UNSPECIFIED(values[3]));
-	cl_assert_strequal("77", values[4]);
+	cl_assert_equal_s("77", values[4]);
 
 	cl_git_pass(git_attr_get_many(g_repo, "macro_test", 3, names3, values));
 
 	cl_assert(GIT_ATTR_TRUE(values[0]));
 	cl_assert(GIT_ATTR_FALSE(values[1]));
-	cl_assert_strequal("answer", values[2]);
+	cl_assert_equal_s("answer", values[2]);
 }
 
 void test_attr_repo__bad_macros(void)
@@ -222,7 +222,7 @@ void test_attr_repo__bad_macros(void)
 	 *     -firstmacro secondmacro="hahaha" thirdmacro
 	 */
 	cl_assert(GIT_ATTR_FALSE(values[3]));
-	cl_assert_strequal("hahaha", values[4]);
+	cl_assert_equal_s("hahaha", values[4]);
 	cl_assert(GIT_ATTR_TRUE(values[5]));
 }
 
diff --git a/tests-clar/clar b/tests-clar/clar
index 506bde3..8be4ff5 100755
--- a/tests-clar/clar
+++ b/tests-clar/clar
@@ -297,7 +297,7 @@ static const struct clar_func _clar_cb_${suite_name}[] = {
 
 
 CLAR_FILES = {
-"clar.c" : r"""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""",
+"clar.c" : r"""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""",
 "clar_print_default.c" : r"""eJyFU01P4zAQPSe/YqgU1a5Cuadi98ap4rLaE6DIxA5YSu3InnQPK/479jgFB9FycuZ53vObj5QeBeoOjlZL6Abh2tFpg602Gln4AFQe285OBmuIsZ80qhPQWeMRulfhYJMujDgoz8v/ZcGiJP+k78qCpHu22lshlYRKJjXfQOUfzaqG+CJfvJCrZgp/UDhUMpAC+laWZ6rwrxNK+8/8XEkElHPWJeBcBQnKmB9YRt6Vn0YfTfJYkCunRuuwpVzPLlqnHPJtpsOp0x7d1GFKowTY0EF2T09CaCyHO6GHyamG+hokeO6q8k1TeWCV5/AQgko+wcM1hiOml0VBqte/qNAsjr2I4cpYkMp3To+o7YLS6yFnDNqE8U2HZ+W+6MzowhecFmHOS009+BfK0j2w+SJ7HK5u4f7vfs+D/DmdLJ0vp3N5f6yJTlm+5sl62Me0M1klCehD35X8uj+RsFsixMlWuuqC38SG37C+W0MD6+36B380Ifb9f0gmbjZgrB1hc7Pc3uTokrR4Dru6kA6DqGG73ZLwUbSDDlfCvYw7Cn38KVmMa0gzK479XJ5HGWZBeE0UnjjKSDaHb+U7mrWGAw==""",
 "clar_print_tap.c" : r"""eJyNVMFu2zAMPVtfwbgIYBu2gWK3BmuxnYthh+02wFBtORXmSIYkZxiG/vso2m6lJF12skk9ko+PlJh13MkWjlp20A7cNKORyjVSSZfhDzhhXdPqSbkSvG0n6cTqaLWyDtpnbqCYDxQ/CJuzPyzJfMr8LXy3ugLgiW/FEYU+S799+gpHYazUCm4//FBpvmMvjL1D2T5PrtO/1HXa3iGM0WZ2/A/d2BcE7xhLZA/ZJkqYvPZwAyO3VnTAhwG2HRHLbI7NlAFJbCwRgxVRYM/lgIEYxA9a7U+jg4IlxiVxtjXNbV1vu/Nq78tIaUlDNR3WEVtnptbNMAJAQZ9AOkR7Lda6AFVVzSMLfDhzy/cC7mBr35qo7udeDnYfw63A8Uv3+460OMtGowE4y0b+GOqbhwtQ74+RPYp+Cen9MXKQakV2IdL7G5TjSZh8XY/lqBO2NXJ0fqM3H+HL98fHcFkAAsApgeAoj5Wu6/ra5dCKVie8sLQP/hrOF2I2ifXsmNePJryW2lq/hNVCDIkvK/oAqdIO9M8UxUjx48/ChK8mlmMJ0SdyRozaLDtnsysd0Fizy29ORPMGiqJAkv5DCga4f5fgT0gnKoE7WXqBqcCRN4PEI272445MzIQB3i5hWd9+oWHxNZrwtUk/o0iAvxug/T2eAqiET5HPOYXqssV8YX8BFTvXlQ==""",
 "clar_sandbox.c" : r"""eJyNVV1P20AQfLZ/xRIkYpNATItaVSkPlaBVVEoiEgQSRJaxz+SEfY7uLmkD4r931+fEHwRahBST3Zudmb0xSgeahxDOAgl+mATSnwd6dnvsffk07du2MmUutM2VvwwSHvk6nedNTpgJpc3RffrCtZ9tazz5NvEnoDSetngMDkE4VO7CntIu7JyA59qWJZleSAHeum9n7A/Gp4NLPHCotJ9mEXObfcWzE4QhU6pAvfaHP104Idi+/VLjHHNR5ZszvV/EMZNdUPyJ+RoSJh4M9V0ei4jF4F8PLj5+sK0Cx6gsupdoUJgthIYTOO43egw+E0s0SqrbKfagIVZr8muEulpdoKf848x8Xo3PLkeXw++D87OWDdYLSgSrmMRJb5xJcDjieH3g8LUc34dOh7s5fGM2Nj8wjQ/OhgifojGWMRm/JFPplOZiwWhKXnm9Xmo1I1CmFOF85ay9w1J37RxBV5ZkWS82/tpWbx8GMegZo24uM5EytC3KmBJt9DNYQSBWesbFQxe0XIHOYKEY9HA+7PfsN0i1qN4qeDVpmWKNWYUYktpliWIG+gfTE5bORwTqnF4PL09dc6wLBq5x+XaZiHhsdE1mXIFaKc3SjaCEPzIUUNNC4sOFlLlwLlmoMyy+I+7wTWWH78la/3lwVA3AMuMR5JFeCBWI6D7749B3eUyJQCXv3pQC1L7z2qVqvBoYiWoiwhmqQJZIs2JIrHyZVsCaKUQ/eRL5BQWjdMOjcnup4OuAJ3lyWjkeWXOT/7QobZvIrl8a9YCXHEy8s7hKy8UAVd885JZtIRhOQ7/xoS6iqf4ZcPUikyku7YnldGnRo+F4cAOY1N+BjEAlgZoxlS+5EmXrVZRJRBni5j54sY+7fB+W1ShBu9feRG2ziAYGKTuAoym9cbHfDKrXO50SjO7R+tqVXdAhpt1yOducxTHYtMUyYpQ+Ykzmvvrndhr/GMx6DAJdu+px77PnbT1QCTieosE1nujpxdX5+atDhYFlquoXOEf4/wjB3t62O7/9/hGKyVWV6FYvavT+AhbcW38=""",
diff --git a/tests-clar/clar_libgit2.h b/tests-clar/clar_libgit2.h
index bb2feee..4d338ef 100644
--- a/tests-clar/clar_libgit2.h
+++ b/tests-clar/clar_libgit2.h
@@ -25,26 +25,6 @@
  */
 #define cl_git_fail(expr) cl_must_fail(expr)
 
-/**
- * Wrapper for string comparison that knows about nulls.
- */
-#define cl_assert_strequal(a,b) \
-	cl_assert_strequal_internal(a,b,__FILE__,__LINE__,"string mismatch: " #a " != " #b)
-
-GIT_INLINE(void) cl_assert_strequal_internal(
-	const char *a, const char *b, const char *file, int line, const char *err)
-{
-	int match = (a == NULL || b == NULL) ? (a == b) : (strcmp(a, b) == 0);
-	if (!match) {
-		char buf[4096];
-		snprintf(buf, 4096, "'%s' != '%s'", a, b);
-		clar__assert(0, file, line, err, buf, 1);
-	}
-}
-
-#define cl_assert_intequal(a,b) \
-	do { if ((a) != (b)) { char buf[128]; snprintf(buf,128,"%d != %d",(a),(b)); clar__assert(0,__FILE__,__LINE__,#a " != " #b,buf,1); } } while (0)
-
 /*
  * Some utility macros for building long strings
  */
diff --git a/tests-clar/core/buffer.c b/tests-clar/core/buffer.c
index 4ba7b66..9294ccd 100644
--- a/tests-clar/core/buffer.c
+++ b/tests-clar/core/buffer.c
@@ -19,11 +19,11 @@ void test_core_buffer__0(void)
 
 	git_buf_puts(&buf, test_string);
 	cl_assert(git_buf_oom(&buf) == 0);
-	cl_assert_strequal(test_string, git_buf_cstr(&buf));
+	cl_assert_equal_s(test_string, git_buf_cstr(&buf));
 
 	git_buf_puts(&buf, test_string);
 	cl_assert(git_buf_oom(&buf) == 0);
-	cl_assert_strequal(test_string_x2, git_buf_cstr(&buf));
+	cl_assert_equal_s(test_string_x2, git_buf_cstr(&buf));
 
 	git_buf_free(&buf);
 }
@@ -35,11 +35,11 @@ void test_core_buffer__1(void)
 
 	git_buf_printf(&buf, "%s %s %d ", "shoop", "da", 23);
 	cl_assert(git_buf_oom(&buf) == 0);
-	cl_assert_strequal("shoop da 23 ", git_buf_cstr(&buf));
+	cl_assert_equal_s("shoop da 23 ", git_buf_cstr(&buf));
 
 	git_buf_printf(&buf, "%s %d", "woop", 42);
 	cl_assert(git_buf_oom(&buf) == 0);
-	cl_assert_strequal("shoop da 23 woop 42", git_buf_cstr(&buf));
+	cl_assert_equal_s("shoop da 23 woop 42", git_buf_cstr(&buf));
 
 	git_buf_free(&buf);
 }
@@ -59,7 +59,7 @@ void test_core_buffer__2(void)
 	cl_assert(buf.asize == 0);
 
 	/* empty buffer should be empty string */
-	cl_assert_strequal("", git_buf_cstr(&buf));
+	cl_assert_equal_s("", git_buf_cstr(&buf));
 	cl_assert(buf.size == 0);
 	/* cl_assert(buf.asize == 0); -- should not assume what git_buf does */
 
@@ -71,38 +71,38 @@ void test_core_buffer__2(void)
 	/* add letter */
 	git_buf_putc(&buf, '+');
 	cl_assert(git_buf_oom(&buf) == 0);
-	cl_assert_strequal("+", git_buf_cstr(&buf));
+	cl_assert_equal_s("+", git_buf_cstr(&buf));
 
 	/* add letter again */
 	git_buf_putc(&buf, '+');
 	cl_assert(git_buf_oom(&buf) == 0);
-	cl_assert_strequal("++", git_buf_cstr(&buf));
+	cl_assert_equal_s("++", git_buf_cstr(&buf));
 
 	/* let's try that a few times */
 	for (i = 0; i < 16; ++i) {
 		git_buf_putc(&buf, '+');
 		cl_assert(git_buf_oom(&buf) == 0);
 	}
-	cl_assert_strequal("++++++++++++++++++", git_buf_cstr(&buf));
+	cl_assert_equal_s("++++++++++++++++++", git_buf_cstr(&buf));
 
 	git_buf_free(&buf);
 
 	/* add data */
 	git_buf_put(&buf, "xo", 2);
 	cl_assert(git_buf_oom(&buf) == 0);
-	cl_assert_strequal("xo", git_buf_cstr(&buf));
+	cl_assert_equal_s("xo", git_buf_cstr(&buf));
 
 	/* add letter again */
 	git_buf_put(&buf, "xo", 2);
 	cl_assert(git_buf_oom(&buf) == 0);
-	cl_assert_strequal("xoxo", git_buf_cstr(&buf));
+	cl_assert_equal_s("xoxo", git_buf_cstr(&buf));
 
 	/* let's try that a few times */
 	for (i = 0; i < 16; ++i) {
 		git_buf_put(&buf, "xo", 2);
 		cl_assert(git_buf_oom(&buf) == 0);
 	}
-	cl_assert_strequal("xoxoxoxoxoxoxoxoxoxoxoxoxoxoxoxoxoxo",
+	cl_assert_equal_s("xoxoxoxoxoxoxoxoxoxoxoxoxoxoxoxoxoxo",
 					   git_buf_cstr(&buf));
 
 	git_buf_free(&buf);
@@ -110,21 +110,21 @@ void test_core_buffer__2(void)
 	/* set to string */
 	git_buf_sets(&buf, test_string);
 	cl_assert(git_buf_oom(&buf) == 0);
-	cl_assert_strequal(test_string, git_buf_cstr(&buf));
+	cl_assert_equal_s(test_string, git_buf_cstr(&buf));
 
 	/* append string */
 	git_buf_puts(&buf, test_string);
 	cl_assert(git_buf_oom(&buf) == 0);
-	cl_assert_strequal(test_string_x2, git_buf_cstr(&buf));
+	cl_assert_equal_s(test_string_x2, git_buf_cstr(&buf));
 
 	/* set to string again (should overwrite - not append) */
 	git_buf_sets(&buf, test_string);
 	cl_assert(git_buf_oom(&buf) == 0);
-	cl_assert_strequal(test_string, git_buf_cstr(&buf));
+	cl_assert_equal_s(test_string, git_buf_cstr(&buf));
 
 	/* test clear */
 	git_buf_clear(&buf);
-	cl_assert_strequal("", git_buf_cstr(&buf));
+	cl_assert_equal_s("", git_buf_cstr(&buf));
 
 	git_buf_free(&buf);
 
@@ -133,27 +133,27 @@ void test_core_buffer__2(void)
 	cl_assert(git_buf_oom(&buf) == 0);
 
 	git_buf_copy_cstr(data, sizeof(data), &buf);
-	cl_assert_strequal(REP4("0123456789"), data);
+	cl_assert_equal_s(REP4("0123456789"), data);
 	git_buf_copy_cstr(data, 11, &buf);
-	cl_assert_strequal("0123456789", data);
+	cl_assert_equal_s("0123456789", data);
 	git_buf_copy_cstr(data, 3, &buf);
-	cl_assert_strequal("01", data);
+	cl_assert_equal_s("01", data);
 	git_buf_copy_cstr(data, 1, &buf);
-	cl_assert_strequal("", data);
+	cl_assert_equal_s("", data);
 
 	git_buf_copy_cstr(data, sizeof(data), &buf);
-	cl_assert_strequal(REP4("0123456789"), data);
+	cl_assert_equal_s(REP4("0123456789"), data);
 
 	git_buf_sets(&buf, REP256("x"));
 	git_buf_copy_cstr(data, sizeof(data), &buf);
 	/* since sizeof(data) == 128, only 127 bytes should be copied */
-	cl_assert_strequal(REP4(REP16("x")) REP16("x") REP16("x")
+	cl_assert_equal_s(REP4(REP16("x")) REP16("x") REP16("x")
 					   REP16("x") "xxxxxxxxxxxxxxx", data);
 
 	git_buf_free(&buf);
 
 	git_buf_copy_cstr(data, sizeof(data), &buf);
-	cl_assert_strequal("", data);
+	cl_assert_equal_s("", data);
 }
 
 /* let's do some tests with larger buffers to push our limits */
@@ -164,17 +164,17 @@ void test_core_buffer__3(void)
 	/* set to string */
 	git_buf_set(&buf, test_4096, 4096);
 	cl_assert(git_buf_oom(&buf) == 0);
-	cl_assert_strequal(test_4096, git_buf_cstr(&buf));
+	cl_assert_equal_s(test_4096, git_buf_cstr(&buf));
 
 	/* append string */
 	git_buf_puts(&buf, test_4096);
 	cl_assert(git_buf_oom(&buf) == 0);
-	cl_assert_strequal(test_8192, git_buf_cstr(&buf));
+	cl_assert_equal_s(test_8192, git_buf_cstr(&buf));
 
 	/* set to string again (should overwrite - not append) */
 	git_buf_set(&buf, test_4096, 4096);
 	cl_assert(git_buf_oom(&buf) == 0);
-	cl_assert_strequal(test_4096, git_buf_cstr(&buf));
+	cl_assert_equal_s(test_4096, git_buf_cstr(&buf));
 
 	git_buf_free(&buf);
 }
@@ -192,22 +192,22 @@ void test_core_buffer__4(void)
 		cl_assert(strlen(git_buf_cstr(&buf)) == (size_t)((i + 1) * 2));
 	}
 	/* we have appended 1234 10x and removed the first 20 letters */
-	cl_assert_strequal("12341234123412341234", git_buf_cstr(&buf));
+	cl_assert_equal_s("12341234123412341234", git_buf_cstr(&buf));
 
 	git_buf_consume(&buf, NULL);
-	cl_assert_strequal("12341234123412341234", git_buf_cstr(&buf));
+	cl_assert_equal_s("12341234123412341234", git_buf_cstr(&buf));
 
 	git_buf_consume(&buf, "invalid pointer");
-	cl_assert_strequal("12341234123412341234", git_buf_cstr(&buf));
+	cl_assert_equal_s("12341234123412341234", git_buf_cstr(&buf));
 
 	git_buf_consume(&buf, buf.ptr);
-	cl_assert_strequal("12341234123412341234", git_buf_cstr(&buf));
+	cl_assert_equal_s("12341234123412341234", git_buf_cstr(&buf));
 
 	git_buf_consume(&buf, buf.ptr + 1);
-	cl_assert_strequal("2341234123412341234", git_buf_cstr(&buf));
+	cl_assert_equal_s("2341234123412341234", git_buf_cstr(&buf));
 
 	git_buf_consume(&buf, buf.ptr + buf.size);
-	cl_assert_strequal("", git_buf_cstr(&buf));
+	cl_assert_equal_s("", git_buf_cstr(&buf));
 
 	git_buf_free(&buf);
 }
@@ -227,7 +227,7 @@ check_buf_append(
 	cl_assert(git_buf_oom(&tgt) == 0);
 	git_buf_puts(&tgt, data_b);
 	cl_assert(git_buf_oom(&tgt) == 0);
-	cl_assert_strequal(expected_data, git_buf_cstr(&tgt));
+	cl_assert_equal_s(expected_data, git_buf_cstr(&tgt));
 	cl_assert(tgt.size == expected_size);
 	if (expected_asize > 0)
 		cl_assert(tgt.asize == expected_asize);
@@ -250,27 +250,27 @@ check_buf_append_abc(
 
 	git_buf_sets(&buf, buf_a);
 	cl_assert(git_buf_oom(&buf) == 0);
-	cl_assert_strequal(buf_a, git_buf_cstr(&buf));
+	cl_assert_equal_s(buf_a, git_buf_cstr(&buf));
 
 	git_buf_puts(&buf, buf_b);
 	cl_assert(git_buf_oom(&buf) == 0);
-	cl_assert_strequal(expected_ab, git_buf_cstr(&buf));
+	cl_assert_equal_s(expected_ab, git_buf_cstr(&buf));
 
 	git_buf_puts(&buf, buf_c);
 	cl_assert(git_buf_oom(&buf) == 0);
-	cl_assert_strequal(expected_abc, git_buf_cstr(&buf));
+	cl_assert_equal_s(expected_abc, git_buf_cstr(&buf));
 
 	git_buf_puts(&buf, buf_a);
 	cl_assert(git_buf_oom(&buf) == 0);
-	cl_assert_strequal(expected_abca, git_buf_cstr(&buf));
+	cl_assert_equal_s(expected_abca, git_buf_cstr(&buf));
 
 	git_buf_puts(&buf, buf_b);
 	cl_assert(git_buf_oom(&buf) == 0);
-	cl_assert_strequal(expected_abcab, git_buf_cstr(&buf));
+	cl_assert_equal_s(expected_abcab, git_buf_cstr(&buf));
 
 	git_buf_puts(&buf, buf_c);
 	cl_assert(git_buf_oom(&buf) == 0);
-	cl_assert_strequal(expected_abcabc, git_buf_cstr(&buf));
+	cl_assert_equal_s(expected_abcabc, git_buf_cstr(&buf));
 
 	git_buf_free(&buf);
 }
@@ -330,13 +330,13 @@ void test_core_buffer__6(void)
 	git_buf_sets(&b, "bar");
 	cl_assert(git_buf_oom(&b) == 0);
 
-	cl_assert_strequal("foo", git_buf_cstr(&a));
-	cl_assert_strequal("bar", git_buf_cstr(&b));
+	cl_assert_equal_s("foo", git_buf_cstr(&a));
+	cl_assert_equal_s("bar", git_buf_cstr(&b));
 
 	git_buf_swap(&a, &b);
 
-	cl_assert_strequal("bar", git_buf_cstr(&a));
-	cl_assert_strequal("foo", git_buf_cstr(&b));
+	cl_assert_equal_s("bar", git_buf_cstr(&a));
+	cl_assert_equal_s("foo", git_buf_cstr(&b));
 
 	git_buf_free(&a);
 	git_buf_free(&b);
@@ -352,25 +352,25 @@ void test_core_buffer__7(void)
 
 	git_buf_sets(&a, "foo");
 	cl_assert(git_buf_oom(&a) == 0);
-	cl_assert_strequal("foo", git_buf_cstr(&a));
+	cl_assert_equal_s("foo", git_buf_cstr(&a));
 
 	b = git_buf_detach(&a);
 
-	cl_assert_strequal("foo", b);
-	cl_assert_strequal("", a.ptr);
+	cl_assert_equal_s("foo", b);
+	cl_assert_equal_s("", a.ptr);
 	git__free(b);
 
 	b = git_buf_detach(&a);
 
-	cl_assert_strequal(NULL, b);
-	cl_assert_strequal("", a.ptr);
+	cl_assert_equal_s(NULL, b);
+	cl_assert_equal_s("", a.ptr);
 
 	git_buf_free(&a);
 
 	b = git__strdup(fun);
 	git_buf_attach(&a, b, 0);
 
-	cl_assert_strequal(fun, a.ptr);
+	cl_assert_equal_s(fun, a.ptr);
 	cl_assert(a.size == strlen(fun));
 	cl_assert(a.asize == strlen(fun) + 1);
 
@@ -379,7 +379,7 @@ void test_core_buffer__7(void)
 	b = git__strdup(fun);
 	git_buf_attach(&a, b, strlen(fun) + 1);
 
-	cl_assert_strequal(fun, a.ptr);
+	cl_assert_equal_s(fun, a.ptr);
 	cl_assert(a.size == strlen(fun));
 	cl_assert(a.asize == strlen(fun) + 1);
 
@@ -398,7 +398,7 @@ check_joinbuf_2(
 
 	git_buf_join(&buf, sep, a, b);
 	cl_assert(git_buf_oom(&buf) == 0);
-	cl_assert_strequal(expected, git_buf_cstr(&buf));
+	cl_assert_equal_s(expected, git_buf_cstr(&buf));
 	git_buf_free(&buf);
 }
 
@@ -416,7 +416,7 @@ check_joinbuf_n_2(
 
 	git_buf_join_n(&buf, sep, 1, b);
 	cl_assert(git_buf_oom(&buf) == 0);
-	cl_assert_strequal(expected, git_buf_cstr(&buf));
+	cl_assert_equal_s(expected, git_buf_cstr(&buf));
 
 	git_buf_free(&buf);
 }
@@ -433,7 +433,7 @@ check_joinbuf_n_4(
 	git_buf buf = GIT_BUF_INIT;
 	git_buf_join_n(&buf, sep, 4, a, b, c, d);
 	cl_assert(git_buf_oom(&buf) == 0);
-	cl_assert_strequal(expected, git_buf_cstr(&buf));
+	cl_assert_equal_s(expected, git_buf_cstr(&buf));
 	git_buf_free(&buf);
 }
 
@@ -444,15 +444,15 @@ void test_core_buffer__8(void)
 
 	git_buf_join_n(&a, '/', 1, "foo");
 	cl_assert(git_buf_oom(&a) == 0);
-	cl_assert_strequal("foo", git_buf_cstr(&a));
+	cl_assert_equal_s("foo", git_buf_cstr(&a));
 
 	git_buf_join_n(&a, '/', 1, "bar");
 	cl_assert(git_buf_oom(&a) == 0);
-	cl_assert_strequal("foo/bar", git_buf_cstr(&a));
+	cl_assert_equal_s("foo/bar", git_buf_cstr(&a));
 
 	git_buf_join_n(&a, '/', 1, "baz");
 	cl_assert(git_buf_oom(&a) == 0);
-	cl_assert_strequal("foo/bar/baz", git_buf_cstr(&a));
+	cl_assert_equal_s("foo/bar/baz", git_buf_cstr(&a));
 
 	git_buf_free(&a);
 
@@ -536,7 +536,7 @@ void test_core_buffer__9(void)
 		for (j = 0; j < sizeof(b) / sizeof(char*); ++j) {
 			for (i = 0; i < sizeof(a) / sizeof(char*); ++i) {
 				git_buf_join(&buf, separator, a[i], b[j]);
-				cl_assert_strequal(*expect, buf.ptr);
+				cl_assert_equal_s(*expect, buf.ptr);
 				expect++;
 			}
 		}
@@ -550,14 +550,14 @@ void test_core_buffer__10(void)
 	git_buf a = GIT_BUF_INIT;
 
 	cl_git_pass(git_buf_join_n(&a, '/', 1, "test"));
-	cl_assert_strequal(a.ptr, "test");
+	cl_assert_equal_s(a.ptr, "test");
 	cl_git_pass(git_buf_join_n(&a, '/', 1, "string"));
-	cl_assert_strequal(a.ptr, "test/string");
+	cl_assert_equal_s(a.ptr, "test/string");
 	git_buf_clear(&a);
 	cl_git_pass(git_buf_join_n(&a, '/', 3, "test", "string", "join"));
-	cl_assert_strequal(a.ptr, "test/string/join");
+	cl_assert_equal_s(a.ptr, "test/string/join");
 	cl_git_pass(git_buf_join_n(&a, '/', 2, a.ptr, "more"));
-	cl_assert_strequal(a.ptr, "test/string/join/test/string/join/more");
+	cl_assert_equal_s(a.ptr, "test/string/join/test/string/join/more");
 
 	git_buf_free(&a);
 }
diff --git a/tests-clar/core/errors.c b/tests-clar/core/errors.c
index c781000..78f811c 100644
--- a/tests-clar/core/errors.c
+++ b/tests-clar/core/errors.c
@@ -42,12 +42,14 @@ void test_core_errors__new_school(void)
 	cl_assert(str_in_error != NULL);
 
 	git_error_clear();
+	cl_assert(git_error_last() == NULL);
 
-	{
+	do {
 		struct stat st;
+		memset(&st, 0, sizeof(st));
 		assert(p_lstat("this_file_does_not_exist", &st) < 0);
 		GIT_UNUSED(st);
-	}
+	} while (false);
 	giterr_set(GITERR_OS, "stat failed"); /* internal fn */
 
 	cl_assert(git_error_last() != NULL);
diff --git a/tests-clar/core/path.c b/tests-clar/core/path.c
index 2654ef7..f02e0f7 100644
--- a/tests-clar/core/path.c
+++ b/tests-clar/core/path.c
@@ -8,11 +8,11 @@ check_dirname(const char *A, const char *B)
 	char *dir2;
 
 	cl_assert(git_path_dirname_r(&dir, A) >= 0);
-	cl_assert_strequal(B, dir.ptr);
+	cl_assert_equal_s(B, dir.ptr);
 	git_buf_free(&dir);
 
 	cl_assert((dir2 = git_path_dirname(A)) != NULL);
-	cl_assert_strequal(B, dir2);
+	cl_assert_equal_s(B, dir2);
 	git__free(dir2);
 }
 
@@ -23,11 +23,11 @@ check_basename(const char *A, const char *B)
 	char *base2;
 
 	cl_assert(git_path_basename_r(&base, A) >= 0);
-	cl_assert_strequal(B, base.ptr);
+	cl_assert_equal_s(B, base.ptr);
 	git_buf_free(&base);
 
 	cl_assert((base2 = git_path_basename(A)) != NULL);
-	cl_assert_strequal(B, base2);
+	cl_assert_equal_s(B, base2);
 	git__free(base2);
 }
 
@@ -37,7 +37,7 @@ check_topdir(const char *A, const char *B)
 	const char *dir;
 
 	cl_assert((dir = git_path_topdir(A)) != NULL);
-	cl_assert_strequal(B, dir);
+	cl_assert_equal_s(B, dir);
 }
 
 static void
@@ -46,7 +46,7 @@ check_joinpath(const char *path_a, const char *path_b, const char *expected_path
 	git_buf joined_path = GIT_BUF_INIT;
 
 	cl_git_pass(git_buf_joinpath(&joined_path, path_a, path_b));
-	cl_assert_strequal(expected_path, joined_path.ptr);
+	cl_assert_equal_s(expected_path, joined_path.ptr);
 
 	git_buf_free(&joined_path);
 }
@@ -63,7 +63,7 @@ check_joinpath_n(
 
 	cl_git_pass(git_buf_join_n(&joined_path, '/', 4,
 							   path_a, path_b, path_c, path_d));
-	cl_assert_strequal(expected_path, joined_path.ptr);
+	cl_assert_equal_s(expected_path, joined_path.ptr);
 
 	git_buf_free(&joined_path);
 }
@@ -189,7 +189,7 @@ check_path_to_dir(
 
 	git_buf_sets(&tgt, path);
 	cl_git_pass(git_path_to_dir(&tgt));
-	cl_assert_strequal(expected, tgt.ptr);
+	cl_assert_equal_s(expected, tgt.ptr);
 
 	git_buf_free(&tgt);
 }
@@ -197,16 +197,18 @@ check_path_to_dir(
 static void
 check_string_to_dir(
 	const char* path,
-	int         maxlen,
+	size_t      maxlen,
     const char* expected)
 {
-	int  len = strlen(path);
+	size_t len = strlen(path);
 	char *buf = git__malloc(len + 2);
+	cl_assert(buf);
+
 	strncpy(buf, path, len + 2);
 
 	git_path_string_to_dir(buf, maxlen);
 
-	cl_assert_strequal(expected, buf);
+	cl_assert_equal_s(expected, buf);
 
 	git__free(buf);
 }
@@ -247,28 +249,28 @@ void test_core_path__08_self_join(void)
 
 	asize = path.asize;
 	cl_git_pass(git_buf_sets(&path, "/foo"));
-	cl_assert_strequal(path.ptr, "/foo");
+	cl_assert_equal_s(path.ptr, "/foo");
 	cl_assert(asize < path.asize);
 
 	asize = path.asize;
 	cl_git_pass(git_buf_joinpath(&path, path.ptr, "this is a new string"));
-	cl_assert_strequal(path.ptr, "/foo/this is a new string");
+	cl_assert_equal_s(path.ptr, "/foo/this is a new string");
 	cl_assert(asize < path.asize);
 
 	asize = path.asize;
 	cl_git_pass(git_buf_joinpath(&path, path.ptr, "/grow the buffer, grow the buffer, grow the buffer"));
-	cl_assert_strequal(path.ptr, "/foo/this is a new string/grow the buffer, grow the buffer, grow the buffer");
+	cl_assert_equal_s(path.ptr, "/foo/this is a new string/grow the buffer, grow the buffer, grow the buffer");
 	cl_assert(asize < path.asize);
 
 	git_buf_free(&path);
 	cl_git_pass(git_buf_sets(&path, "/foo/bar"));
 
 	cl_git_pass(git_buf_joinpath(&path, path.ptr + 4, "baz"));
-	cl_assert_strequal(path.ptr, "/bar/baz");
+	cl_assert_equal_s(path.ptr, "/bar/baz");
 
 	asize = path.asize;
 	cl_git_pass(git_buf_joinpath(&path, path.ptr + 4, "somethinglongenoughtorealloc"));
-	cl_assert_strequal(path.ptr, "/baz/somethinglongenoughtorealloc");
+	cl_assert_equal_s(path.ptr, "/baz/somethinglongenoughtorealloc");
 	cl_assert(asize < path.asize);
 	
 	git_buf_free(&path);
@@ -279,7 +281,7 @@ static void check_percent_decoding(const char *expected_result, const char *inpu
 	git_buf buf = GIT_BUF_INIT;
 
 	cl_git_pass(git__percent_decode(&buf, input));
-	cl_assert_strequal(expected_result, git_buf_cstr(&buf));
+	cl_assert_equal_s(expected_result, git_buf_cstr(&buf));
 
 	git_buf_free(&buf);
 }
@@ -306,7 +308,7 @@ static void check_fromurl(const char *expected_result, const char *input, int sh
 
 	if (!should_fail) {
 		cl_git_pass(git_path_fromurl(&buf, input));
-		cl_assert_strequal(expected_result, git_buf_cstr(&buf));
+		cl_assert_equal_s(expected_result, git_buf_cstr(&buf));
 	} else
 		cl_git_fail(git_path_fromurl(&buf, input));
 
@@ -346,7 +348,7 @@ static int check_one_walkup_step(void *ref, git_buf *path)
 {
 	check_walkup_info *info = (check_walkup_info *)ref;
 	cl_assert(info->expect[info->expect_idx] != NULL);
-	cl_assert_strequal(info->expect[info->expect_idx], path->ptr);
+	cl_assert_equal_s(info->expect[info->expect_idx], path->ptr);
 	info->expect_idx++;
 	return 0;
 }
@@ -380,7 +382,7 @@ void test_core_path__11_walkup(void)
 			git_path_walk_up(&p, root[j], check_one_walkup_step, &info)
 		);
 
-		cl_assert_strequal(p.ptr, expect[i]);
+		cl_assert_equal_s(p.ptr, expect[i]);
 
 		/* skip to next run of expectations */
 		while (expect[i] != NULL) i++;
diff --git a/tests-clar/diff/iterator.c b/tests-clar/diff/iterator.c
index 60f416f..0ec2326 100644
--- a/tests-clar/diff/iterator.c
+++ b/tests-clar/diff/iterator.c
@@ -37,7 +37,7 @@ static void tree_iterator_test(
 
 	while (entry != NULL) {
 		if (expected_values != NULL)
-			cl_assert_strequal(expected_values[count], entry->path);
+			cl_assert_equal_s(expected_values[count], entry->path);
 
 		count++;
 
@@ -192,7 +192,7 @@ static void index_iterator_test(
 
 	while (entry != NULL) {
 		if (expected_names != NULL)
-			cl_assert_strequal(expected_names[count], entry->path);
+			cl_assert_equal_s(expected_names[count], entry->path);
 
 		if (expected_oids != NULL) {
 			git_oid oid;
@@ -330,7 +330,7 @@ static void workdir_iterator_test(
 		}
 
 		if (expected_names != NULL)
-			cl_assert_strequal(expected_names[count_all], entry->path);
+			cl_assert_equal_s(expected_names[count_all], entry->path);
 
 		if (an_ignored_name && strcmp(an_ignored_name,entry->path)==0)
 			cl_assert(ignored);
diff --git a/tests-clar/diff/tree.c b/tests-clar/diff/tree.c
index 91e1343..1e269ae 100644
--- a/tests-clar/diff/tree.c
+++ b/tests-clar/diff/tree.c
@@ -149,15 +149,15 @@ void test_diff_tree__options(void)
 			diff, &actual, diff_file_fn, diff_hunk_fn, diff_line_fn));
 
 		expected = &test_expects[i];
-		cl_assert_intequal(actual.files,     expected->files);
-		cl_assert_intequal(actual.file_adds, expected->file_adds);
- 		cl_assert_intequal(actual.file_dels, expected->file_dels);
-		cl_assert_intequal(actual.file_mods, expected->file_mods);
-		cl_assert_intequal(actual.hunks,     expected->hunks);
-		cl_assert_intequal(actual.lines,     expected->lines);
-		cl_assert_intequal(actual.line_ctxt, expected->line_ctxt);
-		cl_assert_intequal(actual.line_adds, expected->line_adds);
-		cl_assert_intequal(actual.line_dels, expected->line_dels);
+		cl_assert_equal_i(actual.files,     expected->files);
+		cl_assert_equal_i(actual.file_adds, expected->file_adds);
+ 		cl_assert_equal_i(actual.file_dels, expected->file_dels);
+		cl_assert_equal_i(actual.file_mods, expected->file_mods);
+		cl_assert_equal_i(actual.hunks,     expected->hunks);
+		cl_assert_equal_i(actual.lines,     expected->lines);
+		cl_assert_equal_i(actual.line_ctxt, expected->line_ctxt);
+		cl_assert_equal_i(actual.line_adds, expected->line_adds);
+		cl_assert_equal_i(actual.line_dels, expected->line_dels);
 
 		git_diff_list_free(diff);
 		diff = NULL;
diff --git a/tests-clar/diff/workdir.c b/tests-clar/diff/workdir.c
index 2a93039..1ea1af8 100644
--- a/tests-clar/diff/workdir.c
+++ b/tests-clar/diff/workdir.c
@@ -37,19 +37,19 @@ void test_diff_workdir__to_index(void)
 	 * - git diff
 	 * - mv .git .gitted
 	 */
-	cl_assert_intequal(12, exp.files);
-	cl_assert_intequal(0, exp.file_adds);
-	cl_assert_intequal(4, exp.file_dels);
-	cl_assert_intequal(4, exp.file_mods);
-	cl_assert_intequal(1, exp.file_ignored);
-	cl_assert_intequal(3, exp.file_untracked);
-
-	cl_assert_intequal(8, exp.hunks);
-
-	cl_assert_intequal(14, exp.lines);
-	cl_assert_intequal(5, exp.line_ctxt);
-	cl_assert_intequal(4, exp.line_adds);
-	cl_assert_intequal(5, exp.line_dels);
+	cl_assert_equal_i(12, exp.files);
+	cl_assert_equal_i(0, exp.file_adds);
+	cl_assert_equal_i(4, exp.file_dels);
+	cl_assert_equal_i(4, exp.file_mods);
+	cl_assert_equal_i(1, exp.file_ignored);
+	cl_assert_equal_i(3, exp.file_untracked);
+
+	cl_assert_equal_i(8, exp.hunks);
+
+	cl_assert_equal_i(14, exp.lines);
+	cl_assert_equal_i(5, exp.line_ctxt);
+	cl_assert_equal_i(4, exp.line_adds);
+	cl_assert_equal_i(5, exp.line_dels);
 
 	git_diff_list_free(diff);
 }