diff: introduce binary diff callbacks

Introduce a new binary diff callback to provide the actual binary
delta contents to callers.  Create this data from the diff contents
(instead of directly from the ODB) to support binary diffs including
the workdir, not just things coming out of the ODB.

9 files changed, 182 insertions, 163 deletions

diff --git a/tests/diff/blob.c b/tests/diff/blob.c
index 51bdbab15..b0253f6dc 100644
--- a/tests/diff/blob.c
+++ b/tests/diff/blob.c
@@ -17,7 +17,7 @@ static void quick_diff_blob_to_str(
 
 	cl_git_pass(git_diff_blob_to_buffer(
 		blob, blob_path, str, len, str_path,
-		&opts, diff_file_cb, diff_hunk_cb, diff_line_cb, &expected));
+		&opts, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &expected));
 }
 
 void test_diff_blob__initialize(void)
@@ -88,7 +88,7 @@ void test_diff_blob__can_compare_text_blobs(void)
 	memset(&expected, 0, sizeof(expected));
 	cl_git_pass(git_diff_blobs(
 		a, NULL, b, NULL, &opts,
-		diff_file_cb, diff_hunk_cb, diff_line_cb, &expected));
+		diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &expected));
 	assert_one_modified(1, 6, 1, 5, 0, &expected);
 
 	/* same diff but use direct buffers */
@@ -96,27 +96,27 @@ void test_diff_blob__can_compare_text_blobs(void)
 	cl_git_pass(git_diff_buffers(
 		git_blob_rawcontent(a), (size_t)git_blob_rawsize(a), NULL,
 		git_blob_rawcontent(b), (size_t)git_blob_rawsize(b), NULL, &opts,
-		diff_file_cb, diff_hunk_cb, diff_line_cb, &expected));
+		diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &expected));
 	assert_one_modified(1, 6, 1, 5, 0, &expected);
 
 	/* diff on tests/resources/attr/root_test2 */
 	memset(&expected, 0, sizeof(expected));
 	cl_git_pass(git_diff_blobs(
 		b, NULL, c, NULL, &opts,
-		diff_file_cb, diff_hunk_cb, diff_line_cb, &expected));
+		diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &expected));
 	assert_one_modified(1, 15, 3, 9, 3, &expected);
 
 	/* diff on tests/resources/attr/root_test3 */
 	memset(&expected, 0, sizeof(expected));
 	cl_git_pass(git_diff_blobs(
 		a, NULL, c, NULL, &opts,
-		diff_file_cb, diff_hunk_cb, diff_line_cb, &expected));
+		diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &expected));
 	assert_one_modified(1, 13, 0, 12, 1, &expected);
 
 	memset(&expected, 0, sizeof(expected));
 	cl_git_pass(git_diff_blobs(
 		c, NULL, d, NULL, &opts,
-		diff_file_cb, diff_hunk_cb, diff_line_cb, &expected));
+		diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &expected));
 	assert_one_modified(2, 14, 4, 6, 4, &expected);
 
 	git_blob_free(a);
@@ -206,7 +206,7 @@ void test_diff_blob__can_compare_against_null_blobs(void)
 
 	cl_git_pass(git_diff_blobs(
 		d, NULL, e, NULL, &opts,
-		diff_file_cb, diff_hunk_cb, diff_line_cb, &expected));
+		diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &expected));
 
 	cl_assert_equal_i(1, expected.files);
 	cl_assert_equal_i(1, expected.file_status[GIT_DELTA_DELETED]);
@@ -222,7 +222,7 @@ void test_diff_blob__can_compare_against_null_blobs(void)
 
 	cl_git_pass(git_diff_blobs(
 		d, NULL, e, NULL, &opts,
-		diff_file_cb, diff_hunk_cb, diff_line_cb, &expected));
+		diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &expected));
 
 	cl_assert_equal_i(1, expected.files);
 	cl_assert_equal_i(1, expected.file_status[GIT_DELTA_ADDED]);
@@ -238,7 +238,7 @@ void test_diff_blob__can_compare_against_null_blobs(void)
 
 	cl_git_pass(git_diff_blobs(
 		alien, NULL, NULL, NULL, &opts,
-		diff_file_cb, diff_hunk_cb, diff_line_cb, &expected));
+		diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &expected));
 
 	cl_assert_equal_i(1, expected.files);
 	cl_assert_equal_i(1, expected.files_binary);
@@ -250,7 +250,7 @@ void test_diff_blob__can_compare_against_null_blobs(void)
 
 	cl_git_pass(git_diff_blobs(
 		NULL, NULL, alien, NULL, &opts,
-		diff_file_cb, diff_hunk_cb, diff_line_cb, &expected));
+		diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &expected));
 
 	cl_assert_equal_i(1, expected.files);
 	cl_assert_equal_i(1, expected.files_binary);
@@ -358,7 +358,7 @@ void test_diff_blob__can_compare_identical_blobs(void)
 
 	cl_git_pass(git_diff_blobs(
 		d, NULL, d, NULL, &opts,
-		diff_file_cb, diff_hunk_cb, diff_line_cb, &expected));
+		diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &expected));
 
 	assert_identical_blobs_comparison(&expected);
 	cl_assert_equal_i(0, expected.files_binary);
@@ -366,7 +366,7 @@ void test_diff_blob__can_compare_identical_blobs(void)
 	memset(&expected, 0, sizeof(expected));
 	cl_git_pass(git_diff_blobs(
 		NULL, NULL, NULL, NULL, &opts,
-		diff_file_cb, diff_hunk_cb, diff_line_cb, &expected));
+		diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &expected));
 
 	assert_identical_blobs_comparison(&expected);
 	cl_assert_equal_i(0, expected.files_binary);
@@ -374,7 +374,7 @@ void test_diff_blob__can_compare_identical_blobs(void)
 	memset(&expected, 0, sizeof(expected));
 	cl_git_pass(git_diff_blobs(
 		alien, NULL, alien, NULL, &opts,
-		diff_file_cb, diff_hunk_cb, diff_line_cb, &expected));
+		diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &expected));
 
 	assert_identical_blobs_comparison(&expected);
 	cl_assert(expected.files_binary > 0);
@@ -441,7 +441,7 @@ void test_diff_blob__can_compare_two_binary_blobs(void)
 
 	cl_git_pass(git_diff_blobs(
 		alien, NULL, heart, NULL, &opts,
-		diff_file_cb, diff_hunk_cb, diff_line_cb, &expected));
+		diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &expected));
 
 	assert_binary_blobs_comparison(&expected);
 
@@ -449,7 +449,7 @@ void test_diff_blob__can_compare_two_binary_blobs(void)
 
 	cl_git_pass(git_diff_blobs(
 		heart, NULL, alien, NULL, &opts,
-		diff_file_cb, diff_hunk_cb, diff_line_cb, &expected));
+		diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &expected));
 
 	assert_binary_blobs_comparison(&expected);
 
@@ -460,7 +460,7 @@ void test_diff_blob__can_compare_a_binary_blob_and_a_text_blob(void)
 {
 	cl_git_pass(git_diff_blobs(
 		alien, NULL, d, NULL, &opts,
-		diff_file_cb, diff_hunk_cb, diff_line_cb, &expected));
+		diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &expected));
 
 	assert_binary_blobs_comparison(&expected);
 
@@ -468,7 +468,7 @@ void test_diff_blob__can_compare_a_binary_blob_and_a_text_blob(void)
 
 	cl_git_pass(git_diff_blobs(
 		d, NULL, alien, NULL, &opts,
-		diff_file_cb, diff_hunk_cb, diff_line_cb, &expected));
+		diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &expected));
 
 	assert_binary_blobs_comparison(&expected);
 }
@@ -510,7 +510,7 @@ void test_diff_blob__comparing_two_text_blobs_honors_interhunkcontext(void)
 	/* Test with default inter-hunk-context (not set) => default is 0 */
 	cl_git_pass(git_diff_blobs(
 		old_d, NULL, d, NULL, &opts,
-		diff_file_cb, diff_hunk_cb, diff_line_cb, &expected));
+		diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &expected));
 
 	cl_assert_equal_i(2, expected.hunks);
 
@@ -519,7 +519,7 @@ void test_diff_blob__comparing_two_text_blobs_honors_interhunkcontext(void)
 	memset(&expected, 0, sizeof(expected));
 	cl_git_pass(git_diff_blobs(
 		old_d, NULL, d, NULL, &opts,
-		diff_file_cb, diff_hunk_cb, diff_line_cb, &expected));
+		diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &expected));
 
 	cl_assert_equal_i(2, expected.hunks);
 
@@ -528,7 +528,7 @@ void test_diff_blob__comparing_two_text_blobs_honors_interhunkcontext(void)
 	memset(&expected, 0, sizeof(expected));
 	cl_git_pass(git_diff_blobs(
 		old_d, NULL, d, NULL, &opts,
-		diff_file_cb, diff_hunk_cb, diff_line_cb, &expected));
+		diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &expected));
 
 	cl_assert_equal_i(1, expected.hunks);
 
@@ -542,7 +542,7 @@ void test_diff_blob__checks_options_version_too_low(void)
 	opts.version = 0;
 	cl_git_fail(git_diff_blobs(
 		d, NULL, alien, NULL, &opts,
-		diff_file_cb, diff_hunk_cb, diff_line_cb, &expected));
+		diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &expected));
 	err = giterr_last();
 	cl_assert_equal_i(GITERR_INVALID, err->klass);
 }
@@ -554,7 +554,7 @@ void test_diff_blob__checks_options_version_too_high(void)
 	opts.version = 1024;
 	cl_git_fail(git_diff_blobs(
 		d, NULL, alien, NULL, &opts,
-		diff_file_cb, diff_hunk_cb, diff_line_cb, &expected));
+		diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &expected));
 	err = giterr_last();
 	cl_assert_equal_i(GITERR_INVALID, err->klass);
 }
@@ -752,7 +752,7 @@ void test_diff_blob__binary_data_comparisons(void)
 	memset(&expected, 0, sizeof(expected));
 	cl_git_pass(git_diff_blobs(
 		bin, NULL, nonbin, NULL, &opts,
-		diff_file_cb, diff_hunk_cb, diff_line_cb, &expected));
+		diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &expected));
 	assert_binary_blobs_comparison(&expected);
 
 	/*
@@ -773,7 +773,7 @@ void test_diff_blob__binary_data_comparisons(void)
 	memset(&expected, 0, sizeof(expected));
 	cl_git_pass(git_diff_blobs(
 		bin, NULL, nonbin, NULL, &opts,
-		diff_file_cb, diff_hunk_cb, diff_line_cb, &expected));
+		diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &expected));
 	assert_one_modified_with_lines(&expected, 4);
 
 	/* cleanup */
@@ -993,8 +993,8 @@ void test_diff_blob__can_compare_buffer_to_buffer(void)
 	memset(&expected, 0, sizeof(expected));
 
 	cl_git_pass(git_diff_buffers(
-		a, strlen(a), NULL, b, strlen(b), NULL,
-		&opts, diff_file_cb, diff_hunk_cb, diff_line_cb, &expected));
+		a, strlen(a), NULL, b, strlen(b), NULL, &opts,
+		diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &expected));
 	assert_one_modified(4, 9, 0, 4, 5, &expected);
 
 	opts.flags ^= GIT_DIFF_REVERSE;
@@ -1002,7 +1002,7 @@ void test_diff_blob__can_compare_buffer_to_buffer(void)
 	memset(&expected, 0, sizeof(expected));
 
 	cl_git_pass(git_diff_buffers(
-		a, strlen(a), NULL, b, strlen(b), NULL,
-		&opts, diff_file_cb, diff_hunk_cb, diff_line_cb, &expected));
+		a, strlen(a), NULL, b, strlen(b), NULL, &opts,
+		diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &expected));
 	assert_one_modified(4, 9, 0, 5, 4, &expected);
 }
diff --git a/tests/diff/diff_helpers.c b/tests/diff/diff_helpers.c
index 03862d6b4..c7352571c 100644
--- a/tests/diff/diff_helpers.c
+++ b/tests/diff/diff_helpers.c
@@ -91,6 +91,18 @@ int diff_print_file_cb(
 	return diff_file_cb(delta, progress, payload);
 }
 
+int diff_binary_cb(
+	const git_diff_delta *delta,
+	const git_diff_binary *binary,
+	void *payload)
+{
+	GIT_UNUSED(delta);
+	GIT_UNUSED(binary);
+	GIT_UNUSED(payload);
+
+	return 0;
+}
+
 int diff_hunk_cb(
 	const git_diff_delta *delta,
 	const git_diff_hunk *hunk,
@@ -145,6 +157,7 @@ int diff_line_cb(
 int diff_foreach_via_iterator(
 	git_diff *diff,
 	git_diff_file_cb file_cb,
+	git_diff_binary_cb binary_cb,
 	git_diff_hunk_cb hunk_cb,
 	git_diff_line_cb line_cb,
 	void *data)
diff --git a/tests/diff/diff_helpers.h b/tests/diff/diff_helpers.h
index 6bcd1e671..4d3cd3474 100644
--- a/tests/diff/diff_helpers.h
+++ b/tests/diff/diff_helpers.h
@@ -42,6 +42,11 @@ extern int diff_print_file_cb(
 	float progress,
 	void *cb_data);
 
+extern int diff_binary_cb(
+	const git_diff_delta *delta,
+	const git_diff_binary *binary,
+	void *cb_data);
+
 extern int diff_hunk_cb(
 	const git_diff_delta *delta,
 	const git_diff_hunk *hunk,
@@ -56,6 +61,7 @@ extern int diff_line_cb(
 extern int diff_foreach_via_iterator(
 	git_diff *diff,
 	git_diff_file_cb file_cb,
+	git_diff_binary_cb binary_cb,
 	git_diff_hunk_cb hunk_cb,
 	git_diff_line_cb line_cb,
 	void *data);
diff --git a/tests/diff/index.c b/tests/diff/index.c
index cf883f12a..242fb0046 100644
--- a/tests/diff/index.c
+++ b/tests/diff/index.c
@@ -35,7 +35,7 @@ void test_diff_index__0(void)
 	cl_git_pass(git_diff_tree_to_index(&diff, g_repo, a, NULL, &opts));
 
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 
 	/* to generate these values:
 	 * - cd to tests/resources/status,
@@ -63,7 +63,7 @@ void test_diff_index__0(void)
 	cl_git_pass(git_diff_tree_to_index(&diff, g_repo, b, NULL, &opts));
 
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 
 	/* to generate these values:
 	 * - cd to tests/resources/status,
@@ -127,8 +127,8 @@ void test_diff_index__1(void)
 
 	cl_git_pass(git_diff_tree_to_index(&diff, g_repo, a, NULL, &opts));
 
-	cl_assert_equal_i(
-		1, git_diff_foreach(diff, diff_stop_after_2_files, NULL, NULL, &exp) );
+	cl_assert_equal_i(1, git_diff_foreach(
+		diff, diff_stop_after_2_files, NULL, NULL, NULL, &exp) );
 
 	cl_assert_equal_i(2, exp.files);
 
@@ -193,7 +193,7 @@ static void do_conflicted_diff(diff_expects *exp, unsigned long flags)
 	cl_git_pass(git_diff_tree_to_index(&diff, g_repo, a, index, &opts));
 
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, exp));
 
 	git_diff_free(diff);
 	git_tree_free(a);
diff --git a/tests/diff/notify.c b/tests/diff/notify.c
index da7390d3f..6ef4af573 100644
--- a/tests/diff/notify.c
+++ b/tests/diff/notify.c
@@ -59,7 +59,7 @@ static void test_notify(
 	memset(&exp, 0, sizeof(exp));
 
 	cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));
-	cl_git_pass(git_diff_foreach(diff, diff_file_cb, NULL, NULL, &exp));
+	cl_git_pass(git_diff_foreach(diff, diff_file_cb, NULL, NULL, NULL, &exp));
 
 	cl_assert_equal_i(expected_diffed_files_count, exp.files);
 
@@ -222,7 +222,7 @@ void test_diff_notify__notify_cb_can_be_used_as_filtering_function(void)
 	memset(&exp, 0, sizeof(exp));
 
 	cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));
-	cl_git_pass(git_diff_foreach(diff, diff_file_cb, NULL, NULL, &exp));
+	cl_git_pass(git_diff_foreach(diff, diff_file_cb, NULL, NULL, NULL, &exp));
 
 	cl_assert_equal_i(0, exp.files);
 
diff --git a/tests/diff/rename.c b/tests/diff/rename.c
index 8a327f035..5cfd8e235 100644
--- a/tests/diff/rename.c
+++ b/tests/diff/rename.c
@@ -65,7 +65,7 @@ void test_diff_rename__match_oid(void)
 	 */
 	memset(&exp, 0, sizeof(exp));
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 
 	cl_assert_equal_i(4, exp.files);
 	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_UNMODIFIED]);
@@ -81,7 +81,7 @@ void test_diff_rename__match_oid(void)
 
 	memset(&exp, 0, sizeof(exp));
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 
 	cl_assert_equal_i(3, exp.files);
 	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_UNMODIFIED]);
@@ -102,7 +102,7 @@ void test_diff_rename__match_oid(void)
 
 	memset(&exp, 0, sizeof(exp));
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 
 	cl_assert_equal_i(3, exp.files);
 	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_UNMODIFIED]);
@@ -124,7 +124,7 @@ void test_diff_rename__match_oid(void)
 
 	memset(&exp, 0, sizeof(exp));
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 
 	cl_assert_equal_i(3, exp.files);
 	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_UNMODIFIED]);
@@ -204,7 +204,7 @@ void test_diff_rename__not_exact_match(void)
 	 */
 	memset(&exp, 0, sizeof(exp));
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 
 	cl_assert_equal_i(4, exp.files);
 	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_UNMODIFIED]);
@@ -222,7 +222,7 @@ void test_diff_rename__not_exact_match(void)
 
 	memset(&exp, 0, sizeof(exp));
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 
 	cl_assert_equal_i(4, exp.files);
 	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_UNMODIFIED]);
@@ -243,7 +243,7 @@ void test_diff_rename__not_exact_match(void)
 
 	memset(&exp, 0, sizeof(exp));
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 
 	cl_assert_equal_i(4, exp.files);
 	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_UNMODIFIED]);
@@ -266,7 +266,7 @@ void test_diff_rename__not_exact_match(void)
 
 	memset(&exp, 0, sizeof(exp));
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 
 	cl_assert_equal_i(5, exp.files);
 	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_UNMODIFIED]);
@@ -297,7 +297,7 @@ void test_diff_rename__not_exact_match(void)
 	 */
 	memset(&exp, 0, sizeof(exp));
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 
 	cl_assert_equal_i(6, exp.files);
 	cl_assert_equal_i(2, exp.file_status[GIT_DELTA_MODIFIED]);
@@ -317,7 +317,7 @@ void test_diff_rename__not_exact_match(void)
 
 	memset(&exp, 0, sizeof(exp));
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 
 	cl_assert_equal_i(4, exp.files);
 	cl_assert_equal_i(2, exp.file_status[GIT_DELTA_MODIFIED]);
@@ -344,7 +344,7 @@ void test_diff_rename__not_exact_match(void)
 
 	memset(&exp, 0, sizeof(exp));
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 
 	cl_assert_equal_i(5, exp.files);
 	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_MODIFIED]);
@@ -369,7 +369,7 @@ void test_diff_rename__not_exact_match(void)
 
 	memset(&exp, 0, sizeof(exp));
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 
 	cl_assert_equal_i(4, exp.files);
 	cl_assert_equal_i(2, exp.file_status[GIT_DELTA_MODIFIED]);
@@ -469,7 +469,7 @@ void test_diff_rename__working_directory_changes(void)
 	/* git diff --no-renames 2bc7f351d20b53f1c72c16c4b036e491c478c49a */
 	memset(&exp, 0, sizeof(exp));
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 
 	cl_assert_equal_i(6, exp.files);
 	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_MODIFIED]);
@@ -482,7 +482,7 @@ void test_diff_rename__working_directory_changes(void)
 
 	memset(&exp, 0, sizeof(exp));
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 
 	cl_assert_equal_i(5, exp.files);
 	cl_assert_equal_i(2, exp.file_status[GIT_DELTA_RENAMED]);
@@ -508,7 +508,7 @@ void test_diff_rename__working_directory_changes(void)
 
 	memset(&exp, 0, sizeof(exp));
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 
 	cl_assert_equal_i(5, exp.files);
 	cl_assert_equal_i(2, exp.file_status[GIT_DELTA_RENAMED]);
@@ -527,7 +527,7 @@ void test_diff_rename__working_directory_changes(void)
 
 	memset(&exp, 0, sizeof(exp));
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 
 	cl_assert_equal_i(6, exp.files);
 	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_RENAMED]);
@@ -545,7 +545,7 @@ void test_diff_rename__working_directory_changes(void)
 
 	memset(&exp, 0, sizeof(exp));
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 
 	cl_assert_equal_i(6, exp.files);
 	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_MODIFIED]);
@@ -575,7 +575,7 @@ void test_diff_rename__working_directory_changes(void)
 
 	memset(&exp, 0, sizeof(exp));
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 
 	cl_assert_equal_i(5, exp.files);
 	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_MODIFIED]);
@@ -673,7 +673,7 @@ void test_diff_rename__file_exchange(void)
 
 	memset(&exp, 0, sizeof(exp));
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 	cl_assert_equal_i(2, exp.files);
 	cl_assert_equal_i(2, exp.file_status[GIT_DELTA_MODIFIED]);
 
@@ -682,7 +682,7 @@ void test_diff_rename__file_exchange(void)
 
 	memset(&exp, 0, sizeof(exp));
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 	cl_assert_equal_i(2, exp.files);
 	cl_assert_equal_i(2, exp.file_status[GIT_DELTA_RENAMED]);
 
@@ -725,7 +725,7 @@ void test_diff_rename__file_exchange_three(void)
 
 	memset(&exp, 0, sizeof(exp));
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 	cl_assert_equal_i(3, exp.files);
 	cl_assert_equal_i(3, exp.file_status[GIT_DELTA_MODIFIED]);
 
@@ -734,7 +734,7 @@ void test_diff_rename__file_exchange_three(void)
 
 	memset(&exp, 0, sizeof(exp));
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 	cl_assert_equal_i(3, exp.files);
 	cl_assert_equal_i(3, exp.file_status[GIT_DELTA_RENAMED]);
 
@@ -776,7 +776,7 @@ void test_diff_rename__file_partial_exchange(void)
 
 	memset(&exp, 0, sizeof(exp));
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 	cl_assert_equal_i(2, exp.files);
 	cl_assert_equal_i(2, exp.file_status[GIT_DELTA_MODIFIED]);
 
@@ -785,7 +785,7 @@ void test_diff_rename__file_partial_exchange(void)
 
 	memset(&exp, 0, sizeof(exp));
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 	cl_assert_equal_i(3, exp.files);
 	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_RENAMED]);
 	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_ADDED]);
@@ -833,7 +833,7 @@ void test_diff_rename__rename_and_copy_from_same_source(void)
 
 	memset(&exp, 0, sizeof(exp));
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 	cl_assert_equal_i(6, exp.files);
 	cl_assert_equal_i(2, exp.file_status[GIT_DELTA_ADDED]);
 	cl_assert_equal_i(4, exp.file_status[GIT_DELTA_UNMODIFIED]);
@@ -843,7 +843,7 @@ void test_diff_rename__rename_and_copy_from_same_source(void)
 
 	memset(&exp, 0, sizeof(exp));
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 	cl_assert_equal_i(6, exp.files);
 	cl_assert_equal_i(2, exp.file_status[GIT_DELTA_COPIED]);
 	cl_assert_equal_i(4, exp.file_status[GIT_DELTA_UNMODIFIED]);
@@ -885,7 +885,7 @@ void test_diff_rename__from_deleted_to_split(void)
 
 	memset(&exp, 0, sizeof(exp));
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 	cl_assert_equal_i(4, exp.files);
 	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_DELETED]);
 	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_MODIFIED]);
@@ -896,7 +896,7 @@ void test_diff_rename__from_deleted_to_split(void)
 
 	memset(&exp, 0, sizeof(exp));
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 	cl_assert_equal_i(4, exp.files);
 	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_DELETED]);
 	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_RENAMED]);
@@ -998,8 +998,8 @@ void test_diff_rename__rejected_match_can_match_others(void)
 
 	cl_git_pass(git_diff_find_similar(diff, &findopts));
 
-	cl_git_pass(
-		git_diff_foreach(diff, test_names_expected, NULL, NULL, &expect));
+	cl_git_pass(git_diff_foreach(
+		diff, test_names_expected, NULL, NULL, NULL, &expect));
 
 	git_diff_free(diff);
 	git_tree_free(tree);
@@ -1072,8 +1072,8 @@ void test_diff_rename__rejected_match_can_match_others_two(void)
 
 	cl_git_pass(git_diff_find_similar(diff, &findopts));
 
-	cl_git_pass(
-		git_diff_foreach(diff, test_names_expected, NULL, NULL, &expect));
+	cl_git_pass(git_diff_foreach(
+		diff, test_names_expected, NULL, NULL, NULL, &expect));
 	cl_assert(expect.idx > 0);
 
 	git_diff_free(diff);
@@ -1128,8 +1128,8 @@ void test_diff_rename__rejected_match_can_match_others_three(void)
 
 	cl_git_pass(git_diff_find_similar(diff, &findopts));
 
-	cl_git_pass(
-		git_diff_foreach(diff, test_names_expected, NULL, NULL, &expect));
+	cl_git_pass(git_diff_foreach(
+		diff, test_names_expected, NULL, NULL, NULL, &expect));
 
 	cl_assert(expect.idx == expect.len);
 
@@ -1177,8 +1177,8 @@ void test_diff_rename__can_rename_from_rewrite(void)
 
 	cl_git_pass(git_diff_find_similar(diff, &findopts));
 
-	cl_git_pass(
-		git_diff_foreach(diff, test_names_expected, NULL, NULL, &expect));
+	cl_git_pass(git_diff_foreach(
+		diff, test_names_expected, NULL, NULL, NULL, &expect));
 
 	cl_assert(expect.idx == expect.len);
 
@@ -1210,7 +1210,7 @@ void test_diff_rename__case_changes_are_split(void)
 
 	memset(&exp, 0, sizeof(exp));
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 	cl_assert_equal_i(2, exp.files);
 	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_DELETED]);
 	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_ADDED]);
@@ -1220,7 +1220,7 @@ void test_diff_rename__case_changes_are_split(void)
 
 	memset(&exp, 0, sizeof(exp));
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 	cl_assert_equal_i(1, exp.files);
 	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_RENAMED]);
 
@@ -1252,7 +1252,7 @@ void test_diff_rename__unmodified_can_be_renamed(void)
 
 	memset(&exp, 0, sizeof(exp));
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 	cl_assert_equal_i(2, exp.files);
 	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_DELETED]);
 	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_ADDED]);
@@ -1262,13 +1262,13 @@ void test_diff_rename__unmodified_can_be_renamed(void)
 
 	memset(&exp, 0, sizeof(exp));
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 	cl_assert_equal_i(1, exp.files);
 	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_RENAMED]);
 
 	memset(&exp, 0, sizeof(exp));
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 	cl_assert_equal_i(1, exp.files);
 	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_RENAMED]);
 
@@ -1317,7 +1317,7 @@ void test_diff_rename__rewrite_on_single_file(void)
 	memset(&exp, 0, sizeof(exp));
 
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 	cl_assert_equal_i(2, exp.files);
 	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_DELETED]);
 	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_UNTRACKED]);
@@ -1352,7 +1352,7 @@ void test_diff_rename__can_find_copy_to_split(void)
 
 	memset(&exp, 0, sizeof(exp));
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 	cl_assert_equal_i(4, exp.files);
 	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_MODIFIED]);
 	cl_assert_equal_i(3, exp.file_status[GIT_DELTA_UNMODIFIED]);
@@ -1362,7 +1362,7 @@ void test_diff_rename__can_find_copy_to_split(void)
 
 	memset(&exp, 0, sizeof(exp));
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 	cl_assert_equal_i(5, exp.files);
 	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_DELETED]);
 	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_COPIED]);
@@ -1401,7 +1401,7 @@ void test_diff_rename__can_delete_unmodified_deltas(void)
 
 	memset(&exp, 0, sizeof(exp));
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 	cl_assert_equal_i(4, exp.files);
 	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_MODIFIED]);
 	cl_assert_equal_i(3, exp.file_status[GIT_DELTA_UNMODIFIED]);
@@ -1411,7 +1411,7 @@ void test_diff_rename__can_delete_unmodified_deltas(void)
 
 	memset(&exp, 0, sizeof(exp));
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 	cl_assert_equal_i(2, exp.files);
 	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_DELETED]);
 	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_COPIED]);
@@ -1451,7 +1451,7 @@ void test_diff_rename__matches_config_behavior(void)
 	memset(&exp, 0, sizeof(exp));
 	cl_git_pass(git_diff_find_similar(diff, &opts));
 	cl_git_pass(git_diff_foreach(diff,
-				diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+				diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 	cl_assert_equal_i(4, exp.files);
 	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_UNMODIFIED]);
 	cl_assert_equal_i(2, exp.file_status[GIT_DELTA_ADDED]);
@@ -1465,7 +1465,7 @@ void test_diff_rename__matches_config_behavior(void)
 	memset(&exp, 0, sizeof(exp));
 	cl_git_pass(git_diff_find_similar(diff, &opts));
 	cl_git_pass(git_diff_foreach(diff,
-				diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+				diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 	cl_assert_equal_i(3, exp.files);
 	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_UNMODIFIED]);
 	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_ADDED]);
@@ -1479,7 +1479,7 @@ void test_diff_rename__matches_config_behavior(void)
 	memset(&exp, 0, sizeof(exp));
 	cl_git_pass(git_diff_find_similar(diff, &opts));
 	cl_git_pass(git_diff_foreach(diff,
-				diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+				diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 	cl_assert_equal_i(4, exp.files);
 	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_UNMODIFIED]);
 	cl_assert_equal_i(2, exp.file_status[GIT_DELTA_MODIFIED]);
@@ -1492,7 +1492,7 @@ void test_diff_rename__matches_config_behavior(void)
 	memset(&exp, 0, sizeof(exp));
 	cl_git_pass(git_diff_find_similar(diff, NULL));
 	cl_git_pass(git_diff_foreach(diff,
-				diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+				diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 	cl_assert_equal_i(4, exp.files);
 	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_UNMODIFIED]);
 	cl_assert_equal_i(2, exp.file_status[GIT_DELTA_MODIFIED]);
@@ -1535,7 +1535,7 @@ void test_diff_rename__can_override_thresholds_when_obeying_config(void)
 	memset(&exp, 0, sizeof(exp));
 	cl_git_pass(git_diff_find_similar(diff, &opts));
 	cl_git_pass(git_diff_foreach(diff,
-				diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+				diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 	cl_assert_equal_i(4, exp.files);
 	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_UNMODIFIED]);
 	cl_assert_equal_i(2, exp.file_status[GIT_DELTA_MODIFIED]);
@@ -1549,7 +1549,7 @@ void test_diff_rename__can_override_thresholds_when_obeying_config(void)
 	memset(&exp, 0, sizeof(exp));
 	cl_git_pass(git_diff_find_similar(diff, &opts));
 	cl_git_pass(git_diff_foreach(diff,
-				diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+				diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 	cl_assert_equal_i(4, exp.files);
 	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_UNMODIFIED]);
 	cl_assert_equal_i(2, exp.file_status[GIT_DELTA_MODIFIED]);
@@ -1590,7 +1590,7 @@ void test_diff_rename__by_config_doesnt_mess_with_whitespace_settings(void)
 	memset(&exp, 0, sizeof(exp));
 	cl_git_pass(git_diff_find_similar(diff, &opts));
 	cl_git_pass(git_diff_foreach(diff,
-				diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+				diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 	cl_assert_equal_i(5, exp.files);
 	cl_assert_equal_i(2, exp.file_status[GIT_DELTA_MODIFIED]);
 	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_RENAMED]);
@@ -1631,7 +1631,7 @@ static void expect_files_renamed(const char *one, const char *two, uint32_t whit
 	memset(&exp, 0, sizeof(exp));
 
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 	cl_assert_equal_i(1, exp.files);
 	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_RENAMED]);
 
@@ -1686,7 +1686,7 @@ static void expect_files_not_renamed(const char *one, const char *two, uint32_t
 	memset(&exp, 0, sizeof(exp));
 
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 	cl_assert_equal_i(2, exp.files);
 	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_DELETED]);
 	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_UNTRACKED]);
diff --git a/tests/diff/submodules.c b/tests/diff/submodules.c
index 02870ac86..e2169583b 100644
--- a/tests/diff/submodules.c
+++ b/tests/diff/submodules.c
@@ -465,7 +465,7 @@ void test_diff_submodules__skips_empty_includes_used(void)
 	cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));
 	memset(&exp, 0, sizeof(exp));
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 	cl_assert_equal_i(0, exp.files);
 	git_diff_free(diff);
 
@@ -478,7 +478,7 @@ void test_diff_submodules__skips_empty_includes_used(void)
 	cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));
 	memset(&exp, 0, sizeof(exp));
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 	cl_assert_equal_i(1, exp.files);
 	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_IGNORED]);
 	git_diff_free(diff);
@@ -488,7 +488,7 @@ void test_diff_submodules__skips_empty_includes_used(void)
 	cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));
 	memset(&exp, 0, sizeof(exp));
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 	cl_assert_equal_i(1, exp.files);
 	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_UNTRACKED]);
 	git_diff_free(diff);
diff --git a/tests/diff/tree.c b/tests/diff/tree.c
index 6ab49fdb0..6dd17203d 100644
--- a/tests/diff/tree.c
+++ b/tests/diff/tree.c
@@ -49,7 +49,7 @@ void test_diff_tree__0(void)
 	cl_git_pass(git_diff_tree_to_tree(&diff, g_repo, a, b, &opts));
 
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &expect));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &expect));
 
 	cl_assert_equal_i(5, expect.files);
 	cl_assert_equal_i(2, expect.file_status[GIT_DELTA_ADDED]);
@@ -71,7 +71,7 @@ void test_diff_tree__0(void)
 	cl_git_pass(git_diff_tree_to_tree(&diff, g_repo, c, b, &opts));
 
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &expect));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &expect));
 
 	cl_assert_equal_i(2, expect.files);
 	cl_assert_equal_i(0, expect.file_status[GIT_DELTA_ADDED]);
@@ -158,7 +158,7 @@ void test_diff_tree__options(void)
 			cl_git_pass(git_diff_tree_to_tree(&diff, g_repo, c, d, &opts));
 
 		cl_git_pass(git_diff_foreach(
-			diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &actual));
+			diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &actual));
 
 		expected = &test_expects[i];
 		cl_assert_equal_i(actual.files,     expected->files);
@@ -194,7 +194,7 @@ void test_diff_tree__bare(void)
 	cl_git_pass(git_diff_tree_to_tree(&diff, g_repo, a, b, &opts));
 
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &expect));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &expect));
 
 	cl_assert_equal_i(3, expect.files);
 	cl_assert_equal_i(2, expect.file_status[GIT_DELTA_ADDED]);
@@ -235,7 +235,7 @@ void test_diff_tree__merge(void)
 	git_diff_free(diff2);
 
 	cl_git_pass(git_diff_foreach(
-		diff1, diff_file_cb, diff_hunk_cb, diff_line_cb, &expect));
+		diff1, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &expect));
 
 	cl_assert_equal_i(6, expect.files);
 	cl_assert_equal_i(2, expect.file_status[GIT_DELTA_ADDED]);
@@ -332,7 +332,7 @@ void process_tree_to_tree_diffing(
 	cl_git_pass(git_diff_tree_to_tree(&diff, g_repo, a, b, &opts));
 
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, NULL, NULL, &expect));
+		diff, diff_file_cb, NULL, NULL, NULL, &expect));
 }
 
 void test_diff_tree__symlink_blob_mode_changed_to_regular_file(void)
@@ -441,8 +441,8 @@ void test_diff_tree__issue_1397(void)
 
 	cl_git_pass(git_diff_tree_to_tree(&diff, g_repo, a, b, &opts));
 
-	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &expect));
+	cl_git_pass(git_diff_foreach(diff,
+		diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &expect));
 
 	cl_assert_equal_i(1, expect.files);
 	cl_assert_equal_i(0, expect.file_status[GIT_DELTA_DELETED]);
@@ -472,8 +472,8 @@ void test_diff_tree__diff_configs(void)
 
 	cl_git_pass(git_diff_tree_to_tree(&diff, g_repo, a, b, NULL));
 
-	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &expect));
+	cl_git_pass(git_diff_foreach(diff, 
+		diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &expect));
 
 	cl_assert_equal_i(2, expect.files);
 	cl_assert_equal_i(2, expect.file_status[GIT_DELTA_MODIFIED]);
@@ -492,8 +492,8 @@ void test_diff_tree__diff_configs(void)
 
 	cl_git_pass(git_diff_tree_to_tree(&diff, g_repo, a, b, NULL));
 
-	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &expect));
+	cl_git_pass(git_diff_foreach(diff,
+		diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &expect));
 
 	cl_assert_equal_i(2, expect.files);
 	cl_assert_equal_i(2, expect.file_status[GIT_DELTA_MODIFIED]);
@@ -513,8 +513,8 @@ void test_diff_tree__diff_configs(void)
 
 	cl_git_pass(git_diff_tree_to_tree(&diff, g_repo, a, b, NULL));
 
-	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &expect));
+	cl_git_pass(git_diff_foreach(diff,
+		diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &expect));
 
 	cl_assert_equal_i(2, expect.files);
 	cl_assert_equal_i(2, expect.file_status[GIT_DELTA_MODIFIED]);
diff --git a/tests/diff/workdir.c b/tests/diff/workdir.c
index 65005f927..5d6ebed95 100644
--- a/tests/diff/workdir.c
+++ b/tests/diff/workdir.c
@@ -30,10 +30,10 @@ void test_diff_workdir__to_index(void)
 
 		if (use_iterator)
 			cl_git_pass(diff_foreach_via_iterator(
-				diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+				diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 		else
 			cl_git_pass(git_diff_foreach(
-				diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+				diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 
 		/* to generate these values:
 		 * - cd to tests/resources/status,
@@ -94,7 +94,7 @@ void test_diff_workdir__to_index_with_conflicts(void)
 	cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, index, &opts));
 
 	cl_git_pass(diff_foreach_via_iterator(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 
 	cl_assert_equal_i(9, exp.files);
 	cl_assert_equal_i(0, exp.file_status[GIT_DELTA_ADDED]);
@@ -129,7 +129,7 @@ void test_diff_workdir__to_index_with_assume_unchanged(void)
 	cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));
 	memset(&exp, 0, sizeof(exp));
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 	cl_assert_equal_i(8, exp.files);
 	cl_assert_equal_i(0, exp.file_status[GIT_DELTA_ADDED]);
 	cl_assert_equal_i(4, exp.file_status[GIT_DELTA_DELETED]);
@@ -158,7 +158,7 @@ void test_diff_workdir__to_index_with_assume_unchanged(void)
 	cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));
 	memset(&exp, 0, sizeof(exp));
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 	cl_assert_equal_i(6, exp.files);
 	cl_assert_equal_i(0, exp.file_status[GIT_DELTA_ADDED]);
 	cl_assert_equal_i(3, exp.file_status[GIT_DELTA_DELETED]);
@@ -205,10 +205,10 @@ void test_diff_workdir__to_tree(void)
 
 		if (use_iterator)
 			cl_git_pass(diff_foreach_via_iterator(
-				diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+				diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 		else
 			cl_git_pass(git_diff_foreach(
-				diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+				diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 
 		cl_assert_equal_i(14, exp.files);
 		cl_assert_equal_i(0, exp.file_status[GIT_DELTA_ADDED]);
@@ -241,10 +241,10 @@ void test_diff_workdir__to_tree(void)
 
 		if (use_iterator)
 			cl_git_pass(diff_foreach_via_iterator(
-				diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+				diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 		else
 			cl_git_pass(git_diff_foreach(
-				diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+				diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 
 		cl_assert_equal_i(15, exp.files);
 		cl_assert_equal_i(2, exp.file_status[GIT_DELTA_ADDED]);
@@ -278,10 +278,10 @@ void test_diff_workdir__to_tree(void)
 
 		if (use_iterator)
 			cl_git_pass(diff_foreach_via_iterator(
-				diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+				diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 		else
 			cl_git_pass(git_diff_foreach(
-				diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+				diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 
 		cl_assert_equal_i(16, exp.files);
 		cl_assert_equal_i(5, exp.file_status[GIT_DELTA_ADDED]);
@@ -312,7 +312,7 @@ void test_diff_workdir__to_tree(void)
 	memset(&exp, 0, sizeof(exp));
 
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 
 	cl_assert_equal_i(16, exp.files);
 	cl_assert_equal_i(5, exp.file_status[GIT_DELTA_DELETED]);
@@ -359,9 +359,9 @@ void test_diff_workdir__to_index_with_pathspec(void)
 
 		if (use_iterator)
 			cl_git_pass(diff_foreach_via_iterator(
-				diff, diff_file_cb, NULL, NULL, &exp));
+				diff, diff_file_cb, NULL, NULL, NULL, &exp));
 		else
-			cl_git_pass(git_diff_foreach(diff, diff_file_cb, NULL, NULL, &exp));
+			cl_git_pass(git_diff_foreach(diff, diff_file_cb, NULL, NULL, NULL, &exp));
 
 		cl_assert_equal_i(13, exp.files);
 		cl_assert_equal_i(0, exp.file_status[GIT_DELTA_ADDED]);
@@ -382,9 +382,9 @@ void test_diff_workdir__to_index_with_pathspec(void)
 
 		if (use_iterator)
 			cl_git_pass(diff_foreach_via_iterator(
-				diff, diff_file_cb, NULL, NULL, &exp));
+				diff, diff_file_cb, NULL, NULL, NULL, &exp));
 		else
-			cl_git_pass(git_diff_foreach(diff, diff_file_cb, NULL, NULL, &exp));
+			cl_git_pass(git_diff_foreach(diff, diff_file_cb, NULL, NULL, NULL, &exp));
 
 		cl_assert_equal_i(1, exp.files);
 		cl_assert_equal_i(0, exp.file_status[GIT_DELTA_ADDED]);
@@ -405,9 +405,9 @@ void test_diff_workdir__to_index_with_pathspec(void)
 
 		if (use_iterator)
 			cl_git_pass(diff_foreach_via_iterator(
-				diff, diff_file_cb, NULL, NULL, &exp));
+				diff, diff_file_cb, NULL, NULL, NULL, &exp));
 		else
-			cl_git_pass(git_diff_foreach(diff, diff_file_cb, NULL, NULL, &exp));
+			cl_git_pass(git_diff_foreach(diff, diff_file_cb, NULL, NULL, NULL, &exp));
 
 		cl_assert_equal_i(3, exp.files);
 		cl_assert_equal_i(0, exp.file_status[GIT_DELTA_ADDED]);
@@ -428,9 +428,9 @@ void test_diff_workdir__to_index_with_pathspec(void)
 
 		if (use_iterator)
 			cl_git_pass(diff_foreach_via_iterator(
-				diff, diff_file_cb, NULL, NULL, &exp));
+				diff, diff_file_cb, NULL, NULL, NULL, &exp));
 		else
-			cl_git_pass(git_diff_foreach(diff, diff_file_cb, NULL, NULL, &exp));
+			cl_git_pass(git_diff_foreach(diff, diff_file_cb, NULL, NULL, NULL, &exp));
 
 		cl_assert_equal_i(2, exp.files);
 		cl_assert_equal_i(0, exp.file_status[GIT_DELTA_ADDED]);
@@ -465,10 +465,10 @@ void test_diff_workdir__filemode_changes(void)
 
 		if (use_iterator)
 			cl_git_pass(diff_foreach_via_iterator(
-				diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+				diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 		else
 			cl_git_pass(git_diff_foreach(
-				diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+				diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 
 		cl_assert_equal_i(0, exp.files);
 		cl_assert_equal_i(0, exp.file_status[GIT_DELTA_MODIFIED]);
@@ -488,10 +488,10 @@ void test_diff_workdir__filemode_changes(void)
 
 		if (use_iterator)
 			cl_git_pass(diff_foreach_via_iterator(
-				diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+				diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 		else
 			cl_git_pass(git_diff_foreach(
-				diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+				diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 
 		cl_assert_equal_i(1, exp.files);
 		cl_assert_equal_i(1, exp.file_status[GIT_DELTA_MODIFIED]);
@@ -521,7 +521,7 @@ void test_diff_workdir__filemode_changes_with_filemode_false(void)
 
 	memset(&exp, 0, sizeof(exp));
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 
 	cl_assert_equal_i(0, exp.files);
 	cl_assert_equal_i(0, exp.file_status[GIT_DELTA_MODIFIED]);
@@ -536,8 +536,8 @@ void test_diff_workdir__filemode_changes_with_filemode_false(void)
 	cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, NULL));
 
 	memset(&exp, 0, sizeof(exp));
-	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+	cl_git_pass(git_diff_foreach(diff, 
+		diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 
 	cl_assert_equal_i(0, exp.files);
 	cl_assert_equal_i(0, exp.file_status[GIT_DELTA_MODIFIED]);
@@ -580,10 +580,10 @@ void test_diff_workdir__head_index_and_workdir_all_differ(void)
 
 		if (use_iterator)
 			cl_git_pass(diff_foreach_via_iterator(
-				diff_i2t, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+				diff_i2t, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 		else
 			cl_git_pass(git_diff_foreach(
-				diff_i2t, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+				diff_i2t, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 
 		cl_assert_equal_i(1, exp.files);
 		cl_assert_equal_i(0, exp.file_status[GIT_DELTA_ADDED]);
@@ -601,10 +601,10 @@ void test_diff_workdir__head_index_and_workdir_all_differ(void)
 
 		if (use_iterator)
 			cl_git_pass(diff_foreach_via_iterator(
-				diff_w2i, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+				diff_w2i, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 		else
 			cl_git_pass(git_diff_foreach(
-				diff_w2i, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+				diff_w2i, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 
 		cl_assert_equal_i(1, exp.files);
 		cl_assert_equal_i(0, exp.file_status[GIT_DELTA_ADDED]);
@@ -624,10 +624,10 @@ void test_diff_workdir__head_index_and_workdir_all_differ(void)
 
 		if (use_iterator)
 			cl_git_pass(diff_foreach_via_iterator(
-				diff_i2t, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+				diff_i2t, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 		else
 			cl_git_pass(git_diff_foreach(
-				diff_i2t, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+				diff_i2t, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 
 		cl_assert_equal_i(1, exp.files);
 		cl_assert_equal_i(0, exp.file_status[GIT_DELTA_ADDED]);
@@ -666,10 +666,10 @@ void test_diff_workdir__eof_newline_changes(void)
 
 		if (use_iterator)
 			cl_git_pass(diff_foreach_via_iterator(
-				diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+				diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 		else
 			cl_git_pass(git_diff_foreach(
-				diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+				diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 
 		cl_assert_equal_i(0, exp.files);
 		cl_assert_equal_i(0, exp.file_status[GIT_DELTA_ADDED]);
@@ -693,10 +693,10 @@ void test_diff_workdir__eof_newline_changes(void)
 
 		if (use_iterator)
 			cl_git_pass(diff_foreach_via_iterator(
-				diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+				diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 		else
 			cl_git_pass(git_diff_foreach(
-				diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+				diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 
 		cl_assert_equal_i(1, exp.files);
 		cl_assert_equal_i(0, exp.file_status[GIT_DELTA_ADDED]);
@@ -720,10 +720,10 @@ void test_diff_workdir__eof_newline_changes(void)
 
 		if (use_iterator)
 			cl_git_pass(diff_foreach_via_iterator(
-				diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+				diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 		else
 			cl_git_pass(git_diff_foreach(
-				diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+				diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 
 		cl_assert_equal_i(1, exp.files);
 		cl_assert_equal_i(0, exp.file_status[GIT_DELTA_ADDED]);
@@ -913,7 +913,7 @@ void test_diff_workdir__submodules(void)
 	memset(&exp, 0, sizeof(exp));
 
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 
 	/* so "git diff 873585" returns:
 	 *  M   .gitmodules
@@ -991,7 +991,7 @@ void test_diff_workdir__to_null_tree(void)
 	memset(&exp, 0, sizeof(exp));
 
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 
 	cl_assert_equal_i(exp.files, exp.file_status[GIT_DELTA_UNTRACKED]);
 
@@ -1080,7 +1080,7 @@ void test_diff_workdir__to_index_issue_1397(void)
 
 	memset(&exp, 0, sizeof(exp));
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 
 	cl_assert_equal_i(0, exp.files);
 	cl_assert_equal_i(0, exp.hunks);
@@ -1096,7 +1096,7 @@ void test_diff_workdir__to_index_issue_1397(void)
 
 	memset(&exp, 0, sizeof(exp));
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 
 	cl_assert_equal_i(1, exp.files);
 	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_MODIFIED]);
@@ -1133,7 +1133,7 @@ void test_diff_workdir__to_tree_issue_1397(void)
 
 	memset(&exp, 0, sizeof(exp));
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 
 	cl_assert_equal_i(0, exp.files);
 	cl_assert_equal_i(0, exp.hunks);
@@ -1149,7 +1149,7 @@ void test_diff_workdir__to_tree_issue_1397(void)
 
 	memset(&exp, 0, sizeof(exp));
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 
 	cl_assert_equal_i(0, exp.files);
 	cl_assert_equal_i(0, exp.hunks);
@@ -1203,7 +1203,7 @@ void test_diff_workdir__untracked_directory_scenarios(void)
 
 	cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));
 
-	cl_git_pass(git_diff_foreach(diff, diff_file_cb, NULL, NULL, &exp));
+	cl_git_pass(git_diff_foreach(diff, diff_file_cb, NULL, NULL, NULL, &exp));
 
 	cl_assert_equal_i(3, exp.files);
 	cl_assert_equal_i(0, exp.file_status[GIT_DELTA_ADDED]);
@@ -1223,7 +1223,7 @@ void test_diff_workdir__untracked_directory_scenarios(void)
 
 	cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));
 
-	cl_git_pass(git_diff_foreach(diff, diff_file_cb, NULL, NULL, &exp));
+	cl_git_pass(git_diff_foreach(diff, diff_file_cb, NULL, NULL, NULL, &exp));
 
 	cl_assert_equal_i(4, exp.files);
 	cl_assert_equal_i(0, exp.file_status[GIT_DELTA_ADDED]);
@@ -1243,7 +1243,7 @@ void test_diff_workdir__untracked_directory_scenarios(void)
 
 	cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));
 
-	cl_git_pass(git_diff_foreach(diff, diff_file_cb, NULL, NULL, &exp));
+	cl_git_pass(git_diff_foreach(diff, diff_file_cb, NULL, NULL, NULL, &exp));
 
 	cl_assert_equal_i(4, exp.files);
 	cl_assert_equal_i(0, exp.file_status[GIT_DELTA_ADDED]);
@@ -1267,7 +1267,7 @@ void test_diff_workdir__untracked_directory_scenarios(void)
 
 	cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));
 
-	cl_git_pass(git_diff_foreach(diff, diff_file_cb, NULL, NULL, &exp));
+	cl_git_pass(git_diff_foreach(diff, diff_file_cb, NULL, NULL, NULL, &exp));
 
 	cl_assert_equal_i(4, exp.files);
 	cl_assert_equal_i(0, exp.file_status[GIT_DELTA_ADDED]);
@@ -1290,7 +1290,7 @@ void test_diff_workdir__untracked_directory_scenarios(void)
 
 	cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));
 
-	cl_git_pass(git_diff_foreach(diff, diff_file_cb, NULL, NULL, &exp));
+	cl_git_pass(git_diff_foreach(diff, diff_file_cb, NULL, NULL, NULL, &exp));
 
 	cl_assert_equal_i(4, exp.files);
 	cl_assert_equal_i(0, exp.file_status[GIT_DELTA_ADDED]);
@@ -1310,7 +1310,7 @@ void test_diff_workdir__untracked_directory_scenarios(void)
 
 	cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));
 
-	cl_git_pass(git_diff_foreach(diff, diff_file_cb, NULL, NULL, &exp));
+	cl_git_pass(git_diff_foreach(diff, diff_file_cb, NULL, NULL, NULL, &exp));
 
 	cl_assert_equal_i(4, exp.files);
 	cl_assert_equal_i(0, exp.file_status[GIT_DELTA_ADDED]);
@@ -1333,7 +1333,7 @@ void test_diff_workdir__untracked_directory_scenarios(void)
 
 	cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));
 
-	cl_git_pass(git_diff_foreach(diff, diff_file_cb, NULL, NULL, &exp));
+	cl_git_pass(git_diff_foreach(diff, diff_file_cb, NULL, NULL, NULL, &exp));
 
 	cl_assert_equal_i(4, exp.files);
 	cl_assert_equal_i(0, exp.file_status[GIT_DELTA_ADDED]);
@@ -1354,7 +1354,7 @@ void test_diff_workdir__untracked_directory_scenarios(void)
 
 	cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));
 
-	cl_git_pass(git_diff_foreach(diff, diff_file_cb, NULL, NULL, &exp));
+	cl_git_pass(git_diff_foreach(diff, diff_file_cb, NULL, NULL, NULL, &exp));
 
 	cl_assert_equal_i(4, exp.files);
 	cl_assert_equal_i(0, exp.file_status[GIT_DELTA_ADDED]);
@@ -1505,7 +1505,7 @@ void test_diff_workdir__with_stale_index(void)
 	memset(&exp, 0, sizeof(exp));
 
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 
 	cl_assert_equal_i(17, exp.files);
 	cl_assert_equal_i(0, exp.file_status[GIT_DELTA_ADDED]);
@@ -1527,7 +1527,7 @@ void test_diff_workdir__with_stale_index(void)
 	memset(&exp, 0, sizeof(exp));
 
 	cl_git_pass(git_diff_foreach(
-		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 
 	git_diff_free(diff);
 
@@ -1568,7 +1568,7 @@ static void basic_diff_status(git_diff **out, const git_diff_options *opts)
 	memset(&exp, 0, sizeof(exp));
 
 	cl_git_pass(git_diff_foreach(
-		*out, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+		*out, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
 
 	cl_assert_equal_i(13, exp.files);
 	cl_assert_equal_i(0, exp.file_status[GIT_DELTA_ADDED]);