lookup.c 9.2 KB
Newer Older
1
#include "clar_libgit2.h"
2
#include "attr_file.h"
3

4 5
#include "attr_expect.h"

6 7
void test_attr_lookup__simple(void)
{
8
	git_attr_file *file;
9 10 11
	git_attr_path path;
	const char *value = NULL;

12 13
	cl_git_pass(git_attr_file__new(&file));
	cl_git_pass(git_attr_file__from_file(NULL, cl_fixture("attr/attr0"), file));
14 15 16
	cl_assert_strequal(cl_fixture("attr/attr0"), file->path);
	cl_assert(file->rules.length == 1);

17
	cl_git_pass(git_attr_path__init(&path, "test", NULL));
18 19 20 21 22
	cl_assert_strequal("test", path.path);
	cl_assert_strequal("test", path.basename);
	cl_assert(!path.is_dir);

	cl_git_pass(git_attr_file__lookup_one(file,&path,"binary",&value));
23
	cl_assert(GIT_ATTR_TRUE(value));
24 25 26 27 28 29 30

	cl_git_pass(git_attr_file__lookup_one(file,&path,"missing",&value));
	cl_assert(!value);

	git_attr_file__free(file);
}

31
static void run_test_cases(git_attr_file *file, struct attr_expected *cases, int force_dir)
32 33 34
{
	git_attr_path path;
	const char *value = NULL;
35
	struct attr_expected *c;
36 37 38
	int error;

	for (c = cases; c->path != NULL; c++) {
39
		cl_git_pass(git_attr_path__init(&path, c->path, NULL));
40

41
		if (force_dir)
42 43 44 45 46
			path.is_dir = 1;

		error = git_attr_file__lookup_one(file,&path,c->attr,&value);
		cl_git_pass(error);

47
		attr_check_expected(c->expected, c->expected_str, value);
48 49 50 51 52
	}
}

void test_attr_lookup__match_variants(void)
{
53
	git_attr_file *file;
54
	git_attr_path path;
55 56 57 58 59 60 61 62 63 64 65

	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[] = {
66
		/* pat0 -> simple match */
67 68 69 70 71 72
		{ "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 },
73
		/* negative match */
74 75 76 77 78 79
		{ "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 },
80
		/* dir match */
81 82 83
		{ "pat2", "attr2", EXPECT_UNDEFINED, NULL },
		{ "/testing/for/pat2", "attr2", EXPECT_UNDEFINED, NULL },
		{ "/not/pat2/yousee", "attr2", EXPECT_UNDEFINED, NULL },
84
		/* path match */
85 86 87
		{ "pat3file", "attr3", EXPECT_UNDEFINED, NULL },
		{ "/pat3dir/pat3file", "attr3", EXPECT_UNDEFINED, NULL },
		{ "pat3dir/pat3file", "attr3", EXPECT_TRUE, NULL },
88
		/* pattern* match */
89 90 91 92
		{ "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 },
93
		/* *pattern match */
94 95 96 97
		{ "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 },
98
		/* glob match with slashes */
99 100 101 102 103 104
		{ "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_UNDEFINED, NULL },
105
		/* complex pattern */
106 107 108 109 110 111 112 113 114
		{ "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 },
115
		/* pattern with spaces */
116 117 118 119
		{ "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 },
120
		/* pattern at eof */
121 122 123 124 125
		{ "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 },
126
		/* sentinel at end */
127
		{ NULL, NULL, 0, NULL }
128 129
	};

130 131
	cl_git_pass(git_attr_file__new(&file));
	cl_git_pass(git_attr_file__from_file(NULL, cl_fixture("attr/attr1"), file));
132 133 134
	cl_assert_strequal(cl_fixture("attr/attr1"), file->path);
	cl_assert(file->rules.length == 10);

135
	cl_git_pass(git_attr_path__init(&path, "/testing/for/pat0", NULL));
136 137
	cl_assert_strequal("pat0", path.basename);

138 139
	run_test_cases(file, cases, 0);
	run_test_cases(file, dir_cases, 1);
140 141 142 143 144 145

	git_attr_file__free(file);
}

void test_attr_lookup__assign_variants(void)
{
146
	git_attr_file *file;
147
	struct attr_expected cases[] = {
148
		/* pat0 -> simple assign */
149 150 151 152
		{ "pat0", "simple", EXPECT_TRUE, NULL },
		{ "/testing/pat0", "simple", EXPECT_TRUE, NULL },
		{ "pat0", "fail", EXPECT_UNDEFINED, NULL },
		{ "/testing/pat0", "fail", EXPECT_UNDEFINED, NULL },
153
		/* negative assign */
154 155 156 157
		{ "pat1", "neg", EXPECT_FALSE, NULL },
		{ "/testing/pat1", "neg", EXPECT_FALSE, NULL },
		{ "pat1", "fail", EXPECT_UNDEFINED, NULL },
		{ "/testing/pat1", "fail", EXPECT_UNDEFINED, NULL },
158
		/* forced undef */
159 160 161 162
		{ "pat1", "notundef", EXPECT_TRUE, NULL },
		{ "pat2", "notundef", EXPECT_UNDEFINED, NULL },
		{ "/lead/in/pat1", "notundef", EXPECT_TRUE, NULL },
		{ "/lead/in/pat2", "notundef", EXPECT_UNDEFINED, NULL },
163
		/* assign value */
164 165
		{ "pat3", "assigned", EXPECT_STRING, "test-value" },
		{ "pat3", "notassigned", EXPECT_UNDEFINED, NULL },
166
		/* assign value */
167 168
		{ "pat4", "rule-with-more-chars", EXPECT_STRING, "value-with-more-chars" },
		{ "pat4", "notassigned-rule-with-more-chars", EXPECT_UNDEFINED, NULL },
169
		/* empty assignments */
170 171
		{ "pat5", "empty", EXPECT_TRUE, NULL },
		{ "pat6", "negempty", EXPECT_FALSE, NULL },
172
		/* multiple assignment */
173 174 175 176 177 178 179
		{ "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" },
180
		/* bad assignment */
181 182 183
		{ "patbad0", "simple", EXPECT_UNDEFINED, NULL },
		{ "patbad0", "notundef", EXPECT_TRUE, NULL },
		{ "patbad1", "simple", EXPECT_UNDEFINED, NULL },
184
		/* eof assignment */
185
		{ "pat9", "at-eof", EXPECT_FALSE, NULL },
186
		/* sentinel at end */
187
		{ NULL, NULL, 0, NULL }
188 189
	};

190 191
	cl_git_pass(git_attr_file__new(&file));
	cl_git_pass(git_attr_file__from_file(NULL, cl_fixture("attr/attr2"), file));
192 193
	cl_assert(file->rules.length == 11);

194
	run_test_cases(file, cases, 0);
195 196 197 198 199 200

	git_attr_file__free(file);
}

void test_attr_lookup__check_attr_examples(void)
{
201
	git_attr_file *file;
202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220
	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 },
221
		/* sentinel at end */
222
		{ NULL, NULL, 0, NULL }
223 224
	};

225 226
	cl_git_pass(git_attr_file__new(&file));
	cl_git_pass(git_attr_file__from_file(NULL, cl_fixture("attr/attr3"), file));
227 228
	cl_assert(file->rules.length == 3);

229
	run_test_cases(file, cases, 0);
230 231 232 233 234 235

	git_attr_file__free(file);
}

void test_attr_lookup__from_buffer(void)
{
236
	git_attr_file *file;
237 238 239 240 241 242 243 244 245 246 247
	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 }
248 249
	};

250 251
	cl_git_pass(git_attr_file__new(&file));
	cl_git_pass(git_attr_file__from_buffer(NULL, "a* foo\nabc bar\n* baz", file));
252 253
	cl_assert(file->rules.length == 3);

254
	run_test_cases(file, cases, 0);
255 256 257

	git_attr_file__free(file);
}