t/t1000-read-tree-m-3way.sh

   1 #!/bin/sh
   2 #
   3 # Copyright (c) 2005 Junio C Hamano
   4 #
   5
   6 test_description='Three way merge with read-tree -m
   7
   8 This test tries three-way merge with read-tree -m
   9
  10 There is one ancestor (called O for Original) and two branches A
  11 and B derived from it.  We want to do a 3-way merge between A and
  12 B, using O as the common ancestor.
  13
  14     merge A O B
  15
  16 Decisions are made by comparing contents of O, A and B pathname
  17 by pathname.  The result is determined by the following guiding
  18 principle:
  19
  20  - If only A does something to it and B does not touch it, take
  21    whatever A does.
  22
  23  - If only B does something to it and A does not touch it, take
  24    whatever B does.
  25
  26  - If both A and B does something but in the same way, take
  27    whatever they do.
  28
  29  - If A and B does something but different things, we need a
  30    3-way merge:
  31
  32    - We cannot do anything about the following cases:
  33
  34      * O does not have it.  A and B both must be adding to the
  35        same path independently.
  36
  37      * A deletes it.  B must be modifying.
  38
  39    - Otherwise, A and B are modifying.  Run 3-way merge.
  40
  41 First, the case matrix.
  42
  43  - Vertical axis is for A'\''s actions.
  44  - Horizontal axis is for B'\''s actions.
  45
  46 .----------------------------------------------------------------.
  47 | A        B | No Action  |   Delete   |   Modify   |    Add     |
  48 |------------+------------+------------+------------+------------|
  49 | No Action  |            |            |            |            |
  50 |            | select O   | delete     | select B   | select B   |
  51 |            |            |            |            |            |
  52 |------------+------------+------------+------------+------------|
  53 | Delete     |            |            | ********** |    can     |
  54 |            | delete     | delete     | merge      |    not     |
  55 |            |            |            |            |  happen    |
  56 |------------+------------+------------+------------+------------|
  57 | Modify     |            | ********** | ?????????? |    can     |
  58 |            | select A   | merge      | select A=B |    not     |
  59 |            |            |            | merge      |  happen    |
  60 |------------+------------+------------+------------+------------|
  61 | Add        |            |    can     |    can     | ?????????? |
  62 |            | select A   |    not     |    not     | select A=B |
  63 |            |            |  happen    |  happen    | merge      |
  64 .----------------------------------------------------------------.
  65
  66 In addition:
  67
  68  SS: a special case of MM, where A and B makes the same modification.
  69  LL: a special case of AA, where A and B creates the same file.
  70  TT: a special case of MM, where A and B makes mergeable changes.
  71  DF: a special case, where A makes a directory and B makes a file.
  72
  73 '
  74 . ./test-lib.sh
  75 . ../lib-read-tree-m-3way.sh
  76
  77 ################################################################
  78 # Trivial "majority when 3 stages exist" merge plus #2ALT, #3ALT
  79 # and #5ALT trivial merges.
  80
  81 cat >expected <<\EOF
  82 100644 X 2      AA
  83 100644 X 3      AA
  84 100644 X 0      AN
  85 100644 X 1      DD
  86 100644 X 3      DF
  87 100644 X 2      DF/DF
  88 100644 X 1      DM
  89 100644 X 3      DM
  90 100644 X 1      DN
  91 100644 X 3      DN
  92 100644 X 0      LL
  93 100644 X 1      MD
  94 100644 X 2      MD
  95 100644 X 1      MM
  96 100644 X 2      MM
  97 100644 X 3      MM
  98 100644 X 0      MN
  99 100644 X 0      NA
 100 100644 X 1      ND
 101 100644 X 2      ND
 102 100644 X 0      NM
 103 100644 X 0      NN
 104 100644 X 0      SS
 105 100644 X 1      TT
 106 100644 X 2      TT
 107 100644 X 3      TT
 108 100644 X 2      Z/AA
 109 100644 X 3      Z/AA
 110 100644 X 0      Z/AN
 111 100644 X 1      Z/DD
 112 100644 X 1      Z/DM
 113 100644 X 3      Z/DM
 114 100644 X 1      Z/DN
 115 100644 X 3      Z/DN
 116 100644 X 1      Z/MD
 117 100644 X 2      Z/MD
 118 100644 X 1      Z/MM
 119 100644 X 2      Z/MM
 120 100644 X 3      Z/MM
 121 100644 X 0      Z/MN
 122 100644 X 0      Z/NA
 123 100644 X 1      Z/ND
 124 100644 X 2      Z/ND
 125 100644 X 0      Z/NM
 126 100644 X 0      Z/NN
 127 EOF
 128
 129 _x40='[0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f]'
 130 _x40="$_x40$_x40$_x40$_x40$_x40$_x40$_x40$_x40"
 131
 132 check_result () {
 133     git ls-files --stage | sed -e 's/ '"$_x40"' / X /' >current &&
 134     git diff expected current
 135 }
 136
 137 # This is done on an empty work directory, which is the normal
 138 # merge person behaviour.
 139 test_expect_success \
 140     '3-way merge with git read-tree -m, empty cache' \
 141     "rm -fr [NDMALTS][NDMALTSF] Z &&
 142      rm .git/index &&
 143      git read-tree -m $tree_O $tree_A $tree_B &&
 144      check_result"
 145
 146 # This starts out with the first head, which is the normal
 147 # patch submitter behaviour.
 148 test_expect_success \
 149     '3-way merge with git read-tree -m, match H' \
 150     "rm -fr [NDMALTS][NDMALTSF] Z &&
 151      rm .git/index &&
 152      git read-tree $tree_A &&
 153      git checkout-index -f -u -a &&
 154      git read-tree -m $tree_O $tree_A $tree_B &&
 155      check_result"
 156
 157 : <<\END_OF_CASE_TABLE
 158
 159 We have so far tested only empty index and clean-and-matching-A index
 160 case which are trivial.  Make sure index requirements are also
 161 checked.
 162
 163 "git read-tree -m O A B"
 164
 165      O       A       B         result      index requirements
 166 -------------------------------------------------------------------
 167   1  missing missing missing   -           must not exist.
 168  ------------------------------------------------------------------
 169   2  missing missing exists    take B*     must match B, if exists.
 170  ------------------------------------------------------------------
 171   3  missing exists  missing   take A*     must match A, if exists.
 172  ------------------------------------------------------------------
 173   4  missing exists  A!=B      no merge    must match A and be
 174                                            up-to-date, if exists.
 175  ------------------------------------------------------------------
 176   5  missing exists  A==B      take A      must match A, if exists.
 177  ------------------------------------------------------------------
 178   6  exists  missing missing   remove      must not exist.
 179  ------------------------------------------------------------------
 180   7  exists  missing O!=B      no merge    must not exist.
 181  ------------------------------------------------------------------
 182   8  exists  missing O==B      remove      must not exist.
 183  ------------------------------------------------------------------
 184   9  exists  O!=A    missing   no merge    must match A and be
 185                                            up-to-date, if exists.
 186  ------------------------------------------------------------------
 187  10  exists  O==A    missing   no merge    must match A
 188  ------------------------------------------------------------------
 189  11  exists  O!=A    O!=B      no merge    must match A and be
 190                      A!=B                  up-to-date, if exists.
 191  ------------------------------------------------------------------
 192  12  exists  O!=A    O!=B      take A      must match A, if exists.
 193                      A==B
 194  ------------------------------------------------------------------
 195  13  exists  O!=A    O==B      take A      must match A, if exists.
 196  ------------------------------------------------------------------
 197  14  exists  O==A    O!=B      take B      if exists, must either (1)
 198                                            match A and be up-to-date,
 199                                            or (2) match B.
 200  ------------------------------------------------------------------
 201  15  exists  O==A    O==B      take B      must match A if exists.
 202  ------------------------------------------------------------------
 203  16  exists  O==A    O==B      barf        must match A if exists.
 204      *multi* in one  in another
 205 -------------------------------------------------------------------
 206
 207 Note: we need to be careful in case 2 and 3.  The tree A may contain
 208 DF (file) when tree B require DF to be a directory by having DF/DF
 209 (file).
 210
 211 END_OF_CASE_TABLE
 212
 213 test_expect_success '1 - must not have an entry not in A.' "
 214      rm -f .git/index XX &&
 215      echo XX >XX &&
 216      git update-index --add XX &&
 217      ! git read-tree -m $tree_O $tree_A $tree_B
 218 "
 219
 220 test_expect_success \
 221     '2 - must match B in !O && !A && B case.' \
 222     "rm -f .git/index NA &&
 223      cp .orig-B/NA NA &&
 224      git update-index --add NA &&
 225      git read-tree -m $tree_O $tree_A $tree_B"
 226
 227 test_expect_success \
 228     '2 - matching B alone is OK in !O && !A && B case.' \
 229     "rm -f .git/index NA &&
 230      cp .orig-B/NA NA &&
 231      git update-index --add NA &&
 232      echo extra >>NA &&
 233      git read-tree -m $tree_O $tree_A $tree_B"
 234
 235 test_expect_success \
 236     '3 - must match A in !O && A && !B case.' \
 237     "rm -f .git/index AN &&
 238      cp .orig-A/AN AN &&
 239      git update-index --add AN &&
 240      git read-tree -m $tree_O $tree_A $tree_B &&
 241      check_result"
 242
 243 test_expect_success \
 244     '3 - matching A alone is OK in !O && A && !B case.' \
 245     "rm -f .git/index AN &&
 246      cp .orig-A/AN AN &&
 247      git update-index --add AN &&
 248      echo extra >>AN &&
 249      git read-tree -m $tree_O $tree_A $tree_B"
 250
 251 test_expect_success \
 252     '3 (fail) - must match A in !O && A && !B case.' "
 253      rm -f .git/index AN &&
 254      cp .orig-A/AN AN &&
 255      echo extra >>AN &&
 256      git update-index --add AN &&
 257      ! git read-tree -m $tree_O $tree_A $tree_B
 258 "
 259
 260 test_expect_success \
 261     '4 - must match and be up-to-date in !O && A && B && A!=B case.' \
 262     "rm -f .git/index AA &&
 263      cp .orig-A/AA AA &&
 264      git update-index --add AA &&
 265      git read-tree -m $tree_O $tree_A $tree_B &&
 266      check_result"
 267
 268 test_expect_success \
 269     '4 (fail) - must match and be up-to-date in !O && A && B && A!=B case.' "
 270      rm -f .git/index AA &&
 271      cp .orig-A/AA AA &&
 272      git update-index --add AA &&
 273      echo extra >>AA &&
 274      ! git read-tree -m $tree_O $tree_A $tree_B
 275 "
 276
 277 test_expect_success \
 278     '4 (fail) - must match and be up-to-date in !O && A && B && A!=B case.' "
 279      rm -f .git/index AA &&
 280      cp .orig-A/AA AA &&
 281      echo extra >>AA &&
 282      git update-index --add AA &&
 283      ! git read-tree -m $tree_O $tree_A $tree_B
 284 "
 285
 286 test_expect_success \
 287     '5 - must match in !O && A && B && A==B case.' \
 288     "rm -f .git/index LL &&
 289      cp .orig-A/LL LL &&
 290      git update-index --add LL &&
 291      git read-tree -m $tree_O $tree_A $tree_B &&
 292      check_result"
 293
 294 test_expect_success \
 295     '5 - must match in !O && A && B && A==B case.' \
 296     "rm -f .git/index LL &&
 297      cp .orig-A/LL LL &&
 298      git update-index --add LL &&
 299      echo extra >>LL &&
 300      git read-tree -m $tree_O $tree_A $tree_B &&
 301      check_result"
 302
 303 test_expect_success \
 304     '5 (fail) - must match A in !O && A && B && A==B case.' "
 305      rm -f .git/index LL &&
 306      cp .orig-A/LL LL &&
 307      echo extra >>LL &&
 308      git update-index --add LL &&
 309      ! git read-tree -m $tree_O $tree_A $tree_B
 310 "
 311
 312 test_expect_success \
 313     '6 - must not exist in O && !A && !B case' "
 314      rm -f .git/index DD &&
 315      echo DD >DD
 316      git update-index --add DD &&
 317      ! git read-tree -m $tree_O $tree_A $tree_B
 318 "
 319
 320 test_expect_success \
 321     '7 - must not exist in O && !A && B && O!=B case' "
 322      rm -f .git/index DM &&
 323      cp .orig-B/DM DM &&
 324      git update-index --add DM &&
 325      ! git read-tree -m $tree_O $tree_A $tree_B
 326 "
 327
 328 test_expect_success \
 329     '8 - must not exist in O && !A && B && O==B case' "
 330      rm -f .git/index DN &&
 331      cp .orig-B/DN DN &&
 332      git update-index --add DN &&
 333      ! git read-tree -m $tree_O $tree_A $tree_B
 334 "
 335
 336 test_expect_success \
 337     '9 - must match and be up-to-date in O && A && !B && O!=A case' \
 338     "rm -f .git/index MD &&
 339      cp .orig-A/MD MD &&
 340      git update-index --add MD &&
 341      git read-tree -m $tree_O $tree_A $tree_B &&
 342      check_result"
 343
 344 test_expect_success \
 345     '9 (fail) - must match and be up-to-date in O && A && !B && O!=A case' "
 346      rm -f .git/index MD &&
 347      cp .orig-A/MD MD &&
 348      git update-index --add MD &&
 349      echo extra >>MD &&
 350      ! git read-tree -m $tree_O $tree_A $tree_B
 351 "
 352
 353 test_expect_success \
 354     '9 (fail) - must match and be up-to-date in O && A && !B && O!=A case' "
 355      rm -f .git/index MD &&
 356      cp .orig-A/MD MD &&
 357      echo extra >>MD &&
 358      git update-index --add MD &&
 359      ! git read-tree -m $tree_O $tree_A $tree_B
 360 "
 361
 362 test_expect_success \
 363     '10 - must match and be up-to-date in O && A && !B && O==A case' \
 364     "rm -f .git/index ND &&
 365      cp .orig-A/ND ND &&
 366      git update-index --add ND &&
 367      git read-tree -m $tree_O $tree_A $tree_B &&
 368      check_result"
 369
 370 test_expect_success \
 371     '10 (fail) - must match and be up-to-date in O && A && !B && O==A case' "
 372      rm -f .git/index ND &&
 373      cp .orig-A/ND ND &&
 374      git update-index --add ND &&
 375      echo extra >>ND &&
 376      ! git read-tree -m $tree_O $tree_A $tree_B
 377 "
 378
 379 test_expect_success \
 380     '10 (fail) - must match and be up-to-date in O && A && !B && O==A case' "
 381      rm -f .git/index ND &&
 382      cp .orig-A/ND ND &&
 383      echo extra >>ND &&
 384      git update-index --add ND &&
 385      ! git read-tree -m $tree_O $tree_A $tree_B
 386 "
 387
 388 test_expect_success \
 389     '11 - must match and be up-to-date in O && A && B && O!=A && O!=B && A!=B case' \
 390     "rm -f .git/index MM &&
 391      cp .orig-A/MM MM &&
 392      git update-index --add MM &&
 393      git read-tree -m $tree_O $tree_A $tree_B &&
 394      check_result"
 395
 396 test_expect_success \
 397     '11 (fail) - must match and be up-to-date in O && A && B && O!=A && O!=B && A!=B case' "
 398      rm -f .git/index MM &&
 399      cp .orig-A/MM MM &&
 400      git update-index --add MM &&
 401      echo extra >>MM &&
 402      ! git read-tree -m $tree_O $tree_A $tree_B
 403 "
 404
 405 test_expect_success \
 406     '11 (fail) - must match and be up-to-date in O && A && B && O!=A && O!=B && A!=B case' "
 407      rm -f .git/index MM &&
 408      cp .orig-A/MM MM &&
 409      echo extra >>MM &&
 410      git update-index --add MM &&
 411      ! git read-tree -m $tree_O $tree_A $tree_B
 412 "
 413
 414 test_expect_success \
 415     '12 - must match A in O && A && B && O!=A && A==B case' \
 416     "rm -f .git/index SS &&
 417      cp .orig-A/SS SS &&
 418      git update-index --add SS &&
 419      git read-tree -m $tree_O $tree_A $tree_B &&
 420      check_result"
 421
 422 test_expect_success \
 423     '12 - must match A in O && A && B && O!=A && A==B case' \
 424     "rm -f .git/index SS &&
 425      cp .orig-A/SS SS &&
 426      git update-index --add SS &&
 427      echo extra >>SS &&
 428      git read-tree -m $tree_O $tree_A $tree_B &&
 429      check_result"
 430
 431 test_expect_success \
 432     '12 (fail) - must match A in O && A && B && O!=A && A==B case' "
 433      rm -f .git/index SS &&
 434      cp .orig-A/SS SS &&
 435      echo extra >>SS &&
 436      git update-index --add SS &&
 437      ! git read-tree -m $tree_O $tree_A $tree_B
 438 "
 439
 440 test_expect_success \
 441     '13 - must match A in O && A && B && O!=A && O==B case' \
 442     "rm -f .git/index MN &&
 443      cp .orig-A/MN MN &&
 444      git update-index --add MN &&
 445      git read-tree -m $tree_O $tree_A $tree_B &&
 446      check_result"
 447
 448 test_expect_success \
 449     '13 - must match A in O && A && B && O!=A && O==B case' \
 450     "rm -f .git/index MN &&
 451      cp .orig-A/MN MN &&
 452      git update-index --add MN &&
 453      echo extra >>MN &&
 454      git read-tree -m $tree_O $tree_A $tree_B &&
 455      check_result"
 456
 457 test_expect_success \
 458     '14 - must match and be up-to-date in O && A && B && O==A && O!=B case' \
 459     "rm -f .git/index NM &&
 460      cp .orig-A/NM NM &&
 461      git update-index --add NM &&
 462      git read-tree -m $tree_O $tree_A $tree_B &&
 463      check_result"
 464
 465 test_expect_success \
 466     '14 - may match B in O && A && B && O==A && O!=B case' \
 467     "rm -f .git/index NM &&
 468      cp .orig-B/NM NM &&
 469      git update-index --add NM &&
 470      echo extra >>NM &&
 471      git read-tree -m $tree_O $tree_A $tree_B &&
 472      check_result"
 473
 474 test_expect_success \
 475     '14 (fail) - must match and be up-to-date in O && A && B && O==A && O!=B case' "
 476      rm -f .git/index NM &&
 477      cp .orig-A/NM NM &&
 478      git update-index --add NM &&
 479      echo extra >>NM &&
 480      ! git read-tree -m $tree_O $tree_A $tree_B
 481 "
 482
 483 test_expect_success \
 484     '14 (fail) - must match and be up-to-date in O && A && B && O==A && O!=B case' "
 485      rm -f .git/index NM &&
 486      cp .orig-A/NM NM &&
 487      echo extra >>NM &&
 488      git update-index --add NM &&
 489      ! git read-tree -m $tree_O $tree_A $tree_B
 490 "
 491
 492 test_expect_success \
 493     '15 - must match A in O && A && B && O==A && O==B case' \
 494     "rm -f .git/index NN &&
 495      cp .orig-A/NN NN &&
 496      git update-index --add NN &&
 497      git read-tree -m $tree_O $tree_A $tree_B &&
 498      check_result"
 499
 500 test_expect_success \
 501     '15 - must match A in O && A && B && O==A && O==B case' \
 502     "rm -f .git/index NN &&
 503      cp .orig-A/NN NN &&
 504      git update-index --add NN &&
 505      echo extra >>NN &&
 506      git read-tree -m $tree_O $tree_A $tree_B &&
 507      check_result"
 508
 509 test_expect_success \
 510     '15 (fail) - must match A in O && A && B && O==A && O==B case' "
 511      rm -f .git/index NN &&
 512      cp .orig-A/NN NN &&
 513      echo extra >>NN &&
 514      git update-index --add NN &&
 515      ! git read-tree -m $tree_O $tree_A $tree_B
 516 "
 517
 518 # #16
 519 test_expect_success \
 520     '16 - A matches in one and B matches in another.' \
 521     'rm -f .git/index F16 &&
 522     echo F16 >F16 &&
 523     git update-index --add F16 &&
 524     tree0=`git write-tree` &&
 525     echo E16 >F16 &&
 526     git update-index F16 &&
 527     tree1=`git write-tree` &&
 528     git read-tree -m $tree0 $tree1 $tree1 $tree0 &&
 529     git ls-files --stage'
 530
 531 test_done