| #include "clar_libgit2.h" |
| #include "buffer.h" |
| #include "path.h" |
| |
| static git_buf buf = GIT_BUF_INIT; |
| |
| void test_config_read__cleanup(void) |
| { |
| git_buf_free(&buf); |
| } |
| |
| void test_config_read__simple_read(void) |
| { |
| git_config *cfg; |
| int32_t i; |
| |
| cl_git_pass(git_config_open_ondisk(&cfg, cl_fixture("config/config0"))); |
| |
| cl_git_pass(git_config_get_int32(&i, cfg, "core.repositoryformatversion")); |
| cl_assert(i == 0); |
| cl_git_pass(git_config_get_bool(&i, cfg, "core.filemode")); |
| cl_assert(i == 1); |
| cl_git_pass(git_config_get_bool(&i, cfg, "core.bare")); |
| cl_assert(i == 0); |
| cl_git_pass(git_config_get_bool(&i, cfg, "core.logallrefupdates")); |
| cl_assert(i == 1); |
| |
| git_config_free(cfg); |
| } |
| |
| void test_config_read__case_sensitive(void) |
| { |
| git_config *cfg; |
| int i; |
| |
| cl_git_pass(git_config_open_ondisk(&cfg, cl_fixture("config/config1"))); |
| |
| cl_git_pass(git_config_get_string_buf(&buf, cfg, "this.that.other")); |
| cl_assert_equal_s("true", git_buf_cstr(&buf)); |
| git_buf_clear(&buf); |
| |
| cl_git_pass(git_config_get_string_buf(&buf, cfg, "this.That.other")); |
| cl_assert_equal_s("yes", git_buf_cstr(&buf)); |
| |
| cl_git_pass(git_config_get_bool(&i, cfg, "this.that.other")); |
| cl_assert(i == 1); |
| cl_git_pass(git_config_get_bool(&i, cfg, "this.That.other")); |
| cl_assert(i == 1); |
| |
| /* This one doesn't exist */ |
| cl_must_fail(git_config_get_bool(&i, cfg, "this.thaT.other")); |
| |
| git_config_free(cfg); |
| } |
| |
| /* |
| * 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; |
| |
| cl_git_pass(git_config_open_ondisk(&cfg, cl_fixture("config/config2"))); |
| |
| cl_git_pass(git_config_get_string_buf(&buf, cfg, "this.That.and")); |
| cl_assert_equal_s("one one one two two three three", git_buf_cstr(&buf)); |
| |
| git_config_free(cfg); |
| } |
| |
| static void clean_test_config(void *unused) |
| { |
| GIT_UNUSED(unused); |
| cl_fixture_cleanup("./testconfig"); |
| } |
| |
| void test_config_read__multiline_value_and_eof(void) |
| { |
| git_config *cfg; |
| |
| cl_set_cleanup(&clean_test_config, NULL); |
| cl_git_mkfile("./testconfig", "[header]\n key1 = foo\\\n"); |
| cl_git_pass(git_config_open_ondisk(&cfg, "./testconfig")); |
| |
| cl_git_pass(git_config_get_string_buf(&buf, cfg, "header.key1")); |
| cl_assert_equal_s("foo", git_buf_cstr(&buf)); |
| |
| git_config_free(cfg); |
| } |
| |
| void test_config_read__multiline_eof(void) |
| { |
| git_config *cfg; |
| |
| cl_set_cleanup(&clean_test_config, NULL); |
| cl_git_mkfile("./testconfig", "[header]\n key1 = \\\n"); |
| cl_git_pass(git_config_open_ondisk(&cfg, "./testconfig")); |
| |
| cl_git_pass(git_config_get_string_buf(&buf, cfg, "header.key1")); |
| cl_assert_equal_s("", git_buf_cstr(&buf)); |
| |
| git_config_free(cfg); |
| } |
| |
| /* |
| * This kind of subsection declaration is case-insensitive |
| */ |
| void test_config_read__subsection_header(void) |
| { |
| git_config *cfg; |
| |
| cl_git_pass(git_config_open_ondisk(&cfg, cl_fixture("config/config3"))); |
| |
| cl_git_pass(git_config_get_string_buf(&buf, cfg, "section.subsection.var")); |
| cl_assert_equal_s("hello", git_buf_cstr(&buf)); |
| |
| /* The subsection is transformed to lower-case */ |
| cl_must_fail(git_config_get_string_buf(&buf, cfg, "section.subSectIon.var")); |
| |
| git_config_free(cfg); |
| } |
| |
| void test_config_read__lone_variable(void) |
| { |
| git_config *cfg; |
| int i; |
| |
| cl_git_pass(git_config_open_ondisk(&cfg, cl_fixture("config/config4"))); |
| |
| cl_git_fail(git_config_get_int32(&i, cfg, "some.section.variable")); |
| |
| cl_git_pass(git_config_get_string_buf(&buf, cfg, "some.section.variable")); |
| cl_assert_equal_s("", git_buf_cstr(&buf)); |
| git_buf_clear(&buf); |
| |
| cl_git_pass(git_config_get_bool(&i, cfg, "some.section.variable")); |
| cl_assert(i == 1); |
| |
| cl_git_pass(git_config_get_string_buf(&buf, cfg, "some.section.variableeq")); |
| cl_assert_equal_s("", git_buf_cstr(&buf)); |
| |
| cl_git_pass(git_config_get_bool(&i, cfg, "some.section.variableeq")); |
| cl_assert(i == 0); |
| |
| git_config_free(cfg); |
| } |
| |
| void test_config_read__number_suffixes(void) |
| { |
| git_config *cfg; |
| int64_t i; |
| |
| cl_git_pass(git_config_open_ondisk(&cfg, cl_fixture("config/config5"))); |
| |
| cl_git_pass(git_config_get_int64(&i, cfg, "number.simple")); |
| cl_assert(i == 1); |
| |
| cl_git_pass(git_config_get_int64(&i, cfg, "number.k")); |
| cl_assert(i == 1 * 1024); |
| |
| cl_git_pass(git_config_get_int64(&i, cfg, "number.kk")); |
| cl_assert(i == 1 * 1024); |
| |
| cl_git_pass(git_config_get_int64(&i, cfg, "number.m")); |
| cl_assert(i == 1 * 1024 * 1024); |
| |
| cl_git_pass(git_config_get_int64(&i, cfg, "number.mm")); |
| cl_assert(i == 1 * 1024 * 1024); |
| |
| cl_git_pass(git_config_get_int64(&i, cfg, "number.g")); |
| cl_assert(i == 1 * 1024 * 1024 * 1024); |
| |
| cl_git_pass(git_config_get_int64(&i, cfg, "number.gg")); |
| cl_assert(i == 1 * 1024 * 1024 * 1024); |
| |
| git_config_free(cfg); |
| } |
| |
| void test_config_read__blank_lines(void) |
| { |
| git_config *cfg; |
| int i; |
| |
| cl_git_pass(git_config_open_ondisk(&cfg, cl_fixture("config/config6"))); |
| |
| cl_git_pass(git_config_get_bool(&i, cfg, "valid.subsection.something")); |
| cl_assert(i == 1); |
| |
| cl_git_pass(git_config_get_bool(&i, cfg, "something.else.something")); |
| cl_assert(i == 0); |
| |
| git_config_free(cfg); |
| } |
| |
| void test_config_read__invalid_ext_headers(void) |
| { |
| git_config *cfg; |
| cl_must_fail(git_config_open_ondisk(&cfg, cl_fixture("config/config7"))); |
| } |
| |
| void test_config_read__empty_files(void) |
| { |
| git_config *cfg; |
| cl_git_pass(git_config_open_ondisk(&cfg, cl_fixture("config/config8"))); |
| git_config_free(cfg); |
| } |
| |
| void test_config_read__symbol_headers(void) |
| { |
| git_config *cfg; |
| cl_git_pass(git_config_open_ondisk(&cfg, cl_fixture("config/config20"))); |
| git_config_free(cfg); |
| } |
| |
| void test_config_read__header_in_last_line(void) |
| { |
| git_config *cfg; |
| |
| cl_git_pass(git_config_open_ondisk(&cfg, cl_fixture("config/config10"))); |
| git_config_free(cfg); |
| } |
| |
| void test_config_read__prefixes(void) |
| { |
| git_config *cfg; |
| |
| cl_git_pass(git_config_open_ondisk(&cfg, cl_fixture("config/config9"))); |
| cl_git_pass(git_config_get_string_buf(&buf, cfg, "remote.ab.url")); |
| cl_assert_equal_s("http://example.com/git/ab", git_buf_cstr(&buf)); |
| git_buf_clear(&buf); |
| |
| cl_git_pass(git_config_get_string_buf(&buf, cfg, "remote.abba.url")); |
| cl_assert_equal_s("http://example.com/git/abba", git_buf_cstr(&buf)); |
| |
| git_config_free(cfg); |
| } |
| |
| void test_config_read__escaping_quotes(void) |
| { |
| git_config *cfg; |
| |
| cl_git_pass(git_config_open_ondisk(&cfg, cl_fixture("config/config13"))); |
| cl_git_pass(git_config_get_string_buf(&buf, cfg, "core.editor")); |
| cl_assert_equal_s("\"C:/Program Files/Nonsense/bah.exe\" \"--some option\"", git_buf_cstr(&buf)); |
| |
| git_config_free(cfg); |
| } |
| |
| void test_config_read__invalid_escape_sequence(void) |
| { |
| git_config *cfg; |
| |
| cl_set_cleanup(&clean_test_config, NULL); |
| cl_git_mkfile("./testconfig", "[header]\n key1 = \\\\\\;\n key2 = value2\n"); |
| cl_git_fail(git_config_open_ondisk(&cfg, "./testconfig")); |
| |
| git_config_free(cfg); |
| } |
| |
| static int count_cfg_entries_and_compare_levels( |
| const git_config_entry *entry, void *payload) |
| { |
| int *count = payload; |
| |
| if (!strcmp(entry->value, "7") || !strcmp(entry->value, "17")) |
| cl_assert(entry->level == GIT_CONFIG_LEVEL_GLOBAL); |
| else |
| cl_assert(entry->level == GIT_CONFIG_LEVEL_SYSTEM); |
| |
| (*count)++; |
| return 0; |
| } |
| |
| static int cfg_callback_countdown(const git_config_entry *entry, void *payload) |
| { |
| int *count = payload; |
| GIT_UNUSED(entry); |
| (*count)--; |
| if (*count == 0) |
| return -100; |
| return 0; |
| } |
| |
| void test_config_read__foreach(void) |
| { |
| git_config *cfg; |
| int count, ret; |
| |
| cl_git_pass(git_config_new(&cfg)); |
| cl_git_pass(git_config_add_file_ondisk(cfg, cl_fixture("config/config9"), |
| GIT_CONFIG_LEVEL_SYSTEM, 0)); |
| cl_git_pass(git_config_add_file_ondisk(cfg, cl_fixture("config/config15"), |
| GIT_CONFIG_LEVEL_GLOBAL, 0)); |
| |
| count = 0; |
| cl_git_pass(git_config_foreach(cfg, count_cfg_entries_and_compare_levels, &count)); |
| cl_assert_equal_i(7, count); |
| |
| count = 3; |
| cl_git_fail(ret = git_config_foreach(cfg, cfg_callback_countdown, &count)); |
| cl_assert_equal_i(-100, ret); |
| |
| git_config_free(cfg); |
| } |
| |
| void test_config_read__iterator(void) |
| { |
| git_config *cfg; |
| git_config_iterator *iter; |
| git_config_entry *entry; |
| int count, ret; |
| |
| cl_git_pass(git_config_new(&cfg)); |
| cl_git_pass(git_config_add_file_ondisk(cfg, cl_fixture("config/config9"), |
| GIT_CONFIG_LEVEL_SYSTEM, 0)); |
| cl_git_pass(git_config_add_file_ondisk(cfg, cl_fixture("config/config15"), |
| GIT_CONFIG_LEVEL_GLOBAL, 0)); |
| |
| count = 0; |
| cl_git_pass(git_config_iterator_new(&iter, cfg)); |
| |
| while ((ret = git_config_next(&entry, iter)) == 0) { |
| count++; |
| } |
| |
| git_config_iterator_free(iter); |
| cl_assert_equal_i(GIT_ITEROVER, ret); |
| cl_assert_equal_i(7, count); |
| |
| count = 3; |
| cl_git_pass(git_config_iterator_new(&iter, cfg)); |
| |
| git_config_iterator_free(iter); |
| git_config_free(cfg); |
| } |
| |
| static int count_cfg_entries(const git_config_entry *entry, void *payload) |
| { |
| int *count = payload; |
| GIT_UNUSED(entry); |
| (*count)++; |
| return 0; |
| } |
| |
| void test_config_read__foreach_match(void) |
| { |
| git_config *cfg; |
| int count; |
| |
| cl_git_pass(git_config_open_ondisk(&cfg, cl_fixture("config/config9"))); |
| |
| count = 0; |
| cl_git_pass( |
| git_config_foreach_match(cfg, "core.*", count_cfg_entries, &count)); |
| cl_assert_equal_i(3, count); |
| |
| count = 0; |
| cl_git_pass( |
| git_config_foreach_match(cfg, "remote\\.ab.*", count_cfg_entries, &count)); |
| cl_assert_equal_i(2, count); |
| |
| count = 0; |
| cl_git_pass( |
| git_config_foreach_match(cfg, ".*url$", count_cfg_entries, &count)); |
| cl_assert_equal_i(2, count); |
| |
| count = 0; |
| cl_git_pass( |
| git_config_foreach_match(cfg, ".*dummy.*", count_cfg_entries, &count)); |
| cl_assert_equal_i(2, count); |
| |
| count = 0; |
| cl_git_pass( |
| git_config_foreach_match(cfg, ".*nomatch.*", count_cfg_entries, &count)); |
| cl_assert_equal_i(0, count); |
| |
| git_config_free(cfg); |
| } |
| |
| static void check_glob_iter(git_config *cfg, const char *regexp, int expected) |
| { |
| git_config_iterator *iter; |
| git_config_entry *entry; |
| int count, error; |
| |
| cl_git_pass(git_config_iterator_glob_new(&iter, cfg, regexp)); |
| |
| count = 0; |
| while ((error = git_config_next(&entry, iter)) == 0) |
| count++; |
| |
| cl_assert_equal_i(GIT_ITEROVER, error); |
| cl_assert_equal_i(expected, count); |
| git_config_iterator_free(iter); |
| } |
| |
| void test_config_read__iterator_invalid_glob(void) |
| { |
| git_config *cfg; |
| git_config_iterator *iter; |
| |
| cl_git_pass(git_config_open_ondisk(&cfg, cl_fixture("config/config9"))); |
| |
| cl_git_fail(git_config_iterator_glob_new(&iter, cfg, "*")); |
| |
| git_config_free(cfg); |
| } |
| |
| void test_config_read__iterator_glob(void) |
| { |
| git_config *cfg; |
| |
| cl_git_pass(git_config_open_ondisk(&cfg, cl_fixture("config/config9"))); |
| |
| check_glob_iter(cfg, "core.*", 3); |
| check_glob_iter(cfg, "remote\\.ab.*", 2); |
| check_glob_iter(cfg, ".*url$", 2); |
| check_glob_iter(cfg, ".*dummy.*", 2); |
| check_glob_iter(cfg, ".*nomatch.*", 0); |
| |
| git_config_free(cfg); |
| } |
| |
| void test_config_read__whitespace_not_required_around_assignment(void) |
| { |
| git_config *cfg; |
| |
| cl_git_pass(git_config_open_ondisk(&cfg, cl_fixture("config/config14"))); |
| |
| cl_git_pass(git_config_get_string_buf(&buf, cfg, "a.b")); |
| cl_assert_equal_s("c", git_buf_cstr(&buf)); |
| git_buf_clear(&buf); |
| |
| cl_git_pass(git_config_get_string_buf(&buf, cfg, "d.e")); |
| cl_assert_equal_s("f", git_buf_cstr(&buf)); |
| |
| git_config_free(cfg); |
| } |
| |
| void test_config_read__read_git_config_entry(void) |
| { |
| git_config *cfg; |
| git_config_entry *entry; |
| |
| cl_git_pass(git_config_new(&cfg)); |
| cl_git_pass(git_config_add_file_ondisk(cfg, cl_fixture("config/config9"), |
| GIT_CONFIG_LEVEL_SYSTEM, 0)); |
| |
| cl_git_pass(git_config_get_entry(&entry, cfg, "core.dummy2")); |
| cl_assert_equal_s("core.dummy2", entry->name); |
| cl_assert_equal_s("42", entry->value); |
| cl_assert_equal_i(GIT_CONFIG_LEVEL_SYSTEM, entry->level); |
| |
| git_config_entry_free(entry); |
| git_config_free(cfg); |
| } |
| |
| /* |
| * At the beginning of the test: |
| * - config9 has: core.dummy2=42 |
| * - config15 has: core.dummy2=7 |
| * - config16 has: core.dummy2=28 |
| */ |
| void test_config_read__local_config_overrides_global_config_overrides_system_config(void) |
| { |
| git_config *cfg; |
| int32_t i; |
| |
| cl_git_pass(git_config_new(&cfg)); |
| cl_git_pass(git_config_add_file_ondisk(cfg, cl_fixture("config/config9"), |
| GIT_CONFIG_LEVEL_SYSTEM, 0)); |
| cl_git_pass(git_config_add_file_ondisk(cfg, cl_fixture("config/config15"), |
| GIT_CONFIG_LEVEL_GLOBAL, 0)); |
| cl_git_pass(git_config_add_file_ondisk(cfg, cl_fixture("config/config16"), |
| GIT_CONFIG_LEVEL_LOCAL, 0)); |
| |
| cl_git_pass(git_config_get_int32(&i, cfg, "core.dummy2")); |
| cl_assert_equal_i(28, i); |
| |
| git_config_free(cfg); |
| |
| cl_git_pass(git_config_new(&cfg)); |
| cl_git_pass(git_config_add_file_ondisk(cfg, cl_fixture("config/config9"), |
| GIT_CONFIG_LEVEL_SYSTEM, 0)); |
| cl_git_pass(git_config_add_file_ondisk(cfg, cl_fixture("config/config15"), |
| GIT_CONFIG_LEVEL_GLOBAL, 0)); |
| |
| cl_git_pass(git_config_get_int32(&i, cfg, "core.dummy2")); |
| cl_assert_equal_i(7, i); |
| |
| git_config_free(cfg); |
| } |
| |
| /* |
| * At the beginning of the test: |
| * - config9 has: core.global does not exist |
| * - config15 has: core.global=17 |
| * - config16 has: core.global=29 |
| * |
| * And also: |
| * - config9 has: core.system does not exist |
| * - config15 has: core.system does not exist |
| * - config16 has: core.system=11 |
| */ |
| void test_config_read__fallback_from_local_to_global_and_from_global_to_system(void) |
| { |
| git_config *cfg; |
| int32_t i; |
| |
| cl_git_pass(git_config_new(&cfg)); |
| cl_git_pass(git_config_add_file_ondisk(cfg, cl_fixture("config/config9"), |
| GIT_CONFIG_LEVEL_SYSTEM, 0)); |
| cl_git_pass(git_config_add_file_ondisk(cfg, cl_fixture("config/config15"), |
| GIT_CONFIG_LEVEL_GLOBAL, 0)); |
| cl_git_pass(git_config_add_file_ondisk(cfg, cl_fixture("config/config16"), |
| GIT_CONFIG_LEVEL_LOCAL, 0)); |
| |
| cl_git_pass(git_config_get_int32(&i, cfg, "core.global")); |
| cl_assert_equal_i(17, i); |
| cl_git_pass(git_config_get_int32(&i, cfg, "core.system")); |
| cl_assert_equal_i(11, i); |
| |
| git_config_free(cfg); |
| } |
| |
| /* |
| * At the beginning of the test, config18 has: |
| * int32global = 28 |
| * int64global = 9223372036854775803 |
| * boolglobal = true |
| * stringglobal = I'm a global config value! |
| * |
| * And config19 has: |
| * int32global = -1 |
| * int64global = -2 |
| * boolglobal = false |
| * stringglobal = don't find me! |
| * |
| */ |
| void test_config_read__simple_read_from_specific_level(void) |
| { |
| git_config *cfg, *cfg_specific; |
| int i; |
| int64_t l, expected = +9223372036854775803; |
| |
| cl_git_pass(git_config_new(&cfg)); |
| cl_git_pass(git_config_add_file_ondisk(cfg, cl_fixture("config/config18"), |
| GIT_CONFIG_LEVEL_GLOBAL, 0)); |
| cl_git_pass(git_config_add_file_ondisk(cfg, cl_fixture("config/config19"), |
| GIT_CONFIG_LEVEL_SYSTEM, 0)); |
| |
| cl_git_pass(git_config_open_level(&cfg_specific, cfg, GIT_CONFIG_LEVEL_GLOBAL)); |
| |
| cl_git_pass(git_config_get_int32(&i, cfg_specific, "core.int32global")); |
| cl_assert_equal_i(28, i); |
| cl_git_pass(git_config_get_int64(&l, cfg_specific, "core.int64global")); |
| cl_assert(l == expected); |
| cl_git_pass(git_config_get_bool(&i, cfg_specific, "core.boolglobal")); |
| cl_assert_equal_b(true, i); |
| cl_git_pass(git_config_get_string_buf(&buf, cfg_specific, "core.stringglobal")); |
| cl_assert_equal_s("I'm a global config value!", git_buf_cstr(&buf)); |
| |
| git_config_free(cfg_specific); |
| git_config_free(cfg); |
| } |
| |
| void test_config_read__can_load_and_parse_an_empty_config_file(void) |
| { |
| git_config *cfg; |
| int i; |
| |
| cl_set_cleanup(&clean_test_config, NULL); |
| cl_git_mkfile("./testconfig", ""); |
| cl_git_pass(git_config_open_ondisk(&cfg, "./testconfig")); |
| cl_assert_equal_i(GIT_ENOTFOUND, git_config_get_int32(&i, cfg, "nope.neither")); |
| |
| git_config_free(cfg); |
| } |
| |
| void test_config_read__corrupt_header(void) |
| { |
| git_config *cfg; |
| |
| cl_set_cleanup(&clean_test_config, NULL); |
| cl_git_mkfile("./testconfig", "[sneaky ] \"quoted closing quote mark\\\""); |
| cl_git_fail(git_config_open_ondisk(&cfg, "./testconfig")); |
| |
| git_config_free(cfg); |
| } |
| |
| void test_config_read__corrupt_header2(void) |
| { |
| git_config *cfg; |
| |
| cl_set_cleanup(&clean_test_config, NULL); |
| cl_git_mkfile("./testconfig", "[unclosed \"bracket\"\n lib = git2\n"); |
| cl_git_fail(git_config_open_ondisk(&cfg, "./testconfig")); |
| |
| git_config_free(cfg); |
| } |
| |
| void test_config_read__corrupt_header3(void) |
| { |
| git_config *cfg; |
| |
| cl_set_cleanup(&clean_test_config, NULL); |
| cl_git_mkfile("./testconfig", "[unclosed \"slash\\\"]\n lib = git2\n"); |
| cl_git_fail(git_config_open_ondisk(&cfg, "./testconfig")); |
| |
| git_config_free(cfg); |
| } |
| |
| void test_config_read__invalid_key_chars(void) |
| { |
| git_config *cfg; |
| |
| cl_set_cleanup(&clean_test_config, NULL); |
| cl_git_mkfile("./testconfig", "[foo]\n has_underscore = git2\n"); |
| cl_git_fail(git_config_open_ondisk(&cfg, "./testconfig")); |
| |
| cl_git_rewritefile("./testconfig", "[foo]\n has/slash = git2\n"); |
| cl_git_fail(git_config_open_ondisk(&cfg, "./testconfig")); |
| |
| cl_git_rewritefile("./testconfig", "[foo]\n has+plus = git2\n"); |
| cl_git_fail(git_config_open_ondisk(&cfg, "./testconfig")); |
| |
| cl_git_rewritefile("./testconfig", "[no_key]\n = git2\n"); |
| cl_git_fail(git_config_open_ondisk(&cfg, "./testconfig")); |
| |
| git_config_free(cfg); |
| } |
| |
| void test_config_read__lone_variable_with_trailing_whitespace(void) |
| { |
| git_config *cfg; |
| int b; |
| |
| cl_set_cleanup(&clean_test_config, NULL); |
| cl_git_mkfile("./testconfig", "[foo]\n lonevariable \n"); |
| cl_git_pass(git_config_open_ondisk(&cfg, "./testconfig")); |
| |
| cl_git_pass(git_config_get_bool(&b, cfg, "foo.lonevariable")); |
| cl_assert_equal_b(true, b); |
| |
| git_config_free(cfg); |
| } |
| |
| void test_config_read__override_variable(void) |
| { |
| git_config *cfg; |
| |
| cl_set_cleanup(&clean_test_config, NULL); |
| cl_git_mkfile("./testconfig", "[some] var = one\nvar = two"); |
| cl_git_pass(git_config_open_ondisk(&cfg, "./testconfig")); |
| |
| cl_git_pass(git_config_get_string_buf(&buf, cfg, "some.var")); |
| cl_assert_equal_s("two", git_buf_cstr(&buf)); |
| |
| git_config_free(cfg); |
| } |
| |
| 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_free(&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_free(&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_free(&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_free(&old_path); |
| git_buf_free(&home_path); |
| git_buf_free(&expected_path); |
| git_config_free(cfg); |
| } |