Diff iterators

This refactors the diff output code so that an iterator object
can be used to traverse and generate the diffs, instead of just
the `foreach()` style with callbacks.  The code has been rearranged
so that the two styles can still share most functions.

This also replaces `GIT_REVWALKOVER` with `GIT_ITEROVER` and uses
that as a common error code for marking the end of iteration when
using a iterator style of object.

7 files changed, 613 insertions, 293 deletions

diff --git a/tests-clar/diff/blob.c b/tests-clar/diff/blob.c
index 5d3ab8d56..d5cf41e99 100644
--- a/tests-clar/diff/blob.c
+++ b/tests-clar/diff/blob.c
@@ -58,59 +58,59 @@ void test_diff_blob__can_compare_text_blobs(void)
 	cl_git_pass(git_diff_blobs(
 		a, b, &opts, &expected, diff_file_fn, diff_hunk_fn, diff_line_fn));
 
-	cl_assert(expected.files == 1);
-	cl_assert(expected.file_mods == 1);
+	cl_assert_equal_i(1, expected.files);
+	cl_assert_equal_i(1, expected.file_mods);
 	cl_assert(expected.at_least_one_of_them_is_binary == false);
 
-	cl_assert(expected.hunks == 1);
-	cl_assert(expected.lines == 6);
-	cl_assert(expected.line_ctxt == 1);
-	cl_assert(expected.line_adds == 5);
-	cl_assert(expected.line_dels == 0);
+	cl_assert_equal_i(1, expected.hunks);
+	cl_assert_equal_i(6, expected.lines);
+	cl_assert_equal_i(1, expected.line_ctxt);
+	cl_assert_equal_i(5, expected.line_adds);
+	cl_assert_equal_i(0, expected.line_dels);
 
 	/* diff on tests/resources/attr/root_test2 */
 	memset(&expected, 0, sizeof(expected));
 	cl_git_pass(git_diff_blobs(
 		b, c, &opts, &expected, diff_file_fn, diff_hunk_fn, diff_line_fn));
 
-	cl_assert(expected.files == 1);
-	cl_assert(expected.file_mods == 1);
+	cl_assert_equal_i(1, expected.files);
+	cl_assert_equal_i(1, expected.file_mods);
 	cl_assert(expected.at_least_one_of_them_is_binary == false);
 
-	cl_assert(expected.hunks == 1);
-	cl_assert(expected.lines == 15);
-	cl_assert(expected.line_ctxt == 3);
-	cl_assert(expected.line_adds == 9);
-	cl_assert(expected.line_dels == 3);
+	cl_assert_equal_i(1, expected.hunks);
+	cl_assert_equal_i(15, expected.lines);
+	cl_assert_equal_i(3, expected.line_ctxt);
+	cl_assert_equal_i(9, expected.line_adds);
+	cl_assert_equal_i(3, expected.line_dels);
 
 	/* diff on tests/resources/attr/root_test3 */
 	memset(&expected, 0, sizeof(expected));
 	cl_git_pass(git_diff_blobs(
 		a, c, &opts, &expected, diff_file_fn, diff_hunk_fn, diff_line_fn));
 
-	cl_assert(expected.files == 1);
-	cl_assert(expected.file_mods == 1);
+	cl_assert_equal_i(1, expected.files);
+	cl_assert_equal_i(1, expected.file_mods);
 	cl_assert(expected.at_least_one_of_them_is_binary == false);
 
-	cl_assert(expected.hunks == 1);
-	cl_assert(expected.lines == 13);
-	cl_assert(expected.line_ctxt == 0);
-	cl_assert(expected.line_adds == 12);
-	cl_assert(expected.line_dels == 1);
+	cl_assert_equal_i(1, expected.hunks);
+	cl_assert_equal_i(13, expected.lines);
+	cl_assert_equal_i(0, expected.line_ctxt);
+	cl_assert_equal_i(12, expected.line_adds);
+	cl_assert_equal_i(1, expected.line_dels);
 
 	memset(&expected, 0, sizeof(expected));
 	cl_git_pass(git_diff_blobs(
 		c, d, &opts, &expected, diff_file_fn, diff_hunk_fn, diff_line_fn));
 
-	cl_assert(expected.files == 1);
-	cl_assert(expected.file_mods == 1);
+	cl_assert_equal_i(1, expected.files);
+	cl_assert_equal_i(1, expected.file_mods);
 	cl_assert(expected.at_least_one_of_them_is_binary == false);
 
-	cl_assert(expected.hunks == 2);
-	cl_assert(expected.lines == 14);
-	cl_assert(expected.line_ctxt == 4);
-	cl_assert(expected.line_adds == 6);
-	cl_assert(expected.line_dels == 4);
+	cl_assert_equal_i(2, expected.hunks);
+	cl_assert_equal_i(14, expected.lines);
+	cl_assert_equal_i(4, expected.line_ctxt);
+	cl_assert_equal_i(6, expected.line_adds);
+	cl_assert_equal_i(4, expected.line_dels);
 
 	git_blob_free(a);
 	git_blob_free(b);
@@ -124,14 +124,14 @@ void test_diff_blob__can_compare_against_null_blobs(void)
 	cl_git_pass(git_diff_blobs(
 		d, e, &opts, &expected, diff_file_fn, diff_hunk_fn, diff_line_fn));
 
-	cl_assert(expected.files == 1);
-	cl_assert(expected.file_dels == 1);
+	cl_assert_equal_i(1, expected.files);
+	cl_assert_equal_i(1, expected.file_dels);
 	cl_assert(expected.at_least_one_of_them_is_binary == false);
 
-	cl_assert(expected.hunks == 1);
-	cl_assert(expected.hunk_old_lines == 14);
-	cl_assert(expected.lines == 14);
-	cl_assert(expected.line_dels == 14);
+	cl_assert_equal_i(1, expected.hunks);
+	cl_assert_equal_i(14, expected.hunk_old_lines);
+	cl_assert_equal_i(14, expected.lines);
+	cl_assert_equal_i(14, expected.line_dels);
 
 	opts.flags |= GIT_DIFF_REVERSE;
 	memset(&expected, 0, sizeof(expected));
@@ -139,14 +139,14 @@ void test_diff_blob__can_compare_against_null_blobs(void)
 	cl_git_pass(git_diff_blobs(
 		d, e, &opts, &expected, diff_file_fn, diff_hunk_fn, diff_line_fn));
 
-	cl_assert(expected.files == 1);
-	cl_assert(expected.file_adds == 1);
+	cl_assert_equal_i(1, expected.files);
+	cl_assert_equal_i(1, expected.file_adds);
 	cl_assert(expected.at_least_one_of_them_is_binary == false);
 
-	cl_assert(expected.hunks == 1);
-	cl_assert(expected.hunk_new_lines == 14);
-	cl_assert(expected.lines == 14);
-	cl_assert(expected.line_adds == 14);
+	cl_assert_equal_i(1, expected.hunks);
+	cl_assert_equal_i(14, expected.hunk_new_lines);
+	cl_assert_equal_i(14, expected.lines);
+	cl_assert_equal_i(14, expected.line_adds);
 
 	opts.flags ^= GIT_DIFF_REVERSE;
 	memset(&expected, 0, sizeof(expected));
@@ -156,10 +156,10 @@ void test_diff_blob__can_compare_against_null_blobs(void)
 
 	cl_assert(expected.at_least_one_of_them_is_binary == true);
 
-	cl_assert(expected.files == 1);
-	cl_assert(expected.file_dels == 1);
-	cl_assert(expected.hunks == 0);
-	cl_assert(expected.lines == 0);
+	cl_assert_equal_i(1, expected.files);
+	cl_assert_equal_i(1, expected.file_dels);
+	cl_assert_equal_i(0, expected.hunks);
+	cl_assert_equal_i(0, expected.lines);
 
 	memset(&expected, 0, sizeof(expected));
 
@@ -168,18 +168,18 @@ void test_diff_blob__can_compare_against_null_blobs(void)
 
 	cl_assert(expected.at_least_one_of_them_is_binary == true);
 
-	cl_assert(expected.files == 1);
-	cl_assert(expected.file_adds == 1);
-	cl_assert(expected.hunks == 0);
-	cl_assert(expected.lines == 0);
+	cl_assert_equal_i(1, expected.files);
+	cl_assert_equal_i(1, expected.file_adds);
+	cl_assert_equal_i(0, expected.hunks);
+	cl_assert_equal_i(0, expected.lines);
 }
 
 static void assert_identical_blobs_comparison(diff_expects expected)
 {
-	cl_assert(expected.files == 1);
-	cl_assert(expected.file_unmodified == 1);
-	cl_assert(expected.hunks == 0);
-	cl_assert(expected.lines == 0);
+	cl_assert_equal_i(1, expected.files);
+	cl_assert_equal_i(1, expected.file_unmodified);
+	cl_assert_equal_i(0, expected.hunks);
+	cl_assert_equal_i(0, expected.lines);
 }
 
 void test_diff_blob__can_compare_identical_blobs(void)
@@ -209,10 +209,10 @@ static void assert_binary_blobs_comparison(diff_expects expected)
 {
 	cl_assert(expected.at_least_one_of_them_is_binary == true);
 
-	cl_assert(expected.files == 1);
-	cl_assert(expected.file_mods == 1);
-	cl_assert(expected.hunks == 0);
-	cl_assert(expected.lines == 0);
+	cl_assert_equal_i(1, expected.files);
+	cl_assert_equal_i(1, expected.file_mods);
+	cl_assert_equal_i(0, expected.hunks);
+	cl_assert_equal_i(0, expected.lines);
 }
 
 void test_diff_blob__can_compare_two_binary_blobs(void)
@@ -292,7 +292,7 @@ void test_diff_blob__comparing_two_text_blobs_honors_interhunkcontext(void)
 	cl_git_pass(git_diff_blobs(
 		old_d, d, &opts, &expected, diff_file_fn, diff_hunk_fn, diff_line_fn));
 
-	cl_assert(expected.hunks == 2);
+	cl_assert_equal_i(2, expected.hunks);
 
 	/* Test with inter-hunk-context explicitly set to 0 */
 	opts.interhunk_lines = 0;
@@ -300,7 +300,7 @@ void test_diff_blob__comparing_two_text_blobs_honors_interhunkcontext(void)
 	cl_git_pass(git_diff_blobs(
 		old_d, d, &opts, &expected, diff_file_fn, diff_hunk_fn, diff_line_fn));
 
-	cl_assert(expected.hunks == 2);
+	cl_assert_equal_i(2, expected.hunks);
 
 	/* Test with inter-hunk-context explicitly set to 1 */
 	opts.interhunk_lines = 1;
@@ -308,7 +308,7 @@ void test_diff_blob__comparing_two_text_blobs_honors_interhunkcontext(void)
 	cl_git_pass(git_diff_blobs(
 		old_d, d, &opts, &expected, diff_file_fn, diff_hunk_fn, diff_line_fn));
 
-	cl_assert(expected.hunks == 1);
+	cl_assert_equal_i(1, expected.hunks);
 
 	git_blob_free(old_d);
 }
diff --git a/tests-clar/diff/diff_helpers.c b/tests-clar/diff/diff_helpers.c
index 7b391262d..59e01802c 100644
--- a/tests-clar/diff/diff_helpers.c
+++ b/tests-clar/diff/diff_helpers.c
@@ -103,3 +103,74 @@ int diff_line_fn(
 	}
 	return 0;
 }
+
+int diff_foreach_via_iterator(
+	git_diff_list *diff,
+	void *data,
+	git_diff_file_fn file_cb,
+	git_diff_hunk_fn hunk_cb,
+	git_diff_data_fn line_cb)
+{
+	int error, curr, total;
+	git_diff_iterator *iter;
+	git_diff_delta *delta;
+
+	if ((error = git_diff_iterator_new(&iter, diff)) < 0)
+		return error;
+
+	curr  = 0;
+	total = git_diff_iterator_num_files(iter);
+
+	while (!(error = git_diff_iterator_next_file(&delta, iter))) {
+		git_diff_range *range;
+		const char *hdr;
+		size_t hdr_len;
+
+		/* call file_cb for this file */
+		if (file_cb != NULL && file_cb(data, delta, (float)curr / total) != 0)
+			goto abort;
+
+		if (!hunk_cb && !line_cb)
+			continue;
+
+		while (!(error = git_diff_iterator_next_hunk(
+				&range, &hdr, &hdr_len, iter))) {
+			char origin;
+			const char *line;
+			size_t line_len;
+
+			if (hunk_cb && hunk_cb(data, delta, range, hdr, hdr_len) != 0)
+				goto abort;
+
+			if (!line_cb)
+				continue;
+
+			while (!(error = git_diff_iterator_next_line(
+				&origin, &line, &line_len, iter))) {
+
+				if (line_cb(data, delta, range, origin, line, line_len) != 0)
+					goto abort;
+			}
+
+			if (error && error != GIT_ITEROVER)
+				goto done;
+		}
+
+		if (error && error != GIT_ITEROVER)
+			goto done;
+	}
+
+done:
+	git_diff_iterator_free(iter);
+
+	if (error == GIT_ITEROVER)
+		error = 0;
+
+	return error;
+
+abort:
+	git_diff_iterator_free(iter);
+	giterr_clear();
+
+	return GIT_EUSER;
+}
diff --git a/tests-clar/diff/diff_helpers.h b/tests-clar/diff/diff_helpers.h
index 0aaa6c111..79e140921 100644
--- a/tests-clar/diff/diff_helpers.h
+++ b/tests-clar/diff/diff_helpers.h
@@ -45,3 +45,9 @@ extern int diff_line_fn(
 	const char *content,
 	size_t content_len);
 
+extern int diff_foreach_via_iterator(
+	git_diff_list *diff,
+	void *data,
+	git_diff_file_fn file_cb,
+	git_diff_hunk_fn hunk_cb,
+	git_diff_data_fn line_cb);
diff --git a/tests-clar/diff/diffiter.c b/tests-clar/diff/diffiter.c
new file mode 100644
index 000000000..56c254741
--- /dev/null
+++ b/tests-clar/diff/diffiter.c
@@ -0,0 +1,116 @@
+#include "clar_libgit2.h"
+#include "diff_helpers.h"
+
+void test_diff_diffiter__initialize(void)
+{
+}
+
+void test_diff_diffiter__cleanup(void)
+{
+	cl_git_sandbox_cleanup();
+}
+
+void test_diff_diffiter__create(void)
+{
+	git_repository *repo = cl_git_sandbox_init("attr");
+	git_diff_list *diff;
+	git_diff_iterator *iter;
+
+	cl_git_pass(git_diff_workdir_to_index(repo, NULL, &diff));
+	cl_git_pass(git_diff_iterator_new(&iter, diff));
+	git_diff_iterator_free(iter);
+	git_diff_list_free(diff);
+}
+
+void test_diff_diffiter__iterate_files(void)
+{
+	git_repository *repo = cl_git_sandbox_init("attr");
+	git_diff_list *diff;
+	git_diff_iterator *iter;
+	git_diff_delta *delta;
+	int error, count = 0;
+
+	cl_git_pass(git_diff_workdir_to_index(repo, NULL, &diff));
+	cl_git_pass(git_diff_iterator_new(&iter, diff));
+
+	while ((error = git_diff_iterator_next_file(&delta, iter)) != GIT_ITEROVER) {
+		cl_assert_equal_i(0, error);
+		cl_assert(delta != NULL);
+		count++;
+	}
+
+	cl_assert_equal_i(GIT_ITEROVER, error);
+	cl_assert(delta == NULL);
+	cl_assert_equal_i(6, count);
+
+	git_diff_iterator_free(iter);
+	git_diff_list_free(diff);
+}
+
+void test_diff_diffiter__iterate_files_2(void)
+{
+	git_repository *repo = cl_git_sandbox_init("status");
+	git_diff_list *diff;
+	git_diff_iterator *iter;
+	git_diff_delta *delta;
+	int error, count = 0;
+
+	cl_git_pass(git_diff_workdir_to_index(repo, NULL, &diff));
+	cl_git_pass(git_diff_iterator_new(&iter, diff));
+
+	while ((error = git_diff_iterator_next_file(&delta, iter)) != GIT_ITEROVER) {
+		cl_assert_equal_i(0, error);
+		cl_assert(delta != NULL);
+		count++;
+	}
+
+	cl_assert_equal_i(GIT_ITEROVER, error);
+	cl_assert(delta == NULL);
+	cl_assert_equal_i(8, count);
+
+	git_diff_iterator_free(iter);
+	git_diff_list_free(diff);
+}
+
+void test_diff_diffiter__iterate_files_and_hunks(void)
+{
+	git_repository *repo = cl_git_sandbox_init("status");
+	git_diff_options opts = {0};
+	git_diff_list *diff = NULL;
+	git_diff_iterator *iter;
+	git_diff_delta *delta;
+	git_diff_range *range;
+	const char *header;
+	size_t header_len;
+	int error, file_count = 0, hunk_count = 0;
+
+	opts.context_lines = 3;
+	opts.interhunk_lines = 1;
+	opts.flags |= GIT_DIFF_INCLUDE_IGNORED | GIT_DIFF_INCLUDE_UNTRACKED;
+
+	cl_git_pass(git_diff_workdir_to_index(repo, &opts, &diff));
+
+	cl_git_pass(git_diff_iterator_new(&iter, diff));
+
+	while ((error = git_diff_iterator_next_file(&delta, iter)) != GIT_ITEROVER) {
+		cl_assert_equal_i(0, error);
+		cl_assert(delta);
+
+		file_count++;
+
+		while ((error = git_diff_iterator_next_hunk(
+				&range, &header, &header_len, iter)) != GIT_ITEROVER) {
+			cl_assert_equal_i(0, error);
+			cl_assert(range);
+			hunk_count++;
+		}
+	}
+
+	cl_assert_equal_i(GIT_ITEROVER, error);
+	cl_assert(delta == NULL);
+	cl_assert_equal_i(13, file_count);
+	cl_assert_equal_i(8, hunk_count);
+
+	git_diff_iterator_free(iter);
+	git_diff_list_free(diff);
+}
diff --git a/tests-clar/diff/index.c b/tests-clar/diff/index.c
index 89e65e3b7..2c6e89c4a 100644
--- a/tests-clar/diff/index.c
+++ b/tests-clar/diff/index.c
@@ -44,17 +44,17 @@ void test_diff_index__0(void)
 	 * - git diff -U1 --cached 26a125ee1bf
 	 * - mv .git .gitted
 	 */
-	cl_assert(exp.files == 8);
-	cl_assert(exp.file_adds == 3);
-	cl_assert(exp.file_dels == 2);
-	cl_assert(exp.file_mods == 3);
+	cl_assert_equal_i(8, exp.files);
+	cl_assert_equal_i(3, exp.file_adds);
+	cl_assert_equal_i(2, exp.file_dels);
+	cl_assert_equal_i(3, exp.file_mods);
 
-	cl_assert(exp.hunks == 8);
+	cl_assert_equal_i(8, exp.hunks);
 
-	cl_assert(exp.lines == 11);
-	cl_assert(exp.line_ctxt == 3);
-	cl_assert(exp.line_adds == 6);
-	cl_assert(exp.line_dels == 2);
+	cl_assert_equal_i(11, exp.lines);
+	cl_assert_equal_i(3, exp.line_ctxt);
+	cl_assert_equal_i(6, exp.line_adds);
+	cl_assert_equal_i(2, exp.line_dels);
 
 	git_diff_list_free(diff);
 	diff = NULL;
@@ -72,17 +72,17 @@ void test_diff_index__0(void)
 	 * - git diff -U1 --cached 0017bd4ab1ec3
 	 * - mv .git .gitted
 	 */
-	cl_assert(exp.files == 12);
-	cl_assert(exp.file_adds == 7);
-	cl_assert(exp.file_dels == 2);
-	cl_assert(exp.file_mods == 3);
+	cl_assert_equal_i(12, exp.files);
+	cl_assert_equal_i(7, exp.file_adds);
+	cl_assert_equal_i(2, exp.file_dels);
+	cl_assert_equal_i(3, exp.file_mods);
 
-	cl_assert(exp.hunks == 12);
+	cl_assert_equal_i(12, exp.hunks);
 
-	cl_assert(exp.lines == 16);
-	cl_assert(exp.line_ctxt == 3);
-	cl_assert(exp.line_adds == 11);
-	cl_assert(exp.line_dels == 2);
+	cl_assert_equal_i(16, exp.lines);
+	cl_assert_equal_i(3, exp.line_ctxt);
+	cl_assert_equal_i(11, exp.line_adds);
+	cl_assert_equal_i(2, exp.line_dels);
 
 	git_diff_list_free(diff);
 	diff = NULL;
@@ -132,7 +132,7 @@ void test_diff_index__1(void)
 		git_diff_foreach(diff, &exp, diff_stop_after_2_files, NULL, NULL)
 	);
 
-	cl_assert(exp.files == 2);
+	cl_assert_equal_i(2, exp.files);
 
 	git_diff_list_free(diff);
 	diff = NULL;
diff --git a/tests-clar/diff/tree.c b/tests-clar/diff/tree.c
index be9eb6c13..3003374a5 100644
--- a/tests-clar/diff/tree.c
+++ b/tests-clar/diff/tree.c
@@ -39,17 +39,17 @@ void test_diff_tree__0(void)
 	cl_git_pass(git_diff_foreach(
 		diff, &exp, diff_file_fn, diff_hunk_fn, diff_line_fn));
 
-	cl_assert(exp.files == 5);
-	cl_assert(exp.file_adds == 2);
-	cl_assert(exp.file_dels == 1);
-	cl_assert(exp.file_mods == 2);
+	cl_assert_equal_i(5, exp.files);
+	cl_assert_equal_i(2, exp.file_adds);
+	cl_assert_equal_i(1, exp.file_dels);
+	cl_assert_equal_i(2, exp.file_mods);
 
-	cl_assert(exp.hunks == 5);
+	cl_assert_equal_i(5, exp.hunks);
 
-	cl_assert(exp.lines == 7 + 24 + 1 + 6 + 6);
-	cl_assert(exp.line_ctxt == 1);
-	cl_assert(exp.line_adds == 24 + 1 + 5 + 5);
-	cl_assert(exp.line_dels == 7 + 1);
+	cl_assert_equal_i(7 + 24 + 1 + 6 + 6, exp.lines);
+	cl_assert_equal_i(1, exp.line_ctxt);
+	cl_assert_equal_i(24 + 1 + 5 + 5, exp.line_adds);
+	cl_assert_equal_i(7 + 1, exp.line_dels);
 
 	git_diff_list_free(diff);
 	diff = NULL;
@@ -61,17 +61,17 @@ void test_diff_tree__0(void)
 	cl_git_pass(git_diff_foreach(
 		diff, &exp, diff_file_fn, diff_hunk_fn, diff_line_fn));
 
-	cl_assert(exp.files == 2);
-	cl_assert(exp.file_adds == 0);
-	cl_assert(exp.file_dels == 0);
-	cl_assert(exp.file_mods == 2);
+	cl_assert_equal_i(2, exp.files);
+	cl_assert_equal_i(0, exp.file_adds);
+	cl_assert_equal_i(0, exp.file_dels);
+	cl_assert_equal_i(2, exp.file_mods);
 
-	cl_assert(exp.hunks == 2);
+	cl_assert_equal_i(2, exp.hunks);
 
-	cl_assert(exp.lines == 8 + 15);
-	cl_assert(exp.line_ctxt == 1);
-	cl_assert(exp.line_adds == 1);
-	cl_assert(exp.line_dels == 7 + 14);
+	cl_assert_equal_i(8 + 15, exp.lines);
+	cl_assert_equal_i(1, exp.line_ctxt);
+	cl_assert_equal_i(1, exp.line_adds);
+	cl_assert_equal_i(7 + 14, exp.line_dels);
 
 	git_diff_list_free(diff);
 
@@ -192,17 +192,17 @@ void test_diff_tree__bare(void)
 	cl_git_pass(git_diff_foreach(
 		diff, &exp, diff_file_fn, diff_hunk_fn, diff_line_fn));
 
-	cl_assert(exp.files == 3);
-	cl_assert(exp.file_adds == 2);
-	cl_assert(exp.file_dels == 0);
-	cl_assert(exp.file_mods == 1);
+	cl_assert_equal_i(3, exp.files);
+	cl_assert_equal_i(2, exp.file_adds);
+	cl_assert_equal_i(0, exp.file_dels);
+	cl_assert_equal_i(1, exp.file_mods);
 
-	cl_assert(exp.hunks == 3);
+	cl_assert_equal_i(3, exp.hunks);
 
-	cl_assert(exp.lines == 4);
-	cl_assert(exp.line_ctxt == 0);
-	cl_assert(exp.line_adds == 3);
-	cl_assert(exp.line_dels == 1);
+	cl_assert_equal_i(4, exp.lines);
+	cl_assert_equal_i(0, exp.line_ctxt);
+	cl_assert_equal_i(3, exp.line_adds);
+	cl_assert_equal_i(1, exp.line_dels);
 
 	git_diff_list_free(diff);
 	git_tree_free(a);
@@ -242,17 +242,17 @@ void test_diff_tree__merge(void)
 	cl_git_pass(git_diff_foreach(
 		diff1, &exp, diff_file_fn, diff_hunk_fn, diff_line_fn));
 
-	cl_assert(exp.files == 6);
-	cl_assert(exp.file_adds == 2);
-	cl_assert(exp.file_dels == 1);
-	cl_assert(exp.file_mods == 3);
+	cl_assert_equal_i(6, exp.files);
+	cl_assert_equal_i(2, exp.file_adds);
+	cl_assert_equal_i(1, exp.file_dels);
+	cl_assert_equal_i(3, exp.file_mods);
 
-	cl_assert(exp.hunks == 6);
+	cl_assert_equal_i(6, exp.hunks);
 
-	cl_assert(exp.lines == 59);
-	cl_assert(exp.line_ctxt == 1);
-	cl_assert(exp.line_adds == 36);
-	cl_assert(exp.line_dels == 22);
+	cl_assert_equal_i(59, exp.lines);
+	cl_assert_equal_i(1, exp.line_ctxt);
+	cl_assert_equal_i(36, exp.line_adds);
+	cl_assert_equal_i(22, exp.line_dels);
 
 	git_diff_list_free(diff1);
 }
diff --git a/tests-clar/diff/workdir.c b/tests-clar/diff/workdir.c
index 801439e30..eac7eb87d 100644
--- a/tests-clar/diff/workdir.c
+++ b/tests-clar/diff/workdir.c
@@ -17,6 +17,7 @@ void test_diff_workdir__to_index(void)
 	git_diff_options opts = {0};
 	git_diff_list *diff = NULL;
 	diff_expects exp;
+	int use_iterator;
 
 	g_repo = cl_git_sandbox_init("status");
 
@@ -24,33 +25,39 @@ void test_diff_workdir__to_index(void)
 	opts.interhunk_lines = 1;
 	opts.flags |= GIT_DIFF_INCLUDE_IGNORED | GIT_DIFF_INCLUDE_UNTRACKED;
 
-	memset(&exp, 0, sizeof(exp));
-
 	cl_git_pass(git_diff_workdir_to_index(g_repo, &opts, &diff));
 
-	cl_git_pass(git_diff_foreach(
-		diff, &exp, diff_file_fn, diff_hunk_fn, diff_line_fn));
-
-	/* to generate these values:
-	 * - cd to tests/resources/status,
-	 * - mv .gitted .git
-	 * - git diff --name-status
-	 * - git diff
-	 * - mv .git .gitted
-	 */
-	cl_assert_equal_i(13, 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(4, 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);
+	for (use_iterator = 0; use_iterator <= 1; use_iterator++) {
+		memset(&exp, 0, sizeof(exp));
+
+		if (use_iterator)
+			cl_git_pass(diff_foreach_via_iterator(
+				diff, &exp, diff_file_fn, diff_hunk_fn, diff_line_fn));
+		else
+			cl_git_pass(git_diff_foreach(
+				diff, &exp, diff_file_fn, diff_hunk_fn, diff_line_fn));
+
+		/* to generate these values:
+		 * - cd to tests/resources/status,
+		 * - mv .gitted .git
+		 * - git diff --name-status
+		 * - git diff
+		 * - mv .git .gitted
+		 */
+		cl_assert_equal_i(13, 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(4, 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);
 }
@@ -65,6 +72,7 @@ void test_diff_workdir__to_tree(void)
 	git_diff_list *diff = NULL;
 	git_diff_list *diff2 = NULL;
 	diff_expects exp;
+	int use_iterator;
 
 	g_repo = cl_git_sandbox_init("status");
 
@@ -75,8 +83,6 @@ void test_diff_workdir__to_tree(void)
 	opts.interhunk_lines = 1;
 	opts.flags |= GIT_DIFF_INCLUDE_IGNORED | GIT_DIFF_INCLUDE_UNTRACKED;
 
-	memset(&exp, 0, sizeof(exp));
-
 	/* You can't really generate the equivalent of git_diff_workdir_to_tree()
 	 * using C git.  It really wants to interpose the index into the diff.
 	 *
@@ -89,15 +95,23 @@ void test_diff_workdir__to_tree(void)
 	 */
 	cl_git_pass(git_diff_workdir_to_tree(g_repo, &opts, a, &diff));
 
-	cl_git_pass(git_diff_foreach(
-		diff, &exp, diff_file_fn, diff_hunk_fn, diff_line_fn));
+	for (use_iterator = 0; use_iterator <= 1; use_iterator++) {
+		memset(&exp, 0, sizeof(exp));
 
-	cl_assert_equal_i(14, 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(5, exp.file_untracked);
+		if (use_iterator)
+			cl_git_pass(diff_foreach_via_iterator(
+				diff, &exp, diff_file_fn, diff_hunk_fn, diff_line_fn));
+		else
+			cl_git_pass(git_diff_foreach(
+				diff, &exp, diff_file_fn, diff_hunk_fn, diff_line_fn));
+
+		cl_assert_equal_i(14, 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(5, exp.file_untracked);
+	}
 
 	/* Since there is no git diff equivalent, let's just assume that the
 	 * text diffs produced by git_diff_foreach are accurate here.  We will
@@ -117,22 +131,30 @@ void test_diff_workdir__to_tree(void)
 	cl_git_pass(git_diff_merge(diff, diff2));
 	git_diff_list_free(diff2);
 
-	cl_git_pass(git_diff_foreach(
-		diff, &exp, diff_file_fn, diff_hunk_fn, diff_line_fn));
+	for (use_iterator = 0; use_iterator <= 1; use_iterator++) {
+		memset(&exp, 0, sizeof(exp));
+
+		if (use_iterator)
+			cl_git_pass(diff_foreach_via_iterator(
+				diff, &exp, diff_file_fn, diff_hunk_fn, diff_line_fn));
+		else
+			cl_git_pass(git_diff_foreach(
+				diff, &exp, diff_file_fn, diff_hunk_fn, diff_line_fn));
 
-	cl_assert_equal_i(15, exp.files);
-	cl_assert_equal_i(2, exp.file_adds);
-	cl_assert_equal_i(5, 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(15, exp.files);
+		cl_assert_equal_i(2, exp.file_adds);
+		cl_assert_equal_i(5, 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(11, exp.hunks);
+		cl_assert_equal_i(11, exp.hunks);
 
-	cl_assert_equal_i(17, exp.lines);
-	cl_assert_equal_i(4, exp.line_ctxt);
-	cl_assert_equal_i(8, exp.line_adds);
-	cl_assert_equal_i(5, exp.line_dels);
+		cl_assert_equal_i(17, exp.lines);
+		cl_assert_equal_i(4, exp.line_ctxt);
+		cl_assert_equal_i(8, exp.line_adds);
+		cl_assert_equal_i(5, exp.line_dels);
+	}
 
 	git_diff_list_free(diff);
 	diff = NULL;
@@ -146,22 +168,30 @@ void test_diff_workdir__to_tree(void)
 	cl_git_pass(git_diff_merge(diff, diff2));
 	git_diff_list_free(diff2);
 
-	cl_git_pass(git_diff_foreach(
-		diff, &exp, diff_file_fn, diff_hunk_fn, diff_line_fn));
+	for (use_iterator = 0; use_iterator <= 1; use_iterator++) {
+		memset(&exp, 0, sizeof(exp));
 
-	cl_assert_equal_i(16, exp.files);
-	cl_assert_equal_i(5, exp.file_adds);
-	cl_assert_equal_i(4, exp.file_dels);
-	cl_assert_equal_i(3, exp.file_mods);
-	cl_assert_equal_i(1, exp.file_ignored);
-	cl_assert_equal_i(3, exp.file_untracked);
+		if (use_iterator)
+			cl_git_pass(diff_foreach_via_iterator(
+				diff, &exp, diff_file_fn, diff_hunk_fn, diff_line_fn));
+		else
+			cl_git_pass(git_diff_foreach(
+				diff, &exp, diff_file_fn, diff_hunk_fn, diff_line_fn));
 
-	cl_assert_equal_i(12, exp.hunks);
+		cl_assert_equal_i(16, exp.files);
+		cl_assert_equal_i(5, exp.file_adds);
+		cl_assert_equal_i(4, exp.file_dels);
+		cl_assert_equal_i(3, exp.file_mods);
+		cl_assert_equal_i(1, exp.file_ignored);
+		cl_assert_equal_i(3, exp.file_untracked);
 
-	cl_assert_equal_i(19, exp.lines);
-	cl_assert_equal_i(3, exp.line_ctxt);
-	cl_assert_equal_i(12, exp.line_adds);
-	cl_assert_equal_i(4, exp.line_dels);
+		cl_assert_equal_i(12, exp.hunks);
+
+		cl_assert_equal_i(19, exp.lines);
+		cl_assert_equal_i(3, exp.line_ctxt);
+		cl_assert_equal_i(12, exp.line_adds);
+		cl_assert_equal_i(4, exp.line_dels);
+	}
 
 	git_diff_list_free(diff);
 
@@ -175,6 +205,7 @@ void test_diff_workdir__to_index_with_pathspec(void)
 	git_diff_list *diff = NULL;
 	diff_expects exp;
 	char *pathspec = NULL;
+	int use_iterator;
 
 	g_repo = cl_git_sandbox_init("status");
 
@@ -184,62 +215,93 @@ void test_diff_workdir__to_index_with_pathspec(void)
 	opts.pathspec.strings = &pathspec;
 	opts.pathspec.count   = 1;
 
-	memset(&exp, 0, sizeof(exp));
-
 	cl_git_pass(git_diff_workdir_to_index(g_repo, &opts, &diff));
-	cl_git_pass(git_diff_foreach(diff, &exp, diff_file_fn, NULL, NULL));
 
-	cl_assert_equal_i(13, 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(4, exp.file_untracked);
+	for (use_iterator = 0; use_iterator <= 1; use_iterator++) {
+		memset(&exp, 0, sizeof(exp));
+
+		if (use_iterator)
+			cl_git_pass(diff_foreach_via_iterator(
+				diff, &exp, diff_file_fn, NULL, NULL));
+		else
+			cl_git_pass(git_diff_foreach(diff, &exp, diff_file_fn, NULL, NULL));
+
+		cl_assert_equal_i(13, 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(4, exp.file_untracked);
+	}
 
 	git_diff_list_free(diff);
 
-	memset(&exp, 0, sizeof(exp));
 	pathspec = "modified_file";
 
 	cl_git_pass(git_diff_workdir_to_index(g_repo, &opts, &diff));
-	cl_git_pass(git_diff_foreach(diff, &exp, diff_file_fn, NULL, NULL));
 
-	cl_assert_equal_i(1, exp.files);
-	cl_assert_equal_i(0, exp.file_adds);
-	cl_assert_equal_i(0, exp.file_dels);
-	cl_assert_equal_i(1, exp.file_mods);
-	cl_assert_equal_i(0, exp.file_ignored);
-	cl_assert_equal_i(0, exp.file_untracked);
+	for (use_iterator = 0; use_iterator <= 1; use_iterator++) {
+		memset(&exp, 0, sizeof(exp));
+
+		if (use_iterator)
+			cl_git_pass(diff_foreach_via_iterator(
+				diff, &exp, diff_file_fn, NULL, NULL));
+		else
+			cl_git_pass(git_diff_foreach(diff, &exp, diff_file_fn, NULL, NULL));
+
+		cl_assert_equal_i(1, exp.files);
+		cl_assert_equal_i(0, exp.file_adds);
+		cl_assert_equal_i(0, exp.file_dels);
+		cl_assert_equal_i(1, exp.file_mods);
+		cl_assert_equal_i(0, exp.file_ignored);
+		cl_assert_equal_i(0, exp.file_untracked);
+	}
 
 	git_diff_list_free(diff);
 
-	memset(&exp, 0, sizeof(exp));
 	pathspec = "subdir";
 
 	cl_git_pass(git_diff_workdir_to_index(g_repo, &opts, &diff));
-	cl_git_pass(git_diff_foreach(diff, &exp, diff_file_fn, NULL, NULL));
 
-	cl_assert_equal_i(3, exp.files);
-	cl_assert_equal_i(0, exp.file_adds);
-	cl_assert_equal_i(1, exp.file_dels);
-	cl_assert_equal_i(1, exp.file_mods);
-	cl_assert_equal_i(0, exp.file_ignored);
-	cl_assert_equal_i(1, exp.file_untracked);
+	for (use_iterator = 0; use_iterator <= 1; use_iterator++) {
+		memset(&exp, 0, sizeof(exp));
+
+		if (use_iterator)
+			cl_git_pass(diff_foreach_via_iterator(
+				diff, &exp, diff_file_fn, NULL, NULL));
+		else
+			cl_git_pass(git_diff_foreach(diff, &exp, diff_file_fn, NULL, NULL));
+
+		cl_assert_equal_i(3, exp.files);
+		cl_assert_equal_i(0, exp.file_adds);
+		cl_assert_equal_i(1, exp.file_dels);
+		cl_assert_equal_i(1, exp.file_mods);
+		cl_assert_equal_i(0, exp.file_ignored);
+		cl_assert_equal_i(1, exp.file_untracked);
+	}
 
 	git_diff_list_free(diff);
 
-	memset(&exp, 0, sizeof(exp));
 	pathspec = "*_deleted";
 
 	cl_git_pass(git_diff_workdir_to_index(g_repo, &opts, &diff));
-	cl_git_pass(git_diff_foreach(diff, &exp, diff_file_fn, NULL, NULL));
 
-	cl_assert_equal_i(2, exp.files);
-	cl_assert_equal_i(0, exp.file_adds);
-	cl_assert_equal_i(2, exp.file_dels);
-	cl_assert_equal_i(0, exp.file_mods);
-	cl_assert_equal_i(0, exp.file_ignored);
-	cl_assert_equal_i(0, exp.file_untracked);
+	for (use_iterator = 0; use_iterator <= 1; use_iterator++) {
+		memset(&exp, 0, sizeof(exp));
+
+		if (use_iterator)
+			cl_git_pass(diff_foreach_via_iterator(
+				diff, &exp, diff_file_fn, NULL, NULL));
+		else
+			cl_git_pass(git_diff_foreach(diff, &exp, diff_file_fn, NULL, NULL));
+
+		cl_assert_equal_i(2, exp.files);
+		cl_assert_equal_i(0, exp.file_adds);
+		cl_assert_equal_i(2, exp.file_dels);
+		cl_assert_equal_i(0, exp.file_mods);
+		cl_assert_equal_i(0, exp.file_ignored);
+		cl_assert_equal_i(0, exp.file_untracked);
+	}
 
 	git_diff_list_free(diff);
 }
@@ -249,6 +311,7 @@ void test_diff_workdir__filemode_changes(void)
 	git_config *cfg;
 	git_diff_list *diff = NULL;
 	diff_expects exp;
+	int use_iterator;
 
 	if (!cl_is_chmod_supported())
 		return;
@@ -262,13 +325,20 @@ void test_diff_workdir__filemode_changes(void)
 
 	cl_git_pass(git_diff_workdir_to_index(g_repo, NULL, &diff));
 
-	memset(&exp, 0, sizeof(exp));
-	cl_git_pass(git_diff_foreach(
-		diff, &exp, diff_file_fn, diff_hunk_fn, diff_line_fn));
+	for (use_iterator = 0; use_iterator <= 1; use_iterator++) {
+		memset(&exp, 0, sizeof(exp));
 
-	cl_assert_equal_i(0, exp.files);
-	cl_assert_equal_i(0, exp.file_mods);
-	cl_assert_equal_i(0, exp.hunks);
+		if (use_iterator)
+			cl_git_pass(diff_foreach_via_iterator(
+				diff, &exp, diff_file_fn, diff_hunk_fn, diff_line_fn));
+		else
+			cl_git_pass(git_diff_foreach(
+				diff, &exp, diff_file_fn, diff_hunk_fn, diff_line_fn));
+
+		cl_assert_equal_i(0, exp.files);
+		cl_assert_equal_i(0, exp.file_mods);
+		cl_assert_equal_i(0, exp.hunks);
+	}
 
 	git_diff_list_free(diff);
 
@@ -278,13 +348,20 @@ void test_diff_workdir__filemode_changes(void)
 
 	cl_git_pass(git_diff_workdir_to_index(g_repo, NULL, &diff));
 
-	memset(&exp, 0, sizeof(exp));
-	cl_git_pass(git_diff_foreach(
-		diff, &exp, diff_file_fn, diff_hunk_fn, diff_line_fn));
+	for (use_iterator = 0; use_iterator <= 1; use_iterator++) {
+		memset(&exp, 0, sizeof(exp));
 
-	cl_assert_equal_i(1, exp.files);
-	cl_assert_equal_i(1, exp.file_mods);
-	cl_assert_equal_i(0, exp.hunks);
+		if (use_iterator)
+			cl_git_pass(diff_foreach_via_iterator(
+				diff, &exp, diff_file_fn, diff_hunk_fn, diff_line_fn));
+		else
+			cl_git_pass(git_diff_foreach(
+				diff, &exp, diff_file_fn, diff_hunk_fn, diff_line_fn));
+
+		cl_assert_equal_i(1, exp.files);
+		cl_assert_equal_i(1, exp.file_mods);
+		cl_assert_equal_i(0, exp.hunks);
+	}
 
 	git_diff_list_free(diff);
 
@@ -347,6 +424,7 @@ void test_diff_workdir__head_index_and_workdir_all_differ(void)
 	diff_expects exp;
 	char *pathspec = "staged_changes_modified_file";
 	git_tree *tree;
+	int use_iterator;
 
 	/* For this file,
 	 * - head->index diff has 1 line of context, 1 line of diff
@@ -366,46 +444,70 @@ void test_diff_workdir__head_index_and_workdir_all_differ(void)
 	cl_git_pass(git_diff_index_to_tree(g_repo, &opts, tree, &diff_i2t));
 	cl_git_pass(git_diff_workdir_to_index(g_repo, &opts, &diff_w2i));
 
-	memset(&exp, 0, sizeof(exp));
-	cl_git_pass(git_diff_foreach(
-		diff_i2t, &exp, diff_file_fn, diff_hunk_fn, diff_line_fn));
-	cl_assert_equal_i(1, exp.files);
-	cl_assert_equal_i(0, exp.file_adds);
-	cl_assert_equal_i(0, exp.file_dels);
-	cl_assert_equal_i(1, exp.file_mods);
-	cl_assert_equal_i(1, exp.hunks);
-	cl_assert_equal_i(2, exp.lines);
-	cl_assert_equal_i(1, exp.line_ctxt);
-	cl_assert_equal_i(1, exp.line_adds);
-	cl_assert_equal_i(0, exp.line_dels);
-
-	memset(&exp, 0, sizeof(exp));
-	cl_git_pass(git_diff_foreach(
-		diff_w2i, &exp, diff_file_fn, diff_hunk_fn, diff_line_fn));
-	cl_assert_equal_i(1, exp.files);
-	cl_assert_equal_i(0, exp.file_adds);
-	cl_assert_equal_i(0, exp.file_dels);
-	cl_assert_equal_i(1, exp.file_mods);
-	cl_assert_equal_i(1, exp.hunks);
-	cl_assert_equal_i(3, exp.lines);
-	cl_assert_equal_i(2, exp.line_ctxt);
-	cl_assert_equal_i(1, exp.line_adds);
-	cl_assert_equal_i(0, exp.line_dels);
+	for (use_iterator = 0; use_iterator <= 1; use_iterator++) {
+		memset(&exp, 0, sizeof(exp));
+
+		if (use_iterator)
+			cl_git_pass(diff_foreach_via_iterator(
+				diff_i2t, &exp, diff_file_fn, diff_hunk_fn, diff_line_fn));
+		else
+			cl_git_pass(git_diff_foreach(
+				diff_i2t, &exp, diff_file_fn, diff_hunk_fn, diff_line_fn));
+
+		cl_assert_equal_i(1, exp.files);
+		cl_assert_equal_i(0, exp.file_adds);
+		cl_assert_equal_i(0, exp.file_dels);
+		cl_assert_equal_i(1, exp.file_mods);
+		cl_assert_equal_i(1, exp.hunks);
+		cl_assert_equal_i(2, exp.lines);
+		cl_assert_equal_i(1, exp.line_ctxt);
+		cl_assert_equal_i(1, exp.line_adds);
+		cl_assert_equal_i(0, exp.line_dels);
+	}
+
+	for (use_iterator = 0; use_iterator <= 1; use_iterator++) {
+		memset(&exp, 0, sizeof(exp));
+
+		if (use_iterator)
+			cl_git_pass(diff_foreach_via_iterator(
+				diff_w2i, &exp, diff_file_fn, diff_hunk_fn, diff_line_fn));
+		else
+			cl_git_pass(git_diff_foreach(
+				diff_w2i, &exp, diff_file_fn, diff_hunk_fn, diff_line_fn));
+
+		cl_assert_equal_i(1, exp.files);
+		cl_assert_equal_i(0, exp.file_adds);
+		cl_assert_equal_i(0, exp.file_dels);
+		cl_assert_equal_i(1, exp.file_mods);
+		cl_assert_equal_i(1, exp.hunks);
+		cl_assert_equal_i(3, exp.lines);
+		cl_assert_equal_i(2, exp.line_ctxt);
+		cl_assert_equal_i(1, exp.line_adds);
+		cl_assert_equal_i(0, exp.line_dels);
+	}
 
 	cl_git_pass(git_diff_merge(diff_i2t, diff_w2i));
 
-	memset(&exp, 0, sizeof(exp));
-	cl_git_pass(git_diff_foreach(
-		diff_i2t, &exp, diff_file_fn, diff_hunk_fn, diff_line_fn));
-	cl_assert_equal_i(1, exp.files);
-	cl_assert_equal_i(0, exp.file_adds);
-	cl_assert_equal_i(0, exp.file_dels);
-	cl_assert_equal_i(1, exp.file_mods);
-	cl_assert_equal_i(1, exp.hunks);
-	cl_assert_equal_i(3, exp.lines);
-	cl_assert_equal_i(1, exp.line_ctxt);
-	cl_assert_equal_i(2, exp.line_adds);
-	cl_assert_equal_i(0, exp.line_dels);
+	for (use_iterator = 0; use_iterator <= 1; use_iterator++) {
+		memset(&exp, 0, sizeof(exp));
+
+		if (use_iterator)
+			cl_git_pass(diff_foreach_via_iterator(
+				diff_i2t, &exp, diff_file_fn, diff_hunk_fn, diff_line_fn));
+		else
+			cl_git_pass(git_diff_foreach(
+				diff_i2t, &exp, diff_file_fn, diff_hunk_fn, diff_line_fn));
+
+		cl_assert_equal_i(1, exp.files);
+		cl_assert_equal_i(0, exp.file_adds);
+		cl_assert_equal_i(0, exp.file_dels);
+		cl_assert_equal_i(1, exp.file_mods);
+		cl_assert_equal_i(1, exp.hunks);
+		cl_assert_equal_i(3, exp.lines);
+		cl_assert_equal_i(1, exp.line_ctxt);
+		cl_assert_equal_i(2, exp.line_adds);
+		cl_assert_equal_i(0, exp.line_dels);
+	}
 
 	git_diff_list_free(diff_i2t);
 	git_diff_list_free(diff_w2i);
@@ -419,6 +521,7 @@ void test_diff_workdir__eof_newline_changes(void)
 	git_diff_list *diff = NULL;
 	diff_expects exp;
 	char *pathspec = "current_file";
+	int use_iterator;
 
 	g_repo = cl_git_sandbox_init("status");
 
@@ -427,18 +530,26 @@ void test_diff_workdir__eof_newline_changes(void)
 
 	cl_git_pass(git_diff_workdir_to_index(g_repo, &opts, &diff));
 
-	memset(&exp, 0, sizeof(exp));
-	cl_git_pass(git_diff_foreach(
-		diff, &exp, diff_file_fn, diff_hunk_fn, diff_line_fn));
-	cl_assert_equal_i(0, exp.files);
-	cl_assert_equal_i(0, exp.file_adds);
-	cl_assert_equal_i(0, exp.file_dels);
-	cl_assert_equal_i(0, exp.file_mods);
-	cl_assert_equal_i(0, exp.hunks);
-	cl_assert_equal_i(0, exp.lines);
-	cl_assert_equal_i(0, exp.line_ctxt);
-	cl_assert_equal_i(0, exp.line_adds);
-	cl_assert_equal_i(0, exp.line_dels);
+	for (use_iterator = 0; use_iterator <= 1; use_iterator++) {
+		memset(&exp, 0, sizeof(exp));
+
+		if (use_iterator)
+			cl_git_pass(diff_foreach_via_iterator(
+				diff, &exp, diff_file_fn, diff_hunk_fn, diff_line_fn));
+		else
+			cl_git_pass(git_diff_foreach(
+				diff, &exp, diff_file_fn, diff_hunk_fn, diff_line_fn));
+
+		cl_assert_equal_i(0, exp.files);
+		cl_assert_equal_i(0, exp.file_adds);
+		cl_assert_equal_i(0, exp.file_dels);
+		cl_assert_equal_i(0, exp.file_mods);
+		cl_assert_equal_i(0, exp.hunks);
+		cl_assert_equal_i(0, exp.lines);
+		cl_assert_equal_i(0, exp.line_ctxt);
+		cl_assert_equal_i(0, exp.line_adds);
+		cl_assert_equal_i(0, exp.line_dels);
+	}
 
 	git_diff_list_free(diff);
 
@@ -446,18 +557,26 @@ void test_diff_workdir__eof_newline_changes(void)
 
 	cl_git_pass(git_diff_workdir_to_index(g_repo, &opts, &diff));
 
-	memset(&exp, 0, sizeof(exp));
-	cl_git_pass(git_diff_foreach(
-		diff, &exp, diff_file_fn, diff_hunk_fn, diff_line_fn));
-	cl_assert_equal_i(1, exp.files);
-	cl_assert_equal_i(0, exp.file_adds);
-	cl_assert_equal_i(0, exp.file_dels);
-	cl_assert_equal_i(1, exp.file_mods);
-	cl_assert_equal_i(1, exp.hunks);
-	cl_assert_equal_i(2, exp.lines);
-	cl_assert_equal_i(1, exp.line_ctxt);
-	cl_assert_equal_i(1, exp.line_adds);
-	cl_assert_equal_i(0, exp.line_dels);
+	for (use_iterator = 0; use_iterator <= 1; use_iterator++) {
+		memset(&exp, 0, sizeof(exp));
+
+		if (use_iterator)
+			cl_git_pass(diff_foreach_via_iterator(
+				diff, &exp, diff_file_fn, diff_hunk_fn, diff_line_fn));
+		else
+			cl_git_pass(git_diff_foreach(
+				diff, &exp, diff_file_fn, diff_hunk_fn, diff_line_fn));
+
+		cl_assert_equal_i(1, exp.files);
+		cl_assert_equal_i(0, exp.file_adds);
+		cl_assert_equal_i(0, exp.file_dels);
+		cl_assert_equal_i(1, exp.file_mods);
+		cl_assert_equal_i(1, exp.hunks);
+		cl_assert_equal_i(2, exp.lines);
+		cl_assert_equal_i(1, exp.line_ctxt);
+		cl_assert_equal_i(1, exp.line_adds);
+		cl_assert_equal_i(0, exp.line_dels);
+	}
 
 	git_diff_list_free(diff);
 
@@ -465,18 +584,26 @@ void test_diff_workdir__eof_newline_changes(void)
 
 	cl_git_pass(git_diff_workdir_to_index(g_repo, &opts, &diff));
 
-	memset(&exp, 0, sizeof(exp));
-	cl_git_pass(git_diff_foreach(
-		diff, &exp, diff_file_fn, diff_hunk_fn, diff_line_fn));
-	cl_assert_equal_i(1, exp.files);
-	cl_assert_equal_i(0, exp.file_adds);
-	cl_assert_equal_i(0, exp.file_dels);
-	cl_assert_equal_i(1, exp.file_mods);
-	cl_assert_equal_i(1, exp.hunks);
-	cl_assert_equal_i(3, exp.lines);
-	cl_assert_equal_i(0, exp.line_ctxt);
-	cl_assert_equal_i(1, exp.line_adds);
-	cl_assert_equal_i(2, exp.line_dels);
+	for (use_iterator = 0; use_iterator <= 1; use_iterator++) {
+		memset(&exp, 0, sizeof(exp));
+
+		if (use_iterator)
+			cl_git_pass(diff_foreach_via_iterator(
+				diff, &exp, diff_file_fn, diff_hunk_fn, diff_line_fn));
+		else
+			cl_git_pass(git_diff_foreach(
+				diff, &exp, diff_file_fn, diff_hunk_fn, diff_line_fn));
+
+		cl_assert_equal_i(1, exp.files);
+		cl_assert_equal_i(0, exp.file_adds);
+		cl_assert_equal_i(0, exp.file_dels);
+		cl_assert_equal_i(1, exp.file_mods);
+		cl_assert_equal_i(1, exp.hunks);
+		cl_assert_equal_i(3, exp.lines);
+		cl_assert_equal_i(0, exp.line_ctxt);
+		cl_assert_equal_i(1, exp.line_adds);
+		cl_assert_equal_i(2, exp.line_dels);
+	}
 
 	git_diff_list_free(diff);
 }