Skip to content

G
git2
Commit 411cb017 by Russell Belfer
Options

Merge pull request #887 from nulltoken/topic/reset-hard 

Checkout, reset and others enhancements
parents e8776d30 39783719
Showing with 770 additions and 312 deletions
include/git2/checkout.h
......@@ -21,21 +21,30 @@
*/
GIT_BEGIN_DECL
#define GIT_CHECKOUT_OVERWRITE_EXISTING 0 /* default */
#define GIT_CHECKOUT_SKIP_EXISTING 1
enum {
GIT_CHECKOUT_DEFAULT = (1 << 0),
GIT_CHECKOUT_OVERWRITE_MODIFIED = (1 << 1),
GIT_CHECKOUT_CREATE_MISSING = (1 << 2),
GIT_CHECKOUT_REMOVE_UNTRACKED = (1 << 3),
};
/* Use zeros to indicate default settings */
typedef struct git_checkout_opts {
int existing_file_action; /* default: GIT_CHECKOUT_OVERWRITE_EXISTING */
unsigned int checkout_strategy; /* default: GIT_CHECKOUT_DEFAULT */
int disable_filters;
int dir_mode; /* default is 0755 */
int file_mode; /* default is 0644 */
int file_open_flags; /* default is O_CREAT | O_TRUNC | O_WRONLY */
/* when not NULL, arrays of fnmatch pattern specifying
* which paths should be taken into account
*/
git_strarray paths;
} git_checkout_opts;
/**
* Updates files in the working tree to match the commit pointed to by HEAD.
* Updates files in the index and the working tree to match the content of the
* commit pointed at by HEAD.
*
* @param repo repository to check out (must be non-bare)
* @param opts specifies checkout options (may be NULL)
......@@ -49,19 +58,36 @@ GIT_EXTERN(int) git_checkout_head(
git_indexer_stats *stats);
/**
* Updates files in the working tree to match a commit pointed to by a ref.
* Updates files in the working tree to match the content of the index.
*
* @param ref reference to follow to a commit
* @param repo repository to check out (must be non-bare)
* @param opts specifies checkout options (may be NULL)
* @param stats structure through which progress information is reported
* @return 0 on success, GIT_ERROR otherwise (use giterr_last for information
* about the error)
*/
GIT_EXTERN(int) git_checkout_reference(
git_reference *ref,
GIT_EXTERN(int) git_checkout_index(
git_repository *repo,
git_checkout_opts *opts,
git_indexer_stats *stats);
/**
* Updates files in the index and working tree to match the content of the
* tree pointed at by the treeish.
*
* @param repo repository to check out (must be non-bare)
* @param treeish a commit, tag or tree which content will be used to update
* the working directory
* @param opts specifies checkout options (may be NULL)
* @param stats structure through which progress information is reported
* @return 0 on success, GIT_ERROR otherwise (use giterr_last for information
* about the error)
*/
GIT_EXTERN(int) git_checkout_tree(
git_repository *repo,
git_object *treeish,
git_checkout_opts *opts,
git_indexer_stats *stats);
/** @} */
GIT_END_DECL
......
include/git2/repository.h
......@@ -456,7 +456,7 @@ GIT_EXTERN(int) git_repository_index(git_index **out, git_repository *repo);
GIT_EXTERN(void) git_repository_set_index(git_repository *repo, git_index *index);
/**
* Retrive git's prepared message
* Retrieve git's prepared message
*
* Operations such as git revert/cherry-pick/merge with the -n option
* stop just short of creating a commit with the changes and save
......@@ -506,6 +506,67 @@ GIT_EXTERN(int) git_repository_hashfile(
git_otype type,
const char *as_path);
/**
* Make the repository HEAD point to the specified reference.
*
* If the provided reference points to a Tree or a Blob, the HEAD is
* unaltered and -1 is returned.
*
* If the provided reference points to a branch, the HEAD will point
* to that branch, staying attached, or become attached if it isn't yet.
* If the branch doesn't exist yet, no error will be return. The HEAD
* will then be attached to an unborn branch.
*
* Otherwise, the HEAD will be detached and will directly point to
* the Commit.
*
* @param repo Repository pointer
* @param refname Canonical name of the reference the HEAD should point at
* @return 0 on success, or an error code
*/
GIT_EXTERN(int) git_repository_set_head(
git_repository* repo,
const char* refname);
/**
* Make the repository HEAD directly point to the Commit.
*
* If the provided committish cannot be found in the repository, the HEAD
* is unaltered and GIT_ENOTFOUND is returned.
*
* If the provided commitish cannot be peeled into a commit, the HEAD
* is unaltered and -1 is returned.
*
* Otherwise, the HEAD will eventually be detached and will directly point to
* the peeled Commit.
*
* @param repo Repository pointer
* @param commitish Object id of the Commit the HEAD should point to
* @return 0 on success, or an error code
*/
GIT_EXTERN(int) git_repository_set_head_detached(
git_repository* repo,
const git_oid* commitish);
/**
* Detach the HEAD.
*
* If the HEAD is already detached and points to a Commit, 0 is returned.
*
* If the HEAD is already detached and points to a Tag, the HEAD is
* updated into making it point to the peeled Commit, and 0 is returned.
*
* If the HEAD is already detached and points to a non commitish, the HEAD is
* unaletered, and -1 is returned.
*
* Otherwise, the HEAD will be detached and point to the peeled Commit.
*
* @param repo Repository pointer
* @return 0 on success, or an error code
*/
GIT_EXTERN(int) git_repository_detach_head(
git_repository* repo);
/** @} */
GIT_END_DECL
#endif
include/git2/reset.h
......@@ -24,6 +24,9 @@ GIT_BEGIN_DECL
* Specifying a Mixed kind of reset will trigger a Soft reset and the index will
* be replaced with the content of the commit tree.
*
* Specifying a Hard kind of reset will trigger a Mixed reset and the working
* directory will be replaced with the content of the index.
*
* TODO: Implement remaining kinds of resets.
*
* @param repo Repository where to perform the reset operation.
......
include/git2/types.h
......@@ -173,6 +173,7 @@ typedef enum {
typedef enum {
GIT_RESET_SOFT = 1,
GIT_RESET_MIXED = 2,
GIT_RESET_HARD = 3,
} git_reset_type;
/** Valid modes for index and tree entries. */
......
src/clone.c
......@@ -235,9 +235,8 @@ int git_clone(git_repository **out,
assert(out && origin_url && workdir_path);
if (!(retcode = clone_internal(out, origin_url, workdir_path, fetch_stats, 0))) {
if (!(retcode = clone_internal(out, origin_url, workdir_path, fetch_stats, 0)))
retcode = git_checkout_head(*out, checkout_opts, checkout_stats);
}
return retcode;
}
src/filter.c
......@@ -164,38 +164,3 @@ int git_filters_apply(git_buf *dest, git_buf *source, git_vector *filters)
return 0;
}
static int unfiltered_blob_contents(git_buf *out, git_repository *repo, const git_oid *blob_id)
{
int retcode = GIT_ERROR;
git_blob *blob;
if (!(retcode = git_blob_lookup(&blob, repo, blob_id)))
{
retcode = git_blob__getbuf(out, blob);
git_blob_free(blob);
}
return retcode;
}
int git_filter_blob_contents(git_buf *out, git_repository *repo, const git_oid *oid, const char *path)
{
int retcode = GIT_ERROR;
git_buf unfiltered = GIT_BUF_INIT;
if (!unfiltered_blob_contents(&unfiltered, repo, oid)) {
git_vector filters = GIT_VECTOR_INIT;
if (git_filters_load(&filters,
repo, path, GIT_FILTER_TO_WORKTREE) >= 0) {
git_buf_clear(out);
retcode = git_filters_apply(out, &unfiltered, &filters);
}
git_filters_free(&filters);
}
git_buf_free(&unfiltered);
return retcode;
}
src/filter.h
......@@ -119,16 +119,4 @@ extern void git_text_gather_stats(git_text_stats *stats, const git_buf *text);
*/
extern int git_text_is_binary(git_text_stats *stats);
/**
* Get the content of a blob after all filters have been run.
*
* @param out buffer to receive the contents
* @param repo repository containing the blob
* @param oid object id for the blob
* @param path path to the blob's output file, relative to the workdir root
* @return 0 on success, an error code otherwise
*/
extern int git_filter_blob_contents(git_buf *out, git_repository *repo, const git_oid *oid, const char *path);
#endif
src/repository.c
......@@ -1442,3 +1442,85 @@ cleanup:
return error;
}
static bool looks_like_a_branch(const char *refname)
{
return git__prefixcmp(refname, GIT_REFS_HEADS_DIR) == 0;
}
int git_repository_set_head(
git_repository* repo,
const char* refname)
{
git_reference *ref,
*new_head = NULL;
int error;
assert(repo && refname);
error = git_reference_lookup(&ref, repo, refname);
if (error < 0 && error != GIT_ENOTFOUND)
return error;
if (!error) {
if (git_reference_is_branch(ref))
error = git_reference_create_symbolic(&new_head, repo, GIT_HEAD_FILE, git_reference_name(ref), 1);
else
error = git_repository_set_head_detached(repo, git_reference_oid(ref));
} else if (looks_like_a_branch(refname))
error = git_reference_create_symbolic(&new_head, repo, GIT_HEAD_FILE, refname, 1);
git_reference_free(ref);
git_reference_free(new_head);
return error;
}
int git_repository_set_head_detached(
git_repository* repo,
const git_oid* commitish)
{
int error;
git_object *object,
*peeled = NULL;
git_reference *new_head = NULL;
assert(repo && commitish);
if ((error = git_object_lookup(&object, repo, commitish, GIT_OBJ_ANY)) < 0)
return error;
if ((error = git_object_peel(&peeled, object, GIT_OBJ_COMMIT)) < 0)
goto cleanup;
error = git_reference_create_oid(&new_head, repo, GIT_HEAD_FILE, git_object_id(peeled), 1);
cleanup:
git_object_free(object);
git_object_free(peeled);
git_reference_free(new_head);
return error;
}
int git_repository_detach_head(
git_repository* repo)
{
git_reference *old_head = NULL,
*new_head = NULL;
git_object *object = NULL;
int error = -1;
assert(repo);
if (git_repository_head(&old_head, repo) < 0)
return -1;
if (git_object_lookup(&object, repo, git_reference_oid(old_head), GIT_OBJ_COMMIT) < 0)
goto cleanup;
error = git_reference_create_oid(&new_head, repo, GIT_HEAD_FILE, git_reference_oid(old_head), 1);
cleanup:
git_object_free(object);
git_reference_free(old_head);
git_reference_free(new_head);
return error;
}
src/reset.c
......@@ -9,6 +9,7 @@
#include "commit.h"
#include "tag.h"
#include "git2/reset.h"
#include "git2/checkout.h"
#define ERROR_MSG "Cannot perform reset"
......@@ -27,9 +28,12 @@ int git_reset(
git_index *index = NULL;
git_tree *tree = NULL;
int error = -1;
git_checkout_opts opts;
assert(repo && target);
assert(reset_type == GIT_RESET_SOFT || reset_type == GIT_RESET_MIXED);
assert(reset_type == GIT_RESET_SOFT
|| reset_type == GIT_RESET_MIXED
|| reset_type == GIT_RESET_HARD);
if (git_object_owner(target) != repo)
return reset_error_invalid("The given target does not belong to this repository.");
......@@ -73,6 +77,22 @@ int git_reset(
goto cleanup;
}
if (reset_type == GIT_RESET_MIXED) {
error = 0;
goto cleanup;
}
memset(&opts, 0, sizeof(opts));
opts.checkout_strategy =
GIT_CHECKOUT_CREATE_MISSING
| GIT_CHECKOUT_OVERWRITE_MODIFIED
| GIT_CHECKOUT_REMOVE_UNTRACKED;
if (git_checkout_index(repo, &opts, NULL) < 0) {
giterr_set(GITERR_INDEX, "%s - Failed to checkout the index.", ERROR_MSG);
goto cleanup;
}
error = 0;
cleanup:
......
tests-clar/checkout/checkout.c deleted 100644 → 0
#include "clar_libgit2.h"
#include "git2/checkout.h"
#include "repository.h"
static git_repository *g_repo;
void test_checkout_checkout__initialize(void)
{
const char *attributes = "* text eol=lf\n";
g_repo = cl_git_sandbox_init("testrepo");
cl_git_mkfile("./testrepo/.gitattributes", attributes);
}
void test_checkout_checkout__cleanup(void)
{
cl_git_sandbox_cleanup();
}
static void test_file_contents(const char *path, const char *expectedcontents)
{
int fd;
char buffer[1024] = {0};
size_t expectedlen, actuallen;
fd = p_open(path, O_RDONLY);
cl_assert(fd >= 0);
expectedlen = strlen(expectedcontents);
actuallen = p_read(fd, buffer, 1024);
cl_git_pass(p_close(fd));
cl_assert_equal_sz(actuallen, expectedlen);
cl_assert_equal_s(buffer, expectedcontents);
}
void test_checkout_checkout__bare(void)
{
cl_git_sandbox_cleanup();
g_repo = cl_git_sandbox_init("testrepo.git");
cl_git_fail(git_checkout_head(g_repo, NULL, NULL));
}
void test_checkout_checkout__default(void)
{
cl_git_pass(git_checkout_head(g_repo, NULL, NULL));
test_file_contents("./testrepo/README", "hey there\n");
test_file_contents("./testrepo/branch_file.txt", "hi\nbye!\n");
test_file_contents("./testrepo/new.txt", "my new file\n");
}
void test_checkout_checkout__crlf(void)
{
const char *attributes =
"branch_file.txt text eol=crlf\n"
"new.txt text eol=lf\n";
git_config *cfg;
cl_git_pass(git_repository_config__weakptr(&cfg, g_repo));
cl_git_pass(git_config_set_bool(cfg, "core.autocrlf", false));
cl_git_mkfile("./testrepo/.gitattributes", attributes);
cl_git_pass(git_checkout_head(g_repo, NULL, NULL));
test_file_contents("./testrepo/README", "hey there\n");
test_file_contents("./testrepo/new.txt", "my new file\n");
test_file_contents("./testrepo/branch_file.txt", "hi\r\nbye!\r\n");
}
void test_checkout_checkout__win32_autocrlf(void)
{
#ifdef GIT_WIN32
git_config *cfg;
const char *expected_readme_text = "hey there\r\n";
cl_must_pass(p_unlink("./testrepo/.gitattributes"));
cl_git_pass(git_repository_config__weakptr(&cfg, g_repo));
cl_git_pass(git_config_set_bool(cfg, "core.autocrlf", true));
cl_git_pass(git_checkout_head(g_repo, NULL, NULL));
test_file_contents("./testrepo/README", expected_readme_text);
#endif
}
static void enable_symlinks(bool enable)
{
git_config *cfg;
cl_git_pass(git_repository_config(&cfg, g_repo));
cl_git_pass(git_config_set_bool(cfg, "core.symlinks", enable));
git_config_free(cfg);
}
void test_checkout_checkout__symlinks(void)
{
/* First try with symlinks forced on */
enable_symlinks(true);
cl_git_pass(git_checkout_head(g_repo, NULL, NULL));
#ifdef GIT_WIN32
test_file_contents("./testrepo/link_to_new.txt", "new.txt");
#else
{
char link_data[1024];
size_t link_size = 1024;
link_size = p_readlink("./testrepo/link_to_new.txt", link_data, link_size);
link_data[link_size] = '\0';
cl_assert_equal_i(link_size, strlen("new.txt"));
cl_assert_equal_s(link_data, "new.txt");
test_file_contents("./testrepo/link_to_new.txt", "my new file\n");
}
#endif
/* Now with symlinks forced off */
cl_git_sandbox_cleanup();
g_repo = cl_git_sandbox_init("testrepo");
enable_symlinks(false);
cl_git_pass(git_checkout_head(g_repo, NULL, NULL));
test_file_contents("./testrepo/link_to_new.txt", "new.txt");
}
void test_checkout_checkout__existing_file_skip(void)
{
git_checkout_opts opts = {0};
cl_git_mkfile("./testrepo/new.txt", "This isn't what's stored!");
opts.existing_file_action = GIT_CHECKOUT_SKIP_EXISTING;
cl_git_pass(git_checkout_head(g_repo, &opts, NULL));
test_file_contents("./testrepo/new.txt", "This isn't what's stored!");
}
void test_checkout_checkout__existing_file_overwrite(void)
{
git_checkout_opts opts = {0};
cl_git_mkfile("./testrepo/new.txt", "This isn't what's stored!");
opts.existing_file_action = GIT_CHECKOUT_OVERWRITE_EXISTING;
cl_git_pass(git_checkout_head(g_repo, &opts, NULL));
test_file_contents("./testrepo/new.txt", "my new file\n");
}
void test_checkout_checkout__disable_filters(void)
{
git_checkout_opts opts = {0};
cl_git_mkfile("./testrepo/.gitattributes", "*.txt text eol=crlf\n");
/* TODO cl_git_pass(git_checkout_head(g_repo, &opts, NULL));*/
/* TODO test_file_contents("./testrepo/new.txt", "my new file\r\n");*/
opts.disable_filters = true;
cl_git_pass(git_checkout_head(g_repo, &opts, NULL));
test_file_contents("./testrepo/new.txt", "my new file\n");
}
void test_checkout_checkout__dir_modes(void)
{
#ifndef GIT_WIN32
git_checkout_opts opts = {0};
struct stat st;
git_reference *ref;
cl_git_pass(git_reference_lookup(&ref, g_repo, "refs/heads/dir"));
opts.dir_mode = 0701;
cl_git_pass(git_checkout_reference(ref, &opts, NULL));
cl_git_pass(p_stat("./testrepo/a", &st));
cl_assert_equal_i(st.st_mode & 0777, 0701);
/* File-mode test, since we're on the 'dir' branch */
cl_git_pass(p_stat("./testrepo/a/b.txt", &st));
cl_assert_equal_i(st.st_mode & 0777, 0755);
git_reference_free(ref);
#endif
}
void test_checkout_checkout__override_file_modes(void)
{
#ifndef GIT_WIN32
git_checkout_opts opts = {0};
struct stat st;
opts.file_mode = 0700;
cl_git_pass(git_checkout_head(g_repo, &opts, NULL));
cl_git_pass(p_stat("./testrepo/new.txt", &st));
cl_assert_equal_i(st.st_mode & 0777, 0700);
#endif
}
void test_checkout_checkout__open_flags(void)
{
git_checkout_opts opts = {0};
cl_git_mkfile("./testrepo/new.txt", "hi\n");
opts.file_open_flags = O_CREAT | O_RDWR | O_APPEND;
cl_git_pass(git_checkout_head(g_repo, &opts, NULL));
test_file_contents("./testrepo/new.txt", "hi\nmy new file\n");
}
void test_checkout_checkout__detached_head(void)
{
/* TODO: write this when git_checkout_commit is implemented. */
}
tests-clar/checkout/index.c 0 → 100644
#include "clar_libgit2.h"
#include "git2/checkout.h"
#include "repository.h"
static git_repository *g_repo;
static git_checkout_opts g_opts;
static void reset_index_to_treeish(git_object *treeish)
{
git_object *tree;
git_index *index;
cl_git_pass(git_object_peel(&tree, treeish, GIT_OBJ_TREE));
cl_git_pass(git_repository_index(&index, g_repo));
cl_git_pass(git_index_read_tree(index, (git_tree *)tree, NULL));
cl_git_pass(git_index_write(index));
git_object_free(tree);
git_index_free(index);
}
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_repo = cl_git_sandbox_init("testrepo");
cl_git_pass(git_repository_head_tree(&tree, g_repo));
reset_index_to_treeish((git_object *)tree);
git_tree_free(tree);
cl_git_rewritefile(
"./testrepo/.gitattributes",
"* text eol=lf\n");
}
void test_checkout_index__cleanup(void)
{
cl_git_sandbox_cleanup();
}
static void test_file_contents(const char *path, const char *expectedcontents)
{
int fd;
char buffer[1024] = {0};
size_t expectedlen, actuallen;
fd = p_open(path, O_RDONLY);
cl_assert(fd >= 0);
expectedlen = strlen(expectedcontents);
actuallen = p_read(fd, buffer, 1024);
cl_git_pass(p_close(fd));
cl_assert_equal_sz(actuallen, expectedlen);
cl_assert_equal_s(buffer, expectedcontents);
}
void test_checkout_index__cannot_checkout_a_bare_repository(void)
{
test_checkout_index__cleanup();
memset(&g_opts, 0, sizeof(g_opts));
g_repo = cl_git_sandbox_init("testrepo.git");
cl_git_fail(git_checkout_index(g_repo, NULL, NULL));
}
void test_checkout_index__can_create_missing_files(void)
{
cl_assert_equal_i(false, git_path_isfile("./testrepo/README"));
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, NULL));
test_file_contents("./testrepo/README", "hey there\n");
test_file_contents("./testrepo/branch_file.txt", "hi\nbye!\n");
test_file_contents("./testrepo/new.txt", "my new file\n");
}
void test_checkout_index__can_remove_untracked_files(void)
{
git_futils_mkdir("./testrepo/dir/subdir/subsubdir", NULL, 0755, GIT_MKDIR_PATH);
cl_git_mkfile("./testrepo/dir/one", "one\n");
cl_git_mkfile("./testrepo/dir/subdir/two", "two\n");
cl_assert_equal_i(true, git_path_isdir("./testrepo/dir/subdir/subsubdir"));
g_opts.checkout_strategy = GIT_CHECKOUT_REMOVE_UNTRACKED;
cl_git_pass(git_checkout_index(g_repo, &g_opts, NULL));
cl_assert_equal_i(false, git_path_isdir("./testrepo/dir"));
}
void test_checkout_index__honor_the_specified_pathspecs(void)
{
char *entries[] = { "*.txt" };
g_opts.paths.strings = entries;
g_opts.paths.count = 1;
cl_assert_equal_i(false, git_path_isfile("./testrepo/README"));
cl_assert_equal_i(false, git_path_isfile("./testrepo/branch_file.txt"));
cl_assert_equal_i(false, git_path_isfile("./testrepo/new.txt"));
cl_git_pass(git_checkout_index(g_repo, &g_opts, NULL));
cl_assert_equal_i(false, git_path_isfile("./testrepo/README"));
test_file_contents("./testrepo/branch_file.txt", "hi\nbye!\n");
test_file_contents("./testrepo/new.txt", "my new file\n");
}
static void set_config_entry_to(const char *entry_name, bool value)
{
git_config *cfg;
cl_git_pass(git_repository_config(&cfg, g_repo));
cl_git_pass(git_config_set_bool(cfg, entry_name, value));
git_config_free(cfg);
}
static void set_core_autocrlf_to(bool value)
{
set_config_entry_to("core.autocrlf", value);
}
void test_checkout_index__honor_the_gitattributes_directives(void)
{
const char *attributes =
"branch_file.txt text eol=crlf\n"
"new.txt text eol=lf\n";
cl_git_mkfile("./testrepo/.gitattributes", attributes);
set_core_autocrlf_to(false);
cl_git_pass(git_checkout_index(g_repo, &g_opts, NULL));
test_file_contents("./testrepo/README", "hey there\n");
test_file_contents("./testrepo/new.txt", "my new file\n");
test_file_contents("./testrepo/branch_file.txt", "hi\r\nbye!\r\n");
}
void test_checkout_index__honor_coreautocrlf_setting_set_to_true(void)
{
#ifdef GIT_WIN32
const char *expected_readme_text = "hey there\r\n";
cl_git_pass(p_unlink("./testrepo/.gitattributes"));
set_core_autocrlf_to(true);
cl_git_pass(git_checkout_index(g_repo, &g_opts, NULL));
test_file_contents("./testrepo/README", expected_readme_text);
#endif
}
static void set_repo_symlink_handling_cap_to(bool value)
{
set_config_entry_to("core.symlinks", value);
}
void test_checkout_index__honor_coresymlinks_setting_set_to_true(void)
{
set_repo_symlink_handling_cap_to(true);
cl_git_pass(git_checkout_index(g_repo, &g_opts, NULL));
#ifdef GIT_WIN32
test_file_contents("./testrepo/link_to_new.txt", "new.txt");
#else
{
char link_data[1024];
size_t link_size = 1024;
link_size = p_readlink("./testrepo/link_to_new.txt", link_data, link_size);
link_data[link_size] = '\0';
cl_assert_equal_i(link_size, strlen("new.txt"));
cl_assert_equal_s(link_data, "new.txt");
test_file_contents("./testrepo/link_to_new.txt", "my new file\n");
}
#endif
}
void test_checkout_index__honor_coresymlinks_setting_set_to_false(void)
{
set_repo_symlink_handling_cap_to(false);
cl_git_pass(git_checkout_index(g_repo, &g_opts, NULL));
test_file_contents("./testrepo/link_to_new.txt", "new.txt");
}
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;
cl_git_pass(git_checkout_index(g_repo, &g_opts, NULL));
test_file_contents("./testrepo/new.txt", "This isn't what's stored!");
}
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;
cl_git_pass(git_checkout_index(g_repo, &g_opts, NULL));
test_file_contents("./testrepo/new.txt", "my new file\n");
}
void test_checkout_index__options_disable_filters(void)
{
cl_git_mkfile("./testrepo/.gitattributes", "*.txt text eol=crlf\n");
g_opts.disable_filters = false;
cl_git_pass(git_checkout_index(g_repo, &g_opts, NULL));
test_file_contents("./testrepo/new.txt", "my new file\r\n");
p_unlink("./testrepo/new.txt");
g_opts.disable_filters = true;
cl_git_pass(git_checkout_index(g_repo, &g_opts, NULL));
test_file_contents("./testrepo/new.txt", "my new file\n");
}
void test_checkout_index__options_dir_modes(void)
{
#ifndef GIT_WIN32
struct stat st;
git_oid oid;
git_commit *commit;
cl_git_pass(git_reference_name_to_oid(&oid, g_repo, "refs/heads/dir"));
cl_git_pass(git_commit_lookup(&commit, g_repo, &oid));
reset_index_to_treeish((git_object *)commit);
g_opts.dir_mode = 0701;
cl_git_pass(git_checkout_index(g_repo, &g_opts, NULL));
cl_git_pass(p_stat("./testrepo/a", &st));
cl_assert_equal_i(st.st_mode & 0777, 0701);
/* File-mode test, since we're on the 'dir' branch */
cl_git_pass(p_stat("./testrepo/a/b.txt", &st));
cl_assert_equal_i(st.st_mode & 0777, 0755);
git_commit_free(commit);
#endif
}
void test_checkout_index__options_override_file_modes(void)
{
#ifndef GIT_WIN32
struct stat st;
g_opts.file_mode = 0700;
cl_git_pass(git_checkout_index(g_repo, &g_opts, NULL));
cl_git_pass(p_stat("./testrepo/new.txt", &st));
cl_assert_equal_i(st.st_mode & 0777, 0700);
#endif
}
void test_checkout_index__options_open_flags(void)
{
cl_git_mkfile("./testrepo/new.txt", "hi\n");
g_opts.file_open_flags = O_CREAT | O_RDWR | O_APPEND;
g_opts.checkout_strategy |= GIT_CHECKOUT_OVERWRITE_MODIFIED;
cl_git_pass(git_checkout_index(g_repo, &g_opts, NULL));
test_file_contents("./testrepo/new.txt", "hi\nmy new file\n");
}
tests-clar/checkout/tree.c 0 → 100644
#include "clar_libgit2.h"
#include "git2/checkout.h"
#include "repository.h"
static git_repository *g_repo;
static git_checkout_opts g_opts;
static git_object *g_object;
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;
}
void test_checkout_tree__cleanup(void)
{
git_object_free(g_object);
cl_git_sandbox_cleanup();
}
void test_checkout_tree__cannot_checkout_a_non_treeish(void)
{
/* blob */
cl_git_pass(git_revparse_single(&g_object, g_repo, "a71586c1dfe8a71c6cbf6c129f404c5642ff31bd"));
cl_git_fail(git_checkout_tree(g_repo, g_object, NULL, NULL));
}
void test_checkout_tree__can_checkout_a_subdirectory_from_a_commit(void)
{
char *entries[] = { "ab/de/" };
g_opts.paths.strings = entries;
g_opts.paths.count = 1;
cl_git_pass(git_revparse_single(&g_object, g_repo, "subtrees"));
cl_assert_equal_i(false, git_path_isdir("./testrepo/ab/"));
cl_git_pass(git_checkout_tree(g_repo, g_object, &g_opts, NULL));
cl_assert_equal_i(true, git_path_isfile("./testrepo/ab/de/2.txt"));
cl_assert_equal_i(true, git_path_isfile("./testrepo/ab/de/fgh/1.txt"));
}
void test_checkout_tree__can_checkout_a_subdirectory_from_a_subtree(void)
{
char *entries[] = { "de/" };
g_opts.paths.strings = entries;
g_opts.paths.count = 1;
cl_git_pass(git_revparse_single(&g_object, g_repo, "subtrees:ab"));
cl_assert_equal_i(false, git_path_isdir("./testrepo/de/"));
cl_git_pass(git_checkout_tree(g_repo, g_object, &g_opts, NULL));
cl_assert_equal_i(true, git_path_isfile("./testrepo/de/2.txt"));
cl_assert_equal_i(true, git_path_isfile("./testrepo/de/fgh/1.txt"));
}
tests-clar/repo/getters.c
......@@ -23,52 +23,6 @@ void test_repo_getters__empty(void)
git_repository_free(repo_empty);
}
void test_repo_getters__head_detached(void)
{
git_repository *repo;
git_reference *ref;
git_oid oid;
cl_git_pass(git_repository_open(&repo, "testrepo.git"));
cl_assert(git_repository_head_detached(repo) == 0);
/* detach the HEAD */
git_oid_fromstr(&oid, "c47800c7266a2be04c571c04d5a6614691ea99bd");
cl_git_pass(git_reference_create_oid(&ref, repo, "HEAD", &oid, 1));
cl_assert(git_repository_head_detached(repo) == 1);
git_reference_free(ref);
/* take the reop back to it's original state */
cl_git_pass(git_reference_create_symbolic(&ref, repo, "HEAD", "refs/heads/master", 1));
cl_assert(git_repository_head_detached(repo) == 0);
git_reference_free(ref);
git_repository_free(repo);
}
void test_repo_getters__head_orphan(void)
{
git_repository *repo;
git_reference *ref;
cl_git_pass(git_repository_open(&repo, "testrepo.git"));
cl_assert(git_repository_head_orphan(repo) == 0);
/* orphan HEAD */
cl_git_pass(git_reference_create_symbolic(&ref, repo, "HEAD", "refs/heads/orphan", 1));
cl_assert(git_repository_head_orphan(repo) == 1);
git_reference_free(ref);
/* take the reop back to it's original state */
cl_git_pass(git_reference_create_symbolic(&ref, repo, "HEAD", "refs/heads/master", 1));
cl_assert(git_repository_head_orphan(repo) == 0);
git_reference_free(ref);
git_repository_free(repo);
}
void test_repo_getters__retrieving_the_odb_honors_the_refcount(void)
{
git_odb *odb;
......
tests-clar/repo/head.c 0 → 100644
#include "clar_libgit2.h"
#include "refs.h"
git_repository *repo;
void test_repo_head__initialize(void)
{
repo = cl_git_sandbox_init("testrepo.git");
}
void test_repo_head__cleanup(void)
{
cl_git_sandbox_cleanup();
}
void test_repo_head__head_detached(void)
{
git_reference *ref;
git_oid oid;
cl_assert(git_repository_head_detached(repo) == 0);
/* detach the HEAD */
git_oid_fromstr(&oid, "c47800c7266a2be04c571c04d5a6614691ea99bd");
cl_git_pass(git_reference_create_oid(&ref, repo, "HEAD", &oid, 1));
cl_assert(git_repository_head_detached(repo) == 1);
git_reference_free(ref);
/* take the reop back to it's original state */
cl_git_pass(git_reference_create_symbolic(&ref, repo, "HEAD", "refs/heads/master", 1));
cl_assert(git_repository_head_detached(repo) == 0);
git_reference_free(ref);
}
void test_repo_head__head_orphan(void)
{
git_reference *ref;
cl_assert(git_repository_head_orphan(repo) == 0);
/* orphan HEAD */
cl_git_pass(git_reference_create_symbolic(&ref, repo, "HEAD", "refs/heads/orphan", 1));
cl_assert(git_repository_head_orphan(repo) == 1);
git_reference_free(ref);
/* take the reop back to it's original state */
cl_git_pass(git_reference_create_symbolic(&ref, repo, "HEAD", "refs/heads/master", 1));
cl_assert(git_repository_head_orphan(repo) == 0);
git_reference_free(ref);
}
void test_repo_head__set_head_Attaches_HEAD_to_un_unborn_branch_when_the_branch_doesnt_exist(void)
{
git_reference *head;
cl_git_pass(git_repository_set_head(repo, "refs/heads/doesnt/exist/yet"));
cl_assert_equal_i(false, git_repository_head_detached(repo));
cl_assert_equal_i(GIT_ENOTFOUND, git_repository_head(&head, repo));
}
void test_repo_head__set_head_Returns_ENOTFOUND_when_the_reference_doesnt_exist(void)
{
cl_assert_equal_i(GIT_ENOTFOUND, git_repository_set_head(repo, "refs/tags/doesnt/exist/yet"));
}
void test_repo_head__set_head_Fails_when_the_reference_points_to_a_non_commitish(void)
{
cl_git_fail(git_repository_set_head(repo, "refs/tags/point_to_blob"));
}
void test_repo_head__set_head_Attaches_HEAD_when_the_reference_points_to_a_branch(void)
{
git_reference *head;
cl_git_pass(git_repository_set_head(repo, "refs/heads/br2"));
cl_assert_equal_i(false, git_repository_head_detached(repo));
cl_git_pass(git_repository_head(&head, repo));
cl_assert_equal_s("refs/heads/br2", git_reference_name(head));
git_reference_free(head);
}
static void assert_head_is_correctly_detached(void)
{
git_reference *head;
git_object *commit;
cl_assert_equal_i(true, git_repository_head_detached(repo));
cl_git_pass(git_repository_head(&head, repo));
cl_git_pass(git_object_lookup(&commit, repo, git_reference_oid(head), GIT_OBJ_COMMIT));
git_object_free(commit);
git_reference_free(head);
}
void test_repo_head__set_head_Detaches_HEAD_when_the_reference_doesnt_point_to_a_branch(void)
{
cl_git_pass(git_repository_set_head(repo, "refs/tags/test"));
cl_assert_equal_i(true, git_repository_head_detached(repo));
assert_head_is_correctly_detached();
}
void test_repo_head__set_head_detached_Return_ENOTFOUND_when_the_object_doesnt_exist(void)
{
git_oid oid;
cl_git_pass(git_oid_fromstr(&oid, "deadbeefdeadbeefdeadbeefdeadbeefdeadbeef"));
cl_assert_equal_i(GIT_ENOTFOUND, git_repository_set_head_detached(repo, &oid));
}
void test_repo_head__set_head_detached_Fails_when_the_object_isnt_a_commitish(void)
{
git_object *blob;
cl_git_pass(git_revparse_single(&blob, repo, "point_to_blob"));
cl_git_fail(git_repository_set_head_detached(repo, git_object_id(blob)));
git_object_free(blob);
}
void test_repo_head__set_head_detached_Detaches_HEAD_and_make_it_point_to_the_peeled_commit(void)
{
git_object *tag;
cl_git_pass(git_revparse_single(&tag, repo, "tags/test"));
cl_assert_equal_i(GIT_OBJ_TAG, git_object_type(tag));
cl_git_pass(git_repository_set_head_detached(repo, git_object_id(tag)));
assert_head_is_correctly_detached();
git_object_free(tag);
}
void test_repo_head__detach_head_Detaches_HEAD_and_make_it_point_to_the_peeled_commit(void)
{
cl_assert_equal_i(false, git_repository_head_detached(repo));
cl_git_pass(git_repository_detach_head(repo));
assert_head_is_correctly_detached();
}
void test_repo_head__detach_head_Fails_if_HEAD_and_point_to_a_non_commitish(void)
{
git_reference *head;
cl_git_pass(git_reference_create_symbolic(&head, repo, GIT_HEAD_FILE, "refs/tags/point_to_blob", 1));
cl_git_fail(git_repository_detach_head(repo));
git_reference_free(head);
}
tests-clar/reset/hard.c 0 → 100644
#include "clar_libgit2.h"
#include "posix.h"
#include "reset_helpers.h"
#include "path.h"
#include "fileops.h"
static git_repository *repo;
static git_object *target;
void test_reset_hard__initialize(void)
{
repo = cl_git_sandbox_init("status");
target = NULL;
}
void test_reset_hard__cleanup(void)
{
git_object_free(target);
cl_git_sandbox_cleanup();
}
void test_reset_hard__resetting_culls_empty_directories(void)
{
git_buf subdir_path = GIT_BUF_INIT;
git_buf subfile_path = GIT_BUF_INIT;
git_buf newdir_path = GIT_BUF_INIT;
cl_git_pass(git_buf_joinpath(&newdir_path, git_repository_workdir(repo), "newdir/"));
cl_git_pass(git_buf_joinpath(&subfile_path, git_buf_cstr(&newdir_path), "with/nested/file.txt"));
cl_git_pass(git_futils_mkpath2file(git_buf_cstr(&subfile_path), 0755));
cl_git_mkfile(git_buf_cstr(&subfile_path), "all anew...\n");
cl_git_pass(git_buf_joinpath(&subdir_path, git_repository_workdir(repo), "subdir/"));
cl_assert(git_path_isdir(git_buf_cstr(&subdir_path)) == true);
retrieve_target_from_oid(&target, repo, "0017bd4ab1ec30440b17bae1680cff124ab5f1f6");
cl_git_pass(git_reset(repo, target, GIT_RESET_HARD));
cl_assert(git_path_isdir(git_buf_cstr(&subdir_path)) == false);
cl_assert(git_path_isdir(git_buf_cstr(&newdir_path)) == false);
git_buf_free(&subdir_path);
git_buf_free(&subfile_path);
git_buf_free(&newdir_path);
}
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment