tests/attr/file.c

   1 #include "clar_libgit2.h"
   2 #include "attr_file.h"
   3 #include "attr_expect.h"
   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 {
  10         git_attr_file *file;
  11         git_attr_assignment *assign;
  12         git_attr_rule *rule;
  13
  14         cl_git_pass(git_attr_file__load_standalone(&file, cl_fixture("attr/attr0")));
  15
  16         cl_assert_equal_s(cl_fixture("attr/attr0"), file->entry->path);
  17         cl_assert(file->rules.length == 1);
  18
  19         rule = get_rule(0);
  20         cl_assert(rule != NULL);
  21         cl_assert_equal_s("*", rule->match.pattern);
  22         cl_assert(rule->match.length == 1);
  23         cl_assert((rule->match.flags & GIT_ATTR_FNMATCH_HASWILD) != 0);
  24
  25         cl_assert(rule->assigns.length == 1);
  26         assign = get_assign(rule, 0);
  27         cl_assert(assign != NULL);
  28         cl_assert_equal_s("binary", assign->name);
  29         cl_assert(GIT_ATTR_IS_TRUE(assign->value));
  30
  31         git_attr_file__free(file);
  32 }
  33
  34 void test_attr_file__match_variants(void)
  35 {
  36         git_attr_file *file;
  37         git_attr_rule *rule;
  38         git_attr_assignment *assign;
  39
  40         cl_git_pass(git_attr_file__load_standalone(&file, cl_fixture("attr/attr1")));
  41
  42         cl_assert_equal_s(cl_fixture("attr/attr1"), file->entry->path);
  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);
  50         cl_assert_equal_s("pat0", rule->match.pattern);
  51         cl_assert(rule->match.length == strlen("pat0"));
  52         cl_assert(rule->assigns.length == 1);
  53         assign = get_assign(rule,0);
  54         cl_assert_equal_s("attr0", assign->name);
  55         cl_assert(assign->name_hash == git_attr_file__name_hash(assign->name));
  56         cl_assert(GIT_ATTR_IS_TRUE(assign->value));
  57
  58         rule = get_rule(1);
  59         cl_assert_equal_s("pat1", rule->match.pattern);
  60         cl_assert(rule->match.length == strlen("pat1"));
  61         cl_assert((rule->match.flags & GIT_ATTR_FNMATCH_NEGATIVE) != 0);
  62
  63         rule = get_rule(2);
  64         cl_assert_equal_s("pat2", rule->match.pattern);
  65         cl_assert(rule->match.length == strlen("pat2"));
  66         cl_assert((rule->match.flags & GIT_ATTR_FNMATCH_DIRECTORY) != 0);
  67
  68         rule = get_rule(3);
  69         cl_assert_equal_s("pat3dir/pat3file", rule->match.pattern);
  70         cl_assert((rule->match.flags & GIT_ATTR_FNMATCH_FULLPATH) != 0);
  71
  72         rule = get_rule(4);
  73         cl_assert_equal_s("pat4.*", rule->match.pattern);
  74         cl_assert((rule->match.flags & GIT_ATTR_FNMATCH_HASWILD) != 0);
  75
  76         rule = get_rule(5);
  77         cl_assert_equal_s("*.pat5", rule->match.pattern);
  78         cl_assert((rule->match.flags & GIT_ATTR_FNMATCH_HASWILD) != 0);
  79
  80         rule = get_rule(7);
  81         cl_assert_equal_s("pat7[a-e]??[xyz]", rule->match.pattern);
  82         cl_assert(rule->assigns.length == 1);
  83         cl_assert((rule->match.flags & GIT_ATTR_FNMATCH_HASWILD) != 0);
  84         assign = get_assign(rule,0);
  85         cl_assert_equal_s("attr7", assign->name);
  86         cl_assert(GIT_ATTR_IS_TRUE(assign->value));
  87
  88         rule = get_rule(8);
  89         cl_assert_equal_s("pat8 with spaces", rule->match.pattern);
  90         cl_assert(rule->match.length == strlen("pat8 with spaces"));
  91
  92         rule = get_rule(9);
  93         cl_assert_equal_s("pat9", rule->match.pattern);
  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,
 104         enum attr_expect_t expected,
 105         const char *expected_str)
 106 {
 107         git_attr_rule *rule = get_rule(rule_idx);
 108         git_attr_assignment *assign = get_assign(rule, assign_idx);
 109
 110         cl_assert_equal_s(pattern, rule->match.pattern);
 111         cl_assert(rule->assigns.length == 1);
 112         cl_assert_equal_s(name, assign->name);
 113         cl_assert(assign->name_hash == git_attr_file__name_hash(assign->name));
 114
 115         attr_check_expected(expected, expected_str, assign->name, assign->value);
 116 }
 117
 118 void test_attr_file__assign_variants(void)
 119 {
 120         git_attr_file *file;
 121         git_attr_rule *rule;
 122         git_attr_assignment *assign;
 123
 124         cl_git_pass(git_attr_file__load_standalone(&file, cl_fixture("attr/attr2")));
 125
 126         cl_assert_equal_s(cl_fixture("attr/attr2"), file->entry->path);
 127         cl_assert(file->rules.length == 11);
 128
 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);
 137
 138         rule = get_rule(8);
 139         cl_assert_equal_s("pat7", rule->match.pattern);
 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);
 146         cl_assert_equal_s("multiple", assign->name);
 147         cl_assert(GIT_ATTR_IS_TRUE(assign->value));
 148         assign = git_attr_rule__lookup_assignment(rule, "single");
 149         cl_assert(assign);
 150         cl_assert_equal_s("single", assign->name);
 151         cl_assert(GIT_ATTR_IS_FALSE(assign->value));
 152         assign = git_attr_rule__lookup_assignment(rule, "values");
 153         cl_assert(assign);
 154         cl_assert_equal_s("values", assign->name);
 155         cl_assert_equal_s("1", assign->value);
 156         assign = git_attr_rule__lookup_assignment(rule, "also");
 157         cl_assert(assign);
 158         cl_assert_equal_s("also", assign->name);
 159         cl_assert_equal_s("a-really-long-value/*", assign->value);
 160         assign = git_attr_rule__lookup_assignment(rule, "happy");
 161         cl_assert(assign);
 162         cl_assert_equal_s("happy", assign->name);
 163         cl_assert_equal_s("yes!", assign->value);
 164         assign = git_attr_rule__lookup_assignment(rule, "other");
 165         cl_assert(!assign);
 166
 167         rule = get_rule(9);
 168         cl_assert_equal_s("pat8", rule->match.pattern);
 169         cl_assert(rule->assigns.length == 2);
 170         assign = git_attr_rule__lookup_assignment(rule, "again");
 171         cl_assert(assign);
 172         cl_assert_equal_s("again", assign->name);
 173         cl_assert(GIT_ATTR_IS_TRUE(assign->value));
 174         assign = git_attr_rule__lookup_assignment(rule, "another");
 175         cl_assert(assign);
 176         cl_assert_equal_s("another", assign->name);
 177         cl_assert_equal_s("12321", assign->value);
 178
 179         check_one_assign(file, 10, 0, "pat9", "at-eof", EXPECT_FALSE, NULL);
 180
 181         git_attr_file__free(file);
 182 }
 183
 184 static void assert_examples(git_attr_file *file)
 185 {
 186         git_attr_rule *rule;
 187         git_attr_assignment *assign;
 188
 189         rule = get_rule(0);
 190         cl_assert_equal_s("*.java", rule->match.pattern);
 191         cl_assert(rule->assigns.length == 3);
 192         assign = git_attr_rule__lookup_assignment(rule, "diff");
 193         cl_assert_equal_s("diff", assign->name);
 194         cl_assert_equal_s("java", assign->value);
 195         assign = git_attr_rule__lookup_assignment(rule, "crlf");
 196         cl_assert_equal_s("crlf", assign->name);
 197         cl_assert(GIT_ATTR_IS_FALSE(assign->value));
 198         assign = git_attr_rule__lookup_assignment(rule, "myAttr");
 199         cl_assert_equal_s("myAttr", assign->name);
 200         cl_assert(GIT_ATTR_IS_TRUE(assign->value));
 201         assign = git_attr_rule__lookup_assignment(rule, "missing");
 202         cl_assert(assign == NULL);
 203
 204         rule = get_rule(1);
 205         cl_assert_equal_s("NoMyAttr.java", rule->match.pattern);
 206         cl_assert(rule->assigns.length == 1);
 207         assign = get_assign(rule, 0);
 208         cl_assert_equal_s("myAttr", assign->name);
 209         cl_assert(GIT_ATTR_IS_UNSPECIFIED(assign->value));
 210
 211         rule = get_rule(2);
 212         cl_assert_equal_s("README", rule->match.pattern);
 213         cl_assert(rule->assigns.length == 1);
 214         assign = get_assign(rule, 0);
 215         cl_assert_equal_s("caveat", assign->name);
 216         cl_assert_equal_s("unspecified", assign->value);
 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);
 241
 242         git_attr_file__free(file);
 243 }