void test_attr_ignore__expand_tilde_to_homedir(void) { git_buf path = GIT_BUF_INIT; git_config *cfg; assert_is_ignored(false, "example.global_with_tilde"); /* construct fake home with fake global excludes */ cl_must_pass(p_mkdir("home", 0777)); cl_git_pass(git_path_prettify(&path, "home", NULL)); cl_git_pass(git_libgit2_opts( GIT_OPT_SET_SEARCH_PATH, GIT_CONFIG_LEVEL_GLOBAL, path.ptr)); cl_git_mkfile("home/globalexcludes", "# found me\n*.global_with_tilde\n"); cl_git_pass(git_repository_config(&cfg, g_repo)); cl_git_pass(git_config_set_string(cfg, "core.excludesfile", "~/globalexcludes")); git_config_free(cfg); git_attr_cache_flush(g_repo); /* must reset to pick up change */ assert_is_ignored(true, "example.global_with_tilde"); cl_git_pass(git_futils_rmdir_r("home", NULL, GIT_RMDIR_REMOVE_FILES)); cl_git_pass(git_libgit2_opts( GIT_OPT_SET_SEARCH_PATH, GIT_CONFIG_LEVEL_GLOBAL, NULL)); git_buf_free(&path); }
/* * call-seq: * Settings[option] = value * * Sets a libgit2 library option. */ static VALUE rb_git_set_option(VALUE self, VALUE option, VALUE value) { const char *opt; Check_Type(option, T_STRING); opt = StringValueCStr(option); if (strcmp(opt, "mwindow_size") == 0) { size_t val; Check_Type(value, T_FIXNUM); val = NUM2SIZET(value); git_libgit2_opts(GIT_OPT_SET_MWINDOW_SIZE, val); } else if (strcmp(opt, "mwindow_mapped_limit") == 0) { size_t val; Check_Type(value, T_FIXNUM); val = NUM2SIZET(value); git_libgit2_opts(GIT_OPT_SET_MWINDOW_MAPPED_LIMIT, val); } else { rb_raise(rb_eArgError, "Unknown option specified"); } return Qnil; }
void test_repo_config__can_open_missing_global_with_separators(void) { git_repository *repo; git_config *config, *global; cl_git_pass(git_buf_printf( &path, "%c%s", GIT_PATH_LIST_SEPARATOR, "dummy")); cl_git_pass(git_libgit2_opts( GIT_OPT_SET_SEARCH_PATH, GIT_CONFIG_LEVEL_GLOBAL, path.ptr)); cl_git_pass(git_libgit2_opts( GIT_OPT_SET_SEARCH_PATH, GIT_CONFIG_LEVEL_SYSTEM, path.ptr)); cl_git_pass(git_libgit2_opts( GIT_OPT_SET_SEARCH_PATH, GIT_CONFIG_LEVEL_XDG, path.ptr)); git_buf_dispose(&path); cl_git_pass(git_repository_open(&repo, "empty_standard_repo")); cl_git_pass(git_repository_config(&config, repo)); cl_git_pass(git_config_open_level( &global, config, GIT_CONFIG_LEVEL_GLOBAL)); cl_git_pass(git_config_set_string(global, "test.set", "42")); git_config_free(global); git_config_free(config); git_repository_free(repo); }
void test_refs_create__cleanup(void) { cl_git_sandbox_cleanup(); cl_git_pass(git_libgit2_opts(GIT_OPT_ENABLE_STRICT_OBJECT_CREATION, 1)); cl_git_pass(git_libgit2_opts(GIT_OPT_ENABLE_STRICT_SYMBOLIC_REF_CREATION, 1)); cl_git_pass(git_libgit2_opts(GIT_OPT_ENABLE_SYNCHRONOUS_OBJECT_CREATION, 0)); }
void cl_sandbox_set_search_path_defaults(void) { const char *sandbox_path = clar_sandbox_path(); git_libgit2_opts( GIT_OPT_SET_SEARCH_PATH, GIT_CONFIG_LEVEL_GLOBAL, sandbox_path); git_libgit2_opts( GIT_OPT_SET_SEARCH_PATH, GIT_CONFIG_LEVEL_XDG, sandbox_path); git_libgit2_opts( GIT_OPT_SET_SEARCH_PATH, GIT_CONFIG_LEVEL_SYSTEM, sandbox_path); }
void test_core_opts__readwrite(void) { size_t old_val = 0; size_t new_val = 0; git_libgit2_opts(GIT_OPT_GET_MWINDOW_SIZE, &old_val); git_libgit2_opts(GIT_OPT_SET_MWINDOW_SIZE, (size_t)1234); git_libgit2_opts(GIT_OPT_GET_MWINDOW_SIZE, &new_val); cl_assert(new_val == 1234); git_libgit2_opts(GIT_OPT_SET_MWINDOW_SIZE, old_val); git_libgit2_opts(GIT_OPT_GET_MWINDOW_SIZE, &new_val); cl_assert(new_val == old_val); }
/** * Set the SSL certificate-authority locations * * Either parameter may be 'NULL', but not both. * @param filename Location of a file containing several certificates * concatenated together. Default NULL. * @param path Location of a directory holding several certificates, * one per file. Default NULL. * @return NULL */ SEXP git2r_ssl_cert_locations(SEXP filename, SEXP path) { const char *f = NULL; const char *p = NULL; if (!Rf_isNull(filename)) { if (git2r_arg_check_string(filename)) git2r_error(__func__, NULL, "'filename'", git2r_err_string_arg); f = CHAR(STRING_ELT(filename, 0)); } if (!Rf_isNull(path)) { if (git2r_arg_check_string(path)) git2r_error(__func__, NULL, "'path'", git2r_err_string_arg); p = CHAR(STRING_ELT(path, 0)); } if (f == NULL && p == NULL) git2r_error(__func__, NULL, git2r_err_ssl_cert_locations, NULL); if (git_libgit2_opts(GIT_OPT_SET_SSL_CERT_LOCATIONS, f, p)) git2r_error(__func__, GIT2R_ERROR_LAST(), NULL, NULL); return R_NilValue; }
void test_object_cache__cleanup(void) { git_repository_free(g_repo); g_repo = NULL; git_libgit2_opts(GIT_OPT_SET_CACHE_OBJECT_LIMIT, (int)GIT_OBJ_BLOB, (size_t)0); }
void cl_fake_home(void) { git_buf path = GIT_BUF_INIT; cl_git_pass(git_libgit2_opts( GIT_OPT_GET_SEARCH_PATH, GIT_CONFIG_LEVEL_GLOBAL, &path)); _cl_restore_home = git_buf_detach(&path); cl_set_cleanup(cl_fake_home_cleanup, NULL); if (!git_path_exists("home")) cl_must_pass(p_mkdir("home", 0777)); cl_git_pass(git_path_prettify(&path, "home", NULL)); cl_git_pass(git_libgit2_opts( GIT_OPT_SET_SEARCH_PATH, GIT_CONFIG_LEVEL_GLOBAL, path.ptr)); git_buf_free(&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); cl_fixture_cleanup("tmp_global_path"); }
void test_config_read__path(void) { git_config *cfg; git_buf path = GIT_BUF_INIT; git_buf old_path = GIT_BUF_INIT; git_buf home_path = GIT_BUF_INIT; git_buf expected_path = GIT_BUF_INIT; cl_git_pass(p_mkdir("fakehome", 0777)); cl_git_pass(git_path_prettify(&home_path, "fakehome", NULL)); cl_git_pass(git_libgit2_opts(GIT_OPT_GET_SEARCH_PATH, GIT_CONFIG_LEVEL_GLOBAL, &old_path)); cl_git_pass(git_libgit2_opts(GIT_OPT_SET_SEARCH_PATH, GIT_CONFIG_LEVEL_GLOBAL, home_path.ptr)); cl_git_mkfile("./testconfig", "[some]\n path = ~/somefile"); cl_git_pass(git_path_join_unrooted(&expected_path, "somefile", home_path.ptr, NULL)); cl_git_pass(git_config_open_ondisk(&cfg, "./testconfig")); cl_git_pass(git_config_get_path(&path, cfg, "some.path")); cl_assert_equal_s(expected_path.ptr, path.ptr); git_buf_dispose(&path); cl_git_mkfile("./testconfig", "[some]\n path = ~/"); cl_git_pass(git_path_join_unrooted(&expected_path, "", home_path.ptr, NULL)); cl_git_pass(git_config_get_path(&path, cfg, "some.path")); cl_assert_equal_s(expected_path.ptr, path.ptr); git_buf_dispose(&path); cl_git_mkfile("./testconfig", "[some]\n path = ~"); cl_git_pass(git_buf_sets(&expected_path, home_path.ptr)); cl_git_pass(git_config_get_path(&path, cfg, "some.path")); cl_assert_equal_s(expected_path.ptr, path.ptr); git_buf_dispose(&path); cl_git_mkfile("./testconfig", "[some]\n path = ~user/foo"); cl_git_fail(git_config_get_path(&path, cfg, "some.path")); cl_git_pass(git_libgit2_opts(GIT_OPT_SET_SEARCH_PATH, GIT_CONFIG_LEVEL_GLOBAL, old_path.ptr)); git_buf_dispose(&old_path); git_buf_dispose(&home_path); git_buf_dispose(&expected_path); git_config_free(cfg); }
void test_repo_init__cleanup(void) { git_libgit2_opts(GIT_OPT_SET_SEARCH_PATH, GIT_CONFIG_LEVEL_GLOBAL, _global_path.ptr); git_buf_free(&_global_path); if (_tmp_path.size > 0 && git_path_isdir(_tmp_path.ptr)) git_futils_rmdir_r(_tmp_path.ptr, NULL, GIT_RMDIR_REMOVE_FILES); git_buf_free(&_tmp_path); }
void test_refs_create__fsyncs_when_global_opt_set(void) { size_t create_count, compress_count; cl_git_pass(git_libgit2_opts(GIT_OPT_ENABLE_SYNCHRONOUS_OBJECT_CREATION, 1)); count_fsyncs(&create_count, &compress_count); cl_assert_equal_i(expected_fsyncs_create, create_count); cl_assert_equal_i(expected_fsyncs_compress, compress_count); }
void test_object_tree_write__object_validity(void) { /* Ensure that we cannot add invalid objects by default */ test_invalid_objects(false); test_inserting_submodule(); /* Ensure that we can turn off validation */ cl_git_pass(git_libgit2_opts(GIT_OPT_ENABLE_STRICT_OBJECT_CREATION, 0)); test_invalid_objects(true); test_inserting_submodule(); }
void cl_sandbox_set_search_path_defaults(void) { git_buf path = GIT_BUF_INIT; git_buf_joinpath(&path, clar_sandbox_path(), "__config"); if (!git_path_exists(path.ptr)) cl_must_pass(p_mkdir(path.ptr, 0777)); git_libgit2_opts( GIT_OPT_SET_SEARCH_PATH, GIT_CONFIG_LEVEL_GLOBAL, path.ptr); git_libgit2_opts( GIT_OPT_SET_SEARCH_PATH, GIT_CONFIG_LEVEL_XDG, path.ptr); git_libgit2_opts( GIT_OPT_SET_SEARCH_PATH, GIT_CONFIG_LEVEL_SYSTEM, path.ptr); git_libgit2_opts( GIT_OPT_SET_SEARCH_PATH, GIT_CONFIG_LEVEL_PROGRAMDATA, path.ptr); git_buf_free(&path); }
void test_config_global__initialize(void) { git_buf path = GIT_BUF_INIT; cl_git_pass(git_futils_mkdir_r("home", 0777)); cl_git_pass(git_path_prettify(&path, "home", NULL)); cl_git_pass(git_libgit2_opts( GIT_OPT_SET_SEARCH_PATH, GIT_CONFIG_LEVEL_GLOBAL, path.ptr)); cl_git_pass(git_futils_mkdir_r("xdg/git", 0777)); cl_git_pass(git_path_prettify(&path, "xdg/git", NULL)); cl_git_pass(git_libgit2_opts( GIT_OPT_SET_SEARCH_PATH, GIT_CONFIG_LEVEL_XDG, path.ptr)); cl_git_pass(git_futils_mkdir_r("etc", 0777)); cl_git_pass(git_path_prettify(&path, "etc", NULL)); cl_git_pass(git_libgit2_opts( GIT_OPT_SET_SEARCH_PATH, GIT_CONFIG_LEVEL_SYSTEM, path.ptr)); git_buf_free(&path); }
void test_repo_init__initialize(void) { _repo = NULL; /* load umask if not already loaded */ if (!g_umask) { g_umask = p_umask(022); (void)p_umask(g_umask); } git_libgit2_opts(GIT_OPT_GET_SEARCH_PATH, GIT_CONFIG_LEVEL_GLOBAL, &_global_path); }
void cl_fake_home_cleanup(void *payload) { char *restore = _cl_restore_home; _cl_restore_home = NULL; GIT_UNUSED(payload); if (restore) { cl_git_pass(git_libgit2_opts( GIT_OPT_SET_SEARCH_PATH, GIT_CONFIG_LEVEL_GLOBAL, restore)); git__free(restore); } }
/* * call-seq: * Settings[option] -> value * * Gets the value of a libgit2 library option. */ static VALUE rb_git_get_option(VALUE self, VALUE option) { const char *opt; Check_Type(option, T_STRING); opt = StringValueCStr(option); if (strcmp(opt, "mwindow_size") == 0) { size_t val; git_libgit2_opts(GIT_OPT_GET_MWINDOW_SIZE, &val); return SIZET2NUM(val); } else if (strcmp(opt, "mwindow_mapped_limit") == 0) { size_t val; git_libgit2_opts(GIT_OPT_GET_MWINDOW_MAPPED_LIMIT, &val); return SIZET2NUM(val); } else { rb_raise(rb_eArgError, "Unknown option specified"); } }
void test_repo_config__can_open_global_when_there_is_no_file(void) { git_repository *repo; git_config *config, *global; cl_git_pass(git_libgit2_opts( GIT_OPT_SET_SEARCH_PATH, GIT_CONFIG_LEVEL_GLOBAL, path.ptr)); cl_git_pass(git_libgit2_opts( GIT_OPT_SET_SEARCH_PATH, GIT_CONFIG_LEVEL_SYSTEM, path.ptr)); cl_git_pass(git_libgit2_opts( GIT_OPT_SET_SEARCH_PATH, GIT_CONFIG_LEVEL_XDG, path.ptr)); cl_git_pass(git_repository_open(&repo, "empty_standard_repo")); cl_git_pass(git_repository_config(&config, repo)); cl_git_pass(git_config_open_level( &global, config, GIT_CONFIG_LEVEL_GLOBAL)); cl_git_pass(git_config_set_string(global, "test.set", "42")); git_config_free(global); git_config_free(config); git_repository_free(repo); }
void test_object_cache__cache_everything(void) { int i, start; git_oid oid; git_odb_object *odb_obj; git_object *obj; git_odb *odb; git_libgit2_opts( GIT_OPT_SET_CACHE_OBJECT_LIMIT, (int)GIT_OBJ_BLOB, (size_t)32767); cl_git_pass(git_repository_open(&g_repo, cl_fixture("testrepo.git"))); cl_git_pass(git_repository_odb(&odb, g_repo)); start = (int)git_cache_size(&g_repo->objects); for (i = 0; g_data[i].sha != NULL; ++i) { int count = (int)git_cache_size(&g_repo->objects); cl_git_pass(git_oid_fromstr(&oid, g_data[i].sha)); /* alternate between loading raw and parsed objects */ if ((i & 1) == 0) { cl_git_pass(git_odb_read(&odb_obj, odb, &oid)); cl_assert(g_data[i].type == git_odb_object_type(odb_obj)); git_odb_object_free(odb_obj); } else { cl_git_pass(git_object_lookup(&obj, g_repo, &oid, GIT_OBJ_ANY)); cl_assert(g_data[i].type == git_object_type(obj)); git_object_free(obj); } cl_assert_equal_i(count + 1, (int)git_cache_size(&g_repo->objects)); } cl_assert_equal_i(i, (int)git_cache_size(&g_repo->objects) - start); git_odb_free(odb); for (i = 0; g_data[i].sha != NULL; ++i) { int count = (int)git_cache_size(&g_repo->objects); cl_git_pass(git_oid_fromstr(&oid, g_data[i].sha)); cl_git_pass(git_object_lookup(&obj, g_repo, &oid, GIT_OBJ_ANY)); cl_assert(g_data[i].type == git_object_type(obj)); git_object_free(obj); cl_assert_equal_i(count, (int)git_cache_size(&g_repo->objects)); } }
static void configure_templatedir(const char *template_path) { git_buf config_path = GIT_BUF_INIT; git_buf config_data = GIT_BUF_INIT; cl_git_pass(git_libgit2_opts(GIT_OPT_GET_SEARCH_PATH, GIT_CONFIG_LEVEL_GLOBAL, &_tmp_path)); cl_git_pass(git_buf_puts(&_tmp_path, ".tmp")); cl_git_pass(git_libgit2_opts(GIT_OPT_SET_SEARCH_PATH, GIT_CONFIG_LEVEL_GLOBAL, _tmp_path.ptr)); cl_must_pass(p_mkdir(_tmp_path.ptr, 0777)); cl_git_pass(git_buf_joinpath(&config_path, _tmp_path.ptr, ".gitconfig")); cl_git_pass(git_buf_printf(&config_data, "[init]\n\ttemplatedir = \"%s\"\n", template_path)); cl_git_mkfile(config_path.ptr, config_data.ptr); git_buf_free(&config_path); git_buf_free(&config_data); }
void test_repo_open__no_config(void) { git_buf path = GIT_BUF_INIT; git_repository *repo; git_config *config; cl_fixture_sandbox("empty_standard_repo"); cl_git_pass(cl_rename( "empty_standard_repo/.gitted", "empty_standard_repo/.git")); /* remove local config */ cl_git_pass(git_futils_rmdir_r( "empty_standard_repo/.git/config", NULL, GIT_RMDIR_REMOVE_FILES)); /* isolate from system level configs */ cl_must_pass(p_mkdir("alternate", 0777)); cl_git_pass(git_path_prettify(&path, "alternate", NULL)); cl_git_pass(git_libgit2_opts( GIT_OPT_SET_SEARCH_PATH, GIT_CONFIG_LEVEL_GLOBAL, path.ptr)); cl_git_pass(git_libgit2_opts( GIT_OPT_SET_SEARCH_PATH, GIT_CONFIG_LEVEL_SYSTEM, path.ptr)); cl_git_pass(git_libgit2_opts( GIT_OPT_SET_SEARCH_PATH, GIT_CONFIG_LEVEL_XDG, path.ptr)); git_buf_free(&path); cl_git_pass(git_repository_open(&repo, "empty_standard_repo")); cl_git_pass(git_repository_config(&config, repo)); cl_git_pass(git_config_set_string(config, "test.set", "42")); git_config_free(config); git_repository_free(repo); cl_fixture_cleanup("empty_standard_repo"); cl_sandbox_set_search_path_defaults(); }
void test_odb_backend_simple__read_with_hash_mismatch_succeeds_without_verification(void) { const fake_object objs[] = { { "1234567890123456789012345678901234567890", "nonmatching content" }, { NULL, NULL } }; setup_backend(objs); cl_git_pass(git_oid_fromstr(&_oid, objs[0].oid)); cl_git_pass(git_libgit2_opts(GIT_OPT_ENABLE_STRICT_HASH_VERIFICATION, 0)); cl_git_pass(git_odb_read(&_obj, _odb, &_oid)); assert_object_contains(_obj, objs[0].content); }
void test_odb_backend_simple__read_with_highly_ambiguous_prefix(void) { const fake_object objs[] = { { "1234567890111111111111111111111111111111", "first content" }, { "1234567890111111111111111111111111111112", "second content" }, { NULL, NULL } }; setup_backend(objs); cl_git_pass(git_oid_fromstr(&_oid, objs[0].oid)); cl_git_pass(git_libgit2_opts(GIT_OPT_ENABLE_STRICT_HASH_VERIFICATION, 0)); cl_git_fail_with(GIT_EAMBIGUOUS, git_odb_read_prefix(&_obj, _odb, &_oid, 39)); cl_git_pass(git_odb_read_prefix(&_obj, _odb, &_oid, 40)); assert_object_contains(_obj, objs[0].content); }
void test_refs_create__symbolic_with_arbitrary_content(void) { git_reference *new_reference, *looked_up_ref; git_repository *repo2; git_oid id; const char *new_head_tracker = "ANOTHER_HEAD_TRACKER"; const char *arbitrary_target = "ARBITRARY DATA"; git_oid_fromstr(&id, current_master_tip); /* Attempt to create symbolic ref with arbitrary data in target * fails by default */ cl_git_fail(git_reference_symbolic_create(&new_reference, g_repo, new_head_tracker, arbitrary_target, 0, NULL)); git_libgit2_opts(GIT_OPT_ENABLE_STRICT_SYMBOLIC_REF_CREATION, 0); /* With strict target validation disabled, ref creation succeeds */ cl_git_pass(git_reference_symbolic_create(&new_reference, g_repo, new_head_tracker, arbitrary_target, 0, NULL)); /* Ensure the reference can be looked-up... */ cl_git_pass(git_reference_lookup(&looked_up_ref, g_repo, new_head_tracker)); cl_assert(git_reference_type(looked_up_ref) & GIT_REF_SYMBOLIC); cl_assert(reference_is_packed(looked_up_ref) == 0); cl_assert_equal_s(looked_up_ref->name, new_head_tracker); git_reference_free(looked_up_ref); /* Ensure the target is what we expect it to be */ cl_assert_equal_s(git_reference_symbolic_target(new_reference), arbitrary_target); /* Similar test with a fresh new repository object */ cl_git_pass(git_repository_open(&repo2, "testrepo")); /* Ensure the reference can be looked-up... */ cl_git_pass(git_reference_lookup(&looked_up_ref, repo2, new_head_tracker)); cl_assert(git_reference_type(looked_up_ref) & GIT_REF_SYMBOLIC); cl_assert(reference_is_packed(looked_up_ref) == 0); cl_assert_equal_s(looked_up_ref->name, new_head_tracker); /* Ensure the target is what we expect it to be */ cl_assert_equal_s(git_reference_symbolic_target(new_reference), arbitrary_target); git_repository_free(repo2); git_reference_free(new_reference); git_reference_free(looked_up_ref); }
void test_odb_backend_simple__null_oid_is_ignored(void) { const fake_object objs[] = { { "0000000000000000000000000000000000000000", "null oid content" }, { NULL, NULL } }; git_oid null_oid = {{0}}; git_odb_object *obj; setup_backend(objs); cl_git_pass(git_libgit2_opts(GIT_OPT_ENABLE_STRICT_HASH_VERIFICATION, 0)); cl_assert(!git_odb_exists(_odb, &null_oid)); cl_git_fail_with(GIT_ENOTFOUND, git_odb_read(&obj, _odb, &null_oid)); cl_assert(giterr_last() && strstr(giterr_last()->message, "null OID")); }
/* Can by default create a reference that targets at an unknown id */ void test_refs_create__oid_unknown_succeeds_without_strict(void) { git_reference *new_reference, *looked_up_ref; git_oid id; const char *new_head = "refs/heads/new-head"; git_oid_fromstr(&id, "deadbeef3f795b2b4353bcce3a527ad0a4f7f644"); cl_git_pass(git_libgit2_opts(GIT_OPT_ENABLE_STRICT_OBJECT_CREATION, 0)); /* Create and write the new object id reference */ cl_git_pass(git_reference_create(&new_reference, g_repo, new_head, &id, 0, NULL)); git_reference_free(new_reference); /* Ensure the reference can't be looked-up... */ cl_git_pass(git_reference_lookup(&looked_up_ref, g_repo, new_head)); git_reference_free(looked_up_ref); }
static PyObject * get_search_path(long level) { git_buf buf = {NULL}; PyObject *py_path; int err; err = git_libgit2_opts(GIT_OPT_GET_SEARCH_PATH, level, &buf); if (err < 0) return Error_set(err); py_path = to_unicode(buf.ptr, NULL, NULL); git_buf_free(&buf); if (!py_path) return NULL; return py_path; }
void test_config_global__open_programdata(void) { git_config *cfg; git_repository *repo; git_buf config_path = GIT_BUF_INIT; git_buf var_contents = GIT_BUF_INIT; if (cl_is_env_set("GITTEST_INVASIVE_FS_STRUCTURE")) cl_skip(); cl_git_pass(git_libgit2_opts(GIT_OPT_GET_SEARCH_PATH, GIT_CONFIG_LEVEL_PROGRAMDATA, &config_path)); if (!git_path_isdir(config_path.ptr)) cl_git_pass(p_mkdir(config_path.ptr, 0777)); cl_git_pass(git_buf_puts(&config_path, "/config")); cl_git_pass(git_config_open_ondisk(&cfg, config_path.ptr)); cl_git_pass(git_config_set_string(cfg, "programdata.var", "even higher level")); git_buf_free(&config_path); git_config_free(cfg); git_config_open_default(&cfg); cl_git_pass(git_config_get_string_buf(&var_contents, cfg, "programdata.var")); cl_assert_equal_s("even higher level", var_contents.ptr); git_config_free(cfg); git_buf_free(&var_contents); cl_git_pass(git_repository_init(&repo, "./foo.git", true)); cl_git_pass(git_repository_config(&cfg, repo)); cl_git_pass(git_config_get_string_buf(&var_contents, cfg, "programdata.var")); cl_assert_equal_s("even higher level", var_contents.ptr); git_config_free(cfg); git_buf_free(&var_contents); git_repository_free(repo); cl_fixture_cleanup("./foo.git"); }