rugged 0.1.2 → 0.16.0b1

data/ext/rugged/vendor/libgit2-dist/tests-clay/config/add.c

@@ -0,0 +1,37 @@
+#include "clay_libgit2.h"
+
+void test_config_add__initialize(void)
+{
+	cl_fixture_sandbox("config/config10");
+}
+
+void test_config_add__cleanup(void)
+{
+	cl_fixture_cleanup("config10");
+}
+
+void test_config_add__to_existing_section(void)
+{
+	git_config *cfg;
+	int32_t i;
+
+	cl_git_pass(git_config_open_ondisk(&cfg, "config10"));
+	cl_git_pass(git_config_set_int32(cfg, "empty.tmp", 5));
+	cl_git_pass(git_config_get_int32(cfg, "empty.tmp", &i));
+	cl_assert(i == 5);
+	cl_git_pass(git_config_delete(cfg, "empty.tmp"));
+	git_config_free(cfg);
+}
+
+void test_config_add__to_new_section(void)
+{
+	git_config *cfg;
+	int32_t i;
+
+	cl_git_pass(git_config_open_ondisk(&cfg, "config10"));
+	cl_git_pass(git_config_set_int32(cfg, "section.tmp", 5));
+	cl_git_pass(git_config_get_int32(cfg, "section.tmp", &i));
+	cl_assert(i == 5);
+	cl_git_pass(git_config_delete(cfg, "section.tmp"));
+	git_config_free(cfg);
+}

data/ext/rugged/vendor/libgit2-dist/tests-clay/config/new.c

@@ -0,0 +1,36 @@
+#include "clay_libgit2.h"
+
+#include "filebuf.h"
+#include "fileops.h"
+#include "posix.h"
+
+#define TEST_CONFIG "git-new-config"
+
+void test_config_new__write_new_config(void)
+{
+	const char *out;
+	struct git_config_file *file;
+	git_config *config;
+
+	cl_git_pass(git_config_file__ondisk(&file, TEST_CONFIG));
+	cl_git_pass(git_config_new(&config));
+	cl_git_pass(git_config_add_file(config, file, 0));
+
+	cl_git_pass(git_config_set_string(config, "color.ui", "auto"));
+	cl_git_pass(git_config_set_string(config, "core.editor", "ed"));
+
+	git_config_free(config);
+
+	cl_git_pass(git_config_file__ondisk(&file, TEST_CONFIG));
+	cl_git_pass(git_config_new(&config));
+	cl_git_pass(git_config_add_file(config, file, 0));
+
+	cl_git_pass(git_config_get_string(config, "color.ui", &out));
+	cl_assert(strcmp(out, "auto") == 0);
+	cl_git_pass(git_config_get_string(config, "core.editor", &out));
+	cl_assert(strcmp(out, "ed") == 0);
+
+	git_config_free(config);
+
+	p_unlink(TEST_CONFIG);
+}

data/ext/rugged/vendor/libgit2-dist/tests-clay/config/read.c

@@ -0,0 +1,209 @@
+#include "clay_libgit2.h"
+
+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(cfg, "core.repositoryformatversion", &i));
+	cl_assert(i == 0);
+	cl_git_pass(git_config_get_bool(cfg, "core.filemode", &i));
+	cl_assert(i == 1);
+	cl_git_pass(git_config_get_bool(cfg, "core.bare", &i));
+	cl_assert(i == 0);
+	cl_git_pass(git_config_get_bool(cfg, "core.logallrefupdates", &i));
+	cl_assert(i == 1);
+
+	git_config_free(cfg);
+}
+
+void test_config_read__case_sensitive(void)
+{
+	git_config *cfg;
+	int i;
+	const char *str;
+
+	cl_git_pass(git_config_open_ondisk(&cfg, cl_fixture("config/config1")));
+
+	cl_git_pass(git_config_get_string(cfg, "this.that.other", &str));
+	cl_assert(!strcmp(str, "true"));
+	cl_git_pass(git_config_get_string(cfg, "this.That.other", &str));
+	cl_assert(!strcmp(str, "yes"));
+
+	cl_git_pass(git_config_get_bool(cfg, "this.that.other", &i));
+	cl_assert(i == 1);
+	cl_git_pass(git_config_get_bool(cfg, "this.That.other", &i));
+	cl_assert(i == 1);
+
+	/* This one doesn't exist */
+	cl_must_fail(git_config_get_bool(cfg, "this.thaT.other", &i));
+
+	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;
+	const char *str;
+
+	cl_git_pass(git_config_open_ondisk(&cfg, cl_fixture("config/config2")));
+
+	cl_git_pass(git_config_get_string(cfg, "this.That.and", &str));
+	cl_assert(!strcmp(str, "one one one two two three three"));
+
+	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(cfg, "section.subsection.var", &str));
+	cl_assert(!strcmp(str, "hello"));
+
+	/* The subsection is transformed to lower-case */
+	cl_must_fail(git_config_get_string(cfg, "section.subSectIon.var", &str));
+
+	git_config_free(cfg);
+}
+
+void test_config_read__lone_variable(void)
+{
+	git_config *cfg;
+	const char *str;
+	int i;
+
+	cl_git_pass(git_config_open_ondisk(&cfg, cl_fixture("config/config4")));
+
+	cl_git_pass(git_config_get_string(cfg, "some.section.variable", &str));
+	cl_assert(str == NULL);
+
+	cl_git_pass(git_config_get_bool(cfg, "some.section.variable", &i));
+	cl_assert(i == 1);
+
+	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(cfg, "number.simple", &i));
+	cl_assert(i == 1);
+
+	cl_git_pass(git_config_get_int64(cfg, "number.k", &i));
+	cl_assert(i == 1 * 1024);
+
+	cl_git_pass(git_config_get_int64(cfg, "number.kk", &i));
+	cl_assert(i == 1 * 1024);
+
+	cl_git_pass(git_config_get_int64(cfg, "number.m", &i));
+	cl_assert(i == 1 * 1024 * 1024);
+
+	cl_git_pass(git_config_get_int64(cfg, "number.mm", &i));
+	cl_assert(i == 1 * 1024 * 1024);
+
+	cl_git_pass(git_config_get_int64(cfg, "number.g", &i));
+	cl_assert(i == 1 * 1024 * 1024 * 1024);
+
+	cl_git_pass(git_config_get_int64(cfg, "number.gg", &i));
+	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(cfg, "valid.subsection.something", &i));
+	cl_assert(i == 1);
+
+	cl_git_pass(git_config_get_bool(cfg, "something.else.something", &i));
+	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__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;
+	const char *str;
+
+	cl_git_pass(git_config_open_ondisk(&cfg, cl_fixture("config/config9")));
+	cl_git_pass(git_config_get_string(cfg, "remote.ab.url", &str));
+	cl_assert(strcmp(str, "http://example.com/git/ab") == 0);
+
+	cl_git_pass(git_config_get_string(cfg, "remote.abba.url", &str));
+	cl_assert(strcmp(str, "http://example.com/git/abba") == 0);
+
+	git_config_free(cfg);
+}
+
+#if 0
+
+BEGIN_TEST(config10, "a repo's config overrides the global config")
+	git_repository *repo;
+	git_config *cfg;
+	int32_t version;
+
+	cl_git_pass(git_repository_open(&repo, REPOSITORY_FOLDER));
+	cl_git_pass(git_repository_config(&cfg, repo, GLOBAL_CONFIG, NULL));
+	cl_git_pass(git_config_get_int32(cfg, "core.repositoryformatversion", &version));
+	cl_assert(version == 0);
+	git_config_free(cfg);
+	git_repository_free(repo);
+END_TEST
+
+BEGIN_TEST(config11, "fall back to the global config")
+	git_repository *repo;
+	git_config *cfg;
+	int32_t num;
+
+	cl_git_pass(git_repository_open(&repo, REPOSITORY_FOLDER));
+	cl_git_pass(git_repository_config(&cfg, repo, GLOBAL_CONFIG, NULL));
+	cl_git_pass(git_config_get_int32(cfg, "core.something", &num));
+	cl_assert(num == 2);
+	git_config_free(cfg);
+	git_repository_free(repo);
+END_TEST
+#endif

data/ext/rugged/vendor/libgit2-dist/tests-clay/config/stress.c

@@ -0,0 +1,39 @@
+#include "clay_libgit2.h"
+
+#include "filebuf.h"
+#include "fileops.h"
+#include "posix.h"
+
+void test_config_stress__initialize(void)
+{
+	git_filebuf file = GIT_FILEBUF_INIT;
+
+	cl_git_pass(git_filebuf_open(&file, "git-test-config", 0));
+
+	git_filebuf_printf(&file, "[color]\n\tui = auto\n");
+	git_filebuf_printf(&file, "[core]\n\teditor = \n");
+
+	cl_git_pass(git_filebuf_commit(&file, 0666));
+}
+
+void test_config_stress__cleanup(void)
+{
+	p_unlink("git-test-config");
+}
+
+void test_config_stress__dont_break_on_invalid_input(void)
+{
+	const char *editor, *color;
+	struct git_config_file *file;
+	git_config *config;
+
+	cl_git_pass(git_futils_exists("git-test-config"));
+	cl_git_pass(git_config_file__ondisk(&file, "git-test-config"));
+	cl_git_pass(git_config_new(&config));
+	cl_git_pass(git_config_add_file(config, file, 0));
+
+	cl_git_pass(git_config_get_string(config, "color.ui", &color));
+	cl_git_pass(git_config_get_string(config, "core.editor", &editor));
+
+	git_config_free(config);
+}

data/ext/rugged/vendor/libgit2-dist/tests-clay/config/write.c

@@ -0,0 +1,77 @@
+#include "clay_libgit2.h"
+
+void test_config_write__initialize(void)
+{
+	cl_fixture_sandbox("config/config9");
+}
+
+void test_config_write__cleanup(void)
+{
+	cl_fixture_cleanup("config9");
+}
+
+void test_config_write__replace_value(void)
+{
+	git_config *cfg;
+	int i;
+	int64_t l, expected = +9223372036854775803;
+
+	/* By freeing the config, we make sure we flush the values  */
+	cl_git_pass(git_config_open_ondisk(&cfg, "config9"));
+	cl_git_pass(git_config_set_int32(cfg, "core.dummy", 5));
+	git_config_free(cfg);
+
+	cl_git_pass(git_config_open_ondisk(&cfg, "config9"));
+	cl_git_pass(git_config_get_int32(cfg, "core.dummy", &i));
+	cl_assert(i == 5);
+	git_config_free(cfg);
+
+	cl_git_pass(git_config_open_ondisk(&cfg, "config9"));
+	cl_git_pass(git_config_set_int32(cfg, "core.dummy", 1));
+	git_config_free(cfg);
+
+	cl_git_pass(git_config_open_ondisk(&cfg, "config9"));
+	cl_git_pass(git_config_set_int64(cfg, "core.verylong", expected));
+	git_config_free(cfg);
+
+	cl_git_pass(git_config_open_ondisk(&cfg, "config9"));
+	cl_git_pass(git_config_get_int64(cfg, "core.verylong", &l));
+	cl_assert(l == expected);
+	git_config_free(cfg);
+
+	cl_git_pass(git_config_open_ondisk(&cfg, "config9"));
+	cl_must_fail(git_config_get_int32(cfg, "core.verylong", &i));
+	git_config_free(cfg);
+
+	cl_git_pass(git_config_open_ondisk(&cfg, "config9"));
+	cl_git_pass(git_config_set_int64(cfg, "core.verylong", 1));
+	git_config_free(cfg);
+}
+
+void test_config_write__delete_value(void)
+{
+	git_config *cfg;
+	int32_t i;
+
+	cl_git_pass(git_config_open_ondisk(&cfg, "config9"));
+	cl_git_pass(git_config_set_int32(cfg, "core.dummy", 5));
+	git_config_free(cfg);
+
+	cl_git_pass(git_config_open_ondisk(&cfg, "config9"));
+	cl_git_pass(git_config_delete(cfg, "core.dummy"));
+	git_config_free(cfg);
+
+	cl_git_pass(git_config_open_ondisk(&cfg, "config9"));
+	cl_assert(git_config_get_int32(cfg, "core.dummy", &i) == GIT_ENOTFOUND);
+	cl_git_pass(git_config_set_int32(cfg, "core.dummy", 1));
+	git_config_free(cfg);
+}
+
+void test_config_write__delete_inexistent(void)
+{
+	git_config *cfg;
+
+	cl_git_pass(git_config_open_ondisk(&cfg, "config9"));
+	cl_assert(git_config_delete(cfg, "core.imaginary") == GIT_ENOTFOUND);
+	git_config_free(cfg);
+}

data/ext/rugged/vendor/libgit2-dist/tests-clay/core/dirent.c

@@ -0,0 +1,222 @@
+#include "clay_libgit2.h"
+#include "fileops.h"
+
+typedef struct name_data {
+	int count; /* return count */
+	char *name; /* filename		*/
+} name_data;
+
+typedef struct walk_data {
+	char *sub;		/* sub-directory name */
+	name_data *names; /* name state data	*/
+} walk_data;
+
+
+static char path_buffer[GIT_PATH_MAX];
+static char *top_dir = "dir-walk";
+static walk_data *state_loc;
+
+static void setup(walk_data *d)
+{
+	name_data *n;
+
+	cl_must_pass(p_mkdir(top_dir, 0777));
+
+	cl_must_pass(p_chdir(top_dir));
+
+	if (strcmp(d->sub, ".") != 0)
+		cl_must_pass(p_mkdir(d->sub, 0777));
+
+	strcpy(path_buffer, d->sub);
+	state_loc = d;
+
+	for (n = d->names; n->name; n++) {
+		git_file fd = p_creat(n->name, 0666);
+		cl_assert(fd >= 0);
+		p_close(fd);
+		n->count = 0;
+	}
+}
+
+static void dirent_cleanup__cb(void *_d)
+{
+	walk_data *d = _d;
+	name_data *n;
+
+	for (n = d->names; n->name; n++) {
+		cl_must_pass(p_unlink(n->name));
+	}
+
+	if (strcmp(d->sub, ".") != 0)
+		cl_must_pass(p_rmdir(d->sub));
+
+	cl_must_pass(p_chdir(".."));
+
+	cl_must_pass(p_rmdir(top_dir));
+}
+
+static void check_counts(walk_data *d)
+{
+	name_data *n;
+
+	for (n = d->names; n->name; n++) {
+		cl_assert(n->count == 1);
+	}
+}
+
+static int one_entry(void *state, char *path)
+{
+	walk_data *d = (walk_data *) state;
+	name_data *n;
+
+	if (state != state_loc)
+		return GIT_ERROR;
+
+	if (path != path_buffer)
+		return GIT_ERROR;
+
+	for (n = d->names; n->name; n++) {
+		if (!strcmp(n->name, path)) {
+			n->count++;
+			return 0;
+		}
+	}
+
+	return GIT_ERROR;
+}
+
+static int dont_call_me(void *GIT_UNUSED(state), char *GIT_UNUSED(path))
+{
+	GIT_UNUSED_ARG(state)
+	GIT_UNUSED_ARG(path)
+	return GIT_ERROR;
+}
+
+
+
+static name_data dot_names[] = {
+	{ 0, "./a" },
+	{ 0, "./asdf" },
+	{ 0, "./pack-foo.pack" },
+	{ 0, NULL }
+};
+static walk_data dot = {
+	".",
+	dot_names
+};
+
+/* make sure that the '.' folder is not traversed */
+void test_core_dirent__dont_traverse_dot(void)
+{
+	cl_set_cleanup(&dirent_cleanup__cb, &dot);
+	setup(&dot);
+
+	cl_git_pass(git_futils_direach(path_buffer,
+					sizeof(path_buffer),
+					one_entry,
+					&dot));
+
+	check_counts(&dot);
+}
+
+
+static name_data sub_names[] = {
+	{ 0, "sub/a" },
+	{ 0, "sub/asdf" },
+	{ 0, "sub/pack-foo.pack" },
+	{ 0, NULL }
+};
+static walk_data sub = {
+	"sub",
+	sub_names
+};
+
+/* traverse a subfolder */
+void test_core_dirent__traverse_subfolder(void)
+{
+	cl_set_cleanup(&dirent_cleanup__cb, &sub);
+	setup(&sub);
+
+	cl_git_pass(git_futils_direach(path_buffer,
+					sizeof(path_buffer),
+					one_entry,
+					&sub));
+
+	check_counts(&sub);
+}
+
+
+static walk_data sub_slash = {
+	"sub/",
+	sub_names
+};
+
+/* traverse a slash-terminated subfolder */
+void test_core_dirent__traverse_slash_terminated_folder(void)
+{
+	cl_set_cleanup(&dirent_cleanup__cb, &sub_slash);
+	setup(&sub_slash);
+
+	cl_git_pass(git_futils_direach(path_buffer,
+					sizeof(path_buffer),
+					one_entry,
+					&sub_slash));
+
+	check_counts(&sub_slash);
+}
+
+
+static name_data empty_names[] = {
+	{ 0, NULL }
+};
+static walk_data empty = {
+	"empty",
+	empty_names
+};
+
+/* make sure that empty folders are not traversed */
+void test_core_dirent__dont_traverse_empty_folders(void)
+{
+	cl_set_cleanup(&dirent_cleanup__cb, &empty);
+	setup(&empty);
+
+	cl_git_pass(git_futils_direach(path_buffer,
+					sizeof(path_buffer),
+					one_entry,
+					&empty));
+
+	check_counts(&empty);
+
+	/* make sure callback not called */
+	cl_git_pass(git_futils_direach(path_buffer,
+					sizeof(path_buffer),
+					dont_call_me,
+					&empty));
+}
+
+static name_data odd_names[] = {
+	{ 0, "odd/.a" },
+	{ 0, "odd/..c" },
+	/* the following don't work on cygwin/win32 */
+	/* { 0, "odd/.b." }, */
+	/* { 0, "odd/..d.." }, */
+	{ 0, NULL }
+};
+static walk_data odd = {
+	"odd",
+	odd_names
+};
+
+/* make sure that strange looking filenames ('..c') are traversed */
+void test_core_dirent__traverse_weird_filenames(void)
+{
+	cl_set_cleanup(&dirent_cleanup__cb, &odd);
+	setup(&odd);
+
+	cl_git_pass(git_futils_direach(path_buffer,
+					sizeof(path_buffer),
+					one_entry,
+					&odd));
+
+	check_counts(&odd);
+}