t/t0000-basic.sh

   1 #!/bin/sh
   2 #
   3 # Copyright (c) 2005 Junio C Hamano
   4 #
   5
   6 test_description='Test the very basics part #1.
   7
   8 The rest of the test suite does not check the basic operation of git
   9 plumbing commands to work very carefully.  Their job is to concentrate
  10 on tricky features that caused bugs in the past to detect regression.
  11
  12 This test runs very basic features, like registering things in cache,
  13 writing tree, etc.
  14
  15 Note that this test *deliberately* hard-codes many expected object
  16 IDs.  When object ID computation changes, like in the previous case of
  17 swapping compression and hashing order, the person who is making the
  18 modification *should* take notice and update the test vectors here.
  19 '
  20
  21 . ./test-lib.sh
  22
  23 ################################################################
  24 # git init has been done in an empty repository.
  25 # make sure it is empty.
  26
  27 test_expect_success '.git/objects should be empty after git init in an empty repo' '
  28         find .git/objects -type f -print >should-be-empty &&
  29         test_line_count = 0 should-be-empty
  30 '
  31
  32 # also it should have 2 subdirectories; no fan-out anymore, pack, and info.
  33 # 3 is counting "objects" itself
  34 test_expect_success '.git/objects should have 3 subdirectories' '
  35         find .git/objects -type d -print >full-of-directories &&
  36         test_line_count = 3 full-of-directories
  37 '
  38
  39 ################################################################
  40 # Test harness
  41 test_expect_success 'success is reported like this' '
  42         :
  43 '
  44
  45 run_sub_test_lib_test () {
  46         name="$1" descr="$2" # stdin is the body of the test code
  47         shift 2
  48         mkdir "$name" &&
  49         (
  50                 # Pretend we're not running under a test harness, whether we
  51                 # are or not. The test-lib output depends on the setting of
  52                 # this variable, so we need a stable setting under which to run
  53                 # the sub-test.
  54                 sane_unset HARNESS_ACTIVE &&
  55                 cd "$name" &&
  56                 cat >"$name.sh" <<-EOF &&
  57                 #!$SHELL_PATH
  58
  59                 test_description='$descr (run in sub test-lib)
  60
  61                 This is run in a sub test-lib so that we do not get incorrect
  62                 passing metrics
  63                 '
  64
  65                 # Point to the t/test-lib.sh, which isn't in ../ as usual
  66                 . "\$TEST_DIRECTORY"/test-lib.sh
  67                 EOF
  68                 cat >>"$name.sh" &&
  69                 chmod +x "$name.sh" &&
  70                 export TEST_DIRECTORY &&
  71                 TEST_OUTPUT_DIRECTORY=$(pwd) &&
  72                 export TEST_OUTPUT_DIRECTORY &&
  73                 ./"$name.sh" "$@" >out 2>err
  74         )
  75 }
  76
  77 check_sub_test_lib_test () {
  78         name="$1" # stdin is the expected output from the test
  79         (
  80                 cd "$name" &&
  81                 ! test -s err &&
  82                 sed -e 's/^> //' -e 's/Z$//' >expect &&
  83                 test_cmp expect out
  84         )
  85 }
  86
  87 test_expect_success 'pretend we have a fully passing test suite' "
  88         run_sub_test_lib_test full-pass '3 passing tests' <<-\\EOF &&
  89         for i in 1 2 3
  90         do
  91                 test_expect_success \"passing test #\$i\" 'true'
  92         done
  93         test_done
  94         EOF
  95         check_sub_test_lib_test full-pass <<-\\EOF
  96         > ok 1 - passing test #1
  97         > ok 2 - passing test #2
  98         > ok 3 - passing test #3
  99         > # passed all 3 test(s)
 100         > 1..3
 101         EOF
 102 "
 103
 104 test_expect_success 'pretend we have a partially passing test suite' "
 105         test_must_fail run_sub_test_lib_test \
 106                 partial-pass '2/3 tests passing' <<-\\EOF &&
 107         test_expect_success 'passing test #1' 'true'
 108         test_expect_success 'failing test #2' 'false'
 109         test_expect_success 'passing test #3' 'true'
 110         test_done
 111         EOF
 112         check_sub_test_lib_test partial-pass <<-\\EOF
 113         > ok 1 - passing test #1
 114         > not ok 2 - failing test #2
 115         #       false
 116         > ok 3 - passing test #3
 117         > # failed 1 among 3 test(s)
 118         > 1..3
 119         EOF
 120 "
 121
 122 test_expect_success 'pretend we have a known breakage' "
 123         run_sub_test_lib_test failing-todo 'A failing TODO test' <<-\\EOF &&
 124         test_expect_success 'passing test' 'true'
 125         test_expect_failure 'pretend we have a known breakage' 'false'
 126         test_done
 127         EOF
 128         check_sub_test_lib_test failing-todo <<-\\EOF
 129         > ok 1 - passing test
 130         > not ok 2 - pretend we have a known breakage # TODO known breakage
 131         > # still have 1 known breakage(s)
 132         > # passed all remaining 1 test(s)
 133         > 1..2
 134         EOF
 135 "
 136
 137 test_expect_success 'pretend we have fixed a known breakage' "
 138         run_sub_test_lib_test passing-todo 'A passing TODO test' <<-\\EOF &&
 139         test_expect_failure 'pretend we have fixed a known breakage' 'true'
 140         test_done
 141         EOF
 142         check_sub_test_lib_test passing-todo <<-\\EOF
 143         > ok 1 - pretend we have fixed a known breakage # TODO known breakage vanished
 144         > # 1 known breakage(s) vanished; please update test(s)
 145         > 1..1
 146         EOF
 147 "
 148
 149 test_expect_success 'pretend we have fixed one of two known breakages (run in sub test-lib)' "
 150         run_sub_test_lib_test partially-passing-todos \
 151                 '2 TODO tests, one passing' <<-\\EOF &&
 152         test_expect_failure 'pretend we have a known breakage' 'false'
 153         test_expect_success 'pretend we have a passing test' 'true'
 154         test_expect_failure 'pretend we have fixed another known breakage' 'true'
 155         test_done
 156         EOF
 157         check_sub_test_lib_test partially-passing-todos <<-\\EOF
 158         > not ok 1 - pretend we have a known breakage # TODO known breakage
 159         > ok 2 - pretend we have a passing test
 160         > ok 3 - pretend we have fixed another known breakage # TODO known breakage vanished
 161         > # 1 known breakage(s) vanished; please update test(s)
 162         > # still have 1 known breakage(s)
 163         > # passed all remaining 1 test(s)
 164         > 1..3
 165         EOF
 166 "
 167
 168 test_expect_success 'pretend we have a pass, fail, and known breakage' "
 169         test_must_fail run_sub_test_lib_test \
 170                 mixed-results1 'mixed results #1' <<-\\EOF &&
 171         test_expect_success 'passing test' 'true'
 172         test_expect_success 'failing test' 'false'
 173         test_expect_failure 'pretend we have a known breakage' 'false'
 174         test_done
 175         EOF
 176         check_sub_test_lib_test mixed-results1 <<-\\EOF
 177         > ok 1 - passing test
 178         > not ok 2 - failing test
 179         > #     false
 180         > not ok 3 - pretend we have a known breakage # TODO known breakage
 181         > # still have 1 known breakage(s)
 182         > # failed 1 among remaining 2 test(s)
 183         > 1..3
 184         EOF
 185 "
 186
 187 test_expect_success 'pretend we have a mix of all possible results' "
 188         test_must_fail run_sub_test_lib_test \
 189                 mixed-results2 'mixed results #2' <<-\\EOF &&
 190         test_expect_success 'passing test' 'true'
 191         test_expect_success 'passing test' 'true'
 192         test_expect_success 'passing test' 'true'
 193         test_expect_success 'passing test' 'true'
 194         test_expect_success 'failing test' 'false'
 195         test_expect_success 'failing test' 'false'
 196         test_expect_success 'failing test' 'false'
 197         test_expect_failure 'pretend we have a known breakage' 'false'
 198         test_expect_failure 'pretend we have a known breakage' 'false'
 199         test_expect_failure 'pretend we have fixed a known breakage' 'true'
 200         test_done
 201         EOF
 202         check_sub_test_lib_test mixed-results2 <<-\\EOF
 203         > ok 1 - passing test
 204         > ok 2 - passing test
 205         > ok 3 - passing test
 206         > ok 4 - passing test
 207         > not ok 5 - failing test
 208         > #     false
 209         > not ok 6 - failing test
 210         > #     false
 211         > not ok 7 - failing test
 212         > #     false
 213         > not ok 8 - pretend we have a known breakage # TODO known breakage
 214         > not ok 9 - pretend we have a known breakage # TODO known breakage
 215         > ok 10 - pretend we have fixed a known breakage # TODO known breakage vanished
 216         > # 1 known breakage(s) vanished; please update test(s)
 217         > # still have 2 known breakage(s)
 218         > # failed 3 among remaining 7 test(s)
 219         > 1..10
 220         EOF
 221 "
 222
 223 test_expect_success 'test --verbose' '
 224         test_must_fail run_sub_test_lib_test \
 225                 test-verbose "test verbose" --verbose <<-\EOF &&
 226         test_expect_success "passing test" true
 227         test_expect_success "test with output" "echo foo"
 228         test_expect_success "failing test" false
 229         test_done
 230         EOF
 231         mv test-verbose/out test-verbose/out+
 232         grep -v "^Initialized empty" test-verbose/out+ >test-verbose/out &&
 233         check_sub_test_lib_test test-verbose <<-\EOF
 234         > expecting success: true
 235         > ok 1 - passing test
 236         > Z
 237         > expecting success: echo foo
 238         > foo
 239         > ok 2 - test with output
 240         > Z
 241         > expecting success: false
 242         > not ok 3 - failing test
 243         > #     false
 244         > Z
 245         > # failed 1 among 3 test(s)
 246         > 1..3
 247         EOF
 248 '
 249
 250 test_expect_success 'test --verbose-only' '
 251         test_must_fail run_sub_test_lib_test \
 252                 test-verbose-only-2 "test verbose-only=2" \
 253                 --verbose-only=2 <<-\EOF &&
 254         test_expect_success "passing test" true
 255         test_expect_success "test with output" "echo foo"
 256         test_expect_success "failing test" false
 257         test_done
 258         EOF
 259         check_sub_test_lib_test test-verbose-only-2 <<-\EOF
 260         > ok 1 - passing test
 261         > Z
 262         > expecting success: echo foo
 263         > foo
 264         > ok 2 - test with output
 265         > Z
 266         > not ok 3 - failing test
 267         > #     false
 268         > # failed 1 among 3 test(s)
 269         > 1..3
 270         EOF
 271 '
 272
 273 test_set_prereq HAVEIT
 274 haveit=no
 275 test_expect_success HAVEIT 'test runs if prerequisite is satisfied' '
 276         test_have_prereq HAVEIT &&
 277         haveit=yes
 278 '
 279 donthaveit=yes
 280 test_expect_success DONTHAVEIT 'unmet prerequisite causes test to be skipped' '
 281         donthaveit=no
 282 '
 283 if test $haveit$donthaveit != yesyes
 284 then
 285         say "bug in test framework: prerequisite tags do not work reliably"
 286         exit 1
 287 fi
 288
 289 test_set_prereq HAVETHIS
 290 haveit=no
 291 test_expect_success HAVETHIS,HAVEIT 'test runs if prerequisites are satisfied' '
 292         test_have_prereq HAVEIT &&
 293         test_have_prereq HAVETHIS &&
 294         haveit=yes
 295 '
 296 donthaveit=yes
 297 test_expect_success HAVEIT,DONTHAVEIT 'unmet prerequisites causes test to be skipped' '
 298         donthaveit=no
 299 '
 300 donthaveiteither=yes
 301 test_expect_success DONTHAVEIT,HAVEIT 'unmet prerequisites causes test to be skipped' '
 302         donthaveiteither=no
 303 '
 304 if test $haveit$donthaveit$donthaveiteither != yesyesyes
 305 then
 306         say "bug in test framework: multiple prerequisite tags do not work reliably"
 307         exit 1
 308 fi
 309
 310 test_lazy_prereq LAZY_TRUE true
 311 havetrue=no
 312 test_expect_success LAZY_TRUE 'test runs if lazy prereq is satisfied' '
 313         havetrue=yes
 314 '
 315 donthavetrue=yes
 316 test_expect_success !LAZY_TRUE 'missing lazy prereqs skip tests' '
 317         donthavetrue=no
 318 '
 319
 320 if test "$havetrue$donthavetrue" != yesyes
 321 then
 322         say 'bug in test framework: lazy prerequisites do not work'
 323         exit 1
 324 fi
 325
 326 test_lazy_prereq LAZY_FALSE false
 327 nothavefalse=no
 328 test_expect_success !LAZY_FALSE 'negative lazy prereqs checked' '
 329         nothavefalse=yes
 330 '
 331 havefalse=yes
 332 test_expect_success LAZY_FALSE 'missing negative lazy prereqs will skip' '
 333         havefalse=no
 334 '
 335
 336 if test "$nothavefalse$havefalse" != yesyes
 337 then
 338         say 'bug in test framework: negative lazy prerequisites do not work'
 339         exit 1
 340 fi
 341
 342 clean=no
 343 test_expect_success 'tests clean up after themselves' '
 344         test_when_finished clean=yes
 345 '
 346
 347 if test $clean != yes
 348 then
 349         say "bug in test framework: basic cleanup command does not work reliably"
 350         exit 1
 351 fi
 352
 353 test_expect_success 'tests clean up even on failures' "
 354         test_must_fail run_sub_test_lib_test \
 355                 failing-cleanup 'Failing tests with cleanup commands' <<-\\EOF &&
 356         test_expect_success 'tests clean up even after a failure' '
 357                 touch clean-after-failure &&
 358                 test_when_finished rm clean-after-failure &&
 359                 (exit 1)
 360         '
 361         test_expect_success 'failure to clean up causes the test to fail' '
 362                 test_when_finished \"(exit 2)\"
 363         '
 364         test_done
 365         EOF
 366         check_sub_test_lib_test failing-cleanup <<-\\EOF
 367         > not ok 1 - tests clean up even after a failure
 368         > #     Z
 369         > #     touch clean-after-failure &&
 370         > #     test_when_finished rm clean-after-failure &&
 371         > #     (exit 1)
 372         > #     Z
 373         > not ok 2 - failure to clean up causes the test to fail
 374         > #     Z
 375         > #     test_when_finished \"(exit 2)\"
 376         > #     Z
 377         > # failed 2 among 2 test(s)
 378         > 1..2
 379         EOF
 380 "
 381
 382 ################################################################
 383 # Basics of the basics
 384
 385 # updating a new file without --add should fail.
 386 test_expect_success 'git update-index without --add should fail adding' '
 387         test_must_fail git update-index should-be-empty
 388 '
 389
 390 # and with --add it should succeed, even if it is empty (it used to fail).
 391 test_expect_success 'git update-index with --add should succeed' '
 392         git update-index --add should-be-empty
 393 '
 394
 395 test_expect_success 'writing tree out with git write-tree' '
 396         tree=$(git write-tree)
 397 '
 398
 399 # we know the shape and contents of the tree and know the object ID for it.
 400 test_expect_success 'validate object ID of a known tree' '
 401         test "$tree" = 7bb943559a305bdd6bdee2cef6e5df2413c3d30a
 402     '
 403
 404 # Removing paths.
 405 test_expect_success 'git update-index without --remove should fail removing' '
 406         rm -f should-be-empty full-of-directories &&
 407         test_must_fail git update-index should-be-empty
 408 '
 409
 410 test_expect_success 'git update-index with --remove should be able to remove' '
 411         git update-index --remove should-be-empty
 412 '
 413
 414 # Empty tree can be written with recent write-tree.
 415 test_expect_success 'git write-tree should be able to write an empty tree' '
 416         tree=$(git write-tree)
 417 '
 418
 419 test_expect_success 'validate object ID of a known tree' '
 420         test "$tree" = 4b825dc642cb6eb9a060e54bf8d69288fbee4904
 421 '
 422
 423 # Various types of objects
 424
 425 test_expect_success 'adding various types of objects with git update-index --add' '
 426         mkdir path2 path3 path3/subp3 &&
 427         paths="path0 path2/file2 path3/file3 path3/subp3/file3" &&
 428         (
 429                 for p in $paths
 430                 do
 431                         echo "hello $p" >$p || exit 1
 432                         # Create files for msys
 433                         path=${p%/*}/
 434                         if [ "${path}" == "${p}/" ] ; then
 435                                 path=
 436                         fi
 437                         linkfile="${path}hello $p"
 438                         linkpath="${linkfile%/*}"
 439                         if [ "${linkpath}" != "${linkfile}" ] ; then
 440                                 mkdir -p "${linkpath}"
 441                         fi
 442                         touch "${linkfile}"
 443
 444                         test_ln_s_add "hello $p" ${p}sym || exit 1
 445                 done
 446         ) &&
 447         find path* ! -type d -print | grep -v hello| xargs git update-index --add
 448 '
 449
 450 # Show them and see that matches what we expect.
 451 test_expect_success 'showing stage with git ls-files --stage' '
 452         git ls-files --stage >current
 453 '
 454
 455 test_expect_success 'validate git ls-files output for a known tree' '
 456         cat >expected <<-\EOF &&
 457         100644 f87290f8eb2cbbea7857214459a0739927eab154 0       path0
 458         120000 15a98433ae33114b085f3eb3bb03b832b3180a01 0       path0sym
 459         100644 3feff949ed00a62d9f7af97c15cd8a30595e7ac7 0       path2/file2
 460         120000 d8ce161addc5173867a3c3c730924388daedbc38 0       path2/file2sym
 461         100644 0aa34cae68d0878578ad119c86ca2b5ed5b28376 0       path3/file3
 462         120000 8599103969b43aff7e430efea79ca4636466794f 0       path3/file3sym
 463         100644 00fb5908cb97c2564a9783c0c64087333b3b464f 0       path3/subp3/file3
 464         120000 6649a1ebe9e9f1c553b66f5a6e74136a07ccc57c 0       path3/subp3/file3sym
 465         EOF
 466         test_cmp expected current
 467 '
 468
 469 test_expect_success 'writing tree out with git write-tree' '
 470         tree=$(git write-tree)
 471 '
 472
 473 test_expect_success 'validate object ID for a known tree' '
 474         test "$tree" = 087704a96baf1c2d1c869a8b084481e121c88b5b
 475 '
 476
 477 test_expect_success 'showing tree with git ls-tree' '
 478     git ls-tree $tree >current
 479 '
 480
 481 test_expect_success 'git ls-tree output for a known tree' '
 482         cat >expected <<-\EOF &&
 483         100644 blob f87290f8eb2cbbea7857214459a0739927eab154    path0
 484         120000 blob 15a98433ae33114b085f3eb3bb03b832b3180a01    path0sym
 485         040000 tree 58a09c23e2ca152193f2786e06986b7b6712bdbe    path2
 486         040000 tree 21ae8269cacbe57ae09138dcc3a2887f904d02b3    path3
 487         EOF
 488         test_cmp expected current
 489 '
 490
 491 # This changed in ls-tree pathspec change -- recursive does
 492 # not show tree nodes anymore.
 493 test_expect_success 'showing tree with git ls-tree -r' '
 494         git ls-tree -r $tree >current
 495 '
 496
 497 test_expect_success 'git ls-tree -r output for a known tree' '
 498         cat >expected <<-\EOF &&
 499         100644 blob f87290f8eb2cbbea7857214459a0739927eab154    path0
 500         120000 blob 15a98433ae33114b085f3eb3bb03b832b3180a01    path0sym
 501         100644 blob 3feff949ed00a62d9f7af97c15cd8a30595e7ac7    path2/file2
 502         120000 blob d8ce161addc5173867a3c3c730924388daedbc38    path2/file2sym
 503         100644 blob 0aa34cae68d0878578ad119c86ca2b5ed5b28376    path3/file3
 504         120000 blob 8599103969b43aff7e430efea79ca4636466794f    path3/file3sym
 505         100644 blob 00fb5908cb97c2564a9783c0c64087333b3b464f    path3/subp3/file3
 506         120000 blob 6649a1ebe9e9f1c553b66f5a6e74136a07ccc57c    path3/subp3/file3sym
 507         EOF
 508         test_cmp expected current
 509 '
 510
 511 # But with -r -t we can have both.
 512 test_expect_success 'showing tree with git ls-tree -r -t' '
 513         git ls-tree -r -t $tree >current
 514 '
 515
 516 test_expect_success 'git ls-tree -r output for a known tree' '
 517         cat >expected <<-\EOF &&
 518         100644 blob f87290f8eb2cbbea7857214459a0739927eab154    path0
 519         120000 blob 15a98433ae33114b085f3eb3bb03b832b3180a01    path0sym
 520         040000 tree 58a09c23e2ca152193f2786e06986b7b6712bdbe    path2
 521         100644 blob 3feff949ed00a62d9f7af97c15cd8a30595e7ac7    path2/file2
 522         120000 blob d8ce161addc5173867a3c3c730924388daedbc38    path2/file2sym
 523         040000 tree 21ae8269cacbe57ae09138dcc3a2887f904d02b3    path3
 524         100644 blob 0aa34cae68d0878578ad119c86ca2b5ed5b28376    path3/file3
 525         120000 blob 8599103969b43aff7e430efea79ca4636466794f    path3/file3sym
 526         040000 tree 3c5e5399f3a333eddecce7a9b9465b63f65f51e2    path3/subp3
 527         100644 blob 00fb5908cb97c2564a9783c0c64087333b3b464f    path3/subp3/file3
 528         120000 blob 6649a1ebe9e9f1c553b66f5a6e74136a07ccc57c    path3/subp3/file3sym
 529         EOF
 530         test_cmp expected current
 531 '
 532
 533 test_expect_success 'writing partial tree out with git write-tree --prefix' '
 534         ptree=$(git write-tree --prefix=path3)
 535 '
 536
 537 test_expect_success 'validate object ID for a known tree' '
 538         test "$ptree" = 21ae8269cacbe57ae09138dcc3a2887f904d02b3
 539 '
 540
 541 test_expect_success 'writing partial tree out with git write-tree --prefix' '
 542         ptree=$(git write-tree --prefix=path3/subp3)
 543 '
 544
 545 test_expect_success 'validate object ID for a known tree' '
 546         test "$ptree" = 3c5e5399f3a333eddecce7a9b9465b63f65f51e2
 547 '
 548
 549 test_expect_success 'put invalid objects into the index' '
 550         rm -f .git/index &&
 551         cat >badobjects <<-\EOF &&
 552         100644 blob 1000000000000000000000000000000000000000    dir/file1
 553         100644 blob 2000000000000000000000000000000000000000    dir/file2
 554         100644 blob 3000000000000000000000000000000000000000    dir/file3
 555         100644 blob 4000000000000000000000000000000000000000    dir/file4
 556         100644 blob 5000000000000000000000000000000000000000    dir/file5
 557         EOF
 558         git update-index --index-info <badobjects
 559 '
 560
 561 test_expect_success 'writing this tree without --missing-ok' '
 562         test_must_fail git write-tree
 563 '
 564
 565 test_expect_success 'writing this tree with --missing-ok' '
 566         git write-tree --missing-ok
 567 '
 568
 569
 570 ################################################################
 571 test_expect_success 'git read-tree followed by write-tree should be idempotent' '
 572         rm -f .git/index
 573         git read-tree $tree &&
 574         test -f .git/index &&
 575         newtree=$(git write-tree) &&
 576         test "$newtree" = "$tree"
 577 '
 578
 579 test_expect_success 'validate git diff-files output for a know cache/work tree state' '
 580         cat >expected <<\EOF &&
 581 :100644 100644 f87290f8eb2cbbea7857214459a0739927eab154 0000000000000000000000000000000000000000 M      path0
 582 :120000 120000 15a98433ae33114b085f3eb3bb03b832b3180a01 0000000000000000000000000000000000000000 M      path0sym
 583 :100644 100644 3feff949ed00a62d9f7af97c15cd8a30595e7ac7 0000000000000000000000000000000000000000 M      path2/file2
 584 :120000 120000 d8ce161addc5173867a3c3c730924388daedbc38 0000000000000000000000000000000000000000 M      path2/file2sym
 585 :100644 100644 0aa34cae68d0878578ad119c86ca2b5ed5b28376 0000000000000000000000000000000000000000 M      path3/file3
 586 :120000 120000 8599103969b43aff7e430efea79ca4636466794f 0000000000000000000000000000000000000000 M      path3/file3sym
 587 :100644 100644 00fb5908cb97c2564a9783c0c64087333b3b464f 0000000000000000000000000000000000000000 M      path3/subp3/file3
 588 :120000 120000 6649a1ebe9e9f1c553b66f5a6e74136a07ccc57c 0000000000000000000000000000000000000000 M      path3/subp3/file3sym
 589 EOF
 590         git diff-files >current &&
 591         test_cmp current expected
 592 '
 593
 594 test_expect_success 'git update-index --refresh should succeed' '
 595         git update-index --refresh
 596 '
 597
 598 test_expect_success 'no diff after checkout and git update-index --refresh' '
 599         git diff-files >current &&
 600         cmp -s current /dev/null
 601 '
 602
 603 ################################################################
 604 P=087704a96baf1c2d1c869a8b084481e121c88b5b
 605
 606 test_expect_success 'git commit-tree records the correct tree in a commit' '
 607         commit0=$(echo NO | git commit-tree $P) &&
 608         tree=$(git show --pretty=raw $commit0 |
 609                  sed -n -e "s/^tree //p" -e "/^author /q") &&
 610         test "z$tree" = "z$P"
 611 '
 612
 613 test_expect_success 'git commit-tree records the correct parent in a commit' '
 614         commit1=$(echo NO | git commit-tree $P -p $commit0) &&
 615         parent=$(git show --pretty=raw $commit1 |
 616                 sed -n -e "s/^parent //p" -e "/^author /q") &&
 617         test "z$commit0" = "z$parent"
 618 '
 619
 620 test_expect_success 'git commit-tree omits duplicated parent in a commit' '
 621         commit2=$(echo NO | git commit-tree $P -p $commit0 -p $commit0) &&
 622              parent=$(git show --pretty=raw $commit2 |
 623                 sed -n -e "s/^parent //p" -e "/^author /q" |
 624                 sort -u) &&
 625         test "z$commit0" = "z$parent" &&
 626         numparent=$(git show --pretty=raw $commit2 |
 627                 sed -n -e "s/^parent //p" -e "/^author /q" |
 628                 wc -l) &&
 629         test $numparent = 1
 630 '
 631
 632 test_expect_success 'update-index D/F conflict' '
 633         mv path0 tmp &&
 634         mv path2 path0 &&
 635         mv tmp path2 &&
 636         git update-index --add --replace path2 path0/file2 &&
 637         numpath0=$(git ls-files path0 | wc -l) &&
 638         test $numpath0 = 1
 639 '
 640
 641 test_expect_success 'very long name in the index handled sanely' '
 642
 643         a=a && # 1
 644         a=$a$a$a$a$a$a$a$a$a$a$a$a$a$a$a$a && # 16
 645         a=$a$a$a$a$a$a$a$a$a$a$a$a$a$a$a$a && # 256
 646         a=$a$a$a$a$a$a$a$a$a$a$a$a$a$a$a$a && # 4096
 647         a=${a}q &&
 648
 649         >path4 &&
 650         git update-index --add path4 &&
 651         (
 652                 git ls-files -s path4 |
 653                 sed -e "s/      .*/     /" |
 654                 tr -d "\012"
 655                 echo "$a"
 656         ) | git update-index --index-info &&
 657         len=$(git ls-files "a*" | wc -c) &&
 658         test $len = 4098
 659 '
 660
 661 test_done