Rework checkout with new strategy options

This is a major reworking of checkout strategy options.  The
checkout code is now sensitive to the contents of the HEAD tree
and the new options allow you to update the working tree so that
it will match the index content only when it previously matched
the contents of the HEAD.  This allows you to, for example, to
distinguish between removing files that are in the HEAD but not
in the index, vs just removing all untracked files.

Because of various corner cases that arise, etc., this required
some additional capabilities in rmdir and other utility functions.

This includes the beginnings of an implementation of code to read
a partial tree into the index based on a pathspec, but that is
not enabled because of the possibility of creating conflicting
index entries.

include/git2/checkout.h

@@ -25,20 +25,117 @@ GIT_BEGIN_DECL
  * Checkout behavior flags
  *
  * These flags control what checkout does with files.  Pass in a
- * combination of these values OR'ed together.
+ * combination of these values OR'ed together.  If you just pass zero
+ * (i.e. no flags), then you are effectively doing a "dry run" where no
+ * files will be modified.
+ *
+ * Checkout groups the working directory content into 3 classes of files:
+ * (1) files that don't need a change, and files that do need a change
+ * that either (2) we are allowed to modifed or (3) we are not.  The flags
+ * you pass in will decide which files we are allowed to modify.
+ *
+ * By default, checkout is not allowed to modify any files.  Anything
+ * needing a change would be considered a conflict.
+ *
+ * GIT_CHECKOUT_UPDATE_UNMODIFIED means that checkout is allowed to update
+ * any file where the working directory content matches the HEAD
+ * (e.g. either the files match or the file is absent in both places).
+ *
+ * GIT_CHECKOUT_UPDATE_MISSING means checkout can create a missing file
+ * that exists in the index and does not exist in the working directory.
+ * This is usually desirable for initial checkout, etc.  Technically, the
+ * missing file differs from the HEAD, which is why this is separate.
+ *
+ * GIT_CHECKOUT_UPDATE_MODIFIED means checkout is allowed to update files
+ * where the working directory does not match the HEAD so long as the file
+ * actually exists in the HEAD.  This option implies UPDATE_UNMODIFIED.
+ *
+ * GIT_CHECKOUT_UPDATE_UNTRACKED means checkout is allowed to update files
+ * even if there is a working directory version that does not exist in the
+ * HEAD (i.e. the file was independently created in the workdir).  This
+ * implies UPDATE_UNMODIFIED | UPDATE_MISSING (but *not* UPDATE_MODIFIED).
+ *
+ *
+ * On top of these three basic strategies, there are some modifiers
+ * options that can be applied:
+ *
+ * If any files need update but are disallowed by the strategy, normally
+ * checkout calls the conflict callback (if given) and then aborts.
+ * GIT_CHECKOUT_ALLOW_CONFLICTS means it is okay to update the files that
+ * are allowed by the strategy even if there are conflicts.  The conflict
+ * callbacks are still made, but non-conflicting files will be updated.
+ *
+ * Any unmerged entries in the index are automatically considered conflicts.
+ * If you want to proceed anyhow and just skip unmerged entries, you can use
+ * GIT_CHECKOUT_SKIP_UNMERGED which is less dangerous than just allowing all
+ * conflicts.  Alternatively, use GIT_CHECKOUT_USE_OURS to proceed and
+ * checkout the stage 2 ("ours") version.  GIT_CHECKOUT_USE_THEIRS means to
+ * proceed and use the stage 3 ("theirs") version.
+ *
+ * GIT_CHECKOUT_UPDATE_ONLY means that update is not allowed to create new
+ * files or delete old ones, only update existing content.  With this
+ * flag, files that needs to be created or deleted are not conflicts -
+ * they are just skipped.  This also skips typechanges to existing files
+ * (because the old would have to be removed).
+ *
+ * GIT_CHECKOUT_REMOVE_UNTRACKED means that files in the working directory
+ * that are untracked (and not ignored) will be removed altogether.  These
+ * untracked files (that do not shadow index entries) are not considered
+ * conflicts and would normally be ignored.
+ *
+ *
+ * Checkout is "semi-atomic" as in it will go through the work to be done
+ * before making any changes and if may decide to abort if there are
+ * conflicts, or you can use the conflict callback to explicitly abort the
+ * action before any updates are made.  Despite this, if a second process
+ * is modifying the filesystem while checkout is running, it can't
+ * guarantee that the choices is makes while initially examining the
+ * filesystem are still going to be correct as it applies them.
  */
 typedef enum {
-	/** Checkout does not update any files in the working directory. */
-	GIT_CHECKOUT_DEFAULT            = (1 << 0),
+	GIT_CHECKOUT_DEFAULT = 0, /** default is a dry run, no actual updates */
+
+	/** Allow update of entries where working dir matches HEAD. */
+	GIT_CHECKOUT_UPDATE_UNMODIFIED = (1u << 0),
+
+	/** Allow update of entries where working dir does not have file. */
+	GIT_CHECKOUT_UPDATE_MISSING = (1u << 1),
+
+	/** Allow safe updates that cannot overwrite uncommited data */
+	GIT_CHECKOUT_SAFE =
+		(GIT_CHECKOUT_UPDATE_UNMODIFIED | GIT_CHECKOUT_UPDATE_MISSING),
+
+	/** Allow update of entries in working dir that are modified from HEAD. */
+	GIT_CHECKOUT_UPDATE_MODIFIED = (1u << 2),
+
+	/** Update existing untracked files that are now present in the index. */
+	GIT_CHECKOUT_UPDATE_UNTRACKED = (1u << 3),
 
-	/** When a file exists and is modified, replace it with new version. */
-	GIT_CHECKOUT_OVERWRITE_MODIFIED = (1 << 1),
+	/** Allow all updates to force working directory to look like index */
+	GIT_CHECKOUT_FORCE =
+		(GIT_CHECKOUT_SAFE | GIT_CHECKOUT_UPDATE_MODIFIED | GIT_CHECKOUT_UPDATE_UNTRACKED),
 
-	/** When a file does not exist in the working directory, create it. */
-	GIT_CHECKOUT_CREATE_MISSING     = (1 << 2),
+	/** Allow checkout to make updates even if conflicts are found */
+	GIT_CHECKOUT_ALLOW_CONFLICTS = (1u << 4),
+
+	/** Remove untracked files not in index (that are not ignored) */
+	GIT_CHECKOUT_REMOVE_UNTRACKED = (1u << 5),
+
+	/** Only update existing files, don't create new ones */
+	GIT_CHECKOUT_UPDATE_ONLY = (1u << 6),
+
+	/** Allow checkout to skip unmerged files */
+	GIT_CHECKOUT_SKIP_UNMERGED = (1u << 10),
+	/** For unmerged files, checkout stage 2 from index */
+	GIT_CHECKOUT_USE_OURS = (1u << 11),
+	/** For unmerged files, checkout stage 3 from index */
+	GIT_CHECKOUT_USE_THEIRS = (1u << 12),
+
+	/** Recursively checkout submodule with same options */
+	GIT_CHECKOUT_UPDATE_SUBMODULES = (1u << 16),
+	/** Recursively checkout submodules only if HEAD moved in super repo */
+	GIT_CHECKOUT_UPDATE_SUBMODULES_IF_CHANGED = (1u << 17),
 
-	/** If an untracked file in found in the working dir, delete it. */
-	GIT_CHECKOUT_REMOVE_UNTRACKED   = (1 << 3),
 } git_checkout_strategy_t;
 
 /**
@@ -47,38 +144,38 @@ typedef enum {
  * Use zeros to indicate default settings.
  */
 typedef struct git_checkout_opts {
-	unsigned int checkout_strategy; /** default: GIT_CHECKOUT_DEFAULT */
+	unsigned int checkout_strategy; /** default will be a dry run */
+
 	int disable_filters; /** don't apply filters like CRLF conversion */
 	int dir_mode;		 /** default is 0755 */
 	int file_mode;		 /** default is 0644 or 0755 as dictated by blob */
 	int file_open_flags; /** default is O_CREAT | O_TRUNC | O_WRONLY */
 
-	/** Optional callback to notify the consumer of files that
-	 * haven't be checked out because a modified version of them
-	 * exist in the working directory.
-	 *
-	 * When provided, this callback will be invoked when the flag
-	 * GIT_CHECKOUT_OVERWRITE_MODIFIED isn't part of the checkout strategy.
+	/** Optional callback made on files where the index differs from the
+	 *  working directory but the rules do not allow update.  Return a
+	 *  non-zero value to abort the checkout.  All such callbacks will be
+	 *  made before any changes are made to the working directory.
 	 */
-	int (* skipped_notify_cb)(
-		const char *skipped_file,
-		const git_oid *blob_oid,
-		int file_mode,
+	int (*conflict_cb)(
+		const char *conflicting_path,
+		const git_oid *index_oid,
+		unsigned int index_mode,
+		unsigned int wd_mode,
 		void *payload);
-	void *notify_payload;
+	void *conflict_payload;
 
 	/* Optional callback to notify the consumer of checkout progress. */
-	void (* progress_cb)(
-			const char *path,
-			size_t completed_steps,
-			size_t total_steps,
-			void *payload);
+	void (*progress_cb)(
+		const char *path,
+		size_t completed_steps,
+		size_t total_steps,
+		void *payload);
 	void *progress_payload;
 
-	/** When not NULL, array of fnmatch patterns specifying
-	 * which paths should be taken into account
+	/** When not zeroed out, array of fnmatch patterns specifying which
+	 *  paths should be taken into account, otherwise all files.
 	 */
-	git_strarray paths; 
+	git_strarray paths;
 } git_checkout_opts;
 
 /**

include/git2/errors.h

@@ -60,6 +60,7 @@ typedef enum {
 	GITERR_SUBMODULE,
 	GITERR_THREAD,
 	GITERR_STASH,
+	GITERR_CHECKOUT,
 } git_error_t;
 
 /**

src/fileops.c

@@ -351,6 +351,7 @@ int git_futils_mkdir_r(const char *path, const char *base, const mode_t mode)
 }
 
 typedef struct {
+	const char *base;
 	uint32_t flags;
 	int error;
 } futils__rmdir_data;
@@ -366,11 +367,52 @@ static int futils__error_cannot_rmdir(const char *path, const char *filemsg)
 	return -1;
 }
 
+static int futils__rm_first_parent(git_buf *path, const char *ceiling)
+{
+	int error = GIT_ENOTFOUND;
+	struct stat st;
+
+	while (error == GIT_ENOTFOUND) {
+		git_buf_rtruncate_at_char(path, '/');
+
+		if (!path->size || git__prefixcmp(path->ptr, ceiling) != 0)
+			error = 0;
+		else if (p_lstat(path->ptr, &st) == 0) {
+			if (S_ISREG(st.st_mode) || S_ISLNK(st.st_mode))
+				error = p_unlink(path->ptr);
+			else if (!S_ISDIR(st.st_mode))
+				error = -1; /* fail to remove non-regular file */
+		} else if (errno != ENOTDIR)
+			error = -1;
+	}
+
+	if (error)
+		futils__error_cannot_rmdir(path->ptr, "cannot remove parent");
+
+	return error;
+}
+
 static int futils__rmdir_recurs_foreach(void *opaque, git_buf *path)
 {
+	struct stat st;
 	futils__rmdir_data *data = opaque;
 
-	if (git_path_isdir(path->ptr) == true) {
+	if ((data->error = p_lstat(path->ptr, &st)) < 0) {
+		if (errno == ENOENT)
+			data->error = 0;
+		else if (errno == ENOTDIR) {
+			/* asked to remove a/b/c/d/e and a/b is a normal file */
+			if ((data->flags & GIT_RMDIR_REMOVE_BLOCKERS) != 0)
+				data->error = futils__rm_first_parent(path, data->base);
+			else
+				futils__error_cannot_rmdir(
+					path->ptr, "parent is not directory");
+		}
+		else
+			futils__error_cannot_rmdir(path->ptr, "cannot access");
+	}
+
+	else if (S_ISDIR(st.st_mode)) {
 		int error = git_path_direach(path, futils__rmdir_recurs_foreach, data);
 		if (error < 0)
 			return (error == GIT_EUSER) ? data->error : error;
@@ -393,9 +435,8 @@ static int futils__rmdir_recurs_foreach(void *opaque, git_buf *path)
 			futils__error_cannot_rmdir(path->ptr, "cannot be removed");
 	}
 
-	else if ((data->flags & GIT_RMDIR_SKIP_NONEMPTY) == 0) {
+	else if ((data->flags & GIT_RMDIR_SKIP_NONEMPTY) == 0)
 		data->error = futils__error_cannot_rmdir(path->ptr, "still present");
-	}
 
 	return data->error;
 }
@@ -434,6 +475,7 @@ int git_futils_rmdir_r(
 	if (git_path_join_unrooted(&fullpath, path, base, NULL) < 0)
 		return -1;
 
+	data.base  = base ? base : "";
 	data.flags = flags;
 	data.error = 0;
 

src/fileops.h

@@ -109,6 +109,7 @@ extern int git_futils_mkpath2file(const char *path, const mode_t mode);
  * * GIT_RMDIR_SKIP_NONEMPTY   - skip non-empty directories with no error.
  * * GIT_RMDIR_EMPTY_PARENTS   - remove containing directories up to base
  *       if removing this item leaves them empty
+ * * GIT_RMDIR_REMOVE_BLOCKERS - remove blocking file that causes ENOTDIR
  *
  * The old values translate into the new as follows:
  *
@@ -121,6 +122,7 @@ typedef enum {
 	GIT_RMDIR_REMOVE_FILES    = (1 << 0),
 	GIT_RMDIR_SKIP_NONEMPTY   = (1 << 1),
 	GIT_RMDIR_EMPTY_PARENTS   = (1 << 2),
+	GIT_RMDIR_REMOVE_BLOCKERS = (1 << 3),
 } git_futils_rmdir_flags;
 
 /**

src/index.c

@@ -13,6 +13,8 @@
 #include "tree.h"
 #include "tree-cache.h"
 #include "hash.h"
+#include "iterator.h"
+#include "pathspec.h"
 #include "git2/odb.h"
 #include "git2/oid.h"
 #include "git2/blob.h"
@@ -1590,3 +1592,54 @@ git_repository *git_index_owner(const git_index *index)
 {
 	return INDEX_OWNER(index);
 }
+
+int git_index_read_tree_match(
+	git_index *index, git_tree *tree, git_strarray *strspec)
+{
+#if 0
+	git_iterator *iter = NULL;
+	const git_index_entry *entry;
+	char *pfx = NULL;
+	git_vector pathspec = GIT_VECTOR_INIT;
+	git_pool pathpool = GIT_POOL_INIT_STRINGPOOL;
+#endif
+
+	if (!git_pathspec_is_interesting(strspec))
+		return git_index_read_tree(index, tree);
+
+	return git_index_read_tree(index, tree);
+
+#if 0
+	/* The following loads the matches into the index, but doesn't
+	 * erase obsoleted entries (e.g. you load a blob at "a/b" which
+	 * should obsolete a blob at "a/b/c/d" since b is no longer a tree)
+	 */
+
+	if (git_pathspec_init(&pathspec, strspec, &pathpool) < 0)
+		return -1;
+
+	pfx = git_pathspec_prefix(strspec);
+
+	if ((error = git_iterator_for_tree_range(
+			 &iter, INDEX_OWNER(index), tree, pfx, pfx)) < 0 ||
+		(error = git_iterator_current(iter, &entry)) < 0)
+		goto cleanup;
+
+	while (entry != NULL) {
+		if (git_pathspec_match_path(&pathspec, entry->path, false, false) &&
+			(error = git_index_add(index, entry)) < 0)
+			goto cleanup;
+
+		if ((error = git_iterator_advance(iter, &entry)) < 0)
+			goto cleanup;
+	}
+
+cleanup:
+	git_iterator_free(iter);
+	git_pathspec_free(&pathspec);
+	git_pool_clear(&pathpool);
+	git__free(pfx);
+
+	return error;
+#endif
+}

src/index.h

@@ -48,4 +48,7 @@ extern unsigned int git_index__prefix_position(git_index *index, const char *pat
 extern int git_index_entry__cmp(const void *a, const void *b);
 extern int git_index_entry__cmp_icase(const void *a, const void *b);
 
+extern int git_index_read_tree_match(
+	git_index *index, git_tree *tree, git_strarray *strspec);
+
 #endif

src/path.c

@@ -382,9 +382,10 @@ int git_path_walk_up(
 	iter.asize = path->asize;
 
 	while (scan >= stop) {
-		if ((error = cb(data, &iter)) < 0)
-			break;
+		error = cb(data, &iter);
 		iter.ptr[scan] = oldc;
+		if (error < 0)
+			break;
 		scan = git_buf_rfind_next(&iter, '/');
 		if (scan >= 0) {
 			scan++;

src/reset.c

@@ -137,10 +137,7 @@ int git_reset(
 	}
 
 	memset(&opts, 0, sizeof(opts));
-	opts.checkout_strategy =
-		GIT_CHECKOUT_CREATE_MISSING
-		| GIT_CHECKOUT_OVERWRITE_MODIFIED
-		| GIT_CHECKOUT_REMOVE_UNTRACKED;
+	opts.checkout_strategy = GIT_CHECKOUT_FORCE;
 
 	if (git_checkout_index(repo, &opts) < 0) {
 		giterr_set(GITERR_INDEX, "%s - Failed to checkout the index.", ERROR_MSG);

src/stash.c

@@ -501,8 +501,8 @@ static int reset_index_and_workdir(
 
 	memset(&opts, 0, sizeof(git_checkout_opts));
 
-	opts.checkout_strategy = 
-		GIT_CHECKOUT_CREATE_MISSING | GIT_CHECKOUT_OVERWRITE_MODIFIED;
+	opts.checkout_strategy =
+		GIT_CHECKOUT_UPDATE_MODIFIED | GIT_CHECKOUT_UPDATE_UNTRACKED;
 
 	if (remove_untracked)
 		opts.checkout_strategy |= GIT_CHECKOUT_REMOVE_UNTRACKED;

tests-clar/checkout/index.c

@@ -26,7 +26,7 @@ void test_checkout_index__initialize(void)
 	git_tree *tree;
 
 	memset(&g_opts, 0, sizeof(g_opts));
-	g_opts.checkout_strategy = GIT_CHECKOUT_CREATE_MISSING;
+	g_opts.checkout_strategy = GIT_CHECKOUT_SAFE;
 
 	g_repo = cl_git_sandbox_init("testrepo");
 
@@ -78,7 +78,6 @@ void test_checkout_index__can_create_missing_files(void)
 	cl_assert_equal_i(false, git_path_isfile("./testrepo/branch_file.txt"));
 	cl_assert_equal_i(false, git_path_isfile("./testrepo/new.txt"));
 
-	g_opts.checkout_strategy = GIT_CHECKOUT_CREATE_MISSING;
 	cl_git_pass(git_checkout_index(g_repo, &g_opts));
 
 	test_file_contents("./testrepo/README", "hey there\n");
@@ -94,7 +93,7 @@ void test_checkout_index__can_remove_untracked_files(void)
 
 	cl_assert_equal_i(true, git_path_isdir("./testrepo/dir/subdir/subsubdir"));
 
-	g_opts.checkout_strategy = GIT_CHECKOUT_REMOVE_UNTRACKED;
+	g_opts.checkout_strategy |= GIT_CHECKOUT_REMOVE_UNTRACKED;
 	cl_git_pass(git_checkout_index(g_repo, &g_opts));
 
 	cl_assert_equal_i(false, git_path_isdir("./testrepo/dir"));
@@ -203,7 +202,11 @@ void test_checkout_index__donot_overwrite_modified_file_by_default(void)
 {
 	cl_git_mkfile("./testrepo/new.txt", "This isn't what's stored!");
 
-	g_opts.checkout_strategy = 0;
+	/* set this up to not return an error code on conflicts, but it
+	 * still will not have permission to overwrite anything...
+	 */
+	g_opts.checkout_strategy = GIT_CHECKOUT_ALLOW_CONFLICTS;
+
 	cl_git_pass(git_checkout_index(g_repo, &g_opts));
 
 	test_file_contents("./testrepo/new.txt", "This isn't what's stored!");
@@ -213,7 +216,8 @@ void test_checkout_index__can_overwrite_modified_file(void)
 {
 	cl_git_mkfile("./testrepo/new.txt", "This isn't what's stored!");
 
-	g_opts.checkout_strategy = GIT_CHECKOUT_OVERWRITE_MODIFIED;
+	g_opts.checkout_strategy |= GIT_CHECKOUT_UPDATE_MODIFIED;
+
 	cl_git_pass(git_checkout_index(g_repo, &g_opts));
 
 	test_file_contents("./testrepo/new.txt", "my new file\n");
@@ -282,28 +286,30 @@ void test_checkout_index__options_open_flags(void)
 
 	g_opts.file_open_flags = O_CREAT | O_RDWR | O_APPEND;
 
-	g_opts.checkout_strategy |= GIT_CHECKOUT_OVERWRITE_MODIFIED;
+	g_opts.checkout_strategy |= GIT_CHECKOUT_UPDATE_MODIFIED;
 	cl_git_pass(git_checkout_index(g_repo, &g_opts));
 
 	test_file_contents("./testrepo/new.txt", "hi\nmy new file\n");
 }
 
-struct notify_data {
+struct conflict_data {
 	const char *file;
 	const char *sha;
 };
 
-static int notify_cb(
-	const char *skipped_file,
+static int conflict_cb(
+	const char *conflict_file,
 	const git_oid *blob_oid,
-	int file_mode,
+	unsigned int index_mode,
+	unsigned int wd_mode,
 	void *payload)
 {
-	struct notify_data *expectations = (struct notify_data *)payload;
+	struct conflict_data *expectations = (struct conflict_data *)payload;
 
-	GIT_UNUSED(file_mode);
+	GIT_UNUSED(index_mode);
+	GIT_UNUSED(wd_mode);
 
-	cl_assert_equal_s(expectations->file, skipped_file);
+	cl_assert_equal_s(expectations->file, conflict_file);
 	cl_assert_equal_i(0, git_oid_streq(blob_oid, expectations->sha));
 
 	return 0;
@@ -311,7 +317,7 @@ static int notify_cb(
 
 void test_checkout_index__can_notify_of_skipped_files(void)
 {
-	struct notify_data data;
+	struct conflict_data data;
 
 	cl_git_mkfile("./testrepo/new.txt", "This isn't what's stored!");
 
@@ -324,22 +330,24 @@ void test_checkout_index__can_notify_of_skipped_files(void)
 	data.file = "new.txt";
 	data.sha = "a71586c1dfe8a71c6cbf6c129f404c5642ff31bd";
 
-	g_opts.checkout_strategy = GIT_CHECKOUT_CREATE_MISSING;
-	g_opts.skipped_notify_cb = notify_cb;
-	g_opts.notify_payload = &data;
+	g_opts.checkout_strategy |= GIT_CHECKOUT_ALLOW_CONFLICTS;
+	g_opts.conflict_cb = conflict_cb;
+	g_opts.conflict_payload = &data;
 
 	cl_git_pass(git_checkout_index(g_repo, &g_opts));
 }
 
-static int dont_notify_cb(
-	const char *skipped_file,
+static int dont_conflict_cb(
+	const char *conflict_file,
 	const git_oid *blob_oid,
-	int file_mode,
+	unsigned int index_mode,
+	unsigned int wd_mode,
 	void *payload)
 {
-	GIT_UNUSED(skipped_file);
+	GIT_UNUSED(conflict_file);
 	GIT_UNUSED(blob_oid);
-	GIT_UNUSED(file_mode);
+	GIT_UNUSED(index_mode);
+	GIT_UNUSED(wd_mode);
 	GIT_UNUSED(payload);
 
 	cl_assert(false);
@@ -354,9 +362,9 @@ void test_checkout_index__wont_notify_of_expected_line_ending_changes(void)
 
 	cl_git_mkfile("./testrepo/new.txt", "my new file\r\n");
 
-	g_opts.checkout_strategy = GIT_CHECKOUT_CREATE_MISSING;
-	g_opts.skipped_notify_cb = dont_notify_cb;
-	g_opts.notify_payload = NULL;
+	g_opts.checkout_strategy |= GIT_CHECKOUT_ALLOW_CONFLICTS;
+	g_opts.conflict_cb = dont_conflict_cb;
+	g_opts.conflict_payload = NULL;
 
 	cl_git_pass(git_checkout_index(g_repo, &g_opts));
 }
@@ -389,8 +397,9 @@ void test_checkout_index__can_overcome_name_clashes(void)
 	cl_git_pass(p_mkdir("./testrepo/path1", 0777));
 	cl_git_mkfile("./testrepo/path1/file1", "content\r\n");
 
-	cl_git_pass(git_index_add(index, "path0", 0));
-	cl_git_pass(git_index_add(index, "path1/file1", 0));
+	cl_git_pass(git_index_add_from_workdir(index, "path0"));
+	cl_git_pass(git_index_add_from_workdir(index, "path1/file1"));
+
 
 	cl_git_pass(p_unlink("./testrepo/path0"));
 	cl_git_pass(git_futils_rmdir_r(
@@ -400,11 +409,20 @@ void test_checkout_index__can_overcome_name_clashes(void)
 	cl_git_pass(p_mkdir("./testrepo/path0", 0777));
 	cl_git_mkfile("./testrepo/path0/file0", "content\r\n");
 
-	g_opts.checkout_strategy = GIT_CHECKOUT_CREATE_MISSING;
+	cl_assert(git_path_isfile("./testrepo/path1"));
+	cl_assert(git_path_isfile("./testrepo/path0/file0"));
+
+	g_opts.checkout_strategy = GIT_CHECKOUT_SAFE | GIT_CHECKOUT_ALLOW_CONFLICTS;
 	cl_git_pass(git_checkout_index(g_repo, &g_opts));
 
 	cl_assert(git_path_isfile("./testrepo/path1"));
 	cl_assert(git_path_isfile("./testrepo/path0/file0"));
 
+	g_opts.checkout_strategy = GIT_CHECKOUT_FORCE;
+	cl_git_pass(git_checkout_index(g_repo, &g_opts));
+
+	cl_assert(git_path_isfile("./testrepo/path0"));
+	cl_assert(git_path_isfile("./testrepo/path1/file1"));
+
 	git_index_free(index);
 }

tests-clar/checkout/tree.c

@@ -12,7 +12,7 @@ void test_checkout_tree__initialize(void)
 	g_repo = cl_git_sandbox_init("testrepo");
 
 	memset(&g_opts, 0, sizeof(g_opts));
-	g_opts.checkout_strategy = GIT_CHECKOUT_CREATE_MISSING;
+	g_opts.checkout_strategy = GIT_CHECKOUT_SAFE;
 }
 
 void test_checkout_tree__cleanup(void)
@@ -74,10 +74,13 @@ static void progress(const char *path, size_t cur, size_t tot, void *payload)
 void test_checkout_tree__calls_progress_callback(void)
 {
 	bool was_called = 0;
+
 	g_opts.progress_cb = progress;
 	g_opts.progress_payload = &was_called;
 
 	cl_git_pass(git_revparse_single(&g_object, g_repo, "master"));
+
 	cl_git_pass(git_checkout_tree(g_repo, g_object, &g_opts));
+
 	cl_assert_equal_i(was_called, true);
 }

tests-clar/checkout/typechange.c

@@ -40,10 +40,12 @@ void test_checkout_typechange__checkout_typechanges(void)
 	git_object *obj;
 	git_checkout_opts opts = {0};
 
-	opts.checkout_strategy =
-		GIT_CHECKOUT_REMOVE_UNTRACKED |
-		GIT_CHECKOUT_CREATE_MISSING |
-		GIT_CHECKOUT_OVERWRITE_MODIFIED;
+	opts.checkout_strategy = GIT_CHECKOUT_FORCE;
+
+	/* if you don't include GIT_CHECKOUT_REMOVE_UNTRACKED then on the final
+	 * checkout which is supposed to remove all the files, we will not
+	 * actually remove them!
+	 */
 
 	for (i = 0; g_typechange_oids[i] != NULL; ++i) {
 		cl_git_pass(git_revparse_single(&obj, g_repo, g_typechange_oids[i]));
@@ -51,6 +53,9 @@ void test_checkout_typechange__checkout_typechanges(void)
 
 		cl_git_pass(git_checkout_tree(g_repo, obj, &opts));
 
+		cl_git_pass(
+			git_repository_set_head_detached(g_repo, git_object_id(obj)));
+
 		git_object_free(obj);
 
 		if (!g_typechange_empty[i]) {

tests-clar/clone/network.c

@@ -113,7 +113,7 @@ void test_clone_network__can_checkout_a_cloned_repo(void)
 	bool checkout_progress_cb_was_called = false,
 		  fetch_progress_cb_was_called = false;
 
-	opts.checkout_strategy = GIT_CHECKOUT_CREATE_MISSING;
+	opts.checkout_strategy = GIT_CHECKOUT_UPDATE_UNMODIFIED;
 	opts.progress_cb = &checkout_progress;
 	opts.progress_payload = &checkout_progress_cb_was_called;