void test_config_write__value_containing_quotes(void) { git_config *cfg; const char* str; cl_git_pass(git_config_open_ondisk(&cfg, "config9")); cl_git_pass(git_config_set_string(cfg, "core.somevar", "this \"has\" quotes")); cl_git_pass(git_config_get_string(&str, cfg, "core.somevar")); cl_assert_equal_s(str, "this \"has\" quotes"); git_config_free(cfg); cl_git_pass(git_config_open_ondisk(&cfg, "config9")); cl_git_pass(git_config_get_string(&str, cfg, "core.somevar")); cl_assert_equal_s(str, "this \"has\" quotes"); git_config_free(cfg); /* The code path for values that already exist is different, check that one as well */ cl_git_pass(git_config_open_ondisk(&cfg, "config9")); cl_git_pass(git_config_set_string(cfg, "core.somevar", "this also \"has\" quotes")); cl_git_pass(git_config_get_string(&str, cfg, "core.somevar")); cl_assert_equal_s(str, "this also \"has\" quotes"); git_config_free(cfg); cl_git_pass(git_config_open_ondisk(&cfg, "config9")); cl_git_pass(git_config_get_string(&str, cfg, "core.somevar")); cl_assert_equal_s(str, "this also \"has\" quotes"); git_config_free(cfg); }
/* Returns a color setting (GIT_COLOR_NEVER, etc). */ static int use_sideband_colors(void) { static int use_sideband_colors_cached = -1; const char *key = "color.remote"; struct strbuf sb = STRBUF_INIT; char *value; int i; if (use_sideband_colors_cached >= 0) return use_sideband_colors_cached; if (!git_config_get_string(key, &value)) { use_sideband_colors_cached = git_config_colorbool(key, value); } else if (!git_config_get_string("color.ui", &value)) { use_sideband_colors_cached = git_config_colorbool("color.ui", value); } else { use_sideband_colors_cached = GIT_COLOR_AUTO; } for (i = 0; i < ARRAY_SIZE(keywords); i++) { strbuf_reset(&sb); strbuf_addf(&sb, "%s.%s", key, keywords[i].keyword); if (git_config_get_string(sb.buf, &value)) continue; if (color_parse(value, keywords[i].color)) continue; } strbuf_release(&sb); return use_sideband_colors_cached; }
static int transport_color_config(void) { const char *keys[] = { "color.transport.reset", "color.transport.rejected" }, *key = "color.transport"; char *value; int i; static int initialized; if (initialized) return 0; initialized = 1; if (!git_config_get_string(key, &value)) transport_use_color = git_config_colorbool(key, value); if (!want_color_stderr(transport_use_color)) return 0; for (i = 0; i < ARRAY_SIZE(keys); i++) if (!git_config_get_string(keys[i], &value)) { if (!value) return config_error_nonbool(keys[i]); if (color_parse(value, transport_colors[i]) < 0) return -1; } return 0; }
void test_config_write__add_value_which_needs_quotes(void) { git_config *cfg, *base; const char* str1; const char* str2; const char* str3; const char* str4; const char* str5; cl_git_pass(git_config_open_ondisk(&cfg, "config17")); cl_git_pass(git_config_set_string(cfg, "core.startwithspace", " Something")); cl_git_pass(git_config_set_string(cfg, "core.endwithspace", "Something ")); cl_git_pass(git_config_set_string(cfg, "core.containscommentchar1", "some#thing")); cl_git_pass(git_config_set_string(cfg, "core.containscommentchar2", "some;thing")); cl_git_pass(git_config_set_string(cfg, "core.startwhithsapceandcontainsdoublequote", " some\"thing")); git_config_free(cfg); cl_git_pass(git_config_open_ondisk(&base, "config17")); cl_git_pass(git_config_snapshot(&cfg, base)); cl_git_pass(git_config_get_string(&str1, cfg, "core.startwithspace")); cl_assert_equal_s(" Something", str1); cl_git_pass(git_config_get_string(&str2, cfg, "core.endwithspace")); cl_assert_equal_s("Something ", str2); cl_git_pass(git_config_get_string(&str3, cfg, "core.containscommentchar1")); cl_assert_equal_s("some#thing", str3); cl_git_pass(git_config_get_string(&str4, cfg, "core.containscommentchar2")); cl_assert_equal_s("some;thing", str4); cl_git_pass(git_config_get_string(&str5, cfg, "core.startwhithsapceandcontainsdoublequote")); cl_assert_equal_s(" some\"thing", str5); git_config_free(cfg); git_config_free(base); }
void test_config_read__prefixes(void) { git_config *cfg; const char *str; cl_git_pass(git_config_open_ondisk(&cfg, cl_fixture("config/config9"))); cl_git_pass(git_config_get_string(&str, cfg, "remote.ab.url")); cl_assert_equal_s(str, "http://example.com/git/ab"); cl_git_pass(git_config_get_string(&str, cfg, "remote.abba.url")); cl_assert_equal_s(str, "http://example.com/git/abba"); git_config_free(cfg); }
/* * This kind of subsection declaration is case-insensitive */ void test_config_read__subsection_header(void) { git_config *cfg; const char *str; cl_git_pass(git_config_open_ondisk(&cfg, cl_fixture("config/config3"))); cl_git_pass(git_config_get_string(&str, cfg, "section.subsection.var")); cl_assert_equal_s(str, "hello"); /* The subsection is transformed to lower-case */ cl_must_fail(git_config_get_string(&str, cfg, "section.subSectIon.var")); git_config_free(cfg); }
void test_config_read__whitespace_not_required_around_assignment(void) { git_config *cfg; const char *str; cl_git_pass(git_config_open_ondisk(&cfg, cl_fixture("config/config14"))); cl_git_pass(git_config_get_string(&str, cfg, "a.b")); cl_assert_equal_s(str, "c"); cl_git_pass(git_config_get_string(&str, cfg, "d.e")); cl_assert_equal_s(str, "f"); git_config_free(cfg); }
static char *get_default_remote(void) { char *dest = NULL, *ret; unsigned char sha1[20]; struct strbuf sb = STRBUF_INIT; const char *refname = resolve_ref_unsafe("HEAD", 0, sha1, NULL); if (!refname) die(_("No such ref: %s"), "HEAD"); /* detached HEAD */ if (!strcmp(refname, "HEAD")) return xstrdup("origin"); if (!skip_prefix(refname, "refs/heads/", &refname)) die(_("Expecting a full ref name, got %s"), refname); strbuf_addf(&sb, "branch.%s.remote", refname); if (git_config_get_string(sb.buf, &dest)) ret = xstrdup("origin"); else ret = dest; strbuf_release(&sb); return ret; }
int git_signature_default(git_signature **out, git_repository *repo) { int error; git_config *cfg; const char *user_name, *user_email; if ((error = git_repository_config_snapshot(&cfg, repo)) < 0) return error; if (!(error = git_config_get_string(&user_name, cfg, "user.name")) && !(error = git_config_get_string(&user_email, cfg, "user.email"))) error = git_signature_now(out, user_name, user_email); git_config_free(cfg); return error; }
void test_submodule_init__relative_url(void) { git_submodule *sm; git_config *cfg; git_buf absolute_url = GIT_BUF_INIT; const char *config_url; g_repo = setup_fixture_submodule_simple(); cl_assert(git_path_dirname_r(&absolute_url, git_repository_workdir(g_repo)) > 0); cl_git_pass(git_buf_joinpath(&absolute_url, absolute_url.ptr, "testrepo.git")); cl_git_pass(git_submodule_lookup(&sm, g_repo, "testrepo")); /* verify that the .gitmodules is set with an absolute path*/ cl_assert_equal_s("../testrepo.git", git_submodule_url(sm)); /* init and verify that absolute path is written to .git/config */ cl_git_pass(git_submodule_init(sm, false)); cl_git_pass(git_repository_config_snapshot(&cfg, g_repo)); cl_git_pass(git_config_get_string(&config_url, cfg, "submodule.testrepo.url")); cl_assert_equal_s(absolute_url.ptr, config_url); git_buf_free(&absolute_url); git_config_free(cfg); git_submodule_free(sm); }
PyObject * Config_getitem(Config *self, PyObject *py_key) { int err; int64_t c_intvalue; int c_boolvalue; const char *c_charvalue; const char *c_key; if (!(c_key = py_str_to_c_str(py_key,NULL))) return NULL; err = git_config_get_int64(&c_intvalue, self->config, c_key); if (err == GIT_OK) { return PyInt_FromLong((long)c_intvalue); } err = git_config_get_bool(&c_boolvalue, self->config, c_key); if (err == GIT_OK) { return PyBool_FromLong((long)c_boolvalue); } err = git_config_get_string(&c_charvalue, self->config, c_key); if (err < 0) { if (err == GIT_ENOTFOUND) { PyErr_SetObject(PyExc_KeyError, py_key); return NULL; } return Error_set(err); } return PyUnicode_FromString(c_charvalue); }
static int resolve_relative_url(int argc, const char **argv, const char *prefix) { char *remoteurl = NULL; char *remote = get_default_remote(); const char *up_path = NULL; char *res; const char *url; struct strbuf sb = STRBUF_INIT; if (argc != 2 && argc != 3) die("resolve-relative-url only accepts one or two arguments"); url = argv[1]; strbuf_addf(&sb, "remote.%s.url", remote); free(remote); if (git_config_get_string(sb.buf, &remoteurl)) /* the repository is its own authoritative upstream */ remoteurl = xgetcwd(); if (argc == 3) up_path = argv[2]; res = relative_url(remoteurl, url, up_path); puts(res); free(res); free(remoteurl); return 0; }
void test_config_write__escape_value(void) { git_config *cfg; const char* str; cl_git_pass(git_config_open_ondisk(&cfg, "config9")); cl_git_pass(git_config_set_string(cfg, "core.somevar", "this \"has\" quotes and \t")); cl_git_pass(git_config_get_string(&str, cfg, "core.somevar")); cl_assert_equal_s(str, "this \"has\" quotes and \t"); git_config_free(cfg); cl_git_pass(git_config_open_ondisk(&cfg, "config9")); cl_git_pass(git_config_get_string(&str, cfg, "core.somevar")); cl_assert_equal_s(str, "this \"has\" quotes and \t"); git_config_free(cfg); }
static int load_workdir(git_repository *repo, git_buf *parent_path) { int error; git_config *config; const char *worktree; git_buf worktree_buf = GIT_BUF_INIT; if (repo->is_bare) return 0; if (git_repository_config__weakptr(&config, repo) < 0) return -1; error = git_config_get_string(&worktree, config, "core.worktree"); if (!error && worktree != NULL) repo->workdir = git__strdup(worktree); else if (error != GIT_ENOTFOUND) return error; else { giterr_clear(); if (parent_path && git_path_isdir(parent_path->ptr)) repo->workdir = git_buf_detach(parent_path); else { git_path_dirname_r(&worktree_buf, repo->path_repository); git_path_to_dir(&worktree_buf); repo->workdir = git_buf_detach(&worktree_buf); } } GITERR_CHECK_ALLOC(repo->workdir); return 0; }
static int get_optional_config( bool *found, git_config *config, git_buf *buf, git_config_foreach_cb cb, void *payload) { int error = 0; const char *key = git_buf_cstr(buf); if (git_buf_oom(buf)) return -1; if (cb != NULL) error = git_config_get_multivar_foreach(config, key, NULL, cb, payload); else error = git_config_get_string(payload, config, key); if (found) *found = !error; if (error == GIT_ENOTFOUND) { giterr_clear(); error = 0; } return error; }
void test_submodule_modify__sync(void) { git_submodule *sm1, *sm2, *sm3; git_config *cfg; const char *str; #define SM1 "sm_unchanged" #define SM2 "sm_changed_head" #define SM3 "sm_added_and_uncommited" /* look up some submodules */ cl_git_pass(git_submodule_lookup(&sm1, g_repo, SM1)); cl_git_pass(git_submodule_lookup(&sm2, g_repo, SM2)); cl_git_pass(git_submodule_lookup(&sm3, g_repo, SM3)); /* At this point, the .git/config URLs for the submodules have * not be rewritten with the absolute paths (although the * .gitmodules have. Let's confirm that they DO NOT match * yet, then we can do a sync to make them match... */ /* check submodule info does not match before sync */ cl_git_pass(git_repository_config_snapshot(&cfg, g_repo)); cl_git_pass(git_config_get_string(&str, cfg, "submodule."SM1".url")); cl_assert(strcmp(git_submodule_url(sm1), str) != 0); cl_git_pass(git_config_get_string(&str, cfg, "submodule."SM2".url")); cl_assert(strcmp(git_submodule_url(sm2), str) != 0); cl_git_pass(git_config_get_string(&str, cfg, "submodule."SM3".url")); cl_assert(strcmp(git_submodule_url(sm3), str) != 0); git_config_free(cfg); /* sync all the submodules */ cl_git_pass(git_submodule_foreach(g_repo, sync_one_submodule, NULL)); /* check that submodule config is updated */ assert_submodule_url_is_synced( sm1, "submodule."SM1".url", "branch.origin.remote"); assert_submodule_url_is_synced( sm2, "submodule."SM2".url", "branch.origin.remote"); assert_submodule_url_is_synced( sm3, "submodule."SM3".url", "branch.origin.remote"); git_submodule_free(sm1); git_submodule_free(sm2); git_submodule_free(sm3); }
std::string Config::value(const std::string &key, const std::string &defaultValue) const { const char * result = 0; if (git_config_get_string(&result, _conf, key.c_str()) == GIT_OK) return std::string(result); return defaultValue; }
QVariant QGitConfig::value(const QString &key, const QVariant &defaultValue) const { const char * result = 0; if (git_config_get_string(reinterpret_cast<const char**>(d), (git_config*)key.toUtf8().constData(), result) == 0) return QString::fromUtf8(result); return defaultValue; }
struct git_graph *graph_init(struct rev_info *opt) { struct git_graph *graph = xmalloc(sizeof(struct git_graph)); if (!column_colors) { char *string; if (git_config_get_string("log.graphcolors", &string)) { /* not configured -- use default */ graph_set_column_colors(column_colors_ansi, column_colors_ansi_max); } else { static struct argv_array custom_colors = ARGV_ARRAY_INIT; argv_array_clear(&custom_colors); parse_graph_colors_config(&custom_colors, string); free(string); /* graph_set_column_colors takes a max-index, not a count */ graph_set_column_colors(custom_colors.argv, custom_colors.argc - 1); } } graph->commit = NULL; graph->revs = opt; graph->num_parents = 0; graph->expansion_row = 0; graph->state = GRAPH_PADDING; graph->prev_state = GRAPH_PADDING; graph->commit_index = 0; graph->prev_commit_index = 0; graph->num_columns = 0; graph->num_new_columns = 0; graph->mapping_size = 0; /* * Start the column color at the maximum value, since we'll * always increment it for the first commit we output. * This way we start at 0 for the first commit. */ graph->default_column_color = column_colors_max - 1; /* * Allocate a reasonably large default number of columns * We'll automatically grow columns later if we need more room. */ graph->column_capacity = 30; ALLOC_ARRAY(graph->columns, graph->column_capacity); ALLOC_ARRAY(graph->new_columns, graph->column_capacity); ALLOC_ARRAY(graph->mapping, 2 * graph->column_capacity); ALLOC_ARRAY(graph->new_mapping, 2 * graph->column_capacity); /* * The diff output prefix callback, with this we can make * all the diff output to align with the graph lines. */ opt->diffopt.output_prefix = diff_output_prefix_callback; opt->diffopt.output_prefix_data = graph; return graph; }
void test_submodule_modify__add(void) { git_submodule *sm; git_config *cfg; const char *s; /* re-add existing submodule */ cl_assert( git_submodule_add_setup(NULL, g_repo, "whatever", "sm_unchanged", 1) == GIT_EEXISTS ); /* add a submodule using a gitlink */ cl_git_pass( git_submodule_add_setup(&sm, g_repo, SM_LIBGIT2_URL, SM_LIBGIT2, 1) ); cl_assert(git_path_isfile("submod2/" SM_LIBGIT2 "/.git")); cl_assert(git_path_isdir("submod2/.git/modules")); cl_assert(git_path_isdir("submod2/.git/modules/" SM_LIBGIT2)); cl_assert(git_path_isfile("submod2/.git/modules/" SM_LIBGIT2 "/HEAD")); cl_git_pass(git_repository_config(&cfg, g_repo)); cl_git_pass( git_config_get_string(&s, cfg, "submodule." SM_LIBGIT2 ".url")); cl_assert_equal_s(s, SM_LIBGIT2_URL); git_config_free(cfg); /* add a submodule not using a gitlink */ cl_git_pass( git_submodule_add_setup(&sm, g_repo, SM_LIBGIT2_URL, SM_LIBGIT2B, 0) ); cl_assert(git_path_isdir("submod2/" SM_LIBGIT2B "/.git")); cl_assert(git_path_isfile("submod2/" SM_LIBGIT2B "/.git/HEAD")); cl_assert(!git_path_exists("submod2/.git/modules/" SM_LIBGIT2B)); cl_git_pass(git_repository_config(&cfg, g_repo)); cl_git_pass( git_config_get_string(&s, cfg, "submodule." SM_LIBGIT2B ".url")); cl_assert_equal_s(s, SM_LIBGIT2_URL); git_config_free(cfg); }
/* * This test exposes a bug where duplicate section headers could cause * config_write to add a new entry when one already exists. */ void test_config_write__add_value_with_duplicate_header(void) { const char *file_name = "config-duplicate-insert"; const char *entry_name = "foo.c"; const char *old_val = "old"; const char *new_val = "new"; const char *str; git_config *cfg, *snapshot; /* c = old should be replaced by c = new. * The bug causes c = new to be inserted under the first 'foo' header. */ const char *file_content = "[foo]\n" \ " a = b\n" \ "[other]\n" \ " a = b\n" \ "[foo]\n" \ " c = old\n"; /* Write the test config */ cl_git_mkfile(file_name, file_content); cl_git_pass(git_config_open_ondisk(&cfg, file_name)); /* make sure the expected entry (foo.c) exists */ cl_git_pass(git_config_snapshot(&snapshot, cfg)); cl_git_pass(git_config_get_string(&str, snapshot, entry_name)); cl_assert_equal_s(old_val, str); git_config_free(snapshot); /* Try setting foo.c to something else */ cl_git_pass(git_config_set_string(cfg, entry_name, new_val)); git_config_free(cfg); /* Reopen the file and make sure the new value was set */ cl_git_pass(git_config_open_ondisk(&cfg, file_name)); cl_git_pass(git_config_snapshot(&snapshot, cfg)); cl_git_pass(git_config_get_string(&str, snapshot, entry_name)); cl_assert_equal_s(new_val, str); /* Cleanup */ git_config_free(snapshot); git_config_free(cfg); }
void test_submodule_add__url_absolute(void) { git_submodule *sm; git_config *cfg; git_repository *repo; const char *worktree_path; git_buf dot_git_content = GIT_BUF_INIT; g_repo = setup_fixture_submod2(); /* re-add existing submodule */ cl_git_fail_with( GIT_EEXISTS, git_submodule_add_setup(NULL, g_repo, "whatever", "sm_unchanged", 1)); /* add a submodule using a gitlink */ cl_git_pass( git_submodule_add_setup(&sm, g_repo, "https://github.com/libgit2/libgit2.git", "sm_libgit2", 1) ); git_submodule_free(sm); cl_assert(git_path_isfile("submod2/" "sm_libgit2" "/.git")); cl_assert(git_path_isdir("submod2/.git/modules")); cl_assert(git_path_isdir("submod2/.git/modules/" "sm_libgit2")); cl_assert(git_path_isfile("submod2/.git/modules/" "sm_libgit2" "/HEAD")); assert_submodule_url("sm_libgit2", "https://github.com/libgit2/libgit2.git"); cl_git_pass(git_repository_open(&repo, "submod2/" "sm_libgit2")); /* Verify worktree path is relative */ cl_git_pass(git_repository_config(&cfg, repo)); cl_git_pass(git_config_get_string(&worktree_path, cfg, "core.worktree")); cl_assert_equal_s("../../../sm_libgit2/", worktree_path); /* Verify gitdir path is relative */ cl_git_pass(git_futils_readbuffer(&dot_git_content, "submod2/" "sm_libgit2" "/.git")); cl_assert_equal_s("gitdir: ../.git/modules/sm_libgit2/", dot_git_content.ptr); git_config_free(cfg); git_repository_free(repo); git_buf_free(&dot_git_content); /* add a submodule not using a gitlink */ cl_git_pass( git_submodule_add_setup(&sm, g_repo, "https://github.com/libgit2/libgit2.git", "sm_libgit2b", 0) ); git_submodule_free(sm); cl_assert(git_path_isdir("submod2/" "sm_libgit2b" "/.git")); cl_assert(git_path_isfile("submod2/" "sm_libgit2b" "/.git/HEAD")); cl_assert(!git_path_exists("submod2/.git/modules/" "sm_libgit2b")); assert_submodule_url("sm_libgit2b", "https://github.com/libgit2/libgit2.git"); }
static void assert_submodule_url_is_synced( git_submodule *sm, const char *parent_key, const char *child_key) { git_config *cfg; const char *str; git_repository *smrepo; cl_git_pass(git_repository_config(&cfg, g_repo)); cl_git_pass(git_config_get_string(&str, cfg, parent_key)); cl_assert_equal_s(git_submodule_url(sm), str); git_config_free(cfg); cl_git_pass(git_submodule_open(&smrepo, sm)); cl_git_pass(git_repository_config(&cfg, smrepo)); cl_git_pass(git_config_get_string(&str, cfg, child_key)); cl_assert_equal_s(git_submodule_url(sm), str); git_config_free(cfg); git_repository_free(smrepo); }
void test_config_read__escaping_quotes(void) { git_config *cfg; const char *str; cl_git_pass(git_config_open_ondisk(&cfg, cl_fixture("config/config13"))); cl_git_pass(git_config_get_string(&str, cfg, "core.editor")); cl_assert(strcmp(str, "\"C:/Program Files/Nonsense/bah.exe\" \"--some option\"") == 0); git_config_free(cfg); }
static void fetch_pack_config(void) { git_config_get_int("fetch.unpacklimit", &fetch_unpack_limit); git_config_get_int("transfer.unpacklimit", &transfer_unpack_limit); git_config_get_bool("repack.usedeltabaseoffset", &prefer_ofs_delta); git_config_get_bool("fetch.fsckobjects", &fetch_fsck_objects); git_config_get_bool("transfer.fsckobjects", &transfer_fsck_objects); git_config_get_string("fetch.negotiationalgorithm", &negotiation_algorithm); git_config(fetch_pack_config_cb, NULL); }
/* * If \ is the last non-space character on the line, we read the next * one, separating each line with SP. */ void test_config_read__multiline_value(void) { git_config *cfg; const char *str; cl_git_pass(git_config_open_ondisk(&cfg, cl_fixture("config/config2"))); cl_git_pass(git_config_get_string(&str, cfg, "this.That.and")); cl_assert_equal_s(str, "one one one two two three three"); git_config_free(cfg); }
void test_refs_branches_move__can_not_move_a_branch_if_its_destination_name_collide_with_an_existing_one(void) { git_reference *original_ref, *new_ref; git_config *config; git_buf buf = GIT_BUF_INIT; char *original_remote, *original_merge; const char *str; cl_git_pass(git_repository_config_snapshot(&config, repo)); cl_git_pass(git_config_get_string_buf(&buf, config, "branch.master.remote")); original_remote = git_buf_detach(&buf); cl_git_pass(git_config_get_string_buf(&buf, config, "branch.master.merge")); original_merge = git_buf_detach(&buf); git_config_free(config); cl_git_pass(git_reference_lookup(&original_ref, repo, "refs/heads/br2")); cl_assert_equal_i(GIT_EEXISTS, git_branch_move(&new_ref, original_ref, "master", 0)); cl_assert(giterr_last()->message != NULL); cl_git_pass(git_repository_config_snapshot(&config, repo)); cl_git_pass(git_config_get_string(&str, config, "branch.master.remote")); cl_assert_equal_s(original_remote, str); cl_git_pass(git_config_get_string(&str, config, "branch.master.merge")); cl_assert_equal_s(original_merge, str); git_config_free(config); cl_assert_equal_i(GIT_EEXISTS, git_branch_move(&new_ref, original_ref, "cannot-fetch", 0)); cl_assert(giterr_last()->message != NULL); cl_git_pass(git_repository_config_snapshot(&config, repo)); cl_git_pass(git_config_get_string(&str, config, "branch.master.remote")); cl_assert_equal_s(original_remote, str); cl_git_pass(git_config_get_string(&str, config, "branch.master.merge")); cl_assert_equal_s(original_merge, str); git_config_free(config); git_reference_free(original_ref); cl_git_pass(git_reference_lookup(&original_ref, repo, "refs/heads/track-local")); cl_assert_equal_i(GIT_EEXISTS, git_branch_move(&new_ref, original_ref, "master", 0)); cl_assert(giterr_last()->message != NULL); cl_git_pass(git_repository_config_snapshot(&config, repo)); cl_git_pass(git_config_get_string(&str, config, "branch.master.remote")); cl_assert_equal_s(original_remote, str); cl_git_pass(git_config_get_string(&str, config, "branch.master.merge")); cl_assert_equal_s(original_merge, str); git__free(original_remote); git__free(original_merge); git_reference_free(original_ref); git_config_free(config); }
void test_submodule_modify__init(void) { git_config *cfg; const char *str; /* erase submodule data from .git/config */ cl_git_pass(git_repository_config(&cfg, g_repo)); cl_git_pass( git_config_foreach_match(cfg, "submodule\\..*", delete_one_config, cfg)); git_config_free(cfg); /* confirm no submodule data in config */ cl_git_pass(git_repository_config(&cfg, g_repo)); cl_git_fail(git_config_get_string(&str, cfg, "submodule.sm_unchanged.url")); cl_git_fail(git_config_get_string(&str, cfg, "submodule.sm_changed_head.url")); cl_git_fail(git_config_get_string(&str, cfg, "submodule.sm_added_and_uncommited.url")); git_config_free(cfg); /* call init and see that settings are copied */ cl_git_pass(git_submodule_foreach(g_repo, init_one_submodule, NULL)); git_submodule_reload_all(g_repo); /* confirm submodule data in config */ cl_git_pass(git_repository_config(&cfg, g_repo)); cl_git_pass(git_config_get_string(&str, cfg, "submodule.sm_unchanged.url")); cl_assert(git__suffixcmp(str, "/submod2_target") == 0); cl_git_pass(git_config_get_string(&str, cfg, "submodule.sm_changed_head.url")); cl_assert(git__suffixcmp(str, "/submod2_target") == 0); cl_git_pass(git_config_get_string(&str, cfg, "submodule.sm_added_and_uncommited.url")); cl_assert(git__suffixcmp(str, "/submod2_target") == 0); git_config_free(cfg); }
static void assert_invalid_config_key_name(const char *name) { cl_git_fail_with(git_config_get_string(&value, cfg, name), GIT_EINVALIDSPEC); cl_git_fail_with(git_config_set_string(cfg, name, "42"), GIT_EINVALIDSPEC); cl_git_fail_with(git_config_delete_entry(cfg, name), GIT_EINVALIDSPEC); cl_git_fail_with(git_config_get_multivar_foreach(cfg, name, "*", NULL, NULL), GIT_EINVALIDSPEC); cl_git_fail_with(git_config_set_multivar(cfg, name, "*", "42"), GIT_EINVALIDSPEC); }
static enum protocol_allow_config get_protocol_config(const char *type) { char *key = xstrfmt("protocol.%s.allow", type); char *value; /* first check the per-protocol config */ if (!git_config_get_string(key, &value)) { enum protocol_allow_config ret = parse_protocol_config(key, value); free(key); free(value); return ret; } free(key); /* if defined, fallback to user-defined default for unknown protocols */ if (!git_config_get_string("protocol.allow", &value)) { enum protocol_allow_config ret = parse_protocol_config("protocol.allow", value); free(value); return ret; } /* fallback to built-in defaults */ /* known safe */ if (!strcmp(type, "http") || !strcmp(type, "https") || !strcmp(type, "git") || !strcmp(type, "ssh") || !strcmp(type, "file")) return PROTOCOL_ALLOW_ALWAYS; /* known scary; err on the side of caution */ if (!strcmp(type, "ext")) return PROTOCOL_ALLOW_NEVER; /* unknown; by default let them be used only directly by the user */ return PROTOCOL_ALLOW_USER_ONLY; }