tests-clar/attr/lookup.c

   1 #include "clar_libgit2.h"
   2 #include "attr_file.h"
   3
   4 #include "attr_expect.h"
   5
   6 void test_attr_lookup__simple(void)
   7 {
   8         git_attr_file *file;
   9         git_attr_path path;
  10         const char *value = NULL;
  11
  12         cl_git_pass(git_attr_file__new_and_load(&file, cl_fixture("attr/attr0")));
  13         cl_assert_equal_s(cl_fixture("attr/attr0"), file->key + 2);
  14         cl_assert(file->rules.length == 1);
  15
  16         cl_git_pass(git_attr_path__init(&path, "test", NULL));
  17         cl_assert_equal_s("test", path.path);
  18         cl_assert_equal_s("test", path.basename);
  19         cl_assert(!path.is_dir);
  20
  21         cl_git_pass(git_attr_file__lookup_one(file,&path,"binary",&value));
  22         cl_assert(GIT_ATTR_TRUE(value));
  23
  24         cl_git_pass(git_attr_file__lookup_one(file,&path,"missing",&value));
  25         cl_assert(!value);
  26
  27         git_attr_path__free(&path);
  28         git_attr_file__free(file);
  29 }
  30
  31 static void run_test_cases(git_attr_file *file, struct attr_expected *cases, int force_dir)
  32 {
  33         git_attr_path path;
  34         const char *value = NULL;
  35         struct attr_expected *c;
  36         int error;
  37
  38         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                         path.is_dir = 1;
  43
  44                 error = git_attr_file__lookup_one(file,&path,c->attr,&value);
  45                 cl_git_pass(error);
  46
  47                 attr_check_expected(c->expected, c->expected_str, c->attr, value);
  48
  49                 git_attr_path__free(&path);
  50         }
  51 }
  52
  53 void test_attr_lookup__match_variants(void)
  54 {
  55         git_attr_file *file;
  56         git_attr_path path;
  57
  58         struct attr_expected dir_cases[] = {
  59                 { "pat2", "attr2", EXPECT_TRUE, NULL },
  60                 { "/testing/for/pat2", "attr2", EXPECT_TRUE, NULL },
  61                 { "/not/pat2/yousee", "attr2", EXPECT_UNDEFINED, NULL },
  62                 { "/fun/fun/fun/pat4.dir", "attr4", EXPECT_TRUE, NULL },
  63                 { "foo.pat5", "attr5", EXPECT_TRUE, NULL },
  64                 { NULL, NULL, 0, NULL }
  65         };
  66
  67         struct attr_expected cases[] = {
  68                 /* pat0 -> simple match */
  69                 { "pat0", "attr0", EXPECT_TRUE, NULL },
  70                 { "/testing/for/pat0", "attr0", EXPECT_TRUE, NULL },
  71                 { "relative/to/pat0", "attr0", EXPECT_TRUE, NULL },
  72                 { "this-contains-pat0-inside", "attr0", EXPECT_UNDEFINED, NULL },
  73                 { "this-aint-right", "attr0", EXPECT_UNDEFINED, NULL },
  74                 { "/this/pat0/dont/match", "attr0", EXPECT_UNDEFINED, NULL },
  75                 /* negative match */
  76                 { "pat0", "attr1", EXPECT_TRUE, NULL },
  77                 { "pat1", "attr1", EXPECT_UNDEFINED, NULL },
  78                 { "/testing/for/pat1", "attr1", EXPECT_UNDEFINED, NULL },
  79                 { "/testing/for/pat0", "attr1", EXPECT_TRUE, NULL },
  80                 { "/testing/for/pat1/inside", "attr1", EXPECT_TRUE, NULL },
  81                 { "misc", "attr1", EXPECT_TRUE, NULL },
  82                 /* dir match */
  83                 { "pat2", "attr2", EXPECT_UNDEFINED, NULL },
  84                 { "/testing/for/pat2", "attr2", EXPECT_UNDEFINED, NULL },
  85                 { "/not/pat2/yousee", "attr2", EXPECT_UNDEFINED, NULL },
  86                 /* path match */
  87                 { "pat3file", "attr3", EXPECT_UNDEFINED, NULL },
  88                 { "/pat3dir/pat3file", "attr3", EXPECT_TRUE, NULL },
  89                 { "pat3dir/pat3file", "attr3", EXPECT_TRUE, NULL },
  90                 /* pattern* match */
  91                 { "pat4.txt", "attr4", EXPECT_TRUE, NULL },
  92                 { "/fun/fun/fun/pat4.c", "attr4", EXPECT_TRUE, NULL },
  93                 { "pat4.", "attr4", EXPECT_TRUE, NULL },
  94                 { "pat4", "attr4", EXPECT_UNDEFINED, NULL },
  95                 /* *pattern match */
  96                 { "foo.pat5", "attr5", EXPECT_TRUE, NULL },
  97                 { "/this/is/ok.pat5", "attr5", EXPECT_TRUE, NULL },
  98                 { "/this/is/bad.pat5/yousee.txt", "attr5", EXPECT_UNDEFINED, NULL },
  99                 { "foo.pat5", "attr100", EXPECT_UNDEFINED, NULL },
 100                 /* glob match with slashes */
 101                 { "foo.pat6", "attr6", EXPECT_UNDEFINED, NULL },
 102                 { "pat6/pat6/foobar.pat6", "attr6", EXPECT_TRUE, NULL },
 103                 { "pat6/pat6/.pat6", "attr6", EXPECT_TRUE, NULL },
 104                 { "pat6/pat6/extra/foobar.pat6", "attr6", EXPECT_UNDEFINED, NULL },
 105                 { "/prefix/pat6/pat6/foobar.pat6", "attr6", EXPECT_UNDEFINED, NULL },
 106                 { "/pat6/pat6/foobar.pat6", "attr6", EXPECT_TRUE, NULL },
 107                 /* complex pattern */
 108                 { "pat7a12z", "attr7", EXPECT_TRUE, NULL },
 109                 { "pat7e__x", "attr7", EXPECT_TRUE, NULL },
 110                 { "pat7b/1y", "attr7", EXPECT_UNDEFINED, NULL }, /* ? does not match / */
 111                 { "pat7e_x", "attr7", EXPECT_UNDEFINED, NULL },
 112                 { "pat7aaaa", "attr7", EXPECT_UNDEFINED, NULL },
 113                 { "pat7zzzz", "attr7", EXPECT_UNDEFINED, NULL },
 114                 { "/this/can/be/anything/pat7a12z", "attr7", EXPECT_TRUE, NULL },
 115                 { "but/it/still/must/match/pat7aaaa", "attr7", EXPECT_UNDEFINED, NULL },
 116                 { "pat7aaay.fail", "attr7", EXPECT_UNDEFINED, NULL },
 117                 /* pattern with spaces */
 118                 { "pat8 with spaces", "attr8", EXPECT_TRUE, NULL },
 119                 { "/gotta love/pat8 with spaces", "attr8", EXPECT_TRUE, NULL },
 120                 { "failing pat8 with spaces", "attr8", EXPECT_UNDEFINED, NULL },
 121                 { "spaces", "attr8", EXPECT_UNDEFINED, NULL },
 122                 /* pattern at eof */
 123                 { "pat9", "attr9", EXPECT_TRUE, NULL },
 124                 { "/eof/pat9", "attr9", EXPECT_TRUE, NULL },
 125                 { "pat", "attr9", EXPECT_UNDEFINED, NULL },
 126                 { "at9", "attr9", EXPECT_UNDEFINED, NULL },
 127                 { "pat9.fail", "attr9", EXPECT_UNDEFINED, NULL },
 128                 /* sentinel at end */
 129                 { NULL, NULL, 0, NULL }
 130         };
 131
 132         cl_git_pass(git_attr_file__new_and_load(&file, cl_fixture("attr/attr1")));
 133         cl_assert_equal_s(cl_fixture("attr/attr1"), file->key + 2);
 134         cl_assert(file->rules.length == 10);
 135
 136         cl_git_pass(git_attr_path__init(&path, "/testing/for/pat0", NULL));
 137         cl_assert_equal_s("pat0", path.basename);
 138
 139         run_test_cases(file, cases, 0);
 140         run_test_cases(file, dir_cases, 1);
 141
 142         git_attr_file__free(file);
 143         git_attr_path__free(&path);
 144 }
 145
 146 void test_attr_lookup__assign_variants(void)
 147 {
 148         git_attr_file *file;
 149
 150         struct attr_expected cases[] = {
 151                 /* pat0 -> simple assign */
 152                 { "pat0", "simple", EXPECT_TRUE, NULL },
 153                 { "/testing/pat0", "simple", EXPECT_TRUE, NULL },
 154                 { "pat0", "fail", EXPECT_UNDEFINED, NULL },
 155                 { "/testing/pat0", "fail", EXPECT_UNDEFINED, NULL },
 156                 /* negative assign */
 157                 { "pat1", "neg", EXPECT_FALSE, NULL },
 158                 { "/testing/pat1", "neg", EXPECT_FALSE, NULL },
 159                 { "pat1", "fail", EXPECT_UNDEFINED, NULL },
 160                 { "/testing/pat1", "fail", EXPECT_UNDEFINED, NULL },
 161                 /* forced undef */
 162                 { "pat1", "notundef", EXPECT_TRUE, NULL },
 163                 { "pat2", "notundef", EXPECT_UNDEFINED, NULL },
 164                 { "/lead/in/pat1", "notundef", EXPECT_TRUE, NULL },
 165                 { "/lead/in/pat2", "notundef", EXPECT_UNDEFINED, NULL },
 166                 /* assign value */
 167                 { "pat3", "assigned", EXPECT_STRING, "test-value" },
 168                 { "pat3", "notassigned", EXPECT_UNDEFINED, NULL },
 169                 /* assign value */
 170                 { "pat4", "rule-with-more-chars", EXPECT_STRING, "value-with-more-chars" },
 171                 { "pat4", "notassigned-rule-with-more-chars", EXPECT_UNDEFINED, NULL },
 172                 /* empty assignments */
 173                 { "pat5", "empty", EXPECT_TRUE, NULL },
 174                 { "pat6", "negempty", EXPECT_FALSE, NULL },
 175                 /* multiple assignment */
 176                 { "pat7", "multiple", EXPECT_TRUE, NULL },
 177                 { "pat7", "single", EXPECT_FALSE, NULL },
 178                 { "pat7", "values", EXPECT_STRING, "1" },
 179                 { "pat7", "also", EXPECT_STRING, "a-really-long-value/*" },
 180                 { "pat7", "happy", EXPECT_STRING, "yes!" },
 181                 { "pat8", "again", EXPECT_TRUE, NULL },
 182                 { "pat8", "another", EXPECT_STRING, "12321" },
 183                 /* bad assignment */
 184                 { "patbad0", "simple", EXPECT_UNDEFINED, NULL },
 185                 { "patbad0", "notundef", EXPECT_TRUE, NULL },
 186                 { "patbad1", "simple", EXPECT_UNDEFINED, NULL },
 187                 /* eof assignment */
 188                 { "pat9", "at-eof", EXPECT_FALSE, NULL },
 189                 /* sentinel at end */
 190                 { NULL, NULL, 0, NULL }
 191         };
 192
 193         cl_git_pass(git_attr_file__new_and_load(&file, cl_fixture("attr/attr2")));
 194         cl_assert(file->rules.length == 11);
 195
 196         run_test_cases(file, cases, 0);
 197
 198         git_attr_file__free(file);
 199 }
 200
 201 void test_attr_lookup__check_attr_examples(void)
 202 {
 203         git_attr_file *file;
 204
 205         struct attr_expected cases[] = {
 206                 { "foo.java", "diff", EXPECT_STRING, "java" },
 207                 { "foo.java", "crlf", EXPECT_FALSE, NULL },
 208                 { "foo.java", "myAttr", EXPECT_TRUE, NULL },
 209                 { "foo.java", "other", EXPECT_UNDEFINED, NULL },
 210                 { "/prefix/dir/foo.java", "diff", EXPECT_STRING, "java" },
 211                 { "/prefix/dir/foo.java", "crlf", EXPECT_FALSE, NULL },
 212                 { "/prefix/dir/foo.java", "myAttr", EXPECT_TRUE, NULL },
 213                 { "/prefix/dir/foo.java", "other", EXPECT_UNDEFINED, NULL },
 214                 { "NoMyAttr.java", "crlf", EXPECT_FALSE, NULL },
 215                 { "NoMyAttr.java", "myAttr", EXPECT_UNDEFINED, NULL },
 216                 { "NoMyAttr.java", "other", EXPECT_UNDEFINED, NULL },
 217                 { "/prefix/dir/NoMyAttr.java", "crlf", EXPECT_FALSE, NULL },
 218                 { "/prefix/dir/NoMyAttr.java", "myAttr", EXPECT_UNDEFINED, NULL },
 219                 { "/prefix/dir/NoMyAttr.java", "other", EXPECT_UNDEFINED, NULL },
 220                 { "README", "caveat", EXPECT_STRING, "unspecified" },
 221                 { "/specific/path/README", "caveat", EXPECT_STRING, "unspecified" },
 222                 { "README", "missing", EXPECT_UNDEFINED, NULL },
 223                 { "/specific/path/README", "missing", EXPECT_UNDEFINED, NULL },
 224                 /* sentinel at end */
 225                 { NULL, NULL, 0, NULL }
 226         };
 227
 228         cl_git_pass(git_attr_file__new_and_load(&file, cl_fixture("attr/attr3")));
 229         cl_assert(file->rules.length == 3);
 230
 231         run_test_cases(file, cases, 0);
 232
 233         git_attr_file__free(file);
 234 }
 235
 236 void test_attr_lookup__from_buffer(void)
 237 {
 238         git_attr_file *file;
 239
 240         struct attr_expected cases[] = {
 241                 { "abc", "foo", EXPECT_TRUE, NULL },
 242                 { "abc", "bar", EXPECT_TRUE, NULL },
 243                 { "abc", "baz", EXPECT_TRUE, NULL },
 244                 { "aaa", "foo", EXPECT_TRUE, NULL },
 245                 { "aaa", "bar", EXPECT_UNDEFINED, NULL },
 246                 { "aaa", "baz", EXPECT_TRUE, NULL },
 247                 { "qqq", "foo", EXPECT_UNDEFINED, NULL },
 248                 { "qqq", "bar", EXPECT_UNDEFINED, NULL },
 249                 { "qqq", "baz", EXPECT_TRUE, NULL },
 250                 { NULL, NULL, 0, NULL }
 251         };
 252
 253         cl_git_pass(git_attr_file__new(&file, 0, NULL, NULL));
 254
 255         cl_git_pass(git_attr_file__parse_buffer(NULL, "a* foo\nabc bar\n* baz", file));
 256
 257         cl_assert(file->rules.length == 3);
 258
 259         run_test_cases(file, cases, 0);
 260
 261         git_attr_file__free(file);
 262 }