[libgit2.git] / tests / attr / file.c

#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__load_standalone(&file, cl_fixture("attr/attr0")));

	cl_assert_equal_s(cl_fixture("attr/attr0"), file->entry->path);
	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_IS_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__load_standalone(&file, cl_fixture("attr/attr1")));

	cl_assert_equal_s(cl_fixture("attr/attr1"), file->entry->path);
	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->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_IS_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) != 0);

	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) != 0);

	rule = get_rule(3);
	cl_assert_equal_s("pat3dir/pat3file", rule->match.pattern);
	cl_assert((rule->match.flags & GIT_ATTR_FNMATCH_FULLPATH) != 0);

	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_IS_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"));

	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__load_standalone(&file, cl_fixture("attr/attr2")));

	cl_assert_equal_s(cl_fixture("attr/attr2"), file->entry->path);
	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_IS_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_IS_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_IS_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);
}

static void assert_examples(git_attr_file *file)
{
	git_attr_rule *rule;
	git_attr_assignment *assign;

	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_IS_FALSE(assign->value));
	assign = git_attr_rule__lookup_assignment(rule, "myAttr");
	cl_assert_equal_s("myAttr", assign->name);
	cl_assert(GIT_ATTR_IS_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_IS_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);
}

void test_attr_file__check_attr_examples(void)
{
	git_attr_file *file;

	cl_git_pass(git_attr_file__load_standalone(&file, cl_fixture("attr/attr3")));
	cl_assert_equal_s(cl_fixture("attr/attr3"), file->entry->path);
	cl_assert(file->rules.length == 3);

	assert_examples(file);

	git_attr_file__free(file);
}

void test_attr_file__whitespace(void)
{
	git_attr_file *file;

	cl_git_pass(git_attr_file__load_standalone(&file, cl_fixture("attr/attr4")));
	cl_assert_equal_s(cl_fixture("attr/attr4"), file->entry->path);
	cl_assert(file->rules.length == 3);

	assert_examples(file);

	git_attr_file__free(file);
}
Commit	Line	Data
3fd1520c	1	#include "clar_libgit2.h"
ee1f0b1a	2	#include "attr_file.h"
c63793ee	3	#include "attr_expect.h"
ee1f0b1a RB	4
	5	#define get_rule(X) ((git_attr_rule *)git_vector_get(&file->rules,(X)))
	6	#define get_assign(R,Y) ((git_attr_assignment *)git_vector_get(&(R)->assigns,(Y)))
	7
	8	void test_attr_file__simple_read(void)
	9	{
a51cd8e6	10	git_attr_file *file;
acb159e1	11	git_attr_assignment *assign;
acb159e1	12	git_attr_rule *rule;
ee1f0b1a	13
7d490872	14	cl_git_pass(git_attr_file__load_standalone(&file, cl_fixture("attr/attr0")));
f917481e	15
823c0e9c	16	cl_assert_equal_s(cl_fixture("attr/attr0"), file->entry->path);
ee1f0b1a RB	17	cl_assert(file->rules.length == 1);
ee1f0b1a RB	18
acb159e1	19	rule = get_rule(0);
ee1f0b1a	20	cl_assert(rule != NULL);
1a6e8f8a	21	cl_assert_equal_s("*", rule->match.pattern);
ee1f0b1a	22	cl_assert(rule->match.length == 1);
14a513e0	23	cl_assert((rule->match.flags & GIT_ATTR_FNMATCH_HASWILD) != 0);
ee1f0b1a RB	24
ee1f0b1a RB	25	cl_assert(rule->assigns.length == 1);
acb159e1	26	assign = get_assign(rule, 0);
ee1f0b1a	27	cl_assert(assign != NULL);
1a6e8f8a	28	cl_assert_equal_s("binary", assign->name);
22a2d3d5	29	cl_assert(GIT_ATTR_IS_TRUE(assign->value));
ee1f0b1a RB	30
	31	git_attr_file__free(file);
	32	}
	33
	34	void test_attr_file__match_variants(void)
	35	{
a51cd8e6	36	git_attr_file *file;
ee1f0b1a RB	37	git_attr_rule *rule;
	38	git_attr_assignment *assign;
	39
7d490872	40	cl_git_pass(git_attr_file__load_standalone(&file, cl_fixture("attr/attr1")));
f917481e	41
823c0e9c	42	cl_assert_equal_s(cl_fixture("attr/attr1"), file->entry->path);
ee1f0b1a RB	43	cl_assert(file->rules.length == 10);
	44
	45	/* let's do a thorough check of this rule, then just verify
	46	* the things that are unique for the later rules
	47	*/
	48	rule = get_rule(0);
	49	cl_assert(rule);
1a6e8f8a	50	cl_assert_equal_s("pat0", rule->match.pattern);
ee1f0b1a	51	cl_assert(rule->match.length == strlen("pat0"));
ee1f0b1a RB	52	cl_assert(rule->assigns.length == 1);
ee1f0b1a RB	53	assign = get_assign(rule,0);
1a6e8f8a	54	cl_assert_equal_s("attr0", assign->name);
ee1f0b1a	55	cl_assert(assign->name_hash == git_attr_file__name_hash(assign->name));
22a2d3d5	56	cl_assert(GIT_ATTR_IS_TRUE(assign->value));
ee1f0b1a RB	57
ee1f0b1a RB	58	rule = get_rule(1);
1a6e8f8a	59	cl_assert_equal_s("pat1", rule->match.pattern);
ee1f0b1a	60	cl_assert(rule->match.length == strlen("pat1"));
4ba64794	61	cl_assert((rule->match.flags & GIT_ATTR_FNMATCH_NEGATIVE) != 0);
ee1f0b1a RB	62
ee1f0b1a RB	63	rule = get_rule(2);
1a6e8f8a	64	cl_assert_equal_s("pat2", rule->match.pattern);
ee1f0b1a	65	cl_assert(rule->match.length == strlen("pat2"));
4ba64794	66	cl_assert((rule->match.flags & GIT_ATTR_FNMATCH_DIRECTORY) != 0);
ee1f0b1a RB	67
ee1f0b1a RB	68	rule = get_rule(3);
1a6e8f8a	69	cl_assert_equal_s("pat3dir/pat3file", rule->match.pattern);
4ba64794	70	cl_assert((rule->match.flags & GIT_ATTR_FNMATCH_FULLPATH) != 0);
ee1f0b1a RB	71
ee1f0b1a RB	72	rule = get_rule(4);
1a6e8f8a	73	cl_assert_equal_s("pat4.*", rule->match.pattern);
14a513e0	74	cl_assert((rule->match.flags & GIT_ATTR_FNMATCH_HASWILD) != 0);
ee1f0b1a RB	75
ee1f0b1a RB	76	rule = get_rule(5);
1a6e8f8a	77	cl_assert_equal_s("*.pat5", rule->match.pattern);
14a513e0	78	cl_assert((rule->match.flags & GIT_ATTR_FNMATCH_HASWILD) != 0);
ee1f0b1a RB	79
ee1f0b1a RB	80	rule = get_rule(7);
1a6e8f8a	81	cl_assert_equal_s("pat7[a-e]??[xyz]", rule->match.pattern);
ee1f0b1a	82	cl_assert(rule->assigns.length == 1);
14a513e0	83	cl_assert((rule->match.flags & GIT_ATTR_FNMATCH_HASWILD) != 0);
ee1f0b1a	84	assign = get_assign(rule,0);
1a6e8f8a	85	cl_assert_equal_s("attr7", assign->name);
22a2d3d5	86	cl_assert(GIT_ATTR_IS_TRUE(assign->value));
ee1f0b1a RB	87
ee1f0b1a RB	88	rule = get_rule(8);
1a6e8f8a	89	cl_assert_equal_s("pat8 with spaces", rule->match.pattern);
ee1f0b1a	90	cl_assert(rule->match.length == strlen("pat8 with spaces"));
ee1f0b1a RB	91
ee1f0b1a RB	92	rule = get_rule(9);
1a6e8f8a	93	cl_assert_equal_s("pat9", rule->match.pattern);
ee1f0b1a RB	94
	95	git_attr_file__free(file);
	96	}
	97
	98	static void check_one_assign(
	99	git_attr_file *file,
	100	int rule_idx,
	101	int assign_idx,
	102	const char *pattern,
	103	const char *name,
c63793ee VM	104	enum attr_expect_t expected,
c63793ee VM	105	const char *expected_str)
ee1f0b1a RB	106	{
	107	git_attr_rule *rule = get_rule(rule_idx);
	108	git_attr_assignment *assign = get_assign(rule, assign_idx);
	109
1a6e8f8a	110	cl_assert_equal_s(pattern, rule->match.pattern);
ee1f0b1a	111	cl_assert(rule->assigns.length == 1);
1a6e8f8a	112	cl_assert_equal_s(name, assign->name);
ee1f0b1a	113	cl_assert(assign->name_hash == git_attr_file__name_hash(assign->name));
c63793ee	114
2a99df69	115	attr_check_expected(expected, expected_str, assign->name, assign->value);
ee1f0b1a RB	116	}
	117
	118	void test_attr_file__assign_variants(void)
	119	{
a51cd8e6	120	git_attr_file *file;
ee1f0b1a RB	121	git_attr_rule *rule;
	122	git_attr_assignment *assign;
	123
7d490872	124	cl_git_pass(git_attr_file__load_standalone(&file, cl_fixture("attr/attr2")));
f917481e	125
823c0e9c	126	cl_assert_equal_s(cl_fixture("attr/attr2"), file->entry->path);
ee1f0b1a RB	127	cl_assert(file->rules.length == 11);
ee1f0b1a RB	128
c63793ee VM	129	check_one_assign(file, 0, 0, "pat0", "simple", EXPECT_TRUE, NULL);
	130	check_one_assign(file, 1, 0, "pat1", "neg", EXPECT_FALSE, NULL);
	131	check_one_assign(file, 2, 0, "*", "notundef", EXPECT_TRUE, NULL);
	132	check_one_assign(file, 3, 0, "pat2", "notundef", EXPECT_UNDEFINED, NULL);
	133	check_one_assign(file, 4, 0, "pat3", "assigned", EXPECT_STRING, "test-value");
	134	check_one_assign(file, 5, 0, "pat4", "rule-with-more-chars", EXPECT_STRING, "value-with-more-chars");
	135	check_one_assign(file, 6, 0, "pat5", "empty", EXPECT_TRUE, NULL);
	136	check_one_assign(file, 7, 0, "pat6", "negempty", EXPECT_FALSE, NULL);
ee1f0b1a RB	137
ee1f0b1a RB	138	rule = get_rule(8);
1a6e8f8a	139	cl_assert_equal_s("pat7", rule->match.pattern);
ee1f0b1a RB	140	cl_assert(rule->assigns.length == 5);
	141	/* assignments will be sorted by hash value, so we have to do
	142	* lookups by search instead of by position
	143	*/
	144	assign = git_attr_rule__lookup_assignment(rule, "multiple");
	145	cl_assert(assign);
1a6e8f8a	146	cl_assert_equal_s("multiple", assign->name);
22a2d3d5	147	cl_assert(GIT_ATTR_IS_TRUE(assign->value));
ee1f0b1a RB	148	assign = git_attr_rule__lookup_assignment(rule, "single");
ee1f0b1a RB	149	cl_assert(assign);
1a6e8f8a	150	cl_assert_equal_s("single", assign->name);
22a2d3d5	151	cl_assert(GIT_ATTR_IS_FALSE(assign->value));
ee1f0b1a RB	152	assign = git_attr_rule__lookup_assignment(rule, "values");
ee1f0b1a RB	153	cl_assert(assign);
1a6e8f8a RB	154	cl_assert_equal_s("values", assign->name);
1a6e8f8a RB	155	cl_assert_equal_s("1", assign->value);
ee1f0b1a RB	156	assign = git_attr_rule__lookup_assignment(rule, "also");
ee1f0b1a RB	157	cl_assert(assign);
1a6e8f8a RB	158	cl_assert_equal_s("also", assign->name);
1a6e8f8a RB	159	cl_assert_equal_s("a-really-long-value/*", assign->value);
ee1f0b1a RB	160	assign = git_attr_rule__lookup_assignment(rule, "happy");
ee1f0b1a RB	161	cl_assert(assign);
1a6e8f8a RB	162	cl_assert_equal_s("happy", assign->name);
1a6e8f8a RB	163	cl_assert_equal_s("yes!", assign->value);
ee1f0b1a RB	164	assign = git_attr_rule__lookup_assignment(rule, "other");
	165	cl_assert(!assign);
	166
	167	rule = get_rule(9);
1a6e8f8a	168	cl_assert_equal_s("pat8", rule->match.pattern);
ee1f0b1a RB	169	cl_assert(rule->assigns.length == 2);
	170	assign = git_attr_rule__lookup_assignment(rule, "again");
	171	cl_assert(assign);
1a6e8f8a	172	cl_assert_equal_s("again", assign->name);
22a2d3d5	173	cl_assert(GIT_ATTR_IS_TRUE(assign->value));
ee1f0b1a RB	174	assign = git_attr_rule__lookup_assignment(rule, "another");
ee1f0b1a RB	175	cl_assert(assign);
1a6e8f8a RB	176	cl_assert_equal_s("another", assign->name);
1a6e8f8a RB	177	cl_assert_equal_s("12321", assign->value);
ee1f0b1a	178
c63793ee	179	check_one_assign(file, 10, 0, "pat9", "at-eof", EXPECT_FALSE, NULL);
ee1f0b1a RB	180
	181	git_attr_file__free(file);
	182	}
	183
22a2d3d5	184	static void assert_examples(git_attr_file *file)
ee1f0b1a	185	{
ee1f0b1a RB	186	git_attr_rule *rule;
	187	git_attr_assignment *assign;
	188
ee1f0b1a	189	rule = get_rule(0);
1a6e8f8a	190	cl_assert_equal_s("*.java", rule->match.pattern);
ee1f0b1a RB	191	cl_assert(rule->assigns.length == 3);
ee1f0b1a RB	192	assign = git_attr_rule__lookup_assignment(rule, "diff");
1a6e8f8a RB	193	cl_assert_equal_s("diff", assign->name);
1a6e8f8a RB	194	cl_assert_equal_s("java", assign->value);
ee1f0b1a	195	assign = git_attr_rule__lookup_assignment(rule, "crlf");
1a6e8f8a	196	cl_assert_equal_s("crlf", assign->name);
22a2d3d5	197	cl_assert(GIT_ATTR_IS_FALSE(assign->value));
ee1f0b1a	198	assign = git_attr_rule__lookup_assignment(rule, "myAttr");
1a6e8f8a	199	cl_assert_equal_s("myAttr", assign->name);
22a2d3d5	200	cl_assert(GIT_ATTR_IS_TRUE(assign->value));
ee1f0b1a RB	201	assign = git_attr_rule__lookup_assignment(rule, "missing");
	202	cl_assert(assign == NULL);
	203
	204	rule = get_rule(1);
1a6e8f8a	205	cl_assert_equal_s("NoMyAttr.java", rule->match.pattern);
ee1f0b1a RB	206	cl_assert(rule->assigns.length == 1);
ee1f0b1a RB	207	assign = get_assign(rule, 0);
1a6e8f8a	208	cl_assert_equal_s("myAttr", assign->name);
22a2d3d5	209	cl_assert(GIT_ATTR_IS_UNSPECIFIED(assign->value));
ee1f0b1a RB	210
ee1f0b1a RB	211	rule = get_rule(2);
1a6e8f8a	212	cl_assert_equal_s("README", rule->match.pattern);
ee1f0b1a RB	213	cl_assert(rule->assigns.length == 1);
ee1f0b1a RB	214	assign = get_assign(rule, 0);
1a6e8f8a RB	215	cl_assert_equal_s("caveat", assign->name);
1a6e8f8a RB	216	cl_assert_equal_s("unspecified", assign->value);
22a2d3d5 UG	217	}
	218
	219	void test_attr_file__check_attr_examples(void)
	220	{
	221	git_attr_file *file;
	222
	223	cl_git_pass(git_attr_file__load_standalone(&file, cl_fixture("attr/attr3")));
	224	cl_assert_equal_s(cl_fixture("attr/attr3"), file->entry->path);
	225	cl_assert(file->rules.length == 3);
	226
	227	assert_examples(file);
	228
	229	git_attr_file__free(file);
	230	}
	231
	232	void test_attr_file__whitespace(void)
	233	{
	234	git_attr_file *file;
	235
	236	cl_git_pass(git_attr_file__load_standalone(&file, cl_fixture("attr/attr4")));
	237	cl_assert_equal_s(cl_fixture("attr/attr4"), file->entry->path);
	238	cl_assert(file->rules.length == 3);
	239
	240	assert_examples(file);
ee1f0b1a RB	241
	242	git_attr_file__free(file);
	243	}