diff options
| author | Yuang Li <yuangli88@hotmail.com> | 2022-06-24 13:21:48 +0100 |
|---|---|---|
| committer | Yuang Li <yuangli88@hotmail.com> | 2022-06-24 13:21:48 +0100 |
| commit | e07aa9c3c4f5d0462662e2c7fc1ae8120a29d740 (patch) | |
| tree | da61eddd173c43d09a6545f75b35360f0a48f68b /tests | |
| parent | 79af067665c37b6dc0b31edb35596c362b0cd9a0 (diff) | |
| parent | b7bad55e4bb0a285b073ba5e02b01d3f522fc95d (diff) | |
| download | libgit2-e07aa9c3c4f5d0462662e2c7fc1ae8120a29d740.tar.gz | |
Merge branch 'main' into pr/pks-t/5254
Diffstat (limited to 'tests')
148 files changed, 5179 insertions, 1018 deletions
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt index 6f8a18ec0..49999f481 100644 --- a/tests/CMakeLists.txt +++ b/tests/CMakeLists.txt @@ -1,3 +1,4 @@ +SET(Python_ADDITIONAL_VERSIONS 3 2.7) FIND_PACKAGE(PythonInterp) IF(NOT PYTHONINTERP_FOUND) @@ -9,6 +10,7 @@ SET(CLAR_FIXTURES "${CMAKE_CURRENT_SOURCE_DIR}/resources/") SET(CLAR_PATH "${CMAKE_CURRENT_SOURCE_DIR}") ADD_DEFINITIONS(-DCLAR_FIXTURE_PATH=\"${CLAR_FIXTURES}\") ADD_DEFINITIONS(-DCLAR_TMPDIR=\"libgit2_tests\") +ADD_DEFINITIONS(-DCLAR_WIN32_LONGPATHS) ADD_DEFINITIONS(-D_FILE_OFFSET_BITS=64) # Ensure that we do not use deprecated functions internally @@ -62,7 +64,8 @@ ENDFUNCTION(ADD_CLAR_TEST) ADD_CLAR_TEST(offline -v -xonline) ADD_CLAR_TEST(invasive -v -score::ftruncate -sfilter::stream::bigfile -sodb::largefiles -siterator::workdir::filesystem_gunk -srepo::init -srepo::init::at_filesystem_root) -ADD_CLAR_TEST(online -v -sonline) +ADD_CLAR_TEST(online -v -sonline -xonline::customcert) +ADD_CLAR_TEST(online_customcert -v -sonline::customcert) ADD_CLAR_TEST(gitdaemon -v -sonline::push) ADD_CLAR_TEST(ssh -v -sonline::push -sonline::clone::ssh_cert -sonline::clone::ssh_with_paths -sonline::clone::path_whitespace_ssh) ADD_CLAR_TEST(proxy -v -sonline::clone::proxy) diff --git a/tests/apply/apply_helpers.h b/tests/apply/apply_helpers.h index 2d0019abf..82094773e 100644 --- a/tests/apply/apply_helpers.h +++ b/tests/apply/apply_helpers.h @@ -474,6 +474,15 @@ "-asparagus which had been laid by, boil it until these last articles are\n" \ "-sufficiently done, thicken with flour, butter and milk, and serve it up.\n" +#define DIFF_ADD_INVALID_FILENAME \ + "diff --git a/.git/hello_world.txt b/.git/hello_world.txt\n" \ + "new file mode 100644\n" \ + "index 0000000..f75ba05\n" \ + "--- /dev/null\n" \ + "+++ b/.git/hello_world.txt\n" \ + "@@ -0,0 +1 @@\n" \ + "+Hello, world.\n" + void validate_apply_workdir( git_repository *repo, struct merge_index_entry *workdir_entries, diff --git a/tests/apply/both.c b/tests/apply/both.c index 400df5e38..108963270 100644 --- a/tests/apply/both.c +++ b/tests/apply/both.c @@ -734,3 +734,14 @@ void test_apply_both__cant_remove_file_twice(void) git_diff_free(diff); } + +void test_apply_both__cant_add_invalid_filename(void) +{ + git_diff *diff; + + cl_git_pass(git_diff_from_buffer(&diff, DIFF_ADD_INVALID_FILENAME, + strlen(DIFF_ADD_INVALID_FILENAME))); + cl_git_fail(git_apply(repo, diff, GIT_APPLY_LOCATION_BOTH, NULL)); + + git_diff_free(diff); +} diff --git a/tests/apply/fromdiff.c b/tests/apply/fromdiff.c index e9329f6d3..69dfe0987 100644 --- a/tests/apply/fromdiff.c +++ b/tests/apply/fromdiff.c @@ -3,7 +3,6 @@ #include "apply.h" #include "repository.h" -#include "buf_text.h" #include "../patch/patch_common.h" diff --git a/tests/apply/fromfile.c b/tests/apply/fromfile.c index 477e283ad..ae519eab0 100644 --- a/tests/apply/fromfile.c +++ b/tests/apply/fromfile.c @@ -5,7 +5,6 @@ #include "patch.h" #include "patch_parse.h" #include "repository.h" -#include "buf_text.h" #include "../patch/patch_common.h" diff --git a/tests/apply/partial.c b/tests/apply/partial.c index 466a92717..548faaadb 100644 --- a/tests/apply/partial.c +++ b/tests/apply/partial.c @@ -3,7 +3,6 @@ #include "apply.h" #include "repository.h" -#include "buf_text.h" #include "../patch/patch_common.h" diff --git a/tests/attr/lookup.c b/tests/attr/lookup.c index 6063468cb..f19f38fbb 100644 --- a/tests/attr/lookup.c +++ b/tests/attr/lookup.c @@ -236,6 +236,7 @@ void test_attr_lookup__check_attr_examples(void) void test_attr_lookup__from_buffer(void) { git_attr_file *file; + git_attr_file_source source = {0}; struct attr_expected cases[] = { { "abc", "foo", EXPECT_TRUE, NULL }, @@ -250,7 +251,7 @@ void test_attr_lookup__from_buffer(void) { NULL, NULL, 0, NULL } }; - cl_git_pass(git_attr_file__new(&file, NULL, 0)); + cl_git_pass(git_attr_file__new(&file, NULL, &source)); cl_git_pass(git_attr_file__parse_buffer(NULL, file, "a* foo\nabc bar\n* baz", true)); diff --git a/tests/attr/repo.c b/tests/attr/repo.c index 36beeb095..eabc033eb 100644 --- a/tests/attr/repo.c +++ b/tests/attr/repo.c @@ -71,11 +71,11 @@ void test_attr_repo__get_one(void) } cl_assert(git_attr_cache__is_cached( - g_repo, GIT_ATTR_FILE__FROM_FILE, ".git/info/attributes")); + g_repo, GIT_ATTR_FILE_SOURCE_FILE, ".git/info/attributes")); cl_assert(git_attr_cache__is_cached( - g_repo, GIT_ATTR_FILE__FROM_FILE, ".gitattributes")); + g_repo, GIT_ATTR_FILE_SOURCE_FILE, ".gitattributes")); cl_assert(git_attr_cache__is_cached( - g_repo, GIT_ATTR_FILE__FROM_FILE, "sub/.gitattributes")); + g_repo, GIT_ATTR_FILE_SOURCE_FILE, "sub/.gitattributes")); } void test_attr_repo__get_one_start_deep(void) @@ -92,11 +92,11 @@ void test_attr_repo__get_one_start_deep(void) } cl_assert(git_attr_cache__is_cached( - g_repo, GIT_ATTR_FILE__FROM_FILE, ".git/info/attributes")); + g_repo, GIT_ATTR_FILE_SOURCE_FILE, ".git/info/attributes")); cl_assert(git_attr_cache__is_cached( - g_repo, GIT_ATTR_FILE__FROM_FILE, ".gitattributes")); + g_repo, GIT_ATTR_FILE_SOURCE_FILE, ".gitattributes")); cl_assert(git_attr_cache__is_cached( - g_repo, GIT_ATTR_FILE__FROM_FILE, "sub/.gitattributes")); + g_repo, GIT_ATTR_FILE_SOURCE_FILE, "sub/.gitattributes")); } void test_attr_repo__get_many(void) @@ -341,7 +341,7 @@ void test_attr_repo__sysdir_with_session(void) g_repo = cl_git_sandbox_reopen(); cl_git_pass(git_attr_session__init(&session, g_repo)); - cl_git_pass(git_attr_get_many_with_session(values, g_repo, &session, 0, "file", ARRAY_SIZE(attrs), attrs)); + cl_git_pass(git_attr_get_many_with_session(values, g_repo, &session, NULL, "file", ARRAY_SIZE(attrs), attrs)); cl_assert_equal_s(values[0], "1"); cl_assert_equal_s(values[1], "2"); diff --git a/tests/checkout/tree.c b/tests/checkout/tree.c index 380d25101..3241a3eb7 100644 --- a/tests/checkout/tree.c +++ b/tests/checkout/tree.c @@ -917,7 +917,7 @@ void test_checkout_tree__extremely_long_file_name(void) { /* A utf-8 string with 83 characters, but 249 bytes. */ const char *longname = "\xe5\x8f\x97\xe5\x8f\x97\xe5\x8f\x97\xe5\x8f\x97\xe5\x8f\x97\xe5\x8f\x97\xe5\x8f\x97\xe5\x8f\x97\xe5\x8f\x97\xe5\x8f\x97\xe5\x8f\x97\xe5\x8f\x97\xe5\x8f\x97\xe5\x8f\x97\xe5\x8f\x97\xe5\x8f\x97\xe5\x8f\x97\xe5\x8f\x97\xe5\x8f\x97\xe5\x8f\x97\xe5\x8f\x97\xe5\x8f\x97\xe5\x8f\x97\xe5\x8f\x97\xe5\x8f\x97\xe5\x8f\x97\xe5\x8f\x97\xe5\x8f\x97\xe5\x8f\x97\xe5\x8f\x97\xe5\x8f\x97\xe5\x8f\x97\xe5\x8f\x97\xe5\x8f\x97\xe5\x8f\x97\xe5\x8f\x97\xe5\x8f\x97\xe5\x8f\x97\xe5\x8f\x97\xe5\x8f\x97\xe5\x8f\x97\xe5\x8f\x97\xe5\x8f\x97\xe5\x8f\x97\xe5\x8f\x97\xe5\x8f\x97\xe5\x8f\x97\xe5\x8f\x97\xe5\x8f\x97\xe5\x8f\x97\xe5\x8f\x97\xe5\x8f\x97\xe5\x8f\x97\xe5\x8f\x97\xe5\x8f\x97\xe5\x8f\x97\xe5\x8f\x97\xe5\x8f\x97\xe5\x8f\x97\xe5\x8f\x97\xe5\x8f\x97\xe5\x8f\x97\xe5\x8f\x97\xe5\x8f\x97\xe5\x8f\x97\xe5\x8f\x97\xe5\x8f\x97\xe5\x8f\x97\xe5\x8f\x97\xe5\x8f\x97\xe5\x8f\x97\xe5\x8f\x97\xe5\x8f\x97\xe5\x8f\x97\xe5\x8f\x97\xe5\x8f\x97\xe5\x8f\x97\xe5\x8f\x97\xe5\x8f\x97\xe5\x8f\x97\xe5\x8f\x97\xe5\x8f\x97\xe5\x8f\x97"; - char path[1024]; + char path[1024] = {0}; g_opts.checkout_strategy = GIT_CHECKOUT_FORCE; cl_git_pass(git_revparse_single(&g_object, g_repo, "long-file-name")); @@ -1636,3 +1636,49 @@ void test_checkout_tree__no_index_refresh(void) modify_index_and_checkout_tree(&opts); assert_status_entrycount(g_repo, 0); } + +void test_checkout_tree__dry_run(void) +{ + git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT; + git_oid oid; + git_object *obj = NULL; + checkout_counts ct; + + /* first let's get things into a known state - by checkout out the HEAD */ + + assert_on_branch(g_repo, "master"); + + opts.checkout_strategy = GIT_CHECKOUT_FORCE; + cl_git_pass(git_checkout_head(g_repo, &opts)); + + cl_assert(!git_path_isdir("testrepo/a")); + + check_file_contents_nocr("testrepo/branch_file.txt", "hi\nbye!\n"); + + /* now checkout branch but with dry run enabled */ + + memset(&ct, 0, sizeof(ct)); + opts.checkout_strategy = GIT_CHECKOUT_SAFE | GIT_CHECKOUT_DRY_RUN; + opts.notify_flags = GIT_CHECKOUT_NOTIFY_ALL; + opts.notify_cb = checkout_count_callback; + opts.notify_payload = &ct; + + cl_git_pass(git_reference_name_to_id(&oid, g_repo, "refs/heads/dir")); + cl_git_pass(git_object_lookup(&obj, g_repo, &oid, GIT_OBJECT_ANY)); + + cl_git_pass(git_checkout_tree(g_repo, obj, &opts)); + cl_git_pass(git_repository_set_head(g_repo, "refs/heads/dir")); + + assert_on_branch(g_repo, "dir"); + + /* these normally would have been created and updated, but with + * DRY_RUN they will be unchanged. + */ + cl_assert(!git_path_isdir("testrepo/a")); + check_file_contents_nocr("testrepo/branch_file.txt", "hi\nbye!\n"); + + /* check that notify callback was invoked */ + cl_assert_equal_i(ct.n_updates, 2); + + git_object_free(obj); +} diff --git a/tests/clar/fs.h b/tests/clar/fs.h index 87d345132..44ede4572 100644 --- a/tests/clar/fs.h +++ b/tests/clar/fs.h @@ -8,6 +8,12 @@ #ifdef _WIN32 +#ifdef CLAR_WIN32_LONGPATHS +# define CLAR_MAX_PATH 4096 +#else +# define CLAR_MAX_PATH MAX_PATH +#endif + #define RM_RETRY_COUNT 5 #define RM_RETRY_DELAY 10 @@ -48,21 +54,48 @@ fs_rmdir_rmdir(WCHAR *_wpath) return 0; } +static void translate_path(WCHAR *path, size_t path_size) +{ + size_t path_len, i; + + if (wcsncmp(path, L"\\\\?\\", 4) == 0) + return; + + path_len = wcslen(path); + cl_assert(path_size > path_len + 4); + + for (i = path_len; i > 0; i--) { + WCHAR c = path[i - 1]; + + if (c == L'/') + path[i + 3] = L'\\'; + else + path[i + 3] = path[i - 1]; + } + + path[0] = L'\\'; + path[1] = L'\\'; + path[2] = L'?'; + path[3] = L'\\'; + path[path_len + 4] = L'\0'; +} + static void fs_rmdir_helper(WCHAR *_wsource) { - WCHAR buffer[MAX_PATH]; + WCHAR buffer[CLAR_MAX_PATH]; HANDLE find_handle; WIN32_FIND_DATAW find_data; size_t buffer_prefix_len; /* Set up the buffer and capture the length */ - wcscpy_s(buffer, MAX_PATH, _wsource); - wcscat_s(buffer, MAX_PATH, L"\\"); + wcscpy_s(buffer, CLAR_MAX_PATH, _wsource); + translate_path(buffer, CLAR_MAX_PATH); + wcscat_s(buffer, CLAR_MAX_PATH, L"\\"); buffer_prefix_len = wcslen(buffer); /* FindFirstFile needs a wildcard to match multiple items */ - wcscat_s(buffer, MAX_PATH, L"*"); + wcscat_s(buffer, CLAR_MAX_PATH, L"*"); find_handle = FindFirstFileW(buffer, &find_data); cl_assert(INVALID_HANDLE_VALUE != find_handle); @@ -72,7 +105,7 @@ fs_rmdir_helper(WCHAR *_wsource) if (fs__dotordotdot(find_data.cFileName)) continue; - wcscpy_s(buffer + buffer_prefix_len, MAX_PATH - buffer_prefix_len, find_data.cFileName); + wcscpy_s(buffer + buffer_prefix_len, CLAR_MAX_PATH - buffer_prefix_len, find_data.cFileName); if (FILE_ATTRIBUTE_DIRECTORY & find_data.dwFileAttributes) fs_rmdir_helper(buffer); @@ -123,7 +156,7 @@ fs_rm_wait(WCHAR *_wpath) static void fs_rm(const char *_source) { - WCHAR wsource[MAX_PATH]; + WCHAR wsource[CLAR_MAX_PATH]; DWORD attrs; /* The input path is UTF-8. Convert it to wide characters @@ -133,7 +166,9 @@ fs_rm(const char *_source) _source, -1, /* Indicates NULL termination */ wsource, - MAX_PATH)); + CLAR_MAX_PATH)); + + translate_path(wsource, CLAR_MAX_PATH); /* Does the item exist? If not, we have no work to do */ attrs = GetFileAttributesW(wsource); @@ -158,21 +193,23 @@ fs_rm(const char *_source) static void fs_copydir_helper(WCHAR *_wsource, WCHAR *_wdest) { - WCHAR buf_source[MAX_PATH], buf_dest[MAX_PATH]; + WCHAR buf_source[CLAR_MAX_PATH], buf_dest[CLAR_MAX_PATH]; HANDLE find_handle; WIN32_FIND_DATAW find_data; size_t buf_source_prefix_len, buf_dest_prefix_len; - wcscpy_s(buf_source, MAX_PATH, _wsource); - wcscat_s(buf_source, MAX_PATH, L"\\"); + wcscpy_s(buf_source, CLAR_MAX_PATH, _wsource); + wcscat_s(buf_source, CLAR_MAX_PATH, L"\\"); + translate_path(buf_source, CLAR_MAX_PATH); buf_source_prefix_len = wcslen(buf_source); - wcscpy_s(buf_dest, MAX_PATH, _wdest); - wcscat_s(buf_dest, MAX_PATH, L"\\"); + wcscpy_s(buf_dest, CLAR_MAX_PATH, _wdest); + wcscat_s(buf_dest, CLAR_MAX_PATH, L"\\"); + translate_path(buf_dest, CLAR_MAX_PATH); buf_dest_prefix_len = wcslen(buf_dest); /* Get an enumerator for the items in the source. */ - wcscat_s(buf_source, MAX_PATH, L"*"); + wcscat_s(buf_source, CLAR_MAX_PATH, L"*"); find_handle = FindFirstFileW(buf_source, &find_data); cl_assert(INVALID_HANDLE_VALUE != find_handle); @@ -185,8 +222,8 @@ fs_copydir_helper(WCHAR *_wsource, WCHAR *_wdest) if (fs__dotordotdot(find_data.cFileName)) continue; - wcscpy_s(buf_source + buf_source_prefix_len, MAX_PATH - buf_source_prefix_len, find_data.cFileName); - wcscpy_s(buf_dest + buf_dest_prefix_len, MAX_PATH - buf_dest_prefix_len, find_data.cFileName); + wcscpy_s(buf_source + buf_source_prefix_len, CLAR_MAX_PATH - buf_source_prefix_len, find_data.cFileName); + wcscpy_s(buf_dest + buf_dest_prefix_len, CLAR_MAX_PATH - buf_dest_prefix_len, find_data.cFileName); if (FILE_ATTRIBUTE_DIRECTORY & find_data.dwFileAttributes) fs_copydir_helper(buf_source, buf_dest); @@ -205,7 +242,7 @@ fs_copydir_helper(WCHAR *_wsource, WCHAR *_wdest) static void fs_copy(const char *_source, const char *_dest) { - WCHAR wsource[MAX_PATH], wdest[MAX_PATH]; + WCHAR wsource[CLAR_MAX_PATH], wdest[CLAR_MAX_PATH]; DWORD source_attrs, dest_attrs; HANDLE find_handle; WIN32_FIND_DATAW find_data; @@ -217,14 +254,17 @@ fs_copy(const char *_source, const char *_dest) _source, -1, wsource, - MAX_PATH)); + CLAR_MAX_PATH)); cl_assert(MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, _dest, -1, wdest, - MAX_PATH)); + CLAR_MAX_PATH)); + + translate_path(wsource, CLAR_MAX_PATH); + translate_path(wdest, CLAR_MAX_PATH); /* Check the source for existence */ source_attrs = GetFileAttributesW(wsource); @@ -238,8 +278,8 @@ fs_copy(const char *_source, const char *_dest) * Use FindFirstFile to parse the path */ find_handle = FindFirstFileW(wsource, &find_data); cl_assert(INVALID_HANDLE_VALUE != find_handle); - wcscat_s(wdest, MAX_PATH, L"\\"); - wcscat_s(wdest, MAX_PATH, find_data.cFileName); + wcscat_s(wdest, CLAR_MAX_PATH, L"\\"); + wcscat_s(wdest, CLAR_MAX_PATH, find_data.cFileName); FindClose(find_handle); /* Check the new target for existence */ @@ -273,7 +313,7 @@ cl_fs_cleanup(void) # include <sys/sendfile.h> #endif -#if defined(__APPLE__) || defined(__FreeBSD__) +#if defined(__APPLE__) # include <copyfile.h> #endif @@ -356,7 +396,7 @@ fs_copyfile_helper(const char *source, size_t source_len, const char *dest, int cl_must_pass((in = open(source, O_RDONLY))); cl_must_pass((out = open(dest, O_WRONLY|O_CREAT|O_TRUNC, dest_mode))); -#if USE_FCOPYFILE && (defined(__APPLE__) || defined(__FreeBSD__)) +#if USE_FCOPYFILE && defined(__APPLE__) ((void)(source_len)); /* unused */ cl_must_pass(fcopyfile(in, out, 0, COPYFILE_DATA)); #elif USE_SENDFILE && defined(__linux__) @@ -396,7 +436,7 @@ static void fs_copy(const char *source, const char *_dest) { char *dbuf = NULL; - const char *dest; + const char *dest = NULL; struct stat source_st, dest_st; cl_must_pass_(lstat(source, &source_st), "Failed to stat copy source"); diff --git a/tests/clar/sandbox.h b/tests/clar/sandbox.h index 2114819e4..0ba147962 100644 --- a/tests/clar/sandbox.h +++ b/tests/clar/sandbox.h @@ -2,7 +2,7 @@ #include <sys/syslimits.h> #endif -static char _clar_path[4096]; +static char _clar_path[4096 + 1]; static int is_valid_tmp_path(const char *path) @@ -39,7 +39,8 @@ find_tmp_path(char *buffer, size_t length) if (length >= PATH_MAX && realpath(env, buffer) != NULL) return 0; #endif - strncpy(buffer, env, length); + strncpy(buffer, env, length - 1); + buffer[length - 1] = '\0'; return 0; } } @@ -50,7 +51,8 @@ find_tmp_path(char *buffer, size_t length) if (length >= PATH_MAX && realpath("/tmp", buffer) != NULL) return 0; #endif - strncpy(buffer, "/tmp", length); + strncpy(buffer, "/tmp", length - 1); + buffer[length - 1] = '\0'; return 0; } @@ -65,7 +67,8 @@ find_tmp_path(char *buffer, size_t length) /* This system doesn't like us, try to use the current directory */ if (is_valid_tmp_path(".")) { - strncpy(buffer, ".", length); + strncpy(buffer, ".", length - 1); + buffer[length - 1] = '\0'; return 0; } diff --git a/tests/clar_libgit2.c b/tests/clar_libgit2.c index 65b8923f5..c4550c32a 100644 --- a/tests/clar_libgit2.c +++ b/tests/clar_libgit2.c @@ -275,7 +275,7 @@ const char* cl_git_fixture_url(const char *fixturename) const char* cl_git_path_url(const char *path) { - static char url[4096]; + static char url[4096 + 1]; const char *in_buf; git_buf path_buf = GIT_BUF_INIT; @@ -311,9 +311,10 @@ const char* cl_git_path_url(const char *path) in_buf++; } - cl_assert(url_buf.size < 4096); + cl_assert(url_buf.size < sizeof(url) - 1); - strncpy(url, git_buf_cstr(&url_buf), 4096); + strncpy(url, git_buf_cstr(&url_buf), sizeof(url) - 1); + url[sizeof(url) - 1] = '\0'; git_buf_dispose(&url_buf); git_buf_dispose(&path_buf); return url; diff --git a/tests/clar_libgit2_trace.c b/tests/clar_libgit2_trace.c index d4d8d2c37..8eb6d4e8d 100644 --- a/tests/clar_libgit2_trace.c +++ b/tests/clar_libgit2_trace.c @@ -164,7 +164,7 @@ void _cl_trace_cb__event_handler( switch (ev) { case CL_TRACE__SUITE_BEGIN: git_trace(GIT_TRACE_TRACE, "\n\n%s\n%s: Begin Suite", HR, suite_name); -#if 0 && defined(GIT_MSVC_CRTDBG) +#if 0 && defined(GIT_WIN32_LEAKCHECK) git_win32__crtdbg_stacktrace__dump( GIT_WIN32__CRTDBG_STACKTRACE__SET_MARK, suite_name); @@ -172,7 +172,7 @@ void _cl_trace_cb__event_handler( break; case CL_TRACE__SUITE_END: -#if 0 && defined(GIT_MSVC_CRTDBG) +#if 0 && defined(GIT_WIN32_LEAKCHECK) /* As an example of checkpointing, dump leaks within this suite. * This may generate false positives for things like the global * TLS error state and maybe the odb cache since they aren't diff --git a/tests/clone/empty.c b/tests/clone/empty.c index 8e59d2b8c..94847bc73 100644 --- a/tests/clone/empty.c +++ b/tests/clone/empty.c @@ -2,6 +2,7 @@ #include "git2/clone.h" #include "repository.h" +#include "repo/repo_helpers.h" static git_clone_options g_options; static git_repository *g_repo; @@ -22,6 +23,7 @@ void test_clone_empty__initialize(void) void test_clone_empty__cleanup(void) { + cl_fixture_cleanup("tmp_global_path"); cl_git_sandbox_cleanup(); } @@ -66,6 +68,21 @@ void test_clone_empty__can_clone_an_empty_local_repo_barely(void) expected_tracked_branch_name)); } +void test_clone_empty__respects_initialbranch_config(void) +{ + git_buf buf = GIT_BUF_INIT; + + create_tmp_global_config("tmp_global_path", "init.defaultbranch", "my_default_branch"); + + cl_set_cleanup(&cleanup_repository, "./empty"); + + g_options.bare = true; + cl_git_pass(git_clone(&g_repo_cloned, "./empty_bare.git", "./empty", &g_options)); + cl_git_pass(git_branch_upstream_name(&buf, g_repo_cloned, "refs/heads/my_default_branch")); + cl_assert_equal_s("refs/remotes/origin/my_default_branch", buf.ptr); + git_buf_dispose(&buf); +} + void test_clone_empty__can_clone_an_empty_local_repo(void) { cl_set_cleanup(&cleanup_repository, "./empty"); diff --git a/tests/clone/nonetwork.c b/tests/clone/nonetwork.c index 7ca49085c..ec12fee18 100644 --- a/tests/clone/nonetwork.c +++ b/tests/clone/nonetwork.c @@ -158,6 +158,8 @@ void test_clone_nonetwork__can_prevent_the_checkout_of_a_standard_repo(void) void test_clone_nonetwork__can_checkout_given_branch(void) { + git_reference *remote_head; + g_options.checkout_branch = "test"; cl_git_pass(git_clone(&g_repo, cl_git_fixture_url("testrepo.git"), "./foo", &g_options)); @@ -167,6 +169,12 @@ void test_clone_nonetwork__can_checkout_given_branch(void) cl_assert_equal_s(git_reference_name(g_ref), "refs/heads/test"); cl_assert(git_path_exists("foo/readme.txt")); + + cl_git_pass(git_reference_lookup(&remote_head, g_repo, "refs/remotes/origin/HEAD")); + cl_assert_equal_i(GIT_REFERENCE_SYMBOLIC, git_reference_type(remote_head)); + cl_assert_equal_s("refs/remotes/origin/master", git_reference_symbolic_target(remote_head)); + + git_reference_free(remote_head); } static int clone_cancel_fetch_transfer_progress_cb( diff --git a/tests/config/include.c b/tests/config/include.c index e2b0fc96c..b702d6211 100644 --- a/tests/config/include.c +++ b/tests/config/include.c @@ -178,6 +178,30 @@ void test_config_include__rewriting_include_refreshes_values(void) cl_git_pass(p_unlink("second")); } +void test_config_include__rewriting_include_twice_refreshes_values(void) +{ + cl_git_mkfile("top-level", "[include]\npath = included"); + cl_git_mkfile("included", "[foo]\nbar = first-value"); + + cl_git_pass(git_config_open_ondisk(&cfg, "top-level")); + cl_git_pass(git_config_get_string_buf(&buf, cfg, "foo.bar")); + + git_buf_clear(&buf); + cl_git_mkfile("included", "[foo]\nother = value2"); + cl_git_fail(git_config_get_string_buf(&buf, cfg, "foo.bar")); + cl_git_pass(git_config_get_string_buf(&buf, cfg, "foo.other")); + cl_assert_equal_s(buf.ptr, "value2"); + + git_buf_clear(&buf); + cl_git_mkfile("included", "[foo]\nanother = bar"); + cl_git_fail(git_config_get_string_buf(&buf, cfg, "foo.other")); + cl_git_pass(git_config_get_string_buf(&buf, cfg, "foo.another")); + cl_assert_equal_s(buf.ptr, "bar"); + + cl_git_pass(p_unlink("top-level")); + cl_git_pass(p_unlink("included")); +} + void test_config_include__included_variables_cannot_be_deleted(void) { cl_git_mkfile("top-level", "[include]\npath = included\n"); diff --git a/tests/config/read.c b/tests/config/read.c index ba97302f7..8d1bb8b0a 100644 --- a/tests/config/read.c +++ b/tests/config/read.c @@ -213,6 +213,13 @@ void test_config_read__symbol_headers(void) git_config_free(cfg); } +void test_config_read__multiline_multiple_quoted_comment_chars(void) +{ + git_config *cfg; + cl_git_pass(git_config_open_ondisk(&cfg, cl_fixture("config/config21"))); + git_config_free(cfg); +} + void test_config_read__header_in_last_line(void) { git_config *cfg; @@ -928,3 +935,79 @@ void test_config_read__nosection(void) git_buf_dispose(&buf); git_config_free(cfg); } + +enum { + MAP_TRUE = 0, + MAP_FALSE = 1, + MAP_ALWAYS = 2 +}; + +static git_configmap _test_map1[] = { + {GIT_CONFIGMAP_STRING, "always", MAP_ALWAYS}, + {GIT_CONFIGMAP_FALSE, NULL, MAP_FALSE}, + {GIT_CONFIGMAP_TRUE, NULL, MAP_TRUE}, +}; + +static git_configmap _test_map2[] = { + {GIT_CONFIGMAP_INT32, NULL, 0}, +}; + +void test_config_read__get_mapped(void) +{ + git_config *cfg; + int val; + int known_good; + + cl_set_cleanup(&clean_test_config, NULL); + cl_git_mkfile("./testconfig", "[header]\n" + " key1 = 1\n" + " key2 = true\n" + " key3\n" + " key4 = always\n" + " key5 = false\n" + " key6 = 0\n" + " key7 = never\n" + " key8 = On\n" + " key9 = off\n"); + cl_git_pass(git_config_open_ondisk(&cfg, "./testconfig")); + + /* check parsing bool and string */ + cl_git_pass(git_config_get_mapped(&val, cfg, "header.key1", _test_map1, ARRAY_SIZE(_test_map1))); + cl_assert_equal_i(val, MAP_TRUE); + cl_git_pass(git_config_get_mapped(&val, cfg, "header.key2", _test_map1, ARRAY_SIZE(_test_map1))); + cl_assert_equal_i(val, MAP_TRUE); + cl_git_pass(git_config_get_mapped(&val, cfg, "header.key3", _test_map1, ARRAY_SIZE(_test_map1))); + cl_assert_equal_i(val, MAP_TRUE); + cl_git_pass(git_config_get_mapped(&val, cfg, "header.key8", _test_map1, ARRAY_SIZE(_test_map1))); + cl_assert_equal_i(val, MAP_TRUE); + + cl_git_pass(git_config_get_mapped(&val, cfg, "header.key4", _test_map1, ARRAY_SIZE(_test_map1))); + cl_assert_equal_i(val, MAP_ALWAYS); + + cl_git_pass(git_config_get_mapped(&val, cfg, "header.key5", _test_map1, ARRAY_SIZE(_test_map1))); + cl_assert_equal_i(val, MAP_FALSE); + cl_git_pass(git_config_get_mapped(&val, cfg, "header.key6", _test_map1, ARRAY_SIZE(_test_map1))); + cl_assert_equal_i(val, MAP_FALSE); + cl_git_pass(git_config_get_mapped(&val, cfg, "header.key9", _test_map1, ARRAY_SIZE(_test_map1))); + cl_assert_equal_i(val, MAP_FALSE); + + cl_git_fail(git_config_get_mapped(&val, cfg, "header.key7", _test_map1, ARRAY_SIZE(_test_map1))); + + /* check parsing int values */ + cl_git_pass(git_config_get_mapped(&val, cfg, "header.key1", _test_map2, ARRAY_SIZE(_test_map2))); + cl_git_pass(git_config_get_int32(&known_good, cfg, "header.key1")); + cl_assert_equal_i(val, known_good); + cl_git_pass(git_config_get_mapped(&val, cfg, "header.key6", _test_map2, ARRAY_SIZE(_test_map2))); + cl_git_pass(git_config_get_int32(&known_good, cfg, "header.key6")); + cl_assert_equal_i(val, known_good); + + cl_git_fail(git_config_get_mapped(&val, cfg, "header.key2", _test_map2, ARRAY_SIZE(_test_map2))); + cl_git_fail(git_config_get_mapped(&val, cfg, "header.key3", _test_map2, ARRAY_SIZE(_test_map2))); + cl_git_fail(git_config_get_mapped(&val, cfg, "header.key4", _test_map2, ARRAY_SIZE(_test_map2))); + cl_git_fail(git_config_get_mapped(&val, cfg, "header.key5", _test_map2, ARRAY_SIZE(_test_map2))); + cl_git_fail(git_config_get_mapped(&val, cfg, "header.key7", _test_map2, ARRAY_SIZE(_test_map2))); + cl_git_fail(git_config_get_mapped(&val, cfg, "header.key8", _test_map2, ARRAY_SIZE(_test_map2))); + cl_git_fail(git_config_get_mapped(&val, cfg, "header.key9", _test_map2, ARRAY_SIZE(_test_map2))); + + git_config_free(cfg); +} diff --git a/tests/config/stress.c b/tests/config/stress.c index 28c3c4ac0..577452e8d 100644 --- a/tests/config/stress.c +++ b/tests/config/stress.c @@ -59,6 +59,11 @@ void test_config_stress__comments(void) assert_config_value(config, "some.section.multi", "hi, this is a ; multiline comment # with ;\n special chars and other stuff !@#"); assert_config_value(config, "some.section.multi2", "good, this is a ; multiline comment # with ;\n special chars and other stuff !@#"); assert_config_value(config, "some.section.back", "this is \ba phrase"); + assert_config_value(config, "some.section.dollar", "some $sign"); + assert_config_value(config, "some.section.multiquotes", "!ls x ls # comment2 $HOME"); + assert_config_value(config, "some.section.multiquotes2", "!ls x ls \"# comment2 $HOME\""); + assert_config_value(config, "some.section.multiquotes3", "hi # ho there are # more quotes"); + assert_config_value(config, "some.section.quotecomment", "hi # ho there are # more"); git_config_free(config); } diff --git a/tests/core/buffer.c b/tests/core/buffer.c index 4e895afd9..2af4a8712 100644 --- a/tests/core/buffer.c +++ b/tests/core/buffer.c @@ -1,6 +1,5 @@ #include "clar_libgit2.h" #include "buffer.h" -#include "buf_text.h" #include "git2/sys/hashsig.h" #include "futils.h" @@ -633,7 +632,6 @@ void test_core_buffer__join3(void) void test_core_buffer__11(void) { git_buf a = GIT_BUF_INIT; - git_strarray t; char *t1[] = { "nothing", "in", "common" }; char *t2[] = { "something", "something else", "some other" }; char *t3[] = { "something", "some fun", "no fun" }; @@ -642,39 +640,25 @@ void test_core_buffer__11(void) char *t6[] = { "no", "nope", "" }; char *t7[] = { "", "doesn't matter" }; - t.strings = t1; - t.count = 3; - cl_git_pass(git_buf_text_common_prefix(&a, &t)); + cl_git_pass(git_buf_common_prefix(&a, t1, 3)); cl_assert_equal_s(a.ptr, ""); - t.strings = t2; - t.count = 3; - cl_git_pass(git_buf_text_common_prefix(&a, &t)); + cl_git_pass(git_buf_common_prefix(&a, t2, 3)); cl_assert_equal_s(a.ptr, "some"); - t.strings = t3; - t.count = 3; - cl_git_pass(git_buf_text_common_prefix(&a, &t)); + cl_git_pass(git_buf_common_prefix(&a, t3, 3)); cl_assert_equal_s(a.ptr, ""); - t.strings = t4; - t.count = 3; - cl_git_pass(git_buf_text_common_prefix(&a, &t)); + cl_git_pass(git_buf_common_prefix(&a, t4, 3)); cl_assert_equal_s(a.ptr, "happ"); - t.strings = t5; - t.count = 3; - cl_git_pass(git_buf_text_common_prefix(&a, &t)); + cl_git_pass(git_buf_common_prefix(&a, t5, 3)); cl_assert_equal_s(a.ptr, "happ"); - t.strings = t6; - t.count = 3; - cl_git_pass(git_buf_text_common_prefix(&a, &t)); + cl_git_pass(git_buf_common_prefix(&a, t6, 3)); cl_assert_equal_s(a.ptr, ""); - t.strings = t7; - t.count = 3; - cl_git_pass(git_buf_text_common_prefix(&a, &t)); + cl_git_pass(git_buf_common_prefix(&a, t7, 3)); cl_assert_equal_s(a.ptr, ""); git_buf_dispose(&a); @@ -709,19 +693,19 @@ void test_core_buffer__puts_escaped(void) git_buf a = GIT_BUF_INIT; git_buf_clear(&a); - cl_git_pass(git_buf_text_puts_escaped(&a, "this is a test", "", "")); + cl_git_pass(git_buf_puts_escaped(&a, "this is a test", "", "")); cl_assert_equal_s("this is a test", a.ptr); git_buf_clear(&a); - cl_git_pass(git_buf_text_puts_escaped(&a, "this is a test", "t", "\\")); + cl_git_pass(git_buf_puts_escaped(&a, "this is a test", "t", "\\")); cl_assert_equal_s("\\this is a \\tes\\t", a.ptr); git_buf_clear(&a); - cl_git_pass(git_buf_text_puts_escaped(&a, "this is a test", "i ", "__")); + cl_git_pass(git_buf_puts_escaped(&a, "this is a test", "i ", "__")); cl_assert_equal_s("th__is__ __is__ a__ test", a.ptr); git_buf_clear(&a); - cl_git_pass(git_buf_text_puts_escape_regex(&a, "^match\\s*[A-Z]+.*")); + cl_git_pass(git_buf_puts_escape_regex(&a, "^match\\s*[A-Z]+.*")); cl_assert_equal_s("\\^match\\\\s\\*\\[A-Z\\]\\+\\.\\*", a.ptr); git_buf_dispose(&a); @@ -731,7 +715,7 @@ static void assert_unescape(char *expected, char *to_unescape) { git_buf buf = GIT_BUF_INIT; cl_git_pass(git_buf_sets(&buf, to_unescape)); - git_buf_text_unescape(&buf); + git_buf_unescape(&buf); cl_assert_equal_s(expected, buf.ptr); cl_assert_equal_sz(strlen(expected), buf.size); @@ -864,20 +848,20 @@ void test_core_buffer__classify_with_utf8(void) git_buf b; b.ptr = data0; b.size = b.asize = data0len; - cl_assert(!git_buf_text_is_binary(&b)); - cl_assert(!git_buf_text_contains_nul(&b)); + cl_assert(!git_buf_is_binary(&b)); + cl_assert(!git_buf_contains_nul(&b)); b.ptr = data1; b.size = b.asize = data1len; - cl_assert(!git_buf_text_is_binary(&b)); - cl_assert(!git_buf_text_contains_nul(&b)); + cl_assert(!git_buf_is_binary(&b)); + cl_assert(!git_buf_contains_nul(&b)); b.ptr = data2; b.size = b.asize = data2len; - cl_assert(git_buf_text_is_binary(&b)); - cl_assert(git_buf_text_contains_nul(&b)); + cl_assert(git_buf_is_binary(&b)); + cl_assert(git_buf_contains_nul(&b)); b.ptr = data3; b.size = b.asize = data3len; - cl_assert(!git_buf_text_is_binary(&b)); - cl_assert(!git_buf_text_contains_nul(&b)); + cl_assert(!git_buf_is_binary(&b)); + cl_assert(!git_buf_contains_nul(&b)); } #define SIMILARITY_TEST_DATA_1 \ @@ -1074,80 +1058,80 @@ void test_core_buffer__lf_and_crlf_conversions(void) git_buf_sets(&src, "lf\nlf\nlf\nlf\n"); - cl_git_pass(git_buf_text_lf_to_crlf(&tgt, &src)); + cl_git_pass(git_buf_lf_to_crlf(&tgt, &src)); check_buf("lf\r\nlf\r\nlf\r\nlf\r\n", tgt); - cl_git_pass(git_buf_text_crlf_to_lf(&tgt, &src)); + cl_git_pass(git_buf_crlf_to_lf(&tgt, &src)); check_buf(src.ptr, tgt); git_buf_sets(&src, "\nlf\nlf\nlf\nlf\nlf"); - cl_git_pass(git_buf_text_lf_to_crlf(&tgt, &src)); + cl_git_pass(git_buf_lf_to_crlf(&tgt, &src)); check_buf("\r\nlf\r\nlf\r\nlf\r\nlf\r\nlf", tgt); - cl_git_pass(git_buf_text_crlf_to_lf(&tgt, &src)); + cl_git_pass(git_buf_crlf_to_lf(&tgt, &src)); check_buf(src.ptr, tgt); /* CRLF source */ git_buf_sets(&src, "crlf\r\ncrlf\r\ncrlf\r\ncrlf\r\n"); - cl_git_pass(git_buf_text_lf_to_crlf(&tgt, &src)); + cl_git_pass(git_buf_lf_to_crlf(&tgt, &src)); check_buf("crlf\r\ncrlf\r\ncrlf\r\ncrlf\r\n", tgt); git_buf_sets(&src, "crlf\r\ncrlf\r\ncrlf\r\ncrlf\r\n"); - cl_git_pass(git_buf_text_crlf_to_lf(&tgt, &src)); + cl_git_pass(git_buf_crlf_to_lf(&tgt, &src)); check_buf("crlf\ncrlf\ncrlf\ncrlf\n", tgt); git_buf_sets(&src, "\r\ncrlf\r\ncrlf\r\ncrlf\r\ncrlf\r\ncrlf"); - cl_git_pass(git_buf_text_lf_to_crlf(&tgt, &src)); + cl_git_pass(git_buf_lf_to_crlf(&tgt, &src)); check_buf("\r\ncrlf\r\ncrlf\r\ncrlf\r\ncrlf\r\ncrlf", tgt); git_buf_sets(&src, "\r\ncrlf\r\ncrlf\r\ncrlf\r\ncrlf\r\ncrlf"); - cl_git_pass(git_buf_text_crlf_to_lf(&tgt, &src)); + cl_git_pass(git_buf_crlf_to_lf(&tgt, &src)); check_buf("\ncrlf\ncrlf\ncrlf\ncrlf\ncrlf", tgt); /* CRLF in LF text */ git_buf_sets(&src, "\nlf\nlf\ncrlf\r\nlf\nlf\ncrlf\r\n"); - cl_git_pass(git_buf_text_lf_to_crlf(&tgt, &src)); + cl_git_pass(git_buf_lf_to_crlf(&tgt, &src)); check_buf("\r\nlf\r\nlf\r\ncrlf\r\nlf\r\nlf\r\ncrlf\r\n", tgt); git_buf_sets(&src, "\nlf\nlf\ncrlf\r\nlf\nlf\ncrlf\r\n"); - cl_git_pass(git_buf_text_crlf_to_lf(&tgt, &src)); + cl_git_pass(git_buf_crlf_to_lf(&tgt, &src)); check_buf("\nlf\nlf\ncrlf\nlf\nlf\ncrlf\n", tgt); /* LF in CRLF text */ git_buf_sets(&src, "\ncrlf\r\ncrlf\r\nlf\ncrlf\r\ncrlf"); - cl_git_pass(git_buf_text_lf_to_crlf(&tgt, &src)); + cl_git_pass(git_buf_lf_to_crlf(&tgt, &src)); check_buf("\r\ncrlf\r\ncrlf\r\nlf\r\ncrlf\r\ncrlf", tgt); - cl_git_pass(git_buf_text_crlf_to_lf(&tgt, &src)); + cl_git_pass(git_buf_crlf_to_lf(&tgt, &src)); check_buf("\ncrlf\ncrlf\nlf\ncrlf\ncrlf", tgt); /* bare CR test */ git_buf_sets(&src, "\rcrlf\r\nlf\nlf\ncr\rcrlf\r\nlf\ncr\r"); - cl_git_pass(git_buf_text_lf_to_crlf(&tgt, &src)); + cl_git_pass(git_buf_lf_to_crlf(&tgt, &src)); check_buf("\rcrlf\r\nlf\r\nlf\r\ncr\rcrlf\r\nlf\r\ncr\r", tgt); git_buf_sets(&src, "\rcrlf\r\nlf\nlf\ncr\rcrlf\r\nlf\ncr\r"); - cl_git_pass(git_buf_text_crlf_to_lf(&tgt, &src)); + cl_git_pass(git_buf_crlf_to_lf(&tgt, &src)); check_buf("\rcrlf\nlf\nlf\ncr\rcrlf\nlf\ncr\r", tgt); git_buf_sets(&src, "\rcr\r"); - cl_git_pass(git_buf_text_lf_to_crlf(&tgt, &src)); + cl_git_pass(git_buf_lf_to_crlf(&tgt, &src)); check_buf(src.ptr, tgt); - cl_git_pass(git_buf_text_crlf_to_lf(&tgt, &src)); + cl_git_pass(git_buf_crlf_to_lf(&tgt, &src)); check_buf("\rcr\r", tgt); git_buf_dispose(&src); @@ -1156,37 +1140,37 @@ void test_core_buffer__lf_and_crlf_conversions(void) /* blob correspondence tests */ git_buf_sets(&src, ALL_CRLF_TEXT_RAW); - cl_git_pass(git_buf_text_lf_to_crlf(&tgt, &src)); + cl_git_pass(git_buf_lf_to_crlf(&tgt, &src)); check_buf(ALL_CRLF_TEXT_AS_CRLF, tgt); git_buf_sets(&src, ALL_CRLF_TEXT_RAW); - cl_git_pass(git_buf_text_crlf_to_lf(&tgt, &src)); + cl_git_pass(git_buf_crlf_to_lf(&tgt, &src)); check_buf(ALL_CRLF_TEXT_AS_LF, tgt); git_buf_dispose(&src); git_buf_dispose(&tgt); git_buf_sets(&src, ALL_LF_TEXT_RAW); - cl_git_pass(git_buf_text_lf_to_crlf(&tgt, &src)); + cl_git_pass(git_buf_lf_to_crlf(&tgt, &src)); check_buf(ALL_LF_TEXT_AS_CRLF, tgt); git_buf_sets(&src, ALL_LF_TEXT_RAW); - cl_git_pass(git_buf_text_crlf_to_lf(&tgt, &src)); + cl_git_pass(git_buf_crlf_to_lf(&tgt, &src)); check_buf(ALL_LF_TEXT_AS_LF, tgt); git_buf_dispose(&src); git_buf_dispose(&tgt); git_buf_sets(&src, MORE_CRLF_TEXT_RAW); - cl_git_pass(git_buf_text_lf_to_crlf(&tgt, &src)); + cl_git_pass(git_buf_lf_to_crlf(&tgt, &src)); check_buf(MORE_CRLF_TEXT_AS_CRLF, tgt); git_buf_sets(&src, MORE_CRLF_TEXT_RAW); - cl_git_pass(git_buf_text_crlf_to_lf(&tgt, &src)); + cl_git_pass(git_buf_crlf_to_lf(&tgt, &src)); check_buf(MORE_CRLF_TEXT_AS_LF, tgt); git_buf_dispose(&src); git_buf_dispose(&tgt); git_buf_sets(&src, MORE_LF_TEXT_RAW); - cl_git_pass(git_buf_text_lf_to_crlf(&tgt, &src)); + cl_git_pass(git_buf_lf_to_crlf(&tgt, &src)); check_buf(MORE_LF_TEXT_AS_CRLF, tgt); git_buf_sets(&src, MORE_LF_TEXT_RAW); - cl_git_pass(git_buf_text_crlf_to_lf(&tgt, &src)); + cl_git_pass(git_buf_crlf_to_lf(&tgt, &src)); check_buf(MORE_LF_TEXT_AS_LF, tgt); git_buf_dispose(&src); git_buf_dispose(&tgt); diff --git a/tests/core/encoding.c b/tests/core/encoding.c index a677afe2e..6cec24679 100644 --- a/tests/core/encoding.c +++ b/tests/core/encoding.c @@ -14,7 +14,7 @@ void test_core_encoding__decode(void) cl_assert(size == 4); buf = (unsigned char *)"\xaa\xaa\xfe\xdc\xbaXY"; - cl_assert(git_decode_varint(buf, &size) == 1489279344088ULL); + cl_assert(git_decode_varint(buf, &size) == UINT64_C(1489279344088)); cl_assert(size == 6); buf = (unsigned char *)"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xfe\xdc\xbaXY"; @@ -35,8 +35,8 @@ void test_core_encoding__encode(void) cl_assert(git_encode_varint(buf, 100, 267869656) == 4); cl_assert(!memcmp(buf, "\xfe\xdc\xbaX", 4)); - cl_assert(git_encode_varint(buf, 100, 1489279344088ULL) == 6); + cl_assert(git_encode_varint(buf, 100, UINT64_C(1489279344088)) == 6); cl_assert(!memcmp(buf, "\xaa\xaa\xfe\xdc\xbaX", 6)); - cl_assert(git_encode_varint(buf, 1, 1489279344088ULL) == -1); + cl_assert(git_encode_varint(buf, 1, UINT64_C(1489279344088)) == -1); } diff --git a/tests/core/integer.c b/tests/core/integer.c new file mode 100644 index 000000000..18364ba62 --- /dev/null +++ b/tests/core/integer.c @@ -0,0 +1,253 @@ +#include "clar_libgit2.h" + +void test_core_integer__multiply_int64_no_overflow(void) +{ +#if !defined(git__multiply_int64_overflow) + int64_t result = 0; + cl_assert(!git__multiply_int64_overflow(&result, INT64_C(0x0), INT64_C(0x0))); + cl_assert_equal_i(result, INT64_C(0x0)); + cl_assert(!git__multiply_int64_overflow(&result, INT64_C(0x0), INT64_C(0x1))); + cl_assert_equal_i(result, INT64_C(0x0)); + cl_assert(!git__multiply_int64_overflow(&result, INT64_C(0x0), INT64_C(-0x1))); + cl_assert_equal_i(result, INT64_C(0x0)); + cl_assert(!git__multiply_int64_overflow(&result, INT64_C(0x0), INT64_C(0x2))); + cl_assert_equal_i(result, INT64_C(0x0)); + cl_assert(!git__multiply_int64_overflow(&result, INT64_C(0x0), INT64_C(-0x2))); + cl_assert_equal_i(result, INT64_C(0x0)); + cl_assert(!git__multiply_int64_overflow(&result, INT64_C(0x0), INT64_C(0x7ffffffffffffff))); + cl_assert_equal_i(result, INT64_C(0x0)); + cl_assert(!git__multiply_int64_overflow(&result, INT64_C(0x0), INT64_C(-0x7ffffffffffffff))); + cl_assert_equal_i(result, INT64_C(0x0)); + cl_assert(!git__multiply_int64_overflow(&result, INT64_C(0x0), INT64_C(0x800000000000000))); + cl_assert_equal_i(result, INT64_C(0x0)); + cl_assert(!git__multiply_int64_overflow(&result, INT64_C(0x0), INT64_C(-0x800000000000000))); + cl_assert_equal_i(result, INT64_C(0x0)); + cl_assert(!git__multiply_int64_overflow(&result, INT64_C(0x0), INT64_C(0x7fffffffffffffff))); + cl_assert_equal_i(result, INT64_C(0x0)); + cl_assert(!git__multiply_int64_overflow(&result, INT64_C(0x0), INT64_C(-0x7fffffffffffffff))); + cl_assert_equal_i(result, INT64_C(0x0)); + cl_assert(!git__multiply_int64_overflow(&result, INT64_C(0x0), INT64_C(-0x8000000000000000))); + cl_assert_equal_i(result, INT64_C(0x0)); + cl_assert(!git__multiply_int64_overflow(&result, INT64_C(0x1), INT64_C(0x0))); + cl_assert_equal_i(result, INT64_C(0x0)); + cl_assert(!git__multiply_int64_overflow(&result, INT64_C(0x1), INT64_C(0x1))); + cl_assert_equal_i(result, INT64_C(0x1)); + cl_assert(!git__multiply_int64_overflow(&result, INT64_C(0x1), INT64_C(-0x1))); + cl_assert_equal_i(result, INT64_C(-0x1)); + cl_assert(!git__multiply_int64_overflow(&result, INT64_C(0x1), INT64_C(0x2))); + cl_assert_equal_i(result, INT64_C(0x2)); + cl_assert(!git__multiply_int64_overflow(&result, INT64_C(0x1), INT64_C(-0x2))); + cl_assert_equal_i(result, INT64_C(-0x2)); + cl_assert(!git__multiply_int64_overflow(&result, INT64_C(0x1), INT64_C(0x7ffffffffffffff))); + cl_assert_equal_i(result, INT64_C(0x7ffffffffffffff)); + cl_assert(!git__multiply_int64_overflow(&result, INT64_C(0x1), INT64_C(-0x7ffffffffffffff))); + cl_assert_equal_i(result, INT64_C(-0x7ffffffffffffff)); + cl_assert(!git__multiply_int64_overflow(&result, INT64_C(0x1), INT64_C(0x800000000000000))); + cl_assert_equal_i(result, INT64_C(0x800000000000000)); + cl_assert(!git__multiply_int64_overflow(&result, INT64_C(0x1), INT64_C(-0x800000000000000))); + cl_assert_equal_i(result, INT64_C(-0x800000000000000)); + cl_assert(!git__multiply_int64_overflow(&result, INT64_C(0x1), INT64_C(0x7fffffffffffffff))); + cl_assert_equal_i(result, INT64_C(0x7fffffffffffffff)); + cl_assert(!git__multiply_int64_overflow(&result, INT64_C(0x1), INT64_C(-0x7fffffffffffffff))); + cl_assert_equal_i(result, INT64_C(-0x7fffffffffffffff)); + cl_assert(!git__multiply_int64_overflow(&result, INT64_C(-0x1), INT64_C(0x0))); + cl_assert_equal_i(result, INT64_C(0x0)); + cl_assert(!git__multiply_int64_overflow(&result, INT64_C(-0x1), INT64_C(0x1))); + cl_assert_equal_i(result, INT64_C(-0x1)); + cl_assert(!git__multiply_int64_overflow(&result, INT64_C(-0x1), INT64_C(-0x1))); + cl_assert_equal_i(result, INT64_C(0x1)); + cl_assert(!git__multiply_int64_overflow(&result, INT64_C(-0x1), INT64_C(0x2))); + cl_assert_equal_i(result, INT64_C(-0x2)); + cl_assert(!git__multiply_int64_overflow(&result, INT64_C(-0x1), INT64_C(-0x2))); + cl_assert_equal_i(result, INT64_C(0x2)); + cl_assert(!git__multiply_int64_overflow(&result, INT64_C(-0x1), INT64_C(0x7ffffffffffffff))); + cl_assert_equal_i(result, INT64_C(-0x7ffffffffffffff)); + cl_assert(!git__multiply_int64_overflow(&result, INT64_C(-0x1), INT64_C(-0x7ffffffffffffff))); + cl_assert_equal_i(result, INT64_C(0x7ffffffffffffff)); + cl_assert(!git__multiply_int64_overflow(&result, INT64_C(-0x1), INT64_C(0x800000000000000))); + cl_assert_equal_i(result, INT64_C(-0x800000000000000)); + cl_assert(!git__multiply_int64_overflow(&result, INT64_C(-0x1), INT64_C(-0x800000000000000))); + cl_assert_equal_i(result, INT64_C(0x800000000000000)); + cl_assert(!git__multiply_int64_overflow(&result, INT64_C(-0x1), INT64_C(0x7fffffffffffffff))); + cl_assert_equal_i(result, INT64_C(-0x7fffffffffffffff)); + cl_assert(!git__multiply_int64_overflow(&result, INT64_C(-0x1), INT64_C(-0x7fffffffffffffff))); + cl_assert_equal_i(result, INT64_C(0x7fffffffffffffff)); + cl_assert(!git__multiply_int64_overflow(&result, INT64_C(0x2), INT64_C(0x0))); + cl_assert_equal_i(result, INT64_C(0x0)); + cl_assert(!git__multiply_int64_overflow(&result, INT64_C(0x2), INT64_C(0x1))); + cl_assert_equal_i(result, INT64_C(0x2)); + cl_assert(!git__multiply_int64_overflow(&result, INT64_C(0x2), INT64_C(-0x1))); + cl_assert_equal_i(result, INT64_C(-0x2)); + cl_assert(!git__multiply_int64_overflow(&result, INT64_C(0x2), INT64_C(0x2))); + cl_assert_equal_i(result, INT64_C(0x4)); + cl_assert(!git__multiply_int64_overflow(&result, INT64_C(0x2), INT64_C(-0x2))); + cl_assert_equal_i(result, INT64_C(-0x4)); + cl_assert(!git__multiply_int64_overflow(&result, INT64_C(0x2), INT64_C(0x7ffffffffffffff))); + cl_assert_equal_i(result, INT64_C(0xffffffffffffffe)); + cl_assert(!git__multiply_int64_overflow(&result, INT64_C(0x2), INT64_C(-0x7ffffffffffffff))); + cl_assert_equal_i(result, INT64_C(-0xffffffffffffffe)); + cl_assert(!git__multiply_int64_overflow(&result, INT64_C(0x2), INT64_C(0x800000000000000))); + cl_assert_equal_i(result, INT64_C(0x1000000000000000)); + cl_assert(!git__multiply_int64_overflow(&result, INT64_C(0x2), INT64_C(-0x800000000000000))); + cl_assert_equal_i(result, INT64_C(-0x1000000000000000)); + cl_assert(!git__multiply_int64_overflow(&result, INT64_C(-0x2), INT64_C(0x0))); + cl_assert_equal_i(result, INT64_C(0x0)); + cl_assert(!git__multiply_int64_overflow(&result, INT64_C(-0x2), INT64_C(0x1))); + cl_assert_equal_i(result, INT64_C(-0x2)); + cl_assert(!git__multiply_int64_overflow(&result, INT64_C(-0x2), INT64_C(-0x1))); + cl_assert_equal_i(result, INT64_C(0x2)); + cl_assert(!git__multiply_int64_overflow(&result, INT64_C(-0x2), INT64_C(0x2))); + cl_assert_equal_i(result, INT64_C(-0x4)); + cl_assert(!git__multiply_int64_overflow(&result, INT64_C(-0x2), INT64_C(-0x2))); + cl_assert_equal_i(result, INT64_C(0x4)); + cl_assert(!git__multiply_int64_overflow(&result, INT64_C(-0x2), INT64_C(0x7ffffffffffffff))); + cl_assert_equal_i(result, INT64_C(-0xffffffffffffffe)); + cl_assert(!git__multiply_int64_overflow(&result, INT64_C(-0x2), INT64_C(-0x7ffffffffffffff))); + cl_assert_equal_i(result, INT64_C(0xffffffffffffffe)); + cl_assert(!git__multiply_int64_overflow(&result, INT64_C(-0x2), INT64_C(0x800000000000000))); + cl_assert_equal_i(result, INT64_C(-0x1000000000000000)); + cl_assert(!git__multiply_int64_overflow(&result, INT64_C(-0x2), INT64_C(-0x800000000000000))); + cl_assert_equal_i(result, INT64_C(0x1000000000000000)); + cl_assert(!git__multiply_int64_overflow(&result, INT64_C(0x2), INT64_C(-0x4000000000000000))); + cl_assert_equal_i(result, INT64_C(-0x8000000000000000)); + cl_assert(!git__multiply_int64_overflow(&result, INT64_C(0x7ffffffffffffff), INT64_C(0x0))); + cl_assert_equal_i(result, INT64_C(0x0)); + cl_assert(!git__multiply_int64_overflow(&result, INT64_C(0x7ffffffffffffff), INT64_C(0x1))); + cl_assert_equal_i(result, INT64_C(0x7ffffffffffffff)); + cl_assert(!git__multiply_int64_overflow(&result, INT64_C(0x7ffffffffffffff), INT64_C(-0x1))); + cl_assert_equal_i(result, INT64_C(-0x7ffffffffffffff)); + cl_assert(!git__multiply_int64_overflow(&result, INT64_C(0x7ffffffffffffff), INT64_C(0x2))); + cl_assert_equal_i(result, INT64_C(0xffffffffffffffe)); + cl_assert(!git__multiply_int64_overflow(&result, INT64_C(0x7ffffffffffffff), INT64_C(-0x2))); + cl_assert_equal_i(result, INT64_C(-0xffffffffffffffe)); + cl_assert(!git__multiply_int64_overflow(&result, INT64_C(-0x7ffffffffffffff), INT64_C(0x0))); + cl_assert_equal_i(result, INT64_C(0x0)); + cl_assert(!git__multiply_int64_overflow(&result, INT64_C(-0x7ffffffffffffff), INT64_C(0x1))); + cl_assert_equal_i(result, INT64_C(-0x7ffffffffffffff)); + cl_assert(!git__multiply_int64_overflow(&result, INT64_C(-0x7ffffffffffffff), INT64_C(-0x1))); + cl_assert_equal_i(result, INT64_C(0x7ffffffffffffff)); + cl_assert(!git__multiply_int64_overflow(&result, INT64_C(-0x7ffffffffffffff), INT64_C(0x2))); + cl_assert_equal_i(result, INT64_C(-0xffffffffffffffe)); + cl_assert(!git__multiply_int64_overflow(&result, INT64_C(-0x7ffffffffffffff), INT64_C(-0x2))); + cl_assert_equal_i(result, INT64_C(0xffffffffffffffe)); + cl_assert(!git__multiply_int64_overflow(&result, INT64_C(0x800000000000000), INT64_C(0x0))); + cl_assert_equal_i(result, INT64_C(0x0)); + cl_assert(!git__multiply_int64_overflow(&result, INT64_C(0x800000000000000), INT64_C(0x1))); + cl_assert_equal_i(result, INT64_C(0x800000000000000)); + cl_assert(!git__multiply_int64_overflow(&result, INT64_C(0x800000000000000), INT64_C(-0x1))); + cl_assert_equal_i(result, INT64_C(-0x800000000000000)); + cl_assert(!git__multiply_int64_overflow(&result, INT64_C(0x800000000000000), INT64_C(0x2))); + cl_assert_equal_i(result, INT64_C(0x1000000000000000)); + cl_assert(!git__multiply_int64_overflow(&result, INT64_C(0x800000000000000), INT64_C(-0x2))); + cl_assert_equal_i(result, INT64_C(-0x1000000000000000)); + cl_assert(!git__multiply_int64_overflow(&result, INT64_C(-0x800000000000000), INT64_C(0x0))); + cl_assert_equal_i(result, INT64_C(0x0)); + cl_assert(!git__multiply_int64_overflow(&result, INT64_C(-0x800000000000000), INT64_C(0x1))); + cl_assert_equal_i(result, INT64_C(-0x800000000000000)); + cl_assert(!git__multiply_int64_overflow(&result, INT64_C(-0x800000000000000), INT64_C(-0x1))); + cl_assert_equal_i(result, INT64_C(0x800000000000000)); + cl_assert(!git__multiply_int64_overflow(&result, INT64_C(-0x800000000000000), INT64_C(0x2))); + cl_assert_equal_i(result, INT64_C(-0x1000000000000000)); + cl_assert(!git__multiply_int64_overflow(&result, INT64_C(-0x800000000000000), INT64_C(-0x2))); + cl_assert_equal_i(result, INT64_C(0x1000000000000000)); + cl_assert(!git__multiply_int64_overflow(&result, INT64_C(0x7fffffffffffffff), INT64_C(0x0))); + cl_assert_equal_i(result, INT64_C(0x0)); + cl_assert(!git__multiply_int64_overflow(&result, INT64_C(0x7fffffffffffffff), INT64_C(0x1))); + cl_assert_equal_i(result, INT64_C(0x7fffffffffffffff)); + cl_assert(!git__multiply_int64_overflow(&result, INT64_C(0x7fffffffffffffff), INT64_C(-0x1))); + cl_assert_equal_i(result, INT64_C(-0x7fffffffffffffff)); + cl_assert(!git__multiply_int64_overflow(&result, INT64_C(-0x4000000000000000), INT64_C(0x2))); + cl_assert_equal_i(result, INT64_C(-0x8000000000000000)); + cl_assert(!git__multiply_int64_overflow(&result, INT64_C(-0x7fffffffffffffff), INT64_C(0x0))); + cl_assert_equal_i(result, INT64_C(0x0)); + cl_assert(!git__multiply_int64_overflow(&result, INT64_C(-0x7fffffffffffffff), INT64_C(0x1))); + cl_assert_equal_i(result, INT64_C(-0x7fffffffffffffff)); + cl_assert(!git__multiply_int64_overflow(&result, INT64_C(-0x7fffffffffffffff), INT64_C(-0x1))); + cl_assert_equal_i(result, INT64_C(0x7fffffffffffffff)); + cl_assert(!git__multiply_int64_overflow(&result, INT64_C(-0x8000000000000000), INT64_C(0x0))); + cl_assert_equal_i(result, INT64_C(0x0)); +#endif +} + +void test_core_integer__multiply_int64_overflow(void) +{ +#if !defined(git__multiply_int64_overflow) + int64_t result = 0; + cl_assert(git__multiply_int64_overflow(&result, INT64_C(0x2), INT64_C(0x4000000000000000))); + cl_assert(git__multiply_int64_overflow(&result, INT64_C(0x2), INT64_C(0x7fffffffffffffff))); + cl_assert(git__multiply_int64_overflow(&result, INT64_C(0x2), INT64_C(-0x7fffffffffffffff))); + cl_assert(git__multiply_int64_overflow(&result, INT64_C(0x2), INT64_C(-0x8000000000000000))); + cl_assert(git__multiply_int64_overflow(&result, INT64_C(-0x2), INT64_C(0x7fffffffffffffff))); + cl_assert(git__multiply_int64_overflow(&result, INT64_C(-0x2), INT64_C(-0x7fffffffffffffff))); + cl_assert(git__multiply_int64_overflow(&result, INT64_C(-0x2), INT64_C(-0x8000000000000000))); + cl_assert(git__multiply_int64_overflow(&result, INT64_C(0x7ffffffffffffff), INT64_C(0x7ffffffffffffff))); + cl_assert(git__multiply_int64_overflow(&result, INT64_C(0x7ffffffffffffff), INT64_C(-0x7ffffffffffffff))); + cl_assert(git__multiply_int64_overflow(&result, INT64_C(0x7ffffffffffffff), INT64_C(0x800000000000000))); + cl_assert(git__multiply_int64_overflow(&result, INT64_C(0x7ffffffffffffff), INT64_C(-0x800000000000000))); + cl_assert(git__multiply_int64_overflow(&result, INT64_C(0x7ffffffffffffff), INT64_C(0x7fffffffffffffff))); + cl_assert(git__multiply_int64_overflow(&result, INT64_C(0x7ffffffffffffff), INT64_C(-0x7fffffffffffffff))); + cl_assert(git__multiply_int64_overflow(&result, INT64_C(0x7ffffffffffffff), INT64_C(-0x8000000000000000))); + cl_assert(git__multiply_int64_overflow(&result, INT64_C(-0x7ffffffffffffff), INT64_C(0x7ffffffffffffff))); + cl_assert(git__multiply_int64_overflow(&result, INT64_C(-0x7ffffffffffffff), INT64_C(-0x7ffffffffffffff))); + cl_assert(git__multiply_int64_overflow(&result, INT64_C(-0x7ffffffffffffff), INT64_C(0x800000000000000))); + cl_assert(git__multiply_int64_overflow(&result, INT64_C(-0x7ffffffffffffff), INT64_C(-0x800000000000000))); + cl_assert(git__multiply_int64_overflow(&result, INT64_C(-0x7ffffffffffffff), INT64_C(0x7fffffffffffffff))); + cl_assert(git__multiply_int64_overflow(&result, INT64_C(-0x7ffffffffffffff), INT64_C(-0x7fffffffffffffff))); + cl_assert(git__multiply_int64_overflow(&result, INT64_C(-0x7ffffffffffffff), INT64_C(-0x8000000000000000))); + cl_assert(git__multiply_int64_overflow(&result, INT64_C(0x800000000000000), INT64_C(0x7ffffffffffffff))); + cl_assert(git__multiply_int64_overflow(&result, INT64_C(0x800000000000000), INT64_C(-0x7ffffffffffffff))); + cl_assert(git__multiply_int64_overflow(&result, INT64_C(0x800000000000000), INT64_C(0x800000000000000))); + cl_assert(git__multiply_int64_overflow(&result, INT64_C(0x800000000000000), INT64_C(-0x800000000000000))); + cl_assert(git__multiply_int64_overflow(&result, INT64_C(0x800000000000000), INT64_C(0x7fffffffffffffff))); + cl_assert(git__multiply_int64_overflow(&result, INT64_C(0x800000000000000), INT64_C(-0x7fffffffffffffff))); + cl_assert(git__multiply_int64_overflow(&result, INT64_C(0x800000000000000), INT64_C(-0x8000000000000000))); + cl_assert(git__multiply_int64_overflow(&result, INT64_C(-0x800000000000000), INT64_C(0x7ffffffffffffff))); + cl_assert(git__multiply_int64_overflow(&result, INT64_C(-0x800000000000000), INT64_C(-0x7ffffffffffffff))); + cl_assert(git__multiply_int64_overflow(&result, INT64_C(-0x800000000000000), INT64_C(0x800000000000000))); + cl_assert(git__multiply_int64_overflow(&result, INT64_C(-0x800000000000000), INT64_C(-0x800000000000000))); + cl_assert(git__multiply_int64_overflow(&result, INT64_C(-0x800000000000000), INT64_C(0x7fffffffffffffff))); + cl_assert(git__multiply_int64_overflow(&result, INT64_C(-0x800000000000000), INT64_C(-0x7fffffffffffffff))); + cl_assert(git__multiply_int64_overflow(&result, INT64_C(-0x800000000000000), INT64_C(-0x8000000000000000))); + cl_assert(git__multiply_int64_overflow(&result, INT64_C(0x4000000000000000), INT64_C(0x2))); + cl_assert(git__multiply_int64_overflow(&result, INT64_C(0x7fffffffffffffff), INT64_C(0x2))); + cl_assert(git__multiply_int64_overflow(&result, INT64_C(0x7fffffffffffffff), INT64_C(-0x2))); + cl_assert(git__multiply_int64_overflow(&result, INT64_C(0x7fffffffffffffff), INT64_C(0x7ffffffffffffff))); + cl_assert(git__multiply_int64_overflow(&result, INT64_C(0x7fffffffffffffff), INT64_C(-0x7ffffffffffffff))); + cl_assert(git__multiply_int64_overflow(&result, INT64_C(0x7fffffffffffffff), INT64_C(0x800000000000000))); + cl_assert(git__multiply_int64_overflow(&result, INT64_C(0x7fffffffffffffff), INT64_C(-0x800000000000000))); + cl_assert(git__multiply_int64_overflow(&result, INT64_C(0x7fffffffffffffff), INT64_C(0x7fffffffffffffff))); + cl_assert(git__multiply_int64_overflow(&result, INT64_C(0x7fffffffffffffff), INT64_C(-0x7fffffffffffffff))); + cl_assert(git__multiply_int64_overflow(&result, INT64_C(0x7fffffffffffffff), INT64_C(-0x8000000000000000))); + cl_assert(git__multiply_int64_overflow(&result, INT64_C(-0x7fffffffffffffff), INT64_C(0x2))); + cl_assert(git__multiply_int64_overflow(&result, INT64_C(-0x7fffffffffffffff), INT64_C(-0x2))); + cl_assert(git__multiply_int64_overflow(&result, INT64_C(-0x7fffffffffffffff), INT64_C(0x7ffffffffffffff))); + cl_assert(git__multiply_int64_overflow(&result, INT64_C(-0x7fffffffffffffff), INT64_C(-0x7ffffffffffffff))); + cl_assert(git__multiply_int64_overflow(&result, INT64_C(-0x7fffffffffffffff), INT64_C(0x800000000000000))); + cl_assert(git__multiply_int64_overflow(&result, INT64_C(-0x7fffffffffffffff), INT64_C(-0x800000000000000))); + cl_assert(git__multiply_int64_overflow(&result, INT64_C(-0x7fffffffffffffff), INT64_C(0x7fffffffffffffff))); + cl_assert(git__multiply_int64_overflow(&result, INT64_C(-0x7fffffffffffffff), INT64_C(-0x7fffffffffffffff))); + cl_assert(git__multiply_int64_overflow(&result, INT64_C(-0x7fffffffffffffff), INT64_C(-0x8000000000000000))); + cl_assert(git__multiply_int64_overflow(&result, INT64_C(-0x8000000000000000), INT64_C(0x2))); + cl_assert(git__multiply_int64_overflow(&result, INT64_C(-0x8000000000000000), INT64_C(-0x2))); + cl_assert(git__multiply_int64_overflow(&result, INT64_C(-0x8000000000000000), INT64_C(0x7ffffffffffffff))); + cl_assert(git__multiply_int64_overflow(&result, INT64_C(-0x8000000000000000), INT64_C(-0x7ffffffffffffff))); + cl_assert(git__multiply_int64_overflow(&result, INT64_C(-0x8000000000000000), INT64_C(0x800000000000000))); + cl_assert(git__multiply_int64_overflow(&result, INT64_C(-0x8000000000000000), INT64_C(-0x800000000000000))); + cl_assert(git__multiply_int64_overflow(&result, INT64_C(-0x8000000000000000), INT64_C(0x7fffffffffffffff))); + cl_assert(git__multiply_int64_overflow(&result, INT64_C(-0x8000000000000000), INT64_C(-0x7fffffffffffffff))); + cl_assert(git__multiply_int64_overflow(&result, INT64_C(-0x8000000000000000), INT64_C(-0x8000000000000000))); +#endif +} + +void test_core_integer__multiply_int64_edge_cases(void) +{ +#if !defined(git__multiply_int64_overflow) + int64_t result = 0; + cl_assert(!git__multiply_int64_overflow(&result, INT64_C(-0x8000000000000000), INT64_C(-0x1))); + cl_assert_equal_i(result, INT64_C(-0x8000000000000000)); + cl_assert(!git__multiply_int64_overflow(&result, INT64_C(-0x1), INT64_C(-0x8000000000000000))); + cl_assert_equal_i(result, INT64_C(-0x8000000000000000)); + cl_assert(git__multiply_int64_overflow(&result, INT64_C(0x1), INT64_C(-0x8000000000000000))); + cl_assert(git__multiply_int64_overflow(&result, INT64_C(-0x8000000000000000), INT64_C(0x1))); +#endif +} diff --git a/tests/core/link.c b/tests/core/link.c index 1e5ed454c..0493edf1d 100644 --- a/tests/core/link.c +++ b/tests/core/link.c @@ -123,7 +123,7 @@ static void do_junction(const char *old, const char *new) reparse_buf = LocalAlloc(LMEM_FIXED|LMEM_ZEROINIT, reparse_buflen); cl_assert(reparse_buf); - subst_utf16 = reparse_buf->MountPointReparseBuffer.PathBuffer; + subst_utf16 = reparse_buf->ReparseBuffer.MountPoint.PathBuffer; print_utf16 = subst_utf16 + subst_utf16_len + 1; ret = git__utf8_to_16(subst_utf16, subst_utf16_len + 1, @@ -135,10 +135,10 @@ static void do_junction(const char *old, const char *new) cl_assert_equal_i(print_utf16_len, ret); reparse_buf->ReparseTag = IO_REPARSE_TAG_MOUNT_POINT; - reparse_buf->MountPointReparseBuffer.SubstituteNameOffset = 0; - reparse_buf->MountPointReparseBuffer.SubstituteNameLength = subst_byte_len; - reparse_buf->MountPointReparseBuffer.PrintNameOffset = (USHORT)(subst_byte_len + sizeof(WCHAR)); - reparse_buf->MountPointReparseBuffer.PrintNameLength = print_byte_len; + reparse_buf->ReparseBuffer.MountPoint.SubstituteNameOffset = 0; + reparse_buf->ReparseBuffer.MountPoint.SubstituteNameLength = subst_byte_len; + reparse_buf->ReparseBuffer.MountPoint.PrintNameOffset = (USHORT)(subst_byte_len + sizeof(WCHAR)); + reparse_buf->ReparseBuffer.MountPoint.PrintNameLength = print_byte_len; reparse_buf->ReparseDataLength = reparse_buflen - REPARSE_DATA_HEADER_SIZE; cl_win32_pass(DeviceIoControl(handle, FSCTL_SET_REPARSE_POINT, diff --git a/tests/core/opts.c b/tests/core/opts.c index 72408cbe8..e8f65d510 100644 --- a/tests/core/opts.c +++ b/tests/core/opts.c @@ -1,6 +1,11 @@ #include "clar_libgit2.h" #include "cache.h" +void test_core_opts__cleanup(void) +{ + cl_git_pass(git_libgit2_opts(GIT_OPT_SET_EXTENSIONS, NULL, 0)); +} + void test_core_opts__readwrite(void) { size_t old_val = 0; @@ -23,3 +28,44 @@ void test_core_opts__invalid_option(void) cl_git_fail(git_libgit2_opts(-1, "foobar")); } +void test_core_opts__extensions_query(void) +{ + git_strarray out = { 0 }; + + cl_git_pass(git_libgit2_opts(GIT_OPT_GET_EXTENSIONS, &out)); + + cl_assert_equal_sz(out.count, 1); + cl_assert_equal_s("noop", out.strings[0]); + + git_strarray_dispose(&out); +} + +void test_core_opts__extensions_add(void) +{ + const char *in[] = { "foo" }; + git_strarray out = { 0 }; + + cl_git_pass(git_libgit2_opts(GIT_OPT_SET_EXTENSIONS, in, ARRAY_SIZE(in))); + cl_git_pass(git_libgit2_opts(GIT_OPT_GET_EXTENSIONS, &out)); + + cl_assert_equal_sz(out.count, 2); + cl_assert_equal_s("noop", out.strings[0]); + cl_assert_equal_s("foo", out.strings[1]); + + git_strarray_dispose(&out); +} + +void test_core_opts__extensions_remove(void) +{ + const char *in[] = { "bar", "!negate", "!noop", "baz" }; + git_strarray out = { 0 }; + + cl_git_pass(git_libgit2_opts(GIT_OPT_SET_EXTENSIONS, in, ARRAY_SIZE(in))); + cl_git_pass(git_libgit2_opts(GIT_OPT_GET_EXTENSIONS, &out)); + + cl_assert_equal_sz(out.count, 2); + cl_assert_equal_s("bar", out.strings[0]); + cl_assert_equal_s("baz", out.strings[1]); + + git_strarray_dispose(&out); +} diff --git a/tests/core/path.c b/tests/core/path.c index 2e5a4ab24..eac3573fe 100644 --- a/tests/core/path.c +++ b/tests/core/path.c @@ -32,15 +32,6 @@ check_basename(const char *A, const char *B) } static void -check_topdir(const char *A, const char *B) -{ - const char *dir; - - cl_assert((dir = git_path_topdir(A)) != NULL); - cl_assert_equal_s(B, dir); -} - -static void check_joinpath(const char *path_a, const char *path_b, const char *expected_path) { git_buf joined_path = GIT_BUF_INIT; @@ -119,23 +110,6 @@ void test_core_path__01_basename(void) check_basename(REP1024("/abc"), "abc"); } -/* get the latest component in a path */ -void test_core_path__02_topdir(void) -{ - check_topdir(".git/", ".git/"); - check_topdir("/.git/", ".git/"); - check_topdir("usr/local/.git/", ".git/"); - check_topdir("./.git/", ".git/"); - check_topdir("/usr/.git/", ".git/"); - check_topdir("/", "/"); - check_topdir("a/", "a/"); - - cl_assert(git_path_topdir("/usr/.git") == NULL); - cl_assert(git_path_topdir(".") == NULL); - cl_assert(git_path_topdir("") == NULL); - cl_assert(git_path_topdir("a") == NULL); -} - /* properly join path components */ void test_core_path__05_joins(void) { @@ -285,7 +259,7 @@ void test_core_path__08_self_join(void) cl_git_pass(git_buf_joinpath(&path, path.ptr + 4, "somethinglongenoughtorealloc")); cl_assert_equal_s(path.ptr, "/baz/somethinglongenoughtorealloc"); cl_assert(asize < path.asize); - + git_buf_dispose(&path); } diff --git a/tests/core/sha1.c b/tests/core/sha1.c index f81d40854..196b00352 100644 --- a/tests/core/sha1.c +++ b/tests/core/sha1.c @@ -52,7 +52,7 @@ void test_core_sha1__detect_collision_attack(void) git_oid oid, expected; #ifdef GIT_SHA1_COLLISIONDETECT - GIT_UNUSED(expected); + GIT_UNUSED(&expected); cl_git_fail(sha1_file(&oid, FIXTURE_DIR "/shattered-1.pdf")); cl_assert_equal_s("SHA1 collision attack detected", git_error_last()->message); #else diff --git a/tests/core/sortedcache.c b/tests/core/sortedcache.c index 35e92ece9..d5bbcea19 100644 --- a/tests/core/sortedcache.c +++ b/tests/core/sortedcache.c @@ -54,7 +54,7 @@ void test_core_sortedcache__name_only(void) cl_assert_equal_i( GIT_ENOTFOUND, git_sortedcache_lookup_index(&pos, sc, "abc")); - git_sortedcache_clear(sc, true); + cl_git_pass(git_sortedcache_clear(sc, true)); cl_assert_equal_sz(0, git_sortedcache_entrycount(sc)); cl_assert(git_sortedcache_entry(sc, 0) == NULL); @@ -154,7 +154,7 @@ void test_core_sortedcache__in_memory(void) cl_assert_equal_i(0, free_count); - git_sortedcache_clear(sc, true); + cl_git_pass(git_sortedcache_clear(sc, true)); cl_assert_equal_i(5, free_count); @@ -247,7 +247,7 @@ static void sortedcache_test_reload(git_sortedcache *sc) cl_assert(git_sortedcache_lockandload(sc, &buf) > 0); - git_sortedcache_clear(sc, false); /* clear once we already have lock */ + cl_git_pass(git_sortedcache_clear(sc, false)); /* clear once we already have lock */ for (scan = buf.ptr; *scan; scan = after + 1) { int val = strtol(scan, &after, 0); diff --git a/tests/core/string.c b/tests/core/string.c index 85db0c662..928dfbcc1 100644 --- a/tests/core/string.c +++ b/tests/core/string.c @@ -123,3 +123,14 @@ void test_core_string__strcasecmp(void) cl_assert(git__strcasecmp("et", "e\342\202\254ghi=") < 0); cl_assert(git__strcasecmp("\303\215", "\303\255") < 0); } + +void test_core_string__strlcmp(void) +{ + const char foo[3] = { 'f', 'o', 'o' }; + + cl_assert(git__strlcmp("foo", "foo", 3) == 0); + cl_assert(git__strlcmp("foo", foo, 3) == 0); + cl_assert(git__strlcmp("foo", "foobar", 3) == 0); + cl_assert(git__strlcmp("foobar", "foo", 3) > 0); + cl_assert(git__strlcmp("foo", "foobar", 6) < 0); +} diff --git a/tests/core/strtol.c b/tests/core/strtol.c index 25dbe467c..851b91b0a 100644 --- a/tests/core/strtol.c +++ b/tests/core/strtol.c @@ -30,8 +30,9 @@ void test_core_strtol__int32(void) { assert_l32_parses("123", 123, 10); assert_l32_parses(" +123 ", 123, 10); + assert_l32_parses(" -123 ", -123, 10); assert_l32_parses(" +2147483647 ", 2147483647, 10); - assert_l32_parses(" -2147483648 ", -2147483648LL, 10); + assert_l32_parses(" -2147483648 ", INT64_C(-2147483648), 10); assert_l32_parses("A", 10, 16); assert_l32_parses("1x1", 1, 10); @@ -46,10 +47,11 @@ void test_core_strtol__int64(void) { assert_l64_parses("123", 123, 10); assert_l64_parses(" +123 ", 123, 10); + assert_l64_parses(" -123 ", -123, 10); assert_l64_parses(" +2147483647 ", 2147483647, 10); - assert_l64_parses(" -2147483648 ", -2147483648LL, 10); - assert_l64_parses(" 2147483657 ", 2147483657LL, 10); - assert_l64_parses(" -2147483657 ", -2147483657LL, 10); + assert_l64_parses(" -2147483648 ", INT64_C(-2147483648), 10); + assert_l64_parses(" 2147483657 ", INT64_C(2147483657), 10); + assert_l64_parses(" -2147483657 ", INT64_C(-2147483657), 10); assert_l64_parses(" 9223372036854775807 ", INT64_MAX, 10); assert_l64_parses(" -9223372036854775808 ", INT64_MIN, 10); assert_l64_parses(" 0x7fffffffffffffff ", INT64_MAX, 16); diff --git a/tests/core/structinit.c b/tests/core/structinit.c index 192096be3..d24da874d 100644 --- a/tests/core/structinit.c +++ b/tests/core/structinit.c @@ -1,4 +1,5 @@ #include "clar_libgit2.h" +#include <git2/sys/commit_graph.h> #include <git2/sys/config.h> #include <git2/sys/filter.h> #include <git2/sys/odb_backend.h> @@ -82,6 +83,11 @@ void test_core_structinit__compare(void) git_blame_options, GIT_BLAME_OPTIONS_VERSION, \ GIT_BLAME_OPTIONS_INIT, git_blame_options_init); + /* blob_filter_options */ + CHECK_MACRO_FUNC_INIT_EQUAL( \ + git_blob_filter_options, GIT_BLOB_FILTER_OPTIONS_VERSION, \ + GIT_BLOB_FILTER_OPTIONS_INIT, git_blob_filter_options_init); + /* checkout */ CHECK_MACRO_FUNC_INIT_EQUAL( \ git_checkout_options, GIT_CHECKOUT_OPTIONS_VERSION, \ @@ -92,6 +98,13 @@ void test_core_structinit__compare(void) git_clone_options, GIT_CLONE_OPTIONS_VERSION, \ GIT_CLONE_OPTIONS_INIT, git_clone_options_init); + /* commit_graph_writer */ + CHECK_MACRO_FUNC_INIT_EQUAL( \ + git_commit_graph_writer_options, \ + GIT_COMMIT_GRAPH_WRITER_OPTIONS_VERSION, \ + GIT_COMMIT_GRAPH_WRITER_OPTIONS_INIT, \ + git_commit_graph_writer_options_init); + /* diff */ CHECK_MACRO_FUNC_INIT_EQUAL( \ git_diff_options, GIT_DIFF_OPTIONS_VERSION, \ diff --git a/tests/core/useragent.c b/tests/core/useragent.c index c6c5220b2..2ce935bf5 100644 --- a/tests/core/useragent.c +++ b/tests/core/useragent.c @@ -1,5 +1,5 @@ #include "clar_libgit2.h" -#include "global.h" +#include "settings.h" void test_core_useragent__get(void) { diff --git a/tests/core/utf8.c b/tests/core/utf8.c new file mode 100644 index 000000000..021828e9e --- /dev/null +++ b/tests/core/utf8.c @@ -0,0 +1,19 @@ +#include "clar_libgit2.h" + +void test_core_utf8__char_length(void) +{ + cl_assert_equal_i(0, git_utf8_char_length("", 0)); + cl_assert_equal_i(1, git_utf8_char_length("$", 1)); + cl_assert_equal_i(5, git_utf8_char_length("abcde", 5)); + cl_assert_equal_i(1, git_utf8_char_length("\xc2\xa2", 2)); + cl_assert_equal_i(2, git_utf8_char_length("\x24\xc2\xa2", 3)); + cl_assert_equal_i(1, git_utf8_char_length("\xf0\x90\x8d\x88", 4)); + + /* uncontinued character counted as single characters */ + cl_assert_equal_i(2, git_utf8_char_length("\x24\xc2", 2)); + cl_assert_equal_i(3, git_utf8_char_length("\x24\xc2\xc2\xa2", 4)); + + /* invalid characters are counted as single characters */ + cl_assert_equal_i(4, git_utf8_char_length("\x24\xc0\xc0\x34", 4)); + cl_assert_equal_i(4, git_utf8_char_length("\x24\xf5\xfd\xc2", 4)); +} diff --git a/tests/core/vector.c b/tests/core/vector.c index a7e1a0325..08cd2c19b 100644 --- a/tests/core/vector.c +++ b/tests/core/vector.c @@ -8,7 +8,7 @@ void test_core_vector__0(void) { git_vector x; int i; - git_vector_init(&x, 1, NULL); + cl_git_pass(git_vector_init(&x, 1, NULL)); for (i = 0; i < 10; ++i) { git_vector_insert(&x, (void*) 0xabc); } @@ -21,7 +21,7 @@ void test_core_vector__1(void) { git_vector x; /* make initial capacity exact for our insertions. */ - git_vector_init(&x, 3, NULL); + cl_git_pass(git_vector_init(&x, 3, NULL)); git_vector_insert(&x, (void*) 0xabc); git_vector_insert(&x, (void*) 0xdef); git_vector_insert(&x, (void*) 0x123); @@ -76,7 +76,7 @@ void test_core_vector__3(void) { git_vector x; intptr_t i; - git_vector_init(&x, 1, &compare_them); + cl_git_pass(git_vector_init(&x, 1, &compare_them)); for (i = 0; i < 10; i += 2) { git_vector_insert_sorted(&x, (void*)(i + 1), NULL); @@ -99,7 +99,7 @@ void test_core_vector__4(void) { git_vector x; intptr_t i; - git_vector_init(&x, 1, &compare_them); + cl_git_pass(git_vector_init(&x, 1, &compare_them)); for (i = 0; i < 10; i += 2) { git_vector_insert_sorted(&x, (void*)(i + 1), NULL); @@ -163,7 +163,7 @@ void test_core_vector__5(void) git_vector x; int i; - git_vector_init(&x, 1, &compare_structs); + cl_git_pass(git_vector_init(&x, 1, &compare_structs)); for (i = 0; i < 10; i += 2) git_vector_insert_sorted(&x, alloc_struct(i), &merge_structs); @@ -205,7 +205,7 @@ void test_core_vector__remove_matching(void) size_t i; void *compare; - git_vector_init(&x, 1, NULL); + cl_git_pass(git_vector_init(&x, 1, NULL)); git_vector_insert(&x, (void*) 0x001); cl_assert(x.length == 1); diff --git a/tests/diff/format_email.c b/tests/diff/format_email.c index 28f840ab0..ea7aa070f 100644 --- a/tests/diff/format_email.c +++ b/tests/diff/format_email.c @@ -18,6 +18,7 @@ void test_diff_format_email__cleanup(void) cl_git_sandbox_cleanup(); } +#ifndef GIT_DEPRECATE_HARD static void assert_email_match( const char *expected, const char *oidstr, @@ -51,9 +52,11 @@ static void assert_email_match( git_commit_free(commit); git_buf_dispose(&buf); } +#endif void test_diff_format_email__simple(void) { +#ifndef GIT_DEPRECATE_HARD git_diff_format_email_options opts = GIT_DIFF_FORMAT_EMAIL_OPTIONS_INIT; const char *email = "From 9264b96c6d104d0e07ae33d3007b6a48246c6f92 Mon Sep 17 00:00:00 2001\n" \ @@ -96,10 +99,12 @@ void test_diff_format_email__simple(void) assert_email_match( email, "9264b96c6d104d0e07ae33d3007b6a48246c6f92", &opts); +#endif } void test_diff_format_email__with_message(void) { +#ifndef GIT_DEPRECATE_HARD git_diff_format_email_options opts = GIT_DIFF_FORMAT_EMAIL_OPTIONS_INIT; const char *email = "From 627e7e12d87e07a83fad5b6bfa25e86ead4a5270 Mon Sep 17 00:00:00 2001\n" \ "From: Patrick Steinhardt <ps@pks.im>\n" \ @@ -136,11 +141,13 @@ void test_diff_format_email__with_message(void) assert_email_match( email, "627e7e12d87e07a83fad5b6bfa25e86ead4a5270", &opts); +#endif } void test_diff_format_email__multiple(void) { +#ifndef GIT_DEPRECATE_HARD git_oid oid; git_commit *commit = NULL; git_diff *diff = NULL; @@ -256,10 +263,12 @@ void test_diff_format_email__multiple(void) git_diff_free(diff); git_commit_free(commit); git_buf_dispose(&buf); +#endif } void test_diff_format_email__exclude_marker(void) { +#ifndef GIT_DEPRECATE_HARD git_diff_format_email_options opts = GIT_DIFF_FORMAT_EMAIL_OPTIONS_INIT; const char *email = "From 9264b96c6d104d0e07ae33d3007b6a48246c6f92 Mon Sep 17 00:00:00 2001\n" \ @@ -304,10 +313,12 @@ void test_diff_format_email__exclude_marker(void) assert_email_match( email, "9264b96c6d104d0e07ae33d3007b6a48246c6f92", &opts); +#endif } void test_diff_format_email__invalid_no(void) { +#ifndef GIT_DEPRECATE_HARD git_oid oid; git_commit *commit = NULL; git_diff *diff = NULL; @@ -327,15 +338,16 @@ void test_diff_format_email__invalid_no(void) cl_git_pass(git_diff__commit(&diff, repo, commit, NULL)); cl_git_fail(git_diff_format_email(&buf, diff, &opts)); cl_git_fail(git_diff_commit_as_email(&buf, repo, commit, 2, 1, 0, NULL)); - cl_git_fail(git_diff_commit_as_email(&buf, repo, commit, 0, 0, 0, NULL)); git_diff_free(diff); git_commit_free(commit); git_buf_dispose(&buf); +#endif } void test_diff_format_email__mode_change(void) { +#ifndef GIT_DEPRECATE_HARD git_diff_format_email_options opts = GIT_DIFF_FORMAT_EMAIL_OPTIONS_INIT; const char *email = "From 7ade76dd34bba4733cf9878079f9fd4a456a9189 Mon Sep 17 00:00:00 2001\n" \ @@ -357,10 +369,12 @@ void test_diff_format_email__mode_change(void) assert_email_match( email, "7ade76dd34bba4733cf9878079f9fd4a456a9189", &opts); +#endif } void test_diff_format_email__rename_add_remove(void) { +#ifndef GIT_DEPRECATE_HARD git_diff_format_email_options opts = GIT_DIFF_FORMAT_EMAIL_OPTIONS_INIT; const char *email = "From 6e05acc5a5dab507d91a0a0cc0fb05a3dd98892d Mon Sep 17 00:00:00 2001\n" \ @@ -427,10 +441,12 @@ void test_diff_format_email__rename_add_remove(void) assert_email_match( email, "6e05acc5a5dab507d91a0a0cc0fb05a3dd98892d", &opts); +#endif } void test_diff_format_email__multiline_summary(void) { +#ifndef GIT_DEPRECATE_HARD git_diff_format_email_options opts = GIT_DIFF_FORMAT_EMAIL_OPTIONS_INIT; const char *email = "From 9264b96c6d104d0e07ae33d3007b6a48246c6f92 Mon Sep 17 00:00:00 2001\n" \ @@ -475,10 +491,12 @@ void test_diff_format_email__multiline_summary(void) assert_email_match( email, "9264b96c6d104d0e07ae33d3007b6a48246c6f92", &opts); +#endif } void test_diff_format_email__binary(void) { +#ifndef GIT_DEPRECATE_HARD git_diff_format_email_options opts = GIT_DIFF_FORMAT_EMAIL_OPTIONS_INIT; const char *email = "From 8d7523f6fcb2404257889abe0d96f093d9f524f9 Mon Sep 17 00:00:00 2001\n" \ @@ -487,7 +505,7 @@ void test_diff_format_email__binary(void) "Subject: [PATCH] Modified binary file\n" \ "\n" \ "---\n" \ - " binary.bin | Bin 3 -> 0 bytes\n" \ + " binary.bin | Bin 3 -> 5 bytes\n" \ " 1 file changed, 0 insertions(+), 0 deletions(-)\n" \ "\n" \ "diff --git a/binary.bin b/binary.bin\n" \ @@ -496,11 +514,11 @@ void test_diff_format_email__binary(void) "--\n" \ "libgit2 " LIBGIT2_VERSION "\n" \ "\n"; - /* TODO: Actually 0 bytes here should be 5!. Seems like we don't load the new content for binary files? */ opts.summary = "Modified binary file"; assert_email_match( email, "8d7523f6fcb2404257889abe0d96f093d9f524f9", &opts); +#endif } diff --git a/tests/diff/parse.c b/tests/diff/parse.c index 56f2253aa..6b6e6645e 100644 --- a/tests/diff/parse.c +++ b/tests/diff/parse.c @@ -107,6 +107,29 @@ void test_diff_parse__no_extended_headers(void) git_diff_free(diff); } +void test_diff_parse__add_delete_no_index(void) +{ + const char *content = + "diff --git a/file.txt b/file.txt\n" + "new file mode 100644\n" + "--- /dev/null\n" + "+++ b/file.txt\n" + "@@ -0,0 +1,2 @@\n" + "+one\n" + "+two\n" + "diff --git a/otherfile.txt b/otherfile.txt\n" + "deleted file mode 100644\n" + "--- a/otherfile.txt\n" + "+++ /dev/null\n" + "@@ -1,1 +0,0 @@\n" + "-three\n"; + git_diff *diff; + + cl_git_pass(git_diff_from_buffer( + &diff, content, strlen(content))); + git_diff_free(diff); +} + void test_diff_parse__invalid_patches_fails(void) { test_parse_invalid_diff(PATCH_CORRUPT_MISSING_NEW_FILE); diff --git a/tests/diff/patch.c b/tests/diff/patch.c index 7eb353627..d288bba58 100644 --- a/tests/diff/patch.c +++ b/tests/diff/patch.c @@ -4,7 +4,6 @@ #include "diff_helpers.h" #include "diff.h" #include "repository.h" -#include "buf_text.h" static git_repository *g_repo = NULL; diff --git a/tests/diff/rename.c b/tests/diff/rename.c index df32eebf2..bd25d29aa 100644 --- a/tests/diff/rename.c +++ b/tests/diff/rename.c @@ -1,6 +1,5 @@ #include "clar_libgit2.h" #include "diff_helpers.h" -#include "buf_text.h" static git_repository *g_repo = NULL; @@ -22,6 +21,8 @@ void test_diff_rename__cleanup(void) #define RENAME_MODIFICATION_COMMIT "19dd32dfb1520a64e5bbaae8dce6ef423dfa2f13" #define REWRITE_DELETE_COMMIT "84d8efa38af7ace2b302de0adbda16b1f1cd2e1b" #define DELETE_RENAME_COMMIT "be053a189b0bbde545e0a3f59ce00b46ad29ce0d" +#define BREAK_REWRITE_BASE_COMMIT "db98035f715427eef1f5e17f03e1801c05301e9e" +#define BREAK_REWRITE_COMMIT "7e7bfb88ba9bc65fd700fee1819cf1c317aafa56" /* * Renames repo has: @@ -513,7 +514,7 @@ void test_diff_rename__working_directory_changes(void) cl_git_pass( git_futils_readbuffer(&old_content, "renames/songof7cities.txt")); cl_git_pass( - git_buf_text_lf_to_crlf(&content, &old_content)); + git_buf_lf_to_crlf(&content, &old_content)); cl_git_pass( git_futils_writebuffer(&content, "renames/songof7cities.txt", 0, 0)); @@ -1978,3 +1979,56 @@ void test_diff_rename__delete_and_rename(void) git_tree_free(old_tree); git_tree_free(new_tree); } + +/* + * The break_rewrite branch contains a testcase reduced from + * a real-world scenario, rather than being "constructed" like + * the above tests seem to be. There are two commits layered + * on top of the repo's initial commit; the base commit which + * clears out the files from the initial commit and installs + * four files. And then there's the modification commit which + * mutates the files in such a way as to trigger the bug in + * libgit2. + * commit db98035f715427eef1f5e17f03e1801c05301e9e + * serving.txt (deleted) + * sevencities.txt (deleted) + * AAA (313 lines) + * BBB (314 lines) + * CCC (704 lines) + * DDD (314 lines, identical to BBB) + * commit 7e7bfb88ba9bc65fd700fee1819cf1c317aafa56 + * This deletes CCC and makes slight modifications + * to AAA, BBB, and DDD. The find_best_matches loop + * for git_diff_find_similar computes the following: + * CCC moved to AAA (similarity 91) + * CCC copied to AAA (similarity 91) + * DDD moved to BBB (similarity 52) + * CCC copied to BBB (similarity 90) + * BBB moved to DDD (similarity 52) + * CCC copied to DDD (similarity 90) + * The code to rewrite the diffs by resolving these + * copies/renames would resolve the BBB <-> DDD moves + * but then still leave BBB as a rename target for + * the deleted file CCC. Since the split flag on BBB + * was cleared, this would trigger an error. + */ +void test_diff_rename__break_rewrite(void) +{ + const char *old_sha = BREAK_REWRITE_BASE_COMMIT; + const char *new_sha = BREAK_REWRITE_COMMIT; + git_tree *old_tree, *new_tree; + git_diff *diff; + git_diff_find_options find_opts = GIT_DIFF_FIND_OPTIONS_INIT; + + old_tree = resolve_commit_oid_to_tree(g_repo, old_sha); + new_tree = resolve_commit_oid_to_tree(g_repo, new_sha); + + find_opts.flags = GIT_DIFF_FIND_RENAMES | GIT_DIFF_FIND_COPIES | GIT_DIFF_BREAK_REWRITES | GIT_DIFF_BREAK_REWRITES_FOR_RENAMES_ONLY; + + cl_git_pass(git_diff_tree_to_tree(&diff, g_repo, old_tree, new_tree, NULL)); + cl_git_pass(git_diff_find_similar(diff, &find_opts)); + + git_diff_free(diff); + git_tree_free(old_tree); + git_tree_free(new_tree); +} diff --git a/tests/diff/stats.c b/tests/diff/stats.c index 150355686..54572672c 100644 --- a/tests/diff/stats.c +++ b/tests/diff/stats.c @@ -298,9 +298,8 @@ void test_diff_stats__binary(void) { git_buf buf = GIT_BUF_INIT; const char *stat = - " binary.bin | Bin 3 -> 0 bytes\n" + " binary.bin | Bin 3 -> 5 bytes\n" " 1 file changed, 0 insertions(+), 0 deletions(-)\n"; - /* TODO: Actually 0 bytes here should be 5!. Seems like we don't load the new content for binary files? */ diff_stats_from_commit_oid( &_stats, "8d7523f6fcb2404257889abe0d96f093d9f524f9", false); @@ -343,3 +342,38 @@ void test_diff_stats__mode_change(void) cl_assert_equal_s(stat, git_buf_cstr(&buf)); git_buf_dispose(&buf); } + +void test_diff_stats__new_file(void) +{ + git_diff *diff; + git_buf buf = GIT_BUF_INIT; + + const char *input = + "---\n" + " Gurjeet Singh | 1 +\n" + " 1 file changed, 1 insertion(+)\n" + " create mode 100644 Gurjeet Singh\n" + "\n" + "diff --git a/Gurjeet Singh b/Gurjeet Singh\n" + "new file mode 100644\n" + "index 0000000..6d0ecfd\n" + "--- /dev/null\n" + "+++ b/Gurjeet Singh \n" + "@@ -0,0 +1 @@\n" + "+I'm about to try git send-email\n" + "-- \n" + "2.21.0\n"; + + const char *stat = + " Gurjeet Singh | 1 +\n" + " 1 file changed, 1 insertion(+)\n" + " create mode 100644 Gurjeet Singh\n"; + + cl_git_pass(git_diff_from_buffer(&diff, input, strlen(input))); + cl_git_pass(git_diff_get_stats(&_stats, diff)); + cl_git_pass(git_diff_stats_to_buf(&buf, _stats, GIT_DIFF_STATS_FULL | GIT_DIFF_STATS_INCLUDE_SUMMARY, 0)); + cl_assert_equal_s(stat, git_buf_cstr(&buf)); + + git_buf_dispose(&buf); + git_diff_free(diff); +} diff --git a/tests/diff/workdir.c b/tests/diff/workdir.c index f2404958e..00c52ff1b 100644 --- a/tests/diff/workdir.c +++ b/tests/diff/workdir.c @@ -2203,3 +2203,38 @@ void test_diff_workdir__order(void) git_diff_free(diff); git_tree_free(tree); } + +void test_diff_workdir__ignore_blank_lines(void) +{ + git_diff_options opts = GIT_DIFF_OPTIONS_INIT; + git_diff *diff; + git_patch *patch; + git_buf buf = GIT_BUF_INIT; + + g_repo = cl_git_sandbox_init("rebase"); + cl_git_rewritefile("rebase/gravy.txt", "GRAVY SOUP.\n\n\nGet eight pounds of coarse lean beef--wash it clean and lay it in your\n\npot, put in the same ingredients as for the shin soup, with the same\nquantity of water, and follow the process directed for that. Strain the\nsoup through a sieve, and serve it up clear, with nothing more than\ntoasted bread in it; two table-spoonsful of mushroom catsup will add a\nfine flavour to the soup!\n"); + + /* Perform the diff normally */ + cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts)); + cl_git_pass(git_patch_from_diff(&patch, diff, 0)); + cl_git_pass(git_patch_to_buf(&buf, patch)); + + cl_assert_equal_s("diff --git a/gravy.txt b/gravy.txt\nindex c4e6cca..3c617e6 100644\n--- a/gravy.txt\n+++ b/gravy.txt\n@@ -1,8 +1,10 @@\n GRAVY SOUP.\n \n+\n Get eight pounds of coarse lean beef--wash it clean and lay it in your\n+\n pot, put in the same ingredients as for the shin soup, with the same\n quantity of water, and follow the process directed for that. Strain the\n soup through a sieve, and serve it up clear, with nothing more than\n toasted bread in it; two table-spoonsful of mushroom catsup will add a\n-fine flavour to the soup.\n+fine flavour to the soup!\n", buf.ptr); + + git_buf_dispose(&buf); + git_patch_free(patch); + git_diff_free(diff); + + /* Perform the diff ignoring blank lines */ + opts.flags |= GIT_DIFF_IGNORE_BLANK_LINES; + + cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts)); + cl_git_pass(git_patch_from_diff(&patch, diff, 0)); + cl_git_pass(git_patch_to_buf(&buf, patch)); + + cl_assert_equal_s("diff --git a/gravy.txt b/gravy.txt\nindex c4e6cca..3c617e6 100644\n--- a/gravy.txt\n+++ b/gravy.txt\n@@ -5,4 +7,4 @@ pot, put in the same ingredients as for the shin soup, with the same\n quantity of water, and follow the process directed for that. Strain the\n soup through a sieve, and serve it up clear, with nothing more than\n toasted bread in it; two table-spoonsful of mushroom catsup will add a\n-fine flavour to the soup.\n+fine flavour to the soup!\n", buf.ptr); + + git_buf_dispose(&buf); + git_patch_free(patch); + git_diff_free(diff); +} diff --git a/tests/email/create.c b/tests/email/create.c new file mode 100644 index 000000000..ccf79c2aa --- /dev/null +++ b/tests/email/create.c @@ -0,0 +1,363 @@ +#include "clar.h" +#include "clar_libgit2.h" + +#include "buffer.h" +#include "diff_generate.h" + +static git_repository *repo; + +void test_email_create__initialize(void) +{ + repo = cl_git_sandbox_init("diff_format_email"); +} + +void test_email_create__cleanup(void) +{ + cl_git_sandbox_cleanup(); +} + +static void email_for_commit( + git_buf *out, + const char *commit_id, + git_email_create_options *opts) +{ + git_oid oid; + git_commit *commit = NULL; + git_diff *diff = NULL; + + git_oid_fromstr(&oid, commit_id); + + cl_git_pass(git_commit_lookup(&commit, repo, &oid)); + + cl_git_pass(git_email_create_from_commit(out, commit, opts)); + + git_diff_free(diff); + git_commit_free(commit); +} + +static void assert_email_match( + const char *expected, + const char *commit_id, + git_email_create_options *opts) +{ + git_buf buf = GIT_BUF_INIT; + + email_for_commit(&buf, commit_id, opts); + cl_assert_equal_s(expected, git_buf_cstr(&buf)); + + git_buf_dispose(&buf); +} + +static void assert_subject_match( + const char *expected, + const char *commit_id, + git_email_create_options *opts) +{ + git_buf buf = GIT_BUF_INIT; + const char *loc; + + email_for_commit(&buf, commit_id, opts); + + cl_assert((loc = strstr(buf.ptr, "\nSubject: ")) != NULL); + git_buf_consume(&buf, (loc + 10)); + git_buf_truncate_at_char(&buf, '\n'); + + cl_assert_equal_s(expected, git_buf_cstr(&buf)); + + git_buf_dispose(&buf); +} + +void test_email_create__commit(void) +{ + const char *expected = + "From 9264b96c6d104d0e07ae33d3007b6a48246c6f92 Mon Sep 17 00:00:00 2001\n" \ + "From: Jacques Germishuys <jacquesg@striata.com>\n" \ + "Date: Wed, 9 Apr 2014 20:57:01 +0200\n" \ + "Subject: [PATCH] Modify some content\n" \ + "\n" \ + "---\n" \ + " file1.txt | 8 +++++---\n" \ + " 1 file changed, 5 insertions(+), 3 deletions(-)\n" \ + "\n" \ + "diff --git a/file1.txt b/file1.txt\n" \ + "index 94aaae8..af8f41d 100644\n" \ + "--- a/file1.txt\n" \ + "+++ b/file1.txt\n" \ + "@@ -1,15 +1,17 @@\n" \ + " file1.txt\n" \ + " file1.txt\n" \ + "+_file1.txt_\n" \ + " file1.txt\n" \ + " file1.txt\n" \ + " file1.txt\n" \ + " file1.txt\n" \ + "+\n" \ + "+\n" \ + " file1.txt\n" \ + " file1.txt\n" \ + " file1.txt\n" \ + " file1.txt\n" \ + " file1.txt\n" \ + "-file1.txt\n" \ + "-file1.txt\n" \ + "-file1.txt\n" \ + "+_file1.txt_\n" \ + "+_file1.txt_\n" \ + " file1.txt\n" \ + "--\n" \ + "libgit2 " LIBGIT2_VERSION "\n" \ + "\n"; + + assert_email_match( + expected, "9264b96c6d104d0e07ae33d3007b6a48246c6f92", NULL); +} + +void test_email_create__rename(void) +{ + const char *expected = + "From 6e05acc5a5dab507d91a0a0cc0fb05a3dd98892d Mon Sep 17 00:00:00 2001\n" \ + "From: Jacques Germishuys <jacquesg@striata.com>\n" \ + "Date: Wed, 9 Apr 2014 21:15:56 +0200\n" \ + "Subject: [PATCH] Renamed file1.txt -> file1.txt.renamed\n" \ + "\n" \ + "---\n" \ + " file1.txt => file1.txt.renamed | 4 ++--\n" \ + " 1 file changed, 2 insertions(+), 2 deletions(-)\n" \ + "\n" \ + "diff --git a/file1.txt b/file1.txt.renamed\n" \ + "similarity index 86%\n" \ + "rename from file1.txt\n" \ + "rename to file1.txt.renamed\n" \ + "index af8f41d..a97157a 100644\n" \ + "--- a/file1.txt\n" \ + "+++ b/file1.txt.renamed\n" \ + "@@ -3,13 +3,13 @@ file1.txt\n" \ + " _file1.txt_\n" \ + " file1.txt\n" \ + " file1.txt\n" \ + "-file1.txt\n" \ + "+file1.txt_renamed\n" \ + " file1.txt\n" \ + " \n" \ + " \n" \ + " file1.txt\n" \ + " file1.txt\n" \ + "-file1.txt\n" \ + "+file1.txt_renamed\n" \ + " file1.txt\n" \ + " file1.txt\n" \ + " _file1.txt_\n" \ + "--\n" \ + "libgit2 " LIBGIT2_VERSION "\n" \ + "\n"; + + assert_email_match(expected, "6e05acc5a5dab507d91a0a0cc0fb05a3dd98892d", NULL); +} + +void test_email_create__rename_as_add_delete(void) +{ + const char *expected = + "From 6e05acc5a5dab507d91a0a0cc0fb05a3dd98892d Mon Sep 17 00:00:00 2001\n" \ + "From: Jacques Germishuys <jacquesg@striata.com>\n" \ + "Date: Wed, 9 Apr 2014 21:15:56 +0200\n" \ + "Subject: [PATCH] Renamed file1.txt -> file1.txt.renamed\n" \ + "\n" \ + "---\n" \ + " file1.txt | 17 -----------------\n" \ + " file1.txt.renamed | 17 +++++++++++++++++\n" \ + " 2 files changed, 17 insertions(+), 17 deletions(-)\n" \ + " delete mode 100644 file1.txt\n" \ + " create mode 100644 file1.txt.renamed\n" \ + "\n" \ + "diff --git a/file1.txt b/file1.txt\n" \ + "deleted file mode 100644\n" \ + "index af8f41d..0000000\n" \ + "--- a/file1.txt\n" \ + "+++ /dev/null\n" \ + "@@ -1,17 +0,0 @@\n" \ + "-file1.txt\n" \ + "-file1.txt\n" \ + "-_file1.txt_\n" \ + "-file1.txt\n" \ + "-file1.txt\n" \ + "-file1.txt\n" \ + "-file1.txt\n" \ + "-\n" \ + "-\n" \ + "-file1.txt\n" \ + "-file1.txt\n" \ + "-file1.txt\n" \ + "-file1.txt\n" \ + "-file1.txt\n" \ + "-_file1.txt_\n" \ + "-_file1.txt_\n" \ + "-file1.txt\n" \ + "diff --git a/file1.txt.renamed b/file1.txt.renamed\n" \ + "new file mode 100644\n" \ + "index 0000000..a97157a\n" \ + "--- /dev/null\n" \ + "+++ b/file1.txt.renamed\n" \ + "@@ -0,0 +1,17 @@\n" \ + "+file1.txt\n" \ + "+file1.txt\n" \ + "+_file1.txt_\n" \ + "+file1.txt\n" \ + "+file1.txt\n" \ + "+file1.txt_renamed\n" \ + "+file1.txt\n" \ + "+\n" \ + "+\n" \ + "+file1.txt\n" \ + "+file1.txt\n" \ + "+file1.txt_renamed\n" \ + "+file1.txt\n" \ + "+file1.txt\n" \ + "+_file1.txt_\n" \ + "+_file1.txt_\n" \ + "+file1.txt\n" \ + "--\n" \ + "libgit2 " LIBGIT2_VERSION "\n" \ + "\n"; + + git_email_create_options opts = GIT_EMAIL_CREATE_OPTIONS_INIT; + opts.flags |= GIT_EMAIL_CREATE_NO_RENAMES; + + assert_email_match(expected, "6e05acc5a5dab507d91a0a0cc0fb05a3dd98892d", &opts); +} + +void test_email_create__binary(void) +{ + const char *expected = + "From 8d7523f6fcb2404257889abe0d96f093d9f524f9 Mon Sep 17 00:00:00 2001\n" \ + "From: Jacques Germishuys <jacquesg@striata.com>\n" \ + "Date: Sun, 13 Apr 2014 18:10:18 +0200\n" \ + "Subject: [PATCH] Modified binary file\n" \ + "\n" \ + "---\n" \ + " binary.bin | Bin 3 -> 5 bytes\n" \ + " 1 file changed, 0 insertions(+), 0 deletions(-)\n" \ + "\n" \ + "diff --git a/binary.bin b/binary.bin\n" \ + "index bd474b2519cc15eab801ff851cc7d50f0dee49a1..9ac35ff15cd8864aeafd889e4826a3150f0b06c4 100644\n" \ + "GIT binary patch\n" \ + "literal 5\n" \ + "Mc${NkU}WL~000&M4gdfE\n" \ + "\n" \ + "literal 3\n" \ + "Kc${Nk-~s>u4FC%O\n" \ + "\n" \ + "--\n" \ + "libgit2 " LIBGIT2_VERSION "\n" \ + "\n"; + + assert_email_match(expected, "8d7523f6fcb2404257889abe0d96f093d9f524f9", NULL); +} + +void test_email_create__binary_not_included(void) +{ + const char *expected = + "From 8d7523f6fcb2404257889abe0d96f093d9f524f9 Mon Sep 17 00:00:00 2001\n" \ + "From: Jacques Germishuys <jacquesg@striata.com>\n" \ + "Date: Sun, 13 Apr 2014 18:10:18 +0200\n" \ + "Subject: [PATCH] Modified binary file\n" \ + "\n" \ + "---\n" \ + " binary.bin | Bin 3 -> 5 bytes\n" \ + " 1 file changed, 0 insertions(+), 0 deletions(-)\n" \ + "\n" \ + "diff --git a/binary.bin b/binary.bin\n" \ + "index bd474b2..9ac35ff 100644\n" \ + "Binary files a/binary.bin and b/binary.bin differ\n" \ + "--\n" \ + "libgit2 " LIBGIT2_VERSION "\n" \ + "\n"; + + git_email_create_options opts = GIT_EMAIL_CREATE_OPTIONS_INIT; + opts.diff_opts.flags &= ~GIT_DIFF_SHOW_BINARY; + + assert_email_match(expected, "8d7523f6fcb2404257889abe0d96f093d9f524f9", &opts); +} + +void test_email_create__custom_summary_and_body(void) +{ + const char *expected = "From 627e7e12d87e07a83fad5b6bfa25e86ead4a5270 Mon Sep 17 00:00:00 2001\n" \ + "From: Patrick Steinhardt <ps@pks.im>\n" \ + "Date: Tue, 24 Nov 2015 13:34:39 +0100\n" \ + "Subject: [PPPPPATCH 2/4] This is a subject\n" \ + "\n" \ + "Modify content of file3.txt by appending a new line. Make this\n" \ + "commit message somewhat longer to test behavior with newlines\n" \ + "embedded in the message body.\n" \ + "\n" \ + "Also test if new paragraphs are included correctly.\n" \ + "---\n" \ + " file3.txt | 1 +\n" \ + " 1 file changed, 1 insertion(+)\n" \ + "\n" \ + "diff --git a/file3.txt b/file3.txt\n" \ + "index 9a2d780..7309653 100644\n" \ + "--- a/file3.txt\n" \ + "+++ b/file3.txt\n" \ + "@@ -3,3 +3,4 @@ file3!\n" \ + " file3\n" \ + " file3\n" \ + " file3\n" \ + "+file3\n" \ + "--\n" \ + "libgit2 " LIBGIT2_VERSION "\n" \ + "\n"; + + const char *summary = "This is a subject\nwith\nnewlines"; + const char *body = "Modify content of file3.txt by appending a new line. Make this\n" \ + "commit message somewhat longer to test behavior with newlines\n" \ + "embedded in the message body.\n" \ + "\n" \ + "Also test if new paragraphs are included correctly."; + + git_oid oid; + git_commit *commit = NULL; + git_diff *diff = NULL; + git_buf buf = GIT_BUF_INIT; + git_email_create_options opts = GIT_EMAIL_CREATE_OPTIONS_INIT; + + opts.subject_prefix = "PPPPPATCH"; + + git_oid_fromstr(&oid, "627e7e12d87e07a83fad5b6bfa25e86ead4a5270"); + cl_git_pass(git_commit_lookup(&commit, repo, &oid)); + cl_git_pass(git_diff__commit(&diff, repo, commit, NULL)); + cl_git_pass(git_email_create_from_diff(&buf, diff, 2, 4, &oid, summary, body, git_commit_author(commit), &opts)); + + cl_assert_equal_s(expected, git_buf_cstr(&buf)); + + git_diff_free(diff); + git_commit_free(commit); + git_buf_dispose(&buf); +} + +void test_email_create__commit_subjects(void) +{ + git_email_create_options opts = GIT_EMAIL_CREATE_OPTIONS_INIT; + + assert_subject_match("[PATCH] Modify some content", "9264b96c6d104d0e07ae33d3007b6a48246c6f92", &opts); + + opts.reroll_number = 42; + assert_subject_match("[PATCH v42] Modify some content", "9264b96c6d104d0e07ae33d3007b6a48246c6f92", &opts); + + opts.flags |= GIT_EMAIL_CREATE_ALWAYS_NUMBER; + assert_subject_match("[PATCH v42 1/1] Modify some content", "9264b96c6d104d0e07ae33d3007b6a48246c6f92", &opts); + + opts.start_number = 9; + assert_subject_match("[PATCH v42 9/9] Modify some content", "9264b96c6d104d0e07ae33d3007b6a48246c6f92", &opts); + + opts.subject_prefix = ""; + assert_subject_match("[v42 9/9] Modify some content", "9264b96c6d104d0e07ae33d3007b6a48246c6f92", &opts); + + opts.reroll_number = 0; + assert_subject_match("[9/9] Modify some content", "9264b96c6d104d0e07ae33d3007b6a48246c6f92", &opts); + + opts.start_number = 0; + assert_subject_match("[1/1] Modify some content", "9264b96c6d104d0e07ae33d3007b6a48246c6f92", &opts); + + opts.flags = GIT_EMAIL_CREATE_OMIT_NUMBERS; + assert_subject_match("Modify some content", "9264b96c6d104d0e07ae33d3007b6a48246c6f92", &opts); +} diff --git a/tests/fetchhead/nonetwork.c b/tests/fetchhead/nonetwork.c index 6cea6d166..6881af40a 100644 --- a/tests/fetchhead/nonetwork.c +++ b/tests/fetchhead/nonetwork.c @@ -82,7 +82,7 @@ void test_fetchhead_nonetwork__write(void) int equals = 0; size_t i; - git_vector_init(&fetchhead_vector, 6, NULL); + cl_git_pass(git_vector_init(&fetchhead_vector, 6, NULL)); cl_set_cleanup(&cleanup_repository, "./test1"); cl_git_pass(git_repository_init(&g_repo, "./test1", 0)); @@ -319,6 +319,16 @@ static int assert_master_for_merge(const char *ref, const char *url, const git_o return 0; } +static int assert_none_for_merge(const char *ref, const char *url, const git_oid *id, unsigned int is_merge, void *data) +{ + GIT_UNUSED(ref); + GIT_UNUSED(url); + GIT_UNUSED(id); + GIT_UNUSED(data); + + return is_merge ? -1 : 0; +} + void test_fetchhead_nonetwork__unborn_with_upstream(void) { git_repository *repo; @@ -366,6 +376,25 @@ void test_fetchhead_nonetwork__fetch_into_repo_with_symrefs(void) cl_git_sandbox_cleanup(); } +void test_fetchhead_nonetwork__fetch_into_repo_with_invalid_head(void) +{ + git_remote *remote; + char *strings[] = { "refs/heads/*:refs/remotes/origin/*" }; + git_strarray refspecs = { strings, 1 }; + + cl_set_cleanup(&cleanup_repository, "./test1"); + cl_git_pass(git_repository_init(&g_repo, "./test1", 0)); + + /* HEAD pointing to nonexistent branch */ + cl_git_rewritefile("./test1/.git/HEAD", "ref: refs/heads/\n"); + + cl_git_pass(git_remote_create_anonymous(&remote, g_repo, cl_fixture("testrepo.git"))); + cl_git_pass(git_remote_fetch(remote, &refspecs, NULL, NULL)); + cl_git_pass(git_repository_fetchhead_foreach(g_repo, assert_none_for_merge, NULL)); + + git_remote_free(remote); +} + void test_fetchhead_nonetwork__quote_in_branch_name(void) { cl_set_cleanup(&cleanup_repository, "./test1"); diff --git a/tests/filter/bare.c b/tests/filter/bare.c index 430931ee8..8402638ce 100644 --- a/tests/filter/bare.c +++ b/tests/filter/bare.c @@ -10,7 +10,7 @@ void test_filter_bare__initialize(void) cl_git_pass(git_repository_open(&g_repo, "crlf.git")); filter_opts.flags |= GIT_BLOB_FILTER_NO_SYSTEM_ATTRIBUTES; - filter_opts.flags |= GIT_BLOB_FILTER_ATTTRIBUTES_FROM_HEAD; + filter_opts.flags |= GIT_BLOB_FILTER_ATTRIBUTES_FROM_HEAD; } void test_filter_bare__cleanup(void) @@ -132,3 +132,57 @@ void test_filter_bare__sanitizes(void) git_blob_free(blob); } +void test_filter_bare__from_specific_commit_one(void) +{ + git_blob_filter_options opts = GIT_BLOB_FILTER_OPTIONS_INIT; + git_blob *blob; + git_buf buf = { 0 }; + + opts.flags |= GIT_BLOB_FILTER_NO_SYSTEM_ATTRIBUTES; + opts.flags |= GIT_BLOB_FILTER_ATTRIBUTES_FROM_COMMIT; + cl_git_pass(git_oid_fromstr(&opts.attr_commit_id, "b8986fec0f7bde90f78ac72706e782d82f24f2f0")); + + cl_git_pass(git_revparse_single( + (git_object **)&blob, g_repo, "055c872")); /* ident */ + + cl_assert_equal_s("$Id$\n", git_blob_rawcontent(blob)); + + cl_git_pass(git_blob_filter(&buf, blob, "ident.bin", &opts)); + cl_assert_equal_s("$Id$\n", buf.ptr); + + cl_git_pass(git_blob_filter(&buf, blob, "ident.identlf", &opts)); + cl_assert_equal_s("$Id: 055c8729cdcc372500a08db659c045e16c4409fb $\n", buf.ptr); + + git_buf_dispose(&buf); + git_blob_free(blob); +} + +void test_filter_bare__from_specific_commit_with_no_attributes_file(void) +{ + git_blob_filter_options opts = GIT_BLOB_FILTER_OPTIONS_INIT; + git_blob *blob; + git_buf buf = { 0 }; + + opts.flags |= GIT_BLOB_FILTER_NO_SYSTEM_ATTRIBUTES; + opts.flags |= GIT_BLOB_FILTER_ATTRIBUTES_FROM_COMMIT; + cl_git_pass(git_oid_fromstr(&opts.attr_commit_id, "5afb6a14a864e30787857dd92af837e8cdd2cb1b")); + + cl_git_pass(git_revparse_single( + (git_object **)&blob, g_repo, "799770d")); /* all-lf */ + + cl_assert_equal_s(ALL_LF_TEXT_RAW, git_blob_rawcontent(blob)); + + cl_git_pass(git_blob_filter(&buf, blob, "file.bin", &opts)); + cl_assert_equal_s(ALL_LF_TEXT_RAW, buf.ptr); + + /* we never convert CRLF -> LF on platforms that have LF */ + cl_git_pass(git_blob_filter(&buf, blob, "file.lf", &opts)); + cl_assert_equal_s(ALL_LF_TEXT_RAW, buf.ptr); + + /* we never convert CRLF -> LF on platforms that have LF */ + cl_git_pass(git_blob_filter(&buf, blob, "file.crlf", &opts)); + cl_assert_equal_s(ALL_LF_TEXT_RAW, buf.ptr); + + git_buf_dispose(&buf); + git_blob_free(blob); +} diff --git a/tests/filter/crlf.c b/tests/filter/crlf.c index a266005d4..bc9c7f289 100644 --- a/tests/filter/crlf.c +++ b/tests/filter/crlf.c @@ -23,7 +23,9 @@ void test_filter_crlf__to_worktree(void) { git_filter_list *fl; git_filter *crlf; - git_buf in = { 0 }, out = { 0 }; + git_buf out = GIT_BUF_INIT; + const char *in; + size_t in_len; cl_git_pass(git_filter_list_new( &fl, g_repo, GIT_FILTER_TO_WORKTREE, 0)); @@ -33,10 +35,10 @@ void test_filter_crlf__to_worktree(void) cl_git_pass(git_filter_list_push(fl, crlf, NULL)); - in.ptr = "Some text\nRight here\n"; - in.size = strlen(in.ptr); + in = "Some text\nRight here\n"; + in_len = strlen(in); - cl_git_pass(git_filter_list_apply_to_data(&out, fl, &in)); + cl_git_pass(git_filter_list_apply_to_buffer(&out, fl, in, in_len)); cl_assert_equal_s("Some text\r\nRight here\r\n", out.ptr); @@ -48,7 +50,9 @@ void test_filter_crlf__to_odb(void) { git_filter_list *fl; git_filter *crlf; - git_buf in = { 0 }, out = { 0 }; + git_buf out = GIT_BUF_INIT; + const char *in; + size_t in_len; cl_git_pass(git_filter_list_new( &fl, g_repo, GIT_FILTER_TO_ODB, 0)); @@ -58,10 +62,10 @@ void test_filter_crlf__to_odb(void) cl_git_pass(git_filter_list_push(fl, crlf, NULL)); - in.ptr = "Some text\r\nRight here\r\n"; - in.size = strlen(in.ptr); + in = "Some text\r\nRight here\r\n"; + in_len = strlen(in); - cl_git_pass(git_filter_list_apply_to_data(&out, fl, &in)); + cl_git_pass(git_filter_list_apply_to_buffer(&out, fl, in, in_len)); cl_assert_equal_s("Some text\nRight here\n", out.ptr); @@ -73,7 +77,9 @@ void test_filter_crlf__with_safecrlf(void) { git_filter_list *fl; git_filter *crlf; - git_buf in = {0}, out = GIT_BUF_INIT; + git_buf out = GIT_BUF_INIT; + const char *in; + size_t in_len; cl_repo_set_bool(g_repo, "core.safecrlf", true); @@ -86,31 +92,31 @@ void test_filter_crlf__with_safecrlf(void) cl_git_pass(git_filter_list_push(fl, crlf, NULL)); /* Normalized \r\n succeeds with safecrlf */ - in.ptr = "Normal\r\nCRLF\r\nline-endings.\r\n"; - in.size = strlen(in.ptr); + in = "Normal\r\nCRLF\r\nline-endings.\r\n"; + in_len = strlen(in); - cl_git_pass(git_filter_list_apply_to_data(&out, fl, &in)); + cl_git_pass(git_filter_list_apply_to_buffer(&out, fl, in, in_len)); cl_assert_equal_s("Normal\nCRLF\nline-endings.\n", out.ptr); /* Mix of line endings fails with safecrlf */ - in.ptr = "Mixed\nup\r\nLF\nand\r\nCRLF\nline-endings.\r\n"; - in.size = strlen(in.ptr); + in = "Mixed\nup\r\nLF\nand\r\nCRLF\nline-endings.\r\n"; + in_len = strlen(in); - cl_git_fail(git_filter_list_apply_to_data(&out, fl, &in)); + cl_git_fail(git_filter_list_apply_to_buffer(&out, fl, in, in_len)); cl_assert_equal_i(git_error_last()->klass, GIT_ERROR_FILTER); /* Normalized \n fails for autocrlf=true when safecrlf=true */ - in.ptr = "Normal\nLF\nonly\nline-endings.\n"; - in.size = strlen(in.ptr); + in = "Normal\nLF\nonly\nline-endings.\n"; + in_len = strlen(in); - cl_git_fail(git_filter_list_apply_to_data(&out, fl, &in)); + cl_git_fail(git_filter_list_apply_to_buffer(&out, fl, in, in_len)); cl_assert_equal_i(git_error_last()->klass, GIT_ERROR_FILTER); /* String with \r but without \r\n does not fail with safecrlf */ - in.ptr = "Normal\nCR only\rand some more\nline-endings.\n"; - in.size = strlen(in.ptr); + in = "Normal\nCR only\rand some more\nline-endings.\n"; + in_len = strlen(in); - cl_git_pass(git_filter_list_apply_to_data(&out, fl, &in)); + cl_git_pass(git_filter_list_apply_to_buffer(&out, fl, in, in_len)); cl_assert_equal_s("Normal\nCR only\rand some more\nline-endings.\n", out.ptr); git_filter_list_free(fl); @@ -121,7 +127,9 @@ void test_filter_crlf__with_safecrlf_and_unsafe_allowed(void) { git_filter_list *fl; git_filter *crlf; - git_buf in = {0}, out = GIT_BUF_INIT; + git_buf out = GIT_BUF_INIT; + const char *in; + size_t in_len; cl_repo_set_bool(g_repo, "core.safecrlf", true); @@ -134,25 +142,25 @@ void test_filter_crlf__with_safecrlf_and_unsafe_allowed(void) cl_git_pass(git_filter_list_push(fl, crlf, NULL)); /* Normalized \r\n succeeds with safecrlf */ - in.ptr = "Normal\r\nCRLF\r\nline-endings.\r\n"; - in.size = strlen(in.ptr); + in = "Normal\r\nCRLF\r\nline-endings.\r\n"; + in_len = strlen(in); - cl_git_pass(git_filter_list_apply_to_data(&out, fl, &in)); + cl_git_pass(git_filter_list_apply_to_buffer(&out, fl, in, in_len)); cl_assert_equal_s("Normal\nCRLF\nline-endings.\n", out.ptr); /* Mix of line endings fails with safecrlf, but allowed to pass */ - in.ptr = "Mixed\nup\r\nLF\nand\r\nCRLF\nline-endings.\r\n"; - in.size = strlen(in.ptr); + in = "Mixed\nup\r\nLF\nand\r\nCRLF\nline-endings.\r\n"; + in_len = strlen(in); - cl_git_pass(git_filter_list_apply_to_data(&out, fl, &in)); + cl_git_pass(git_filter_list_apply_to_buffer(&out, fl, in, in_len)); /* TODO: check for warning */ cl_assert_equal_s("Mixed\nup\nLF\nand\nCRLF\nline-endings.\n", out.ptr); /* Normalized \n fails with safecrlf, but allowed to pass */ - in.ptr = "Normal\nLF\nonly\nline-endings.\n"; - in.size = strlen(in.ptr); + in = "Normal\nLF\nonly\nline-endings.\n"; + in_len = strlen(in); - cl_git_pass(git_filter_list_apply_to_data(&out, fl, &in)); + cl_git_pass(git_filter_list_apply_to_buffer(&out, fl, in, in_len)); /* TODO: check for warning */ cl_assert_equal_s("Normal\nLF\nonly\nline-endings.\n", out.ptr); @@ -164,7 +172,9 @@ void test_filter_crlf__no_safecrlf(void) { git_filter_list *fl; git_filter *crlf; - git_buf in = {0}, out = GIT_BUF_INIT; + git_buf out = GIT_BUF_INIT; + const char *in; + size_t in_len; cl_git_pass(git_filter_list_new( &fl, g_repo, GIT_FILTER_TO_ODB, 0)); @@ -175,24 +185,24 @@ void test_filter_crlf__no_safecrlf(void) cl_git_pass(git_filter_list_push(fl, crlf, NULL)); /* Normalized \r\n succeeds with safecrlf */ - in.ptr = "Normal\r\nCRLF\r\nline-endings.\r\n"; - in.size = strlen(in.ptr); + in = "Normal\r\nCRLF\r\nline-endings.\r\n"; + in_len = strlen(in); - cl_git_pass(git_filter_list_apply_to_data(&out, fl, &in)); + cl_git_pass(git_filter_list_apply_to_buffer(&out, fl, in, in_len)); cl_assert_equal_s("Normal\nCRLF\nline-endings.\n", out.ptr); /* Mix of line endings fails with safecrlf */ - in.ptr = "Mixed\nup\r\nLF\nand\r\nCRLF\nline-endings.\r\n"; - in.size = strlen(in.ptr); + in = "Mixed\nup\r\nLF\nand\r\nCRLF\nline-endings.\r\n"; + in_len = strlen(in); - cl_git_pass(git_filter_list_apply_to_data(&out, fl, &in)); + cl_git_pass(git_filter_list_apply_to_buffer(&out, fl, in, in_len)); cl_assert_equal_s("Mixed\nup\nLF\nand\nCRLF\nline-endings.\n", out.ptr); /* Normalized \n fails with safecrlf */ - in.ptr = "Normal\nLF\nonly\nline-endings.\n"; - in.size = strlen(in.ptr); + in = "Normal\nLF\nonly\nline-endings.\n"; + in_len = strlen(in); - cl_git_pass(git_filter_list_apply_to_data(&out, fl, &in)); + cl_git_pass(git_filter_list_apply_to_buffer(&out, fl, in, in_len)); cl_assert_equal_s("Normal\nLF\nonly\nline-endings.\n", out.ptr); git_filter_list_free(fl); @@ -203,7 +213,9 @@ void test_filter_crlf__safecrlf_warn(void) { git_filter_list *fl; git_filter *crlf; - git_buf in = {0}, out = GIT_BUF_INIT; + git_buf out = GIT_BUF_INIT; + const char *in; + size_t in_len; cl_repo_set_string(g_repo, "core.safecrlf", "warn"); @@ -216,26 +228,26 @@ void test_filter_crlf__safecrlf_warn(void) cl_git_pass(git_filter_list_push(fl, crlf, NULL)); /* Normalized \r\n succeeds with safecrlf=warn */ - in.ptr = "Normal\r\nCRLF\r\nline-endings.\r\n"; - in.size = strlen(in.ptr); + in = "Normal\r\nCRLF\r\nline-endings.\r\n"; + in_len = strlen(in); - cl_git_pass(git_filter_list_apply_to_data(&out, fl, &in)); + cl_git_pass(git_filter_list_apply_to_buffer(&out, fl, in, in_len)); cl_assert_equal_s("Normal\nCRLF\nline-endings.\n", out.ptr); /* Mix of line endings succeeds with safecrlf=warn */ - in.ptr = "Mixed\nup\r\nLF\nand\r\nCRLF\nline-endings.\r\n"; - in.size = strlen(in.ptr); + in = "Mixed\nup\r\nLF\nand\r\nCRLF\nline-endings.\r\n"; + in_len = strlen(in); - cl_git_pass(git_filter_list_apply_to_data(&out, fl, &in)); + cl_git_pass(git_filter_list_apply_to_buffer(&out, fl, in, in_len)); /* TODO: check for warning */ cl_assert_equal_s("Mixed\nup\nLF\nand\nCRLF\nline-endings.\n", out.ptr); /* Normalized \n is reversible, so does not fail with safecrlf=warn */ - in.ptr = "Normal\nLF\nonly\nline-endings.\n"; - in.size = strlen(in.ptr); + in = "Normal\nLF\nonly\nline-endings.\n"; + in_len = strlen(in); - cl_git_pass(git_filter_list_apply_to_data(&out, fl, &in)); - cl_assert_equal_s(in.ptr, out.ptr); + cl_git_pass(git_filter_list_apply_to_buffer(&out, fl, in, in_len)); + cl_assert_equal_s(in, out.ptr); git_filter_list_free(fl); git_buf_dispose(&out); diff --git a/tests/filter/custom.c b/tests/filter/custom.c index fe2025fc2..57cef33ce 100644 --- a/tests/filter/custom.c +++ b/tests/filter/custom.c @@ -2,7 +2,6 @@ #include "posix.h" #include "blob.h" #include "filter.h" -#include "buf_text.h" #include "git2/sys/filter.h" #include "git2/sys/repository.h" #include "custom_helpers.h" @@ -95,13 +94,17 @@ static void register_custom_filters(void) void test_filter_custom__to_odb(void) { git_filter_list *fl; - git_buf out = { 0 }; - git_buf in = GIT_BUF_INIT_CONST(workdir_data, strlen(workdir_data)); + git_buf out = GIT_BUF_INIT; + const char *in; + size_t in_len; cl_git_pass(git_filter_list_load( &fl, g_repo, NULL, "herofile", GIT_FILTER_TO_ODB, 0)); - cl_git_pass(git_filter_list_apply_to_data(&out, fl, &in)); + in = workdir_data; + in_len = strlen(workdir_data); + + cl_git_pass(git_filter_list_apply_to_buffer(&out, fl, in, in_len)); cl_assert_equal_i(BITFLIPPED_AND_REVERSED_DATA_LEN, out.size); @@ -115,14 +118,17 @@ void test_filter_custom__to_odb(void) void test_filter_custom__to_workdir(void) { git_filter_list *fl; - git_buf out = { 0 }; - git_buf in = GIT_BUF_INIT_CONST( - bitflipped_and_reversed_data, BITFLIPPED_AND_REVERSED_DATA_LEN); + git_buf out = GIT_BUF_INIT; + const char *in; + size_t in_len; cl_git_pass(git_filter_list_load( &fl, g_repo, NULL, "herofile", GIT_FILTER_TO_WORKTREE, 0)); - cl_git_pass(git_filter_list_apply_to_data(&out, fl, &in)); + in = (char *)bitflipped_and_reversed_data; + in_len = BITFLIPPED_AND_REVERSED_DATA_LEN; + + cl_git_pass(git_filter_list_apply_to_buffer(&out, fl, in, in_len)); cl_assert_equal_i(strlen(workdir_data), out.size); @@ -246,12 +252,16 @@ void test_filter_custom__erroneous_filter_fails(void) { git_filter_list *filters; git_buf out = GIT_BUF_INIT; - git_buf in = GIT_BUF_INIT_CONST(workdir_data, strlen(workdir_data)); + const char *in; + size_t in_len; cl_git_pass(git_filter_list_load( &filters, g_repo, NULL, "villain", GIT_FILTER_TO_WORKTREE, 0)); - cl_git_fail(git_filter_list_apply_to_data(&out, filters, &in)); + in = workdir_data; + in_len = strlen(workdir_data); + + cl_git_fail(git_filter_list_apply_to_buffer(&out, filters, in, in_len)); git_filter_list_free(filters); git_buf_dispose(&out); diff --git a/tests/filter/custom_helpers.c b/tests/filter/custom_helpers.c index d7f2afe7a..ee3b6353b 100644 --- a/tests/filter/custom_helpers.c +++ b/tests/filter/custom_helpers.c @@ -1,7 +1,6 @@ #include "clar_libgit2.h" #include "posix.h" #include "filter.h" -#include "buf_text.h" #include "git2/sys/filter.h" #define VERY_SECURE_ENCRYPTION(b) ((b) ^ 0xff) @@ -38,6 +37,17 @@ int bitflip_filter_apply( return 0; } +static int bitflip_filter_stream( + git_writestream **out, + git_filter *self, + void **payload, + const git_filter_source *src, + git_writestream *next) +{ + return git_filter_buffered_stream_new(out, + self, bitflip_filter_apply, NULL, payload, src, next); +} + static void bitflip_filter_free(git_filter *f) { git__free(f); @@ -51,7 +61,7 @@ git_filter *create_bitflip_filter(void) filter->version = GIT_FILTER_VERSION; filter->attributes = "+bitflip"; filter->shutdown = bitflip_filter_free; - filter->apply = bitflip_filter_apply; + filter->stream = bitflip_filter_stream; return filter; } @@ -89,6 +99,17 @@ int reverse_filter_apply( return 0; } +static int reverse_filter_stream( + git_writestream **out, + git_filter *self, + void **payload, + const git_filter_source *src, + git_writestream *next) +{ + return git_filter_buffered_stream_new(out, + self, reverse_filter_apply, NULL, payload, src, next); +} + static void reverse_filter_free(git_filter *f) { git__free(f); @@ -102,7 +123,7 @@ git_filter *create_reverse_filter(const char *attrs) filter->version = GIT_FILTER_VERSION; filter->attributes = attrs; filter->shutdown = reverse_filter_free; - filter->apply = reverse_filter_apply; + filter->stream = reverse_filter_stream; return filter; } diff --git a/tests/filter/stream.c b/tests/filter/stream.c index 226092c3f..b6a4c3ca1 100644 --- a/tests/filter/stream.c +++ b/tests/filter/stream.c @@ -2,7 +2,6 @@ #include "posix.h" #include "blob.h" #include "filter.h" -#include "buf_text.h" #include "git2/sys/filter.h" #include "git2/sys/repository.h" diff --git a/tests/filter/wildcard.c b/tests/filter/wildcard.c index 3c25ea266..0c9c13b1e 100644 --- a/tests/filter/wildcard.c +++ b/tests/filter/wildcard.c @@ -2,7 +2,6 @@ #include "posix.h" #include "blob.h" #include "filter.h" -#include "buf_text.h" #include "git2/sys/filter.h" #include "git2/sys/repository.h" #include "custom_helpers.h" @@ -94,6 +93,17 @@ static int wildcard_filter_apply( return GIT_PASSTHROUGH; } +static int wildcard_filter_stream( + git_writestream **out, + git_filter *self, + void **payload, + const git_filter_source *src, + git_writestream *next) +{ + return git_filter_buffered_stream_new(out, + self, wildcard_filter_apply, NULL, payload, src, next); +} + static void wildcard_filter_cleanup(git_filter *self, void *payload) { GIT_UNUSED(self); @@ -113,7 +123,7 @@ static git_filter *create_wildcard_filter(void) filter->version = GIT_FILTER_VERSION; filter->attributes = "filter=*"; filter->check = wildcard_filter_check; - filter->apply = wildcard_filter_apply; + filter->stream = wildcard_filter_stream; filter->cleanup = wildcard_filter_cleanup; filter->shutdown = wildcard_filter_free; @@ -123,13 +133,12 @@ static git_filter *create_wildcard_filter(void) void test_filter_wildcard__reverse(void) { git_filter_list *fl; - git_buf in = GIT_BUF_INIT, out = GIT_BUF_INIT; + git_buf out = GIT_BUF_INIT; cl_git_pass(git_filter_list_load( &fl, g_repo, NULL, "hero-reverse-foo", GIT_FILTER_TO_ODB, 0)); - cl_git_pass(git_buf_put(&in, (char *)input, DATA_LEN)); - cl_git_pass(git_filter_list_apply_to_data(&out, fl, &in)); + cl_git_pass(git_filter_list_apply_to_buffer(&out, fl, (char *)input, DATA_LEN)); cl_assert_equal_i(DATA_LEN, out.size); @@ -138,19 +147,17 @@ void test_filter_wildcard__reverse(void) git_filter_list_free(fl); git_buf_dispose(&out); - git_buf_dispose(&in); } void test_filter_wildcard__flip(void) { git_filter_list *fl; - git_buf in = GIT_BUF_INIT, out = GIT_BUF_INIT; + git_buf out = GIT_BUF_INIT; cl_git_pass(git_filter_list_load( &fl, g_repo, NULL, "hero-flip-foo", GIT_FILTER_TO_ODB, 0)); - cl_git_pass(git_buf_put(&in, (char *)input, DATA_LEN)); - cl_git_pass(git_filter_list_apply_to_data(&out, fl, &in)); + cl_git_pass(git_filter_list_apply_to_buffer(&out, fl, (char *)input, DATA_LEN)); cl_assert_equal_i(DATA_LEN, out.size); @@ -159,19 +166,17 @@ void test_filter_wildcard__flip(void) git_filter_list_free(fl); git_buf_dispose(&out); - git_buf_dispose(&in); } void test_filter_wildcard__none(void) { git_filter_list *fl; - git_buf in = GIT_BUF_INIT, out = GIT_BUF_INIT; + git_buf out = GIT_BUF_INIT; cl_git_pass(git_filter_list_load( &fl, g_repo, NULL, "none-foo", GIT_FILTER_TO_ODB, 0)); - cl_git_pass(git_buf_put(&in, (char *)input, DATA_LEN)); - cl_git_pass(git_filter_list_apply_to_data(&out, fl, &in)); + cl_git_pass(git_filter_list_apply_to_buffer(&out, fl, (char *)input, DATA_LEN)); cl_assert_equal_i(DATA_LEN, out.size); @@ -180,5 +185,4 @@ void test_filter_wildcard__none(void) git_filter_list_free(fl); git_buf_dispose(&out); - git_buf_dispose(&in); } diff --git a/tests/graph/commit_graph.c b/tests/graph/commit_graph.c new file mode 100644 index 000000000..5926dca6f --- /dev/null +++ b/tests/graph/commit_graph.c @@ -0,0 +1,125 @@ +#include "clar_libgit2.h" + +#include <git2.h> +#include <git2/sys/commit_graph.h> + +#include "commit_graph.h" +#include "futils.h" + +void test_graph_commit_graph__parse(void) +{ + git_repository *repo; + struct git_commit_graph_file *file; + struct git_commit_graph_entry e, parent; + git_oid id; + git_buf commit_graph_path = GIT_BUF_INIT; + + cl_git_pass(git_repository_open(&repo, cl_fixture("testrepo.git"))); + cl_git_pass(git_buf_joinpath(&commit_graph_path, git_repository_path(repo), "objects/info/commit-graph")); + cl_git_pass(git_commit_graph_file_open(&file, git_buf_cstr(&commit_graph_path))); + cl_assert_equal_i(git_commit_graph_file_needs_refresh(file, git_buf_cstr(&commit_graph_path)), 0); + + cl_git_pass(git_oid_fromstr(&id, "5001298e0c09ad9c34e4249bc5801c75e9754fa5")); + cl_git_pass(git_commit_graph_entry_find(&e, file, &id, GIT_OID_HEXSZ)); + cl_assert_equal_oid(&e.sha1, &id); + cl_git_pass(git_oid_fromstr(&id, "418382dff1ffb8bdfba833f4d8bbcde58b1e7f47")); + cl_assert_equal_oid(&e.tree_oid, &id); + cl_assert_equal_i(e.generation, 1); + cl_assert_equal_i(e.commit_time, UINT64_C(1273610423)); + cl_assert_equal_i(e.parent_count, 0); + + cl_git_pass(git_oid_fromstr(&id, "be3563ae3f795b2b4353bcce3a527ad0a4f7f644")); + cl_git_pass(git_commit_graph_entry_find(&e, file, &id, GIT_OID_HEXSZ)); + cl_assert_equal_oid(&e.sha1, &id); + cl_assert_equal_i(e.generation, 5); + cl_assert_equal_i(e.commit_time, UINT64_C(1274813907)); + cl_assert_equal_i(e.parent_count, 2); + + cl_git_pass(git_oid_fromstr(&id, "9fd738e8f7967c078dceed8190330fc8648ee56a")); + cl_git_pass(git_commit_graph_entry_parent(&parent, file, &e, 0)); + cl_assert_equal_oid(&parent.sha1, &id); + cl_assert_equal_i(parent.generation, 4); + + cl_git_pass(git_oid_fromstr(&id, "c47800c7266a2be04c571c04d5a6614691ea99bd")); + cl_git_pass(git_commit_graph_entry_parent(&parent, file, &e, 1)); + cl_assert_equal_oid(&parent.sha1, &id); + cl_assert_equal_i(parent.generation, 3); + + git_commit_graph_file_free(file); + git_repository_free(repo); + git_buf_dispose(&commit_graph_path); +} + +void test_graph_commit_graph__parse_octopus_merge(void) +{ + git_repository *repo; + struct git_commit_graph_file *file; + struct git_commit_graph_entry e, parent; + git_oid id; + git_buf commit_graph_path = GIT_BUF_INIT; + + cl_git_pass(git_repository_open(&repo, cl_fixture("merge-recursive/.gitted"))); + cl_git_pass(git_buf_joinpath(&commit_graph_path, git_repository_path(repo), "objects/info/commit-graph")); + cl_git_pass(git_commit_graph_file_open(&file, git_buf_cstr(&commit_graph_path))); + + cl_git_pass(git_oid_fromstr(&id, "d71c24b3b113fd1d1909998c5bfe33b86a65ee03")); + cl_git_pass(git_commit_graph_entry_find(&e, file, &id, GIT_OID_HEXSZ)); + cl_assert_equal_oid(&e.sha1, &id); + cl_git_pass(git_oid_fromstr(&id, "348f16ffaeb73f319a75cec5b16a0a47d2d5e27c")); + cl_assert_equal_oid(&e.tree_oid, &id); + cl_assert_equal_i(e.generation, 7); + cl_assert_equal_i(e.commit_time, UINT64_C(1447083009)); + cl_assert_equal_i(e.parent_count, 3); + + cl_git_pass(git_oid_fromstr(&id, "ad2ace9e15f66b3d1138922e6ffdc3ea3f967fa6")); + cl_git_pass(git_commit_graph_entry_parent(&parent, file, &e, 0)); + cl_assert_equal_oid(&parent.sha1, &id); + cl_assert_equal_i(parent.generation, 6); + + cl_git_pass(git_oid_fromstr(&id, "483065df53c0f4a02cdc6b2910b05d388fc17ffb")); + cl_git_pass(git_commit_graph_entry_parent(&parent, file, &e, 1)); + cl_assert_equal_oid(&parent.sha1, &id); + cl_assert_equal_i(parent.generation, 2); + + cl_git_pass(git_oid_fromstr(&id, "815b5a1c80ca749d705c7aa0cb294a00cbedd340")); + cl_git_pass(git_commit_graph_entry_parent(&parent, file, &e, 2)); + cl_assert_equal_oid(&parent.sha1, &id); + cl_assert_equal_i(parent.generation, 6); + + git_commit_graph_file_free(file); + git_repository_free(repo); + git_buf_dispose(&commit_graph_path); +} + +void test_graph_commit_graph__writer(void) +{ + git_repository *repo; + git_commit_graph_writer *w = NULL; + git_revwalk *walk; + git_commit_graph_writer_options opts = GIT_COMMIT_GRAPH_WRITER_OPTIONS_INIT; + git_buf cgraph = GIT_BUF_INIT, expected_cgraph = GIT_BUF_INIT, path = GIT_BUF_INIT; + + cl_git_pass(git_repository_open(&repo, cl_fixture("testrepo.git"))); + + cl_git_pass(git_buf_joinpath(&path, git_repository_path(repo), "objects/info")); + cl_git_pass(git_commit_graph_writer_new(&w, git_buf_cstr(&path))); + + /* This is equivalent to `git commit-graph write --reachable`. */ + cl_git_pass(git_revwalk_new(&walk, repo)); + cl_git_pass(git_revwalk_push_glob(walk, "refs/*")); + cl_git_pass(git_commit_graph_writer_add_revwalk(w, walk)); + git_revwalk_free(walk); + + cl_git_pass(git_commit_graph_writer_dump(&cgraph, w, &opts)); + cl_git_pass(git_buf_joinpath(&path, git_repository_path(repo), "objects/info/commit-graph")); + cl_git_pass(git_futils_readbuffer(&expected_cgraph, git_buf_cstr(&path))); + + cl_assert_equal_i(git_buf_len(&cgraph), git_buf_len(&expected_cgraph)); + cl_assert_equal_i(memcmp(git_buf_cstr(&cgraph), git_buf_cstr(&expected_cgraph), git_buf_len(&cgraph)), 0); + + git_buf_dispose(&cgraph); + git_buf_dispose(&expected_cgraph); + git_buf_dispose(&path); + git_commit_graph_writer_free(w); + git_repository_free(repo); +} diff --git a/tests/graph/reachable_from_any.c b/tests/graph/reachable_from_any.c new file mode 100644 index 000000000..5c8416499 --- /dev/null +++ b/tests/graph/reachable_from_any.c @@ -0,0 +1,236 @@ +#include "clar_libgit2.h" + +#include <git2.h> + +#include "commit_graph.h" +#include "bitvec.h" +#include "vector.h" + +static git_repository *repo; + +#define TEST_REPO_PATH "merge-recursive" + +void test_graph_reachable_from_any__initialize(void) +{ + git_oid oid; + git_commit *commit; + + repo = cl_git_sandbox_init(TEST_REPO_PATH); + + git_oid_fromstr(&oid, "539bd011c4822c560c1d17cab095006b7a10f707"); + cl_git_pass(git_commit_lookup(&commit, repo, &oid)); + cl_git_pass(git_reset(repo, (git_object *)commit, GIT_RESET_HARD, NULL)); + git_commit_free(commit); +} + +void test_graph_reachable_from_any__cleanup(void) +{ + cl_git_sandbox_cleanup(); +} + +void test_graph_reachable_from_any__returns_correct_result(void) +{ + git_object *branchA1, *branchA2, *branchB1, *branchB2, *branchC1, *branchC2, *branchH1, + *branchH2; + git_oid descendants[7]; + + cl_git_pass(git_revparse_single(&branchA1, repo, "branchA-1")); + cl_git_pass(git_revparse_single(&branchA2, repo, "branchA-2")); + cl_git_pass(git_revparse_single(&branchB1, repo, "branchB-1")); + cl_git_pass(git_revparse_single(&branchB2, repo, "branchB-2")); + cl_git_pass(git_revparse_single(&branchC1, repo, "branchC-1")); + cl_git_pass(git_revparse_single(&branchC2, repo, "branchC-2")); + cl_git_pass(git_revparse_single(&branchH1, repo, "branchH-1")); + cl_git_pass(git_revparse_single(&branchH2, repo, "branchH-2")); + + cl_assert_equal_i( + git_graph_reachable_from_any( + repo, git_object_id(branchH1), git_object_id(branchA1), 1), + 0); + cl_assert_equal_i( + git_graph_reachable_from_any( + repo, git_object_id(branchH1), git_object_id(branchA2), 1), + 0); + + cl_git_pass(git_oid_cpy(&descendants[0], git_object_id(branchA1))); + cl_git_pass(git_oid_cpy(&descendants[1], git_object_id(branchA2))); + cl_git_pass(git_oid_cpy(&descendants[2], git_object_id(branchB1))); + cl_git_pass(git_oid_cpy(&descendants[3], git_object_id(branchB2))); + cl_git_pass(git_oid_cpy(&descendants[4], git_object_id(branchC1))); + cl_git_pass(git_oid_cpy(&descendants[5], git_object_id(branchC2))); + cl_git_pass(git_oid_cpy(&descendants[6], git_object_id(branchH2))); + cl_assert_equal_i( + git_graph_reachable_from_any(repo, git_object_id(branchH2), descendants, 6), + 0); + cl_assert_equal_i( + git_graph_reachable_from_any(repo, git_object_id(branchH2), descendants, 7), + 1); + + git_object_free(branchA1); + git_object_free(branchA2); + git_object_free(branchB1); + git_object_free(branchB2); + git_object_free(branchC1); + git_object_free(branchC2); + git_object_free(branchH1); + git_object_free(branchH2); +} + +struct exhaustive_state { + git_odb *db; + git_vector commits; +}; + +/** Get all commits from the repository. */ +static int exhaustive_commits(const git_oid *id, void *payload) +{ + struct exhaustive_state *mc = (struct exhaustive_state *)payload; + size_t header_len; + git_object_t header_type; + int error = 0; + + error = git_odb_read_header(&header_len, &header_type, mc->db, id); + if (error < 0) + return error; + + if (header_type == GIT_OBJECT_COMMIT) { + git_commit *commit = NULL; + + cl_git_pass(git_commit_lookup(&commit, repo, id)); + cl_git_pass(git_vector_insert(&mc->commits, commit)); + } + + return 0; +} + +/** Compare the `git_oid`s of two `git_commit` objects. */ +static int commit_id_cmp(const void *a, const void *b) +{ + return git_oid_cmp( + git_commit_id((const git_commit *)a), git_commit_id((const git_commit *)b)); +} + +/** Find a `git_commit` whose ID matches the provided `git_oid` key. */ +static int id_commit_id_cmp(const void *key, const void *commit) +{ + return git_oid_cmp((const git_oid *)key, git_commit_id((const git_commit *)commit)); +} + +void test_graph_reachable_from_any__exhaustive(void) +{ + struct exhaustive_state mc = { + .db = NULL, + .commits = GIT_VECTOR_INIT, + }; + size_t child_idx, commit_count; + size_t n_descendants; + git_commit *child_commit; + git_bitvec reachable; + + cl_git_pass(git_repository_odb(&mc.db, repo)); + cl_git_pass(git_odb_foreach(mc.db, &exhaustive_commits, &mc)); + git_vector_set_cmp(&mc.commits, commit_id_cmp); + git_vector_sort(&mc.commits); + cl_git_pass(git_bitvec_init( + &reachable, + git_vector_length(&mc.commits) * git_vector_length(&mc.commits))); + + commit_count = git_vector_length(&mc.commits); + git_vector_foreach (&mc.commits, child_idx, child_commit) { + unsigned int parent_i; + + /* We treat each commit as being able to reach itself. */ + git_bitvec_set(&reachable, child_idx * commit_count + child_idx, true); + + for (parent_i = 0; parent_i < git_commit_parentcount(child_commit); ++parent_i) { + size_t parent_idx = -1; + cl_git_pass(git_vector_bsearch2( + &parent_idx, + &mc.commits, + id_commit_id_cmp, + git_commit_parent_id(child_commit, parent_i))); + + /* We have established that parent_idx is reachable from child_idx */ + git_bitvec_set(&reachable, parent_idx * commit_count + child_idx, true); + } + } + + /* Floyd-Warshall */ + { + size_t i, j, k; + for (k = 0; k < commit_count; ++k) { + for (i = 0; i < commit_count; ++i) { + if (!git_bitvec_get(&reachable, i * commit_count + k)) + continue; + for (j = 0; j < commit_count; ++j) { + if (!git_bitvec_get(&reachable, k * commit_count + j)) + continue; + git_bitvec_set(&reachable, i * commit_count + j, true); + } + } + } + } + + /* Try 1000 subsets of 1 through 10 entries each. */ + srand(0x223ddc4b); + for (n_descendants = 1; n_descendants < 10; ++n_descendants) { + size_t test_iteration; + git_oid descendants[10]; + + for (test_iteration = 0; test_iteration < 1000; ++test_iteration) { + size_t descendant_i; + size_t child_idx, parent_idx; + int expected_reachable = false, actual_reachable; + git_commit *child_commit, *parent_commit; + + parent_idx = rand() % commit_count; + parent_commit = (git_commit *)git_vector_get(&mc.commits, parent_idx); + for (descendant_i = 0; descendant_i < n_descendants; ++descendant_i) { + child_idx = rand() % commit_count; + child_commit = (git_commit *)git_vector_get(&mc.commits, child_idx); + expected_reachable |= git_bitvec_get( + &reachable, parent_idx * commit_count + child_idx); + git_oid_cpy(&descendants[descendant_i], + git_commit_id(child_commit)); + } + + actual_reachable = git_graph_reachable_from_any( + repo, + git_commit_id(parent_commit), + descendants, + n_descendants); + if (actual_reachable != expected_reachable) { + git_buf error_message_buf = GIT_BUF_INIT; + char parent_oidbuf[9] = {0}, child_oidbuf[9] = {0}; + + cl_git_pass(git_oid_nfmt( + parent_oidbuf, 8, git_commit_id(parent_commit))); + git_buf_printf(&error_message_buf, + "git_graph_reachable_from_any(\"%s\", %zu, " + "{", + parent_oidbuf, + n_descendants); + for (descendant_i = 0; descendant_i < n_descendants; + ++descendant_i) { + cl_git_pass( + git_oid_nfmt(child_oidbuf, + 8, + &descendants[descendant_i])); + git_buf_printf(&error_message_buf, " \"%s\"", child_oidbuf); + } + git_buf_printf(&error_message_buf, + " }) = %d, expected = %d", + actual_reachable, + expected_reachable); + cl_check_(actual_reachable == expected_reachable, + git_buf_cstr(&error_message_buf)); + } + } + } + + git_vector_foreach (&mc.commits, child_idx, child_commit) + git_commit_free(child_commit); + git_bitvec_free(&reachable); + git_vector_free(&mc.commits); + git_odb_free(mc.db); +} diff --git a/tests/ignore/path.c b/tests/ignore/path.c index 5d53c9df9..d55bdc5dd 100644 --- a/tests/ignore/path.c +++ b/tests/ignore/path.c @@ -575,3 +575,11 @@ void test_ignore_path__negative_prefix_rule(void) assert_is_ignored(true, "ff"); assert_is_ignored(false, "f"); } + +void test_ignore_path__negative_more_specific(void) +{ + cl_git_rewritefile("attr/.gitignore", "*.txt\n!/dir/test.txt\n"); + assert_is_ignored(true, "test.txt"); + assert_is_ignored(false, "dir/test.txt"); + assert_is_ignored(true, "outer/dir/test.txt"); +} diff --git a/tests/ignore/status.c b/tests/ignore/status.c index 188fbe469..83e821bdd 100644 --- a/tests/ignore/status.c +++ b/tests/ignore/status.c @@ -70,9 +70,9 @@ void test_ignore_status__0(void) /* confirm that ignore files were cached */ cl_assert(git_attr_cache__is_cached( - g_repo, GIT_ATTR_FILE__FROM_FILE, ".git/info/exclude")); + g_repo, GIT_ATTR_FILE_SOURCE_FILE, ".git/info/exclude")); cl_assert(git_attr_cache__is_cached( - g_repo, GIT_ATTR_FILE__FROM_FILE, ".gitignore")); + g_repo, GIT_ATTR_FILE_SOURCE_FILE, ".gitignore")); } diff --git a/tests/index/addall.c b/tests/index/addall.c index d1ef31daf..6f95f6386 100644 --- a/tests/index/addall.c +++ b/tests/index/addall.c @@ -318,11 +318,9 @@ void test_index_addall__files_in_folders(void) void test_index_addall__hidden_files(void) { +#ifdef GIT_WIN32 git_index *index; - GIT_UNUSED(index); - -#ifdef GIT_WIN32 addall_create_test_repo(true); cl_git_pass(git_repository_index(&index, g_repo)); diff --git a/tests/index/bypath.c b/tests/index/bypath.c index 21d3d3ed0..b32a0a789 100644 --- a/tests/index/bypath.c +++ b/tests/index/bypath.c @@ -49,13 +49,10 @@ void test_index_bypath__add_submodule_unregistered(void) void test_index_bypath__add_hidden(void) { +#ifdef GIT_WIN32 const git_index_entry *entry; bool hidden; - GIT_UNUSED(entry); - GIT_UNUSED(hidden); - -#ifdef GIT_WIN32 cl_git_mkfile("submod2/hidden_file", "you can't see me"); cl_git_pass(git_win32__hidden(&hidden, "submod2/hidden_file")); diff --git a/tests/iterator/workdir.c b/tests/iterator/workdir.c index 547fb7d95..82ee363f9 100644 --- a/tests/iterator/workdir.c +++ b/tests/iterator/workdir.c @@ -1024,7 +1024,7 @@ static void create_paths(const char *root, int depth) int i; cl_git_pass(git_buf_puts(&fullpath, root)); - cl_git_pass(git_buf_putc(&fullpath, '/')); + cl_git_pass(git_path_to_dir(&fullpath)); root_len = fullpath.size; diff --git a/tests/mailmap/parsing.c b/tests/mailmap/parsing.c index e2ab05c99..ba3b3a2f6 100644 --- a/tests/mailmap/parsing.c +++ b/tests/mailmap/parsing.c @@ -2,7 +2,6 @@ #include "repository.h" #include "git2/sys/repository.h" #include "mailmap_testdata.h" -#include "buf_text.h" static git_repository *g_repo; static git_mailmap *g_mailmap; @@ -109,7 +108,7 @@ void test_mailmap_parsing__windows_string(void) /* Parse with windows-style line endings */ git_buf_attach_notowned(&unixbuf, string_mailmap, strlen(string_mailmap)); - cl_git_pass(git_buf_text_lf_to_crlf(&winbuf, &unixbuf)); + cl_git_pass(git_buf_lf_to_crlf(&winbuf, &unixbuf)); cl_git_pass(git_mailmap_from_buffer(&g_mailmap, winbuf.ptr, winbuf.size)); git_buf_dispose(&winbuf); diff --git a/tests/main.c b/tests/main.c index 00b2bae02..56751c288 100644 --- a/tests/main.c +++ b/tests/main.c @@ -1,6 +1,10 @@ #include "clar_libgit2.h" #include "clar_libgit2_trace.h" +#ifdef GIT_WIN32_LEAKCHECK +# include "win32/w32_leakcheck.h" +#endif + #ifdef _WIN32 int __cdecl main(int argc, char *argv[]) #else @@ -14,7 +18,9 @@ int main(int argc, char *argv[]) res = git_libgit2_init(); if (res < 0) { - fprintf(stderr, "failed to init libgit2"); + const git_error *err = git_error_last(); + const char *msg = err ? err->message : "unknown failure"; + fprintf(stderr, "failed to init libgit2: %s\n", msg); return res; } @@ -29,6 +35,11 @@ int main(int argc, char *argv[]) cl_global_trace_disable(); git_libgit2_shutdown(); +#ifdef GIT_WIN32_LEAKCHECK + if (git_win32_leakcheck_has_leaks()) + res = res || 1; +#endif + at_exit_cmd = getenv("CLAR_AT_EXIT"); if (at_exit_cmd != NULL) { int at_exit = system(at_exit_cmd); diff --git a/tests/merge/workdir/setup.c b/tests/merge/workdir/setup.c index ad29fcd94..0b85f2712 100644 --- a/tests/merge/workdir/setup.c +++ b/tests/merge/workdir/setup.c @@ -49,7 +49,7 @@ static bool test_file_contents(const char *filename, const char *expected) git_buf file_path_buf = GIT_BUF_INIT, file_buf = GIT_BUF_INIT; bool equals; - git_buf_printf(&file_path_buf, "%s/%s", git_repository_path(repo), filename); + git_buf_joinpath(&file_path_buf, git_repository_path(repo), filename); cl_git_pass(git_futils_readbuffer(&file_buf, file_path_buf.ptr)); equals = (strcmp(file_buf.ptr, expected) == 0); @@ -64,7 +64,7 @@ static void write_file_contents(const char *filename, const char *output) { git_buf file_path_buf = GIT_BUF_INIT; - git_buf_printf(&file_path_buf, "%s/%s", git_repository_path(repo), + git_buf_joinpath(&file_path_buf, git_repository_path(repo), filename); cl_git_rewritefile(file_path_buf.ptr, output); diff --git a/tests/network/refspecs.c b/tests/network/refspecs.c index 5c8eb1502..d9e0d9e8d 100644 --- a/tests/network/refspecs.c +++ b/tests/network/refspecs.c @@ -13,7 +13,7 @@ static void assert_refspec(unsigned int direction, const char *input, bool is_ex if (is_expected_to_be_valid) cl_assert_equal_i(0, error); else - cl_assert_equal_i(GIT_ERROR, error); + cl_assert_equal_i(GIT_EINVALIDSPEC, error); } void test_network_refspecs__parsing(void) diff --git a/tests/network/remote/isvalidname.c b/tests/network/remote/isvalidname.c index c26fbd0a5..a3080f67c 100644 --- a/tests/network/remote/isvalidname.c +++ b/tests/network/remote/isvalidname.c @@ -1,17 +1,24 @@ #include "clar_libgit2.h" +static int is_valid_name(const char *name) +{ + int valid = 0; + cl_git_pass(git_remote_name_is_valid(&valid, name)); + return valid; +} + void test_network_remote_isvalidname__can_detect_invalid_formats(void) { - cl_assert_equal_i(false, git_remote_is_valid_name("/")); - cl_assert_equal_i(false, git_remote_is_valid_name("//")); - cl_assert_equal_i(false, git_remote_is_valid_name(".lock")); - cl_assert_equal_i(false, git_remote_is_valid_name("a.lock")); - cl_assert_equal_i(false, git_remote_is_valid_name("/no/leading/slash")); - cl_assert_equal_i(false, git_remote_is_valid_name("no/trailing/slash/")); + cl_assert_equal_i(false, is_valid_name("/")); + cl_assert_equal_i(false, is_valid_name("//")); + cl_assert_equal_i(false, is_valid_name(".lock")); + cl_assert_equal_i(false, is_valid_name("a.lock")); + cl_assert_equal_i(false, is_valid_name("/no/leading/slash")); + cl_assert_equal_i(false, is_valid_name("no/trailing/slash/")); } void test_network_remote_isvalidname__wont_hopefully_choke_on_valid_formats(void) { - cl_assert_equal_i(true, git_remote_is_valid_name("webmatrix")); - cl_assert_equal_i(true, git_remote_is_valid_name("yishaigalatzer/rules")); + cl_assert_equal_i(true, is_valid_name("webmatrix")); + cl_assert_equal_i(true, is_valid_name("yishaigalatzer/rules")); } diff --git a/tests/network/remote/remotes.c b/tests/network/remote/remotes.c index 0694a6f66..ed6a89075 100644 --- a/tests/network/remote/remotes.c +++ b/tests/network/remote/remotes.c @@ -56,6 +56,49 @@ void test_network_remote_remotes__parsing(void) git_buf_dispose(&url); } +static int remote_ready_callback(git_remote *remote, int direction, void *payload) +{ + if (direction == GIT_DIRECTION_PUSH) { + const char *url = git_remote_pushurl(remote); + + cl_assert_equal_p(url, NULL);; + cl_assert_equal_s(payload, "payload"); + return git_remote_set_instance_pushurl(remote, "push_url"); + } + + if (direction == GIT_DIRECTION_FETCH) { + const char *url = git_remote_url(remote); + + cl_assert_equal_s(url, "git://github.com/libgit2/libgit2"); + cl_assert_equal_s(payload, "payload"); + return git_remote_set_instance_url(remote, "fetch_url"); + } + + return -1; +} + +void test_network_remote_remotes__remote_ready(void) +{ + git_buf url = GIT_BUF_INIT; + + git_remote_callbacks callbacks = GIT_REMOTE_CALLBACKS_INIT; + callbacks.remote_ready = remote_ready_callback; + callbacks.payload = "payload"; + + cl_assert_equal_s(git_remote_name(_remote), "test"); + cl_assert_equal_s(git_remote_url(_remote), "git://github.com/libgit2/libgit2"); + cl_assert(git_remote_pushurl(_remote) == NULL); + + cl_git_pass(git_remote__urlfordirection(&url, _remote, GIT_DIRECTION_FETCH, &callbacks)); + cl_assert_equal_s(url.ptr, "fetch_url"); + + cl_git_pass(git_remote__urlfordirection(&url, _remote, GIT_DIRECTION_PUSH, &callbacks)); + cl_assert_equal_s(url.ptr, "push_url"); + + git_buf_dispose(&url); +} + +#ifndef GIT_DEPRECATE_HARD static int urlresolve_callback(git_buf *url_resolved, const char *url, int direction, void *payload) { cl_assert(strcmp(url, "git://github.com/libgit2/libgit2") == 0); @@ -69,9 +112,11 @@ static int urlresolve_callback(git_buf *url_resolved, const char *url, int direc return GIT_OK; } +#endif void test_network_remote_remotes__urlresolve(void) { +#ifndef GIT_DEPRECATE_HARD git_buf url = GIT_BUF_INIT; git_remote_callbacks callbacks = GIT_REMOTE_CALLBACKS_INIT; @@ -89,8 +134,10 @@ void test_network_remote_remotes__urlresolve(void) cl_assert_equal_s(url.ptr, "pushresolve"); git_buf_dispose(&url); +#endif } +#ifndef GIT_DEPRECATE_HARD static int urlresolve_passthrough_callback(git_buf *url_resolved, const char *url, int direction, void *payload) { GIT_UNUSED(url_resolved); @@ -99,9 +146,11 @@ static int urlresolve_passthrough_callback(git_buf *url_resolved, const char *ur GIT_UNUSED(payload); return GIT_PASSTHROUGH; } +#endif void test_network_remote_remotes__urlresolve_passthrough(void) { +#ifndef GIT_DEPRECATE_HARD git_buf url = GIT_BUF_INIT; const char *orig_url = "git://github.com/libgit2/libgit2"; @@ -119,6 +168,52 @@ void test_network_remote_remotes__urlresolve_passthrough(void) cl_assert_equal_s(url.ptr, orig_url); git_buf_dispose(&url); +#endif +} + +void test_network_remote_remotes__instance_url(void) +{ + git_buf url = GIT_BUF_INIT; + const char *orig_url = "git://github.com/libgit2/libgit2"; + + cl_assert_equal_s(git_remote_name(_remote), "test"); + cl_assert_equal_s(git_remote_url(_remote), orig_url); + + cl_git_pass(git_remote__urlfordirection(&url, _remote, GIT_DIRECTION_FETCH, NULL)); + cl_assert_equal_s(url.ptr, orig_url); + git_buf_clear(&url); + + cl_git_pass(git_remote__urlfordirection(&url, _remote, GIT_DIRECTION_PUSH, NULL)); + cl_assert_equal_s(url.ptr, orig_url); + git_buf_clear(&url); + + /* Setting the instance url updates the fetch and push URLs */ + git_remote_set_instance_url(_remote, "https://github.com/new/remote/url"); + cl_assert_equal_s(git_remote_url(_remote), "https://github.com/new/remote/url"); + cl_assert_equal_p(git_remote_pushurl(_remote), NULL); + + cl_git_pass(git_remote__urlfordirection(&url, _remote, GIT_DIRECTION_FETCH, NULL)); + cl_assert_equal_s(url.ptr, "https://github.com/new/remote/url"); + git_buf_clear(&url); + + cl_git_pass(git_remote__urlfordirection(&url, _remote, GIT_DIRECTION_PUSH, NULL)); + cl_assert_equal_s(url.ptr, "https://github.com/new/remote/url"); + git_buf_clear(&url); + + /* Setting the instance push url updates only the push URL */ + git_remote_set_instance_pushurl(_remote, "https://github.com/new/push/url"); + cl_assert_equal_s(git_remote_url(_remote), "https://github.com/new/remote/url"); + cl_assert_equal_s(git_remote_pushurl(_remote), "https://github.com/new/push/url"); + + cl_git_pass(git_remote__urlfordirection(&url, _remote, GIT_DIRECTION_FETCH, NULL)); + cl_assert_equal_s(url.ptr, "https://github.com/new/remote/url"); + git_buf_clear(&url); + + cl_git_pass(git_remote__urlfordirection(&url, _remote, GIT_DIRECTION_PUSH, NULL)); + cl_assert_equal_s(url.ptr, "https://github.com/new/push/url"); + git_buf_clear(&url); + + git_buf_dispose(&url); } void test_network_remote_remotes__pushurl(void) diff --git a/tests/network/joinpath.c b/tests/network/url/joinpath.c index da8393b91..bf4557138 100644 --- a/tests/network/joinpath.c +++ b/tests/network/url/joinpath.c @@ -4,19 +4,19 @@ static git_net_url source, target; -void test_network_joinpath__initialize(void) +void test_network_url_joinpath__initialize(void) { memset(&source, 0, sizeof(source)); memset(&target, 0, sizeof(target)); } -void test_network_joinpath__cleanup(void) +void test_network_url_joinpath__cleanup(void) { git_net_url_dispose(&source); git_net_url_dispose(&target); } -void test_network_joinpath__target_paths_and_queries(void) +void test_network_url_joinpath__target_paths_and_queries(void) { cl_git_pass(git_net_url_parse(&source, "http://example.com/a/b")); @@ -31,7 +31,7 @@ void test_network_joinpath__target_paths_and_queries(void) git_net_url_dispose(&target); } -void test_network_joinpath__source_query_removed(void) +void test_network_url_joinpath__source_query_removed(void) { cl_git_pass(git_net_url_parse(&source, "http://example.com/a/b?query&one&two")); @@ -46,7 +46,7 @@ void test_network_joinpath__source_query_removed(void) git_net_url_dispose(&target); } -void test_network_joinpath__source_lacks_path(void) +void test_network_url_joinpath__source_lacks_path(void) { cl_git_pass(git_net_url_parse(&source, "http://example.com")); @@ -91,7 +91,7 @@ void test_network_joinpath__source_lacks_path(void) git_net_url_dispose(&target); } -void test_network_joinpath__source_is_slash(void) +void test_network_url_joinpath__source_is_slash(void) { cl_git_pass(git_net_url_parse(&source, "http://example.com/")); @@ -137,7 +137,7 @@ void test_network_joinpath__source_is_slash(void) } -void test_network_joinpath__source_has_query(void) +void test_network_url_joinpath__source_has_query(void) { cl_git_pass(git_net_url_parse(&source, "http://example.com?query")); @@ -183,7 +183,7 @@ void test_network_joinpath__source_has_query(void) } -void test_network_joinpath__empty_query_ignored(void) +void test_network_url_joinpath__empty_query_ignored(void) { cl_git_pass(git_net_url_parse(&source, "http://example.com/foo")); diff --git a/tests/network/url/parse.c b/tests/network/url/parse.c new file mode 100644 index 000000000..edfd6abec --- /dev/null +++ b/tests/network/url/parse.c @@ -0,0 +1,557 @@ +#include "clar_libgit2.h" +#include "net.h" + +static git_net_url conndata; + +void test_network_url_parse__initialize(void) +{ + memset(&conndata, 0, sizeof(conndata)); +} + +void test_network_url_parse__cleanup(void) +{ + git_net_url_dispose(&conndata); +} + +/* Hostname */ + +void test_network_url_parse__hostname_trivial(void) +{ + cl_git_pass(git_net_url_parse(&conndata, "http://example.com/resource")); + cl_assert_equal_s(conndata.scheme, "http"); + cl_assert_equal_s(conndata.host, "example.com"); + cl_assert_equal_s(conndata.port, "80"); + cl_assert_equal_s(conndata.path, "/resource"); + cl_assert_equal_p(conndata.username, NULL); + cl_assert_equal_p(conndata.password, NULL); + cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1); +} + +void test_network_url_parse__hostname_root(void) +{ + cl_git_pass(git_net_url_parse(&conndata, "http://example.com/")); + cl_assert_equal_s(conndata.scheme, "http"); + cl_assert_equal_s(conndata.host, "example.com"); + cl_assert_equal_s(conndata.port, "80"); + cl_assert_equal_s(conndata.path, "/"); + cl_assert_equal_p(conndata.username, NULL); + cl_assert_equal_p(conndata.password, NULL); + cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1); +} + +void test_network_url_parse__hostname_implied_root(void) +{ + cl_git_pass(git_net_url_parse(&conndata, "http://example.com")); + cl_assert_equal_s(conndata.scheme, "http"); + cl_assert_equal_s(conndata.host, "example.com"); + cl_assert_equal_s(conndata.port, "80"); + cl_assert_equal_s(conndata.path, "/"); + cl_assert_equal_p(conndata.username, NULL); + cl_assert_equal_p(conndata.password, NULL); + cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1); +} + +void test_network_url_parse__hostname_implied_root_custom_port(void) +{ + cl_git_pass(git_net_url_parse(&conndata, "http://example.com:42")); + cl_assert_equal_s(conndata.scheme, "http"); + cl_assert_equal_s(conndata.host, "example.com"); + cl_assert_equal_s(conndata.port, "42"); + cl_assert_equal_s(conndata.path, "/"); + cl_assert_equal_p(conndata.username, NULL); + cl_assert_equal_p(conndata.password, NULL); + cl_assert_equal_i(git_net_url_is_default_port(&conndata), 0); +} + +void test_network_url_parse__hostname_implied_root_empty_port(void) +{ + cl_git_pass(git_net_url_parse(&conndata, "http://example.com:")); + cl_assert_equal_s(conndata.scheme, "http"); + cl_assert_equal_s(conndata.host, "example.com"); + cl_assert_equal_s(conndata.port, "80"); + cl_assert_equal_s(conndata.path, "/"); + cl_assert_equal_p(conndata.username, NULL); + cl_assert_equal_p(conndata.password, NULL); + cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1); +} + +void test_network_url_parse__hostname_encoded_password(void) +{ + cl_git_pass(git_net_url_parse(&conndata, + "https://user:pass%2fis%40bad@hostname.com:1234/")); + cl_assert_equal_s(conndata.scheme, "https"); + cl_assert_equal_s(conndata.host, "hostname.com"); + cl_assert_equal_s(conndata.port, "1234"); + cl_assert_equal_s(conndata.path, "/"); + cl_assert_equal_s(conndata.username, "user"); + cl_assert_equal_s(conndata.password, "pass/is@bad"); + cl_assert_equal_i(git_net_url_is_default_port(&conndata), 0); +} + +void test_network_url_parse__hostname_user(void) +{ + cl_git_pass(git_net_url_parse(&conndata, + "https://user@example.com/resource")); + cl_assert_equal_s(conndata.scheme, "https"); + cl_assert_equal_s(conndata.host, "example.com"); + cl_assert_equal_s(conndata.port, "443"); + cl_assert_equal_s(conndata.path, "/resource"); + cl_assert_equal_s(conndata.username, "user"); + cl_assert_equal_p(conndata.password, NULL); + cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1); +} + +void test_network_url_parse__hostname_user_pass(void) +{ + /* user:pass@hostname.tld/resource */ + cl_git_pass(git_net_url_parse(&conndata, + "https://user:pass@example.com/resource")); + cl_assert_equal_s(conndata.scheme, "https"); + cl_assert_equal_s(conndata.host, "example.com"); + cl_assert_equal_s(conndata.port, "443"); + cl_assert_equal_s(conndata.path, "/resource"); + cl_assert_equal_s(conndata.username, "user"); + cl_assert_equal_s(conndata.password, "pass"); + cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1); +} + +void test_network_url_parse__hostname_port(void) +{ + /* hostname.tld:port/resource */ + cl_git_pass(git_net_url_parse(&conndata, + "https://example.com:9191/resource")); + cl_assert_equal_s(conndata.scheme, "https"); + cl_assert_equal_s(conndata.host, "example.com"); + cl_assert_equal_s(conndata.port, "9191"); + cl_assert_equal_s(conndata.path, "/resource"); + cl_assert_equal_p(conndata.username, NULL); + cl_assert_equal_p(conndata.password, NULL); + cl_assert_equal_i(git_net_url_is_default_port(&conndata), 0); +} + +void test_network_url_parse__hostname_empty_port(void) +{ + cl_git_pass(git_net_url_parse(&conndata, "http://example.com:/resource")); + cl_assert_equal_s(conndata.scheme, "http"); + cl_assert_equal_s(conndata.host, "example.com"); + cl_assert_equal_s(conndata.port, "80"); + cl_assert_equal_s(conndata.path, "/resource"); + cl_assert_equal_p(conndata.username, NULL); + cl_assert_equal_p(conndata.password, NULL); + cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1); +} + +void test_network_url_parse__hostname_user_port(void) +{ + /* user@hostname.tld:port/resource */ + cl_git_pass(git_net_url_parse(&conndata, + "https://user@example.com:9191/resource")); + cl_assert_equal_s(conndata.scheme, "https"); + cl_assert_equal_s(conndata.host, "example.com"); + cl_assert_equal_s(conndata.port, "9191"); + cl_assert_equal_s(conndata.path, "/resource"); + cl_assert_equal_s(conndata.username, "user"); + cl_assert_equal_p(conndata.password, NULL); + cl_assert_equal_i(git_net_url_is_default_port(&conndata), 0); +} + +void test_network_url_parse__hostname_user_pass_port(void) +{ + /* user:pass@hostname.tld:port/resource */ + cl_git_pass(git_net_url_parse(&conndata, + "https://user:pass@example.com:9191/resource")); + cl_assert_equal_s(conndata.scheme, "https"); + cl_assert_equal_s(conndata.host, "example.com"); + cl_assert_equal_s(conndata.port, "9191"); + cl_assert_equal_s(conndata.path, "/resource"); + cl_assert_equal_s(conndata.username, "user"); + cl_assert_equal_s(conndata.password, "pass"); + cl_assert_equal_i(git_net_url_is_default_port(&conndata), 0); +} + +/* IPv4 addresses */ + +void test_network_url_parse__ipv4_trivial(void) +{ + cl_git_pass(git_net_url_parse(&conndata, "http://192.168.1.1/resource")); + cl_assert_equal_s(conndata.scheme, "http"); + cl_assert_equal_s(conndata.host, "192.168.1.1"); + cl_assert_equal_s(conndata.port, "80"); + cl_assert_equal_s(conndata.path, "/resource"); + cl_assert_equal_p(conndata.username, NULL); + cl_assert_equal_p(conndata.password, NULL); + cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1); +} + +void test_network_url_parse__ipv4_root(void) +{ + cl_git_pass(git_net_url_parse(&conndata, "http://192.168.1.1/")); + cl_assert_equal_s(conndata.scheme, "http"); + cl_assert_equal_s(conndata.host, "192.168.1.1"); + cl_assert_equal_s(conndata.port, "80"); + cl_assert_equal_s(conndata.path, "/"); + cl_assert_equal_p(conndata.username, NULL); + cl_assert_equal_p(conndata.password, NULL); + cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1); +} + +void test_network_url_parse__ipv4_implied_root(void) +{ + cl_git_pass(git_net_url_parse(&conndata, "http://192.168.1.1")); + cl_assert_equal_s(conndata.scheme, "http"); + cl_assert_equal_s(conndata.host, "192.168.1.1"); + cl_assert_equal_s(conndata.port, "80"); + cl_assert_equal_s(conndata.path, "/"); + cl_assert_equal_p(conndata.username, NULL); + cl_assert_equal_p(conndata.password, NULL); + cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1); +} + +void test_network_url_parse__ipv4_implied_root_custom_port(void) +{ + cl_git_pass(git_net_url_parse(&conndata, "http://192.168.1.1:42")); + cl_assert_equal_s(conndata.scheme, "http"); + cl_assert_equal_s(conndata.host, "192.168.1.1"); + cl_assert_equal_s(conndata.port, "42"); + cl_assert_equal_s(conndata.path, "/"); + cl_assert_equal_p(conndata.username, NULL); + cl_assert_equal_p(conndata.password, NULL); + cl_assert_equal_i(git_net_url_is_default_port(&conndata), 0); +} + +void test_network_url_parse__ipv4_implied_root_empty_port(void) +{ + cl_git_pass(git_net_url_parse(&conndata, "http://192.168.1.1:")); + cl_assert_equal_s(conndata.scheme, "http"); + cl_assert_equal_s(conndata.host, "192.168.1.1"); + cl_assert_equal_s(conndata.port, "80"); + cl_assert_equal_s(conndata.path, "/"); + cl_assert_equal_p(conndata.username, NULL); + cl_assert_equal_p(conndata.password, NULL); + cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1); +} + +void test_network_url_parse__ipv4_encoded_password(void) +{ + cl_git_pass(git_net_url_parse(&conndata, + "https://user:pass%2fis%40bad@192.168.1.1:1234/")); + cl_assert_equal_s(conndata.scheme, "https"); + cl_assert_equal_s(conndata.host, "192.168.1.1"); + cl_assert_equal_s(conndata.port, "1234"); + cl_assert_equal_s(conndata.path, "/"); + cl_assert_equal_s(conndata.username, "user"); + cl_assert_equal_s(conndata.password, "pass/is@bad"); + cl_assert_equal_i(git_net_url_is_default_port(&conndata), 0); +} + +void test_network_url_parse__ipv4_user(void) +{ + cl_git_pass(git_net_url_parse(&conndata, + "https://user@192.168.1.1/resource")); + cl_assert_equal_s(conndata.scheme, "https"); + cl_assert_equal_s(conndata.host, "192.168.1.1"); + cl_assert_equal_s(conndata.port, "443"); + cl_assert_equal_s(conndata.path, "/resource"); + cl_assert_equal_s(conndata.username, "user"); + cl_assert_equal_p(conndata.password, NULL); + cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1); +} + +void test_network_url_parse__ipv4_user_pass(void) +{ + cl_git_pass(git_net_url_parse(&conndata, + "https://user:pass@192.168.1.1/resource")); + cl_assert_equal_s(conndata.scheme, "https"); + cl_assert_equal_s(conndata.host, "192.168.1.1"); + cl_assert_equal_s(conndata.port, "443"); + cl_assert_equal_s(conndata.path, "/resource"); + cl_assert_equal_s(conndata.username, "user"); + cl_assert_equal_s(conndata.password, "pass"); + cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1); +} + +void test_network_url_parse__ipv4_port(void) +{ + cl_git_pass(git_net_url_parse(&conndata, + "https://192.168.1.1:9191/resource")); + cl_assert_equal_s(conndata.scheme, "https"); + cl_assert_equal_s(conndata.host, "192.168.1.1"); + cl_assert_equal_s(conndata.port, "9191"); + cl_assert_equal_s(conndata.path, "/resource"); + cl_assert_equal_p(conndata.username, NULL); + cl_assert_equal_p(conndata.password, NULL); + cl_assert_equal_i(git_net_url_is_default_port(&conndata), 0); +} + +void test_network_url_parse__ipv4_empty_port(void) +{ + cl_git_pass(git_net_url_parse(&conndata, "http://192.168.1.1:/resource")); + cl_assert_equal_s(conndata.scheme, "http"); + cl_assert_equal_s(conndata.host, "192.168.1.1"); + cl_assert_equal_s(conndata.port, "80"); + cl_assert_equal_s(conndata.path, "/resource"); + cl_assert_equal_p(conndata.username, NULL); + cl_assert_equal_p(conndata.password, NULL); + cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1); +} + +void test_network_url_parse__ipv4_user_port(void) +{ + cl_git_pass(git_net_url_parse(&conndata, + "https://user@192.168.1.1:9191/resource")); + cl_assert_equal_s(conndata.scheme, "https"); + cl_assert_equal_s(conndata.host, "192.168.1.1"); + cl_assert_equal_s(conndata.port, "9191"); + cl_assert_equal_s(conndata.path, "/resource"); + cl_assert_equal_s(conndata.username, "user"); + cl_assert_equal_p(conndata.password, NULL); + cl_assert_equal_i(git_net_url_is_default_port(&conndata), 0); +} + +void test_network_url_parse__ipv4_user_pass_port(void) +{ + cl_git_pass(git_net_url_parse(&conndata, + "https://user:pass@192.168.1.1:9191/resource")); + cl_assert_equal_s(conndata.scheme, "https"); + cl_assert_equal_s(conndata.host, "192.168.1.1"); + cl_assert_equal_s(conndata.port, "9191"); + cl_assert_equal_s(conndata.path, "/resource"); + cl_assert_equal_s(conndata.username, "user"); + cl_assert_equal_s(conndata.password, "pass"); + cl_assert_equal_i(git_net_url_is_default_port(&conndata), 0); +} + +/* IPv6 addresses */ + +void test_network_url_parse__ipv6_trivial(void) +{ + cl_git_pass(git_net_url_parse(&conndata, "http://[fe80::dcad:beff:fe00:0001]/resource")); + cl_assert_equal_s(conndata.scheme, "http"); + cl_assert_equal_s(conndata.host, "fe80::dcad:beff:fe00:0001"); + cl_assert_equal_s(conndata.port, "80"); + cl_assert_equal_s(conndata.path, "/resource"); + cl_assert_equal_p(conndata.username, NULL); + cl_assert_equal_p(conndata.password, NULL); + cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1); +} + +void test_network_url_parse__ipv6_root(void) +{ + cl_git_pass(git_net_url_parse(&conndata, "http://[fe80::dcad:beff:fe00:0001]/")); + cl_assert_equal_s(conndata.scheme, "http"); + cl_assert_equal_s(conndata.host, "fe80::dcad:beff:fe00:0001"); + cl_assert_equal_s(conndata.port, "80"); + cl_assert_equal_s(conndata.path, "/"); + cl_assert_equal_p(conndata.username, NULL); + cl_assert_equal_p(conndata.password, NULL); + cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1); +} + +void test_network_url_parse__ipv6_implied_root(void) +{ + cl_git_pass(git_net_url_parse(&conndata, "http://[fe80::dcad:beff:fe00:0001]")); + cl_assert_equal_s(conndata.scheme, "http"); + cl_assert_equal_s(conndata.host, "fe80::dcad:beff:fe00:0001"); + cl_assert_equal_s(conndata.port, "80"); + cl_assert_equal_s(conndata.path, "/"); + cl_assert_equal_p(conndata.username, NULL); + cl_assert_equal_p(conndata.password, NULL); + cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1); +} + +void test_network_url_parse__ipv6_implied_root_custom_port(void) +{ + cl_git_pass(git_net_url_parse(&conndata, "http://[fe80::dcad:beff:fe00:0001]:42")); + cl_assert_equal_s(conndata.scheme, "http"); + cl_assert_equal_s(conndata.host, "fe80::dcad:beff:fe00:0001"); + cl_assert_equal_s(conndata.port, "42"); + cl_assert_equal_s(conndata.path, "/"); + cl_assert_equal_p(conndata.username, NULL); + cl_assert_equal_p(conndata.password, NULL); + cl_assert_equal_i(git_net_url_is_default_port(&conndata), 0); +} + +void test_network_url_parse__ipv6_implied_root_empty_port(void) +{ + cl_git_pass(git_net_url_parse(&conndata, "http://[fe80::dcad:beff:fe00:0001]:")); + cl_assert_equal_s(conndata.scheme, "http"); + cl_assert_equal_s(conndata.host, "fe80::dcad:beff:fe00:0001"); + cl_assert_equal_s(conndata.port, "80"); + cl_assert_equal_s(conndata.path, "/"); + cl_assert_equal_p(conndata.username, NULL); + cl_assert_equal_p(conndata.password, NULL); + cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1); +} + +void test_network_url_parse__ipv6_encoded_password(void) +{ + cl_git_pass(git_net_url_parse(&conndata, + "https://user:pass%2fis%40bad@[fe80::dcad:beff:fe00:0001]:1234/")); + cl_assert_equal_s(conndata.scheme, "https"); + cl_assert_equal_s(conndata.host, "fe80::dcad:beff:fe00:0001"); + cl_assert_equal_s(conndata.port, "1234"); + cl_assert_equal_s(conndata.path, "/"); + cl_assert_equal_s(conndata.username, "user"); + cl_assert_equal_s(conndata.password, "pass/is@bad"); + cl_assert_equal_i(git_net_url_is_default_port(&conndata), 0); +} + +void test_network_url_parse__ipv6_user(void) +{ + cl_git_pass(git_net_url_parse(&conndata, + "https://user@[fe80::dcad:beff:fe00:0001]/resource")); + cl_assert_equal_s(conndata.scheme, "https"); + cl_assert_equal_s(conndata.host, "fe80::dcad:beff:fe00:0001"); + cl_assert_equal_s(conndata.port, "443"); + cl_assert_equal_s(conndata.path, "/resource"); + cl_assert_equal_s(conndata.username, "user"); + cl_assert_equal_p(conndata.password, NULL); + cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1); +} + +void test_network_url_parse__ipv6_user_pass(void) +{ + cl_git_pass(git_net_url_parse(&conndata, + "https://user:pass@[fe80::dcad:beff:fe00:0001]/resource")); + cl_assert_equal_s(conndata.scheme, "https"); + cl_assert_equal_s(conndata.host, "fe80::dcad:beff:fe00:0001"); + cl_assert_equal_s(conndata.port, "443"); + cl_assert_equal_s(conndata.path, "/resource"); + cl_assert_equal_s(conndata.username, "user"); + cl_assert_equal_s(conndata.password, "pass"); + cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1); +} + +void test_network_url_parse__ipv6_port(void) +{ + cl_git_pass(git_net_url_parse(&conndata, + "https://[fe80::dcad:beff:fe00:0001]:9191/resource")); + cl_assert_equal_s(conndata.scheme, "https"); + cl_assert_equal_s(conndata.host, "fe80::dcad:beff:fe00:0001"); + cl_assert_equal_s(conndata.port, "9191"); + cl_assert_equal_s(conndata.path, "/resource"); + cl_assert_equal_p(conndata.username, NULL); + cl_assert_equal_p(conndata.password, NULL); + cl_assert_equal_i(git_net_url_is_default_port(&conndata), 0); +} + +void test_network_url_parse__ipv6_empty_port(void) +{ + cl_git_pass(git_net_url_parse(&conndata, "http://[fe80::dcad:beff:fe00:0001]:/resource")); + cl_assert_equal_s(conndata.scheme, "http"); + cl_assert_equal_s(conndata.host, "fe80::dcad:beff:fe00:0001"); + cl_assert_equal_s(conndata.port, "80"); + cl_assert_equal_s(conndata.path, "/resource"); + cl_assert_equal_p(conndata.username, NULL); + cl_assert_equal_p(conndata.password, NULL); + cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1); +} + +void test_network_url_parse__ipv6_user_port(void) +{ + cl_git_pass(git_net_url_parse(&conndata, + "https://user@[fe80::dcad:beff:fe00:0001]:9191/resource")); + cl_assert_equal_s(conndata.scheme, "https"); + cl_assert_equal_s(conndata.host, "fe80::dcad:beff:fe00:0001"); + cl_assert_equal_s(conndata.port, "9191"); + cl_assert_equal_s(conndata.path, "/resource"); + cl_assert_equal_s(conndata.username, "user"); + cl_assert_equal_p(conndata.password, NULL); + cl_assert_equal_i(git_net_url_is_default_port(&conndata), 0); +} + +void test_network_url_parse__ipv6_user_pass_port(void) +{ + cl_git_pass(git_net_url_parse(&conndata, + "https://user:pass@[fe80::dcad:beff:fe00:0001]:9191/resource")); + cl_assert_equal_s(conndata.scheme, "https"); + cl_assert_equal_s(conndata.host, "fe80::dcad:beff:fe00:0001"); + cl_assert_equal_s(conndata.port, "9191"); + cl_assert_equal_s(conndata.path, "/resource"); + cl_assert_equal_s(conndata.username, "user"); + cl_assert_equal_s(conndata.password, "pass"); + cl_assert_equal_i(git_net_url_is_default_port(&conndata), 0); +} + +void test_network_url_parse__ipv6_invalid_addresses(void) +{ + /* Opening bracket missing */ + cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse(&conndata, + "http://fe80::dcad:beff:fe00:0001]/resource")); + cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse(&conndata, + "http://fe80::dcad:beff:fe00:0001]/")); + cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse(&conndata, + "http://fe80::dcad:beff:fe00:0001]")); + cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse(&conndata, + "http://fe80::dcad:beff:fe00:0001]:42")); + cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse(&conndata, + "http://fe80::dcad:beff:fe00:0001]:")); + cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse(&conndata, + "https://user:pass%2fis%40bad@fe80::dcad:beff:fe00:0001]:1234/")); + cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse(&conndata, + "https://user@fe80::dcad:beff:fe00:0001]/resource")); + cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse(&conndata, + "https://user:pass@fe80::dcad:beff:fe00:0001]/resource")); + cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse(&conndata, + "https://fe80::dcad:beff:fe00:0001]:9191/resource")); + cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse(&conndata, + "http://fe80::dcad:beff:fe00:0001]:/resource")); + cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse(&conndata, + "https://user@fe80::dcad:beff:fe00:0001]:9191/resource")); + cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse(&conndata, + "https://user:pass@fe80::dcad:beff:fe00:0001]:9191/resource")); + + /* Closing bracket missing */ + cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse(&conndata, + "http://[fe80::dcad:beff:fe00:0001/resource")); + cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse(&conndata, + "http://[fe80::dcad:beff:fe00:0001/")); + cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse(&conndata, + "http://[fe80::dcad:beff:fe00:0001")); + cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse(&conndata, + "http://[fe80::dcad:beff:fe00:0001:42")); + cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse(&conndata, + "http://[fe80::dcad:beff:fe00:0001:")); + cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse(&conndata, + "https://user:pass%2fis%40bad@[fe80::dcad:beff:fe00:0001:1234/")); + cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse(&conndata, + "https://user@[fe80::dcad:beff:fe00:0001/resource")); + cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse(&conndata, + "https://user:pass@[fe80::dcad:beff:fe00:0001/resource")); + cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse(&conndata, + "https://[fe80::dcad:beff:fe00:0001:9191/resource")); + cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse(&conndata, + "http://[fe80::dcad:beff:fe00:0001:/resource")); + cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse(&conndata, + "https://user@[fe80::dcad:beff:fe00:0001:9191/resource")); + cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse(&conndata, + "https://user:pass@[fe80::dcad:beff:fe00:0001:9191/resource")); + /* Both brackets missing */ + cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse(&conndata, + "http://fe80::dcad:beff:fe00:0001/resource")); + cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse(&conndata, + "http://fe80::dcad:beff:fe00:0001/")); + cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse(&conndata, + "http://fe80::dcad:beff:fe00:0001")); + cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse(&conndata, + "http://fe80::dcad:beff:fe00:0001:42")); + cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse(&conndata, + "http://fe80::dcad:beff:fe00:0001:")); + cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse(&conndata, + "https://user:pass%2fis%40bad@fe80::dcad:beff:fe00:0001:1234/")); + cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse(&conndata, + "https://user@fe80::dcad:beff:fe00:0001/resource")); + cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse(&conndata, + "https://user:pass@fe80::dcad:beff:fe00:0001/resource")); + cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse(&conndata, + "https://fe80::dcad:beff:fe00:0001:9191/resource")); + cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse(&conndata, + "http://fe80::dcad:beff:fe00:0001:/resource")); + cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse(&conndata, + "https://user@fe80::dcad:beff:fe00:0001:9191/resource")); + cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse(&conndata, + "https://user:pass@fe80::dcad:beff:fe00:0001:9191/resource")); + + /* Invalid chracter inside address */ + cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse(&conndata, "http://[fe8o::dcad:beff:fe00:0001]/resource")); +} diff --git a/tests/network/url/pattern.c b/tests/network/url/pattern.c new file mode 100644 index 000000000..5e4495f70 --- /dev/null +++ b/tests/network/url/pattern.c @@ -0,0 +1,103 @@ +#include "clar_libgit2.h" +#include "net.h" + +struct url_pattern { + const char *url; + const char *pattern; + bool matches; +}; + +void test_network_url_pattern__single(void) +{ + git_net_url url; + size_t i; + + struct url_pattern url_patterns[] = { + /* Wildcard matches */ + { "https://example.com/", "", false }, + { "https://example.com/", "*", true }, + + /* Literal and wildcard matches */ + { "https://example.com/", "example.com", true }, + { "https://example.com/", ".example.com", true }, + { "https://example.com/", "*.example.com", true }, + { "https://www.example.com/", "www.example.com", true }, + { "https://www.example.com/", ".example.com", true }, + { "https://www.example.com/", "*.example.com", true }, + + /* Literal and wildcard failures */ + { "https://example.com/", "example.org", false }, + { "https://example.com/", ".example.org", false }, + { "https://example.com/", "*.example.org", false }, + { "https://foo.example.com/", "www.example.com", false }, + + /* + * A port in the pattern is optional; if no port is + * present, it matches *all* ports. + */ + { "https://example.com/", "example.com:443", true }, + { "https://example.com/", "example.com:80", false }, + { "https://example.com:1443/", "example.com", true }, + + /* Failures with similar prefix/suffix */ + { "https://texample.com/", "example.com", false }, + { "https://example.com/", "mexample.com", false }, + { "https://example.com:44/", "example.com:443", false }, + { "https://example.com:443/", "example.com:44", false }, + }; + + for (i = 0; i < ARRAY_SIZE(url_patterns); i++) { + cl_git_pass(git_net_url_parse(&url, url_patterns[i].url)); + cl_assert_(git_net_url_matches_pattern(&url, url_patterns[i].pattern) == url_patterns[i].matches, url_patterns[i].pattern); + git_net_url_dispose(&url); + } +} + +void test_network_url_pattern__list(void) +{ + git_net_url url; + size_t i; + + struct url_pattern url_patterns[] = { + /* Wildcard matches */ + { "https://example.com/", "", false }, + { "https://example.com/", "*", true }, + { "https://example.com/", ",example.com,", true }, + { "https://example.com/", "foo,,example.com,,bar", true }, + { "https://example.com/", "foo,,zzz,,*,,bar", true }, + + /* Literals */ + { "https://example.com/", "example.com", true }, + { "https://example.com/", "foo.bar,example.com", true }, + { "https://example.com/", "foo.bar", false }, + { "https://example.com/", "foo.bar,example.org", false }, + { "https://www.example.com/", "foo.example.com,www.example.com,bar.example.com", true }, + { "https://www.example.com/", "foo.example.com,baz.example.com,bar.example.com", false }, + { "https://foo.example.com/", "www.example.com", false }, + { "https://foo.example.com/", "bar.example.com,www.example.com,", false }, + + /* Wildcards */ + { "https://example.com/", ".example.com", true }, + { "https://example.com/", "*.example.com", true }, + { "https://example.com/", "foo.com,bar.com,.example.com", true }, + { "https://example.com/", ".foo.com,.bar.com,.example.com", true }, + { "https://example.com/", ".foo.com,.bar.com,asdf.com", false }, + { "https://example.com/", "*.foo,*.bar,*.example.com,*.asdf", true }, + { "https://example.com/", "*.foo,*.bar,*.asdf", false }, + + + /* Ports! */ + { "https://example.com/", "example.com:443", true }, + { "https://example.com/", "example.com:42,example.com:443,example.com:99", true }, + { "https://example.com/", "example.com:42,example.com:80,example.org:443", false }, + { "https://example.com:1443/", "example.com", true }, + { "https://example.com:44/", "example.com:443", false }, + { "https://example.com:443/", "example.com:44", false }, + }; + + for (i = 0; i < ARRAY_SIZE(url_patterns); i++) { + cl_git_pass(git_net_url_parse(&url, url_patterns[i].url)); + cl_assert_(git_net_url_matches_pattern_list(&url, url_patterns[i].pattern) == url_patterns[i].matches, url_patterns[i].pattern); + git_net_url_dispose(&url); + } +} diff --git a/tests/network/redirect.c b/tests/network/url/redirect.c index 7ce1310db..2c0b614d9 100644 --- a/tests/network/redirect.c +++ b/tests/network/url/redirect.c @@ -4,17 +4,17 @@ static git_net_url conndata; -void test_network_redirect__initialize(void) +void test_network_url_redirect__initialize(void) { memset(&conndata, 0, sizeof(conndata)); } -void test_network_redirect__cleanup(void) +void test_network_url_redirect__cleanup(void) { git_net_url_dispose(&conndata); } -void test_network_redirect__redirect_http(void) +void test_network_url_redirect__redirect_http(void) { cl_git_pass(git_net_url_parse(&conndata, "http://example.com/foo/bar/baz")); @@ -28,7 +28,7 @@ void test_network_redirect__redirect_http(void) cl_assert_equal_p(conndata.password, NULL); } -void test_network_redirect__redirect_ssl(void) +void test_network_url_redirect__redirect_ssl(void) { cl_git_pass(git_net_url_parse(&conndata, "https://example.com/foo/bar/baz")); @@ -42,7 +42,7 @@ void test_network_redirect__redirect_ssl(void) cl_assert_equal_p(conndata.password, NULL); } -void test_network_redirect__redirect_leaves_root_path(void) +void test_network_url_redirect__redirect_leaves_root_path(void) { cl_git_pass(git_net_url_parse(&conndata, "https://example.com/foo/bar/baz")); @@ -56,7 +56,7 @@ void test_network_redirect__redirect_leaves_root_path(void) cl_assert_equal_p(conndata.password, NULL); } -void test_network_redirect__redirect_encoded_username_password(void) +void test_network_url_redirect__redirect_encoded_username_password(void) { cl_git_pass(git_net_url_parse(&conndata, "https://user%2fname:pass%40word%zyx%v@example.com/foo/bar/baz")); @@ -70,7 +70,7 @@ void test_network_redirect__redirect_encoded_username_password(void) cl_assert_equal_s(conndata.password, "pass@word%zyx%v"); } -void test_network_redirect__redirect_cross_host_denied(void) +void test_network_url_redirect__redirect_cross_host_denied(void) { cl_git_pass(git_net_url_parse(&conndata, "https://bar.com/bar/baz")); cl_git_fail_with(git_net_url_apply_redirect(&conndata, @@ -78,7 +78,7 @@ void test_network_redirect__redirect_cross_host_denied(void) -1); } -void test_network_redirect__redirect_http_downgrade_denied(void) +void test_network_url_redirect__redirect_http_downgrade_denied(void) { cl_git_pass(git_net_url_parse(&conndata, "https://foo.com/bar/baz")); cl_git_fail_with(git_net_url_apply_redirect(&conndata, @@ -86,7 +86,7 @@ void test_network_redirect__redirect_http_downgrade_denied(void) -1); } -void test_network_redirect__redirect_relative(void) +void test_network_url_redirect__redirect_relative(void) { cl_git_pass(git_net_url_parse(&conndata, "http://foo.com/bar/baz/biff")); cl_git_pass(git_net_url_apply_redirect(&conndata, @@ -99,7 +99,7 @@ void test_network_redirect__redirect_relative(void) cl_assert_equal_p(conndata.password, NULL); } -void test_network_redirect__redirect_relative_ssl(void) +void test_network_url_redirect__redirect_relative_ssl(void) { cl_git_pass(git_net_url_parse(&conndata, "https://foo.com/bar/baz/biff")); cl_git_pass(git_net_url_apply_redirect(&conndata, @@ -112,7 +112,7 @@ void test_network_redirect__redirect_relative_ssl(void) cl_assert_equal_p(conndata.password, NULL); } -void test_network_redirect__service_query_no_query_params_in_location(void) +void test_network_url_redirect__service_query_no_query_params_in_location(void) { cl_git_pass(git_net_url_parse(&conndata, "https://foo.com/bar/info/refs?service=git-upload-pack")); cl_git_pass(git_net_url_apply_redirect(&conndata, @@ -120,7 +120,7 @@ void test_network_redirect__service_query_no_query_params_in_location(void) cl_assert_equal_s(conndata.path, "/baz"); } -void test_network_redirect__service_query_with_query_params_in_location(void) +void test_network_url_redirect__service_query_with_query_params_in_location(void) { cl_git_pass(git_net_url_parse(&conndata, "https://foo.com/bar/info/refs?service=git-upload-pack")); cl_git_pass(git_net_url_apply_redirect(&conndata, diff --git a/tests/network/urlparse.c b/tests/network/urlparse.c deleted file mode 100644 index 15707885a..000000000 --- a/tests/network/urlparse.c +++ /dev/null @@ -1,168 +0,0 @@ -#include "clar_libgit2.h" -#include "net.h" - -static git_net_url conndata; - -void test_network_urlparse__initialize(void) -{ - memset(&conndata, 0, sizeof(conndata)); -} - -void test_network_urlparse__cleanup(void) -{ - git_net_url_dispose(&conndata); -} - -void test_network_urlparse__trivial(void) -{ - cl_git_pass(git_net_url_parse(&conndata, "http://example.com/resource")); - cl_assert_equal_s(conndata.scheme, "http"); - cl_assert_equal_s(conndata.host, "example.com"); - cl_assert_equal_s(conndata.port, "80"); - cl_assert_equal_s(conndata.path, "/resource"); - cl_assert_equal_p(conndata.username, NULL); - cl_assert_equal_p(conndata.password, NULL); - cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1); -} - -void test_network_urlparse__root(void) -{ - cl_git_pass(git_net_url_parse(&conndata, "http://example.com/")); - cl_assert_equal_s(conndata.scheme, "http"); - cl_assert_equal_s(conndata.host, "example.com"); - cl_assert_equal_s(conndata.port, "80"); - cl_assert_equal_s(conndata.path, "/"); - cl_assert_equal_p(conndata.username, NULL); - cl_assert_equal_p(conndata.password, NULL); - cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1); -} - -void test_network_urlparse__implied_root(void) -{ - cl_git_pass(git_net_url_parse(&conndata, "http://example.com")); - cl_assert_equal_s(conndata.scheme, "http"); - cl_assert_equal_s(conndata.host, "example.com"); - cl_assert_equal_s(conndata.port, "80"); - cl_assert_equal_s(conndata.path, "/"); - cl_assert_equal_p(conndata.username, NULL); - cl_assert_equal_p(conndata.password, NULL); - cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1); -} - -void test_network_urlparse__implied_root_custom_port(void) -{ - cl_git_pass(git_net_url_parse(&conndata, "http://example.com:42")); - cl_assert_equal_s(conndata.scheme, "http"); - cl_assert_equal_s(conndata.host, "example.com"); - cl_assert_equal_s(conndata.port, "42"); - cl_assert_equal_s(conndata.path, "/"); - cl_assert_equal_p(conndata.username, NULL); - cl_assert_equal_p(conndata.password, NULL); - cl_assert_equal_i(git_net_url_is_default_port(&conndata), 0); -} - -void test_network_urlparse__implied_root_empty_port(void) -{ - cl_git_pass(git_net_url_parse(&conndata, "http://example.com:")); - cl_assert_equal_s(conndata.scheme, "http"); - cl_assert_equal_s(conndata.host, "example.com"); - cl_assert_equal_s(conndata.port, "80"); - cl_assert_equal_s(conndata.path, "/"); - cl_assert_equal_p(conndata.username, NULL); - cl_assert_equal_p(conndata.password, NULL); - cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1); -} - -void test_network_urlparse__encoded_password(void) -{ - cl_git_pass(git_net_url_parse(&conndata, - "https://user:pass%2fis%40bad@hostname.com:1234/")); - cl_assert_equal_s(conndata.scheme, "https"); - cl_assert_equal_s(conndata.host, "hostname.com"); - cl_assert_equal_s(conndata.port, "1234"); - cl_assert_equal_s(conndata.path, "/"); - cl_assert_equal_s(conndata.username, "user"); - cl_assert_equal_s(conndata.password, "pass/is@bad"); - cl_assert_equal_i(git_net_url_is_default_port(&conndata), 0); -} - -void test_network_urlparse__user(void) -{ - cl_git_pass(git_net_url_parse(&conndata, - "https://user@example.com/resource")); - cl_assert_equal_s(conndata.scheme, "https"); - cl_assert_equal_s(conndata.host, "example.com"); - cl_assert_equal_s(conndata.port, "443"); - cl_assert_equal_s(conndata.path, "/resource"); - cl_assert_equal_s(conndata.username, "user"); - cl_assert_equal_p(conndata.password, NULL); - cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1); -} - -void test_network_urlparse__user_pass(void) -{ - /* user:pass@hostname.tld/resource */ - cl_git_pass(git_net_url_parse(&conndata, - "https://user:pass@example.com/resource")); - cl_assert_equal_s(conndata.scheme, "https"); - cl_assert_equal_s(conndata.host, "example.com"); - cl_assert_equal_s(conndata.port, "443"); - cl_assert_equal_s(conndata.path, "/resource"); - cl_assert_equal_s(conndata.username, "user"); - cl_assert_equal_s(conndata.password, "pass"); - cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1); -} - -void test_network_urlparse__port(void) -{ - /* hostname.tld:port/resource */ - cl_git_pass(git_net_url_parse(&conndata, - "https://example.com:9191/resource")); - cl_assert_equal_s(conndata.scheme, "https"); - cl_assert_equal_s(conndata.host, "example.com"); - cl_assert_equal_s(conndata.port, "9191"); - cl_assert_equal_s(conndata.path, "/resource"); - cl_assert_equal_p(conndata.username, NULL); - cl_assert_equal_p(conndata.password, NULL); - cl_assert_equal_i(git_net_url_is_default_port(&conndata), 0); -} - -void test_network_urlparse__empty_port(void) -{ - cl_git_pass(git_net_url_parse(&conndata, "http://example.com:/resource")); - cl_assert_equal_s(conndata.scheme, "http"); - cl_assert_equal_s(conndata.host, "example.com"); - cl_assert_equal_s(conndata.port, "80"); - cl_assert_equal_s(conndata.path, "/resource"); - cl_assert_equal_p(conndata.username, NULL); - cl_assert_equal_p(conndata.password, NULL); - cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1); -} - -void test_network_urlparse__user_port(void) -{ - /* user@hostname.tld:port/resource */ - cl_git_pass(git_net_url_parse(&conndata, - "https://user@example.com:9191/resource")); - cl_assert_equal_s(conndata.scheme, "https"); - cl_assert_equal_s(conndata.host, "example.com"); - cl_assert_equal_s(conndata.port, "9191"); - cl_assert_equal_s(conndata.path, "/resource"); - cl_assert_equal_s(conndata.username, "user"); - cl_assert_equal_p(conndata.password, NULL); - cl_assert_equal_i(git_net_url_is_default_port(&conndata), 0); -} - -void test_network_urlparse__user_pass_port(void) -{ - /* user:pass@hostname.tld:port/resource */ - cl_git_pass(git_net_url_parse(&conndata, - "https://user:pass@example.com:9191/resource")); - cl_assert_equal_s(conndata.scheme, "https"); - cl_assert_equal_s(conndata.host, "example.com"); - cl_assert_equal_s(conndata.port, "9191"); - cl_assert_equal_s(conndata.path, "/resource"); - cl_assert_equal_s(conndata.username, "user"); - cl_assert_equal_s(conndata.password, "pass"); - cl_assert_equal_i(git_net_url_is_default_port(&conndata), 0); -} diff --git a/tests/object/blob/filter.c b/tests/object/blob/filter.c index 0f0f4845f..a8e3d3097 100644 --- a/tests/object/blob/filter.c +++ b/tests/object/blob/filter.c @@ -1,7 +1,6 @@ #include "clar_libgit2.h" #include "posix.h" #include "blob.h" -#include "buf_text.h" static git_repository *g_repo = NULL; @@ -44,9 +43,9 @@ static git_buf_text_stats g_crlf_filtered_stats[CRLF_NUM_TEST_OBJECTS] = { { 0, 0, 2, 2, 2, 6, 0 }, { 0, 0, 4, 4, 1, 31, 0 }, { 0, 1, 1, 2, 1, 9, 5 }, - { GIT_BOM_UTF8, 0, 0, 1, 0, 16, 0 }, - { GIT_BOM_UTF8, 0, 2, 2, 2, 27, 0 }, - { GIT_BOM_UTF16_BE, 5, 0, 0, 0, 7, 5 }, + { GIT_BUF_BOM_UTF8, 0, 0, 1, 0, 16, 0 }, + { GIT_BUF_BOM_UTF8, 0, 2, 2, 2, 27, 0 }, + { GIT_BUF_BOM_UTF16_BE, 5, 0, 0, 0, 7, 5 }, }; void test_object_blob_filter__initialize(void) @@ -97,7 +96,7 @@ void test_object_blob_filter__stats(void) for (i = 0; i < CRLF_NUM_TEST_OBJECTS; i++) { cl_git_pass(git_blob_lookup(&blob, g_repo, &g_crlf_oids[i])); cl_git_pass(git_blob__getbuf(&buf, blob)); - git_buf_text_gather_stats(&stats, &buf, false); + git_buf_gather_text_stats(&stats, &buf, false); cl_assert_equal_i( 0, memcmp(&g_crlf_filtered_stats[i], &stats, sizeof(stats))); git_blob_free(blob); diff --git a/tests/object/tag/list.c b/tests/object/tag/list.c index 8a1a2d26d..d15f09205 100644 --- a/tests/object/tag/list.c +++ b/tests/object/tag/list.c @@ -20,7 +20,7 @@ static void ensure_tag_pattern_match(git_repository *repo, int already_found[MAX_USED_TAGS] = { 0 }; git_strarray tag_list; int error = 0; - size_t sucessfully_found = 0; + size_t successfully_found = 0; size_t i, j; cl_assert(data->expected_matches <= MAX_USED_TAGS); @@ -42,12 +42,12 @@ static void ensure_tag_pattern_match(git_repository *repo, if (!already_found[j] && !strcmp(data->expected_results[j], tag_list.strings[i])) { already_found[j] = 1; - sucessfully_found++; + successfully_found++; break; } } } - cl_assert_equal_i((int)sucessfully_found, (int)data->expected_matches); + cl_assert_equal_i((int)successfully_found, (int)data->expected_matches); exit: git_strarray_dispose(&tag_list); diff --git a/tests/odb/foreach.c b/tests/odb/foreach.c index 7a45a57ae..02112380b 100644 --- a/tests/odb/foreach.c +++ b/tests/odb/foreach.c @@ -127,7 +127,7 @@ void test_odb_foreach__files_in_objects_dir(void) cl_fixture_sandbox("testrepo.git"); cl_git_pass(git_repository_open(&repo, "testrepo.git")); - cl_git_pass(git_buf_printf(&buf, "%s/objects/somefile", git_repository_path(repo))); + cl_git_pass(git_buf_joinpath(&buf, git_repository_path(repo), "objects/somefile")); cl_git_mkfile(buf.ptr, ""); git_buf_dispose(&buf); diff --git a/tests/odb/sorting.c b/tests/odb/sorting.c index 6af8b0d1b..e027230fa 100644 --- a/tests/odb/sorting.c +++ b/tests/odb/sorting.c @@ -1,5 +1,6 @@ #include "clar_libgit2.h" #include "git2/sys/odb_backend.h" +#include "odb.h" typedef struct { git_odb_backend base; @@ -43,6 +44,11 @@ void test_odb_sorting__cleanup(void) { git_odb_free(_odb); _odb = NULL; + + cl_git_pass(git_libgit2_opts(GIT_OPT_SET_ODB_LOOSE_PRIORITY, + GIT_ODB_DEFAULT_LOOSE_PRIORITY)); + cl_git_pass(git_libgit2_opts(GIT_OPT_SET_ODB_PACKED_PRIORITY, + GIT_ODB_DEFAULT_PACKED_PRIORITY)); } void test_odb_sorting__basic_backends_sorting(void) @@ -68,3 +74,26 @@ void test_odb_sorting__alternate_backends_sorting(void) check_backend_sorting(_odb); } + +void test_odb_sorting__override_default_backend_priority(void) +{ + git_odb *new_odb; + git_odb_backend *loose, *packed, *backend; + cl_git_pass(git_libgit2_opts(GIT_OPT_SET_ODB_LOOSE_PRIORITY, 5)); + cl_git_pass(git_libgit2_opts(GIT_OPT_SET_ODB_PACKED_PRIORITY, 3)); + git_odb_backend_pack(&packed, "./testrepo.git/objects"); + git_odb_backend_loose(&loose, "./testrepo.git/objects", -1, 0, 0, 0); + + cl_git_pass(git_odb_open(&new_odb, cl_fixture("testrepo.git/objects"))); + cl_assert_equal_sz(2, git_odb_num_backends(new_odb)); + + cl_git_pass(git_odb_get_backend(&backend, new_odb, 0)); + cl_assert_equal_p(loose->read, backend->read); + + cl_git_pass(git_odb_get_backend(&backend, new_odb, 1)); + cl_assert_equal_p(packed->read, backend->read); + + git_odb_free(new_odb); + loose->free(loose); + packed->free(packed); +} diff --git a/tests/online/badssl.c b/tests/online/badssl.c index 6524fcd8e..6735e9cdb 100644 --- a/tests/online/badssl.c +++ b/tests/online/badssl.c @@ -67,14 +67,9 @@ void test_online_badssl__old_cipher(void) git_clone_options opts = GIT_CLONE_OPTIONS_INIT; opts.fetch_opts.callbacks.certificate_check = cert_check_assert_invalid; - /* FIXME: we don't actually reject RC4 anywhere, figure out what to tweak */ - cl_skip(); - if (!g_has_ssl) cl_skip(); - cl_git_fail_with(GIT_ECERTIFICATE, - git_clone(&g_repo, "https://rc4.badssl.com/fake.git", "./fake", NULL)); - cl_git_fail_with(GIT_ECERTIFICATE, - git_clone(&g_repo, "https://rc4.badssl.com/fake.git", "./fake", &opts)); + cl_git_fail(git_clone(&g_repo, "https://rc4.badssl.com/fake.git", "./fake", NULL)); + cl_git_fail(git_clone(&g_repo, "https://rc4.badssl.com/fake.git", "./fake", &opts)); } diff --git a/tests/online/clone.c b/tests/online/clone.c index 9107956bd..7d43c6a09 100644 --- a/tests/online/clone.c +++ b/tests/online/clone.c @@ -36,6 +36,7 @@ static char *_remote_expectcontinue = NULL; static int _orig_proxies_need_reset = 0; static char *_orig_http_proxy = NULL; static char *_orig_https_proxy = NULL; +static char *_orig_no_proxy = NULL; static int ssl_cert(git_cert *cert, int valid, const char *host, void *payload) { @@ -110,10 +111,14 @@ void test_online_clone__cleanup(void) if (_orig_proxies_need_reset) { cl_setenv("HTTP_PROXY", _orig_http_proxy); cl_setenv("HTTPS_PROXY", _orig_https_proxy); + cl_setenv("NO_PROXY", _orig_no_proxy); git__free(_orig_http_proxy); git__free(_orig_https_proxy); + git__free(_orig_no_proxy); } + + git_libgit2_opts(GIT_OPT_SET_SSL_CERT_LOCATIONS, NULL, NULL); } void test_online_clone__network_full(void) @@ -176,7 +181,7 @@ static int fetch_progress(const git_indexer_progress *stats, void *payload) void test_online_clone__can_checkout_a_cloned_repo(void) { git_buf path = GIT_BUF_INIT; - git_reference *head; + git_reference *head, *remote_head; bool checkout_progress_cb_was_called = false, fetch_progress_cb_was_called = false; @@ -195,9 +200,14 @@ void test_online_clone__can_checkout_a_cloned_repo(void) cl_assert_equal_i(GIT_REFERENCE_SYMBOLIC, git_reference_type(head)); cl_assert_equal_s("refs/heads/master", git_reference_symbolic_target(head)); + cl_git_pass(git_reference_lookup(&remote_head, g_repo, "refs/remotes/origin/HEAD")); + cl_assert_equal_i(GIT_REFERENCE_SYMBOLIC, git_reference_type(remote_head)); + cl_assert_equal_s("refs/remotes/origin/master", git_reference_symbolic_target(remote_head)); + cl_assert_equal_i(true, checkout_progress_cb_was_called); cl_assert_equal_i(true, fetch_progress_cb_was_called); + git_reference_free(remote_head); git_reference_free(head); git_buf_dispose(&path); } @@ -847,6 +857,7 @@ void test_online_clone__proxy_credentials_in_environment(void) _orig_http_proxy = cl_getenv("HTTP_PROXY"); _orig_https_proxy = cl_getenv("HTTPS_PROXY"); + _orig_no_proxy = cl_getenv("NO_PROXY"); _orig_proxies_need_reset = 1; g_options.fetch_opts.proxy_opts.type = GIT_PROXY_AUTO; @@ -858,12 +869,35 @@ void test_online_clone__proxy_credentials_in_environment(void) cl_setenv("HTTP_PROXY", url.ptr); cl_setenv("HTTPS_PROXY", url.ptr); + cl_setenv("NO_PROXY", NULL); cl_git_pass(git_clone(&g_repo, "http://github.com/libgit2/TestGitRepository", "./foo", &g_options)); git_buf_dispose(&url); } +void test_online_clone__proxy_credentials_in_url_https(void) +{ + git_buf url = GIT_BUF_INIT; + + if (!_remote_proxy_host || !_remote_proxy_user || !_remote_proxy_pass) + cl_skip(); + + cl_git_pass(git_buf_printf(&url, "%s://%s:%s@%s/", + _remote_proxy_scheme ? _remote_proxy_scheme : "http", + _remote_proxy_user, _remote_proxy_pass, _remote_proxy_host)); + + g_options.fetch_opts.proxy_opts.type = GIT_PROXY_SPECIFIED; + g_options.fetch_opts.proxy_opts.url = url.ptr; + g_options.fetch_opts.proxy_opts.certificate_check = proxy_cert_cb; + g_options.fetch_opts.callbacks.certificate_check = ssl_cert; + called_proxy_creds = 0; + cl_git_pass(git_clone(&g_repo, "https://github.com/libgit2/TestGitRepository", "./foo", &g_options)); + cl_assert(called_proxy_creds == 0); + + git_buf_dispose(&url); +} + void test_online_clone__proxy_auto_not_detected(void) { g_options.fetch_opts.proxy_opts.type = GIT_PROXY_AUTO; diff --git a/tests/online/customcert.c b/tests/online/customcert.c new file mode 100644 index 000000000..c7a0de1a1 --- /dev/null +++ b/tests/online/customcert.c @@ -0,0 +1,79 @@ +#include "clar_libgit2.h" + +#include "path.h" +#include "git2/clone.h" +#include "git2/cred_helpers.h" +#include "remote.h" +#include "futils.h" +#include "refs.h" + +/* + * Certificate one is in the `certs` folder; certificate two is in the + * `self-signed.pem` file. + */ +#define CUSTOM_CERT_ONE_URL "https://test.libgit2.org:1443/anonymous/test.git" +#define CUSTOM_CERT_ONE_PATH "certs" + +#define CUSTOM_CERT_TWO_URL "https://test.libgit2.org:2443/anonymous/test.git" +#define CUSTOM_CERT_TWO_FILE "self-signed.pem" + +#if (GIT_OPENSSL || GIT_MBEDTLS) +static git_repository *g_repo; +static int initialized = false; +#endif + +void test_online_customcert__initialize(void) +{ +#if (GIT_OPENSSL || GIT_MBEDTLS) + g_repo = NULL; + + if (!initialized) { + git_buf path = GIT_BUF_INIT, file = GIT_BUF_INIT; + char cwd[GIT_PATH_MAX]; + + cl_fixture_sandbox(CUSTOM_CERT_ONE_PATH); + cl_fixture_sandbox(CUSTOM_CERT_TWO_FILE); + + cl_must_pass(p_getcwd(cwd, GIT_PATH_MAX)); + cl_git_pass(git_buf_joinpath(&path, cwd, CUSTOM_CERT_ONE_PATH)); + cl_git_pass(git_buf_joinpath(&file, cwd, CUSTOM_CERT_TWO_FILE)); + + cl_git_pass(git_libgit2_opts(GIT_OPT_SET_SSL_CERT_LOCATIONS, + file.ptr, path.ptr)); + initialized = true; + + git_buf_dispose(&file); + git_buf_dispose(&path); + } +#endif +} + +void test_online_customcert__cleanup(void) +{ +#if (GIT_OPENSSL || GIT_MBEDTLS) + if (g_repo) { + git_repository_free(g_repo); + g_repo = NULL; + } + + cl_fixture_cleanup("./cloned"); + cl_fixture_cleanup(CUSTOM_CERT_ONE_PATH); + cl_fixture_cleanup(CUSTOM_CERT_TWO_FILE); +#endif +} + +void test_online_customcert__file(void) +{ +#if (GIT_OPENSSL || GIT_MBEDTLS) + cl_git_pass(git_clone(&g_repo, CUSTOM_CERT_ONE_URL, "./cloned", NULL)); + cl_assert(git_path_exists("./cloned/master.txt")); +#endif +} + +void test_online_customcert__path(void) +{ +#if (GIT_OPENSSL || GIT_MBEDTLS) + cl_git_pass(git_clone(&g_repo, CUSTOM_CERT_TWO_URL, "./cloned", NULL)); + cl_assert(git_path_exists("./cloned/master.txt")); +#endif +} diff --git a/tests/online/fetch.c b/tests/online/fetch.c index f939a16b8..67dfd69ed 100644 --- a/tests/online/fetch.c +++ b/tests/online/fetch.c @@ -3,9 +3,19 @@ static git_repository *_repo; static int counter; +static char *_remote_proxy_scheme = NULL; +static char *_remote_proxy_host = NULL; +static char *_remote_proxy_user = NULL; +static char *_remote_proxy_pass = NULL; + void test_online_fetch__initialize(void) { cl_git_pass(git_repository_init(&_repo, "./fetch", 0)); + + _remote_proxy_scheme = cl_getenv("GITTEST_REMOTE_PROXY_SCHEME"); + _remote_proxy_host = cl_getenv("GITTEST_REMOTE_PROXY_HOST"); + _remote_proxy_user = cl_getenv("GITTEST_REMOTE_PROXY_USER"); + _remote_proxy_pass = cl_getenv("GITTEST_REMOTE_PROXY_PASS"); } void test_online_fetch__cleanup(void) @@ -14,6 +24,11 @@ void test_online_fetch__cleanup(void) _repo = NULL; cl_fixture_cleanup("./fetch"); + + git__free(_remote_proxy_scheme); + git__free(_remote_proxy_host); + git__free(_remote_proxy_user); + git__free(_remote_proxy_pass); } static int update_tips(const char *refname, const git_oid *a, const git_oid *b, void *data) @@ -207,3 +222,28 @@ void test_online_fetch__twice(void) git_remote_free(remote); } + +void test_online_fetch__proxy(void) +{ + git_remote *remote; + git_buf url = GIT_BUF_INIT; + git_fetch_options fetch_opts; + + if (!_remote_proxy_host || !_remote_proxy_user || !_remote_proxy_pass) + cl_skip(); + + cl_git_pass(git_buf_printf(&url, "%s://%s:%s@%s/", + _remote_proxy_scheme ? _remote_proxy_scheme : "http", + _remote_proxy_user, _remote_proxy_pass, _remote_proxy_host)); + + cl_git_pass(git_fetch_options_init(&fetch_opts, GIT_FETCH_OPTIONS_VERSION)); + fetch_opts.proxy_opts.type = GIT_PROXY_SPECIFIED; + fetch_opts.proxy_opts.url = url.ptr; + + cl_git_pass(git_remote_create(&remote, _repo, "test", "https://github.com/libgit2/TestGitRepository.git")); + cl_git_pass(git_remote_connect(remote, GIT_DIRECTION_FETCH, NULL, &fetch_opts.proxy_opts, NULL)); + cl_git_pass(git_remote_fetch(remote, NULL, &fetch_opts, NULL)); + + git_remote_free(remote); + git_buf_dispose(&url); +} diff --git a/tests/online/push_util.c b/tests/online/push_util.c index fe9af2c43..b39f78114 100644 --- a/tests/online/push_util.c +++ b/tests/online/push_util.c @@ -58,12 +58,14 @@ int record_update_tips_cb(const char *refname, const git_oid *a, const git_oid * int create_deletion_refspecs(git_vector *out, const git_remote_head **heads, size_t heads_len) { git_buf del_spec = GIT_BUF_INIT; + int valid; size_t i; for (i = 0; i < heads_len; i++) { const git_remote_head *head = heads[i]; /* Ignore malformed ref names (which also saves us from tag^{} */ - if (!git_reference_is_valid_name(head->name)) + cl_git_pass(git_reference_name_is_valid(&valid, head->name)); + if (!valid) return 0; /* Create a refspec that deletes a branch in the remote */ diff --git a/tests/online/push_util.h b/tests/online/push_util.h index d829bbc4a..5f669feaf 100644 --- a/tests/online/push_util.h +++ b/tests/online/push_util.h @@ -12,7 +12,7 @@ extern const git_oid OID_ZERO; * @param data pointer to a record_callbacks_data instance */ #define RECORD_CALLBACKS_INIT(data) \ - { GIT_REMOTE_CALLBACKS_VERSION, NULL, NULL, cred_acquire_cb, NULL, NULL, record_update_tips_cb, NULL, NULL, NULL, NULL, NULL, data, NULL } + { GIT_REMOTE_CALLBACKS_VERSION, NULL, NULL, cred_acquire_cb, NULL, NULL, record_update_tips_cb, NULL, NULL, NULL, NULL, NULL, NULL, data, NULL } typedef struct { char *name; diff --git a/tests/pack/filelimit.c b/tests/pack/filelimit.c new file mode 100644 index 000000000..5e0b77e9b --- /dev/null +++ b/tests/pack/filelimit.c @@ -0,0 +1,136 @@ +#include "clar_libgit2.h" +#include "mwindow.h" + +#include <git2.h> +#include "git2/sys/commit.h" +#include "git2/sys/mempack.h" + +static size_t expected_open_mwindow_files = 0; +static size_t original_mwindow_file_limit = 0; + +extern git_mutex git__mwindow_mutex; +extern git_mwindow_ctl git_mwindow__mem_ctl; + +void test_pack_filelimit__initialize_tiny(void) +{ + expected_open_mwindow_files = 1; + cl_git_pass(git_libgit2_opts(GIT_OPT_GET_MWINDOW_FILE_LIMIT, &original_mwindow_file_limit)); + cl_git_pass(git_libgit2_opts(GIT_OPT_SET_MWINDOW_FILE_LIMIT, expected_open_mwindow_files)); +} + +void test_pack_filelimit__initialize_medium(void) +{ + expected_open_mwindow_files = 10; + cl_git_pass(git_libgit2_opts(GIT_OPT_GET_MWINDOW_FILE_LIMIT, &original_mwindow_file_limit)); + cl_git_pass(git_libgit2_opts(GIT_OPT_SET_MWINDOW_FILE_LIMIT, expected_open_mwindow_files)); +} + +void test_pack_filelimit__initialize_unlimited(void) +{ + expected_open_mwindow_files = 15; + cl_git_pass(git_libgit2_opts(GIT_OPT_GET_MWINDOW_FILE_LIMIT, &original_mwindow_file_limit)); + cl_git_pass(git_libgit2_opts(GIT_OPT_SET_MWINDOW_FILE_LIMIT, 0)); +} + +void test_pack_filelimit__cleanup(void) +{ + git_buf path = GIT_BUF_INIT; + cl_git_pass(git_libgit2_opts(GIT_OPT_SET_MWINDOW_FILE_LIMIT, original_mwindow_file_limit)); + + cl_git_pass(git_buf_joinpath(&path, clar_sandbox_path(), "repo.git")); + cl_fixture_cleanup(path.ptr); + git_buf_dispose(&path); +} + +/* + * Create a packfile with one commit, one tree, and two blobs. The first blob + * (README.md) has the same content in all commits, but the second one + * (file.txt) has a different content in each commit. + */ +void create_packfile_commit( + git_repository *repo, + git_oid *out_commit_id, + git_oid *parent_id, + size_t commit_index, + size_t commit_count) +{ + git_buf file_contents = GIT_BUF_INIT; + git_treebuilder *treebuilder; + git_packbuilder *packbuilder; + git_signature *s; + git_oid oid, tree_id, commit_id; + const git_oid *parents[] = { parent_id }; + size_t parent_count = parent_id ? 1 : 0; + + cl_git_pass(git_treebuilder_new(&treebuilder, repo, NULL)); + + cl_git_pass(git_blob_create_from_buffer(&oid, repo, "", 0)); + cl_git_pass(git_treebuilder_insert(NULL, treebuilder, "README.md", &oid, 0100644)); + + cl_git_pass(git_buf_printf(&file_contents, "Commit %zd/%zd", commit_index, commit_count)); + cl_git_pass(git_blob_create_from_buffer(&oid, repo, file_contents.ptr, file_contents.size)); + cl_git_pass(git_treebuilder_insert(NULL, treebuilder, "file.txt", &oid, 0100644)); + + cl_git_pass(git_treebuilder_write(&tree_id, treebuilder)); + cl_git_pass(git_signature_now(&s, "alice", "alice@example.com")); + cl_git_pass(git_commit_create_from_ids(&commit_id, repo, "refs/heads/master", s, s, + NULL, file_contents.ptr, &tree_id, parent_count, parents)); + + cl_git_pass(git_packbuilder_new(&packbuilder, repo)); + cl_git_pass(git_packbuilder_insert_commit(packbuilder, &commit_id)); + cl_git_pass(git_packbuilder_write(packbuilder, NULL, 0, NULL, NULL)); + + cl_git_pass(git_oid_cpy(out_commit_id, &commit_id)); + + git_buf_dispose(&file_contents); + git_treebuilder_free(treebuilder); + git_packbuilder_free(packbuilder); + git_signature_free(s); +} + +void test_pack_filelimit__open_repo_with_multiple_packfiles(void) +{ + git_buf path = GIT_BUF_INIT; + git_mwindow_ctl *ctl = &git_mwindow__mem_ctl; + git_repository *repo; + git_revwalk *walk; + git_oid id, *parent_id = NULL; + size_t i; + const size_t commit_count = 16; + unsigned int open_windows; + + /* + * Create a repository and populate it with 16 commits, each in its own + * packfile. + */ + cl_git_pass(git_buf_joinpath(&path, clar_sandbox_path(), "repo.git")); + cl_git_pass(git_repository_init(&repo, path.ptr, true)); + for (i = 0; i < commit_count; ++i) { + create_packfile_commit(repo, &id, parent_id, i + 1, commit_count); + parent_id = &id; + } + + cl_git_pass(git_revwalk_new(&walk, repo)); + cl_git_pass(git_revwalk_sorting(walk, GIT_SORT_TOPOLOGICAL)); + cl_git_pass(git_revwalk_push_ref(walk, "refs/heads/master")); + + /* Walking the repository requires eventually opening each of the packfiles. */ + i = 0; + while (git_revwalk_next(&id, walk) == 0) + ++i; + cl_assert_equal_i(commit_count, i); + + cl_git_pass(git_mutex_lock(&git__mwindow_mutex)); + /* + * Adding an assert while holding a lock will cause the whole process to + * deadlock. Copy the value and do the assert after releasing the lock. + */ + open_windows = ctl->open_windows; + cl_git_pass(git_mutex_unlock(&git__mwindow_mutex)); + + cl_assert_equal_i(expected_open_mwindow_files, open_windows); + + git_buf_dispose(&path); + git_revwalk_free(walk); + git_repository_free(repo); +} diff --git a/tests/pack/midx.c b/tests/pack/midx.c new file mode 100644 index 000000000..d5b91d28b --- /dev/null +++ b/tests/pack/midx.c @@ -0,0 +1,110 @@ +#include "clar_libgit2.h" + +#include <git2.h> +#include <git2/sys/midx.h> + +#include "futils.h" +#include "midx.h" + +void test_pack_midx__parse(void) +{ + git_repository *repo; + struct git_midx_file *idx; + struct git_midx_entry e; + git_oid id; + git_buf midx_path = GIT_BUF_INIT; + + cl_git_pass(git_repository_open(&repo, cl_fixture("testrepo.git"))); + cl_git_pass(git_buf_joinpath(&midx_path, git_repository_path(repo), "objects/pack/multi-pack-index")); + cl_git_pass(git_midx_open(&idx, git_buf_cstr(&midx_path))); + cl_assert_equal_i(git_midx_needs_refresh(idx, git_buf_cstr(&midx_path)), 0); + + cl_git_pass(git_oid_fromstr(&id, "5001298e0c09ad9c34e4249bc5801c75e9754fa5")); + cl_git_pass(git_midx_entry_find(&e, idx, &id, GIT_OID_HEXSZ)); + cl_assert_equal_oid(&e.sha1, &id); + cl_assert_equal_s( + (const char *)git_vector_get(&idx->packfile_names, e.pack_index), + "pack-d7c6adf9f61318f041845b01440d09aa7a91e1b5.idx"); + + git_midx_free(idx); + git_repository_free(repo); + git_buf_dispose(&midx_path); +} + +void test_pack_midx__lookup(void) +{ + git_repository *repo; + git_commit *commit; + git_oid id; + + cl_git_pass(git_repository_open(&repo, cl_fixture("testrepo.git"))); + + cl_git_pass(git_oid_fromstr(&id, "5001298e0c09ad9c34e4249bc5801c75e9754fa5")); + cl_git_pass(git_commit_lookup_prefix(&commit, repo, &id, GIT_OID_HEXSZ)); + cl_assert_equal_s(git_commit_message(commit), "packed commit one\n"); + + git_commit_free(commit); + git_repository_free(repo); +} + +void test_pack_midx__writer(void) +{ + git_repository *repo; + git_midx_writer *w = NULL; + git_buf midx = GIT_BUF_INIT, expected_midx = GIT_BUF_INIT, path = GIT_BUF_INIT; + + cl_git_pass(git_repository_open(&repo, cl_fixture("testrepo.git"))); + + cl_git_pass(git_buf_joinpath(&path, git_repository_path(repo), "objects/pack")); + cl_git_pass(git_midx_writer_new(&w, git_buf_cstr(&path))); + + cl_git_pass(git_midx_writer_add(w, "pack-d7c6adf9f61318f041845b01440d09aa7a91e1b5.idx")); + cl_git_pass(git_midx_writer_add(w, "pack-d85f5d483273108c9d8dd0e4728ccf0b2982423a.idx")); + cl_git_pass(git_midx_writer_add(w, "pack-a81e489679b7d3418f9ab594bda8ceb37dd4c695.idx")); + + cl_git_pass(git_midx_writer_dump(&midx, w)); + cl_git_pass(git_buf_joinpath(&path, git_repository_path(repo), "objects/pack/multi-pack-index")); + cl_git_pass(git_futils_readbuffer(&expected_midx, git_buf_cstr(&path))); + + cl_assert_equal_i(git_buf_len(&midx), git_buf_len(&expected_midx)); + cl_assert_equal_strn(git_buf_cstr(&midx), git_buf_cstr(&expected_midx), git_buf_len(&midx)); + + git_buf_dispose(&midx); + git_buf_dispose(&expected_midx); + git_buf_dispose(&path); + git_midx_writer_free(w); + git_repository_free(repo); +} + +void test_pack_midx__odb_create(void) +{ + git_repository *repo; + git_odb *odb; + git_clone_options opts = GIT_CLONE_OPTIONS_INIT; + git_buf midx = GIT_BUF_INIT, expected_midx = GIT_BUF_INIT, midx_path = GIT_BUF_INIT; + struct stat st; + + opts.bare = true; + opts.local = GIT_CLONE_LOCAL; + cl_git_pass(git_clone(&repo, cl_fixture("testrepo/.gitted"), "./clone.git", &opts)); + cl_git_pass(git_buf_joinpath(&midx_path, git_repository_path(repo), "objects/pack/multi-pack-index")); + cl_git_fail(p_stat(git_buf_cstr(&midx_path), &st)); + + cl_git_pass(git_repository_odb(&odb, repo)); + cl_git_pass(git_odb_write_multi_pack_index(odb)); + git_odb_free(odb); + + cl_git_pass(p_stat(git_buf_cstr(&midx_path), &st)); + + cl_git_pass(git_futils_readbuffer(&expected_midx, cl_fixture("testrepo.git/objects/pack/multi-pack-index"))); + cl_git_pass(git_futils_readbuffer(&midx, git_buf_cstr(&midx_path))); + cl_assert_equal_i(git_buf_len(&midx), git_buf_len(&expected_midx)); + cl_assert_equal_strn(git_buf_cstr(&midx), git_buf_cstr(&expected_midx), git_buf_len(&midx)); + + git_repository_free(repo); + git_buf_dispose(&midx); + git_buf_dispose(&midx_path); + git_buf_dispose(&expected_midx); + + cl_git_pass(git_futils_rmdir_r("./clone.git", NULL, GIT_RMDIR_REMOVE_FILES)); +}
\ No newline at end of file diff --git a/tests/pack/threadsafety.c b/tests/pack/threadsafety.c new file mode 100644 index 000000000..fd6a61fbd --- /dev/null +++ b/tests/pack/threadsafety.c @@ -0,0 +1,62 @@ +#include "clar_libgit2.h" +#include "pool.h" + +#include <git2.h> +#include "git2/sys/commit.h" +#include "git2/sys/mempack.h" + +static size_t original_mwindow_file_limit = 0; + +void test_pack_threadsafety__initialize(void) +{ + size_t open_mwindow_files = 1; + + cl_git_pass(git_libgit2_opts(GIT_OPT_GET_MWINDOW_FILE_LIMIT, &original_mwindow_file_limit)); + cl_git_pass(git_libgit2_opts(GIT_OPT_SET_MWINDOW_FILE_LIMIT, open_mwindow_files)); +} + +void test_pack_threadsafety__cleanup(void) +{ + cl_git_pass(git_libgit2_opts(GIT_OPT_SET_MWINDOW_FILE_LIMIT, original_mwindow_file_limit)); +} + +#ifdef GIT_THREADS +static void *get_status(void *arg) +{ + const char *repo_path = (const char *)arg; + git_repository *repo; + git_status_list *status; + + cl_git_pass(git_repository_open(&repo, repo_path)); + cl_git_pass(git_status_list_new(&status, repo, NULL)); + git_status_list_free(status); + git_repository_free(repo); + + return NULL; +} +#endif + +void test_pack_threadsafety__open_repo_in_multiple_threads(void) +{ +#ifdef GIT_THREADS + const char *repo_path = cl_fixture("../.."); + git_repository *repo; + git_thread threads[8]; + size_t i; + + /* If we can't open the libgit2 repo or if it isn't a full repo + * with proper history, just skip this test */ + if (git_repository_open(&repo, repo_path) < 0) + cl_skip(); + if (git_repository_is_shallow(repo)) + cl_skip(); + git_repository_free(repo); + + for (i = 0; i < ARRAY_SIZE(threads); i++) + git_thread_create(&threads[i], get_status, (void *)repo_path); + for (i = 0; i < ARRAY_SIZE(threads); i++) + git_thread_join(&threads[i], NULL); +#else + cl_skip(); +#endif +} diff --git a/tests/path/core.c b/tests/path/core.c index 48b518c8d..c875a862c 100644 --- a/tests/path/core.c +++ b/tests/path/core.c @@ -1,6 +1,11 @@ #include "clar_libgit2.h" #include "path.h" +void test_path_core__cleanup(void) +{ + cl_git_sandbox_cleanup(); +} + static void test_make_relative( const char *expected_path, const char *path, @@ -44,266 +49,322 @@ void test_path_core__make_relative(void) test_make_relative("/path/to/foo.c", "/path/to/foo.c", "d:/path/to", GIT_ENOTFOUND); test_make_relative("d:/path/to/foo.c", "d:/path/to/foo.c", "/path/to", GIT_ENOTFOUND); - + test_make_relative("/path/to/foo.c", "/path/to/foo.c", "not-a-rooted-path", GIT_ENOTFOUND); test_make_relative("not-a-rooted-path", "not-a-rooted-path", "/path/to", GIT_ENOTFOUND); - + test_make_relative("/path", "/path", "pathtofoo", GIT_ENOTFOUND); test_make_relative("path", "path", "pathtofoo", GIT_ENOTFOUND); } void test_path_core__isvalid_standard(void) { - cl_assert_equal_b(true, git_path_isvalid(NULL, "foo/bar", 0, 0)); - cl_assert_equal_b(true, git_path_isvalid(NULL, "foo/bar/file.txt", 0, 0)); - cl_assert_equal_b(true, git_path_isvalid(NULL, "foo/bar/.file", 0, 0)); + cl_assert_equal_b(true, git_path_validate(NULL, "foo/bar", 0, 0)); + cl_assert_equal_b(true, git_path_validate(NULL, "foo/bar/file.txt", 0, 0)); + cl_assert_equal_b(true, git_path_validate(NULL, "foo/bar/.file", 0, 0)); } void test_path_core__isvalid_empty_dir_component(void) { - cl_assert_equal_b(false, git_path_isvalid(NULL, "foo//bar", 0, 0)); + cl_assert_equal_b(false, git_path_validate(NULL, "foo//bar", 0, 0)); /* leading slash */ - cl_assert_equal_b(false, git_path_isvalid(NULL, "/", 0, 0)); - cl_assert_equal_b(false, git_path_isvalid(NULL, "/foo", 0, 0)); - cl_assert_equal_b(false, git_path_isvalid(NULL, "/foo/bar", 0, 0)); + cl_assert_equal_b(false, git_path_validate(NULL, "/", 0, 0)); + cl_assert_equal_b(false, git_path_validate(NULL, "/foo", 0, 0)); + cl_assert_equal_b(false, git_path_validate(NULL, "/foo/bar", 0, 0)); /* trailing slash */ - cl_assert_equal_b(false, git_path_isvalid(NULL, "foo/", 0, 0)); - cl_assert_equal_b(false, git_path_isvalid(NULL, "foo/bar/", 0, 0)); + cl_assert_equal_b(false, git_path_validate(NULL, "foo/", 0, 0)); + cl_assert_equal_b(false, git_path_validate(NULL, "foo/bar/", 0, 0)); } void test_path_core__isvalid_dot_and_dotdot(void) { - cl_assert_equal_b(true, git_path_isvalid(NULL, ".", 0, 0)); - cl_assert_equal_b(true, git_path_isvalid(NULL, "./foo", 0, 0)); - cl_assert_equal_b(true, git_path_isvalid(NULL, "foo/.", 0, 0)); - cl_assert_equal_b(true, git_path_isvalid(NULL, "./foo", 0, 0)); - - cl_assert_equal_b(true, git_path_isvalid(NULL, "..", 0, 0)); - cl_assert_equal_b(true, git_path_isvalid(NULL, "../foo", 0, 0)); - cl_assert_equal_b(true, git_path_isvalid(NULL, "foo/..", 0, 0)); - cl_assert_equal_b(true, git_path_isvalid(NULL, "../foo", 0, 0)); - - cl_assert_equal_b(false, git_path_isvalid(NULL, ".", 0, GIT_PATH_REJECT_TRAVERSAL)); - cl_assert_equal_b(false, git_path_isvalid(NULL, "./foo", 0, GIT_PATH_REJECT_TRAVERSAL)); - cl_assert_equal_b(false, git_path_isvalid(NULL, "foo/.", 0, GIT_PATH_REJECT_TRAVERSAL)); - cl_assert_equal_b(false, git_path_isvalid(NULL, "./foo", 0, GIT_PATH_REJECT_TRAVERSAL)); - - cl_assert_equal_b(false, git_path_isvalid(NULL, "..", 0, GIT_PATH_REJECT_TRAVERSAL)); - cl_assert_equal_b(false, git_path_isvalid(NULL, "../foo", 0, GIT_PATH_REJECT_TRAVERSAL)); - cl_assert_equal_b(false, git_path_isvalid(NULL, "foo/..", 0, GIT_PATH_REJECT_TRAVERSAL)); - cl_assert_equal_b(false, git_path_isvalid(NULL, "../foo", 0, GIT_PATH_REJECT_TRAVERSAL)); + cl_assert_equal_b(true, git_path_validate(NULL, ".", 0, 0)); + cl_assert_equal_b(true, git_path_validate(NULL, "./foo", 0, 0)); + cl_assert_equal_b(true, git_path_validate(NULL, "foo/.", 0, 0)); + cl_assert_equal_b(true, git_path_validate(NULL, "./foo", 0, 0)); + + cl_assert_equal_b(true, git_path_validate(NULL, "..", 0, 0)); + cl_assert_equal_b(true, git_path_validate(NULL, "../foo", 0, 0)); + cl_assert_equal_b(true, git_path_validate(NULL, "foo/..", 0, 0)); + cl_assert_equal_b(true, git_path_validate(NULL, "../foo", 0, 0)); + + cl_assert_equal_b(false, git_path_validate(NULL, ".", 0, GIT_PATH_REJECT_TRAVERSAL)); + cl_assert_equal_b(false, git_path_validate(NULL, "./foo", 0, GIT_PATH_REJECT_TRAVERSAL)); + cl_assert_equal_b(false, git_path_validate(NULL, "foo/.", 0, GIT_PATH_REJECT_TRAVERSAL)); + cl_assert_equal_b(false, git_path_validate(NULL, "./foo", 0, GIT_PATH_REJECT_TRAVERSAL)); + + cl_assert_equal_b(false, git_path_validate(NULL, "..", 0, GIT_PATH_REJECT_TRAVERSAL)); + cl_assert_equal_b(false, git_path_validate(NULL, "../foo", 0, GIT_PATH_REJECT_TRAVERSAL)); + cl_assert_equal_b(false, git_path_validate(NULL, "foo/..", 0, GIT_PATH_REJECT_TRAVERSAL)); + cl_assert_equal_b(false, git_path_validate(NULL, "../foo", 0, GIT_PATH_REJECT_TRAVERSAL)); } void test_path_core__isvalid_dot_git(void) { - cl_assert_equal_b(true, git_path_isvalid(NULL, ".git", 0, 0)); - cl_assert_equal_b(true, git_path_isvalid(NULL, ".git/foo", 0, 0)); - cl_assert_equal_b(true, git_path_isvalid(NULL, "foo/.git", 0, 0)); - cl_assert_equal_b(true, git_path_isvalid(NULL, "foo/.git/bar", 0, 0)); - cl_assert_equal_b(true, git_path_isvalid(NULL, "foo/.GIT/bar", 0, 0)); - cl_assert_equal_b(true, git_path_isvalid(NULL, "foo/bar/.Git", 0, 0)); - - cl_assert_equal_b(false, git_path_isvalid(NULL, ".git", 0, GIT_PATH_REJECT_DOT_GIT_LITERAL)); - cl_assert_equal_b(false, git_path_isvalid(NULL, ".git/foo", 0, GIT_PATH_REJECT_DOT_GIT_LITERAL)); - cl_assert_equal_b(false, git_path_isvalid(NULL, "foo/.git", 0, GIT_PATH_REJECT_DOT_GIT_LITERAL)); - cl_assert_equal_b(false, git_path_isvalid(NULL, "foo/.git/bar", 0, GIT_PATH_REJECT_DOT_GIT_LITERAL)); - cl_assert_equal_b(false, git_path_isvalid(NULL, "foo/.GIT/bar", 0, GIT_PATH_REJECT_DOT_GIT_LITERAL)); - cl_assert_equal_b(false, git_path_isvalid(NULL, "foo/bar/.Git", 0, GIT_PATH_REJECT_DOT_GIT_LITERAL)); - - cl_assert_equal_b(true, git_path_isvalid(NULL, "!git", 0, 0)); - cl_assert_equal_b(true, git_path_isvalid(NULL, "foo/!git", 0, 0)); - cl_assert_equal_b(true, git_path_isvalid(NULL, "!git/bar", 0, 0)); - cl_assert_equal_b(true, git_path_isvalid(NULL, ".tig", 0, 0)); - cl_assert_equal_b(true, git_path_isvalid(NULL, "foo/.tig", 0, 0)); - cl_assert_equal_b(true, git_path_isvalid(NULL, ".tig/bar", 0, 0)); + cl_assert_equal_b(true, git_path_validate(NULL, ".git", 0, 0)); + cl_assert_equal_b(true, git_path_validate(NULL, ".git/foo", 0, 0)); + cl_assert_equal_b(true, git_path_validate(NULL, "foo/.git", 0, 0)); + cl_assert_equal_b(true, git_path_validate(NULL, "foo/.git/bar", 0, 0)); + cl_assert_equal_b(true, git_path_validate(NULL, "foo/.GIT/bar", 0, 0)); + cl_assert_equal_b(true, git_path_validate(NULL, "foo/bar/.Git", 0, 0)); + + cl_assert_equal_b(false, git_path_validate(NULL, ".git", 0, GIT_PATH_REJECT_DOT_GIT_LITERAL)); + cl_assert_equal_b(false, git_path_validate(NULL, ".git/foo", 0, GIT_PATH_REJECT_DOT_GIT_LITERAL)); + cl_assert_equal_b(false, git_path_validate(NULL, "foo/.git", 0, GIT_PATH_REJECT_DOT_GIT_LITERAL)); + cl_assert_equal_b(false, git_path_validate(NULL, "foo/.git/bar", 0, GIT_PATH_REJECT_DOT_GIT_LITERAL)); + cl_assert_equal_b(false, git_path_validate(NULL, "foo/.GIT/bar", 0, GIT_PATH_REJECT_DOT_GIT_LITERAL)); + cl_assert_equal_b(false, git_path_validate(NULL, "foo/bar/.Git", 0, GIT_PATH_REJECT_DOT_GIT_LITERAL)); + + cl_assert_equal_b(true, git_path_validate(NULL, "!git", 0, 0)); + cl_assert_equal_b(true, git_path_validate(NULL, "foo/!git", 0, 0)); + cl_assert_equal_b(true, git_path_validate(NULL, "!git/bar", 0, 0)); + cl_assert_equal_b(true, git_path_validate(NULL, ".tig", 0, 0)); + cl_assert_equal_b(true, git_path_validate(NULL, "foo/.tig", 0, 0)); + cl_assert_equal_b(true, git_path_validate(NULL, ".tig/bar", 0, 0)); } void test_path_core__isvalid_backslash(void) { - cl_assert_equal_b(true, git_path_isvalid(NULL, "foo\\file.txt", 0, 0)); - cl_assert_equal_b(true, git_path_isvalid(NULL, "foo/bar\\file.txt", 0, 0)); - cl_assert_equal_b(true, git_path_isvalid(NULL, "foo/bar\\", 0, 0)); + cl_assert_equal_b(true, git_path_validate(NULL, "foo\\file.txt", 0, 0)); + cl_assert_equal_b(true, git_path_validate(NULL, "foo/bar\\file.txt", 0, 0)); + cl_assert_equal_b(true, git_path_validate(NULL, "foo/bar\\", 0, 0)); - cl_assert_equal_b(false, git_path_isvalid(NULL, "foo\\file.txt", 0, GIT_PATH_REJECT_BACKSLASH)); - cl_assert_equal_b(false, git_path_isvalid(NULL, "foo/bar\\file.txt", 0, GIT_PATH_REJECT_BACKSLASH)); - cl_assert_equal_b(false, git_path_isvalid(NULL, "foo/bar\\", 0, GIT_PATH_REJECT_BACKSLASH)); + cl_assert_equal_b(false, git_path_validate(NULL, "foo\\file.txt", 0, GIT_PATH_REJECT_BACKSLASH)); + cl_assert_equal_b(false, git_path_validate(NULL, "foo/bar\\file.txt", 0, GIT_PATH_REJECT_BACKSLASH)); + cl_assert_equal_b(false, git_path_validate(NULL, "foo/bar\\", 0, GIT_PATH_REJECT_BACKSLASH)); } void test_path_core__isvalid_trailing_dot(void) { - cl_assert_equal_b(true, git_path_isvalid(NULL, "foo.", 0, 0)); - cl_assert_equal_b(true, git_path_isvalid(NULL, "foo...", 0, 0)); - cl_assert_equal_b(true, git_path_isvalid(NULL, "foo/bar.", 0, 0)); - cl_assert_equal_b(true, git_path_isvalid(NULL, "foo./bar", 0, 0)); - - cl_assert_equal_b(false, git_path_isvalid(NULL, "foo.", 0, GIT_PATH_REJECT_TRAILING_DOT)); - cl_assert_equal_b(false, git_path_isvalid(NULL, "foo...", 0, GIT_PATH_REJECT_TRAILING_DOT)); - cl_assert_equal_b(false, git_path_isvalid(NULL, "foo/bar.", 0, GIT_PATH_REJECT_TRAILING_DOT)); - cl_assert_equal_b(false, git_path_isvalid(NULL, "foo./bar", 0, GIT_PATH_REJECT_TRAILING_DOT)); + cl_assert_equal_b(true, git_path_validate(NULL, "foo.", 0, 0)); + cl_assert_equal_b(true, git_path_validate(NULL, "foo...", 0, 0)); + cl_assert_equal_b(true, git_path_validate(NULL, "foo/bar.", 0, 0)); + cl_assert_equal_b(true, git_path_validate(NULL, "foo./bar", 0, 0)); + + cl_assert_equal_b(false, git_path_validate(NULL, "foo.", 0, GIT_PATH_REJECT_TRAILING_DOT)); + cl_assert_equal_b(false, git_path_validate(NULL, "foo...", 0, GIT_PATH_REJECT_TRAILING_DOT)); + cl_assert_equal_b(false, git_path_validate(NULL, "foo/bar.", 0, GIT_PATH_REJECT_TRAILING_DOT)); + cl_assert_equal_b(false, git_path_validate(NULL, "foo./bar", 0, GIT_PATH_REJECT_TRAILING_DOT)); } void test_path_core__isvalid_trailing_space(void) { - cl_assert_equal_b(true, git_path_isvalid(NULL, "foo ", 0, 0)); - cl_assert_equal_b(true, git_path_isvalid(NULL, "foo ", 0, 0)); - cl_assert_equal_b(true, git_path_isvalid(NULL, "foo/bar ", 0, 0)); - cl_assert_equal_b(true, git_path_isvalid(NULL, " ", 0, 0)); - cl_assert_equal_b(true, git_path_isvalid(NULL, "foo /bar", 0, 0)); - - cl_assert_equal_b(false, git_path_isvalid(NULL, "foo ", 0, GIT_PATH_REJECT_TRAILING_SPACE)); - cl_assert_equal_b(false, git_path_isvalid(NULL, "foo ", 0, GIT_PATH_REJECT_TRAILING_SPACE)); - cl_assert_equal_b(false, git_path_isvalid(NULL, "foo/bar ", 0, GIT_PATH_REJECT_TRAILING_SPACE)); - cl_assert_equal_b(false, git_path_isvalid(NULL, " ", 0, GIT_PATH_REJECT_TRAILING_SPACE)); - cl_assert_equal_b(false, git_path_isvalid(NULL, "foo /bar", 0, GIT_PATH_REJECT_TRAILING_SPACE)); + cl_assert_equal_b(true, git_path_validate(NULL, "foo ", 0, 0)); + cl_assert_equal_b(true, git_path_validate(NULL, "foo ", 0, 0)); + cl_assert_equal_b(true, git_path_validate(NULL, "foo/bar ", 0, 0)); + cl_assert_equal_b(true, git_path_validate(NULL, " ", 0, 0)); + cl_assert_equal_b(true, git_path_validate(NULL, "foo /bar", 0, 0)); + + cl_assert_equal_b(false, git_path_validate(NULL, "foo ", 0, GIT_PATH_REJECT_TRAILING_SPACE)); + cl_assert_equal_b(false, git_path_validate(NULL, "foo ", 0, GIT_PATH_REJECT_TRAILING_SPACE)); + cl_assert_equal_b(false, git_path_validate(NULL, "foo/bar ", 0, GIT_PATH_REJECT_TRAILING_SPACE)); + cl_assert_equal_b(false, git_path_validate(NULL, " ", 0, GIT_PATH_REJECT_TRAILING_SPACE)); + cl_assert_equal_b(false, git_path_validate(NULL, "foo /bar", 0, GIT_PATH_REJECT_TRAILING_SPACE)); } void test_path_core__isvalid_trailing_colon(void) { - cl_assert_equal_b(true, git_path_isvalid(NULL, "foo:", 0, 0)); - cl_assert_equal_b(true, git_path_isvalid(NULL, "foo/bar:", 0, 0)); - cl_assert_equal_b(true, git_path_isvalid(NULL, ":", 0, 0)); - cl_assert_equal_b(true, git_path_isvalid(NULL, "foo:/bar", 0, 0)); - - cl_assert_equal_b(false, git_path_isvalid(NULL, "foo:", 0, GIT_PATH_REJECT_TRAILING_COLON)); - cl_assert_equal_b(false, git_path_isvalid(NULL, "foo/bar:", 0, GIT_PATH_REJECT_TRAILING_COLON)); - cl_assert_equal_b(false, git_path_isvalid(NULL, ":", 0, GIT_PATH_REJECT_TRAILING_COLON)); - cl_assert_equal_b(false, git_path_isvalid(NULL, "foo:/bar", 0, GIT_PATH_REJECT_TRAILING_COLON)); + cl_assert_equal_b(true, git_path_validate(NULL, "foo:", 0, 0)); + cl_assert_equal_b(true, git_path_validate(NULL, "foo/bar:", 0, 0)); + cl_assert_equal_b(true, git_path_validate(NULL, ":", 0, 0)); + cl_assert_equal_b(true, git_path_validate(NULL, "foo:/bar", 0, 0)); + + cl_assert_equal_b(false, git_path_validate(NULL, "foo:", 0, GIT_PATH_REJECT_TRAILING_COLON)); + cl_assert_equal_b(false, git_path_validate(NULL, "foo/bar:", 0, GIT_PATH_REJECT_TRAILING_COLON)); + cl_assert_equal_b(false, git_path_validate(NULL, ":", 0, GIT_PATH_REJECT_TRAILING_COLON)); + cl_assert_equal_b(false, git_path_validate(NULL, "foo:/bar", 0, GIT_PATH_REJECT_TRAILING_COLON)); } void test_path_core__isvalid_dotgit_ntfs(void) { - cl_assert_equal_b(true, git_path_isvalid(NULL, ".git", 0, 0)); - cl_assert_equal_b(true, git_path_isvalid(NULL, ".git ", 0, 0)); - cl_assert_equal_b(true, git_path_isvalid(NULL, ".git.", 0, 0)); - cl_assert_equal_b(true, git_path_isvalid(NULL, ".git.. .", 0, 0)); - - cl_assert_equal_b(true, git_path_isvalid(NULL, "git~1", 0, 0)); - cl_assert_equal_b(true, git_path_isvalid(NULL, "git~1 ", 0, 0)); - cl_assert_equal_b(true, git_path_isvalid(NULL, "git~1.", 0, 0)); - cl_assert_equal_b(true, git_path_isvalid(NULL, "git~1.. .", 0, 0)); - - cl_assert_equal_b(false, git_path_isvalid(NULL, ".git", 0, GIT_PATH_REJECT_DOT_GIT_NTFS)); - cl_assert_equal_b(false, git_path_isvalid(NULL, ".git ", 0, GIT_PATH_REJECT_DOT_GIT_NTFS)); - cl_assert_equal_b(false, git_path_isvalid(NULL, ".git.", 0, GIT_PATH_REJECT_DOT_GIT_NTFS)); - cl_assert_equal_b(false, git_path_isvalid(NULL, ".git.. .", 0, GIT_PATH_REJECT_DOT_GIT_NTFS)); - - cl_assert_equal_b(false, git_path_isvalid(NULL, "git~1", 0, GIT_PATH_REJECT_DOT_GIT_NTFS)); - cl_assert_equal_b(false, git_path_isvalid(NULL, "git~1 ", 0, GIT_PATH_REJECT_DOT_GIT_NTFS)); - cl_assert_equal_b(false, git_path_isvalid(NULL, "git~1.", 0, GIT_PATH_REJECT_DOT_GIT_NTFS)); - cl_assert_equal_b(false, git_path_isvalid(NULL, "git~1.. .", 0, GIT_PATH_REJECT_DOT_GIT_NTFS)); + cl_assert_equal_b(true, git_path_validate(NULL, ".git", 0, 0)); + cl_assert_equal_b(true, git_path_validate(NULL, ".git ", 0, 0)); + cl_assert_equal_b(true, git_path_validate(NULL, ".git.", 0, 0)); + cl_assert_equal_b(true, git_path_validate(NULL, ".git.. .", 0, 0)); + + cl_assert_equal_b(true, git_path_validate(NULL, "git~1", 0, 0)); + cl_assert_equal_b(true, git_path_validate(NULL, "git~1 ", 0, 0)); + cl_assert_equal_b(true, git_path_validate(NULL, "git~1.", 0, 0)); + cl_assert_equal_b(true, git_path_validate(NULL, "git~1.. .", 0, 0)); + + cl_assert_equal_b(false, git_path_validate(NULL, ".git", 0, GIT_PATH_REJECT_DOT_GIT_NTFS)); + cl_assert_equal_b(false, git_path_validate(NULL, ".git ", 0, GIT_PATH_REJECT_DOT_GIT_NTFS)); + cl_assert_equal_b(false, git_path_validate(NULL, ".git.", 0, GIT_PATH_REJECT_DOT_GIT_NTFS)); + cl_assert_equal_b(false, git_path_validate(NULL, ".git.. .", 0, GIT_PATH_REJECT_DOT_GIT_NTFS)); + + cl_assert_equal_b(false, git_path_validate(NULL, "git~1", 0, GIT_PATH_REJECT_DOT_GIT_NTFS)); + cl_assert_equal_b(false, git_path_validate(NULL, "git~1 ", 0, GIT_PATH_REJECT_DOT_GIT_NTFS)); + cl_assert_equal_b(false, git_path_validate(NULL, "git~1.", 0, GIT_PATH_REJECT_DOT_GIT_NTFS)); + cl_assert_equal_b(false, git_path_validate(NULL, "git~1.. .", 0, GIT_PATH_REJECT_DOT_GIT_NTFS)); } void test_path_core__isvalid_dos_paths(void) { - cl_assert_equal_b(true, git_path_isvalid(NULL, "aux", 0, 0)); - cl_assert_equal_b(true, git_path_isvalid(NULL, "aux.", 0, 0)); - cl_assert_equal_b(true, git_path_isvalid(NULL, "aux:", 0, 0)); - cl_assert_equal_b(true, git_path_isvalid(NULL, "aux.asdf", 0, 0)); - cl_assert_equal_b(true, git_path_isvalid(NULL, "aux.asdf\\zippy", 0, 0)); - cl_assert_equal_b(true, git_path_isvalid(NULL, "aux:asdf\\foobar", 0, 0)); - cl_assert_equal_b(true, git_path_isvalid(NULL, "con", 0, 0)); - cl_assert_equal_b(true, git_path_isvalid(NULL, "prn", 0, 0)); - cl_assert_equal_b(true, git_path_isvalid(NULL, "nul", 0, 0)); - - cl_assert_equal_b(false, git_path_isvalid(NULL, "aux", 0, GIT_PATH_REJECT_DOS_PATHS)); - cl_assert_equal_b(false, git_path_isvalid(NULL, "aux.", 0, GIT_PATH_REJECT_DOS_PATHS)); - cl_assert_equal_b(false, git_path_isvalid(NULL, "aux:", 0, GIT_PATH_REJECT_DOS_PATHS)); - cl_assert_equal_b(false, git_path_isvalid(NULL, "aux.asdf", 0, GIT_PATH_REJECT_DOS_PATHS)); - cl_assert_equal_b(false, git_path_isvalid(NULL, "aux.asdf\\zippy", 0, GIT_PATH_REJECT_DOS_PATHS)); - cl_assert_equal_b(false, git_path_isvalid(NULL, "aux:asdf\\foobar", 0, GIT_PATH_REJECT_DOS_PATHS)); - cl_assert_equal_b(false, git_path_isvalid(NULL, "con", 0, GIT_PATH_REJECT_DOS_PATHS)); - cl_assert_equal_b(false, git_path_isvalid(NULL, "prn", 0, GIT_PATH_REJECT_DOS_PATHS)); - cl_assert_equal_b(false, git_path_isvalid(NULL, "nul", 0, GIT_PATH_REJECT_DOS_PATHS)); - - cl_assert_equal_b(true, git_path_isvalid(NULL, "aux1", 0, 0)); - cl_assert_equal_b(true, git_path_isvalid(NULL, "aux1", 0, GIT_PATH_REJECT_DOS_PATHS)); - cl_assert_equal_b(true, git_path_isvalid(NULL, "auxn", 0, GIT_PATH_REJECT_DOS_PATHS)); - cl_assert_equal_b(true, git_path_isvalid(NULL, "aux\\foo", 0, GIT_PATH_REJECT_DOS_PATHS)); + cl_assert_equal_b(true, git_path_validate(NULL, "aux", 0, 0)); + cl_assert_equal_b(true, git_path_validate(NULL, "aux.", 0, 0)); + cl_assert_equal_b(true, git_path_validate(NULL, "aux:", 0, 0)); + cl_assert_equal_b(true, git_path_validate(NULL, "aux.asdf", 0, 0)); + cl_assert_equal_b(true, git_path_validate(NULL, "aux.asdf\\zippy", 0, 0)); + cl_assert_equal_b(true, git_path_validate(NULL, "aux:asdf\\foobar", 0, 0)); + cl_assert_equal_b(true, git_path_validate(NULL, "con", 0, 0)); + cl_assert_equal_b(true, git_path_validate(NULL, "prn", 0, 0)); + cl_assert_equal_b(true, git_path_validate(NULL, "nul", 0, 0)); + + cl_assert_equal_b(false, git_path_validate(NULL, "aux", 0, GIT_PATH_REJECT_DOS_PATHS)); + cl_assert_equal_b(false, git_path_validate(NULL, "aux.", 0, GIT_PATH_REJECT_DOS_PATHS)); + cl_assert_equal_b(false, git_path_validate(NULL, "aux:", 0, GIT_PATH_REJECT_DOS_PATHS)); + cl_assert_equal_b(false, git_path_validate(NULL, "aux.asdf", 0, GIT_PATH_REJECT_DOS_PATHS)); + cl_assert_equal_b(false, git_path_validate(NULL, "aux.asdf\\zippy", 0, GIT_PATH_REJECT_DOS_PATHS)); + cl_assert_equal_b(false, git_path_validate(NULL, "aux:asdf\\foobar", 0, GIT_PATH_REJECT_DOS_PATHS)); + cl_assert_equal_b(false, git_path_validate(NULL, "con", 0, GIT_PATH_REJECT_DOS_PATHS)); + cl_assert_equal_b(false, git_path_validate(NULL, "prn", 0, GIT_PATH_REJECT_DOS_PATHS)); + cl_assert_equal_b(false, git_path_validate(NULL, "nul", 0, GIT_PATH_REJECT_DOS_PATHS)); + + cl_assert_equal_b(true, git_path_validate(NULL, "aux1", 0, 0)); + cl_assert_equal_b(true, git_path_validate(NULL, "aux1", 0, GIT_PATH_REJECT_DOS_PATHS)); + cl_assert_equal_b(true, git_path_validate(NULL, "auxn", 0, GIT_PATH_REJECT_DOS_PATHS)); + cl_assert_equal_b(true, git_path_validate(NULL, "aux\\foo", 0, GIT_PATH_REJECT_DOS_PATHS)); } void test_path_core__isvalid_dos_paths_withnum(void) { - cl_assert_equal_b(true, git_path_isvalid(NULL, "com1", 0, 0)); - cl_assert_equal_b(true, git_path_isvalid(NULL, "com1.", 0, 0)); - cl_assert_equal_b(true, git_path_isvalid(NULL, "com1:", 0, 0)); - cl_assert_equal_b(true, git_path_isvalid(NULL, "com1.asdf", 0, 0)); - cl_assert_equal_b(true, git_path_isvalid(NULL, "com1.asdf\\zippy", 0, 0)); - cl_assert_equal_b(true, git_path_isvalid(NULL, "com1:asdf\\foobar", 0, 0)); - cl_assert_equal_b(true, git_path_isvalid(NULL, "com1\\foo", 0, 0)); - cl_assert_equal_b(true, git_path_isvalid(NULL, "lpt1", 0, 0)); - - cl_assert_equal_b(false, git_path_isvalid(NULL, "com1", 0, GIT_PATH_REJECT_DOS_PATHS)); - cl_assert_equal_b(false, git_path_isvalid(NULL, "com1.", 0, GIT_PATH_REJECT_DOS_PATHS)); - cl_assert_equal_b(false, git_path_isvalid(NULL, "com1:", 0, GIT_PATH_REJECT_DOS_PATHS)); - cl_assert_equal_b(false, git_path_isvalid(NULL, "com1.asdf", 0, GIT_PATH_REJECT_DOS_PATHS)); - cl_assert_equal_b(false, git_path_isvalid(NULL, "com1.asdf\\zippy", 0, GIT_PATH_REJECT_DOS_PATHS)); - cl_assert_equal_b(false, git_path_isvalid(NULL, "com1:asdf\\foobar", 0, GIT_PATH_REJECT_DOS_PATHS)); - cl_assert_equal_b(false, git_path_isvalid(NULL, "com1/foo", 0, GIT_PATH_REJECT_DOS_PATHS)); - cl_assert_equal_b(false, git_path_isvalid(NULL, "lpt1", 0, GIT_PATH_REJECT_DOS_PATHS)); - - cl_assert_equal_b(true, git_path_isvalid(NULL, "com0", 0, 0)); - cl_assert_equal_b(true, git_path_isvalid(NULL, "com0", 0, GIT_PATH_REJECT_DOS_PATHS)); - cl_assert_equal_b(true, git_path_isvalid(NULL, "com10", 0, 0)); - cl_assert_equal_b(true, git_path_isvalid(NULL, "com10", 0, GIT_PATH_REJECT_DOS_PATHS)); - cl_assert_equal_b(true, git_path_isvalid(NULL, "comn", 0, GIT_PATH_REJECT_DOS_PATHS)); - cl_assert_equal_b(true, git_path_isvalid(NULL, "com1\\foo", 0, GIT_PATH_REJECT_DOS_PATHS)); - cl_assert_equal_b(true, git_path_isvalid(NULL, "lpt0", 0, GIT_PATH_REJECT_DOS_PATHS)); - cl_assert_equal_b(true, git_path_isvalid(NULL, "lpt10", 0, GIT_PATH_REJECT_DOS_PATHS)); - cl_assert_equal_b(true, git_path_isvalid(NULL, "lptn", 0, GIT_PATH_REJECT_DOS_PATHS)); + cl_assert_equal_b(true, git_path_validate(NULL, "com1", 0, 0)); + cl_assert_equal_b(true, git_path_validate(NULL, "com1.", 0, 0)); + cl_assert_equal_b(true, git_path_validate(NULL, "com1:", 0, 0)); + cl_assert_equal_b(true, git_path_validate(NULL, "com1.asdf", 0, 0)); + cl_assert_equal_b(true, git_path_validate(NULL, "com1.asdf\\zippy", 0, 0)); + cl_assert_equal_b(true, git_path_validate(NULL, "com1:asdf\\foobar", 0, 0)); + cl_assert_equal_b(true, git_path_validate(NULL, "com1\\foo", 0, 0)); + cl_assert_equal_b(true, git_path_validate(NULL, "lpt1", 0, 0)); + + cl_assert_equal_b(false, git_path_validate(NULL, "com1", 0, GIT_PATH_REJECT_DOS_PATHS)); + cl_assert_equal_b(false, git_path_validate(NULL, "com1.", 0, GIT_PATH_REJECT_DOS_PATHS)); + cl_assert_equal_b(false, git_path_validate(NULL, "com1:", 0, GIT_PATH_REJECT_DOS_PATHS)); + cl_assert_equal_b(false, git_path_validate(NULL, "com1.asdf", 0, GIT_PATH_REJECT_DOS_PATHS)); + cl_assert_equal_b(false, git_path_validate(NULL, "com1.asdf\\zippy", 0, GIT_PATH_REJECT_DOS_PATHS)); + cl_assert_equal_b(false, git_path_validate(NULL, "com1:asdf\\foobar", 0, GIT_PATH_REJECT_DOS_PATHS)); + cl_assert_equal_b(false, git_path_validate(NULL, "com1/foo", 0, GIT_PATH_REJECT_DOS_PATHS)); + cl_assert_equal_b(false, git_path_validate(NULL, "lpt1", 0, GIT_PATH_REJECT_DOS_PATHS)); + + cl_assert_equal_b(true, git_path_validate(NULL, "com0", 0, 0)); + cl_assert_equal_b(true, git_path_validate(NULL, "com0", 0, GIT_PATH_REJECT_DOS_PATHS)); + cl_assert_equal_b(true, git_path_validate(NULL, "com10", 0, 0)); + cl_assert_equal_b(true, git_path_validate(NULL, "com10", 0, GIT_PATH_REJECT_DOS_PATHS)); + cl_assert_equal_b(true, git_path_validate(NULL, "comn", 0, GIT_PATH_REJECT_DOS_PATHS)); + cl_assert_equal_b(true, git_path_validate(NULL, "com1\\foo", 0, GIT_PATH_REJECT_DOS_PATHS)); + cl_assert_equal_b(true, git_path_validate(NULL, "lpt0", 0, GIT_PATH_REJECT_DOS_PATHS)); + cl_assert_equal_b(true, git_path_validate(NULL, "lpt10", 0, GIT_PATH_REJECT_DOS_PATHS)); + cl_assert_equal_b(true, git_path_validate(NULL, "lptn", 0, GIT_PATH_REJECT_DOS_PATHS)); } void test_path_core__isvalid_nt_chars(void) { - cl_assert_equal_b(true, git_path_isvalid(NULL, "asdf\001foo", 0, 0)); - cl_assert_equal_b(true, git_path_isvalid(NULL, "asdf\037bar", 0, 0)); - cl_assert_equal_b(true, git_path_isvalid(NULL, "asdf<bar", 0, 0)); - cl_assert_equal_b(true, git_path_isvalid(NULL, "asdf>foo", 0, 0)); - cl_assert_equal_b(true, git_path_isvalid(NULL, "asdf:foo", 0, 0)); - cl_assert_equal_b(true, git_path_isvalid(NULL, "asdf\"bar", 0, 0)); - cl_assert_equal_b(true, git_path_isvalid(NULL, "asdf|foo", 0, 0)); - cl_assert_equal_b(true, git_path_isvalid(NULL, "asdf?bar", 0, 0)); - cl_assert_equal_b(true, git_path_isvalid(NULL, "asdf*bar", 0, 0)); - - cl_assert_equal_b(false, git_path_isvalid(NULL, "asdf\001foo", 0, GIT_PATH_REJECT_NT_CHARS)); - cl_assert_equal_b(false, git_path_isvalid(NULL, "asdf\037bar", 0, GIT_PATH_REJECT_NT_CHARS)); - cl_assert_equal_b(false, git_path_isvalid(NULL, "asdf<bar", 0, GIT_PATH_REJECT_NT_CHARS)); - cl_assert_equal_b(false, git_path_isvalid(NULL, "asdf>foo", 0, GIT_PATH_REJECT_NT_CHARS)); - cl_assert_equal_b(false, git_path_isvalid(NULL, "asdf:foo", 0, GIT_PATH_REJECT_NT_CHARS)); - cl_assert_equal_b(false, git_path_isvalid(NULL, "asdf\"bar", 0, GIT_PATH_REJECT_NT_CHARS)); - cl_assert_equal_b(false, git_path_isvalid(NULL, "asdf|foo", 0, GIT_PATH_REJECT_NT_CHARS)); - cl_assert_equal_b(false, git_path_isvalid(NULL, "asdf?bar", 0, GIT_PATH_REJECT_NT_CHARS)); - cl_assert_equal_b(false, git_path_isvalid(NULL, "asdf*bar", 0, GIT_PATH_REJECT_NT_CHARS)); + cl_assert_equal_b(true, git_path_validate(NULL, "asdf\001foo", 0, 0)); + cl_assert_equal_b(true, git_path_validate(NULL, "asdf\037bar", 0, 0)); + cl_assert_equal_b(true, git_path_validate(NULL, "asdf<bar", 0, 0)); + cl_assert_equal_b(true, git_path_validate(NULL, "asdf>foo", 0, 0)); + cl_assert_equal_b(true, git_path_validate(NULL, "asdf:foo", 0, 0)); + cl_assert_equal_b(true, git_path_validate(NULL, "asdf\"bar", 0, 0)); + cl_assert_equal_b(true, git_path_validate(NULL, "asdf|foo", 0, 0)); + cl_assert_equal_b(true, git_path_validate(NULL, "asdf?bar", 0, 0)); + cl_assert_equal_b(true, git_path_validate(NULL, "asdf*bar", 0, 0)); + + cl_assert_equal_b(false, git_path_validate(NULL, "asdf\001foo", 0, GIT_PATH_REJECT_NT_CHARS)); + cl_assert_equal_b(false, git_path_validate(NULL, "asdf\037bar", 0, GIT_PATH_REJECT_NT_CHARS)); + cl_assert_equal_b(false, git_path_validate(NULL, "asdf<bar", 0, GIT_PATH_REJECT_NT_CHARS)); + cl_assert_equal_b(false, git_path_validate(NULL, "asdf>foo", 0, GIT_PATH_REJECT_NT_CHARS)); + cl_assert_equal_b(false, git_path_validate(NULL, "asdf:foo", 0, GIT_PATH_REJECT_NT_CHARS)); + cl_assert_equal_b(false, git_path_validate(NULL, "asdf\"bar", 0, GIT_PATH_REJECT_NT_CHARS)); + cl_assert_equal_b(false, git_path_validate(NULL, "asdf|foo", 0, GIT_PATH_REJECT_NT_CHARS)); + cl_assert_equal_b(false, git_path_validate(NULL, "asdf?bar", 0, GIT_PATH_REJECT_NT_CHARS)); + cl_assert_equal_b(false, git_path_validate(NULL, "asdf*bar", 0, GIT_PATH_REJECT_NT_CHARS)); } void test_path_core__isvalid_dotgit_with_hfs_ignorables(void) { - cl_assert_equal_b(false, git_path_isvalid(NULL, ".git", 0, GIT_PATH_REJECT_DOT_GIT_HFS)); - cl_assert_equal_b(false, git_path_isvalid(NULL, ".git\xe2\x80\x8c", 0, GIT_PATH_REJECT_DOT_GIT_HFS)); - cl_assert_equal_b(false, git_path_isvalid(NULL, ".gi\xe2\x80\x8dT", 0, GIT_PATH_REJECT_DOT_GIT_HFS)); - cl_assert_equal_b(false, git_path_isvalid(NULL, ".g\xe2\x80\x8eIt", 0, GIT_PATH_REJECT_DOT_GIT_HFS)); - cl_assert_equal_b(false, git_path_isvalid(NULL, ".\xe2\x80\x8fgIt", 0, GIT_PATH_REJECT_DOT_GIT_HFS)); - cl_assert_equal_b(false, git_path_isvalid(NULL, "\xe2\x80\xaa.gIt", 0, GIT_PATH_REJECT_DOT_GIT_HFS)); - - cl_assert_equal_b(false, git_path_isvalid(NULL, "\xe2\x80\xab.\xe2\x80\xacG\xe2\x80\xadI\xe2\x80\xaet", 0, GIT_PATH_REJECT_DOT_GIT_HFS)); - cl_assert_equal_b(false, git_path_isvalid(NULL, "\xe2\x81\xab.\xe2\x80\xaaG\xe2\x81\xabI\xe2\x80\xact", 0, GIT_PATH_REJECT_DOT_GIT_HFS)); - cl_assert_equal_b(false, git_path_isvalid(NULL, "\xe2\x81\xad.\xe2\x80\xaeG\xef\xbb\xbfIT", 0, GIT_PATH_REJECT_DOT_GIT_HFS)); - - cl_assert_equal_b(true, git_path_isvalid(NULL, ".", 0, GIT_PATH_REJECT_DOT_GIT_HFS)); - cl_assert_equal_b(true, git_path_isvalid(NULL, ".g", 0, GIT_PATH_REJECT_DOT_GIT_HFS)); - cl_assert_equal_b(true, git_path_isvalid(NULL, ".gi", 0, GIT_PATH_REJECT_DOT_GIT_HFS)); - cl_assert_equal_b(true, git_path_isvalid(NULL, " .git", 0, GIT_PATH_REJECT_DOT_GIT_HFS)); - cl_assert_equal_b(true, git_path_isvalid(NULL, "..git\xe2\x80\x8c", 0, GIT_PATH_REJECT_DOT_GIT_HFS)); - cl_assert_equal_b(true, git_path_isvalid(NULL, ".gi\xe2\x80\x8dT.", 0, GIT_PATH_REJECT_DOT_GIT_HFS)); - cl_assert_equal_b(true, git_path_isvalid(NULL, ".g\xe2\x80It", 0, GIT_PATH_REJECT_DOT_GIT_HFS)); - cl_assert_equal_b(true, git_path_isvalid(NULL, ".\xe2gIt", 0, GIT_PATH_REJECT_DOT_GIT_HFS)); - cl_assert_equal_b(true, git_path_isvalid(NULL, "\xe2\x80\xaa.gi", 0, GIT_PATH_REJECT_DOT_GIT_HFS)); - cl_assert_equal_b(true, git_path_isvalid(NULL, ".gi\x80\x8dT", 0, GIT_PATH_REJECT_DOT_GIT_HFS)); - cl_assert_equal_b(true, git_path_isvalid(NULL, ".gi\x8dT", 0, GIT_PATH_REJECT_DOT_GIT_HFS)); - cl_assert_equal_b(true, git_path_isvalid(NULL, ".g\xe2i\x80T\x8e", 0, GIT_PATH_REJECT_DOT_GIT_HFS)); - cl_assert_equal_b(true, git_path_isvalid(NULL, ".git\xe2\x80\xbf", 0, GIT_PATH_REJECT_DOT_GIT_HFS)); - cl_assert_equal_b(true, git_path_isvalid(NULL, ".git\xe2\xab\x81", 0, GIT_PATH_REJECT_DOT_GIT_HFS)); + cl_assert_equal_b(false, git_path_validate(NULL, ".git", 0, GIT_PATH_REJECT_DOT_GIT_HFS)); + cl_assert_equal_b(false, git_path_validate(NULL, ".git\xe2\x80\x8c", 0, GIT_PATH_REJECT_DOT_GIT_HFS)); + cl_assert_equal_b(false, git_path_validate(NULL, ".gi\xe2\x80\x8dT", 0, GIT_PATH_REJECT_DOT_GIT_HFS)); + cl_assert_equal_b(false, git_path_validate(NULL, ".g\xe2\x80\x8eIt", 0, GIT_PATH_REJECT_DOT_GIT_HFS)); + cl_assert_equal_b(false, git_path_validate(NULL, ".\xe2\x80\x8fgIt", 0, GIT_PATH_REJECT_DOT_GIT_HFS)); + cl_assert_equal_b(false, git_path_validate(NULL, "\xe2\x80\xaa.gIt", 0, GIT_PATH_REJECT_DOT_GIT_HFS)); + + cl_assert_equal_b(false, git_path_validate(NULL, "\xe2\x80\xab.\xe2\x80\xacG\xe2\x80\xadI\xe2\x80\xaet", 0, GIT_PATH_REJECT_DOT_GIT_HFS)); + cl_assert_equal_b(false, git_path_validate(NULL, "\xe2\x81\xab.\xe2\x80\xaaG\xe2\x81\xabI\xe2\x80\xact", 0, GIT_PATH_REJECT_DOT_GIT_HFS)); + cl_assert_equal_b(false, git_path_validate(NULL, "\xe2\x81\xad.\xe2\x80\xaeG\xef\xbb\xbfIT", 0, GIT_PATH_REJECT_DOT_GIT_HFS)); + + cl_assert_equal_b(true, git_path_validate(NULL, ".", 0, GIT_PATH_REJECT_DOT_GIT_HFS)); + cl_assert_equal_b(true, git_path_validate(NULL, ".g", 0, GIT_PATH_REJECT_DOT_GIT_HFS)); + cl_assert_equal_b(true, git_path_validate(NULL, ".gi", 0, GIT_PATH_REJECT_DOT_GIT_HFS)); + cl_assert_equal_b(true, git_path_validate(NULL, " .git", 0, GIT_PATH_REJECT_DOT_GIT_HFS)); + cl_assert_equal_b(true, git_path_validate(NULL, "..git\xe2\x80\x8c", 0, GIT_PATH_REJECT_DOT_GIT_HFS)); + cl_assert_equal_b(true, git_path_validate(NULL, ".gi\xe2\x80\x8dT.", 0, GIT_PATH_REJECT_DOT_GIT_HFS)); + cl_assert_equal_b(true, git_path_validate(NULL, ".g\xe2\x80It", 0, GIT_PATH_REJECT_DOT_GIT_HFS)); + cl_assert_equal_b(true, git_path_validate(NULL, ".\xe2gIt", 0, GIT_PATH_REJECT_DOT_GIT_HFS)); + cl_assert_equal_b(true, git_path_validate(NULL, "\xe2\x80\xaa.gi", 0, GIT_PATH_REJECT_DOT_GIT_HFS)); + cl_assert_equal_b(true, git_path_validate(NULL, ".gi\x80\x8dT", 0, GIT_PATH_REJECT_DOT_GIT_HFS)); + cl_assert_equal_b(true, git_path_validate(NULL, ".gi\x8dT", 0, GIT_PATH_REJECT_DOT_GIT_HFS)); + cl_assert_equal_b(true, git_path_validate(NULL, ".g\xe2i\x80T\x8e", 0, GIT_PATH_REJECT_DOT_GIT_HFS)); + cl_assert_equal_b(true, git_path_validate(NULL, ".git\xe2\x80\xbf", 0, GIT_PATH_REJECT_DOT_GIT_HFS)); + cl_assert_equal_b(true, git_path_validate(NULL, ".git\xe2\xab\x81", 0, GIT_PATH_REJECT_DOT_GIT_HFS)); +} + +void test_path_core__validate_workdir(void) +{ + cl_must_pass(git_path_validate_workdir(NULL, "/foo/bar")); + cl_must_pass(git_path_validate_workdir(NULL, "C:\\Foo\\Bar")); + cl_must_pass(git_path_validate_workdir(NULL, "\\\\?\\C:\\Foo\\Bar")); + cl_must_pass(git_path_validate_workdir(NULL, "\\\\?\\C:\\Foo\\Bar")); + cl_must_pass(git_path_validate_workdir(NULL, "\\\\?\\UNC\\server\\C$\\folder")); + +#ifdef GIT_WIN32 + /* + * In the absense of a repo configuration, 259 character paths + * succeed. >= 260 character paths fail. + */ + cl_must_pass(git_path_validate_workdir(NULL, "C:\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\ok.txt")); + cl_must_pass(git_path_validate_workdir(NULL, "C:\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\260.txt")); + cl_must_fail(git_path_validate_workdir(NULL, "C:\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\longer_than_260.txt")); + + /* count characters, not bytes */ + cl_must_pass(git_path_validate_workdir(NULL, "C:\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\\xc2\xa2\xc2\xa2\xc2\xa2\xc2\xa2\xc2\xa2\xc2\xa2\xc2\xa2\xc2\xa2\xc2\xa2\\260.txt")); + cl_must_fail(git_path_validate_workdir(NULL, "C:\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\\xc2\xa2\xc2\xa2\xc2\xa2\xc2\xa2\xc2\xa2\xc2\xa2\xc2\xa2\xc2\xa2\xc2\xa2\\long.txt")); +#else + cl_must_pass(git_path_validate_workdir(NULL, "/c/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/ok.txt")); + cl_must_pass(git_path_validate_workdir(NULL, "/c/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/260.txt")); + cl_must_pass(git_path_validate_workdir(NULL, "/c/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/longer_than_260.txt")); + cl_must_pass(git_path_validate_workdir(NULL, "C:\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\\xc2\xa2\xc2\xa2\xc2\xa2\xc2\xa2\xc2\xa2\xc2\xa2\xc2\xa2\xc2\xa2\xc2\xa2\\260.txt")); + cl_must_pass(git_path_validate_workdir(NULL, "C:\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\aaaaaaaaa\\\xc2\xa2\xc2\xa2\xc2\xa2\xc2\xa2\xc2\xa2\xc2\xa2\xc2\xa2\xc2\xa2\xc2\xa2\\long.txt")); +#endif +} + +void test_path_core__validate_workdir_with_core_longpath(void) +{ +#ifdef GIT_WIN32 + git_repository *repo; + git_config *config; + + repo = cl_git_sandbox_init("empty_bare.git"); + + cl_git_pass(git_repository_open(&repo, "empty_bare.git")); + cl_git_pass(git_repository_config(&config, repo)); + + /* fail by default */ + cl_must_fail(git_path_validate_workdir(repo, "/c/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/longer_than_260.txt")); + + /* set core.longpaths explicitly on */ + cl_git_pass(git_config_set_bool(config, "core.longpaths", 1)); + cl_must_pass(git_path_validate_workdir(repo, "/c/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/longer_than_260.txt")); + + /* set core.longpaths explicitly off */ + cl_git_pass(git_config_set_bool(config, "core.longpaths", 0)); + cl_must_fail(git_path_validate_workdir(repo, "/c/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/aaaaaaaaa/longer_than_260.txt")); + + git_config_free(config); + git_repository_free(repo); +#endif } static void test_join_unrooted( diff --git a/tests/path/dotgit.c b/tests/path/dotgit.c index ceb7330d2..2f9fcae4f 100644 --- a/tests/path/dotgit.c +++ b/tests/path/dotgit.c @@ -113,8 +113,8 @@ void test_path_dotgit__dotgit_modules(void) void test_path_dotgit__dotgit_modules_symlink(void) { - cl_assert_equal_b(true, git_path_isvalid(NULL, ".gitmodules", 0, GIT_PATH_REJECT_DOT_GIT_HFS|GIT_PATH_REJECT_DOT_GIT_NTFS)); - cl_assert_equal_b(false, git_path_isvalid(NULL, ".gitmodules", S_IFLNK, GIT_PATH_REJECT_DOT_GIT_HFS)); - cl_assert_equal_b(false, git_path_isvalid(NULL, ".gitmodules", S_IFLNK, GIT_PATH_REJECT_DOT_GIT_NTFS)); - cl_assert_equal_b(false, git_path_isvalid(NULL, ".gitmodules . .::$DATA", S_IFLNK, GIT_PATH_REJECT_DOT_GIT_NTFS)); + cl_assert_equal_b(true, git_path_validate(NULL, ".gitmodules", 0, GIT_PATH_REJECT_DOT_GIT_HFS|GIT_PATH_REJECT_DOT_GIT_NTFS)); + cl_assert_equal_b(false, git_path_validate(NULL, ".gitmodules", S_IFLNK, GIT_PATH_REJECT_DOT_GIT_HFS)); + cl_assert_equal_b(false, git_path_validate(NULL, ".gitmodules", S_IFLNK, GIT_PATH_REJECT_DOT_GIT_NTFS)); + cl_assert_equal_b(false, git_path_validate(NULL, ".gitmodules . .::$DATA", S_IFLNK, GIT_PATH_REJECT_DOT_GIT_NTFS)); } diff --git a/tests/path/win32.c b/tests/path/win32.c index b416e9e60..46b5c9f70 100644 --- a/tests/path/win32.c +++ b/tests/path/win32.c @@ -78,13 +78,11 @@ void test_path_win32__honors_max_path(void) #ifdef GIT_WIN32 git_win32_path path_utf16; - test_utf8_to_utf16("C:\\This path is 259 chars and is the max length in windows\\0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij", - L"\\\\?\\C:\\This path is 259 chars and is the max length in windows\\0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij"); - test_utf8_to_utf16("\\\\unc\\paths may also be 259 characters including the server\\123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij", - L"\\\\?\\UNC\\unc\\paths may also be 259 characters including the server\\123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij"); + test_utf8_to_utf16("C:\\This path is 261 characters which is fine for our path handling functions which cope with paths longer than MAX_PATH\\0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghijk", + L"\\\\?\\C:\\This path is 261 characters which is fine for our path handling functions which cope with paths longer than MAX_PATH\\0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghijk"); + + cl_check_fail(git_win32_path_from_utf8(path_utf16, "C:\\This path is 4097 chars and exceeds our maximum path length on Windows which is limited to 4096 characters\\alas\\0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij01")); - cl_check_fail(git_win32_path_from_utf8(path_utf16, "C:\\This path is 260 chars and is sadly too long for windows\\0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij")); - cl_check_fail(git_win32_path_from_utf8(path_utf16, "\\\\unc\\paths are also bound by 260 character restrictions\\including the server name portion\\bcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij")); #endif } diff --git a/tests/rebase/sign.c b/tests/rebase/sign.c index fa4776661..06c18937a 100644 --- a/tests/rebase/sign.c +++ b/tests/rebase/sign.c @@ -18,7 +18,239 @@ void test_rebase_sign__cleanup(void) cl_git_sandbox_cleanup(); } -static const char *expected_commit_content = "tree cd99b26250099fc38d30bfaed7797a7275ed3366\n\ +static int create_cb_passthrough( + git_oid *out, + const git_signature *author, + const git_signature *committer, + const char *message_encoding, + const char *message, + const git_tree *tree, + size_t parent_count, + const git_commit *parents[], + void *payload) +{ + GIT_UNUSED(out); + GIT_UNUSED(author); + GIT_UNUSED(committer); + GIT_UNUSED(message_encoding); + GIT_UNUSED(message); + GIT_UNUSED(tree); + GIT_UNUSED(parent_count); + GIT_UNUSED(parents); + GIT_UNUSED(payload); + + return GIT_PASSTHROUGH; +} + +/* git checkout gravy ; git rebase --merge veal */ +void test_rebase_sign__passthrough_create_cb(void) +{ + git_rebase *rebase; + git_reference *branch_ref, *upstream_ref; + git_annotated_commit *branch_head, *upstream_head; + git_rebase_operation *rebase_operation; + git_oid commit_id, expected_id; + git_rebase_options rebase_opts = GIT_REBASE_OPTIONS_INIT; + git_commit *commit; + const char *expected_commit_raw_header = "tree cd99b26250099fc38d30bfaed7797a7275ed3366\n\ +parent f87d14a4a236582a0278a916340a793714256864\n\ +author Edward Thomson <ethomson@edwardthomson.com> 1405625055 -0400\n\ +committer Rebaser <rebaser@rebaser.rb> 1405694510 +0000\n"; + + rebase_opts.commit_create_cb = create_cb_passthrough; + + cl_git_pass(git_reference_lookup(&branch_ref, repo, "refs/heads/gravy")); + cl_git_pass(git_reference_lookup(&upstream_ref, repo, "refs/heads/veal")); + + cl_git_pass(git_annotated_commit_from_ref(&branch_head, repo, branch_ref)); + cl_git_pass(git_annotated_commit_from_ref(&upstream_head, repo, upstream_ref)); + + cl_git_pass(git_rebase_init(&rebase, repo, branch_head, upstream_head, NULL, &rebase_opts)); + + cl_git_pass(git_rebase_next(&rebase_operation, rebase)); + cl_git_pass(git_rebase_commit(&commit_id, rebase, NULL, signature, NULL, NULL)); + + git_oid_fromstr(&expected_id, "129183968a65abd6c52da35bff43325001bfc630"); + cl_assert_equal_oid(&expected_id, &commit_id); + + cl_git_pass(git_commit_lookup(&commit, repo, &commit_id)); + cl_assert_equal_s(expected_commit_raw_header, git_commit_raw_header(commit)); + + cl_git_fail_with(GIT_ITEROVER, git_rebase_next(&rebase_operation, rebase)); + + git_reference_free(branch_ref); + git_reference_free(upstream_ref); + git_annotated_commit_free(branch_head); + git_annotated_commit_free(upstream_head); + git_commit_free(commit); + git_rebase_free(rebase); +} + +int create_cb_signed_gpg( + git_oid *out, + const git_signature *author, + const git_signature *committer, + const char *message_encoding, + const char *message, + const git_tree *tree, + size_t parent_count, + const git_commit *parents[], + void *payload) +{ + git_buf commit_content = GIT_BUF_INIT; + const char *gpg_signature = "-----BEGIN PGP SIGNATURE-----\n\ +\n\ +iQIzBAEBCgAdFiEEgVlDEfSlmKn0fvGgK++h5T2/ctIFAlwZcrAACgkQK++h5T2/\n\ +ctIPVhAA42RyZhMdKl5Bm0KtQco2scsukIg2y7tjSwhti91zDu3HQgpusjjo0fQx\n\ +ZzB+OrmlvQ9CDcGpZ0THIzXD8GRJoDMPqdrvZVrBWkGcHvw7/YPA8skzsjkauJ8W\n\ +7lzF5LCuHSS6OUmPT/+5hEHPin5PB3zhfszyC+Q7aujnIuPJMrKiMnUa+w1HWifM\n\ +km49OOygQ9S6NQoVuEQede22+c76DlDL7yFghGoo1f0sKCE/9LW6SEnwI/bWv9eo\n\ +nom5vOPrvQeJiYCQk+2DyWo8RdSxINtY+G9bPE4RXm+6ZgcXECPm9TYDIWpL36fC\n\ +jvtGLs98woWFElOziBMp5Tb630GMcSI+q5ivHfJ3WS5NKLYLHBNK4iSFN0/dgAnB\n\ +dj6GcKXKWnIBWn6ZM4o40pcM5KSRUUCLtA0ZmjJH4c4zx3X5fUxd+enwkf3e9VZO\n\ +fNKC/+xfq6NfoPUPK9+UnchHpJaJw7RG5tZS+sWCz2xpQ1y3/o49xImNyM3wnpvB\n\ +cRAZabqIHpZa9/DIUkELOtCzln6niqkjRgg3M/YCCNznwV+0RNgz87VtyTPerdef\n\ +xrqn0+ROMF6ebVqIs6PPtuPkxnAJu7TMKXVB5rFnAewS24e6cIGFzeIA7810py3l\n\ +cttVRsdOoego+fiy08eFE+aJIeYiINRGhqOBTsuqG4jIdpdKxPE=\n\ +=KbsY\n\ +-----END PGP SIGNATURE-----"; + + git_repository *repo = (git_repository *)payload; + int error; + + if ((error = git_commit_create_buffer(&commit_content, + repo, author, committer, message_encoding, message, + tree, parent_count, parents)) < 0) + goto done; + + error = git_commit_create_with_signature(out, repo, + commit_content.ptr, + gpg_signature, + NULL); + +done: + git_buf_dispose(&commit_content); + return error; +} + +/* git checkout gravy ; git rebase --merge veal */ +void test_rebase_sign__create_gpg_signed(void) +{ + git_rebase *rebase; + git_reference *branch_ref, *upstream_ref; + git_annotated_commit *branch_head, *upstream_head; + git_rebase_operation *rebase_operation; + git_oid commit_id, expected_id; + git_rebase_options rebase_opts = GIT_REBASE_OPTIONS_INIT; + git_commit *commit; + const char *expected_commit_raw_header = "tree cd99b26250099fc38d30bfaed7797a7275ed3366\n\ +parent f87d14a4a236582a0278a916340a793714256864\n\ +author Edward Thomson <ethomson@edwardthomson.com> 1405625055 -0400\n\ +committer Rebaser <rebaser@rebaser.rb> 1405694510 +0000\n\ +gpgsig -----BEGIN PGP SIGNATURE-----\n\ + \n\ + iQIzBAEBCgAdFiEEgVlDEfSlmKn0fvGgK++h5T2/ctIFAlwZcrAACgkQK++h5T2/\n\ + ctIPVhAA42RyZhMdKl5Bm0KtQco2scsukIg2y7tjSwhti91zDu3HQgpusjjo0fQx\n\ + ZzB+OrmlvQ9CDcGpZ0THIzXD8GRJoDMPqdrvZVrBWkGcHvw7/YPA8skzsjkauJ8W\n\ + 7lzF5LCuHSS6OUmPT/+5hEHPin5PB3zhfszyC+Q7aujnIuPJMrKiMnUa+w1HWifM\n\ + km49OOygQ9S6NQoVuEQede22+c76DlDL7yFghGoo1f0sKCE/9LW6SEnwI/bWv9eo\n\ + nom5vOPrvQeJiYCQk+2DyWo8RdSxINtY+G9bPE4RXm+6ZgcXECPm9TYDIWpL36fC\n\ + jvtGLs98woWFElOziBMp5Tb630GMcSI+q5ivHfJ3WS5NKLYLHBNK4iSFN0/dgAnB\n\ + dj6GcKXKWnIBWn6ZM4o40pcM5KSRUUCLtA0ZmjJH4c4zx3X5fUxd+enwkf3e9VZO\n\ + fNKC/+xfq6NfoPUPK9+UnchHpJaJw7RG5tZS+sWCz2xpQ1y3/o49xImNyM3wnpvB\n\ + cRAZabqIHpZa9/DIUkELOtCzln6niqkjRgg3M/YCCNznwV+0RNgz87VtyTPerdef\n\ + xrqn0+ROMF6ebVqIs6PPtuPkxnAJu7TMKXVB5rFnAewS24e6cIGFzeIA7810py3l\n\ + cttVRsdOoego+fiy08eFE+aJIeYiINRGhqOBTsuqG4jIdpdKxPE=\n\ + =KbsY\n\ + -----END PGP SIGNATURE-----\n"; + + rebase_opts.commit_create_cb = create_cb_signed_gpg; + rebase_opts.payload = repo; + + cl_git_pass(git_reference_lookup(&branch_ref, repo, "refs/heads/gravy")); + cl_git_pass(git_reference_lookup(&upstream_ref, repo, "refs/heads/veal")); + + cl_git_pass(git_annotated_commit_from_ref(&branch_head, repo, branch_ref)); + cl_git_pass(git_annotated_commit_from_ref(&upstream_head, repo, upstream_ref)); + + cl_git_pass(git_rebase_init(&rebase, repo, branch_head, upstream_head, NULL, &rebase_opts)); + + cl_git_pass(git_rebase_next(&rebase_operation, rebase)); + cl_git_pass(git_rebase_commit(&commit_id, rebase, NULL, signature, NULL, NULL)); + + git_oid_fromstr(&expected_id, "bf78348e45c8286f52b760f1db15cb6da030f2ef"); + cl_assert_equal_oid(&expected_id, &commit_id); + + cl_git_pass(git_commit_lookup(&commit, repo, &commit_id)); + cl_assert_equal_s(expected_commit_raw_header, git_commit_raw_header(commit)); + + cl_git_fail_with(GIT_ITEROVER, git_rebase_next(&rebase_operation, rebase)); + + git_reference_free(branch_ref); + git_reference_free(upstream_ref); + git_annotated_commit_free(branch_head); + git_annotated_commit_free(upstream_head); + git_commit_free(commit); + git_rebase_free(rebase); +} + +static int create_cb_error( + git_oid *out, + const git_signature *author, + const git_signature *committer, + const char *message_encoding, + const char *message, + const git_tree *tree, + size_t parent_count, + const git_commit *parents[], + void *payload) +{ + GIT_UNUSED(out); + GIT_UNUSED(author); + GIT_UNUSED(committer); + GIT_UNUSED(message_encoding); + GIT_UNUSED(message); + GIT_UNUSED(tree); + GIT_UNUSED(parent_count); + GIT_UNUSED(parents); + GIT_UNUSED(payload); + + return GIT_EUSER; +} + +/* git checkout gravy ; git rebase --merge veal */ +void test_rebase_sign__create_propagates_error(void) +{ + git_rebase *rebase; + git_reference *branch_ref, *upstream_ref; + git_annotated_commit *branch_head, *upstream_head; + git_oid commit_id; + git_rebase_operation *rebase_operation; + git_rebase_options rebase_opts = GIT_REBASE_OPTIONS_INIT; + + rebase_opts.commit_create_cb = create_cb_error; + + cl_git_pass(git_reference_lookup(&branch_ref, repo, "refs/heads/gravy")); + cl_git_pass(git_reference_lookup(&upstream_ref, repo, "refs/heads/veal")); + + cl_git_pass(git_annotated_commit_from_ref(&branch_head, repo, branch_ref)); + cl_git_pass(git_annotated_commit_from_ref(&upstream_head, repo, upstream_ref)); + + cl_git_pass(git_rebase_init(&rebase, repo, branch_head, upstream_head, NULL, &rebase_opts)); + + cl_git_pass(git_rebase_next(&rebase_operation, rebase)); + cl_git_fail_with(GIT_EUSER, git_rebase_commit(&commit_id, rebase, NULL, signature, NULL, NULL)); + + git_reference_free(branch_ref); + git_reference_free(upstream_ref); + git_annotated_commit_free(branch_head); + git_annotated_commit_free(upstream_head); + git_rebase_free(rebase); +} + +#ifndef GIT_DEPRECATE_HARD +static const char *expected_commit_content = "\ +tree cd99b26250099fc38d30bfaed7797a7275ed3366\n\ parent f87d14a4a236582a0278a916340a793714256864\n\ author Edward Thomson <ethomson@edwardthomson.com> 1405625055 -0400\n\ committer Rebaser <rebaser@rebaser.rb> 1405694510 +0000\n\ @@ -37,10 +269,12 @@ int signing_cb_passthrough( cl_assert_equal_p(NULL, payload); return GIT_PASSTHROUGH; } +#endif /* !GIT_DEPRECATE_HARD */ /* git checkout gravy ; git rebase --merge veal */ void test_rebase_sign__passthrough_signing_cb(void) { +#ifndef GIT_DEPRECATE_HARD git_rebase *rebase; git_reference *branch_ref, *upstream_ref; git_annotated_commit *branch_head, *upstream_head; @@ -80,15 +314,18 @@ committer Rebaser <rebaser@rebaser.rb> 1405694510 +0000\n"; git_annotated_commit_free(upstream_head); git_commit_free(commit); git_rebase_free(rebase); +#endif /* !GIT_DEPRECATE_HARD */ } +#ifndef GIT_DEPRECATE_HARD int signing_cb_gpg( git_buf *signature, git_buf *signature_field, const char *commit_content, void *payload) { - const char *gpg_signature = "-----BEGIN PGP SIGNATURE-----\n\ + const char *gpg_signature = "\ +-----BEGIN PGP SIGNATURE-----\n\ \n\ iQIzBAEBCgAdFiEEgVlDEfSlmKn0fvGgK++h5T2/ctIFAlwZcrAACgkQK++h5T2/\n\ ctIPVhAA42RyZhMdKl5Bm0KtQco2scsukIg2y7tjSwhti91zDu3HQgpusjjo0fQx\n\ @@ -113,10 +350,12 @@ cttVRsdOoego+fiy08eFE+aJIeYiINRGhqOBTsuqG4jIdpdKxPE=\n\ cl_git_pass(git_buf_set(signature, gpg_signature, strlen(gpg_signature) + 1)); return GIT_OK; } +#endif /* !GIT_DEPRECATE_HARD */ /* git checkout gravy ; git rebase --merge veal */ void test_rebase_sign__gpg_with_no_field(void) { +#ifndef GIT_DEPRECATE_HARD git_rebase *rebase; git_reference *branch_ref, *upstream_ref; git_annotated_commit *branch_head, *upstream_head; @@ -124,7 +363,8 @@ void test_rebase_sign__gpg_with_no_field(void) git_oid commit_id, expected_id; git_rebase_options rebase_opts = GIT_REBASE_OPTIONS_INIT; git_commit *commit; - const char *expected_commit_raw_header = "tree cd99b26250099fc38d30bfaed7797a7275ed3366\n\ + const char *expected_commit_raw_header = "\ +tree cd99b26250099fc38d30bfaed7797a7275ed3366\n\ parent f87d14a4a236582a0278a916340a793714256864\n\ author Edward Thomson <ethomson@edwardthomson.com> 1405625055 -0400\n\ committer Rebaser <rebaser@rebaser.rb> 1405694510 +0000\n\ @@ -172,9 +412,11 @@ gpgsig -----BEGIN PGP SIGNATURE-----\n\ git_annotated_commit_free(upstream_head); git_commit_free(commit); git_rebase_free(rebase); +#endif /* !GIT_DEPRECATE_HARD */ } +#ifndef GIT_DEPRECATE_HARD int signing_cb_magic_field( git_buf *signature, git_buf *signature_field, @@ -196,10 +438,12 @@ int signing_cb_magic_field( return GIT_OK; } +#endif /* !GIT_DEPRECATE_HARD */ /* git checkout gravy ; git rebase --merge veal */ void test_rebase_sign__custom_signature_field(void) { +#ifndef GIT_DEPRECATE_HARD git_rebase *rebase; git_reference *branch_ref, *upstream_ref; git_annotated_commit *branch_head, *upstream_head; @@ -207,7 +451,8 @@ void test_rebase_sign__custom_signature_field(void) git_oid commit_id, expected_id; git_rebase_options rebase_opts = GIT_REBASE_OPTIONS_INIT; git_commit *commit; - const char *expected_commit_raw_header = "tree cd99b26250099fc38d30bfaed7797a7275ed3366\n\ + const char *expected_commit_raw_header = "\ +tree cd99b26250099fc38d30bfaed7797a7275ed3366\n\ parent f87d14a4a236582a0278a916340a793714256864\n\ author Edward Thomson <ethomson@edwardthomson.com> 1405625055 -0400\n\ committer Rebaser <rebaser@rebaser.rb> 1405694510 +0000\n\ @@ -240,4 +485,5 @@ magicsig magic word: pretty please\n"; git_annotated_commit_free(upstream_head); git_commit_free(commit); git_rebase_free(rebase); +#endif /* !GIT_DEPRECATE_HARD */ } diff --git a/tests/refs/basic.c b/tests/refs/basic.c index ed0c0bde6..9e4c22964 100644 --- a/tests/refs/basic.c +++ b/tests/refs/basic.c @@ -42,3 +42,44 @@ void test_refs_basic__reference_realloc(void) git_reference_free(new_ref); git_reference_free(ref); } + +void test_refs_basic__longpaths(void) +{ +#ifdef GIT_WIN32 + const char *base; + size_t base_len, extra_len; + ssize_t remain_len, i; + git_buf refname = GIT_BUF_INIT; + git_reference *one = NULL, *two = NULL; + git_oid id; + + cl_git_pass(git_oid_fromstr(&id, "099fabac3a9ea935598528c27f866e34089c2eff")); + + base = git_repository_path(g_repo); + base_len = git_utf8_char_length(base, strlen(base)); + extra_len = CONST_STRLEN("logs/refs/heads/") + CONST_STRLEN(".lock"); + + remain_len = (ssize_t)MAX_PATH - (base_len + extra_len); + cl_assert(remain_len > 0); + + cl_git_pass(git_buf_puts(&refname, "refs/heads/")); + + for (i = 0; i < remain_len; i++) { + cl_git_pass(git_buf_putc(&refname, 'a')); + } + + /* + * The full path to the reflog lockfile is 260 characters, + * this is permitted. + */ + cl_git_pass(git_reference_create(&one, g_repo, refname.ptr, &id, 0, NULL)); + + /* Adding one more character gives us a path that is too long. */ + cl_git_pass(git_buf_putc(&refname, 'z')); + cl_git_fail(git_reference_create(&two, g_repo, refname.ptr, &id, 0, NULL)); + + git_reference_free(one); + git_reference_free(two); + git_buf_dispose(&refname); +#endif +} diff --git a/tests/refs/branches/name.c b/tests/refs/branches/name.c index 176f836a4..290916eec 100644 --- a/tests/refs/branches/name.c +++ b/tests/refs/branches/name.c @@ -43,3 +43,20 @@ void test_refs_branches_name__error_when_ref_is_no_branch(void) cl_git_pass(git_reference_lookup(&ref,repo,"refs/notes/fanout")); cl_git_fail(git_branch_name(&name,ref)); } + +static int name_is_valid(const char *name) +{ + int valid; + cl_git_pass(git_branch_name_is_valid(&valid, name)); + return valid; +} + +void test_refs_branches_is_name_valid(void) +{ + cl_assert_equal_i(true, name_is_valid("master")); + cl_assert_equal_i(true, name_is_valid("test/master")); + + cl_assert_equal_i(false, name_is_valid("")); + cl_assert_equal_i(false, name_is_valid("HEAD")); + cl_assert_equal_i(false, name_is_valid("-dash")); +} diff --git a/tests/refs/branches/upstream.c b/tests/refs/branches/upstream.c index 928a9ff7b..919705e07 100644 --- a/tests/refs/branches/upstream.c +++ b/tests/refs/branches/upstream.c @@ -71,6 +71,31 @@ void test_refs_branches_upstream__upstream_remote(void) git_buf_dispose(&buf); } +void test_refs_branches_upstream__upstream_merge(void) +{ + git_reference *branch; + git_repository *repository; + git_buf buf = GIT_BUF_INIT; + + repository = cl_git_sandbox_init("testrepo.git"); + + /* check repository */ + cl_git_pass(git_reference_lookup(&branch, repository, "refs/heads/test")); + cl_git_pass(git_branch_set_upstream(branch, "test/master")); + + assert_config_entry_value(repository, "branch.test.remote", "test"); + assert_config_entry_value(repository, "branch.test.merge", "refs/heads/master"); + + git_reference_free(branch); + + /* check merge branch */ + cl_git_pass(git_branch_upstream_merge(&buf, repository, "refs/heads/test")); + cl_assert_equal_s("refs/heads/master", buf.ptr); + git_buf_dispose(&buf); + + cl_git_sandbox_cleanup(); +} + void test_refs_branches_upstream__upstream_remote_empty_value(void) { git_repository *repository; diff --git a/tests/refs/isvalidname.c b/tests/refs/isvalidname.c index 65c70ba4d..063f0f798 100644 --- a/tests/refs/isvalidname.c +++ b/tests/refs/isvalidname.c @@ -1,31 +1,38 @@ #include "clar_libgit2.h" +static bool is_valid_name(const char *name) +{ + int valid; + cl_git_pass(git_reference_name_is_valid(&valid, name)); + return valid; +} + void test_refs_isvalidname__can_detect_invalid_formats(void) { - cl_assert_equal_i(false, git_reference_is_valid_name("refs/tags/0.17.0^{}")); - cl_assert_equal_i(false, git_reference_is_valid_name("TWO/LEVELS")); - cl_assert_equal_i(false, git_reference_is_valid_name("ONE.LEVEL")); - cl_assert_equal_i(false, git_reference_is_valid_name("HEAD/")); - cl_assert_equal_i(false, git_reference_is_valid_name("NO_TRAILING_UNDERSCORE_")); - cl_assert_equal_i(false, git_reference_is_valid_name("_NO_LEADING_UNDERSCORE")); - cl_assert_equal_i(false, git_reference_is_valid_name("HEAD/aa")); - cl_assert_equal_i(false, git_reference_is_valid_name("lower_case")); - cl_assert_equal_i(false, git_reference_is_valid_name("/stupid/name/master")); - cl_assert_equal_i(false, git_reference_is_valid_name("/")); - cl_assert_equal_i(false, git_reference_is_valid_name("//")); - cl_assert_equal_i(false, git_reference_is_valid_name("")); - cl_assert_equal_i(false, git_reference_is_valid_name("refs/heads/sub.lock/webmatrix")); + cl_assert_equal_i(false, is_valid_name("refs/tags/0.17.0^{}")); + cl_assert_equal_i(false, is_valid_name("TWO/LEVELS")); + cl_assert_equal_i(false, is_valid_name("ONE.LEVEL")); + cl_assert_equal_i(false, is_valid_name("HEAD/")); + cl_assert_equal_i(false, is_valid_name("NO_TRAILING_UNDERSCORE_")); + cl_assert_equal_i(false, is_valid_name("_NO_LEADING_UNDERSCORE")); + cl_assert_equal_i(false, is_valid_name("HEAD/aa")); + cl_assert_equal_i(false, is_valid_name("lower_case")); + cl_assert_equal_i(false, is_valid_name("/stupid/name/master")); + cl_assert_equal_i(false, is_valid_name("/")); + cl_assert_equal_i(false, is_valid_name("//")); + cl_assert_equal_i(false, is_valid_name("")); + cl_assert_equal_i(false, is_valid_name("refs/heads/sub.lock/webmatrix")); } void test_refs_isvalidname__wont_hopefully_choke_on_valid_formats(void) { - cl_assert_equal_i(true, git_reference_is_valid_name("refs/tags/0.17.0")); - cl_assert_equal_i(true, git_reference_is_valid_name("refs/LEVELS")); - cl_assert_equal_i(true, git_reference_is_valid_name("HEAD")); - cl_assert_equal_i(true, git_reference_is_valid_name("ONE_LEVEL")); - cl_assert_equal_i(true, git_reference_is_valid_name("refs/stash")); - cl_assert_equal_i(true, git_reference_is_valid_name("refs/remotes/origin/bim_with_3d@11296")); - cl_assert_equal_i(true, git_reference_is_valid_name("refs/master{yesterday")); - cl_assert_equal_i(true, git_reference_is_valid_name("refs/master}yesterday")); - cl_assert_equal_i(true, git_reference_is_valid_name("refs/master{yesterday}")); + cl_assert_equal_i(true, is_valid_name("refs/tags/0.17.0")); + cl_assert_equal_i(true, is_valid_name("refs/LEVELS")); + cl_assert_equal_i(true, is_valid_name("HEAD")); + cl_assert_equal_i(true, is_valid_name("ONE_LEVEL")); + cl_assert_equal_i(true, is_valid_name("refs/stash")); + cl_assert_equal_i(true, is_valid_name("refs/remotes/origin/bim_with_3d@11296")); + cl_assert_equal_i(true, is_valid_name("refs/master{yesterday")); + cl_assert_equal_i(true, is_valid_name("refs/master}yesterday")); + cl_assert_equal_i(true, is_valid_name("refs/master{yesterday}")); } diff --git a/tests/refs/races.c b/tests/refs/races.c index 04a1bc17b..476789358 100644 --- a/tests/refs/races.c +++ b/tests/refs/races.c @@ -22,6 +22,24 @@ void test_refs_races__cleanup(void) cl_git_sandbox_cleanup(); } +void test_refs_races__create_matching_zero_old(void) +{ + git_reference *ref; + git_oid id, zero_id; + + git_oid_fromstr(&id, commit_id); + git_oid_fromstr(&zero_id, "0000000000000000000000000000000000000000"); + + cl_git_fail(git_reference_create_matching(&ref, g_repo, refname, &id, 1, &zero_id, NULL)); + git_reference_free(ref); + + cl_git_pass(git_reference_create_matching(&ref, g_repo, other_refname, &id, 1, &zero_id, NULL)); + git_reference_free(ref); + + cl_git_fail(git_reference_create_matching(&ref, g_repo, other_refname, &id, 1, &zero_id, NULL)); + git_reference_free(ref); +} + void test_refs_races__create_matching(void) { git_reference *ref, *ref2, *ref3; diff --git a/tests/refs/reflog/messages.c b/tests/refs/reflog/messages.c index 43f59a84b..53b8c6f3e 100644 --- a/tests/refs/reflog/messages.c +++ b/tests/refs/reflog/messages.c @@ -24,11 +24,8 @@ void test_refs_reflog_messages__cleanup(void) void test_refs_reflog_messages__setting_head_updates_reflog(void) { git_object *tag; - git_signature *sig; git_annotated_commit *annotated; - cl_git_pass(git_signature_now(&sig, "me", "foo@example.com")); - cl_git_pass(git_repository_set_head(g_repo, "refs/heads/haacked")); /* 4 */ cl_git_pass(git_repository_set_head(g_repo, "refs/heads/unborn")); cl_git_pass(git_revparse_single(&tag, g_repo, "tags/test")); @@ -68,7 +65,6 @@ void test_refs_reflog_messages__setting_head_updates_reflog(void) git_annotated_commit_free(annotated); git_object_free(tag); - git_signature_free(sig); } void test_refs_reflog_messages__setting_head_to_same_target_ignores_reflog(void) @@ -87,12 +83,9 @@ void test_refs_reflog_messages__setting_head_to_same_target_ignores_reflog(void) void test_refs_reflog_messages__detaching_writes_reflog(void) { - git_signature *sig; git_oid id; const char *msg; - cl_git_pass(git_signature_now(&sig, "me", "foo@example.com")); - msg = "checkout: moving from master to e90810b8df3e80c413d903f631643c716887138d"; git_oid_fromstr(&id, "e90810b8df3e80c413d903f631643c716887138d"); cl_git_pass(git_repository_set_head_detached(g_repo, &id)); @@ -107,8 +100,6 @@ void test_refs_reflog_messages__detaching_writes_reflog(void) "e90810b8df3e80c413d903f631643c716887138d", "258f0e2a959a364e40ed6603d5d44fbb24765b10", NULL, msg); - - git_signature_free(sig); } void test_refs_reflog_messages__orphan_branch_does_not_count(void) diff --git a/tests/refs/revparse.c b/tests/refs/revparse.c index 3c4ed9af5..bc6e0a4c4 100644 --- a/tests/refs/revparse.c +++ b/tests/refs/revparse.c @@ -50,7 +50,7 @@ static void test_id_inrepo( const char *spec, const char *expected_left, const char *expected_right, - git_revparse_mode_t expected_flags, + git_revspec_t expected_flags, git_repository *repo) { git_revspec revspec; @@ -90,7 +90,7 @@ static void test_object_and_ref(const char *spec, const char *expected_oid, cons static void test_rangelike(const char *rangelike, const char *expected_left, const char *expected_right, - git_revparse_mode_t expected_revparseflags) + git_revspec_t expected_revparseflags) { char objstr[64] = {0}; git_revspec revspec; @@ -117,7 +117,7 @@ static void test_id( const char *spec, const char *expected_left, const char *expected_right, - git_revparse_mode_t expected_flags) + git_revspec_t expected_flags) { test_id_inrepo(spec, expected_left, expected_right, expected_flags, g_repo); } @@ -735,53 +735,53 @@ void test_refs_revparse__range(void) test_rangelike("be3563a^1..be3563a", "9fd738e8f7967c078dceed8190330fc8648ee56a", "be3563ae3f795b2b4353bcce3a527ad0a4f7f644", - GIT_REVPARSE_RANGE); + GIT_REVSPEC_RANGE); test_rangelike("be3563a^1...be3563a", "9fd738e8f7967c078dceed8190330fc8648ee56a", "be3563ae3f795b2b4353bcce3a527ad0a4f7f644", - GIT_REVPARSE_RANGE | GIT_REVPARSE_MERGE_BASE); + GIT_REVSPEC_RANGE | GIT_REVSPEC_MERGE_BASE); test_rangelike("be3563a^1.be3563a", NULL, NULL, 0); } void test_refs_revparse__parses_range_operator(void) { - test_id("HEAD", "a65fedf39aefe402d3bb6e24df4d4f5fe4547750", NULL, GIT_REVPARSE_SINGLE); + test_id("HEAD", "a65fedf39aefe402d3bb6e24df4d4f5fe4547750", NULL, GIT_REVSPEC_SINGLE); test_id("HEAD~3..HEAD", "4a202b346bb0fb0db7eff3cffeb3c70babbd2045", "a65fedf39aefe402d3bb6e24df4d4f5fe4547750", - GIT_REVPARSE_RANGE); + GIT_REVSPEC_RANGE); test_id("HEAD~3...HEAD", "4a202b346bb0fb0db7eff3cffeb3c70babbd2045", "a65fedf39aefe402d3bb6e24df4d4f5fe4547750", - GIT_REVPARSE_RANGE | GIT_REVPARSE_MERGE_BASE); + GIT_REVSPEC_RANGE | GIT_REVSPEC_MERGE_BASE); test_id("HEAD~3..", "4a202b346bb0fb0db7eff3cffeb3c70babbd2045", "a65fedf39aefe402d3bb6e24df4d4f5fe4547750", - GIT_REVPARSE_RANGE); + GIT_REVSPEC_RANGE); test_id("HEAD~3...", "4a202b346bb0fb0db7eff3cffeb3c70babbd2045", "a65fedf39aefe402d3bb6e24df4d4f5fe4547750", - GIT_REVPARSE_RANGE | GIT_REVPARSE_MERGE_BASE); + GIT_REVSPEC_RANGE | GIT_REVSPEC_MERGE_BASE); test_id("..HEAD~3", "a65fedf39aefe402d3bb6e24df4d4f5fe4547750", "4a202b346bb0fb0db7eff3cffeb3c70babbd2045", - GIT_REVPARSE_RANGE); + GIT_REVSPEC_RANGE); test_id("...HEAD~3", "a65fedf39aefe402d3bb6e24df4d4f5fe4547750", "4a202b346bb0fb0db7eff3cffeb3c70babbd2045", - GIT_REVPARSE_RANGE | GIT_REVPARSE_MERGE_BASE); + GIT_REVSPEC_RANGE | GIT_REVSPEC_MERGE_BASE); test_id("...", "a65fedf39aefe402d3bb6e24df4d4f5fe4547750", "a65fedf39aefe402d3bb6e24df4d4f5fe4547750", - GIT_REVPARSE_RANGE | GIT_REVPARSE_MERGE_BASE); + GIT_REVSPEC_RANGE | GIT_REVSPEC_MERGE_BASE); test_invalid_revspec(".."); } diff --git a/tests/refs/tags/name.c b/tests/refs/tags/name.c new file mode 100644 index 000000000..0ca5df7d6 --- /dev/null +++ b/tests/refs/tags/name.c @@ -0,0 +1,17 @@ +#include "clar_libgit2.h" + +static int name_is_valid(const char *name) +{ + int valid; + cl_git_pass(git_tag_name_is_valid(&valid, name)); + return valid; +} + +void test_refs_tags_is_name_valid(void) +{ + cl_assert_equal_i(true, name_is_valid("sometag")); + cl_assert_equal_i(true, name_is_valid("test/sometag")); + + cl_assert_equal_i(false, name_is_valid("")); + cl_assert_equal_i(false, name_is_valid("-dash")); +} diff --git a/tests/remote/fetch.c b/tests/remote/fetch.c new file mode 100644 index 000000000..7e825ca16 --- /dev/null +++ b/tests/remote/fetch.c @@ -0,0 +1,169 @@ +#include "../clar_libgit2.h" + +#include "remote.h" +#include "repository.h" + +static git_repository *repo1; +static git_repository *repo2; +static char* repo1_path; +static char* repo2_path; + +static const char *REPO1_REFNAME = "refs/heads/main"; +static const char *REPO2_REFNAME = "refs/remotes/repo1/main"; +static char *FORCE_FETCHSPEC = "+refs/heads/main:refs/remotes/repo1/main"; +static char *NON_FORCE_FETCHSPEC = "refs/heads/main:refs/remotes/repo1/main"; + +void test_remote_fetch__initialize(void) { + git_config *c; + git_buf repo1_path_buf = GIT_BUF_INIT; + git_buf repo2_path_buf = GIT_BUF_INIT; + const char *sandbox = clar_sandbox_path(); + + cl_git_pass(git_buf_joinpath(&repo1_path_buf, sandbox, "fetchtest_repo1")); + repo1_path = git_buf_detach(&repo1_path_buf); + cl_git_pass(git_repository_init(&repo1, repo1_path, true)); + + cl_git_pass(git_buf_joinpath(&repo2_path_buf, sandbox, "fetchtest_repo2")); + repo2_path = git_buf_detach(&repo2_path_buf); + cl_git_pass(git_repository_init(&repo2, repo2_path, true)); + + cl_git_pass(git_repository_config(&c, repo1)); + cl_git_pass(git_config_set_string(c, "user.email", "some@email")); + cl_git_pass(git_config_set_string(c, "user.name", "some@name")); + git_config_free(c); + git_buf_dispose(&repo1_path_buf); + git_buf_dispose(&repo2_path_buf); +} + +void test_remote_fetch__cleanup(void) { + git_repository_free(repo1); + git_repository_free(repo2); + + cl_git_pass(git_futils_rmdir_r(repo1_path, NULL, GIT_RMDIR_REMOVE_FILES)); + free(repo1_path); + + cl_git_pass(git_futils_rmdir_r(repo2_path, NULL, GIT_RMDIR_REMOVE_FILES)); + free(repo2_path); +} + + +/** + * This checks that the '+' flag on fetchspecs is respected. We create a + * repository that has a reference to two commits, one a child of the other. + * We fetch this repository into a second repository. Then we reset the + * reference in the first repository and run the fetch again. If the '+' flag + * is used then the reference in the second repository will change, but if it + * is not then it should stay the same. + * + * @param commit1id A pointer to an OID which will be populated with the first + * commit. + * @param commit2id A pointer to an OID which will be populated with the second + * commit, which is a descendant of the first. + * @param force Whether to use a spec with '+' prefixed to force the refs + * to update + */ +void do_time_travelling_fetch(git_oid *commit1id, git_oid *commit2id, + bool force) { + char *refspec_strs = { + force ? FORCE_FETCHSPEC : NON_FORCE_FETCHSPEC, + }; + git_strarray refspecs = { + .count = 1, + .strings = &refspec_strs, + }; + + /* create two commits in repo 1 and a reference to them */ + { + git_oid empty_tree_id; + git_tree *empty_tree; + git_signature *sig; + git_treebuilder *tb; + cl_git_pass(git_treebuilder_new(&tb, repo1, NULL)); + cl_git_pass(git_treebuilder_write(&empty_tree_id, tb)); + cl_git_pass(git_tree_lookup(&empty_tree, repo1, &empty_tree_id)); + cl_git_pass(git_signature_default(&sig, repo1)); + cl_git_pass(git_commit_create(commit1id, repo1, REPO1_REFNAME, sig, + sig, NULL, "one", empty_tree, 0, NULL)); + cl_git_pass(git_commit_create_v(commit2id, repo1, REPO1_REFNAME, sig, + sig, NULL, "two", empty_tree, 1, commit1id)); + + git_tree_free(empty_tree); + git_signature_free(sig); + git_treebuilder_free(tb); + } + + /* fetch the reference via the remote */ + { + git_remote *remote; + + cl_git_pass(git_remote_create_anonymous(&remote, repo2, + git_repository_path(repo1))); + cl_git_pass(git_remote_fetch(remote, &refspecs, NULL, "some message")); + + git_remote_free(remote); + } + + /* assert that repo2 references the second commit */ + { + const git_oid *target; + git_reference *ref; + cl_git_pass(git_reference_lookup(&ref, repo2, REPO2_REFNAME)); + target = git_reference_target(ref); + cl_assert_equal_b(git_oid_cmp(target, commit2id), 0); + git_reference_free(ref); + } + + /* set the reference in repo1 to point to the older commit */ + { + git_reference *ref; + git_reference *ref2; + cl_git_pass(git_reference_lookup(&ref, repo1, REPO1_REFNAME)); + cl_git_pass(git_reference_set_target(&ref2, ref, commit1id, + "rollback")); + git_reference_free(ref); + git_reference_free(ref2); + } + + /* fetch the reference again */ + { + git_remote *remote; + + cl_git_pass(git_remote_create_anonymous(&remote, repo2, + git_repository_path(repo1))); + cl_git_pass(git_remote_fetch(remote, &refspecs, NULL, "some message")); + + git_remote_free(remote); + } +} + +void test_remote_fetch__dont_update_refs_if_not_descendant_and_not_force(void) { + const git_oid *target; + git_oid commit1id; + git_oid commit2id; + git_reference *ref; + + do_time_travelling_fetch(&commit1id, &commit2id, false); + + /* assert that the reference in repo2 has not changed */ + cl_git_pass(git_reference_lookup(&ref, repo2, REPO2_REFNAME)); + target = git_reference_target(ref); + cl_assert_equal_b(git_oid_cmp(target, &commit2id), 0); + + git_reference_free(ref); +} + +void test_remote_fetch__do_update_refs_if_not_descendant_and_force(void) { + const git_oid *target; + git_oid commit1id; + git_oid commit2id; + git_reference *ref; + + do_time_travelling_fetch(&commit1id, &commit2id, true); + + /* assert that the reference in repo2 has changed */ + cl_git_pass(git_reference_lookup(&ref, repo2, REPO2_REFNAME)); + target = git_reference_target(ref); + cl_assert_equal_b(git_oid_cmp(target, &commit1id), 0); + + git_reference_free(ref); +} diff --git a/tests/remote/httpproxy.c b/tests/remote/httpproxy.c new file mode 100644 index 000000000..8cd4371f5 --- /dev/null +++ b/tests/remote/httpproxy.c @@ -0,0 +1,188 @@ +#include "clar_libgit2.h" +#include "futils.h" +#include "net.h" +#include "remote.h" + +static git_repository *repo; +static git_net_url url = GIT_NET_URL_INIT; + +static int orig_proxies_need_reset = 0; +static char *orig_http_proxy = NULL; +static char *orig_https_proxy = NULL; +static char *orig_no_proxy = NULL; + +void test_remote_httpproxy__initialize(void) +{ + git_remote *remote; + + repo = cl_git_sandbox_init("testrepo"); + cl_git_pass(git_remote_create(&remote, repo, "lg2", "https://github.com/libgit2/libgit2")); + cl_git_pass(git_net_url_parse(&url, "https://github.com/libgit2/libgit2")); + + git_remote_free(remote); + + orig_proxies_need_reset = 0; +} + +void test_remote_httpproxy__cleanup(void) +{ + if (orig_proxies_need_reset) { + cl_setenv("HTTP_PROXY", orig_http_proxy); + cl_setenv("HTTPS_PROXY", orig_https_proxy); + cl_setenv("NO_PROXY", orig_no_proxy); + + git__free(orig_http_proxy); + git__free(orig_https_proxy); + git__free(orig_no_proxy); + } + + git_net_url_dispose(&url); + cl_git_sandbox_cleanup(); +} + +void assert_proxy_is(const char *expected) +{ + git_remote *remote; + char *proxy; + + cl_git_pass(git_remote_lookup(&remote, repo, "lg2")); + cl_git_pass(git_remote__http_proxy(&proxy, remote, &url)); + + if (expected) + cl_assert_equal_s(proxy, expected); + else + cl_assert_equal_p(proxy, expected); + + git_remote_free(remote); + git__free(proxy); +} + +void assert_config_match(const char *config, const char *expected) +{ + git_remote *remote; + char *proxy; + + if (config) + cl_repo_set_string(repo, config, expected); + + cl_git_pass(git_remote_lookup(&remote, repo, "lg2")); + cl_git_pass(git_remote__http_proxy(&proxy, remote, &url)); + + if (expected) + cl_assert_equal_s(proxy, expected); + else + cl_assert_equal_p(proxy, expected); + + git_remote_free(remote); + git__free(proxy); +} + +void test_remote_httpproxy__config_overrides(void) +{ + /* + * http.proxy should be honored, then http.<url>.proxy should + * be honored in increasing specificity of the url. finally, + * remote.<name>.proxy is the most specific. + */ + assert_config_match(NULL, NULL); + assert_config_match("http.proxy", "http://localhost:1/"); + assert_config_match("http.https://github.com.proxy", "http://localhost:2/"); + assert_config_match("http.https://github.com/.proxy", "http://localhost:3/"); + assert_config_match("http.https://github.com/libgit2.proxy", "http://localhost:4/"); + assert_config_match("http.https://github.com/libgit2/.proxy", "http://localhost:5/"); + assert_config_match("http.https://github.com/libgit2/libgit2.proxy", "http://localhost:6/"); + assert_config_match("remote.lg2.proxy", "http://localhost:7/"); +} + +void test_remote_httpproxy__config_empty_overrides(void) +{ + /* + * with greater specificity, an empty config entry overrides + * a set one + */ + assert_config_match("http.proxy", "http://localhost:1/"); + assert_config_match("http.https://github.com.proxy", ""); + assert_config_match("http.https://github.com/libgit2/libgit2.proxy", "http://localhost:2/"); + assert_config_match("remote.lg2.proxy", ""); +} + +void assert_global_config_match(const char *config, const char *expected) +{ + git_remote *remote; + char *proxy; + git_config* cfg; + + if (config) { + cl_git_pass(git_config_open_default(&cfg)); + git_config_set_string(cfg, config, expected); + git_config_free(cfg); + } + + cl_git_pass(git_remote_create_detached(&remote, "https://github.com/libgit2/libgit2")); + cl_git_pass(git_remote__http_proxy(&proxy, remote, &url)); + + if (expected) + cl_assert_equal_s(proxy, expected); + else + cl_assert_equal_p(proxy, expected); + + git_remote_free(remote); + git__free(proxy); +} + +void test_remote_httpproxy__config_overrides_detached_remote(void) +{ + cl_fake_home(); + + assert_global_config_match(NULL, NULL); + assert_global_config_match("http.proxy", "http://localhost:1/"); + assert_global_config_match("http.https://github.com.proxy", "http://localhost:2/"); + assert_global_config_match("http.https://github.com/.proxy", "http://localhost:3/"); + assert_global_config_match("http.https://github.com/libgit2.proxy", "http://localhost:4/"); + assert_global_config_match("http.https://github.com/libgit2/.proxy", "http://localhost:5/"); + assert_global_config_match("http.https://github.com/libgit2/libgit2.proxy", "http://localhost:6/"); + + cl_git_pass(git_futils_rmdir_r("home", NULL, GIT_RMDIR_REMOVE_FILES)); +} + +void test_remote_httpproxy__env(void) +{ + orig_http_proxy = cl_getenv("HTTP_PROXY"); + orig_https_proxy = cl_getenv("HTTPS_PROXY"); + orig_no_proxy = cl_getenv("NO_PROXY"); + orig_proxies_need_reset = 1; + + /* Clear everything for a fresh start */ + cl_setenv("HTTP_PROXY", NULL); + cl_setenv("HTTPS_PROXY", NULL); + cl_setenv("NO_PROXY", NULL); + + /* HTTP proxy is ignored for HTTPS */ + cl_setenv("HTTP_PROXY", "http://localhost:9/"); + assert_proxy_is(NULL); + + /* HTTPS proxy is honored for HTTPS */ + cl_setenv("HTTPS_PROXY", "http://localhost:10/"); + assert_proxy_is("http://localhost:10/"); + + /* NO_PROXY is honored */ + cl_setenv("NO_PROXY", "github.com:443"); + assert_proxy_is(NULL); + + cl_setenv("NO_PROXY", "github.com:80"); + assert_proxy_is("http://localhost:10/"); + + cl_setenv("NO_PROXY", "github.com"); + assert_proxy_is(NULL); + + cl_setenv("NO_PROXY", "github.dev,github.com,github.foo"); + assert_proxy_is(NULL); + + cl_setenv("HTTPS_PROXY", ""); + assert_proxy_is(NULL); + + /* configuration overrides environment variables */ + cl_setenv("HTTPS_PROXY", "http://localhost:10/"); + cl_setenv("NO_PROXY", "github.none"); + assert_config_match("http.https://github.com.proxy", "http://localhost:11/"); +} diff --git a/tests/repo/extensions.c b/tests/repo/extensions.c new file mode 100644 index 000000000..e7772acd5 --- /dev/null +++ b/tests/repo/extensions.c @@ -0,0 +1,72 @@ +#include "clar_libgit2.h" +#include "futils.h" +#include "sysdir.h" +#include <ctype.h> + +git_repository *repo; + +void test_repo_extensions__initialize(void) +{ + git_config *config; + + repo = cl_git_sandbox_init("empty_bare.git"); + + cl_git_pass(git_repository_config(&config, repo)); + cl_git_pass(git_config_set_int32(config, "core.repositoryformatversion", 1)); + git_config_free(config); +} + +void test_repo_extensions__cleanup(void) +{ + cl_git_sandbox_cleanup(); + cl_git_pass(git_libgit2_opts(GIT_OPT_SET_EXTENSIONS, NULL, 0)); +} + +void test_repo_extensions__builtin(void) +{ + git_repository *extended; + + cl_repo_set_string(repo, "extensions.noop", "foobar"); + + cl_git_pass(git_repository_open(&extended, "empty_bare.git")); + cl_assert(git_repository_path(extended) != NULL); + cl_assert(git__suffixcmp(git_repository_path(extended), "/") == 0); + git_repository_free(extended); +} + +void test_repo_extensions__negate_builtin(void) +{ + const char *in[] = { "foo", "!noop", "baz" }; + git_repository *extended; + + cl_repo_set_string(repo, "extensions.noop", "foobar"); + + cl_git_pass(git_libgit2_opts(GIT_OPT_SET_EXTENSIONS, in, ARRAY_SIZE(in))); + + cl_git_fail(git_repository_open(&extended, "empty_bare.git")); + git_repository_free(extended); +} + +void test_repo_extensions__unsupported(void) +{ + git_repository *extended = NULL; + + cl_repo_set_string(repo, "extensions.unknown", "foobar"); + + cl_git_fail(git_repository_open(&extended, "empty_bare.git")); + git_repository_free(extended); +} + +void test_repo_extensions__adds_extension(void) +{ + const char *in[] = { "foo", "!noop", "newextension", "baz" }; + git_repository *extended; + + cl_repo_set_string(repo, "extensions.newextension", "foobar"); + cl_git_pass(git_libgit2_opts(GIT_OPT_SET_EXTENSIONS, in, ARRAY_SIZE(in))); + + cl_git_pass(git_repository_open(&extended, "empty_bare.git")); + cl_assert(git_repository_path(extended) != NULL); + cl_assert(git__suffixcmp(git_repository_path(extended), "/") == 0); + git_repository_free(extended); +} diff --git a/tests/repo/getters.c b/tests/repo/getters.c index b8ede126c..d401bb832 100644 --- a/tests/repo/getters.c +++ b/tests/repo/getters.c @@ -1,4 +1,5 @@ #include "clar_libgit2.h" +#include "repo/repo_helpers.h" void test_repo_getters__is_empty_correctly_deals_with_pristine_looking_repos(void) { @@ -23,6 +24,18 @@ void test_repo_getters__is_empty_can_detect_used_repositories(void) git_repository_free(repo); } +void test_repo_getters__is_empty_can_detect_repositories_with_defaultbranch_config_empty(void) +{ + git_repository *repo; + + create_tmp_global_config("tmp_global_path", "init.defaultBranch", ""); + + cl_git_pass(git_repository_open(&repo, cl_fixture("testrepo.git"))); + cl_assert_equal_i(false, git_repository_is_empty(repo)); + + git_repository_free(repo); +} + void test_repo_getters__retrieving_the_odb_honors_the_refcount(void) { git_odb *odb; diff --git a/tests/repo/hashfile.c b/tests/repo/hashfile.c index 0fb4e6772..bffb51bb5 100644 --- a/tests/repo/hashfile.c +++ b/tests/repo/hashfile.c @@ -10,6 +10,7 @@ void test_repo_hashfile__initialize(void) void test_repo_hashfile__cleanup(void) { + cl_fixture_cleanup("absolute"); cl_git_sandbox_cleanup(); _repo = NULL; } @@ -38,10 +39,18 @@ void test_repo_hashfile__simple(void) git_buf_dispose(&full); } -void test_repo_hashfile__filtered(void) +void test_repo_hashfile__filtered_in_workdir(void) { + git_buf root = GIT_BUF_INIT, txt = GIT_BUF_INIT, bin = GIT_BUF_INIT; + char cwd[GIT_PATH_MAX]; git_oid a, b; + cl_must_pass(p_getcwd(cwd, GIT_PATH_MAX)); + cl_must_pass(p_mkdir("absolute", 0777)); + cl_git_pass(git_buf_joinpath(&root, cwd, "status")); + cl_git_pass(git_buf_joinpath(&txt, root.ptr, "testfile.txt")); + cl_git_pass(git_buf_joinpath(&bin, root.ptr, "testfile.bin")); + cl_repo_set_bool(_repo, "core.autocrlf", true); cl_git_append2file("status/.gitattributes", "*.txt text\n*.bin binary\n\n"); @@ -55,21 +64,41 @@ void test_repo_hashfile__filtered(void) cl_git_pass(git_repository_hashfile(&b, _repo, "testfile.txt", GIT_OBJECT_BLOB, NULL)); cl_assert(git_oid_cmp(&a, &b)); + /* not equal hashes because of filtering when specified by absolute path */ + cl_git_pass(git_odb_hashfile(&a, "status/testfile.txt", GIT_OBJECT_BLOB)); + cl_git_pass(git_repository_hashfile(&b, _repo, txt.ptr, GIT_OBJECT_BLOB, NULL)); + cl_assert(git_oid_cmp(&a, &b)); + /* equal hashes because filter is binary */ cl_git_pass(git_odb_hashfile(&a, "status/testfile.bin", GIT_OBJECT_BLOB)); cl_git_pass(git_repository_hashfile(&b, _repo, "testfile.bin", GIT_OBJECT_BLOB, NULL)); cl_assert_equal_oid(&a, &b); + /* equal hashes because filter is binary when specified by absolute path */ + cl_git_pass(git_odb_hashfile(&a, "status/testfile.bin", GIT_OBJECT_BLOB)); + cl_git_pass(git_repository_hashfile(&b, _repo, bin.ptr, GIT_OBJECT_BLOB, NULL)); + cl_assert_equal_oid(&a, &b); + /* equal hashes when 'as_file' points to binary filtering */ cl_git_pass(git_odb_hashfile(&a, "status/testfile.txt", GIT_OBJECT_BLOB)); cl_git_pass(git_repository_hashfile(&b, _repo, "testfile.txt", GIT_OBJECT_BLOB, "foo.bin")); cl_assert_equal_oid(&a, &b); + /* equal hashes when 'as_file' points to binary filtering (absolute path) */ + cl_git_pass(git_odb_hashfile(&a, "status/testfile.txt", GIT_OBJECT_BLOB)); + cl_git_pass(git_repository_hashfile(&b, _repo, txt.ptr, GIT_OBJECT_BLOB, "foo.bin")); + cl_assert_equal_oid(&a, &b); + /* not equal hashes when 'as_file' points to text filtering */ cl_git_pass(git_odb_hashfile(&a, "status/testfile.bin", GIT_OBJECT_BLOB)); cl_git_pass(git_repository_hashfile(&b, _repo, "testfile.bin", GIT_OBJECT_BLOB, "foo.txt")); cl_assert(git_oid_cmp(&a, &b)); + /* not equal hashes when 'as_file' points to text filtering */ + cl_git_pass(git_odb_hashfile(&a, "status/testfile.bin", GIT_OBJECT_BLOB)); + cl_git_pass(git_repository_hashfile(&b, _repo, bin.ptr, GIT_OBJECT_BLOB, "foo.txt")); + cl_assert(git_oid_cmp(&a, &b)); + /* equal hashes when 'as_file' is empty and turns off filtering */ cl_git_pass(git_odb_hashfile(&a, "status/testfile.txt", GIT_OBJECT_BLOB)); cl_git_pass(git_repository_hashfile(&b, _repo, "testfile.txt", GIT_OBJECT_BLOB, "")); @@ -79,7 +108,65 @@ void test_repo_hashfile__filtered(void) cl_git_pass(git_repository_hashfile(&b, _repo, "testfile.bin", GIT_OBJECT_BLOB, "")); cl_assert_equal_oid(&a, &b); + cl_git_pass(git_odb_hashfile(&a, "status/testfile.txt", GIT_OBJECT_BLOB)); + cl_git_pass(git_repository_hashfile(&b, _repo, txt.ptr, GIT_OBJECT_BLOB, "")); + cl_assert_equal_oid(&a, &b); + + cl_git_pass(git_odb_hashfile(&a, "status/testfile.bin", GIT_OBJECT_BLOB)); + cl_git_pass(git_repository_hashfile(&b, _repo, bin.ptr, GIT_OBJECT_BLOB, "")); + cl_assert_equal_oid(&a, &b); + /* some hash type failures */ cl_git_fail(git_odb_hashfile(&a, "status/testfile.txt", 0)); cl_git_fail(git_repository_hashfile(&b, _repo, "testfile.txt", GIT_OBJECT_ANY, NULL)); + + git_buf_dispose(&txt); + git_buf_dispose(&bin); + git_buf_dispose(&root); +} + +void test_repo_hashfile__filtered_outside_workdir(void) +{ + git_buf root = GIT_BUF_INIT, txt = GIT_BUF_INIT, bin = GIT_BUF_INIT; + char cwd[GIT_PATH_MAX]; + git_oid a, b; + + cl_must_pass(p_getcwd(cwd, GIT_PATH_MAX)); + cl_must_pass(p_mkdir("absolute", 0777)); + cl_git_pass(git_buf_joinpath(&root, cwd, "absolute")); + cl_git_pass(git_buf_joinpath(&txt, root.ptr, "testfile.txt")); + cl_git_pass(git_buf_joinpath(&bin, root.ptr, "testfile.bin")); + + cl_repo_set_bool(_repo, "core.autocrlf", true); + cl_git_append2file("status/.gitattributes", "*.txt text\n*.bin binary\n\n"); + + /* create some sample content with CRLF in it */ + cl_git_mkfile("absolute/testfile.txt", "content\r\n"); + cl_git_mkfile("absolute/testfile.bin", "other\r\nstuff\r\n"); + + /* not equal hashes because of filtering */ + cl_git_pass(git_odb_hashfile(&a, "absolute/testfile.txt", GIT_OBJECT_BLOB)); + cl_git_pass(git_repository_hashfile(&b, _repo, txt.ptr, GIT_OBJECT_BLOB, "testfile.txt")); + cl_assert(git_oid_cmp(&a, &b)); + + /* equal hashes because filter is binary */ + cl_git_pass(git_odb_hashfile(&a, "absolute/testfile.bin", GIT_OBJECT_BLOB)); + cl_git_pass(git_repository_hashfile(&b, _repo, bin.ptr, GIT_OBJECT_BLOB, "testfile.bin")); + cl_assert_equal_oid(&a, &b); + + /* + * equal hashes because no filtering occurs for absolute paths outside the working + * directory unless as_path is specified + */ + cl_git_pass(git_odb_hashfile(&a, "absolute/testfile.txt", GIT_OBJECT_BLOB)); + cl_git_pass(git_repository_hashfile(&b, _repo, txt.ptr, GIT_OBJECT_BLOB, NULL)); + cl_assert_equal_oid(&a, &b); + + cl_git_pass(git_odb_hashfile(&a, "absolute/testfile.bin", GIT_OBJECT_BLOB)); + cl_git_pass(git_repository_hashfile(&b, _repo, bin.ptr, GIT_OBJECT_BLOB, NULL)); + cl_assert_equal_oid(&a, &b); + + git_buf_dispose(&txt); + git_buf_dispose(&bin); + git_buf_dispose(&root); } diff --git a/tests/repo/init.c b/tests/repo/init.c index 5a95229e6..1aa326f7f 100644 --- a/tests/repo/init.c +++ b/tests/repo/init.c @@ -11,30 +11,30 @@ enum repo_mode { BARE_REPOSITORY = 1 }; -static git_repository *_repo = NULL; -static git_buf _global_path = GIT_BUF_INIT; +static git_repository *g_repo = NULL; +static git_buf g_global_path = GIT_BUF_INIT; void test_repo_init__initialize(void) { - _repo = NULL; + g_repo = NULL; git_libgit2_opts(GIT_OPT_GET_SEARCH_PATH, GIT_CONFIG_LEVEL_GLOBAL, - &_global_path); + &g_global_path); } void test_repo_init__cleanup(void) { git_libgit2_opts(GIT_OPT_SET_SEARCH_PATH, GIT_CONFIG_LEVEL_GLOBAL, - _global_path.ptr); - git_buf_dispose(&_global_path); + g_global_path.ptr); + git_buf_dispose(&g_global_path); cl_fixture_cleanup("tmp_global_path"); } static void cleanup_repository(void *path) { - git_repository_free(_repo); - _repo = NULL; + git_repository_free(g_repo); + g_repo = NULL; cl_fixture_cleanup((const char *)path); } @@ -49,9 +49,9 @@ static void ensure_repository_init( cl_assert(!git_path_isdir(working_directory)); - cl_git_pass(git_repository_init(&_repo, working_directory, is_bare)); + cl_git_pass(git_repository_init(&g_repo, working_directory, is_bare)); - workdir = git_repository_workdir(_repo); + workdir = git_repository_workdir(g_repo); if (workdir != NULL || expected_working_directory != NULL) { cl_assert( git__suffixcmp(workdir, expected_working_directory) == 0 @@ -59,19 +59,19 @@ static void ensure_repository_init( } cl_assert( - git__suffixcmp(git_repository_path(_repo), expected_path_repository) == 0 + git__suffixcmp(git_repository_path(g_repo), expected_path_repository) == 0 ); - cl_assert(git_repository_is_bare(_repo) == is_bare); + cl_assert(git_repository_is_bare(g_repo) == is_bare); #ifdef GIT_WIN32 if (!is_bare) { - DWORD fattrs = GetFileAttributes(git_repository_path(_repo)); + DWORD fattrs = GetFileAttributes(git_repository_path(g_repo)); cl_assert((fattrs & FILE_ATTRIBUTE_HIDDEN) != 0); } #endif - cl_assert(git_repository_is_empty(_repo)); + cl_assert(git_repository_is_empty(g_repo)); } void test_repo_init__standard_repo(void) @@ -112,13 +112,14 @@ void test_repo_init__bare_repo_escaping_current_workdir(void) cl_git_pass(chdir(git_buf_cstr(&path_repository))); /* Initialize a bare repo with a relative path escaping out of the current working directory */ - cl_git_pass(git_repository_init(&_repo, "../d/e.git", 1)); - cl_git_pass(git__suffixcmp(git_repository_path(_repo), "/a/b/d/e.git/")); + cl_git_pass(git_repository_init(&g_repo, "../d/e.git", 1)); + cl_git_pass(git__suffixcmp(git_repository_path(g_repo), "/a/b/d/e.git/")); - git_repository_free(_repo); + git_repository_free(g_repo); + g_repo = NULL; /* Open a bare repo with a relative path escaping out of the current working directory */ - cl_git_pass(git_repository_open(&_repo, "../d/e.git")); + cl_git_pass(git_repository_open(&g_repo, "../d/e.git")); cl_git_pass(chdir(git_buf_cstr(&path_current_workdir))); @@ -133,11 +134,12 @@ void test_repo_init__reinit_bare_repo(void) cl_set_cleanup(&cleanup_repository, "reinit.git"); /* Initialize the repository */ - cl_git_pass(git_repository_init(&_repo, "reinit.git", 1)); - git_repository_free(_repo); + cl_git_pass(git_repository_init(&g_repo, "reinit.git", 1)); + git_repository_free(g_repo); + g_repo = NULL; /* Reinitialize the repository */ - cl_git_pass(git_repository_init(&_repo, "reinit.git", 1)); + cl_git_pass(git_repository_init(&g_repo, "reinit.git", 1)); } void test_repo_init__reinit_too_recent_bare_repo(void) @@ -145,8 +147,8 @@ void test_repo_init__reinit_too_recent_bare_repo(void) git_config *config; /* Initialize the repository */ - cl_git_pass(git_repository_init(&_repo, "reinit.git", 1)); - git_repository_config(&config, _repo); + cl_git_pass(git_repository_init(&g_repo, "reinit.git", 1)); + git_repository_config(&config, g_repo); /* * Hack the config of the repository to make it look like it has @@ -155,10 +157,11 @@ void test_repo_init__reinit_too_recent_bare_repo(void) cl_git_pass(git_config_set_int32(config, "core.repositoryformatversion", 42)); git_config_free(config); - git_repository_free(_repo); + git_repository_free(g_repo); + g_repo = NULL; /* Try to reinitialize the repository */ - cl_git_fail(git_repository_init(&_repo, "reinit.git", 1)); + cl_git_fail(git_repository_init(&g_repo, "reinit.git", 1)); cl_fixture_cleanup("reinit.git"); } @@ -172,15 +175,15 @@ void test_repo_init__additional_templates(void) ensure_repository_init("tester", 0, "tester/.git/", "tester/"); cl_git_pass( - git_buf_joinpath(&path, git_repository_path(_repo), "description")); + git_buf_joinpath(&path, git_repository_path(g_repo), "description")); cl_assert(git_path_isfile(git_buf_cstr(&path))); cl_git_pass( - git_buf_joinpath(&path, git_repository_path(_repo), "info/exclude")); + git_buf_joinpath(&path, git_repository_path(g_repo), "info/exclude")); cl_assert(git_path_isfile(git_buf_cstr(&path))); cl_git_pass( - git_buf_joinpath(&path, git_repository_path(_repo), "hooks")); + git_buf_joinpath(&path, git_repository_path(g_repo), "hooks")); cl_assert(git_path_isdir(git_buf_cstr(&path))); /* won't confirm specific contents of hooks dir since it may vary */ @@ -197,9 +200,9 @@ static void assert_config_entry_on_init_bytype( cl_set_cleanup(&cleanup_repository, "config_entry"); - cl_git_pass(git_repository_init(&_repo, repo_path, is_bare)); + cl_git_pass(git_repository_init(&g_repo, repo_path, is_bare)); - cl_git_pass(git_repository_config(&config, _repo)); + cl_git_pass(git_repository_config(&config, g_repo)); error = git_config_get_bool(¤t_value, config, config_key); git_config_free(config); @@ -215,7 +218,8 @@ static void assert_config_entry_on_init( const char *config_key, int expected_value) { assert_config_entry_on_init_bytype(config_key, expected_value, true); - git_repository_free(_repo); + git_repository_free(g_repo); + g_repo = NULL; assert_config_entry_on_init_bytype(config_key, expected_value, false); } @@ -262,10 +266,10 @@ void test_repo_init__symlinks_win32_enabled_by_global_config(void) * Create a new repository (can't use `assert_config_on_init` since we * want to examine configuration levels with more granularity.) */ - cl_git_pass(git_repository_init(&_repo, "config_entry/test.non.bare.git", false)); + cl_git_pass(git_repository_init(&g_repo, "config_entry/test.non.bare.git", false)); /* Ensure that core.symlinks remains set (via the global config). */ - cl_git_pass(git_repository_config(&config, _repo)); + cl_git_pass(git_repository_config(&config, g_repo)); cl_git_pass(git_config_get_bool(&val, config, "core.symlinks")); cl_assert_equal_i(1, val); @@ -278,6 +282,9 @@ void test_repo_init__symlinks_win32_enabled_by_global_config(void) git_config_free(repo_config); git_config_free(config); + + git_repository_free(g_repo); + g_repo = NULL; #endif } @@ -324,18 +331,18 @@ void test_repo_init__reinit_doesnot_overwrite_ignorecase(void) /* Init a new repo */ cl_set_cleanup(&cleanup_repository, "not.overwrite.git"); - cl_git_pass(git_repository_init(&_repo, "not.overwrite.git", 1)); + cl_git_pass(git_repository_init(&g_repo, "not.overwrite.git", 1)); /* Change the "core.ignorecase" config value to something unlikely */ - git_repository_config(&config, _repo); + git_repository_config(&config, g_repo); git_config_set_int32(config, "core.ignorecase", 42); git_config_free(config); - git_repository_free(_repo); - _repo = NULL; + git_repository_free(g_repo); + g_repo = NULL; /* Reinit the repository */ - cl_git_pass(git_repository_init(&_repo, "not.overwrite.git", 1)); - git_repository_config(&config, _repo); + cl_git_pass(git_repository_init(&g_repo, "not.overwrite.git", 1)); + git_repository_config(&config, g_repo); /* Ensure the "core.ignorecase" config value hasn't been updated */ cl_git_pass(git_config_get_int32(¤t_value, config, "core.ignorecase")); @@ -350,26 +357,26 @@ void test_repo_init__reinit_overwrites_filemode(void) /* Init a new repo */ cl_set_cleanup(&cleanup_repository, "overwrite.git"); - cl_git_pass(git_repository_init(&_repo, "overwrite.git", 1)); + cl_git_pass(git_repository_init(&g_repo, "overwrite.git", 1)); /* Change the "core.filemode" config value to something unlikely */ - cl_repo_set_bool(_repo, "core.filemode", !expected); + cl_repo_set_bool(g_repo, "core.filemode", !expected); - git_repository_free(_repo); - _repo = NULL; + git_repository_free(g_repo); + g_repo = NULL; /* Reinit the repository */ - cl_git_pass(git_repository_init(&_repo, "overwrite.git", 1)); + cl_git_pass(git_repository_init(&g_repo, "overwrite.git", 1)); /* Ensure the "core.filemode" config value has been reset */ - current_value = cl_repo_get_bool(_repo, "core.filemode"); + current_value = cl_repo_get_bool(g_repo, "core.filemode"); cl_assert_equal_i(expected, current_value); } void test_repo_init__sets_logAllRefUpdates_according_to_type_of_repository(void) { assert_config_entry_on_init_bytype("core.logallrefupdates", GIT_ENOTFOUND, true); - git_repository_free(_repo); + git_repository_free(g_repo); assert_config_entry_on_init_bytype("core.logallrefupdates", true, false); } @@ -378,16 +385,16 @@ void test_repo_init__extended_0(void) git_repository_init_options opts = GIT_REPOSITORY_INIT_OPTIONS_INIT; /* without MKDIR this should fail */ - cl_git_fail(git_repository_init_ext(&_repo, "extended", &opts)); + cl_git_fail(git_repository_init_ext(&g_repo, "extended", &opts)); /* make the directory first, then it should succeed */ cl_git_pass(git_futils_mkdir("extended", 0775, 0)); - cl_git_pass(git_repository_init_ext(&_repo, "extended", &opts)); + cl_git_pass(git_repository_init_ext(&g_repo, "extended", &opts)); - cl_assert(!git__suffixcmp(git_repository_workdir(_repo), "/extended/")); - cl_assert(!git__suffixcmp(git_repository_path(_repo), "/extended/.git/")); - cl_assert(!git_repository_is_bare(_repo)); - cl_assert(git_repository_is_empty(_repo)); + cl_assert(!git__suffixcmp(git_repository_workdir(g_repo), "/extended/")); + cl_assert(!git__suffixcmp(git_repository_path(g_repo), "/extended/.git/")); + cl_assert(!git_repository_is_bare(g_repo)); + cl_assert(git_repository_is_empty(g_repo)); cleanup_repository("extended"); } @@ -407,33 +414,33 @@ void test_repo_init__extended_1(void) opts.initial_head = "development"; opts.origin_url = "https://github.com/libgit2/libgit2.git"; - cl_git_pass(git_repository_init_ext(&_repo, "root/b/c.git", &opts)); + cl_git_pass(git_repository_init_ext(&g_repo, "root/b/c.git", &opts)); - cl_assert(!git__suffixcmp(git_repository_workdir(_repo), "/c_wd/")); - cl_assert(!git__suffixcmp(git_repository_path(_repo), "/c.git/")); + cl_assert(!git__suffixcmp(git_repository_workdir(g_repo), "/c_wd/")); + cl_assert(!git__suffixcmp(git_repository_path(g_repo), "/c.git/")); cl_assert(git_path_isfile("root/b/c_wd/.git")); - cl_assert(!git_repository_is_bare(_repo)); + cl_assert(!git_repository_is_bare(g_repo)); /* repo will not be counted as empty because we set head to "development" */ - cl_assert(!git_repository_is_empty(_repo)); + cl_assert(!git_repository_is_empty(g_repo)); - cl_git_pass(git_path_lstat(git_repository_path(_repo), &st)); + cl_git_pass(git_path_lstat(git_repository_path(g_repo), &st)); cl_assert(S_ISDIR(st.st_mode)); if (cl_is_chmod_supported()) cl_assert((S_ISGID & st.st_mode) == S_ISGID); else cl_assert((S_ISGID & st.st_mode) == 0); - cl_git_pass(git_reference_lookup(&ref, _repo, "HEAD")); + cl_git_pass(git_reference_lookup(&ref, g_repo, "HEAD")); cl_assert(git_reference_type(ref) == GIT_REFERENCE_SYMBOLIC); cl_assert_equal_s("refs/heads/development", git_reference_symbolic_target(ref)); git_reference_free(ref); - cl_git_pass(git_remote_lookup(&remote, _repo, "origin")); + cl_git_pass(git_remote_lookup(&remote, g_repo, "origin")); cl_assert_equal_s("origin", git_remote_name(remote)); cl_assert_equal_s(opts.origin_url, git_remote_url(remote)); git_remote_free(remote); - git_repository_free(_repo); + git_repository_free(g_repo); cl_fixture_cleanup("root"); } @@ -449,17 +456,17 @@ void test_repo_init__relative_gitdir(void) GIT_REPOSITORY_INIT_NO_DOTGIT_DIR; /* make the directory first, then it should succeed */ - cl_git_pass(git_repository_init_ext(&_repo, "root/b/my_repository", &opts)); + cl_git_pass(git_repository_init_ext(&g_repo, "root/b/my_repository", &opts)); - cl_assert(!git__suffixcmp(git_repository_workdir(_repo), "root/b/c_wd/")); - cl_assert(!git__suffixcmp(git_repository_path(_repo), "root/b/my_repository/")); - cl_assert(!git_repository_is_bare(_repo)); - cl_assert(git_repository_is_empty(_repo)); + cl_assert(!git__suffixcmp(git_repository_workdir(g_repo), "root/b/c_wd/")); + cl_assert(!git__suffixcmp(git_repository_path(g_repo), "root/b/my_repository/")); + cl_assert(!git_repository_is_bare(g_repo)); + cl_assert(git_repository_is_empty(g_repo)); /* Verify that the gitlink and worktree entries are relative */ /* Verify worktree */ - assert_config_entry_value(_repo, "core.worktree", "../c_wd/"); + assert_config_entry_value(g_repo, "core.worktree", "../c_wd/"); /* Verify gitlink */ cl_git_pass(git_futils_readbuffer(&dot_git_content, "root/b/c_wd/.git")); @@ -485,18 +492,18 @@ void test_repo_init__relative_gitdir_2(void) GIT_REPOSITORY_INIT_NO_DOTGIT_DIR; /* make the directory first, then it should succeed */ - cl_git_pass(git_repository_init_ext(&_repo, "root/b/my_repository", &opts)); + cl_git_pass(git_repository_init_ext(&g_repo, "root/b/my_repository", &opts)); git_buf_dispose(&full_path); - cl_assert(!git__suffixcmp(git_repository_workdir(_repo), "root/b/c_wd/")); - cl_assert(!git__suffixcmp(git_repository_path(_repo), "root/b/my_repository/")); - cl_assert(!git_repository_is_bare(_repo)); - cl_assert(git_repository_is_empty(_repo)); + cl_assert(!git__suffixcmp(git_repository_workdir(g_repo), "root/b/c_wd/")); + cl_assert(!git__suffixcmp(git_repository_path(g_repo), "root/b/my_repository/")); + cl_assert(!git_repository_is_bare(g_repo)); + cl_assert(git_repository_is_empty(g_repo)); /* Verify that the gitlink and worktree entries are relative */ /* Verify worktree */ - assert_config_entry_value(_repo, "core.worktree", "../c_wd/"); + assert_config_entry_value(g_repo, "core.worktree", "../c_wd/"); /* Verify gitlink */ cl_git_pass(git_futils_readbuffer(&dot_git_content, "root/b/c_wd/.git")); @@ -513,11 +520,11 @@ void test_repo_init__can_reinit_an_initialized_repository(void) cl_set_cleanup(&cleanup_repository, "extended"); cl_git_pass(git_futils_mkdir("extended", 0775, 0)); - cl_git_pass(git_repository_init(&_repo, "extended", false)); + cl_git_pass(git_repository_init(&g_repo, "extended", false)); cl_git_pass(git_repository_init(&reinit, "extended", false)); - cl_assert_equal_s(git_repository_path(_repo), git_repository_path(reinit)); + cl_assert_equal_s(git_repository_path(g_repo), git_repository_path(reinit)); git_repository_free(reinit); } @@ -529,10 +536,10 @@ void test_repo_init__init_with_initial_commit(void) cl_set_cleanup(&cleanup_repository, "committed"); /* Initialize the repository */ - cl_git_pass(git_repository_init(&_repo, "committed", 0)); + cl_git_pass(git_repository_init(&g_repo, "committed", 0)); /* Index will be automatically created when requested for a new repo */ - cl_git_pass(git_repository_index(&index, _repo)); + cl_git_pass(git_repository_index(&index, g_repo)); /* Create a file so we can commit it * @@ -558,7 +565,7 @@ void test_repo_init__init_with_initial_commit(void) /* Make sure we're ready to use git_signature_default :-) */ { git_config *cfg, *local; - cl_git_pass(git_repository_config(&cfg, _repo)); + cl_git_pass(git_repository_config(&cfg, g_repo)); cl_git_pass(git_config_open_level(&local, cfg, GIT_CONFIG_LEVEL_LOCAL)); cl_git_pass(git_config_set_string(local, "user.name", "Test User")); cl_git_pass(git_config_set_string(local, "user.email", "t@example.com")); @@ -572,12 +579,12 @@ void test_repo_init__init_with_initial_commit(void) git_oid tree_id, commit_id; git_tree *tree; - cl_git_pass(git_signature_default(&sig, _repo)); + cl_git_pass(git_signature_default(&sig, g_repo)); cl_git_pass(git_index_write_tree(&tree_id, index)); - cl_git_pass(git_tree_lookup(&tree, _repo, &tree_id)); + cl_git_pass(git_tree_lookup(&tree, g_repo, &tree_id)); cl_git_pass(git_commit_create_v( - &commit_id, _repo, "HEAD", sig, sig, + &commit_id, g_repo, "HEAD", sig, sig, NULL, "First", tree, 0)); git_tree_free(tree); @@ -665,3 +672,67 @@ void test_repo_init__unwriteable_directory(void) clar__skip(); #endif } + +void test_repo_init__defaultbranch_config(void) +{ + git_reference *head; + + cl_set_cleanup(&cleanup_repository, "repo"); + + create_tmp_global_config("tmp_global_path", "init.defaultbranch", "my_default_branch"); + + cl_git_pass(git_repository_init(&g_repo, "repo", 0)); + cl_git_pass(git_reference_lookup(&head, g_repo, "HEAD")); + + cl_assert_equal_s("refs/heads/my_default_branch", git_reference_symbolic_target(head)); + + git_reference_free(head); +} + +void test_repo_init__defaultbranch_config_empty(void) +{ + git_reference *head; + + cl_set_cleanup(&cleanup_repository, "repo"); + + create_tmp_global_config("tmp_global_path", "init.defaultbranch", ""); + + cl_git_pass(git_repository_init(&g_repo, "repo", 0)); + cl_git_pass(git_reference_lookup(&head, g_repo, "HEAD")); + + cl_assert_equal_s("refs/heads/master", git_reference_symbolic_target(head)); + + git_reference_free(head); +} + +void test_repo_init__longpath(void) +{ +#ifdef GIT_WIN32 + size_t padding = CONST_STRLEN("objects/pack/pack-.pack.lock") + GIT_OID_HEXSZ; + size_t max, i; + git_buf path = GIT_BUF_INIT; + git_repository *one = NULL, *two = NULL; + + /* + * Files within repositories need to fit within MAX_PATH; + * that means a repo path must be at most (MAX_PATH - 18). + */ + cl_git_pass(git_buf_puts(&path, clar_sandbox_path())); + cl_git_pass(git_buf_putc(&path, '/')); + + max = ((MAX_PATH) - path.size) - padding; + + for (i = 0; i < max - 1; i++) + cl_git_pass(git_buf_putc(&path, 'a')); + + cl_git_pass(git_repository_init(&one, path.ptr, 1)); + + /* Paths longer than this are rejected */ + cl_git_pass(git_buf_putc(&path, 'z')); + cl_git_fail(git_repository_init(&two, path.ptr, 1)); + + git_repository_free(one); + git_repository_free(two); + git_buf_dispose(&path); +#endif +} diff --git a/tests/repo/open.c b/tests/repo/open.c index 881a23d34..bd60c12c2 100644 --- a/tests/repo/open.c +++ b/tests/repo/open.c @@ -42,48 +42,6 @@ void test_repo_open__format_version_1(void) git_repository_free(repo); } -void test_repo_open__format_version_1_with_valid_extension(void) -{ - git_repository *repo; - git_config *config; - - repo = cl_git_sandbox_init("empty_bare.git"); - - cl_git_pass(git_repository_open(&repo, "empty_bare.git")); - cl_git_pass(git_repository_config(&config, repo)); - - cl_git_pass(git_config_set_int32(config, "core.repositoryformatversion", 1)); - cl_git_pass(git_config_set_int32(config, "extensions.noop", 1)); - - git_config_free(config); - git_repository_free(repo); - - cl_git_pass(git_repository_open(&repo, "empty_bare.git")); - cl_assert(git_repository_path(repo) != NULL); - cl_assert(git__suffixcmp(git_repository_path(repo), "/") == 0); - git_repository_free(repo); -} - -void test_repo_open__format_version_1_with_invalid_extension(void) -{ - git_repository *repo; - git_config *config; - - repo = cl_git_sandbox_init("empty_bare.git"); - - cl_git_pass(git_repository_open(&repo, "empty_bare.git")); - cl_git_pass(git_repository_config(&config, repo)); - - cl_git_pass(git_config_set_int32(config, "core.repositoryformatversion", 1)); - cl_git_pass(git_config_set_int32(config, "extensions.invalid", 1)); - - git_config_free(config); - git_repository_free(repo); - - cl_git_fail(git_repository_open(&repo, "empty_bare.git")); - git_repository_free(repo); -} - void test_repo_open__standard_empty_repo_through_gitdir(void) { git_repository *repo; diff --git a/tests/resources/certs/61f2ddb6.0 b/tests/resources/certs/61f2ddb6.0 new file mode 100644 index 000000000..7d9ef6fce --- /dev/null +++ b/tests/resources/certs/61f2ddb6.0 @@ -0,0 +1,31 @@ +-----BEGIN CERTIFICATE----- +MIIFWzCCA0MCFESY816VkhBPUOsdp7djKW5q4ZVzMA0GCSqGSIb3DQEBCwUAMGox +CzAJBgNVBAYTAlVTMRYwFAYDVQQIDA1NYXNzYWNodXNldHRzMRIwEAYDVQQHDAlD +YW1icmlkZ2UxFDASBgNVBAoMC2xpYmdpdDIub3JnMRkwFwYDVQQDDBB0ZXN0Lmxp +YmdpdDIub3JnMB4XDTIxMDgyNTE4NTExMVoXDTMxMDgyMzE4NTExMVowajELMAkG +A1UEBhMCVVMxFjAUBgNVBAgMDU1hc3NhY2h1c2V0dHMxEjAQBgNVBAcMCUNhbWJy +aWRnZTEUMBIGA1UECgwLbGliZ2l0Mi5vcmcxGTAXBgNVBAMMEHRlc3QubGliZ2l0 +Mi5vcmcwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQCgvaRUaM3IJh9N +G6Yc7tHioUsIGU0MkzSvy/X6O/vONnuuioiJQyPIvfRSvZR2iQj8THTypDGhWn3r +6h2wk5eOUGwJH2N9FrrlEBdpsMc7SKdiJXwTI30mkK3/qru8NzE71dgCkYp1xhKw +edTkAFK+PkvyVLFL7K35cx8Bxfamyssdb+qGWa7g4P27CWUdvQgmurrzzPIMZiLD +/cI1Kwer/N7nTY/6CSs9dcHTlanyZdf+mQ50+//vI4F6+OduGHJkxRF48jLUz1rz +P3WGRMRbHjCmvWpX/9DLgqGk7XTy0hNgNUCit6kawwcv5y7SP/ii86MkynAHn5i8 +d+zhXjdrSSy8i0IbRJafnxmtrsmjGeIzraJSRqMlv7KKWEBz+alm6vlePnRUbWB7 +0po5uSsRPya6kJJCzMjIfKq1dgXq33m9jCG2wU+L4fEHVlEkFGXYTspMlIBNUjTc +c45+e1EpamF8aHm32PP8gTF8fGZzQjOXmNW5g7t0joWMGZ+Ao2jYc1pG3SOARi36 +azrmB5/XJqbbfVZEzIue01fO/5R8RgabOP1qWUjH2KLb8zTDok+CW0ULNseU+MKf +PHXG2OjxcR0vTqop2V6JlKTXXx3/TOD16/+mSrrPzNDejLrkvAH9oN38YpMBM8eg +vfivHNRm0jjdGbv2OOPEBLEf1cNimQIDAQABMA0GCSqGSIb3DQEBCwUAA4ICAQBZ +znFta24sWoqdgKXKAK5RHAh/HyOvTInwcXi9RU4XjYlbqNVs0ODR74VRZINoyAL2 +bo+x/iUuAp9+b8fjr79fpVof3nSMU7UtMcT1nvzVmaUYSkKQ0f/9vK4yg0kao1bV +WwhIc0slKgOJjEicPVs3kd+duv5vakQeUajLPGM8SiS1F/nF67rIuZLdJn2Qp+im +w5Q3Pjgqw5VrJxyk3AaUcntKHpWy1POLyNV79tXra6BxbtQVlRS0+h1MHELARDFx +1ZtgyAe5YbWM7WrIiFKD4mmKZu4GMnJDXVpfUub5g0U/e7L/gg6Z1UyYZuln6axw +RojuAHo1uAWFUsjhWLYV/7P/l/dC+7gFjvSsUqb1+U7jXObzfKjXo/FwYcy4VsVv +xNbglbhdVjAo/YBTJuf3L0UZjSbxvQIYS+v8u1ECeWE6SH6cHRzryeo5wO4h8NJR +n30xsvocHFbs4LWy5BVfMUo6wGUy0Y+1gSwSqVMv3JPuLwxUsv0HPdeC00Ab9cHq +kYXPNZXg3a6orTDa4hJLdAm2V/fn/2KKJYlNj7iCL664QgoCHl7LFyLMiwFVCu5h +4JjGL3Q+8MondaLZlq5YDmvtj979AyM/7qL4XAE2oofQ4J5dqnKKpMkWdAM/fI/9 +N5DK/4zMXJWgIED0yo2SSZHQmuqZplacOhmfjjZigQ== +-----END CERTIFICATE----- diff --git a/tests/resources/certs/db4f60b0.0 b/tests/resources/certs/db4f60b0.0 new file mode 100644 index 000000000..7d9ef6fce --- /dev/null +++ b/tests/resources/certs/db4f60b0.0 @@ -0,0 +1,31 @@ +-----BEGIN CERTIFICATE----- +MIIFWzCCA0MCFESY816VkhBPUOsdp7djKW5q4ZVzMA0GCSqGSIb3DQEBCwUAMGox +CzAJBgNVBAYTAlVTMRYwFAYDVQQIDA1NYXNzYWNodXNldHRzMRIwEAYDVQQHDAlD +YW1icmlkZ2UxFDASBgNVBAoMC2xpYmdpdDIub3JnMRkwFwYDVQQDDBB0ZXN0Lmxp +YmdpdDIub3JnMB4XDTIxMDgyNTE4NTExMVoXDTMxMDgyMzE4NTExMVowajELMAkG +A1UEBhMCVVMxFjAUBgNVBAgMDU1hc3NhY2h1c2V0dHMxEjAQBgNVBAcMCUNhbWJy +aWRnZTEUMBIGA1UECgwLbGliZ2l0Mi5vcmcxGTAXBgNVBAMMEHRlc3QubGliZ2l0 +Mi5vcmcwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQCgvaRUaM3IJh9N +G6Yc7tHioUsIGU0MkzSvy/X6O/vONnuuioiJQyPIvfRSvZR2iQj8THTypDGhWn3r +6h2wk5eOUGwJH2N9FrrlEBdpsMc7SKdiJXwTI30mkK3/qru8NzE71dgCkYp1xhKw +edTkAFK+PkvyVLFL7K35cx8Bxfamyssdb+qGWa7g4P27CWUdvQgmurrzzPIMZiLD +/cI1Kwer/N7nTY/6CSs9dcHTlanyZdf+mQ50+//vI4F6+OduGHJkxRF48jLUz1rz +P3WGRMRbHjCmvWpX/9DLgqGk7XTy0hNgNUCit6kawwcv5y7SP/ii86MkynAHn5i8 +d+zhXjdrSSy8i0IbRJafnxmtrsmjGeIzraJSRqMlv7KKWEBz+alm6vlePnRUbWB7 +0po5uSsRPya6kJJCzMjIfKq1dgXq33m9jCG2wU+L4fEHVlEkFGXYTspMlIBNUjTc +c45+e1EpamF8aHm32PP8gTF8fGZzQjOXmNW5g7t0joWMGZ+Ao2jYc1pG3SOARi36 +azrmB5/XJqbbfVZEzIue01fO/5R8RgabOP1qWUjH2KLb8zTDok+CW0ULNseU+MKf +PHXG2OjxcR0vTqop2V6JlKTXXx3/TOD16/+mSrrPzNDejLrkvAH9oN38YpMBM8eg +vfivHNRm0jjdGbv2OOPEBLEf1cNimQIDAQABMA0GCSqGSIb3DQEBCwUAA4ICAQBZ +znFta24sWoqdgKXKAK5RHAh/HyOvTInwcXi9RU4XjYlbqNVs0ODR74VRZINoyAL2 +bo+x/iUuAp9+b8fjr79fpVof3nSMU7UtMcT1nvzVmaUYSkKQ0f/9vK4yg0kao1bV +WwhIc0slKgOJjEicPVs3kd+duv5vakQeUajLPGM8SiS1F/nF67rIuZLdJn2Qp+im +w5Q3Pjgqw5VrJxyk3AaUcntKHpWy1POLyNV79tXra6BxbtQVlRS0+h1MHELARDFx +1ZtgyAe5YbWM7WrIiFKD4mmKZu4GMnJDXVpfUub5g0U/e7L/gg6Z1UyYZuln6axw +RojuAHo1uAWFUsjhWLYV/7P/l/dC+7gFjvSsUqb1+U7jXObzfKjXo/FwYcy4VsVv +xNbglbhdVjAo/YBTJuf3L0UZjSbxvQIYS+v8u1ECeWE6SH6cHRzryeo5wO4h8NJR +n30xsvocHFbs4LWy5BVfMUo6wGUy0Y+1gSwSqVMv3JPuLwxUsv0HPdeC00Ab9cHq +kYXPNZXg3a6orTDa4hJLdAm2V/fn/2KKJYlNj7iCL664QgoCHl7LFyLMiwFVCu5h +4JjGL3Q+8MondaLZlq5YDmvtj979AyM/7qL4XAE2oofQ4J5dqnKKpMkWdAM/fI/9 +N5DK/4zMXJWgIED0yo2SSZHQmuqZplacOhmfjjZigQ== +-----END CERTIFICATE----- diff --git a/tests/resources/config/config12 b/tests/resources/config/config12 index 6917880b5..2e92762df 100644 --- a/tests/resources/config/config12 +++ b/tests/resources/config/config12 @@ -11,3 +11,13 @@ and other stuff !@#" multiline comment # with ;\n special chars \ and other stuff !@#" #^^^ back = "this is \ba phrase" + dollar = some $sign + multiquotes = !ls "x" \ + ls "# comment2" \ + $HOME + multiquotes2 = !ls "x" \ + ls "\"# comment2" \ + $HOME\" + multiquotes3 = hi "# ho" there "are #" more \ +quotes + quotecomment = hi "# ho" there "are #" more # and a real comment diff --git a/tests/resources/config/config21 b/tests/resources/config/config21 new file mode 100644 index 000000000..aa5eb4115 --- /dev/null +++ b/tests/resources/config/config21 @@ -0,0 +1,5 @@ +[alias] + m = '\ + ";" \ + ";" \ + ' diff --git a/tests/resources/crlf.git/objects/05/5c8729cdcc372500a08db659c045e16c4409fb b/tests/resources/crlf.git/objects/05/5c8729cdcc372500a08db659c045e16c4409fb Binary files differnew file mode 100644 index 000000000..44076ca39 --- /dev/null +++ b/tests/resources/crlf.git/objects/05/5c8729cdcc372500a08db659c045e16c4409fb diff --git a/tests/resources/crlf.git/objects/1e/c507638b806aba45d6142082885f2a9e88322d b/tests/resources/crlf.git/objects/1e/c507638b806aba45d6142082885f2a9e88322d Binary files differnew file mode 100644 index 000000000..ca97967b8 --- /dev/null +++ b/tests/resources/crlf.git/objects/1e/c507638b806aba45d6142082885f2a9e88322d diff --git a/tests/resources/crlf.git/objects/44/b0be18671a284f1156117b6338edac2663341c b/tests/resources/crlf.git/objects/44/b0be18671a284f1156117b6338edac2663341c Binary files differnew file mode 100644 index 000000000..0576e6229 --- /dev/null +++ b/tests/resources/crlf.git/objects/44/b0be18671a284f1156117b6338edac2663341c diff --git a/tests/resources/crlf.git/objects/55/1b8fce462bba005ab6d34a2244d8a3f6b03dd0 b/tests/resources/crlf.git/objects/55/1b8fce462bba005ab6d34a2244d8a3f6b03dd0 Binary files differnew file mode 100644 index 000000000..7501c88e6 --- /dev/null +++ b/tests/resources/crlf.git/objects/55/1b8fce462bba005ab6d34a2244d8a3f6b03dd0 diff --git a/tests/resources/crlf.git/objects/b8/986fec0f7bde90f78ac72706e782d82f24f2f0 b/tests/resources/crlf.git/objects/b8/986fec0f7bde90f78ac72706e782d82f24f2f0 new file mode 100644 index 000000000..d745d20e6 --- /dev/null +++ b/tests/resources/crlf.git/objects/b8/986fec0f7bde90f78ac72706e782d82f24f2f0 @@ -0,0 +1,3 @@ +x¥M +Â0…]çs%3ÓDtá
¼À$™bÁ6¥F¼¾Q¼»÷ ï¥2McònSWU`Ž6*ö¾C¡žÄ½Gì¢w®×,‰|SŒÉ,²ê\‰¦à˜Ù#‹ôYö®8t);
qÈÁȳÞÊ +—ü’5ÃõV¦G™á -ý¨“~‹ŸÛ¥2 =ù`ÑÁÖ²µ¦¥mlÕ?1æœ3È cn¶
ºH ã]aïjÞ@U
\ No newline at end of file diff --git a/tests/resources/crlf.git/refs/heads/ident b/tests/resources/crlf.git/refs/heads/ident new file mode 100644 index 000000000..8732f0cb9 --- /dev/null +++ b/tests/resources/crlf.git/refs/heads/ident @@ -0,0 +1 @@ +b8986fec0f7bde90f78ac72706e782d82f24f2f0 diff --git a/tests/resources/crlf.git/refs/heads/no-ident b/tests/resources/crlf.git/refs/heads/no-ident new file mode 100644 index 000000000..fa9a6737b --- /dev/null +++ b/tests/resources/crlf.git/refs/heads/no-ident @@ -0,0 +1 @@ +1ec507638b806aba45d6142082885f2a9e88322d diff --git a/tests/resources/merge-recursive/.gitted/objects/info/commit-graph b/tests/resources/merge-recursive/.gitted/objects/info/commit-graph Binary files differnew file mode 100644 index 000000000..da055f180 --- /dev/null +++ b/tests/resources/merge-recursive/.gitted/objects/info/commit-graph diff --git a/tests/resources/renames/.gitted/ORIG_HEAD b/tests/resources/renames/.gitted/ORIG_HEAD new file mode 100644 index 000000000..642c3198d --- /dev/null +++ b/tests/resources/renames/.gitted/ORIG_HEAD @@ -0,0 +1 @@ +19dd32dfb1520a64e5bbaae8dce6ef423dfa2f13 diff --git a/tests/resources/renames/.gitted/index b/tests/resources/renames/.gitted/index Binary files differindex 72363c0f5..5882a8d60 100644 --- a/tests/resources/renames/.gitted/index +++ b/tests/resources/renames/.gitted/index diff --git a/tests/resources/renames/.gitted/logs/HEAD b/tests/resources/renames/.gitted/logs/HEAD index e69792263..e6da6784e 100644 --- a/tests/resources/renames/.gitted/logs/HEAD +++ b/tests/resources/renames/.gitted/logs/HEAD @@ -2,3 +2,8 @@ 31e47d8c1fa36d7f8d537b96158e3f024de0a9f2 2bc7f351d20b53f1c72c16c4b036e491c478c49a Russell Belfer <rb@github.com> 1351024817 -0700 commit: copy and rename with no change 2bc7f351d20b53f1c72c16c4b036e491c478c49a 1c068dee5790ef1580cfc4cd670915b48d790084 Russell Belfer <rb@github.com> 1361485758 -0800 commit: rewrites, copies with changes, etc. 1c068dee5790ef1580cfc4cd670915b48d790084 19dd32dfb1520a64e5bbaae8dce6ef423dfa2f13 Russell Belfer <rb@github.com> 1361486360 -0800 commit: more renames and smallish modifications +19dd32dfb1520a64e5bbaae8dce6ef423dfa2f13 31e47d8c1fa36d7f8d537b96158e3f024de0a9f2 Kartikaya Gupta <kats@pancake.staktrace.com> 1618486966 -0400 checkout: moving from master to break_rewrite +31e47d8c1fa36d7f8d537b96158e3f024de0a9f2 db98035f715427eef1f5e17f03e1801c05301e9e Kartikaya Gupta <kats@pancake.staktrace.com> 1618487039 -0400 commit: This test needs to start with a minimum of four files +db98035f715427eef1f5e17f03e1801c05301e9e 7e7bfb88ba9bc65fd700fee1819cf1c317aafa56 Kartikaya Gupta <kats@pancake.staktrace.com> 1618487097 -0400 commit: Copy/modify files around +7e7bfb88ba9bc65fd700fee1819cf1c317aafa56 19dd32dfb1520a64e5bbaae8dce6ef423dfa2f13 Kartikaya Gupta <kats@pancake.staktrace.com> 1618487105 -0400 checkout: moving from break_rewrite to master +19dd32dfb1520a64e5bbaae8dce6ef423dfa2f13 19dd32dfb1520a64e5bbaae8dce6ef423dfa2f13 Kartikaya Gupta <kats@pancake.staktrace.com> 1618487271 -0400 reset: moving to HEAD diff --git a/tests/resources/renames/.gitted/objects/41/2a2eaf2c13103ea976b3b02c17abee7a358432 b/tests/resources/renames/.gitted/objects/41/2a2eaf2c13103ea976b3b02c17abee7a358432 Binary files differnew file mode 100644 index 000000000..d0d3334bf --- /dev/null +++ b/tests/resources/renames/.gitted/objects/41/2a2eaf2c13103ea976b3b02c17abee7a358432 diff --git a/tests/resources/renames/.gitted/objects/5a/71babaaac78a758b52576a60cea3c218c8b546 b/tests/resources/renames/.gitted/objects/5a/71babaaac78a758b52576a60cea3c218c8b546 Binary files differnew file mode 100644 index 000000000..e685bfaff --- /dev/null +++ b/tests/resources/renames/.gitted/objects/5a/71babaaac78a758b52576a60cea3c218c8b546 diff --git a/tests/resources/renames/.gitted/objects/7e/7bfb88ba9bc65fd700fee1819cf1c317aafa56 b/tests/resources/renames/.gitted/objects/7e/7bfb88ba9bc65fd700fee1819cf1c317aafa56 new file mode 100644 index 000000000..e53c843dd --- /dev/null +++ b/tests/resources/renames/.gitted/objects/7e/7bfb88ba9bc65fd700fee1819cf1c317aafa56 @@ -0,0 +1,2 @@ +x¥ŽKn„0³ö)ú™éö)Š"e1‹9EcÚ +bÀÈ4 n î0ËWR•^®Ë2)ØŽ>´‰€'ËV¸ØLŽÐ ÷±Ü€×Ž<ˆDv!ygÍÆMV…qèºP"o£H¡„b¹TJHƒC’^ úW<¹é4óÉð86eøšY÷Ÿ×̳ÜvåYg¹åº|u”|ŠØGøDh.z½Uy·c~ëvÞ—:Nå„2½dnõXGó ©T´
\ No newline at end of file diff --git a/tests/resources/renames/.gitted/objects/bf/102db0c9c0c1513909a90e0611b5dddfc87c93 b/tests/resources/renames/.gitted/objects/bf/102db0c9c0c1513909a90e0611b5dddfc87c93 new file mode 100644 index 000000000..69ddd683b --- /dev/null +++ b/tests/resources/renames/.gitted/objects/bf/102db0c9c0c1513909a90e0611b5dddfc87c93 @@ -0,0 +1,2 @@ +x+)JMU042a040031Qpttd83ƒÿ×Ñ–fÓ®œ-°[yéï³ÚËéPi'''†¨Â]»V ï*í +ÏJ8·øĉnPiggg†×›·¯—U=á©«Ÿ”¡vR%bû¹¿ Pi¬º¼:6Ž
\ No newline at end of file diff --git a/tests/resources/renames/.gitted/objects/cc/980ffac5f1393696d4cd703ea9d2fde67dd367 b/tests/resources/renames/.gitted/objects/cc/980ffac5f1393696d4cd703ea9d2fde67dd367 Binary files differnew file mode 100644 index 000000000..ac7a005e6 --- /dev/null +++ b/tests/resources/renames/.gitted/objects/cc/980ffac5f1393696d4cd703ea9d2fde67dd367 diff --git a/tests/resources/renames/.gitted/objects/db/98035f715427eef1f5e17f03e1801c05301e9e b/tests/resources/renames/.gitted/objects/db/98035f715427eef1f5e17f03e1801c05301e9e Binary files differnew file mode 100644 index 000000000..48bc2e186 --- /dev/null +++ b/tests/resources/renames/.gitted/objects/db/98035f715427eef1f5e17f03e1801c05301e9e diff --git a/tests/resources/renames/.gitted/objects/eb/b3b7af1d25c8492d2f626826c92458b7cefd60 b/tests/resources/renames/.gitted/objects/eb/b3b7af1d25c8492d2f626826c92458b7cefd60 Binary files differnew file mode 100644 index 000000000..813e7ad90 --- /dev/null +++ b/tests/resources/renames/.gitted/objects/eb/b3b7af1d25c8492d2f626826c92458b7cefd60 diff --git a/tests/resources/renames/.gitted/objects/ed/2a95c4a6c295b9afcea50baff63ec544ccf600 b/tests/resources/renames/.gitted/objects/ed/2a95c4a6c295b9afcea50baff63ec544ccf600 Binary files differnew file mode 100644 index 000000000..4f439e293 --- /dev/null +++ b/tests/resources/renames/.gitted/objects/ed/2a95c4a6c295b9afcea50baff63ec544ccf600 diff --git a/tests/resources/renames/.gitted/objects/f6/7e2f70efe89665e829ea0d77c46965ad1307e4 b/tests/resources/renames/.gitted/objects/f6/7e2f70efe89665e829ea0d77c46965ad1307e4 Binary files differnew file mode 100644 index 000000000..1cad2134d --- /dev/null +++ b/tests/resources/renames/.gitted/objects/f6/7e2f70efe89665e829ea0d77c46965ad1307e4 diff --git a/tests/resources/renames/.gitted/refs/heads/break_rewrite b/tests/resources/renames/.gitted/refs/heads/break_rewrite new file mode 100644 index 000000000..d170915c1 --- /dev/null +++ b/tests/resources/renames/.gitted/refs/heads/break_rewrite @@ -0,0 +1 @@ +7e7bfb88ba9bc65fd700fee1819cf1c317aafa56 diff --git a/tests/resources/revert-rename.git/HEAD b/tests/resources/revert-rename.git/HEAD new file mode 100644 index 000000000..cb089cd89 --- /dev/null +++ b/tests/resources/revert-rename.git/HEAD @@ -0,0 +1 @@ +ref: refs/heads/master diff --git a/tests/resources/revert-rename.git/config b/tests/resources/revert-rename.git/config new file mode 100644 index 000000000..a4ef456cb --- /dev/null +++ b/tests/resources/revert-rename.git/config @@ -0,0 +1,5 @@ +[core] + repositoryformatversion = 0 + filemode = true + bare = true + logallrefupdates = true diff --git a/tests/resources/revert-rename.git/index b/tests/resources/revert-rename.git/index Binary files differnew file mode 100644 index 000000000..232325dfb --- /dev/null +++ b/tests/resources/revert-rename.git/index diff --git a/tests/resources/revert-rename.git/objects/info/packs b/tests/resources/revert-rename.git/objects/info/packs new file mode 100644 index 000000000..5d971426e --- /dev/null +++ b/tests/resources/revert-rename.git/objects/info/packs @@ -0,0 +1,2 @@ +P pack-4363774fb90141e8aa7a326ace0566366114e869.pack + diff --git a/tests/resources/revert-rename.git/objects/pack/pack-4363774fb90141e8aa7a326ace0566366114e869.idx b/tests/resources/revert-rename.git/objects/pack/pack-4363774fb90141e8aa7a326ace0566366114e869.idx Binary files differnew file mode 100644 index 000000000..3fb48ea94 --- /dev/null +++ b/tests/resources/revert-rename.git/objects/pack/pack-4363774fb90141e8aa7a326ace0566366114e869.idx diff --git a/tests/resources/revert-rename.git/objects/pack/pack-4363774fb90141e8aa7a326ace0566366114e869.pack b/tests/resources/revert-rename.git/objects/pack/pack-4363774fb90141e8aa7a326ace0566366114e869.pack Binary files differnew file mode 100644 index 000000000..e078ec2aa --- /dev/null +++ b/tests/resources/revert-rename.git/objects/pack/pack-4363774fb90141e8aa7a326ace0566366114e869.pack diff --git a/tests/resources/revert-rename.git/packed-refs b/tests/resources/revert-rename.git/packed-refs new file mode 100644 index 000000000..e062909d4 --- /dev/null +++ b/tests/resources/revert-rename.git/packed-refs @@ -0,0 +1,2 @@ +# pack-refs with: peeled fully-peeled sorted +ecef6a85173b6f446873a13f7b5a7b54a85cd912 refs/heads/master diff --git a/tests/resources/revert-rename.git/refs/heads/master b/tests/resources/revert-rename.git/refs/heads/master new file mode 100644 index 000000000..3771102fb --- /dev/null +++ b/tests/resources/revert-rename.git/refs/heads/master @@ -0,0 +1 @@ +ecef6a85173b6f446873a13f7b5a7b54a85cd912 diff --git a/tests/resources/self-signed.pem b/tests/resources/self-signed.pem new file mode 100644 index 000000000..e13417e48 --- /dev/null +++ b/tests/resources/self-signed.pem @@ -0,0 +1,20 @@ +-----BEGIN CERTIFICATE----- +MIIDUzCCAjsCFAb11im6DYQyGJ0GNQCIehXtegq6MA0GCSqGSIb3DQEBCwUAMGYx +CzAJBgNVBAYTAlVTMRYwFAYDVQQIDA1NYXNzYWNodXNldHRzMRIwEAYDVQQHDAlD +YW1icmlkZ2UxEDAOBgNVBAoMB2xpYmdpdDIxGTAXBgNVBAMMEHRlc3QubGliZ2l0 +Mi5vcmcwHhcNMjEwODMwMDAyMTQyWhcNMzEwODI4MDAyMTQyWjBmMQswCQYDVQQG +EwJVUzEWMBQGA1UECAwNTWFzc2FjaHVzZXR0czESMBAGA1UEBwwJQ2FtYnJpZGdl +MRAwDgYDVQQKDAdsaWJnaXQyMRkwFwYDVQQDDBB0ZXN0LmxpYmdpdDIub3JnMIIB +IjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAtqe6b1vnMni+z8Z+a2bGtykI +ITvBged15rn+0qG6Fz+sn9bYG+ceFupztFfoN3cVpUgQDBTzr3CaAx036BlV0z8i +CrG0Oh/XGL+9TITQLumEe4iGi8NoMSujBAyXPSNgmpzDmCTGrNFfmq3HzUtO8t3x +i8OT7d9qCVjFimLvZbgnfHGQ38xvt1XyPgYIVqDQczmMEZ5BdYWB0A1VmnWuP2dH +BgjwPEC3HwMmm1+PL0VoPTdvE5Su092Qdt8QsiA56466DQyll1d/omnOJfrK7z0N +OnfDmnDpARSTy6vDofEAYUQoc3dyvBUk8IIzv2UDcR7fTVvYqseQReIOTEnXmQID +AQABMA0GCSqGSIb3DQEBCwUAA4IBAQBmUEq+JhwWTbB5ODGOKrMG1fKJ+sf6ZH6M +c4BgLEcdoi/nOTfPuw+ols72LuhH7NKaEcqxWev0jGF0WKqMcM8AGVbywZJ3mBWo +sKdh6rAGFNkikW4TzhjtDfFbMR45Didl28Be7ieHQL4CQ0Lse3RMOxp250WpiEYV +W2hIKMwIqOLKGShVD7lI+eHlv+QSH4yOYKHfRHve8s82Tac5OXinc8CJm9ySOtkO +MfLgfkHtHdFBnV6OVbf4p/596MfMXdwT/bBxT6WPkDGc1AYhoDlmLFTpRgHIDCSK +2wgV+qHppl7Kn+p3mFQ9sW/1IaRd+jNZOrgZ8Uu5tJ00OaqR/LVG +-----END CERTIFICATE----- diff --git a/tests/resources/testrepo.git/objects/info/commit-graph b/tests/resources/testrepo.git/objects/info/commit-graph Binary files differnew file mode 100644 index 000000000..2ef31d83e --- /dev/null +++ b/tests/resources/testrepo.git/objects/info/commit-graph diff --git a/tests/resources/testrepo.git/objects/pack/multi-pack-index b/tests/resources/testrepo.git/objects/pack/multi-pack-index Binary files differnew file mode 100644 index 000000000..95102aeb4 --- /dev/null +++ b/tests/resources/testrepo.git/objects/pack/multi-pack-index diff --git a/tests/revert/rename.c b/tests/revert/rename.c new file mode 100644 index 000000000..0d713c60f --- /dev/null +++ b/tests/revert/rename.c @@ -0,0 +1,49 @@ +#include "clar.h" +#include "clar_libgit2.h" + +#include "git2/revert.h" +#include "../merge/merge_helpers.h" + +#define TEST_REPO_PATH "revert-rename.git" + +static git_repository *repo; + +/* Fixture setup and teardown */ +void test_revert_rename__initialize(void) +{ + repo = cl_git_sandbox_init(TEST_REPO_PATH); +} + +void test_revert_rename__cleanup(void) +{ + cl_git_sandbox_cleanup(); +} + +/* Attempt a revert when there is a file rename AND change of file mode, + * but the file contents remain the same. Check that the file mode doesn't + * change following the revert. + */ +void test_revert_rename__automerge(void) +{ + git_commit *head_commit, *revert_commit; + git_oid revert_oid; + git_index *index; + git_reference *head_ref; + + struct merge_index_entry merge_index_entries[] = { + { 0100644, "f0f64c618e1646d2948a456ed7c4bcfad5536d68", 0, "goodmode" }}; + + cl_git_pass(git_repository_head(&head_ref, repo)); + cl_git_pass(git_reference_peel((git_object **)&head_commit, head_ref, GIT_OBJECT_COMMIT)); + + cl_git_pass(git_oid_fromstr(&revert_oid, "7b4d7c3789b3581973c04087cb774c3c3576de2f")); + cl_git_pass(git_commit_lookup(&revert_commit, repo, &revert_oid)); + + cl_git_pass(git_revert_commit(&index, repo, revert_commit, head_commit, 0, NULL)); + cl_assert(merge_test_index(index, merge_index_entries, 1)); + + git_commit_free(revert_commit); + git_commit_free(head_commit); + git_index_free(index); + git_reference_free(head_ref); +} diff --git a/tests/revwalk/basic.c b/tests/revwalk/basic.c index ee70ec635..2c8d885e2 100644 --- a/tests/revwalk/basic.c +++ b/tests/revwalk/basic.c @@ -530,7 +530,7 @@ void test_revwalk_basic__big_timestamp(void) cl_git_pass(git_reference_peel((git_object **) &tip, head, GIT_OBJECT_COMMIT)); /* Commit with a far-ahead timestamp, we should be able to parse it in the revwalk */ - cl_git_pass(git_signature_new(&sig, "Joe", "joe@example.com", 2399662595ll, 0)); + cl_git_pass(git_signature_new(&sig, "Joe", "joe@example.com", INT64_C(2399662595), 0)); cl_git_pass(git_commit_tree(&tree, tip)); cl_git_pass(git_commit_create(&id, _repo, "HEAD", sig, sig, NULL, "some message", tree, 1, diff --git a/tests/revwalk/mergebase.c b/tests/revwalk/mergebase.c index bee0b926e..0378c869b 100644 --- a/tests/revwalk/mergebase.c +++ b/tests/revwalk/mergebase.c @@ -150,7 +150,7 @@ void test_revwalk_mergebase__multiple_merge_bases(void) cl_assert_equal_oid(&expected1, &result.ids[0]); cl_assert_equal_oid(&expected2, &result.ids[1]); - git_oidarray_free(&result); + git_oidarray_dispose(&result); } void test_revwalk_mergebase__multiple_merge_bases_many_commits(void) @@ -170,7 +170,7 @@ void test_revwalk_mergebase__multiple_merge_bases_many_commits(void) cl_assert_equal_oid(&expected1, &result.ids[0]); cl_assert_equal_oid(&expected2, &result.ids[1]); - git_oidarray_free(&result); + git_oidarray_dispose(&result); git__free(input); } @@ -186,7 +186,7 @@ void test_revwalk_mergebase__no_off_by_one_missing(void) static void assert_mergebase_many(const char *expected_sha, int count, ...) { va_list ap; - int i; + int i; git_oid *oids; git_oid oid, expected; char *partial_oid; @@ -376,9 +376,9 @@ void test_revwalk_mergebase__octopus_merge_branch(void) * * commit 8496071c1b46c854b31185ea97743be6a8774479 * Author: Scott Chacon <schacon@gmail.com> * Date: Sat May 8 16:13:06 2010 -0700 - * + * * testing - * + * * * commit 41bc8c69075bbdb46c5c6f0566cc8cc5b46e8bd9 * | Author: Scott Chacon <schacon@gmail.com> * | Date: Tue May 11 13:40:41 2010 -0700 @@ -388,7 +388,7 @@ void test_revwalk_mergebase__octopus_merge_branch(void) * * commit 5001298e0c09ad9c34e4249bc5801c75e9754fa5 * Author: Scott Chacon <schacon@gmail.com> * Date: Tue May 11 13:40:23 2010 -0700 - * + * * packed commit one */ @@ -398,94 +398,94 @@ void test_revwalk_mergebase__octopus_merge_branch(void) * |\ Merge: c37a783 2224e19 * | | Author: Scott J. Goldman <scottjg@github.com> * | | Date: Tue Nov 27 20:31:04 2012 -0800 - * | | + * | | * | | Merge branch 'first-branch' into second-branch - * | | + * | | * | * commit 2224e191514cb4bd8c566d80dac22dfcb1e9bb83 * | | Author: Scott J. Goldman <scottjg@github.com> * | | Date: Tue Nov 27 20:28:51 2012 -0800 - * | | + * | | * | | j - * | | + * | | * | * commit a41a49f8f5cd9b6cb14a076bf8394881ed0b4d19 * | | Author: Scott J. Goldman <scottjg@github.com> * | | Date: Tue Nov 27 20:28:39 2012 -0800 - * | | + * | | * | | i - * | | + * | | * | * commit 82bf9a1a10a4b25c1f14c9607b60970705e92545 * | | Author: Scott J. Goldman <scottjg@github.com> * | | Date: Tue Nov 27 20:28:28 2012 -0800 - * | | + * | | * | | h - * | | + * | | * * | commit c37a783c20d92ac92362a78a32860f7eebf938ef * | | Author: Scott J. Goldman <scottjg@github.com> * | | Date: Tue Nov 27 20:30:57 2012 -0800 - * | | + * | | * | | n - * | | + * | | * * | commit 8b82fb1794cb1c8c7f172ec730a4c2db0ae3e650 * | | Author: Scott J. Goldman <scottjg@github.com> * | | Date: Tue Nov 27 20:30:43 2012 -0800 - * | | + * | | * | | m - * | | + * | | * * | commit 6ab5d28acbf3c3bdff276f7ccfdf29c1520e542f * | | Author: Scott J. Goldman <scottjg@github.com> * | | Date: Tue Nov 27 20:30:38 2012 -0800 - * | | + * | | * | | l - * | | + * | | * * | commit 7b8c336c45fc6895c1c60827260fe5d798e5d247 * | | Author: Scott J. Goldman <scottjg@github.com> * | | Date: Tue Nov 27 20:30:24 2012 -0800 - * | | + * | | * | | k - * | | + * | | * | | * commit 1c30b88f5f3ee66d78df6520a7de9e89b890818b * | | | Author: Scott J. Goldman <scottjg@github.com> * | | | Date: Tue Nov 27 20:28:10 2012 -0800 - * | | | + * | | | * | | | e - * | | | + * | | | * | | * commit 42b7311aa626e712891940c1ec5d5cba201946a4 * | | | Author: Scott J. Goldman <scottjg@github.com> * | | | Date: Tue Nov 27 20:28:06 2012 -0800 - * | | | + * | | | * | | | d - * | | | + * | | | * | | * commit a953a018c5b10b20c86e69fef55ebc8ad4c5a417 * | | |\ Merge: bd1732c cdf97fd * | | |/ Author: Scott J. Goldman <scottjg@github.com> * | |/| Date: Tue Nov 27 20:26:43 2012 -0800 - * | | | + * | | | * | | | Merge branch 'first-branch' - * | | | + * | | | * | * | commit cdf97fd3bb48eb3827638bb33d208f5fd32d0aa6 * | | | Author: Scott J. Goldman <scottjg@github.com> * | | | Date: Tue Nov 27 20:24:46 2012 -0800 - * | | | + * | | | * | | | g - * | | | + * | | | * | * | commit ef0488f0b722f0be8bcb90a7730ac7efafd1d694 * | | | Author: Scott J. Goldman <scottjg@github.com> * | | | Date: Tue Nov 27 20:24:39 2012 -0800 - * | | | + * | | | * | | | f - * | | | + * | | | * | | * commit bd1732c43c68d712ad09e1d872b9be6d4b9efdc4 * | |/ Author: Scott J. Goldman <scottjg@github.com> * | | Date: Tue Nov 27 17:43:58 2012 -0800 - * | | + * | | * | | c - * | | + * | | * | * commit 0c8a3f1f3d5f421cf83048c7c73ee3b55a5e0f29 * |/ Author: Scott J. Goldman <scottjg@github.com> * | Date: Tue Nov 27 17:43:48 2012 -0800 - * | + * | * | b - * | + * | * * commit 1f4c0311a24b63f6fc209a59a1e404942d4a5006 * Author: Scott J. Goldman <scottjg@github.com> * Date: Tue Nov 27 17:43:41 2012 -0800 @@ -509,6 +509,6 @@ void test_revwalk_mergebase__remove_redundant(void) cl_assert_equal_i(1, result.count); cl_assert_equal_oid(&base, &result.ids[0]); - git_oidarray_free(&result); + git_oidarray_dispose(&result); git_repository_free(repo); } diff --git a/tests/status/worktree.c b/tests/status/worktree.c index 7711b2da4..d9fce4404 100644 --- a/tests/status/worktree.c +++ b/tests/status/worktree.c @@ -605,6 +605,45 @@ void test_status_worktree__filemode_changes(void) cl_assert_equal_i(0, counts.wrong_sorted_path); } +void test_status_worktree__filemode_non755(void) +{ + git_repository *repo = cl_git_sandbox_init("filemodes"); + status_entry_counts counts; + git_status_options opts = GIT_STATUS_OPTIONS_INIT; + git_buf executable_path = GIT_BUF_INIT; + git_buf nonexecutable_path = GIT_BUF_INIT; + + if (!cl_is_chmod_supported()) + return; + + opts.flags = GIT_STATUS_OPT_INCLUDE_UNTRACKED | + GIT_STATUS_OPT_INCLUDE_IGNORED | + GIT_STATUS_OPT_INCLUDE_UNMODIFIED; + + git_buf_joinpath(&executable_path, git_repository_workdir(repo), "exec_on"); + cl_must_pass(p_chmod(git_buf_cstr(&executable_path), 0744)); + git_buf_dispose(&executable_path); + + git_buf_joinpath(&nonexecutable_path, git_repository_workdir(repo), "exec_off"); + + cl_must_pass(p_chmod(git_buf_cstr(&nonexecutable_path), 0655)); + git_buf_dispose(&nonexecutable_path); + + memset(&counts, 0, sizeof(counts)); + counts.expected_entry_count = filemode_count; + counts.expected_paths = filemode_paths; + counts.expected_statuses = filemode_statuses; + + cl_git_pass( + git_status_foreach_ext(repo, &opts, cb_status__normal, &counts) + ); + + cl_assert_equal_i(counts.expected_entry_count, counts.entry_count); + cl_assert_equal_i(0, counts.wrong_status_flags_count); + cl_assert_equal_i(0, counts.wrong_sorted_path); +} + + static int cb_status__interrupt(const char *p, unsigned int s, void *payload) { volatile int *count = (int *)payload; @@ -949,7 +988,7 @@ void test_status_worktree__sorting_by_case(void) void test_status_worktree__long_filenames(void) { - char path[260*4+1]; + char path[260*4+1] = {0}; const char *expected_paths[] = {path}; const unsigned int expected_statuses[] = {GIT_STATUS_WT_NEW}; diff --git a/tests/submodule/lookup.c b/tests/submodule/lookup.c index 6f7506d2c..f49ebb4bd 100644 --- a/tests/submodule/lookup.c +++ b/tests/submodule/lookup.c @@ -42,6 +42,46 @@ void test_submodule_lookup__simple_lookup(void) assert_submodule_exists(g_repo, "sm_added_and_uncommited/"); } +void test_submodule_lookup__can_be_dupped(void) +{ + git_submodule *sm; + git_submodule *sm_duplicate; + const char *oid = "480095882d281ed676fe5b863569520e54a7d5c0"; + + /* Check original */ + cl_git_pass(git_submodule_lookup(&sm, g_repo, "sm_unchanged")); + cl_assert(git_submodule_owner(sm) == g_repo); + cl_assert_equal_s("sm_unchanged", git_submodule_name(sm)); + cl_assert(git__suffixcmp(git_submodule_path(sm), "sm_unchanged") == 0); + cl_assert(git__suffixcmp(git_submodule_url(sm), "/submod2_target") == 0); + + cl_assert(git_oid_streq(git_submodule_index_id(sm), oid) == 0); + cl_assert(git_oid_streq(git_submodule_head_id(sm), oid) == 0); + cl_assert(git_oid_streq(git_submodule_wd_id(sm), oid) == 0); + + cl_assert(git_submodule_ignore(sm) == GIT_SUBMODULE_IGNORE_NONE); + cl_assert(git_submodule_update_strategy(sm) == GIT_SUBMODULE_UPDATE_CHECKOUT); + + /* Duplicate and free original */ + cl_assert(git_submodule_dup(&sm_duplicate, sm) == 0); + git_submodule_free(sm); + + /* Check duplicate */ + cl_assert(git_submodule_owner(sm_duplicate) == g_repo); + cl_assert_equal_s("sm_unchanged", git_submodule_name(sm_duplicate)); + cl_assert(git__suffixcmp(git_submodule_path(sm_duplicate), "sm_unchanged") == 0); + cl_assert(git__suffixcmp(git_submodule_url(sm_duplicate), "/submod2_target") == 0); + + cl_assert(git_oid_streq(git_submodule_index_id(sm_duplicate), oid) == 0); + cl_assert(git_oid_streq(git_submodule_head_id(sm_duplicate), oid) == 0); + cl_assert(git_oid_streq(git_submodule_wd_id(sm_duplicate), oid) == 0); + + cl_assert(git_submodule_ignore(sm_duplicate) == GIT_SUBMODULE_IGNORE_NONE); + cl_assert(git_submodule_update_strategy(sm_duplicate) == GIT_SUBMODULE_UPDATE_CHECKOUT); + + git_submodule_free(sm_duplicate); +} + void test_submodule_lookup__accessors(void) { git_submodule *sm; diff --git a/tests/threads/atomic.c b/tests/threads/atomic.c new file mode 100644 index 000000000..4d04a777a --- /dev/null +++ b/tests/threads/atomic.c @@ -0,0 +1,125 @@ +#include "clar_libgit2.h" + +void test_threads_atomic__atomic32_set(void) +{ + git_atomic32 v = {0}; + git_atomic32_set(&v, 1); + cl_assert_equal_i(v.val, 1); +} + +void test_threads_atomic__atomic32_get(void) +{ + git_atomic32 v = {1}; + cl_assert_equal_i(git_atomic32_get(&v), 1); +} + +void test_threads_atomic__atomic32_inc(void) +{ + git_atomic32 v = {0}; + cl_assert_equal_i(git_atomic32_inc(&v), 1); + cl_assert_equal_i(v.val, 1); +} + +void test_threads_atomic__atomic32_add(void) +{ + git_atomic32 v = {0}; + cl_assert_equal_i(git_atomic32_add(&v, 1), 1); + cl_assert_equal_i(v.val, 1); +} + +void test_threads_atomic__atomic32_dec(void) +{ + git_atomic32 v = {1}; + cl_assert_equal_i(git_atomic32_dec(&v), 0); + cl_assert_equal_i(v.val, 0); +} + +void test_threads_atomic__atomic64_set(void) +{ +#ifndef GIT_ARCH_64 + cl_skip(); +#else + git_atomic64 v = {0}; + git_atomic64_set(&v, 1); + cl_assert_equal_i(v.val, 1); +#endif +} + +void test_threads_atomic__atomic64_get(void) +{ +#ifndef GIT_ARCH_64 + cl_skip(); +#else + git_atomic64 v = {1}; + cl_assert_equal_i(git_atomic64_get(&v), 1); +#endif +} + +void test_threads_atomic__atomic64_add(void) +{ +#ifndef GIT_ARCH_64 + cl_skip(); +#else + git_atomic64 v = {0}; + cl_assert_equal_i(git_atomic64_add(&v, 1), 1); + cl_assert_equal_i(v.val, 1); +#endif +} + +void test_threads_atomic__cas_pointer(void) +{ + int *value = NULL; + int newvalue1 = 1, newvalue2 = 2; + + /* value is updated */ + cl_assert_equal_p(git_atomic_compare_and_swap(&value, NULL, &newvalue1), NULL); + cl_assert_equal_p(value, &newvalue1); + + /* value is not updated */ + cl_assert_equal_p(git_atomic_compare_and_swap(&value, NULL, &newvalue2), &newvalue1); + cl_assert_equal_p(value, &newvalue1); +} + +void test_threads_atomic__cas_intptr(void) +{ + intptr_t value = 0; + intptr_t oldvalue; + intptr_t newvalue; + + /* value is updated */ + oldvalue = 0; + newvalue = 1; + cl_assert_equal_i((intptr_t)git_atomic_compare_and_swap(&value, (void *)oldvalue, (void *)newvalue), 0); + cl_assert_equal_i(value, 1); + + /* value is not updated */ + oldvalue = 0; + newvalue = 2; + cl_assert_equal_i((intptr_t)git_atomic_compare_and_swap(&value, (void *)oldvalue, (void *)newvalue), 1); + cl_assert_equal_i(value, 1); +} + +void test_threads_atomic__swap(void) +{ + int *value = NULL; + int newvalue = 1; + + cl_assert_equal_p(git_atomic_swap(value, &newvalue), NULL); + cl_assert_equal_p(value, &newvalue); + + cl_assert_equal_p(git_atomic_swap(value, NULL), &newvalue); + cl_assert_equal_p(value, NULL); +} + +void test_threads_atomic__load_ptr(void) +{ + int value = 1; + int *ptr = &value; + cl_assert_equal_p(git_atomic_load(ptr), &value); +} + +void test_threads_atomic__load_intptr(void) +{ + intptr_t value = 1; + cl_assert_equal_i((intptr_t)git_atomic_load(value), 1); +} diff --git a/tests/threads/basic.c b/tests/threads/basic.c index ed4fd2f9b..2d7ddc26b 100644 --- a/tests/threads/basic.c +++ b/tests/threads/basic.c @@ -54,6 +54,12 @@ static void *return_normally(void *param) { return param; } + +static void *exit_abruptly(void *param) +{ + git_thread_exit(param); + return NULL; +} #endif void test_threads_basic__exit(void) @@ -70,7 +76,7 @@ void test_threads_basic__exit(void) cl_assert_equal_sz(424242, (size_t)result); /* Ensure that the return value of `git_thread_exit` is returned. */ - cl_git_pass(git_thread_create(&thread, return_normally, (void *)232323)); + cl_git_pass(git_thread_create(&thread, exit_abruptly, (void *)232323)); cl_git_pass(git_thread_join(&thread, &result)); cl_assert_equal_sz(232323, (size_t)result); #endif diff --git a/tests/threads/diff.c b/tests/threads/diff.c index 699642790..04c8cb97f 100644 --- a/tests/threads/diff.c +++ b/tests/threads/diff.c @@ -17,7 +17,7 @@ static git_repository *_repo; static git_tree *_a, *_b; -static git_atomic _counts[4]; +static git_atomic32 _counts[4]; static int _check_counts; #ifdef GIT_WIN32 static int _retries; @@ -66,10 +66,10 @@ static void free_trees(void) git_tree_free(_b); _b = NULL; if (_check_counts) { - cl_assert_equal_i(288, git_atomic_get(&_counts[0])); - cl_assert_equal_i(112, git_atomic_get(&_counts[1])); - cl_assert_equal_i( 80, git_atomic_get(&_counts[2])); - cl_assert_equal_i( 96, git_atomic_get(&_counts[3])); + cl_assert_equal_i(288, git_atomic32_get(&_counts[0])); + cl_assert_equal_i(112, git_atomic32_get(&_counts[1])); + cl_assert_equal_i( 80, git_atomic32_get(&_counts[2])); + cl_assert_equal_i( 96, git_atomic32_get(&_counts[3])); } } @@ -107,14 +107,14 @@ static void *run_index_diffs(void *arg) /* keep some diff stats to make sure results are as expected */ i = git_diff_num_deltas(diff); - git_atomic_add(&_counts[0], (int32_t)i); + git_atomic32_add(&_counts[0], (int32_t)i); exp[0] = (int)i; while (i > 0) { switch (git_diff_get_delta(diff, --i)->status) { - case GIT_DELTA_MODIFIED: exp[1]++; git_atomic_inc(&_counts[1]); break; - case GIT_DELTA_ADDED: exp[2]++; git_atomic_inc(&_counts[2]); break; - case GIT_DELTA_DELETED: exp[3]++; git_atomic_inc(&_counts[3]); break; + case GIT_DELTA_MODIFIED: exp[1]++; git_atomic32_inc(&_counts[1]); break; + case GIT_DELTA_ADDED: exp[2]++; git_atomic32_inc(&_counts[2]); break; + case GIT_DELTA_DELETED: exp[3]++; git_atomic32_inc(&_counts[3]); break; default: break; } } diff --git a/tests/threads/thread_helpers.h b/tests/threads/thread_helpers.h index 3c13cfb6b..0f23a4ce0 100644 --- a/tests/threads/thread_helpers.h +++ b/tests/threads/thread_helpers.h @@ -1,4 +1,4 @@ -#include "thread-utils.h" +#include "thread.h" void run_in_parallel( int repeats, diff --git a/tests/threads/tlsdata.c b/tests/threads/tlsdata.c new file mode 100644 index 000000000..7c69b4444 --- /dev/null +++ b/tests/threads/tlsdata.c @@ -0,0 +1,65 @@ +#include "clar_libgit2.h" + +#include "thread_helpers.h" + +void test_threads_tlsdata__can_set_and_get(void) +{ + git_tlsdata_key key_one, key_two, key_three; + + cl_git_pass(git_tlsdata_init(&key_one, NULL)); + cl_git_pass(git_tlsdata_init(&key_two, NULL)); + cl_git_pass(git_tlsdata_init(&key_three, NULL)); + + cl_git_pass(git_tlsdata_set(key_one, (void *)(size_t)42424242)); + cl_git_pass(git_tlsdata_set(key_two, (void *)(size_t)0xdeadbeef)); + cl_git_pass(git_tlsdata_set(key_three, (void *)(size_t)98761234)); + + cl_assert_equal_sz((size_t)42424242, git_tlsdata_get(key_one)); + cl_assert_equal_sz((size_t)0xdeadbeef, git_tlsdata_get(key_two)); + cl_assert_equal_sz((size_t)98761234, git_tlsdata_get(key_three)); + + cl_git_pass(git_tlsdata_dispose(key_one)); + cl_git_pass(git_tlsdata_dispose(key_two)); + cl_git_pass(git_tlsdata_dispose(key_three)); +} + +#ifdef GIT_THREADS + +static void *set_and_get(void *param) +{ + git_tlsdata_key *tlsdata_key = (git_tlsdata_key *)param; + int val; + + if (git_tlsdata_set(*tlsdata_key, &val) != 0 || + git_tlsdata_get(*tlsdata_key) != &val) + return (void *)0; + + return (void *)1; +} + +#endif + +#define THREAD_COUNT 10 + +void test_threads_tlsdata__threads(void) +{ +#ifdef GIT_THREADS + git_thread thread[THREAD_COUNT]; + git_tlsdata_key tlsdata; + int i; + + cl_git_pass(git_tlsdata_init(&tlsdata, NULL)); + + for (i = 0; i < THREAD_COUNT; i++) + cl_git_pass(git_thread_create(&thread[i], set_and_get, &tlsdata)); + + for (i = 0; i < THREAD_COUNT; i++) { + void *result; + + cl_git_pass(git_thread_join(&thread[i], &result)); + cl_assert_equal_sz(1, (size_t)result); + } + + cl_git_pass(git_tlsdata_dispose(tlsdata)); +#endif +} diff --git a/tests/trace/windows/stacktrace.c b/tests/trace/windows/stacktrace.c index 756ac68a3..0a77ef99d 100644 --- a/tests/trace/windows/stacktrace.c +++ b/tests/trace/windows/stacktrace.c @@ -1,13 +1,12 @@ #include "clar_libgit2.h" -#include "win32/w32_stack.h" -#include "win32/w32_crtdbg_stacktrace.h" +#include "win32/w32_leakcheck.h" -#if defined(GIT_MSVC_CRTDBG) +#if defined(GIT_WIN32_LEAKCHECK) static void a(void) { char buf[10000]; - cl_assert(git_win32__stack(buf, sizeof(buf), 0, NULL, NULL) == 0); + cl_assert(git_win32_leakcheck_stack(buf, sizeof(buf), 0, NULL, NULL) == 0); #if 0 fprintf(stderr, "Stacktrace from [%s:%d]:\n%s\n", __FILE__, __LINE__, buf); @@ -27,7 +26,7 @@ static void c(void) void test_trace_windows_stacktrace__basic(void) { -#if defined(GIT_MSVC_CRTDBG) +#if defined(GIT_WIN32_LEAKCHECK) c(); #endif } @@ -35,7 +34,7 @@ void test_trace_windows_stacktrace__basic(void) void test_trace_windows_stacktrace__leaks(void) { -#if defined(GIT_MSVC_CRTDBG) +#if defined(GIT_WIN32_LEAKCHECK) void * p1; void * p2; void * p3; @@ -47,84 +46,85 @@ void test_trace_windows_stacktrace__leaks(void) /* remember outstanding leaks due to set setup * and set mark/checkpoint. */ - before = git_win32__crtdbg_stacktrace__dump( - GIT_WIN32__CRTDBG_STACKTRACE__QUIET | - GIT_WIN32__CRTDBG_STACKTRACE__LEAKS_TOTAL | - GIT_WIN32__CRTDBG_STACKTRACE__SET_MARK, + before = git_win32_leakcheck_stacktrace_dump( + GIT_WIN32_LEAKCHECK_STACKTRACE_QUIET | + GIT_WIN32_LEAKCHECK_STACKTRACE_LEAKS_TOTAL | + GIT_WIN32_LEAKCHECK_STACKTRACE_SET_MARK, NULL); p1 = git__malloc(5); - leaks = git_win32__crtdbg_stacktrace__dump( - GIT_WIN32__CRTDBG_STACKTRACE__QUIET | - GIT_WIN32__CRTDBG_STACKTRACE__LEAKS_SINCE_MARK, + leaks = git_win32_leakcheck_stacktrace_dump( + GIT_WIN32_LEAKCHECK_STACKTRACE_QUIET | + GIT_WIN32_LEAKCHECK_STACKTRACE_LEAKS_SINCE_MARK, "p1"); - cl_assert((leaks == 1)); + cl_assert_equal_i(1, leaks); p2 = git__malloc(5); - leaks = git_win32__crtdbg_stacktrace__dump( - GIT_WIN32__CRTDBG_STACKTRACE__QUIET | - GIT_WIN32__CRTDBG_STACKTRACE__LEAKS_SINCE_MARK, + leaks = git_win32_leakcheck_stacktrace_dump( + GIT_WIN32_LEAKCHECK_STACKTRACE_QUIET | + GIT_WIN32_LEAKCHECK_STACKTRACE_LEAKS_SINCE_MARK, "p1,p2"); - cl_assert((leaks == 2)); + cl_assert_equal_i(2, leaks); p3 = git__malloc(5); - leaks = git_win32__crtdbg_stacktrace__dump( - GIT_WIN32__CRTDBG_STACKTRACE__QUIET | - GIT_WIN32__CRTDBG_STACKTRACE__LEAKS_SINCE_MARK, + leaks = git_win32_leakcheck_stacktrace_dump( + GIT_WIN32_LEAKCHECK_STACKTRACE_QUIET | + GIT_WIN32_LEAKCHECK_STACKTRACE_LEAKS_SINCE_MARK, "p1,p2,p3"); - cl_assert((leaks == 3)); + cl_assert_equal_i(3, leaks); git__free(p2); - leaks = git_win32__crtdbg_stacktrace__dump( - GIT_WIN32__CRTDBG_STACKTRACE__QUIET | - GIT_WIN32__CRTDBG_STACKTRACE__LEAKS_SINCE_MARK, + leaks = git_win32_leakcheck_stacktrace_dump( + GIT_WIN32_LEAKCHECK_STACKTRACE_QUIET | + GIT_WIN32_LEAKCHECK_STACKTRACE_LEAKS_SINCE_MARK, "p1,p3"); - cl_assert((leaks == 2)); + cl_assert_equal_i(2, leaks); /* move the mark. only new leaks should appear afterwards */ - error = git_win32__crtdbg_stacktrace__dump( - GIT_WIN32__CRTDBG_STACKTRACE__SET_MARK, + error = git_win32_leakcheck_stacktrace_dump( + GIT_WIN32_LEAKCHECK_STACKTRACE_SET_MARK, NULL); - cl_assert((error == 0)); + /* cannot use cl_git_pass() since that may allocate memory. */ + cl_assert_equal_i(0, error); - leaks = git_win32__crtdbg_stacktrace__dump( - GIT_WIN32__CRTDBG_STACKTRACE__QUIET | - GIT_WIN32__CRTDBG_STACKTRACE__LEAKS_SINCE_MARK, + leaks = git_win32_leakcheck_stacktrace_dump( + GIT_WIN32_LEAKCHECK_STACKTRACE_QUIET | + GIT_WIN32_LEAKCHECK_STACKTRACE_LEAKS_SINCE_MARK, "not_p1,not_p3"); - cl_assert((leaks == 0)); + cl_assert_equal_i(0, leaks); p4 = git__malloc(5); - leaks = git_win32__crtdbg_stacktrace__dump( - GIT_WIN32__CRTDBG_STACKTRACE__QUIET | - GIT_WIN32__CRTDBG_STACKTRACE__LEAKS_SINCE_MARK, + leaks = git_win32_leakcheck_stacktrace_dump( + GIT_WIN32_LEAKCHECK_STACKTRACE_QUIET | + GIT_WIN32_LEAKCHECK_STACKTRACE_LEAKS_SINCE_MARK, "p4,not_p1,not_p3"); - cl_assert((leaks == 1)); + cl_assert_equal_i(1, leaks); git__free(p1); git__free(p3); - leaks = git_win32__crtdbg_stacktrace__dump( - GIT_WIN32__CRTDBG_STACKTRACE__QUIET | - GIT_WIN32__CRTDBG_STACKTRACE__LEAKS_SINCE_MARK, + leaks = git_win32_leakcheck_stacktrace_dump( + GIT_WIN32_LEAKCHECK_STACKTRACE_QUIET | + GIT_WIN32_LEAKCHECK_STACKTRACE_LEAKS_SINCE_MARK, "p4"); - cl_assert((leaks == 1)); + cl_assert_equal_i(1, leaks); git__free(p4); - leaks = git_win32__crtdbg_stacktrace__dump( - GIT_WIN32__CRTDBG_STACKTRACE__QUIET | - GIT_WIN32__CRTDBG_STACKTRACE__LEAKS_SINCE_MARK, + leaks = git_win32_leakcheck_stacktrace_dump( + GIT_WIN32_LEAKCHECK_STACKTRACE_QUIET | + GIT_WIN32_LEAKCHECK_STACKTRACE_LEAKS_SINCE_MARK, "end"); - cl_assert((leaks == 0)); + cl_assert_equal_i(0, leaks); /* confirm current absolute leaks count matches beginning value. */ - after = git_win32__crtdbg_stacktrace__dump( - GIT_WIN32__CRTDBG_STACKTRACE__QUIET | - GIT_WIN32__CRTDBG_STACKTRACE__LEAKS_TOTAL, + after = git_win32_leakcheck_stacktrace_dump( + GIT_WIN32_LEAKCHECK_STACKTRACE_QUIET | + GIT_WIN32_LEAKCHECK_STACKTRACE_LEAKS_TOTAL, "total"); - cl_assert((before == after)); + cl_assert_equal_i(before, after); #endif } -#if defined(GIT_MSVC_CRTDBG) +#if defined(GIT_WIN32_LEAKCHECK) static void aux_cb_alloc__1(unsigned int *aux_id) { static unsigned int aux_counter = 0; @@ -141,12 +141,12 @@ static void aux_cb_lookup__1(unsigned int aux_id, char *aux_msg, size_t aux_msg_ void test_trace_windows_stacktrace__aux1(void) { -#if defined(GIT_MSVC_CRTDBG) - git_win32__stack__set_aux_cb(aux_cb_alloc__1, aux_cb_lookup__1); +#if defined(GIT_WIN32_LEAKCHECK) + git_win32_leakcheck_stack_set_aux_cb(aux_cb_alloc__1, aux_cb_lookup__1); c(); c(); c(); c(); - git_win32__stack__set_aux_cb(NULL, NULL); + git_win32_leakcheck_stack_set_aux_cb(NULL, NULL); #endif } diff --git a/tests/win32/longpath.c b/tests/win32/longpath.c index 80ae08d8b..f8b8c4b0a 100644 --- a/tests/win32/longpath.c +++ b/tests/win32/longpath.c @@ -4,9 +4,12 @@ #include "clone.h" #include "buffer.h" #include "futils.h" +#include "repository.h" static git_buf path = GIT_BUF_INIT; +#define LONG_FILENAME "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.txt" + void test_win32_longpath__initialize(void) { #ifdef GIT_WIN32 @@ -29,34 +32,100 @@ void test_win32_longpath__initialize(void) void test_win32_longpath__cleanup(void) { git_buf_dispose(&path); + cl_git_sandbox_cleanup(); } +void test_win32_longpath__errmsg_on_checkout(void) +{ #ifdef GIT_WIN32 -void assert_name_too_long(void) + git_repository *repo; + + cl_git_fail(git_clone(&repo, cl_fixture("testrepo.git"), path.ptr, NULL)); + cl_assert(git__prefixcmp(git_error_last()->message, "path too long") == 0); +#endif +} + +void test_win32_longpath__workdir_path_validated(void) { - const git_error *err; - size_t expected_len, actual_len; - char *expected_msg; +#ifdef GIT_WIN32 + git_repository *repo = cl_git_sandbox_init("testrepo"); + git_buf out = GIT_BUF_INIT; + + cl_git_pass(git_repository_workdir_path(&out, repo, "a.txt")); + + /* even if the repo path is a drive letter, this is too long */ + cl_git_fail(git_repository_workdir_path(&out, repo, LONG_FILENAME)); + cl_assert(git__prefixcmp(git_error_last()->message, "path too long") == 0); - err = git_error_last(); - actual_len = strlen(err->message); + cl_repo_set_bool(repo, "core.longpaths", true); + cl_git_pass(git_repository_workdir_path(&out, repo, "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.txt")); + cl_git_pass(git_repository_workdir_path(&out, repo, LONG_FILENAME)); + git_buf_dispose(&out); +#endif +} + +#ifdef GIT_WIN32 +static void assert_longpath_status_and_add(git_repository *repo, const char *wddata, const char *repodata) { + git_index *index; + git_blob *blob; + git_buf out = GIT_BUF_INIT; + const git_index_entry *entry; + unsigned int status_flags; - expected_msg = git_win32_get_error_message(ERROR_FILENAME_EXCED_RANGE); - expected_len = strlen(expected_msg); + cl_git_pass(git_repository_workdir_path(&out, repo, LONG_FILENAME)); - /* check the suffix */ - cl_assert_equal_s(expected_msg, err->message + (actual_len - expected_len)); + cl_git_rewritefile(out.ptr, wddata); - git__free(expected_msg); + cl_git_pass(git_status_file(&status_flags, repo, LONG_FILENAME)); + cl_assert_equal_i(GIT_STATUS_WT_NEW, status_flags); + + cl_git_pass(git_repository_index(&index, repo)); + cl_git_pass(git_index_add_bypath(index, LONG_FILENAME)); + + cl_git_pass(git_status_file(&status_flags, repo, LONG_FILENAME)); + cl_assert_equal_i(GIT_STATUS_INDEX_NEW, status_flags); + + cl_assert((entry = git_index_get_bypath(index, LONG_FILENAME, 0)) != NULL); + cl_git_pass(git_blob_lookup(&blob, repo, &entry->id)); + cl_assert_equal_s(repodata, git_blob_rawcontent(blob)); + + git_blob_free(blob); + git_index_free(index); + git_buf_dispose(&out); } #endif -void test_win32_longpath__errmsg_on_checkout(void) +void test_win32_longpath__status_and_add(void) { #ifdef GIT_WIN32 - git_repository *repo; + git_repository *repo = cl_git_sandbox_init("testrepo"); - cl_git_fail(git_clone(&repo, cl_fixture("testrepo.git"), path.ptr, NULL)); - assert_name_too_long(); + cl_repo_set_bool(repo, "core.longpaths", true); + + /* + * Doing no content filtering, we expect the data we add + * to be the data in the repository. + */ + assert_longpath_status_and_add(repo, + "This is a long path.\r\n", + "This is a long path.\r\n"); +#endif +} + +void test_win32_longpath__status_and_add_with_filter(void) +{ +#ifdef GIT_WIN32 + git_repository *repo = cl_git_sandbox_init("testrepo"); + + cl_repo_set_bool(repo, "core.longpaths", true); + cl_repo_set_bool(repo, "core.autocrlf", true); + + /* + * With `core.autocrlf`, we expect the data we add to have + * newline conversion performed. + */ + assert_longpath_status_and_add(repo, + "This is a long path.\r\n", + "This is a long path.\n"); #endif } diff --git a/tests/worktree/merge.c b/tests/worktree/merge.c index 4b743829c..2a1206032 100644 --- a/tests/worktree/merge.c +++ b/tests/worktree/merge.c @@ -70,9 +70,9 @@ void test_worktree_merge__merge_setup(void) ours, (const git_annotated_commit **)&theirs, 1)); for (i = 0; i < ARRAY_SIZE(merge_files); i++) { - git_buf_clear(&path); - cl_git_pass(git_buf_printf(&path, "%s/%s", - fixture.worktree->gitdir, merge_files[i])); + cl_git_pass(git_buf_joinpath(&path, + fixture.worktree->gitdir, + merge_files[i])); cl_assert(git_path_exists(path.ptr)); } diff --git a/tests/worktree/refs.c b/tests/worktree/refs.c index 501255274..27dc667ea 100644 --- a/tests/worktree/refs.c +++ b/tests/worktree/refs.c @@ -163,7 +163,10 @@ void test_worktree_refs__renaming_reference_updates_worktree_heads(void) cl_git_pass(git_branch_lookup(&branch, fixture.repo, "testrepo-worktree", GIT_BRANCH_LOCAL)); cl_git_pass(git_reference_rename(&renamed, branch, "refs/heads/renamed", 0, NULL)); - cl_git_pass(git_repository_head(&head, fixture.worktree)); + + cl_git_pass(git_reference_lookup(&head, fixture.worktree, GIT_HEAD_FILE)); + cl_assert_equal_i(git_reference_type(head), GIT_REFERENCE_SYMBOLIC); + cl_assert_equal_s(git_reference_symbolic_target(head), "refs/heads/renamed"); git_reference_free(head); git_reference_free(branch); diff --git a/tests/worktree/repository.c b/tests/worktree/repository.c index ca56413b7..c4eeadd35 100644 --- a/tests/worktree/repository.c +++ b/tests/worktree/repository.c @@ -50,9 +50,12 @@ void test_worktree_repository__head_detached(void) cl_assert(git_repository_head_detached(fixture.worktree)); cl_assert(git_repository_head_detached_for_worktree(fixture.repo, "testrepo-worktree")); - cl_git_fail(git_repository_head_for_worktree(&head, fixture.repo, "testrepo-worktree")); + cl_git_pass(git_repository_head_for_worktree(&head, fixture.repo, "testrepo-worktree")); + + cl_assert_equal_oid(&ref->target.oid, &head->target.oid); git_reference_free(ref); + git_reference_free(head); } void test_worktree_repository__head_detached_fails_for_invalid_worktree(void) diff --git a/tests/worktree/worktree.c b/tests/worktree/worktree.c index 716d0aa0a..9b87bfae6 100644 --- a/tests/worktree/worktree.c +++ b/tests/worktree/worktree.c @@ -44,8 +44,9 @@ void test_worktree_worktree__list_with_invalid_worktree_dirs(void) git_strarray wts; size_t i, j, len; - cl_git_pass(git_buf_printf(&path, "%s/worktrees/invalid", - fixture.repo->commondir)); + cl_git_pass(git_buf_joinpath(&path, + fixture.repo->commondir, + "worktrees/invalid")); cl_git_pass(p_mkdir(path.ptr, 0755)); len = path.size; @@ -145,9 +146,9 @@ void test_worktree_worktree__open_invalid_commondir(void) git_buf buf = GIT_BUF_INIT, path = GIT_BUF_INIT; cl_git_pass(git_buf_sets(&buf, "/path/to/nonexistent/commondir")); - cl_git_pass(git_buf_printf(&path, - "%s/worktrees/testrepo-worktree/commondir", - fixture.repo->commondir)); + cl_git_pass(git_buf_joinpath(&path, + fixture.repo->commondir, + "worktrees/testrepo-worktree/commondir")); cl_git_pass(git_futils_writebuffer(&buf, path.ptr, O_RDWR, 0644)); cl_git_pass(git_worktree_lookup(&wt, fixture.repo, "testrepo-worktree")); @@ -165,9 +166,9 @@ void test_worktree_worktree__open_invalid_gitdir(void) git_buf buf = GIT_BUF_INIT, path = GIT_BUF_INIT; cl_git_pass(git_buf_sets(&buf, "/path/to/nonexistent/gitdir")); - cl_git_pass(git_buf_printf(&path, - "%s/worktrees/testrepo-worktree/gitdir", - fixture.repo->commondir)); + cl_git_pass(git_buf_joinpath(&path, + fixture.repo->commondir, + "worktrees/testrepo-worktree/gitdir")); cl_git_pass(git_futils_writebuffer(&buf, path.ptr, O_RDWR, 0644)); cl_git_pass(git_worktree_lookup(&wt, fixture.repo, "testrepo-worktree")); @@ -581,45 +582,44 @@ void test_worktree_worktree__prune_worktree(void) git_worktree_free(wt); } -static int read_head_ref(git_repository *repo, const char *path, void *payload) +static int foreach_worktree_cb(git_repository *worktree, void *payload) { - git_vector *refs = (git_vector *) payload; - git_reference *head; + int *counter = (int *)payload; - GIT_UNUSED(repo); - - cl_git_pass(git_reference__read_head(&head, repo, path)); + switch (*counter) { + case 0: + cl_assert_equal_s(git_repository_path(fixture.repo), + git_repository_path(worktree)); + cl_assert(!git_repository_is_worktree(worktree)); + break; + case 1: + cl_assert_equal_s(git_repository_path(fixture.worktree), + git_repository_path(worktree)); + cl_assert(git_repository_is_worktree(worktree)); + break; + default: + cl_fail("more worktrees found than expected"); + } - git_vector_insert(refs, head); + (*counter)++; return 0; } -void test_worktree_worktree__foreach_head_gives_same_results_in_wt_and_repo(void) +void test_worktree_worktree__foreach_worktree_lists_all_worktrees(void) { - git_vector repo_refs = GIT_VECTOR_INIT, worktree_refs = GIT_VECTOR_INIT; - git_reference *heads[2]; - size_t i; - - cl_git_pass(git_reference_lookup(&heads[0], fixture.repo, GIT_HEAD_FILE)); - cl_git_pass(git_reference_lookup(&heads[1], fixture.worktree, GIT_HEAD_FILE)); - - cl_git_pass(git_repository_foreach_head(fixture.repo, read_head_ref, 0, &repo_refs)); - cl_git_pass(git_repository_foreach_head(fixture.worktree, read_head_ref, 0, &worktree_refs)); - - cl_assert_equal_i(repo_refs.length, ARRAY_SIZE(heads)); - cl_assert_equal_i(worktree_refs.length, ARRAY_SIZE(heads)); + int counter = 0; + cl_git_pass(git_repository_foreach_worktree(fixture.repo, foreach_worktree_cb, &counter)); +} - for (i = 0; i < ARRAY_SIZE(heads); i++) { - cl_assert_equal_s(heads[i]->name, ((git_reference *) repo_refs.contents[i])->name); - cl_assert_equal_s(heads[i]->name, ((git_reference *) repo_refs.contents[i])->name); - cl_assert_equal_s(heads[i]->name, ((git_reference *) worktree_refs.contents[i])->name); +void test_worktree_worktree__validate_invalid_worktreedir(void) +{ + git_worktree *wt; - git_reference_free(heads[i]); - git_reference_free(repo_refs.contents[i]); - git_reference_free(worktree_refs.contents[i]); - } + cl_git_pass(git_worktree_lookup(&wt, fixture.repo, "testrepo-worktree")); + p_rename("testrepo-worktree", "testrepo-worktree-tmp"); + cl_git_fail(git_worktree_validate(wt)); + p_rename("testrepo-worktree-tmp", "testrepo-worktree"); - git_vector_free(&repo_refs); - git_vector_free(&worktree_refs); + git_worktree_free(wt); } |