#include "clar_libgit2.h"

#include "diff_helpers.h"

#include "repository.h"

#include "git2/sys/diff.h"

#include "../checkout/checkout_helpers.h"

static git_repository *g_repo = NULL;

void test_diff_workdir__cleanup(void)

{

	cl_git_sandbox_cleanup();

}

void test_diff_workdir__to_index(void)

{

	git_diff_options opts = GIT_DIFF_OPTIONS_INIT;

	git_diff *diff = NULL;

	diff_expects exp;

	int use_iterator;

	g_repo = cl_git_sandbox_init("status");

	opts.context_lines = 3;

	opts.interhunk_lines = 1;

	opts.flags |= GIT_DIFF_INCLUDE_IGNORED | GIT_DIFF_INCLUDE_UNTRACKED;

	cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));

	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, 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_binary_cb, diff_hunk_cb, diff_line_cb, &exp);;

		/* 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_status[GIT_DELTA_ADDED]);

		cl_assert_equal_i(4, exp.file_status[GIT_DELTA_DELETED]);

		cl_assert_equal_i(4, exp.file_status[GIT_DELTA_MODIFIED]);

		cl_assert_equal_i(1, exp.file_status[GIT_DELTA_IGNORED]);

		cl_assert_equal_i(4, exp.file_status[GIT_DELTA_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_perfdata perf = GIT_DIFF_PERFDATA_INIT;

		cl_git_pass(git_diff_get_perfdata(&perf, diff));

		cl_assert_equal_sz(

			13 /* in root */ + 3 /* in subdir */, perf.stat_calls);

		cl_assert_equal_sz(5, perf.oid_calculations);

	}

	git_diff_free(diff);

}

void test_diff_workdir__to_index_with_conflicts(void)

{

	git_diff_options opts = GIT_DIFF_OPTIONS_INIT;

	git_diff *diff = NULL;

	git_index *index;

	git_index_entry our_entry = {{0}}, their_entry = {{0}};

	diff_expects exp = {0};

	g_repo = cl_git_sandbox_init("status");

	opts.context_lines = 3;

	opts.interhunk_lines = 1;

	/* Adding an entry that represents a rename gets two files in conflict */

	our_entry.path = "subdir/modified_file";

	our_entry.mode = 0100644;

	git_oid_fromstr(&our_entry.id, "ee3fa1b8c00aff7fe02065fdb50864bb0d932ccf");

	their_entry.path = "subdir/rename_conflict";

	their_entry.mode = 0100644;

	git_oid_fromstr(&their_entry.id, "2bd0a343aeef7a2cf0d158478966a6e587ff3863");

	cl_git_pass(git_repository_index(&index, g_repo));

	cl_git_pass(git_index_conflict_add(index, NULL, &our_entry, &their_entry));

	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_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]);

	cl_assert_equal_i(4, exp.file_status[GIT_DELTA_DELETED]);

	cl_assert_equal_i(3, exp.file_status[GIT_DELTA_MODIFIED]);

	cl_assert_equal_i(2, exp.file_status[GIT_DELTA_CONFLICTED]);

	cl_assert_equal_i(7, exp.hunks);

	cl_assert_equal_i(12, exp.lines);

	cl_assert_equal_i(4, exp.line_ctxt);

	cl_assert_equal_i(3, exp.line_adds);

	cl_assert_equal_i(5, exp.line_dels);

	git_diff_free(diff);

	git_index_free(index);

}

void test_diff_workdir__to_index_with_assume_unchanged(void)

{

	git_diff_options opts = GIT_DIFF_OPTIONS_INIT;

	git_diff *diff = NULL;

	git_index *idx = NULL;

	diff_expects exp;

	const git_index_entry *iep;

	git_index_entry ie;

	g_repo = cl_git_sandbox_init("status");

	/* do initial diff */

	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_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]);

	cl_assert_equal_i(4, exp.file_status[GIT_DELTA_MODIFIED]);

	git_diff_free(diff);

	/* mark a couple of entries with ASSUME_UNCHANGED */

	cl_git_pass(git_repository_index(&idx, g_repo));

	cl_assert((iep = git_index_get_bypath(idx, "modified_file", 0)) != NULL);

	memcpy(&ie, iep, sizeof(ie));

	ie.flags |= GIT_IDXENTRY_VALID;

	cl_git_pass(git_index_add(idx, &ie);;

	cl_assert((iep = git_index_get_bypath(idx, "file_deleted", 0)) != NULL);

	memcpy(&ie, iep, sizeof(ie));

	ie.flags |= GIT_IDXENTRY_VALID;

	cl_git_pass(git_index_add(idx, &ie);;

	cl_git_pass(git_index_write(idx));

	git_index_free(idx);

	/* redo diff and see that entries are skipped */

	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_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]);

	cl_assert_equal_i(3, exp.file_status[GIT_DELTA_MODIFIED]);

	git_diff_free(diff);

}

void test_diff_workdir__to_tree(void)

{

	/* grabbed a couple of commit oids from the history of the attr repo */

	const char *a_commit = "26a125ee1bf"; /* the current HEAD */

	const char *b_commit = "0017bd4ab1ec3"; /* the start */

	git_tree *a, *b;

	git_diff_options opts = GIT_DIFF_OPTIONS_INIT;

	git_diff *diff = NULL;

	git_diff *diff2 = NULL;

	diff_expects exp;

	int use_iterator;

	g_repo = cl_git_sandbox_init("status");

	a = resolve_commit_oid_to_tree(g_repo, a_commit);

	b = resolve_commit_oid_to_tree(g_repo, b_commit);

	opts.context_lines = 3;

	opts.interhunk_lines = 1;

	opts.flags |= GIT_DIFF_INCLUDE_IGNORED | GIT_DIFF_INCLUDE_UNTRACKED;

	/* You can't really generate the equivalent of git_diff_tree_to_workdir()

	 * using C git.  It really wants to interpose the index into the diff.

	 *

	 * To validate the following results with command line git, I ran the

	 * following:

	 * - git ls-tree 26a125

	 * - find . ! -path ./.git/\* -a -type f | git hash-object --stdin-paths

	 * The results are documented at the bottom of this file in the

	 * long comment entitled "PREPARATION OF TEST DATA".

	 */

	cl_git_pass(git_diff_tree_to_workdir(&diff, g_repo, a, &opts));

	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, 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_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]);

		cl_assert_equal_i(4, exp.file_status[GIT_DELTA_DELETED]);

		cl_assert_equal_i(4, exp.file_status[GIT_DELTA_MODIFIED]);

		cl_assert_equal_i(1, exp.file_status[GIT_DELTA_IGNORED]);

		cl_assert_equal_i(5, exp.file_status[GIT_DELTA_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

	 * do more apples-to-apples test comparison below.

	 */

	git_diff_free(diff);

	diff = NULL;

	memset(&exp, 0, sizeof(exp));

	/* This is a compatible emulation of "git diff <sha>" which looks like

	 * a workdir to tree diff (even though it is not really).  This is what

	 * you would get from "git diff --name-status 26a125ee1bf"

	 */

	cl_git_pass(git_diff_tree_to_index(&diff, g_repo, a, NULL, &opts));

	cl_git_pass(git_diff_index_to_workdir(&diff2, g_repo, NULL, &opts));

	cl_git_pass(git_diff_merge(diff, diff2));

	git_diff_free(diff2);

	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, 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_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]);

		cl_assert_equal_i(5, exp.file_status[GIT_DELTA_DELETED]);

		cl_assert_equal_i(4, exp.file_status[GIT_DELTA_MODIFIED]);

		cl_assert_equal_i(1, exp.file_status[GIT_DELTA_IGNORED]);

		cl_assert_equal_i(3, exp.file_status[GIT_DELTA_UNTRACKED]);

		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);

	}

	git_diff_free(diff);

	diff = NULL;

	memset(&exp, 0, sizeof(exp));

	/* Again, emulating "git diff <sha>" for testing purposes using

	 * "git diff --name-status 0017bd4ab1ec3" instead.

	 */

	cl_git_pass(git_diff_tree_to_index(&diff, g_repo, b, NULL, &opts));

	cl_git_pass(git_diff_index_to_workdir(&diff2, g_repo, NULL, &opts));

	cl_git_pass(git_diff_merge(diff, diff2));

	git_diff_free(diff2);

	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, 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_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]);

		cl_assert_equal_i(4, exp.file_status[GIT_DELTA_DELETED]);

		cl_assert_equal_i(3, exp.file_status[GIT_DELTA_MODIFIED]);

		cl_assert_equal_i(1, exp.file_status[GIT_DELTA_IGNORED]);

		cl_assert_equal_i(3, exp.file_status[GIT_DELTA_UNTRACKED]);

		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_free(diff);

	/* Let's try that once more with a reversed diff */

	opts.flags |= GIT_DIFF_REVERSE;

	cl_git_pass(git_diff_tree_to_index(&diff, g_repo, b, NULL, &opts));

	cl_git_pass(git_diff_index_to_workdir(&diff2, g_repo, NULL, &opts));

	cl_git_pass(git_diff_merge(diff, diff2));

	git_diff_free(diff2);

	memset(&exp, 0, sizeof(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(16, exp.files);

	cl_assert_equal_i(5, exp.file_status[GIT_DELTA_DELETED]);

	cl_assert_equal_i(4, exp.file_status[GIT_DELTA_ADDED]);

	cl_assert_equal_i(3, exp.file_status[GIT_DELTA_MODIFIED]);

	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_IGNORED]);

	cl_assert_equal_i(3, exp.file_status[GIT_DELTA_UNTRACKED]);

	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_dels);

	cl_assert_equal_i(4, exp.line_adds);

	git_diff_free(diff);

	/* all done now */

	git_tree_free(a);

	git_tree_free(b);

}

void test_diff_workdir__to_index_with_pathspec(void)

{

	git_diff_options opts = GIT_DIFF_OPTIONS_INIT;

	git_diff *diff = NULL;

	diff_expects exp;

	char *pathspec = NULL;

	int use_iterator;

	g_repo = cl_git_sandbox_init("status");

	opts.context_lines = 3;

	opts.interhunk_lines = 1;

	opts.flags |= GIT_DIFF_INCLUDE_IGNORED | GIT_DIFF_INCLUDE_UNTRACKED;

	opts.pathspec.strings = &pathspec;

	opts.pathspec.count   = 1;

	cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));

	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, diff_file_cb, NULL, NULL, NULL, &exp);;

		else

			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]);

		cl_assert_equal_i(4, exp.file_status[GIT_DELTA_DELETED]);

		cl_assert_equal_i(4, exp.file_status[GIT_DELTA_MODIFIED]);

		cl_assert_equal_i(1, exp.file_status[GIT_DELTA_IGNORED]);

		cl_assert_equal_i(4, exp.file_status[GIT_DELTA_UNTRACKED]);

	}

	git_diff_free(diff);

	pathspec = "modified_file";

	cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));

	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, diff_file_cb, NULL, NULL, NULL, &exp);;

		else

			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]);

		cl_assert_equal_i(0, exp.file_status[GIT_DELTA_DELETED]);

		cl_assert_equal_i(1, exp.file_status[GIT_DELTA_MODIFIED]);

		cl_assert_equal_i(0, exp.file_status[GIT_DELTA_IGNORED]);

		cl_assert_equal_i(0, exp.file_status[GIT_DELTA_UNTRACKED]);

	}

	git_diff_free(diff);

	pathspec = "subdir";

	cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));

	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, diff_file_cb, NULL, NULL, NULL, &exp);;

		else

			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]);

		cl_assert_equal_i(1, exp.file_status[GIT_DELTA_DELETED]);

		cl_assert_equal_i(1, exp.file_status[GIT_DELTA_MODIFIED]);

		cl_assert_equal_i(0, exp.file_status[GIT_DELTA_IGNORED]);

		cl_assert_equal_i(1, exp.file_status[GIT_DELTA_UNTRACKED]);

	}

	git_diff_free(diff);

	pathspec = "*_deleted";

	cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));

	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, diff_file_cb, NULL, NULL, NULL, &exp);;

		else

			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]);

		cl_assert_equal_i(2, exp.file_status[GIT_DELTA_DELETED]);

		cl_assert_equal_i(0, exp.file_status[GIT_DELTA_MODIFIED]);

		cl_assert_equal_i(0, exp.file_status[GIT_DELTA_IGNORED]);

		cl_assert_equal_i(0, exp.file_status[GIT_DELTA_UNTRACKED]);

	}

	git_diff_free(diff);

}

void test_diff_workdir__to_index_with_pathlist_disabling_fnmatch(void)

{

	git_diff_options opts = GIT_DIFF_OPTIONS_INIT;

	git_diff *diff = NULL;

	diff_expects exp;

	char *pathspec = NULL;

	int use_iterator;

	g_repo = cl_git_sandbox_init("status");

	opts.context_lines = 3;

	opts.interhunk_lines = 1;

	opts.flags |= GIT_DIFF_INCLUDE_IGNORED | GIT_DIFF_INCLUDE_UNTRACKED |

		GIT_DIFF_DISABLE_PATHSPEC_MATCH;

	opts.pathspec.strings = &pathspec;

	opts.pathspec.count   = 0;

	/* ensure that an empty pathspec list is ignored */

	cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));

	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, diff_file_cb, NULL, NULL, NULL, &exp);;

		else

			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]);

		cl_assert_equal_i(4, exp.file_status[GIT_DELTA_DELETED]);

		cl_assert_equal_i(4, exp.file_status[GIT_DELTA_MODIFIED]);

		cl_assert_equal_i(1, exp.file_status[GIT_DELTA_IGNORED]);

		cl_assert_equal_i(4, exp.file_status[GIT_DELTA_UNTRACKED]);

	}

	git_diff_free(diff);

	/* ensure that a single NULL pathspec is filtered out (like when using

	 * fnmatch filtering)

	 */

	opts.pathspec.count   = 1;

	cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));

	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, diff_file_cb, NULL, NULL, NULL, &exp);;

		else

			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]);

		cl_assert_equal_i(4, exp.file_status[GIT_DELTA_DELETED]);

		cl_assert_equal_i(4, exp.file_status[GIT_DELTA_MODIFIED]);

		cl_assert_equal_i(1, exp.file_status[GIT_DELTA_IGNORED]);

		cl_assert_equal_i(4, exp.file_status[GIT_DELTA_UNTRACKED]);

	}

	git_diff_free(diff);

	pathspec = "modified_file";

	cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));

	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, diff_file_cb, NULL, NULL, NULL, &exp);;

		else

			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]);

		cl_assert_equal_i(0, exp.file_status[GIT_DELTA_DELETED]);

		cl_assert_equal_i(1, exp.file_status[GIT_DELTA_MODIFIED]);

		cl_assert_equal_i(0, exp.file_status[GIT_DELTA_IGNORED]);

		cl_assert_equal_i(0, exp.file_status[GIT_DELTA_UNTRACKED]);

	}

	git_diff_free(diff);

	/* ensure that subdirs can be specified */

	pathspec = "subdir";

	cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));

	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, diff_file_cb, NULL, NULL, NULL, &exp);;

		else

			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]);

		cl_assert_equal_i(1, exp.file_status[GIT_DELTA_DELETED]);

		cl_assert_equal_i(1, exp.file_status[GIT_DELTA_MODIFIED]);

		cl_assert_equal_i(0, exp.file_status[GIT_DELTA_IGNORED]);

		cl_assert_equal_i(1, exp.file_status[GIT_DELTA_UNTRACKED]);

	}

	git_diff_free(diff);

	/* ensure that subdirs can be specified with a trailing slash */

	pathspec = "subdir/";

	cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));

	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, diff_file_cb, NULL, NULL, NULL, &exp);;

		else

			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]);

		cl_assert_equal_i(1, exp.file_status[GIT_DELTA_DELETED]);

		cl_assert_equal_i(1, exp.file_status[GIT_DELTA_MODIFIED]);

		cl_assert_equal_i(0, exp.file_status[GIT_DELTA_IGNORED]);

		cl_assert_equal_i(1, exp.file_status[GIT_DELTA_UNTRACKED]);

	}

	git_diff_free(diff);

	/* ensure that fnmatching is completely disabled */

	pathspec = "subdir/*";

	cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));

	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, diff_file_cb, NULL, NULL, NULL, &exp);;

		else

			cl_git_pass(git_diff_foreach(diff, diff_file_cb, NULL, NULL, NULL, &exp);;

		cl_assert_equal_i(0, exp.files);

		cl_assert_equal_i(0, exp.file_status[GIT_DELTA_ADDED]);

		cl_assert_equal_i(0, exp.file_status[GIT_DELTA_DELETED]);

		cl_assert_equal_i(0, exp.file_status[GIT_DELTA_MODIFIED]);

		cl_assert_equal_i(0, exp.file_status[GIT_DELTA_IGNORED]);

		cl_assert_equal_i(0, exp.file_status[GIT_DELTA_UNTRACKED]);

	}

	git_diff_free(diff);

	/* ensure that the prefix matching isn't completely braindead */

	pathspec = "subdi";

	cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));

	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, diff_file_cb, NULL, NULL, NULL, &exp);;

		else

			cl_git_pass(git_diff_foreach(diff, diff_file_cb, NULL, NULL, NULL, &exp);;

		cl_assert_equal_i(0, exp.files);

		cl_assert_equal_i(0, exp.file_status[GIT_DELTA_ADDED]);

		cl_assert_equal_i(0, exp.file_status[GIT_DELTA_DELETED]);

		cl_assert_equal_i(0, exp.file_status[GIT_DELTA_MODIFIED]);

		cl_assert_equal_i(0, exp.file_status[GIT_DELTA_IGNORED]);

		cl_assert_equal_i(0, exp.file_status[GIT_DELTA_UNTRACKED]);

	}

	git_diff_free(diff);

	/* ensure that fnmatching isn't working at all */

	pathspec = "*_deleted";

	cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));

	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, diff_file_cb, NULL, NULL, NULL, &exp);;

		else

			cl_git_pass(git_diff_foreach(diff, diff_file_cb, NULL, NULL, NULL, &exp);;

		cl_assert_equal_i(0, exp.files);

		cl_assert_equal_i(0, exp.file_status[GIT_DELTA_ADDED]);

		cl_assert_equal_i(0, exp.file_status[GIT_DELTA_DELETED]);

		cl_assert_equal_i(0, exp.file_status[GIT_DELTA_MODIFIED]);

		cl_assert_equal_i(0, exp.file_status[GIT_DELTA_IGNORED]);

		cl_assert_equal_i(0, exp.file_status[GIT_DELTA_UNTRACKED]);

	}

	git_diff_free(diff);

}

void test_diff_workdir__filemode_changes(void)

{

	git_diff *diff = NULL;

	diff_expects exp;

	int use_iterator;

	if (!cl_is_chmod_supported())

		return;

	g_repo = cl_git_sandbox_init("issue_592");

	cl_repo_set_bool(g_repo, "core.filemode", true);

	/* test once with no mods */

	cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, NULL));

	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, 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_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]);

		cl_assert_equal_i(0, exp.hunks);

	}

	git_diff_free(diff);

	/* chmod file and test again */

	cl_assert(cl_toggle_filemode("issue_592/a.txt"));

	cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, NULL));

	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, 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_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]);

		cl_assert_equal_i(0, exp.hunks);

	}

	git_diff_free(diff);

	cl_assert(cl_toggle_filemode("issue_592/a.txt"));

}

void test_diff_workdir__filemode_changes_with_filemode_false(void)

{

	git_diff *diff = NULL;

	diff_expects exp;

	if (!cl_is_chmod_supported())

		return;

	g_repo = cl_git_sandbox_init("issue_592");

	cl_repo_set_bool(g_repo, "core.filemode", false);

	/* test once with no mods */

	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_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]);

	cl_assert_equal_i(0, exp.hunks);

	git_diff_free(diff);

	/* chmod file and test again */

	cl_assert(cl_toggle_filemode("issue_592/a.txt"));

	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_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]);

	cl_assert_equal_i(0, exp.hunks);

	git_diff_free(diff);

	cl_assert(cl_toggle_filemode("issue_592/a.txt"));

}

void test_diff_workdir__head_index_and_workdir_all_differ(void)

{

	git_diff_options opts = GIT_DIFF_OPTIONS_INIT;

	git_diff *diff_i2t = NULL, *diff_w2i = NULL;

	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

	 * - index->workdir diff has 2 lines of context, 1 line of diff

	 * but

	 * - head->workdir diff has 1 line of context, 2 lines of diff

	 * Let's make sure the right one is returned from each fn.

	 */

	g_repo = cl_git_sandbox_init("status");

	tree = resolve_commit_oid_to_tree(g_repo, "26a125ee1bfc5df1e1b2e9441bbe63c8a7ae989f");

	opts.pathspec.strings = &pathspec;

	opts.pathspec.count   = 1;

	cl_git_pass(git_diff_tree_to_index(&diff_i2t, g_repo, tree, NULL, &opts));

	cl_git_pass(git_diff_index_to_workdir(&diff_w2i, g_repo, NULL, &opts));

	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, 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_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]);

		cl_assert_equal_i(0, exp.file_status[GIT_DELTA_DELETED]);

		cl_assert_equal_i(1, exp.file_status[GIT_DELTA_MODIFIED]);

		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, 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_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]);

		cl_assert_equal_i(0, exp.file_status[GIT_DELTA_DELETED]);

		cl_assert_equal_i(1, exp.file_status[GIT_DELTA_MODIFIED]);

		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));

	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, 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_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]);

		cl_assert_equal_i(0, exp.file_status[GIT_DELTA_DELETED]);

		cl_assert_equal_i(1, exp.file_status[GIT_DELTA_MODIFIED]);

		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_free(diff_i2t);

	git_diff_free(diff_w2i);

	git_tree_free(tree);

}

void test_diff_workdir__eof_newline_changes(void)

{

	git_diff_options opts = GIT_DIFF_OPTIONS_INIT;

	git_diff *diff = NULL;

	diff_expects exp;

	char *pathspec = "current_file";

	int use_iterator;

	g_repo = cl_git_sandbox_init("status");

	opts.pathspec.strings = &pathspec;

	opts.pathspec.count   = 1;

	cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));

	for (use_iterator = 0; use_iterator <= 1; use_iterator++) {

		memset(&exp, 0, sizeof(exp));

		if (use_iterator)