tests/index/reuc.c

   1 #include "clar_libgit2.h"
   2 #include "index.h"
   3 #include "git2/sys/index.h"
   4 #include "git2/repository.h"
   5 #include "../reset/reset_helpers.h"
   6
   7 static git_repository *repo;
   8 static git_index *repo_index;
   9
  10 #define TEST_REPO_PATH "mergedrepo"
  11 #define TEST_INDEX_PATH TEST_REPO_PATH "/.git/index"
  12
  13 #define ONE_ANCESTOR_OID "478871385b9cd03908c5383acfd568bef023c6b3"
  14 #define ONE_OUR_OID "4458b8bc9e72b6c8755ae456f60e9844d0538d8c"
  15 #define ONE_THEIR_OID "8b72416545c7e761b64cecad4f1686eae4078aa8"
  16
  17 #define TWO_ANCESTOR_OID "9d81f82fccc7dcd7de7a1ffead1815294c2e092c"
  18 #define TWO_OUR_OID "8f3c06cff9a83757cec40c80bc9bf31a2582bde9"
  19 #define TWO_THEIR_OID "887b153b165d32409c70163e0f734c090f12f673"
  20
  21 /* Fixture setup and teardown */
  22 void test_index_reuc__initialize(void)
  23 {
  24         repo = cl_git_sandbox_init("mergedrepo");
  25         git_repository_index(&repo_index, repo);
  26 }
  27
  28 void test_index_reuc__cleanup(void)
  29 {
  30         git_index_free(repo_index);
  31         repo_index = NULL;
  32
  33         cl_git_sandbox_cleanup();
  34 }
  35
  36 void test_index_reuc__add(void)
  37 {
  38         git_oid ancestor_oid, our_oid, their_oid;
  39         const git_index_reuc_entry *reuc;
  40
  41         git_oid_fromstr(&ancestor_oid, ONE_ANCESTOR_OID);
  42         git_oid_fromstr(&our_oid, ONE_OUR_OID);
  43         git_oid_fromstr(&their_oid, ONE_THEIR_OID);
  44
  45         cl_git_pass(git_index_reuc_add(repo_index, "newfile.txt",
  46                 0100644, &ancestor_oid,
  47                 0100644, &our_oid,
  48                 0100644, &their_oid));
  49
  50         cl_assert(reuc = git_index_reuc_get_bypath(repo_index, "newfile.txt"));
  51
  52         cl_assert_equal_s("newfile.txt", reuc->path);
  53         cl_assert(reuc->mode[0] == 0100644);
  54         cl_assert(reuc->mode[1] == 0100644);
  55         cl_assert(reuc->mode[2] == 0100644);
  56         cl_assert_equal_oid(&reuc->oid[0], &ancestor_oid);
  57         cl_assert_equal_oid(&reuc->oid[1], &our_oid);
  58         cl_assert_equal_oid(&reuc->oid[2], &their_oid);
  59
  60         cl_git_pass(git_index_write(repo_index));
  61 }
  62
  63 void test_index_reuc__add_no_ancestor(void)
  64 {
  65         git_oid ancestor_oid, our_oid, their_oid;
  66         const git_index_reuc_entry *reuc;
  67
  68         memset(&ancestor_oid, 0x0, sizeof(git_oid));
  69         git_oid_fromstr(&our_oid, ONE_OUR_OID);
  70         git_oid_fromstr(&their_oid, ONE_THEIR_OID);
  71
  72         cl_git_pass(git_index_reuc_add(repo_index, "newfile.txt",
  73                 0, NULL,
  74                 0100644, &our_oid,
  75                 0100644, &their_oid));
  76
  77         cl_assert(reuc = git_index_reuc_get_bypath(repo_index, "newfile.txt"));
  78
  79         cl_assert_equal_s("newfile.txt", reuc->path);
  80         cl_assert(reuc->mode[0] == 0);
  81         cl_assert(reuc->mode[1] == 0100644);
  82         cl_assert(reuc->mode[2] == 0100644);
  83         cl_assert_equal_oid(&reuc->oid[0], &ancestor_oid);
  84         cl_assert_equal_oid(&reuc->oid[1], &our_oid);
  85         cl_assert_equal_oid(&reuc->oid[2], &their_oid);
  86
  87         cl_git_pass(git_index_write(repo_index));
  88 }
  89
  90 void test_index_reuc__read_bypath(void)
  91 {
  92         const git_index_reuc_entry *reuc;
  93         git_oid oid;
  94
  95         cl_assert_equal_i(2, git_index_reuc_entrycount(repo_index));
  96
  97         cl_assert(reuc = git_index_reuc_get_bypath(repo_index, "two.txt"));
  98
  99         cl_assert_equal_s("two.txt", reuc->path);
 100         cl_assert(reuc->mode[0] == 0100644);
 101         cl_assert(reuc->mode[1] == 0100644);
 102         cl_assert(reuc->mode[2] == 0100644);
 103         git_oid_fromstr(&oid, TWO_ANCESTOR_OID);
 104         cl_assert_equal_oid(&reuc->oid[0], &oid);
 105         git_oid_fromstr(&oid, TWO_OUR_OID);
 106         cl_assert_equal_oid(&reuc->oid[1], &oid);
 107         git_oid_fromstr(&oid, TWO_THEIR_OID);
 108         cl_assert_equal_oid(&reuc->oid[2], &oid);
 109
 110         cl_assert(reuc = git_index_reuc_get_bypath(repo_index, "one.txt"));
 111
 112         cl_assert_equal_s("one.txt", reuc->path);
 113         cl_assert(reuc->mode[0] == 0100644);
 114         cl_assert(reuc->mode[1] == 0100644);
 115         cl_assert(reuc->mode[2] == 0100644);
 116         git_oid_fromstr(&oid, ONE_ANCESTOR_OID);
 117         cl_assert_equal_oid(&reuc->oid[0], &oid);
 118         git_oid_fromstr(&oid, ONE_OUR_OID);
 119         cl_assert_equal_oid(&reuc->oid[1], &oid);
 120         git_oid_fromstr(&oid, ONE_THEIR_OID);
 121         cl_assert_equal_oid(&reuc->oid[2], &oid);
 122 }
 123
 124 void test_index_reuc__ignore_case(void)
 125 {
 126         const git_index_reuc_entry *reuc;
 127         git_oid oid;
 128         int index_caps;
 129
 130         index_caps = git_index_caps(repo_index);
 131
 132         index_caps &= ~GIT_INDEX_CAPABILITY_IGNORE_CASE;
 133         cl_git_pass(git_index_set_caps(repo_index, index_caps));
 134
 135         cl_assert(!git_index_reuc_get_bypath(repo_index, "TWO.txt"));
 136
 137         index_caps |= GIT_INDEX_CAPABILITY_IGNORE_CASE;
 138         cl_git_pass(git_index_set_caps(repo_index, index_caps));
 139
 140         cl_assert_equal_i(2, git_index_reuc_entrycount(repo_index));
 141
 142         cl_assert(reuc = git_index_reuc_get_bypath(repo_index, "TWO.txt"));
 143
 144         cl_assert_equal_s("two.txt", reuc->path);
 145         cl_assert(reuc->mode[0] == 0100644);
 146         cl_assert(reuc->mode[1] == 0100644);
 147         cl_assert(reuc->mode[2] == 0100644);
 148         git_oid_fromstr(&oid, TWO_ANCESTOR_OID);
 149         cl_assert_equal_oid(&reuc->oid[0], &oid);
 150         git_oid_fromstr(&oid, TWO_OUR_OID);
 151         cl_assert_equal_oid(&reuc->oid[1], &oid);
 152         git_oid_fromstr(&oid, TWO_THEIR_OID);
 153         cl_assert_equal_oid(&reuc->oid[2], &oid);
 154 }
 155
 156 void test_index_reuc__read_byindex(void)
 157 {
 158         const git_index_reuc_entry *reuc;
 159         git_oid oid;
 160
 161         cl_assert_equal_i(2, git_index_reuc_entrycount(repo_index));
 162
 163         cl_assert(reuc = git_index_reuc_get_byindex(repo_index, 0));
 164
 165         cl_assert_equal_s("one.txt", reuc->path);
 166         cl_assert(reuc->mode[0] == 0100644);
 167         cl_assert(reuc->mode[1] == 0100644);
 168         cl_assert(reuc->mode[2] == 0100644);
 169         git_oid_fromstr(&oid, ONE_ANCESTOR_OID);
 170         cl_assert_equal_oid(&reuc->oid[0], &oid);
 171         git_oid_fromstr(&oid, ONE_OUR_OID);
 172         cl_assert_equal_oid(&reuc->oid[1], &oid);
 173         git_oid_fromstr(&oid, ONE_THEIR_OID);
 174         cl_assert_equal_oid(&reuc->oid[2], &oid);
 175
 176         cl_assert(reuc = git_index_reuc_get_byindex(repo_index, 1));
 177
 178         cl_assert_equal_s("two.txt", reuc->path);
 179         cl_assert(reuc->mode[0] == 0100644);
 180         cl_assert(reuc->mode[1] == 0100644);
 181         cl_assert(reuc->mode[2] == 0100644);
 182         git_oid_fromstr(&oid, TWO_ANCESTOR_OID);
 183         cl_assert_equal_oid(&reuc->oid[0], &oid);
 184         git_oid_fromstr(&oid, TWO_OUR_OID);
 185         cl_assert_equal_oid(&reuc->oid[1], &oid);
 186         git_oid_fromstr(&oid, TWO_THEIR_OID);
 187         cl_assert_equal_oid(&reuc->oid[2], &oid);
 188 }
 189
 190 void test_index_reuc__updates_existing(void)
 191 {
 192         const git_index_reuc_entry *reuc;
 193         git_oid ancestor_oid, our_oid, their_oid, oid;
 194         int index_caps;
 195
 196         git_index_clear(repo_index);
 197
 198         index_caps = git_index_caps(repo_index);
 199
 200         index_caps |= GIT_INDEX_CAPABILITY_IGNORE_CASE;
 201         cl_git_pass(git_index_set_caps(repo_index, index_caps));
 202
 203         git_oid_fromstr(&ancestor_oid, TWO_ANCESTOR_OID);
 204         git_oid_fromstr(&our_oid, TWO_OUR_OID);
 205         git_oid_fromstr(&their_oid, TWO_THEIR_OID);
 206
 207         cl_git_pass(git_index_reuc_add(repo_index, "two.txt",
 208                 0100644, &ancestor_oid,
 209                 0100644, &our_oid,
 210                 0100644, &their_oid));
 211
 212         cl_git_pass(git_index_reuc_add(repo_index, "TWO.txt",
 213                 0100644, &our_oid,
 214                 0100644, &their_oid,
 215                 0100644, &ancestor_oid));
 216
 217         cl_assert_equal_i(1, git_index_reuc_entrycount(repo_index));
 218
 219         cl_assert(reuc = git_index_reuc_get_byindex(repo_index, 0));
 220
 221         cl_assert_equal_s("TWO.txt", reuc->path);
 222         git_oid_fromstr(&oid, TWO_OUR_OID);
 223         cl_assert_equal_oid(&reuc->oid[0], &oid);
 224         git_oid_fromstr(&oid, TWO_THEIR_OID);
 225         cl_assert_equal_oid(&reuc->oid[1], &oid);
 226         git_oid_fromstr(&oid, TWO_ANCESTOR_OID);
 227         cl_assert_equal_oid(&reuc->oid[2], &oid);
 228 }
 229
 230 void test_index_reuc__remove(void)
 231 {
 232         git_oid oid;
 233         const git_index_reuc_entry *reuc;
 234
 235         cl_assert_equal_i(2, git_index_reuc_entrycount(repo_index));
 236
 237         cl_git_pass(git_index_reuc_remove(repo_index, 0));
 238         cl_git_fail(git_index_reuc_remove(repo_index, 1));
 239
 240         cl_assert_equal_i(1, git_index_reuc_entrycount(repo_index));
 241
 242         cl_assert(reuc = git_index_reuc_get_byindex(repo_index, 0));
 243
 244         cl_assert_equal_s("two.txt", reuc->path);
 245         cl_assert(reuc->mode[0] == 0100644);
 246         cl_assert(reuc->mode[1] == 0100644);
 247         cl_assert(reuc->mode[2] == 0100644);
 248         git_oid_fromstr(&oid, TWO_ANCESTOR_OID);
 249         cl_assert_equal_oid(&reuc->oid[0], &oid);
 250         git_oid_fromstr(&oid, TWO_OUR_OID);
 251         cl_assert_equal_oid(&reuc->oid[1], &oid);
 252         git_oid_fromstr(&oid, TWO_THEIR_OID);
 253         cl_assert_equal_oid(&reuc->oid[2], &oid);
 254 }
 255
 256 void test_index_reuc__write(void)
 257 {
 258         git_oid ancestor_oid, our_oid, their_oid;
 259         const git_index_reuc_entry *reuc;
 260
 261         git_index_clear(repo_index);
 262
 263         /* Write out of order to ensure sorting is correct */
 264         git_oid_fromstr(&ancestor_oid, TWO_ANCESTOR_OID);
 265         git_oid_fromstr(&our_oid, TWO_OUR_OID);
 266         git_oid_fromstr(&their_oid, TWO_THEIR_OID);
 267
 268         cl_git_pass(git_index_reuc_add(repo_index, "two.txt",
 269                 0100644, &ancestor_oid,
 270                 0100644, &our_oid,
 271                 0100644, &their_oid));
 272
 273         git_oid_fromstr(&ancestor_oid, ONE_ANCESTOR_OID);
 274         git_oid_fromstr(&our_oid, ONE_OUR_OID);
 275         git_oid_fromstr(&their_oid, ONE_THEIR_OID);
 276
 277         cl_git_pass(git_index_reuc_add(repo_index, "one.txt",
 278                 0100644, &ancestor_oid,
 279                 0100644, &our_oid,
 280                 0100644, &their_oid));
 281
 282         cl_git_pass(git_index_write(repo_index));
 283         cl_assert_equal_i(2, git_index_reuc_entrycount(repo_index));
 284
 285         /* ensure sort order was round-tripped correct */
 286         cl_assert(reuc = git_index_reuc_get_byindex(repo_index, 0));
 287         cl_assert_equal_s("one.txt", reuc->path);
 288
 289         cl_assert(reuc = git_index_reuc_get_byindex(repo_index, 1));
 290         cl_assert_equal_s("two.txt", reuc->path);
 291 }
 292
 293 static int reuc_entry_exists(void)
 294 {
 295         return (git_index_reuc_get_bypath(repo_index, "newfile.txt") != NULL);
 296 }
 297
 298 void test_index_reuc__cleaned_on_reset_hard(void)
 299 {
 300         git_object *target;
 301
 302         cl_git_pass(git_revparse_single(&target, repo, "3a34580"));
 303
 304         test_index_reuc__add();
 305         cl_git_pass(git_reset(repo, target, GIT_RESET_HARD, NULL));
 306         cl_assert(reuc_entry_exists() == false);
 307
 308         git_object_free(target);
 309 }
 310
 311 void test_index_reuc__cleaned_on_reset_mixed(void)
 312 {
 313         git_object *target;
 314
 315         cl_git_pass(git_revparse_single(&target, repo, "3a34580"));
 316
 317         test_index_reuc__add();
 318         cl_git_pass(git_reset(repo, target, GIT_RESET_MIXED, NULL));
 319         cl_assert(reuc_entry_exists() == false);
 320
 321         git_object_free(target);
 322 }
 323
 324 void test_index_reuc__retained_on_reset_soft(void)
 325 {
 326         git_object *target;
 327
 328         cl_git_pass(git_revparse_single(&target, repo, "3a34580"));
 329
 330         cl_git_pass(git_reset(repo, target, GIT_RESET_HARD, NULL));
 331
 332         test_index_reuc__add();
 333         cl_git_pass(git_reset(repo, target, GIT_RESET_SOFT, NULL));
 334         cl_assert(reuc_entry_exists() == true);
 335
 336         git_object_free(target);
 337 }
 338
 339 void test_index_reuc__cleaned_on_checkout_tree(void)
 340 {
 341         git_oid oid;
 342         git_object *obj;
 343         git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;
 344
 345         opts.checkout_strategy = GIT_CHECKOUT_FORCE;
 346
 347         test_index_reuc__add();
 348         cl_git_pass(git_reference_name_to_id(&oid, repo, "refs/heads/master"));
 349         cl_git_pass(git_object_lookup(&obj, repo, &oid, GIT_OBJECT_ANY));
 350         cl_git_pass(git_checkout_tree(repo, obj, &opts));
 351         cl_assert(reuc_entry_exists() == false);
 352
 353         git_object_free(obj);
 354 }
 355
 356 void test_index_reuc__cleaned_on_checkout_head(void)
 357 {
 358         git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;
 359
 360         opts.checkout_strategy = GIT_CHECKOUT_FORCE;
 361
 362         test_index_reuc__add();
 363         cl_git_pass(git_checkout_head(repo, &opts));
 364         cl_assert(reuc_entry_exists() == false);
 365 }
 366
 367 void test_index_reuc__retained_on_checkout_index(void)
 368 {
 369         git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;
 370
 371         opts.checkout_strategy = GIT_CHECKOUT_FORCE;
 372
 373         test_index_reuc__add();
 374         cl_git_pass(git_checkout_index(repo, repo_index, &opts));
 375         cl_assert(reuc_entry_exists() == true);
 376 }