rugged 0.16.0 → 0.17.0b1

data/ext/rugged/vendor/libgit2-dist/tests-clar/attr/file.c

@@ -0,0 +1,226 @@
+#include "clar_libgit2.h"
+#include "attr_file.h"
+#include "attr_expect.h"
+
+#define get_rule(X) ((git_attr_rule *)git_vector_get(&file->rules,(X)))
+#define get_assign(R,Y) ((git_attr_assignment *)git_vector_get(&(R)->assigns,(Y)))
+
+void test_attr_file__simple_read(void)
+{
+	git_attr_file *file;
+	git_attr_assignment *assign;
+	git_attr_rule *rule;
+
+	cl_git_pass(git_attr_file__new_and_load(&file, cl_fixture("attr/attr0")));
+
+	cl_assert_equal_s(cl_fixture("attr/attr0"), file->key + 2);
+	cl_assert(file->rules.length == 1);
+
+	rule = get_rule(0);
+	cl_assert(rule != NULL);
+	cl_assert_equal_s("*", rule->match.pattern);
+	cl_assert(rule->match.length == 1);
+	cl_assert((rule->match.flags & GIT_ATTR_FNMATCH_HASWILD) != 0);
+
+	cl_assert(rule->assigns.length == 1);
+	assign = get_assign(rule, 0);
+	cl_assert(assign != NULL);
+	cl_assert_equal_s("binary", assign->name);
+	cl_assert(GIT_ATTR_TRUE(assign->value));
+
+	git_attr_file__free(file);
+}
+
+void test_attr_file__match_variants(void)
+{
+	git_attr_file *file;
+	git_attr_rule *rule;
+	git_attr_assignment *assign;
+
+	cl_git_pass(git_attr_file__new_and_load(&file, cl_fixture("attr/attr1")));
+
+	cl_assert_equal_s(cl_fixture("attr/attr1"), file->key + 2);
+	cl_assert(file->rules.length == 10);
+
+	/* let's do a thorough check of this rule, then just verify
+	 * the things that are unique for the later rules
+	 */
+	rule = get_rule(0);
+	cl_assert(rule);
+	cl_assert_equal_s("pat0", rule->match.pattern);
+	cl_assert(rule->match.length == strlen("pat0"));
+	cl_assert(rule->match.flags == 0);
+	cl_assert(rule->assigns.length == 1);
+	assign = get_assign(rule,0);
+	cl_assert_equal_s("attr0", assign->name);
+	cl_assert(assign->name_hash == git_attr_file__name_hash(assign->name));
+	cl_assert(GIT_ATTR_TRUE(assign->value));
+
+	rule = get_rule(1);
+	cl_assert_equal_s("pat1", rule->match.pattern);
+	cl_assert(rule->match.length == strlen("pat1"));
+	cl_assert(rule->match.flags == GIT_ATTR_FNMATCH_NEGATIVE);
+
+	rule = get_rule(2);
+	cl_assert_equal_s("pat2", rule->match.pattern);
+	cl_assert(rule->match.length == strlen("pat2"));
+	cl_assert(rule->match.flags == GIT_ATTR_FNMATCH_DIRECTORY);
+
+	rule = get_rule(3);
+	cl_assert_equal_s("pat3dir/pat3file", rule->match.pattern);
+	cl_assert(rule->match.flags == GIT_ATTR_FNMATCH_FULLPATH);
+
+	rule = get_rule(4);
+	cl_assert_equal_s("pat4.*", rule->match.pattern);
+	cl_assert((rule->match.flags & GIT_ATTR_FNMATCH_HASWILD) != 0);
+
+	rule = get_rule(5);
+	cl_assert_equal_s("*.pat5", rule->match.pattern);
+	cl_assert((rule->match.flags & GIT_ATTR_FNMATCH_HASWILD) != 0);
+
+	rule = get_rule(7);
+	cl_assert_equal_s("pat7[a-e]??[xyz]", rule->match.pattern);
+	cl_assert(rule->assigns.length == 1);
+	cl_assert((rule->match.flags & GIT_ATTR_FNMATCH_HASWILD) != 0);
+	assign = get_assign(rule,0);
+	cl_assert_equal_s("attr7", assign->name);
+	cl_assert(GIT_ATTR_TRUE(assign->value));
+
+	rule = get_rule(8);
+	cl_assert_equal_s("pat8 with spaces", rule->match.pattern);
+	cl_assert(rule->match.length == strlen("pat8 with spaces"));
+	cl_assert(rule->match.flags == 0);
+
+	rule = get_rule(9);
+	cl_assert_equal_s("pat9", rule->match.pattern);
+
+	git_attr_file__free(file);
+}
+
+static void check_one_assign(
+	git_attr_file *file,
+	int rule_idx,
+	int assign_idx,
+	const char *pattern,
+	const char *name,
+	enum attr_expect_t expected,
+	const char *expected_str)
+{
+	git_attr_rule *rule = get_rule(rule_idx);
+	git_attr_assignment *assign = get_assign(rule, assign_idx);
+
+	cl_assert_equal_s(pattern, rule->match.pattern);
+	cl_assert(rule->assigns.length == 1);
+	cl_assert_equal_s(name, assign->name);
+	cl_assert(assign->name_hash == git_attr_file__name_hash(assign->name));
+
+	attr_check_expected(expected, expected_str, assign->name, assign->value);
+}
+
+void test_attr_file__assign_variants(void)
+{
+	git_attr_file *file;
+	git_attr_rule *rule;
+	git_attr_assignment *assign;
+
+	cl_git_pass(git_attr_file__new_and_load(&file, cl_fixture("attr/attr2")));
+
+	cl_assert_equal_s(cl_fixture("attr/attr2"), file->key + 2);
+	cl_assert(file->rules.length == 11);
+
+	check_one_assign(file, 0, 0, "pat0", "simple", EXPECT_TRUE, NULL);
+	check_one_assign(file, 1, 0, "pat1", "neg", EXPECT_FALSE, NULL);
+	check_one_assign(file, 2, 0, "*", "notundef", EXPECT_TRUE, NULL);
+	check_one_assign(file, 3, 0, "pat2", "notundef", EXPECT_UNDEFINED, NULL);
+	check_one_assign(file, 4, 0, "pat3", "assigned", EXPECT_STRING, "test-value");
+	check_one_assign(file, 5, 0, "pat4", "rule-with-more-chars", EXPECT_STRING, "value-with-more-chars");
+	check_one_assign(file, 6, 0, "pat5", "empty", EXPECT_TRUE, NULL);
+	check_one_assign(file, 7, 0, "pat6", "negempty", EXPECT_FALSE, NULL);
+
+	rule = get_rule(8);
+	cl_assert_equal_s("pat7", rule->match.pattern);
+	cl_assert(rule->assigns.length == 5);
+	/* assignments will be sorted by hash value, so we have to do
+	 * lookups by search instead of by position
+	 */
+	assign = git_attr_rule__lookup_assignment(rule, "multiple");
+	cl_assert(assign);
+	cl_assert_equal_s("multiple", assign->name);
+	cl_assert(GIT_ATTR_TRUE(assign->value));
+	assign = git_attr_rule__lookup_assignment(rule, "single");
+	cl_assert(assign);
+	cl_assert_equal_s("single", assign->name);
+	cl_assert(GIT_ATTR_FALSE(assign->value));
+	assign = git_attr_rule__lookup_assignment(rule, "values");
+	cl_assert(assign);
+	cl_assert_equal_s("values", assign->name);
+	cl_assert_equal_s("1", assign->value);
+	assign = git_attr_rule__lookup_assignment(rule, "also");
+	cl_assert(assign);
+	cl_assert_equal_s("also", assign->name);
+	cl_assert_equal_s("a-really-long-value/*", assign->value);
+	assign = git_attr_rule__lookup_assignment(rule, "happy");
+	cl_assert(assign);
+	cl_assert_equal_s("happy", assign->name);
+	cl_assert_equal_s("yes!", assign->value);
+	assign = git_attr_rule__lookup_assignment(rule, "other");
+	cl_assert(!assign);
+
+	rule = get_rule(9);
+	cl_assert_equal_s("pat8", rule->match.pattern);
+	cl_assert(rule->assigns.length == 2);
+	assign = git_attr_rule__lookup_assignment(rule, "again");
+	cl_assert(assign);
+	cl_assert_equal_s("again", assign->name);
+	cl_assert(GIT_ATTR_TRUE(assign->value));
+	assign = git_attr_rule__lookup_assignment(rule, "another");
+	cl_assert(assign);
+	cl_assert_equal_s("another", assign->name);
+	cl_assert_equal_s("12321", assign->value);
+
+	check_one_assign(file, 10, 0, "pat9", "at-eof", EXPECT_FALSE, NULL);
+
+	git_attr_file__free(file);
+}
+
+void test_attr_file__check_attr_examples(void)
+{
+	git_attr_file *file;
+	git_attr_rule *rule;
+	git_attr_assignment *assign;
+
+	cl_git_pass(git_attr_file__new_and_load(&file, cl_fixture("attr/attr3")));
+	cl_assert_equal_s(cl_fixture("attr/attr3"), file->key + 2);
+	cl_assert(file->rules.length == 3);
+
+	rule = get_rule(0);
+	cl_assert_equal_s("*.java", rule->match.pattern);
+	cl_assert(rule->assigns.length == 3);
+	assign = git_attr_rule__lookup_assignment(rule, "diff");
+	cl_assert_equal_s("diff", assign->name);
+	cl_assert_equal_s("java", assign->value);
+	assign = git_attr_rule__lookup_assignment(rule, "crlf");
+	cl_assert_equal_s("crlf", assign->name);
+	cl_assert(GIT_ATTR_FALSE(assign->value));
+	assign = git_attr_rule__lookup_assignment(rule, "myAttr");
+	cl_assert_equal_s("myAttr", assign->name);
+	cl_assert(GIT_ATTR_TRUE(assign->value));
+	assign = git_attr_rule__lookup_assignment(rule, "missing");
+	cl_assert(assign == NULL);
+
+	rule = get_rule(1);
+	cl_assert_equal_s("NoMyAttr.java", rule->match.pattern);
+	cl_assert(rule->assigns.length == 1);
+	assign = get_assign(rule, 0);
+	cl_assert_equal_s("myAttr", assign->name);
+	cl_assert(GIT_ATTR_UNSPECIFIED(assign->value));
+
+	rule = get_rule(2);
+	cl_assert_equal_s("README", rule->match.pattern);
+	cl_assert(rule->assigns.length == 1);
+	assign = get_assign(rule, 0);
+	cl_assert_equal_s("caveat", assign->name);
+	cl_assert_equal_s("unspecified", assign->value);
+
+	git_attr_file__free(file);
+}

data/ext/rugged/vendor/libgit2-dist/tests-clar/attr/flags.c

@@ -0,0 +1,108 @@
+#include "clar_libgit2.h"
+#include "git2/attr.h"
+
+void test_attr_flags__cleanup(void)
+{
+	cl_git_sandbox_cleanup();
+}
+
+void test_attr_flags__bare(void)
+{
+	git_repository *repo = cl_git_sandbox_init("testrepo.git");
+	const char *value;
+
+	cl_assert(git_repository_is_bare(repo));
+
+	cl_git_pass(git_attr_get(
+		&value, repo, GIT_ATTR_CHECK_NO_SYSTEM, "README.md", "diff"));
+	cl_assert(GIT_ATTR_UNSPECIFIED(value));
+}
+
+void test_attr_flags__index_vs_workdir(void)
+{
+	git_repository *repo = cl_git_sandbox_init("attr_index");
+	const char *value;
+
+	cl_assert(!git_repository_is_bare(repo));
+
+	/* wd then index */
+	cl_git_pass(git_attr_get(
+		&value, repo, GIT_ATTR_CHECK_NO_SYSTEM | GIT_ATTR_CHECK_FILE_THEN_INDEX,
+		"README.md", "bar"));
+	cl_assert(GIT_ATTR_FALSE(value));
+
+	cl_git_pass(git_attr_get(
+		&value, repo, GIT_ATTR_CHECK_NO_SYSTEM | GIT_ATTR_CHECK_FILE_THEN_INDEX,
+		"README.md", "blargh"));
+	cl_assert_equal_s(value, "goop");
+
+	cl_git_pass(git_attr_get(
+		&value, repo, GIT_ATTR_CHECK_NO_SYSTEM | GIT_ATTR_CHECK_FILE_THEN_INDEX,
+		"README.txt", "foo"));
+	cl_assert(GIT_ATTR_FALSE(value));
+
+	/* index then wd */
+	cl_git_pass(git_attr_get(
+		&value, repo, GIT_ATTR_CHECK_NO_SYSTEM | GIT_ATTR_CHECK_INDEX_THEN_FILE,
+		"README.md", "bar"));
+	cl_assert(GIT_ATTR_TRUE(value));
+
+	cl_git_pass(git_attr_get(
+		&value, repo, GIT_ATTR_CHECK_NO_SYSTEM | GIT_ATTR_CHECK_INDEX_THEN_FILE,
+		"README.md", "blargh"));
+	cl_assert_equal_s(value, "garble");
+
+	cl_git_pass(git_attr_get(
+		&value, repo, GIT_ATTR_CHECK_NO_SYSTEM | GIT_ATTR_CHECK_INDEX_THEN_FILE,
+		"README.txt", "foo"));
+	cl_assert(GIT_ATTR_TRUE(value));
+}
+
+void test_attr_flags__subdir(void)
+{
+	git_repository *repo = cl_git_sandbox_init("attr_index");
+	const char *value;
+
+	/* wd then index */
+	cl_git_pass(git_attr_get(
+		&value, repo, GIT_ATTR_CHECK_NO_SYSTEM | GIT_ATTR_CHECK_FILE_THEN_INDEX,
+		"sub/sub/README.md", "bar"));
+	cl_assert_equal_s(value, "1234");
+
+	cl_git_pass(git_attr_get(
+		&value, repo, GIT_ATTR_CHECK_NO_SYSTEM | GIT_ATTR_CHECK_FILE_THEN_INDEX,
+		"sub/sub/README.txt", "another"));
+	cl_assert_equal_s(value, "one");
+
+	cl_git_pass(git_attr_get(
+		&value, repo, GIT_ATTR_CHECK_NO_SYSTEM | GIT_ATTR_CHECK_FILE_THEN_INDEX,
+		"sub/sub/README.txt", "again"));
+	cl_assert(GIT_ATTR_TRUE(value));
+
+	cl_git_pass(git_attr_get(
+		&value, repo, GIT_ATTR_CHECK_NO_SYSTEM | GIT_ATTR_CHECK_FILE_THEN_INDEX,
+		"sub/sub/README.txt", "beep"));
+	cl_assert_equal_s(value, "10");
+
+	/* index then wd */
+	cl_git_pass(git_attr_get(
+		&value, repo, GIT_ATTR_CHECK_NO_SYSTEM | GIT_ATTR_CHECK_INDEX_THEN_FILE,
+		"sub/sub/README.md", "bar"));
+	cl_assert_equal_s(value, "1337");
+
+	cl_git_pass(git_attr_get(
+		&value, repo, GIT_ATTR_CHECK_NO_SYSTEM | GIT_ATTR_CHECK_INDEX_THEN_FILE,
+		"sub/sub/README.txt", "another"));
+	cl_assert_equal_s(value, "one");
+
+	cl_git_pass(git_attr_get(
+		&value, repo, GIT_ATTR_CHECK_NO_SYSTEM | GIT_ATTR_CHECK_INDEX_THEN_FILE,
+		"sub/sub/README.txt", "again"));
+	cl_assert(GIT_ATTR_TRUE(value));
+
+	cl_git_pass(git_attr_get(
+		&value, repo, GIT_ATTR_CHECK_NO_SYSTEM | GIT_ATTR_CHECK_INDEX_THEN_FILE,
+		"sub/sub/README.txt", "beep"));
+	cl_assert_equal_s(value, "5");
+}
+

data/ext/rugged/vendor/libgit2-dist/tests-clar/attr/lookup.c

@@ -0,0 +1,262 @@
+#include "clar_libgit2.h"
+#include "attr_file.h"
+
+#include "attr_expect.h"
+
+void test_attr_lookup__simple(void)
+{
+	git_attr_file *file;
+	git_attr_path path;
+	const char *value = NULL;
+
+	cl_git_pass(git_attr_file__new_and_load(&file, cl_fixture("attr/attr0")));
+	cl_assert_equal_s(cl_fixture("attr/attr0"), file->key + 2);
+	cl_assert(file->rules.length == 1);
+
+	cl_git_pass(git_attr_path__init(&path, "test", NULL));
+	cl_assert_equal_s("test", path.path);
+	cl_assert_equal_s("test", path.basename);
+	cl_assert(!path.is_dir);
+
+	cl_git_pass(git_attr_file__lookup_one(file,&path,"binary",&value));
+	cl_assert(GIT_ATTR_TRUE(value));
+
+	cl_git_pass(git_attr_file__lookup_one(file,&path,"missing",&value));
+	cl_assert(!value);
+
+	git_attr_path__free(&path);
+	git_attr_file__free(file);
+}
+
+static void run_test_cases(git_attr_file *file, struct attr_expected *cases, int force_dir)
+{
+	git_attr_path path;
+	const char *value = NULL;
+	struct attr_expected *c;
+	int error;
+
+	for (c = cases; c->path != NULL; c++) {
+		cl_git_pass(git_attr_path__init(&path, c->path, NULL));
+
+		if (force_dir)
+			path.is_dir = 1;
+
+		error = git_attr_file__lookup_one(file,&path,c->attr,&value);
+		cl_git_pass(error);
+
+		attr_check_expected(c->expected, c->expected_str, c->attr, value);
+
+		git_attr_path__free(&path);
+	}
+}
+
+void test_attr_lookup__match_variants(void)
+{
+	git_attr_file *file;
+	git_attr_path path;
+
+	struct attr_expected dir_cases[] = {
+		{ "pat2", "attr2", EXPECT_TRUE, NULL },
+		{ "/testing/for/pat2", "attr2", EXPECT_TRUE, NULL },
+		{ "/not/pat2/yousee", "attr2", EXPECT_UNDEFINED, NULL },
+		{ "/fun/fun/fun/pat4.dir", "attr4", EXPECT_TRUE, NULL },
+		{ "foo.pat5", "attr5", EXPECT_TRUE, NULL },
+		{ NULL, NULL, 0, NULL }
+	};
+
+	struct attr_expected cases[] = {
+		/* pat0 -> simple match */
+		{ "pat0", "attr0", EXPECT_TRUE, NULL },
+		{ "/testing/for/pat0", "attr0", EXPECT_TRUE, NULL },
+		{ "relative/to/pat0", "attr0", EXPECT_TRUE, NULL },
+		{ "this-contains-pat0-inside", "attr0", EXPECT_UNDEFINED, NULL },
+		{ "this-aint-right", "attr0", EXPECT_UNDEFINED, NULL },
+		{ "/this/pat0/dont/match", "attr0", EXPECT_UNDEFINED, NULL },
+		/* negative match */
+		{ "pat0", "attr1", EXPECT_TRUE, NULL },
+		{ "pat1", "attr1", EXPECT_UNDEFINED, NULL },
+		{ "/testing/for/pat1", "attr1", EXPECT_UNDEFINED, NULL },
+		{ "/testing/for/pat0", "attr1", EXPECT_TRUE, NULL },
+		{ "/testing/for/pat1/inside", "attr1", EXPECT_TRUE, NULL },
+		{ "misc", "attr1", EXPECT_TRUE, NULL },
+		/* dir match */
+		{ "pat2", "attr2", EXPECT_UNDEFINED, NULL },
+		{ "/testing/for/pat2", "attr2", EXPECT_UNDEFINED, NULL },
+		{ "/not/pat2/yousee", "attr2", EXPECT_UNDEFINED, NULL },
+		/* path match */
+		{ "pat3file", "attr3", EXPECT_UNDEFINED, NULL },
+		{ "/pat3dir/pat3file", "attr3", EXPECT_TRUE, NULL },
+		{ "pat3dir/pat3file", "attr3", EXPECT_TRUE, NULL },
+		/* pattern* match */
+		{ "pat4.txt", "attr4", EXPECT_TRUE, NULL },
+		{ "/fun/fun/fun/pat4.c", "attr4", EXPECT_TRUE, NULL },
+		{ "pat4.", "attr4", EXPECT_TRUE, NULL },
+		{ "pat4", "attr4", EXPECT_UNDEFINED, NULL },
+		/* *pattern match */
+		{ "foo.pat5", "attr5", EXPECT_TRUE, NULL },
+		{ "/this/is/ok.pat5", "attr5", EXPECT_TRUE, NULL },
+		{ "/this/is/bad.pat5/yousee.txt", "attr5", EXPECT_UNDEFINED, NULL },
+		{ "foo.pat5", "attr100", EXPECT_UNDEFINED, NULL },
+		/* glob match with slashes */
+		{ "foo.pat6", "attr6", EXPECT_UNDEFINED, NULL },
+		{ "pat6/pat6/foobar.pat6", "attr6", EXPECT_TRUE, NULL },
+		{ "pat6/pat6/.pat6", "attr6", EXPECT_TRUE, NULL },
+		{ "pat6/pat6/extra/foobar.pat6", "attr6", EXPECT_UNDEFINED, NULL },
+		{ "/prefix/pat6/pat6/foobar.pat6", "attr6", EXPECT_UNDEFINED, NULL },
+		{ "/pat6/pat6/foobar.pat6", "attr6", EXPECT_TRUE, NULL },
+		/* complex pattern */
+		{ "pat7a12z", "attr7", EXPECT_TRUE, NULL },
+		{ "pat7e__x", "attr7", EXPECT_TRUE, NULL },
+		{ "pat7b/1y", "attr7", EXPECT_UNDEFINED, NULL }, /* ? does not match / */
+		{ "pat7e_x", "attr7", EXPECT_UNDEFINED, NULL },
+		{ "pat7aaaa", "attr7", EXPECT_UNDEFINED, NULL },
+		{ "pat7zzzz", "attr7", EXPECT_UNDEFINED, NULL },
+		{ "/this/can/be/anything/pat7a12z", "attr7", EXPECT_TRUE, NULL },
+		{ "but/it/still/must/match/pat7aaaa", "attr7", EXPECT_UNDEFINED, NULL },
+		{ "pat7aaay.fail", "attr7", EXPECT_UNDEFINED, NULL },
+		/* pattern with spaces */
+		{ "pat8 with spaces", "attr8", EXPECT_TRUE, NULL },
+		{ "/gotta love/pat8 with spaces", "attr8", EXPECT_TRUE, NULL },
+		{ "failing pat8 with spaces", "attr8", EXPECT_UNDEFINED, NULL },
+		{ "spaces", "attr8", EXPECT_UNDEFINED, NULL },
+		/* pattern at eof */
+		{ "pat9", "attr9", EXPECT_TRUE, NULL },
+		{ "/eof/pat9", "attr9", EXPECT_TRUE, NULL },
+		{ "pat", "attr9", EXPECT_UNDEFINED, NULL },
+		{ "at9", "attr9", EXPECT_UNDEFINED, NULL },
+		{ "pat9.fail", "attr9", EXPECT_UNDEFINED, NULL },
+		/* sentinel at end */
+		{ NULL, NULL, 0, NULL }
+	};
+
+	cl_git_pass(git_attr_file__new_and_load(&file, cl_fixture("attr/attr1")));
+	cl_assert_equal_s(cl_fixture("attr/attr1"), file->key + 2);
+	cl_assert(file->rules.length == 10);
+
+	cl_git_pass(git_attr_path__init(&path, "/testing/for/pat0", NULL));
+	cl_assert_equal_s("pat0", path.basename);
+
+	run_test_cases(file, cases, 0);
+	run_test_cases(file, dir_cases, 1);
+
+	git_attr_file__free(file);
+	git_attr_path__free(&path);
+}
+
+void test_attr_lookup__assign_variants(void)
+{
+	git_attr_file *file;
+
+	struct attr_expected cases[] = {
+		/* pat0 -> simple assign */
+		{ "pat0", "simple", EXPECT_TRUE, NULL },
+		{ "/testing/pat0", "simple", EXPECT_TRUE, NULL },
+		{ "pat0", "fail", EXPECT_UNDEFINED, NULL },
+		{ "/testing/pat0", "fail", EXPECT_UNDEFINED, NULL },
+		/* negative assign */
+		{ "pat1", "neg", EXPECT_FALSE, NULL },
+		{ "/testing/pat1", "neg", EXPECT_FALSE, NULL },
+		{ "pat1", "fail", EXPECT_UNDEFINED, NULL },
+		{ "/testing/pat1", "fail", EXPECT_UNDEFINED, NULL },
+		/* forced undef */
+		{ "pat1", "notundef", EXPECT_TRUE, NULL },
+		{ "pat2", "notundef", EXPECT_UNDEFINED, NULL },
+		{ "/lead/in/pat1", "notundef", EXPECT_TRUE, NULL },
+		{ "/lead/in/pat2", "notundef", EXPECT_UNDEFINED, NULL },
+		/* assign value */
+		{ "pat3", "assigned", EXPECT_STRING, "test-value" },
+		{ "pat3", "notassigned", EXPECT_UNDEFINED, NULL },
+		/* assign value */
+		{ "pat4", "rule-with-more-chars", EXPECT_STRING, "value-with-more-chars" },
+		{ "pat4", "notassigned-rule-with-more-chars", EXPECT_UNDEFINED, NULL },
+		/* empty assignments */
+		{ "pat5", "empty", EXPECT_TRUE, NULL },
+		{ "pat6", "negempty", EXPECT_FALSE, NULL },
+		/* multiple assignment */
+		{ "pat7", "multiple", EXPECT_TRUE, NULL },
+		{ "pat7", "single", EXPECT_FALSE, NULL },
+		{ "pat7", "values", EXPECT_STRING, "1" },
+		{ "pat7", "also", EXPECT_STRING, "a-really-long-value/*" },
+		{ "pat7", "happy", EXPECT_STRING, "yes!" },
+		{ "pat8", "again", EXPECT_TRUE, NULL },
+		{ "pat8", "another", EXPECT_STRING, "12321" },
+		/* bad assignment */
+		{ "patbad0", "simple", EXPECT_UNDEFINED, NULL },
+		{ "patbad0", "notundef", EXPECT_TRUE, NULL },
+		{ "patbad1", "simple", EXPECT_UNDEFINED, NULL },
+		/* eof assignment */
+		{ "pat9", "at-eof", EXPECT_FALSE, NULL },
+		/* sentinel at end */
+		{ NULL, NULL, 0, NULL }
+	};
+
+	cl_git_pass(git_attr_file__new_and_load(&file, cl_fixture("attr/attr2")));
+	cl_assert(file->rules.length == 11);
+
+	run_test_cases(file, cases, 0);
+
+	git_attr_file__free(file);
+}
+
+void test_attr_lookup__check_attr_examples(void)
+{
+	git_attr_file *file;
+
+	struct attr_expected cases[] = {
+		{ "foo.java", "diff", EXPECT_STRING, "java" },
+		{ "foo.java", "crlf", EXPECT_FALSE, NULL },
+		{ "foo.java", "myAttr", EXPECT_TRUE, NULL },
+		{ "foo.java", "other", EXPECT_UNDEFINED, NULL },
+		{ "/prefix/dir/foo.java", "diff", EXPECT_STRING, "java" },
+		{ "/prefix/dir/foo.java", "crlf", EXPECT_FALSE, NULL },
+		{ "/prefix/dir/foo.java", "myAttr", EXPECT_TRUE, NULL },
+		{ "/prefix/dir/foo.java", "other", EXPECT_UNDEFINED, NULL },
+		{ "NoMyAttr.java", "crlf", EXPECT_FALSE, NULL },
+		{ "NoMyAttr.java", "myAttr", EXPECT_UNDEFINED, NULL },
+		{ "NoMyAttr.java", "other", EXPECT_UNDEFINED, NULL },
+		{ "/prefix/dir/NoMyAttr.java", "crlf", EXPECT_FALSE, NULL },
+		{ "/prefix/dir/NoMyAttr.java", "myAttr", EXPECT_UNDEFINED, NULL },
+		{ "/prefix/dir/NoMyAttr.java", "other", EXPECT_UNDEFINED, NULL },
+		{ "README", "caveat", EXPECT_STRING, "unspecified" },
+		{ "/specific/path/README", "caveat", EXPECT_STRING, "unspecified" },
+		{ "README", "missing", EXPECT_UNDEFINED, NULL },
+		{ "/specific/path/README", "missing", EXPECT_UNDEFINED, NULL },
+		/* sentinel at end */
+		{ NULL, NULL, 0, NULL }
+	};
+
+	cl_git_pass(git_attr_file__new_and_load(&file, cl_fixture("attr/attr3")));
+	cl_assert(file->rules.length == 3);
+
+	run_test_cases(file, cases, 0);
+
+	git_attr_file__free(file);
+}
+
+void test_attr_lookup__from_buffer(void)
+{
+	git_attr_file *file;
+
+	struct attr_expected cases[] = {
+		{ "abc", "foo", EXPECT_TRUE, NULL },
+		{ "abc", "bar", EXPECT_TRUE, NULL },
+		{ "abc", "baz", EXPECT_TRUE, NULL },
+		{ "aaa", "foo", EXPECT_TRUE, NULL },
+		{ "aaa", "bar", EXPECT_UNDEFINED, NULL },
+		{ "aaa", "baz", EXPECT_TRUE, NULL },
+		{ "qqq", "foo", EXPECT_UNDEFINED, NULL },
+		{ "qqq", "bar", EXPECT_UNDEFINED, NULL },
+		{ "qqq", "baz", EXPECT_TRUE, NULL },
+		{ NULL, NULL, 0, NULL }
+	};
+
+	cl_git_pass(git_attr_file__new(&file, 0, NULL, NULL));
+
+	cl_git_pass(git_attr_file__parse_buffer(NULL, "a* foo\nabc bar\n* baz", file));
+
+	cl_assert(file->rules.length == 3);
+
+	run_test_cases(file, cases, 0);
+
+	git_attr_file__free(file);
+}