git.oblomov.eu Git - git/blob - contrib/subtree/t/t7900-subtree.sh

   1 #!/bin/sh
   2 #
   3 # Copyright (c) 2012 Avery Pennaraum
   4 # Copyright (c) 2015 Alexey Shumkin
   5 #
   6 test_description='Basic porcelain support for subtrees
   7
   8 This test verifies the basic operation of the add, pull, merge
   9 and split subcommands of git subtree.
  10 '
  11
  12 TEST_DIRECTORY=$(pwd)/../../../t
  13 export TEST_DIRECTORY
  14
  15 . ../../../t/test-lib.sh
  16
  17 subtree_test_create_repo()
  18 {
  19         test_create_repo "$1" &&
  20         (
  21                 cd "$1" &&
  22                 git config log.date relative
  23         )
  24 }
  25
  26 create()
  27 {
  28         echo "$1" >"$1" &&
  29         git add "$1"
  30 }
  31
  32 check_equal()
  33 {
  34         test_debug 'echo'
  35         test_debug "echo \"check a:\" \"{$1}\""
  36         test_debug "echo \"      b:\" \"{$2}\""
  37         if [ "$1" = "$2" ]; then
  38                 return 0
  39         else
  40                 return 1
  41         fi
  42 }
  43
  44 undo()
  45 {
  46         git reset --hard HEAD~
  47 }
  48
  49 # Make sure no patch changes more than one file.
  50 # The original set of commits changed only one file each.
  51 # A multi-file change would imply that we pruned commits
  52 # too aggressively.
  53 join_commits()
  54 {
  55         commit=
  56         all=
  57         while read x y; do
  58                 if [ -z "$x" ]; then
  59                         continue
  60                 elif [ "$x" = "commit:" ]; then
  61                         if [ -n "$commit" ]; then
  62                                 echo "$commit $all"
  63                                 all=
  64                         fi
  65                         commit="$y"
  66                 else
  67                         all="$all $y"
  68                 fi
  69         done
  70         echo "$commit $all"
  71 }
  72
  73 test_create_commit() (
  74         repo=$1 &&
  75         commit=$2 &&
  76         cd "$repo" &&
  77         mkdir -p "$(dirname "$commit")" \
  78         || error "Could not create directory for commit"
  79         echo "$commit" >"$commit" &&
  80         git add "$commit" || error "Could not add commit"
  81         git commit -m "$commit" || error "Could not commit"
  82 )
  83
  84 last_commit_message()
  85 {
  86         git log --pretty=format:%s -1
  87 }
  88
  89 subtree_test_count=0
  90 next_test() {
  91         subtree_test_count=$(($subtree_test_count+1))
  92 }
  93
  94 #
  95 # Tests for 'git subtree add'
  96 #
  97
  98 next_test
  99 test_expect_success 'no merge from non-existent subtree' '
 100         subtree_test_create_repo "$subtree_test_count" &&
 101         subtree_test_create_repo "$subtree_test_count/sub proj" &&
 102         test_create_commit "$subtree_test_count" main1 &&
 103         test_create_commit "$subtree_test_count/sub proj" sub1 &&
 104         (
 105                 cd "$subtree_test_count" &&
 106                 git fetch ./"sub proj" master &&
 107                 test_must_fail git subtree merge --prefix="sub dir" FETCH_HEAD
 108         )
 109 '
 110
 111 next_test
 112 test_expect_success 'no pull from non-existent subtree' '
 113         subtree_test_create_repo "$subtree_test_count" &&
 114         subtree_test_create_repo "$subtree_test_count/sub proj" &&
 115         test_create_commit "$subtree_test_count" main1 &&
 116         test_create_commit "$subtree_test_count/sub proj" sub1 &&
 117         (
 118                 cd "$subtree_test_count" &&
 119                 git fetch ./"sub proj" master &&
 120                 test_must_fail git subtree pull --prefix="sub dir" ./"sub proj" master
 121         )'
 122
 123 next_test
 124 test_expect_success 'add subproj as subtree into sub dir/ with --prefix' '
 125         subtree_test_create_repo "$subtree_test_count" &&
 126         subtree_test_create_repo "$subtree_test_count/sub proj" &&
 127         test_create_commit "$subtree_test_count" main1 &&
 128         test_create_commit "$subtree_test_count/sub proj" sub1 &&
 129         (
 130                 cd "$subtree_test_count" &&
 131                 git fetch ./"sub proj" master &&
 132                 git subtree add --prefix="sub dir" FETCH_HEAD &&
 133                 check_equal "$(last_commit_message)" "Add '\''sub dir/'\'' from commit '\''$(git rev-parse FETCH_HEAD)'\''"
 134         )
 135 '
 136
 137 next_test
 138 test_expect_success 'add subproj as subtree into sub dir/ with --prefix and --message' '
 139         subtree_test_create_repo "$subtree_test_count" &&
 140         subtree_test_create_repo "$subtree_test_count/sub proj" &&
 141         test_create_commit "$subtree_test_count" main1 &&
 142         test_create_commit "$subtree_test_count/sub proj" sub1 &&
 143         (
 144                 cd "$subtree_test_count" &&
 145                 git fetch ./"sub proj" master &&
 146                 git subtree add --prefix="sub dir" --message="Added subproject" FETCH_HEAD &&
 147                 check_equal "$(last_commit_message)" "Added subproject"
 148         )
 149 '
 150
 151 next_test
 152 test_expect_success 'add subproj as subtree into sub dir/ with --prefix as -P and --message as -m' '
 153         subtree_test_create_repo "$subtree_test_count" &&
 154         subtree_test_create_repo "$subtree_test_count/sub proj" &&
 155         test_create_commit "$subtree_test_count" main1 &&
 156         test_create_commit "$subtree_test_count/sub proj" sub1 &&
 157         (
 158                 cd "$subtree_test_count" &&
 159                 git fetch ./"sub proj" master &&
 160                 git subtree add -P "sub dir" -m "Added subproject" FETCH_HEAD &&
 161                 check_equal "$(last_commit_message)" "Added subproject"
 162         )
 163 '
 164
 165 next_test
 166 test_expect_success 'add subproj as subtree into sub dir/ with --squash and --prefix and --message' '
 167         subtree_test_create_repo "$subtree_test_count" &&
 168         subtree_test_create_repo "$subtree_test_count/sub proj" &&
 169         test_create_commit "$subtree_test_count" main1 &&
 170         test_create_commit "$subtree_test_count/sub proj" sub1 &&
 171         (
 172                 cd "$subtree_test_count" &&
 173                 git fetch ./"sub proj" master &&
 174                 git subtree add --prefix="sub dir" --message="Added subproject with squash" --squash FETCH_HEAD &&
 175                 check_equal "$(last_commit_message)" "Added subproject with squash"
 176         )
 177 '
 178
 179 #
 180 # Tests for 'git subtree merge'
 181 #
 182
 183 next_test
 184 test_expect_success 'merge new subproj history into sub dir/ with --prefix' '
 185         subtree_test_create_repo "$subtree_test_count" &&
 186         subtree_test_create_repo "$subtree_test_count/sub proj" &&
 187         test_create_commit "$subtree_test_count" main1 &&
 188         test_create_commit "$subtree_test_count/sub proj" sub1 &&
 189         (
 190                 cd "$subtree_test_count" &&
 191                 git fetch ./"sub proj" master &&
 192                 git subtree add --prefix="sub dir" FETCH_HEAD
 193         ) &&
 194         test_create_commit "$subtree_test_count/sub proj" sub2 &&
 195         (
 196                 cd "$subtree_test_count" &&
 197                 git fetch ./"sub proj" master &&
 198                 git subtree merge --prefix="sub dir" FETCH_HEAD &&
 199                 check_equal "$(last_commit_message)" "Merge commit '\''$(git rev-parse FETCH_HEAD)'\''"
 200         )
 201 '
 202
 203 next_test
 204 test_expect_success 'merge new subproj history into sub dir/ with --prefix and --message' '
 205         subtree_test_create_repo "$subtree_test_count" &&
 206         subtree_test_create_repo "$subtree_test_count/sub proj" &&
 207         test_create_commit "$subtree_test_count" main1 &&
 208         test_create_commit "$subtree_test_count/sub proj" sub1 &&
 209         (
 210                 cd "$subtree_test_count" &&
 211                 git fetch ./"sub proj" master &&
 212                 git subtree add --prefix="sub dir" FETCH_HEAD
 213         ) &&
 214         test_create_commit "$subtree_test_count/sub proj" sub2 &&
 215         (
 216                 cd "$subtree_test_count" &&
 217                 git fetch ./"sub proj" master &&
 218                 git subtree merge --prefix="sub dir" --message="Merged changes from subproject" FETCH_HEAD &&
 219                 check_equal "$(last_commit_message)" "Merged changes from subproject"
 220         )
 221 '
 222
 223 next_test
 224 test_expect_success 'merge new subproj history into sub dir/ with --squash and --prefix and --message' '
 225         subtree_test_create_repo "$subtree_test_count/sub proj" &&
 226         subtree_test_create_repo "$subtree_test_count" &&
 227         test_create_commit "$subtree_test_count" main1 &&
 228         test_create_commit "$subtree_test_count/sub proj" sub1 &&
 229         (
 230                 cd "$subtree_test_count" &&
 231                 git fetch ./"sub proj" master &&
 232                 git subtree add --prefix="sub dir" FETCH_HEAD
 233         ) &&
 234         test_create_commit "$subtree_test_count/sub proj" sub2 &&
 235         (
 236                 cd "$subtree_test_count" &&
 237                 git fetch ./"sub proj" master &&
 238                 git subtree merge --prefix="sub dir" --message="Merged changes from subproject using squash" --squash FETCH_HEAD &&
 239                 check_equal "$(last_commit_message)" "Merged changes from subproject using squash"
 240         )
 241 '
 242
 243 next_test
 244 test_expect_success 'merge the added subproj again, should do nothing' '
 245         subtree_test_create_repo "$subtree_test_count" &&
 246         subtree_test_create_repo "$subtree_test_count/sub proj" &&
 247         test_create_commit "$subtree_test_count" main1 &&
 248         test_create_commit "$subtree_test_count/sub proj" sub1 &&
 249         (
 250                 cd "$subtree_test_count" &&
 251                 git fetch ./"sub proj" master &&
 252                 git subtree add --prefix="sub dir" FETCH_HEAD &&
 253                 # this shouldn not actually do anything, since FETCH_HEAD
 254                 # is already a parent
 255                 result=$(git merge -s ours -m "merge -s -ours" FETCH_HEAD) &&
 256                 check_equal "${result}" "Already up to date."
 257         )
 258 '
 259
 260 next_test
 261 test_expect_success 'merge new subproj history into subdir/ with a slash appended to the argument of --prefix' '
 262         test_create_repo "$test_count" &&
 263         test_create_repo "$test_count/subproj" &&
 264         test_create_commit "$test_count" main1 &&
 265         test_create_commit "$test_count/subproj" sub1 &&
 266         (
 267                 cd "$test_count" &&
 268                 git fetch ./subproj master &&
 269                 git subtree add --prefix=subdir/ FETCH_HEAD
 270         ) &&
 271         test_create_commit "$test_count/subproj" sub2 &&
 272         (
 273                 cd "$test_count" &&
 274                 git fetch ./subproj master &&
 275                 git subtree merge --prefix=subdir/ FETCH_HEAD &&
 276                 check_equal "$(last_commit_message)" "Merge commit '\''$(git rev-parse FETCH_HEAD)'\''"
 277         )
 278 '
 279
 280 #
 281 # Tests for 'git subtree split'
 282 #
 283
 284 next_test
 285 test_expect_success 'split requires option --prefix' '
 286         subtree_test_create_repo "$subtree_test_count" &&
 287         subtree_test_create_repo "$subtree_test_count/sub proj" &&
 288         test_create_commit "$subtree_test_count" main1 &&
 289         test_create_commit "$subtree_test_count/sub proj" sub1 &&
 290         (
 291                 cd "$subtree_test_count" &&
 292                 git fetch ./"sub proj" master &&
 293                 git subtree add --prefix="sub dir" FETCH_HEAD &&
 294                 echo "You must provide the --prefix option." > expected &&
 295                 test_must_fail git subtree split > actual 2>&1 &&
 296                 test_debug "printf '"expected: "'" &&
 297                 test_debug "cat expected" &&
 298                 test_debug "printf '"actual: "'" &&
 299                 test_debug "cat actual" &&
 300                 test_cmp expected actual
 301         )
 302 '
 303
 304 next_test
 305 test_expect_success 'split requires path given by option --prefix must exist' '
 306         subtree_test_create_repo "$subtree_test_count" &&
 307         subtree_test_create_repo "$subtree_test_count/sub proj" &&
 308         test_create_commit "$subtree_test_count" main1 &&
 309         test_create_commit "$subtree_test_count/sub proj" sub1 &&
 310         (
 311                 cd "$subtree_test_count" &&
 312                 git fetch ./"sub proj" master &&
 313                 git subtree add --prefix="sub dir" FETCH_HEAD &&
 314                 echo "'\''non-existent-directory'\'' does not exist; use '\''git subtree add'\''" > expected &&
 315                 test_must_fail git subtree split --prefix=non-existent-directory > actual 2>&1 &&
 316                 test_debug "printf '"expected: "'" &&
 317                 test_debug "cat expected" &&
 318                 test_debug "printf '"actual: "'" &&
 319                 test_debug "cat actual" &&
 320                 test_cmp expected actual
 321         )
 322 '
 323
 324 next_test
 325 test_expect_success 'split sub dir/ with --rejoin' '
 326         subtree_test_create_repo "$subtree_test_count" &&
 327         subtree_test_create_repo "$subtree_test_count/sub proj" &&
 328         test_create_commit "$subtree_test_count" main1 &&
 329         test_create_commit "$subtree_test_count/sub proj" sub1 &&
 330         (
 331                 cd "$subtree_test_count" &&
 332                 git fetch ./"sub proj" master &&
 333                 git subtree add --prefix="sub dir" FETCH_HEAD
 334         ) &&
 335         test_create_commit "$subtree_test_count" "sub dir"/main-sub1 &&
 336         test_create_commit "$subtree_test_count" main2 &&
 337         test_create_commit "$subtree_test_count/sub proj" sub2 &&
 338         test_create_commit "$subtree_test_count" "sub dir"/main-sub2 &&
 339         (
 340                 cd "$subtree_test_count" &&
 341                 git fetch ./"sub proj" master &&
 342                 git subtree merge --prefix="sub dir" FETCH_HEAD &&
 343                 split_hash=$(git subtree split --prefix="sub dir" --annotate="*") &&
 344                 git subtree split --prefix="sub dir" --annotate="*" --rejoin &&
 345                 check_equal "$(last_commit_message)" "Split '\''sub dir/'\'' into commit '\''$split_hash'\''"
 346         )
 347  '
 348
 349 next_test
 350 test_expect_success 'split sub dir/ with --rejoin from scratch' '
 351         subtree_test_create_repo "$subtree_test_count" &&
 352         test_create_commit "$subtree_test_count" main1 &&
 353         (
 354                 cd "$subtree_test_count" &&
 355                 mkdir "sub dir" &&
 356                 echo file >"sub dir"/file &&
 357                 git add "sub dir/file" &&
 358                 git commit -m"sub dir file" &&
 359                 split_hash=$(git subtree split --prefix="sub dir" --rejoin) &&
 360                 git subtree split --prefix="sub dir" --rejoin &&
 361                 check_equal "$(last_commit_message)" "Split '\''sub dir/'\'' into commit '\''$split_hash'\''"
 362         )
 363  '
 364
 365 next_test
 366 test_expect_success 'split sub dir/ with --rejoin and --message' '
 367         subtree_test_create_repo "$subtree_test_count" &&
 368         subtree_test_create_repo "$subtree_test_count/sub proj" &&
 369         test_create_commit "$subtree_test_count" main1 &&
 370         test_create_commit "$subtree_test_count/sub proj" sub1 &&
 371         (
 372                 cd "$subtree_test_count" &&
 373                 git fetch ./"sub proj" master &&
 374                 git subtree add --prefix="sub dir" FETCH_HEAD
 375         ) &&
 376         test_create_commit "$subtree_test_count" "sub dir"/main-sub1 &&
 377         test_create_commit "$subtree_test_count" main2 &&
 378         test_create_commit "$subtree_test_count/sub proj" sub2 &&
 379         test_create_commit "$subtree_test_count" "sub dir"/main-sub2 &&
 380         (
 381                 cd "$subtree_test_count" &&
 382                 git fetch ./"sub proj" master &&
 383                 git subtree merge --prefix="sub dir" FETCH_HEAD &&
 384                 git subtree split --prefix="sub dir" --message="Split & rejoin" --annotate="*" --rejoin &&
 385                 check_equal "$(last_commit_message)" "Split & rejoin"
 386         )
 387 '
 388
 389 next_test
 390 test_expect_success 'split "sub dir"/ with --branch' '
 391         subtree_test_create_repo "$subtree_test_count" &&
 392         subtree_test_create_repo "$subtree_test_count/sub proj" &&
 393         test_create_commit "$subtree_test_count" main1 &&
 394         test_create_commit "$subtree_test_count/sub proj" sub1 &&
 395         (
 396                 cd "$subtree_test_count" &&
 397                 git fetch ./"sub proj" master &&
 398                 git subtree add --prefix="sub dir" FETCH_HEAD
 399         ) &&
 400         test_create_commit "$subtree_test_count" "sub dir"/main-sub1 &&
 401         test_create_commit "$subtree_test_count" main2 &&
 402         test_create_commit "$subtree_test_count/sub proj" sub2 &&
 403         test_create_commit "$subtree_test_count" "sub dir"/main-sub2 &&
 404         (
 405                 cd "$subtree_test_count" &&
 406                 git fetch ./"sub proj" master &&
 407                 git subtree merge --prefix="sub dir" FETCH_HEAD &&
 408                 split_hash=$(git subtree split --prefix="sub dir" --annotate="*") &&
 409                 git subtree split --prefix="sub dir" --annotate="*" --branch subproj-br &&
 410                 check_equal "$(git rev-parse subproj-br)" "$split_hash"
 411         )
 412 '
 413
 414 next_test
 415 test_expect_success 'check hash of split' '
 416         subtree_test_create_repo "$subtree_test_count" &&
 417         subtree_test_create_repo "$subtree_test_count/sub proj" &&
 418         test_create_commit "$subtree_test_count" main1 &&
 419         test_create_commit "$subtree_test_count/sub proj" sub1 &&
 420         (
 421                 cd "$subtree_test_count" &&
 422                 git fetch ./"sub proj" master &&
 423                 git subtree add --prefix="sub dir" FETCH_HEAD
 424         ) &&
 425         test_create_commit "$subtree_test_count" "sub dir"/main-sub1 &&
 426         test_create_commit "$subtree_test_count" main2 &&
 427         test_create_commit "$subtree_test_count/sub proj" sub2 &&
 428         test_create_commit "$subtree_test_count" "sub dir"/main-sub2 &&
 429         (
 430                 cd "$subtree_test_count" &&
 431                 git fetch ./"sub proj" master &&
 432                 git subtree merge --prefix="sub dir" FETCH_HEAD &&
 433                 split_hash=$(git subtree split --prefix="sub dir" --annotate="*") &&
 434                 git subtree split --prefix="sub dir" --annotate="*" --branch subproj-br &&
 435                 check_equal "$(git rev-parse subproj-br)" "$split_hash" &&
 436                 # Check hash of split
 437                 new_hash=$(git rev-parse subproj-br^2) &&
 438                 (
 439                         cd ./"sub proj" &&
 440                         subdir_hash=$(git rev-parse HEAD) &&
 441                         check_equal ''"$new_hash"'' "$subdir_hash"
 442                 )
 443         )
 444 '
 445
 446 next_test
 447 test_expect_success 'split "sub dir"/ with --branch for an existing branch' '
 448         subtree_test_create_repo "$subtree_test_count" &&
 449         subtree_test_create_repo "$subtree_test_count/sub proj" &&
 450         test_create_commit "$subtree_test_count" main1 &&
 451         test_create_commit "$subtree_test_count/sub proj" sub1 &&
 452         (
 453                 cd "$subtree_test_count" &&
 454                 git fetch ./"sub proj" master &&
 455                 git branch subproj-br FETCH_HEAD &&
 456                 git subtree add --prefix="sub dir" FETCH_HEAD
 457         ) &&
 458         test_create_commit "$subtree_test_count" "sub dir"/main-sub1 &&
 459         test_create_commit "$subtree_test_count" main2 &&
 460         test_create_commit "$subtree_test_count/sub proj" sub2 &&
 461         test_create_commit "$subtree_test_count" "sub dir"/main-sub2 &&
 462         (
 463                 cd "$subtree_test_count" &&
 464                 git fetch ./"sub proj" master &&
 465                 git subtree merge --prefix="sub dir" FETCH_HEAD &&
 466                 split_hash=$(git subtree split --prefix="sub dir" --annotate="*") &&
 467                 git subtree split --prefix="sub dir" --annotate="*" --branch subproj-br &&
 468                 check_equal "$(git rev-parse subproj-br)" "$split_hash"
 469         )
 470 '
 471
 472 next_test
 473 test_expect_success 'split "sub dir"/ with --branch for an incompatible branch' '
 474         subtree_test_create_repo "$subtree_test_count" &&
 475         subtree_test_create_repo "$subtree_test_count/sub proj" &&
 476         test_create_commit "$subtree_test_count" main1 &&
 477         test_create_commit "$subtree_test_count/sub proj" sub1 &&
 478         (
 479                 cd "$subtree_test_count" &&
 480                 git branch init HEAD &&
 481                 git fetch ./"sub proj" master &&
 482                 git subtree add --prefix="sub dir" FETCH_HEAD
 483         ) &&
 484         test_create_commit "$subtree_test_count" "sub dir"/main-sub1 &&
 485         test_create_commit "$subtree_test_count" main2 &&
 486         test_create_commit "$subtree_test_count/sub proj" sub2 &&
 487         test_create_commit "$subtree_test_count" "sub dir"/main-sub2 &&
 488         (
 489                 cd "$subtree_test_count" &&
 490                 git fetch ./"sub proj" master &&
 491                 git subtree merge --prefix="sub dir" FETCH_HEAD &&
 492                 test_must_fail git subtree split --prefix="sub dir" --branch init
 493         )
 494 '
 495
 496 #
 497 # Validity checking
 498 #
 499
 500 next_test
 501 test_expect_success 'make sure exactly the right set of files ends up in the subproj' '
 502         subtree_test_create_repo "$subtree_test_count" &&
 503         subtree_test_create_repo "$subtree_test_count/sub proj" &&
 504         test_create_commit "$subtree_test_count" main1 &&
 505         test_create_commit "$subtree_test_count/sub proj" sub1 &&
 506         (
 507                 cd "$subtree_test_count" &&
 508                 git fetch ./"sub proj" master &&
 509                 git subtree add --prefix="sub dir" FETCH_HEAD
 510         ) &&
 511         test_create_commit "$subtree_test_count" "sub dir"/main-sub1 &&
 512         test_create_commit "$subtree_test_count" main2 &&
 513         test_create_commit "$subtree_test_count/sub proj" sub2 &&
 514         test_create_commit "$subtree_test_count" "sub dir"/main-sub2 &&
 515         (
 516                 cd "$subtree_test_count" &&
 517                 git fetch ./"sub proj" master &&
 518                 git subtree merge --prefix="sub dir" FETCH_HEAD &&
 519                 git subtree split --prefix="sub dir" --annotate="*" --branch subproj-br --rejoin
 520         ) &&
 521         test_create_commit "$subtree_test_count/sub proj" sub3 &&
 522         test_create_commit "$subtree_test_count" "sub dir"/main-sub3 &&
 523         (
 524                 cd "$subtree_test_count/sub proj" &&
 525                 git fetch .. subproj-br &&
 526                 git merge FETCH_HEAD
 527         ) &&
 528         test_create_commit "$subtree_test_count/sub proj" sub4 &&
 529         (
 530                 cd "$subtree_test_count" &&
 531                 git subtree split --prefix="sub dir" --annotate="*" --branch subproj-br --rejoin
 532         ) &&
 533         test_create_commit "$subtree_test_count" "sub dir"/main-sub4 &&
 534         (
 535                 cd "$subtree_test_count" &&
 536                 git subtree split --prefix="sub dir" --annotate="*" --branch subproj-br --rejoin
 537         ) &&
 538         (
 539                 cd "$subtree_test_count/sub proj" &&
 540                 git fetch .. subproj-br &&
 541                 git merge FETCH_HEAD &&
 542
 543                 test_write_lines main-sub1 main-sub2 main-sub3 main-sub4 \
 544                         sub1 sub2 sub3 sub4 >expect &&
 545                 git ls-files >actual &&
 546                 test_cmp expect actual
 547         )
 548 '
 549
 550 next_test
 551 test_expect_success 'make sure the subproj *only* contains commits that affect the "sub dir"' '
 552         subtree_test_create_repo "$subtree_test_count" &&
 553         subtree_test_create_repo "$subtree_test_count/sub proj" &&
 554         test_create_commit "$subtree_test_count" main1 &&
 555         test_create_commit "$subtree_test_count/sub proj" sub1 &&
 556         (
 557                 cd "$subtree_test_count" &&
 558                 git fetch ./"sub proj" master &&
 559                 git subtree add --prefix="sub dir" FETCH_HEAD
 560         ) &&
 561         test_create_commit "$subtree_test_count" "sub dir"/main-sub1 &&
 562         test_create_commit "$subtree_test_count" main2 &&
 563         test_create_commit "$subtree_test_count/sub proj" sub2 &&
 564         test_create_commit "$subtree_test_count" "sub dir"/main-sub2 &&
 565         (
 566                 cd "$subtree_test_count" &&
 567                 git fetch ./"sub proj" master &&
 568                 git subtree merge --prefix="sub dir" FETCH_HEAD &&
 569                 git subtree split --prefix="sub dir" --annotate="*" --branch subproj-br --rejoin
 570         ) &&
 571         test_create_commit "$subtree_test_count/sub proj" sub3 &&
 572         test_create_commit "$subtree_test_count" "sub dir"/main-sub3 &&
 573         (
 574                 cd "$subtree_test_count/sub proj" &&
 575                 git fetch .. subproj-br &&
 576                 git merge FETCH_HEAD
 577         ) &&
 578         test_create_commit "$subtree_test_count/sub proj" sub4 &&
 579         (
 580                 cd "$subtree_test_count" &&
 581                 git subtree split --prefix="sub dir" --annotate="*" --branch subproj-br --rejoin
 582         ) &&
 583         test_create_commit "$subtree_test_count" "sub dir"/main-sub4 &&
 584         (
 585                 cd "$subtree_test_count" &&
 586                 git subtree split --prefix="sub dir" --annotate="*" --branch subproj-br --rejoin
 587         ) &&
 588         (
 589                 cd "$subtree_test_count/sub proj" &&
 590                 git fetch .. subproj-br &&
 591                 git merge FETCH_HEAD &&
 592
 593                 test_write_lines main-sub1 main-sub2 main-sub3 main-sub4 \
 594                         sub1 sub2 sub3 sub4 >expect &&
 595                 git log --name-only --pretty=format:"" >log &&
 596                 sort <log | sed "/^\$/ d" >actual &&
 597                 test_cmp expect actual
 598         )
 599 '
 600
 601 next_test
 602 test_expect_success 'make sure exactly the right set of files ends up in the mainline' '
 603         subtree_test_create_repo "$subtree_test_count" &&
 604         subtree_test_create_repo "$subtree_test_count/sub proj" &&
 605         test_create_commit "$subtree_test_count" main1 &&
 606         test_create_commit "$subtree_test_count/sub proj" sub1 &&
 607         (
 608                 cd "$subtree_test_count" &&
 609                 git fetch ./"sub proj" master &&
 610                 git subtree add --prefix="sub dir" FETCH_HEAD
 611         ) &&
 612         test_create_commit "$subtree_test_count" "sub dir"/main-sub1 &&
 613         test_create_commit "$subtree_test_count" main2 &&
 614         test_create_commit "$subtree_test_count/sub proj" sub2 &&
 615         test_create_commit "$subtree_test_count" "sub dir"/main-sub2 &&
 616         (
 617                 cd "$subtree_test_count" &&
 618                 git fetch ./"sub proj" master &&
 619                 git subtree merge --prefix="sub dir" FETCH_HEAD &&
 620                 git subtree split --prefix="sub dir" --annotate="*" --branch subproj-br --rejoin
 621         ) &&
 622         test_create_commit "$subtree_test_count/sub proj" sub3 &&
 623         test_create_commit "$subtree_test_count" "sub dir"/main-sub3 &&
 624         (
 625                 cd "$subtree_test_count/sub proj" &&
 626                 git fetch .. subproj-br &&
 627                 git merge FETCH_HEAD
 628         ) &&
 629         test_create_commit "$subtree_test_count/sub proj" sub4 &&
 630         (
 631                 cd "$subtree_test_count" &&
 632                 git subtree split --prefix="sub dir" --annotate="*" --branch subproj-br --rejoin
 633         ) &&
 634         test_create_commit "$subtree_test_count" "sub dir"/main-sub4 &&
 635         (
 636                 cd "$subtree_test_count" &&
 637                 git subtree split --prefix="sub dir" --annotate="*" --branch subproj-br --rejoin
 638         ) &&
 639         (
 640                 cd "$subtree_test_count/sub proj" &&
 641                 git fetch .. subproj-br &&
 642                 git merge FETCH_HEAD
 643         ) &&
 644         (
 645                 cd "$subtree_test_count" &&
 646                 git subtree pull --prefix="sub dir" ./"sub proj" master &&
 647
 648                 test_write_lines main1 main2 >chkm &&
 649                 test_write_lines main-sub1 main-sub2 main-sub3 main-sub4 >chkms &&
 650                 sed "s,^,sub dir/," chkms >chkms_sub &&
 651                 test_write_lines sub1 sub2 sub3 sub4 >chks &&
 652                 sed "s,^,sub dir/," chks >chks_sub &&
 653
 654                 cat chkm chkms_sub chks_sub >expect &&
 655                 git ls-files >actual &&
 656                 test_cmp expect actual
 657         )
 658 '
 659
 660 next_test
 661 test_expect_success 'make sure each filename changed exactly once in the entire history' '
 662         subtree_test_create_repo "$subtree_test_count" &&
 663         subtree_test_create_repo "$subtree_test_count/sub proj" &&
 664         test_create_commit "$subtree_test_count" main1 &&
 665         test_create_commit "$subtree_test_count/sub proj" sub1 &&
 666         (
 667                 cd "$subtree_test_count" &&
 668                 git config log.date relative &&
 669                 git fetch ./"sub proj" master &&
 670                 git subtree add --prefix="sub dir" FETCH_HEAD
 671         ) &&
 672         test_create_commit "$subtree_test_count" "sub dir"/main-sub1 &&
 673         test_create_commit "$subtree_test_count" main2 &&
 674         test_create_commit "$subtree_test_count/sub proj" sub2 &&
 675         test_create_commit "$subtree_test_count" "sub dir"/main-sub2 &&
 676         (
 677                 cd "$subtree_test_count" &&
 678                 git fetch ./"sub proj" master &&
 679                 git subtree merge --prefix="sub dir" FETCH_HEAD &&
 680                 git subtree split --prefix="sub dir" --annotate="*" --branch subproj-br --rejoin
 681         ) &&
 682         test_create_commit "$subtree_test_count/sub proj" sub3 &&
 683         test_create_commit "$subtree_test_count" "sub dir"/main-sub3 &&
 684         (
 685                 cd "$subtree_test_count/sub proj" &&
 686                 git fetch .. subproj-br &&
 687                 git merge FETCH_HEAD
 688         ) &&
 689         test_create_commit "$subtree_test_count/sub proj" sub4 &&
 690         (
 691                 cd "$subtree_test_count" &&
 692                 git subtree split --prefix="sub dir" --annotate="*" --branch subproj-br --rejoin
 693         ) &&
 694         test_create_commit "$subtree_test_count" "sub dir"/main-sub4 &&
 695         (
 696                 cd "$subtree_test_count" &&
 697                 git subtree split --prefix="sub dir" --annotate="*" --branch subproj-br --rejoin
 698         ) &&
 699         (
 700                 cd "$subtree_test_count/sub proj" &&
 701                 git fetch .. subproj-br &&
 702                 git merge FETCH_HEAD
 703         ) &&
 704         (
 705                 cd "$subtree_test_count" &&
 706                 git subtree pull --prefix="sub dir" ./"sub proj" master &&
 707
 708                 test_write_lines main1 main2 >chkm &&
 709                 test_write_lines sub1 sub2 sub3 sub4 >chks &&
 710                 test_write_lines main-sub1 main-sub2 main-sub3 main-sub4 >chkms &&
 711                 sed "s,^,sub dir/," chkms >chkms_sub &&
 712
 713                 # main-sub?? and /"sub dir"/main-sub?? both change, because those are the
 714                 # changes that were split into their own history.  And "sub dir"/sub?? never
 715                 # change, since they were *only* changed in the subtree branch.
 716                 git log --name-only --pretty=format:"" >log &&
 717                 sort <log >sorted-log &&
 718                 sed "/^$/ d" sorted-log >actual &&
 719
 720                 cat chkms chkm chks chkms_sub >expect-unsorted &&
 721                 sort expect-unsorted >expect &&
 722                 test_cmp expect actual
 723         )
 724 '
 725
 726 next_test
 727 test_expect_success 'make sure the --rejoin commits never make it into subproj' '
 728         subtree_test_create_repo "$subtree_test_count" &&
 729         subtree_test_create_repo "$subtree_test_count/sub proj" &&
 730         test_create_commit "$subtree_test_count" main1 &&
 731         test_create_commit "$subtree_test_count/sub proj" sub1 &&
 732         (
 733                 cd "$subtree_test_count" &&
 734                 git fetch ./"sub proj" master &&
 735                 git subtree add --prefix="sub dir" FETCH_HEAD
 736         ) &&
 737         test_create_commit "$subtree_test_count" "sub dir"/main-sub1 &&
 738         test_create_commit "$subtree_test_count" main2 &&
 739         test_create_commit "$subtree_test_count/sub proj" sub2 &&
 740         test_create_commit "$subtree_test_count" "sub dir"/main-sub2 &&
 741         (
 742                 cd "$subtree_test_count" &&
 743                 git fetch ./"sub proj" master &&
 744                 git subtree merge --prefix="sub dir" FETCH_HEAD &&
 745                 git subtree split --prefix="sub dir" --annotate="*" --branch subproj-br --rejoin
 746         ) &&
 747         test_create_commit "$subtree_test_count/sub proj" sub3 &&
 748         test_create_commit "$subtree_test_count" "sub dir"/main-sub3 &&
 749         (
 750                 cd "$subtree_test_count/sub proj" &&
 751                 git fetch .. subproj-br &&
 752                 git merge FETCH_HEAD
 753         ) &&
 754         test_create_commit "$subtree_test_count/sub proj" sub4 &&
 755         (
 756                 cd "$subtree_test_count" &&
 757                 git subtree split --prefix="sub dir" --annotate="*" --branch subproj-br --rejoin
 758         ) &&
 759         test_create_commit "$subtree_test_count" "sub dir"/main-sub4 &&
 760         (
 761                 cd "$subtree_test_count" &&
 762                 git subtree split --prefix="sub dir" --annotate="*" --branch subproj-br --rejoin
 763         ) &&
 764         (
 765                 cd "$subtree_test_count/sub proj" &&
 766                 git fetch .. subproj-br &&
 767                 git merge FETCH_HEAD
 768         ) &&
 769         (
 770                 cd "$subtree_test_count" &&
 771                 git subtree pull --prefix="sub dir" ./"sub proj" master &&
 772                 check_equal "$(git log --pretty=format:"%s" HEAD^2 | grep -i split)" ""
 773         )
 774 '
 775
 776 next_test
 777 test_expect_success 'make sure no "git subtree" tagged commits make it into subproj' '
 778         subtree_test_create_repo "$subtree_test_count" &&
 779         subtree_test_create_repo "$subtree_test_count/sub proj" &&
 780         test_create_commit "$subtree_test_count" main1 &&
 781         test_create_commit "$subtree_test_count/sub proj" sub1 &&
 782         (
 783                 cd "$subtree_test_count" &&
 784                 git fetch ./"sub proj" master &&
 785                 git subtree add --prefix="sub dir" FETCH_HEAD
 786         ) &&
 787         test_create_commit "$subtree_test_count" "sub dir"/main-sub1 &&
 788         test_create_commit "$subtree_test_count" main2 &&
 789         test_create_commit "$subtree_test_count/sub proj" sub2 &&
 790         test_create_commit "$subtree_test_count" "sub dir"/main-sub2 &&
 791         (
 792                 cd "$subtree_test_count" &&
 793                 git fetch ./"sub proj" master &&
 794                 git subtree merge --prefix="sub dir" FETCH_HEAD &&
 795                 git subtree split --prefix="sub dir" --annotate="*" --branch subproj-br --rejoin
 796         ) &&
 797         test_create_commit "$subtree_test_count/sub proj" sub3 &&
 798         test_create_commit "$subtree_test_count" "sub dir"/main-sub3 &&
 799         (
 800                 cd "$subtree_test_count/sub proj" &&
 801                 git fetch .. subproj-br &&
 802                  git merge FETCH_HEAD
 803         ) &&
 804         test_create_commit "$subtree_test_count/sub proj" sub4 &&
 805         (
 806                 cd "$subtree_test_count" &&
 807                 git subtree split --prefix="sub dir" --annotate="*" --branch subproj-br --rejoin
 808         ) &&
 809         test_create_commit "$subtree_test_count" "sub dir"/main-sub4 &&
 810         (
 811                 cd "$subtree_test_count" &&
 812                 git subtree split --prefix="sub dir" --annotate="*" --branch subproj-br --rejoin
 813         ) &&
 814         (
 815                 cd "$subtree_test_count/sub proj" &&
 816                 git fetch .. subproj-br &&
 817                 git merge FETCH_HEAD
 818         ) &&
 819         (
 820                 cd "$subtree_test_count" &&
 821                 git subtree pull --prefix="sub dir" ./"sub proj" master &&
 822
 823                 # They are meaningless to subproj since one side of the merge refers to the mainline
 824                 check_equal "$(git log --pretty=format:"%s%n%b" HEAD^2 | grep "git-subtree.*:")" ""
 825         )
 826 '
 827
 828 #
 829 # A new set of tests
 830 #
 831
 832 next_test
 833 test_expect_success 'make sure "git subtree split" find the correct parent' '
 834         subtree_test_create_repo "$subtree_test_count" &&
 835         subtree_test_create_repo "$subtree_test_count/sub proj" &&
 836         test_create_commit "$subtree_test_count" main1 &&
 837         test_create_commit "$subtree_test_count/sub proj" sub1 &&
 838         (
 839                 cd "$subtree_test_count" &&
 840                 git fetch ./"sub proj" master &&
 841                 git subtree add --prefix="sub dir" FETCH_HEAD
 842         ) &&
 843         test_create_commit "$subtree_test_count/sub proj" sub2 &&
 844         (
 845                 cd "$subtree_test_count" &&
 846                 git fetch ./"sub proj" master &&
 847                 git branch subproj-ref FETCH_HEAD &&
 848                 git subtree merge --prefix="sub dir" FETCH_HEAD
 849         ) &&
 850         test_create_commit "$subtree_test_count" "sub dir"/main-sub1 &&
 851         (
 852                 cd "$subtree_test_count" &&
 853                 git subtree split --prefix="sub dir" --branch subproj-br &&
 854
 855                 # at this point, the new commit parent should be subproj-ref, if it is
 856                 # not, something went wrong (the "newparent" of "master~" commit should
 857                 # have been sub2, but it was not, because its cache was not set to
 858                 # itself)
 859                 check_equal "$(git log --pretty=format:%P -1 subproj-br)" "$(git rev-parse subproj-ref)"
 860         )
 861 '
 862
 863 next_test
 864 test_expect_success 'split a new subtree without --onto option' '
 865         subtree_test_create_repo "$subtree_test_count" &&
 866         subtree_test_create_repo "$subtree_test_count/sub proj" &&
 867         test_create_commit "$subtree_test_count" main1 &&
 868         test_create_commit "$subtree_test_count/sub proj" sub1 &&
 869         (
 870                 cd "$subtree_test_count" &&
 871                 git fetch ./"sub proj" master &&
 872                 git subtree add --prefix="sub dir" FETCH_HEAD
 873         ) &&
 874         test_create_commit "$subtree_test_count/sub proj" sub2 &&
 875         (
 876                 cd "$subtree_test_count" &&
 877                 git fetch ./"sub proj" master &&
 878                 git subtree merge --prefix="sub dir" FETCH_HEAD
 879         ) &&
 880         test_create_commit "$subtree_test_count" "sub dir"/main-sub1 &&
 881         (
 882                 cd "$subtree_test_count" &&
 883                 git subtree split --prefix="sub dir" --branch subproj-br
 884         ) &&
 885         mkdir "$subtree_test_count"/"sub dir2" &&
 886         test_create_commit "$subtree_test_count" "sub dir2"/main-sub2 &&
 887         (
 888                 cd "$subtree_test_count" &&
 889
 890                 # also test that we still can split out an entirely new subtree
 891                 # if the parent of the first commit in the tree is not empty,
 892                 # then the new subtree has accidentally been attached to something
 893                 git subtree split --prefix="sub dir2" --branch subproj2-br &&
 894                 check_equal "$(git log --pretty=format:%P -1 subproj2-br)" ""
 895         )
 896 '
 897
 898 next_test
 899 test_expect_success 'verify one file change per commit' '
 900         subtree_test_create_repo "$subtree_test_count" &&
 901         subtree_test_create_repo "$subtree_test_count/sub proj" &&
 902         test_create_commit "$subtree_test_count" main1 &&
 903         test_create_commit "$subtree_test_count/sub proj" sub1 &&
 904         (
 905                 cd "$subtree_test_count" &&
 906                 git fetch ./"sub proj" master &&
 907                 git branch sub1 FETCH_HEAD &&
 908                 git subtree add --prefix="sub dir" sub1
 909         ) &&
 910         test_create_commit "$subtree_test_count/sub proj" sub2 &&
 911         (
 912                 cd "$subtree_test_count" &&
 913                 git fetch ./"sub proj" master &&
 914                 git subtree merge --prefix="sub dir" FETCH_HEAD
 915         ) &&
 916         test_create_commit "$subtree_test_count" "sub dir"/main-sub1 &&
 917         (
 918                 cd "$subtree_test_count" &&
 919                 git subtree split --prefix="sub dir" --branch subproj-br
 920         ) &&
 921         mkdir "$subtree_test_count"/"sub dir2" &&
 922         test_create_commit "$subtree_test_count" "sub dir2"/main-sub2 &&
 923         (
 924                 cd "$subtree_test_count" &&
 925                 git subtree split --prefix="sub dir2" --branch subproj2-br &&
 926
 927                 x= &&
 928                 git log --pretty=format:"commit: %H" | join_commits |
 929                 (
 930                         while read commit a b; do
 931                                 test_debug "echo Verifying commit $commit"
 932                                 test_debug "echo a: $a"
 933                                 test_debug "echo b: $b"
 934                                 check_equal "$b" ""
 935                                 x=1
 936                         done
 937                         check_equal "$x" 1
 938                 )
 939         )
 940 '
 941
 942 next_test
 943 test_expect_success 'push split to subproj' '
 944         subtree_test_create_repo "$subtree_test_count" &&
 945         subtree_test_create_repo "$subtree_test_count/sub proj" &&
 946         test_create_commit "$subtree_test_count" main1 &&
 947         test_create_commit "$subtree_test_count/sub proj" sub1 &&
 948         (
 949                 cd "$subtree_test_count" &&
 950                 git fetch ./"sub proj" master &&
 951                 git subtree add --prefix="sub dir" FETCH_HEAD
 952         ) &&
 953         test_create_commit "$subtree_test_count" "sub dir"/main-sub1 &&
 954         test_create_commit "$subtree_test_count" main2 &&
 955         test_create_commit "$subtree_test_count/sub proj" sub2 &&
 956         test_create_commit "$subtree_test_count" "sub dir"/main-sub2 &&
 957         (
 958                 cd $subtree_test_count/"sub proj" &&
 959                 git branch sub-branch-1 &&
 960                 cd .. &&
 961                 git fetch ./"sub proj" master &&
 962                 git subtree merge --prefix="sub dir" FETCH_HEAD
 963         ) &&
 964         test_create_commit "$subtree_test_count" "sub dir"/main-sub3 &&
 965         (
 966                 cd "$subtree_test_count" &&
 967                 git subtree push ./"sub proj" --prefix "sub dir" sub-branch-1 &&
 968                 cd ./"sub proj" &&
 969                 git checkout sub-branch-1 &&
 970                 check_equal "$(last_commit_message)" "sub dir/main-sub3"
 971         )
 972 '
 973
 974 #
 975 # This test covers 2 cases in subtree split copy_or_skip code
 976 # 1) Merges where one parent is a superset of the changes of the other
 977 #    parent regarding changes to the subtree, in this case the merge
 978 #    commit should be copied
 979 # 2) Merges where only one parent operate on the subtree, and the merge
 980 #    commit should be skipped
 981 #
 982 # (1) is checked by ensuring subtree_tip is a descendent of subtree_branch
 983 # (2) should have a check added (not_a_subtree_change shouldn't be present
 984 #     on the produced subtree)
 985 #
 986 # Other related cases which are not tested (or currently handled correctly)
 987 # - Case (1) where there are more than 2 parents, it will sometimes correctly copy
 988 #   the merge, and sometimes not
 989 # - Merge commit where both parents have same tree as the merge, currently
 990 #   will always be skipped, even if they reached that state via different
 991 #   set of commits.
 992 #
 993
 994 next_test
 995 test_expect_success 'subtree descendant check' '
 996         subtree_test_create_repo "$subtree_test_count" &&
 997         test_create_commit "$subtree_test_count" folder_subtree/a &&
 998         (
 999                 cd "$subtree_test_count" &&
1000                 git branch branch
1001         ) &&
1002         test_create_commit "$subtree_test_count" folder_subtree/0 &&
1003         test_create_commit "$subtree_test_count" folder_subtree/b &&
1004         cherry=$(cd "$subtree_test_count"; git rev-parse HEAD) &&
1005         (
1006                 cd "$subtree_test_count" &&
1007                 git checkout branch
1008         ) &&
1009         test_create_commit "$subtree_test_count" commit_on_branch &&
1010         (
1011                 cd "$subtree_test_count" &&
1012                 git cherry-pick $cherry &&
1013                 git checkout master &&
1014                 git merge -m "merge should be kept on subtree" branch &&
1015                 git branch no_subtree_work_branch
1016         ) &&
1017         test_create_commit "$subtree_test_count" folder_subtree/d &&
1018         (
1019                 cd "$subtree_test_count" &&
1020                 git checkout no_subtree_work_branch
1021         ) &&
1022         test_create_commit "$subtree_test_count" not_a_subtree_change &&
1023         (
1024                 cd "$subtree_test_count" &&
1025                 git checkout master &&
1026                 git merge -m "merge should be skipped on subtree" no_subtree_work_branch &&
1027
1028                 git subtree split --prefix folder_subtree/ --branch subtree_tip master &&
1029                 git subtree split --prefix folder_subtree/ --branch subtree_branch branch &&
1030                 check_equal $(git rev-list --count subtree_tip..subtree_branch) 0
1031         )
1032 '
1033
1034 test_done