Andrew's git - gitweb.git/blob

   1#!/bin/sh
   2#
   3# Copyright (c) 2005 Junio C Hamano
   4#
   5
   6test_description='Test the very basics part #1.
   7
   8The rest of the test suite does not check the basic operation of git
   9plumbing commands to work very carefully.  Their job is to concentrate
  10on tricky features that caused bugs in the past to detect regression.
  11
  12This test runs very basic features, like registering things in cache,
  13writing tree, etc.
  14
  15Note that this test *deliberately* hard-codes many expected object
  16IDs.  When object ID computation changes, like in the previous case of
  17swapping compression and hashing order, the person who is making the
  18modification *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
  27test_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
  34test_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
  41test_expect_success 'success is reported like this' '
  42        :
  43'
  44test_expect_failure 'pretend we have a known breakage' '
  45        false
  46'
  47
  48run_sub_test_lib_test () {
  49        name="$1" descr="$2" # stdin is the body of the test code
  50        shift 2
  51        mkdir "$name" &&
  52        (
  53                # Pretend we're a test harness.  This prevents
  54                # test-lib from writing the counts to a file that will
  55                # later be summarized, showing spurious "failed" tests
  56                export HARNESS_ACTIVE=t &&
  57                cd "$name" &&
  58                cat >"$name.sh" <<-EOF &&
  59                #!$SHELL_PATH
  60
  61                test_description='$descr (run in sub test-lib)
  62
  63                This is run in a sub test-lib so that we do not get incorrect
  64                passing metrics
  65                '
  66
  67                # Point to the t/test-lib.sh, which isn't in ../ as usual
  68                . "\$TEST_DIRECTORY"/test-lib.sh
  69                EOF
  70                cat >>"$name.sh" &&
  71                chmod +x "$name.sh" &&
  72                export TEST_DIRECTORY &&
  73                ./"$name.sh" "$@" >out 2>err
  74        )
  75}
  76
  77check_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
  87test_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
 104test_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
 122test_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
 137test_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
 149test_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
 168test_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
 187test_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
 223test_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        > Z
 236        > ok 1 - passing test
 237        > Z
 238        > expecting success: echo foo
 239        > foo
 240        > Z
 241        > ok 2 - test with output
 242        > Z
 243        > expecting success: false
 244        > Z
 245        > not ok 3 - failing test
 246        > #     false
 247        > Z
 248        > # failed 1 among 3 test(s)
 249        > 1..3
 250        EOF
 251'
 252
 253test_expect_success 'test --verbose-only' '
 254        test_must_fail run_sub_test_lib_test \
 255                test-verbose-only-2 "test verbose-only=2" \
 256                --verbose-only=2 <<-\EOF &&
 257        test_expect_success "passing test" true
 258        test_expect_success "test with output" "echo foo"
 259        test_expect_success "failing test" false
 260        test_done
 261        EOF
 262        check_sub_test_lib_test test-verbose-only-2 <<-\EOF
 263        > ok 1 - passing test
 264        > Z
 265        > expecting success: echo foo
 266        > foo
 267        > Z
 268        > ok 2 - test with output
 269        > Z
 270        > not ok 3 - failing test
 271        > #     false
 272        > # failed 1 among 3 test(s)
 273        > 1..3
 274        EOF
 275'
 276
 277test_set_prereq HAVEIT
 278haveit=no
 279test_expect_success HAVEIT 'test runs if prerequisite is satisfied' '
 280        test_have_prereq HAVEIT &&
 281        haveit=yes
 282'
 283donthaveit=yes
 284test_expect_success DONTHAVEIT 'unmet prerequisite causes test to be skipped' '
 285        donthaveit=no
 286'
 287if test $haveit$donthaveit != yesyes
 288then
 289        say "bug in test framework: prerequisite tags do not work reliably"
 290        exit 1
 291fi
 292
 293test_set_prereq HAVETHIS
 294haveit=no
 295test_expect_success HAVETHIS,HAVEIT 'test runs if prerequisites are satisfied' '
 296        test_have_prereq HAVEIT &&
 297        test_have_prereq HAVETHIS &&
 298        haveit=yes
 299'
 300donthaveit=yes
 301test_expect_success HAVEIT,DONTHAVEIT 'unmet prerequisites causes test to be skipped' '
 302        donthaveit=no
 303'
 304donthaveiteither=yes
 305test_expect_success DONTHAVEIT,HAVEIT 'unmet prerequisites causes test to be skipped' '
 306        donthaveiteither=no
 307'
 308if test $haveit$donthaveit$donthaveiteither != yesyesyes
 309then
 310        say "bug in test framework: multiple prerequisite tags do not work reliably"
 311        exit 1
 312fi
 313
 314test_lazy_prereq LAZY_TRUE true
 315havetrue=no
 316test_expect_success LAZY_TRUE 'test runs if lazy prereq is satisfied' '
 317        havetrue=yes
 318'
 319donthavetrue=yes
 320test_expect_success !LAZY_TRUE 'missing lazy prereqs skip tests' '
 321        donthavetrue=no
 322'
 323
 324if test "$havetrue$donthavetrue" != yesyes
 325then
 326        say 'bug in test framework: lazy prerequisites do not work'
 327        exit 1
 328fi
 329
 330test_lazy_prereq LAZY_FALSE false
 331nothavefalse=no
 332test_expect_success !LAZY_FALSE 'negative lazy prereqs checked' '
 333        nothavefalse=yes
 334'
 335havefalse=yes
 336test_expect_success LAZY_FALSE 'missing negative lazy prereqs will skip' '
 337        havefalse=no
 338'
 339
 340if test "$nothavefalse$havefalse" != yesyes
 341then
 342        say 'bug in test framework: negative lazy prerequisites do not work'
 343        exit 1
 344fi
 345
 346clean=no
 347test_expect_success 'tests clean up after themselves' '
 348        test_when_finished clean=yes
 349'
 350
 351if test $clean != yes
 352then
 353        say "bug in test framework: basic cleanup command does not work reliably"
 354        exit 1
 355fi
 356
 357test_expect_success 'tests clean up even on failures' "
 358        test_must_fail run_sub_test_lib_test \
 359                failing-cleanup 'Failing tests with cleanup commands' <<-\\EOF &&
 360        test_expect_success 'tests clean up even after a failure' '
 361                touch clean-after-failure &&
 362                test_when_finished rm clean-after-failure &&
 363                (exit 1)
 364        '
 365        test_expect_success 'failure to clean up causes the test to fail' '
 366                test_when_finished \"(exit 2)\"
 367        '
 368        test_done
 369        EOF
 370        check_sub_test_lib_test failing-cleanup <<-\\EOF
 371        > not ok 1 - tests clean up even after a failure
 372        > #     Z
 373        > #     touch clean-after-failure &&
 374        > #     test_when_finished rm clean-after-failure &&
 375        > #     (exit 1)
 376        > #     Z
 377        > not ok 2 - failure to clean up causes the test to fail
 378        > #     Z
 379        > #     test_when_finished \"(exit 2)\"
 380        > #     Z
 381        > # failed 2 among 2 test(s)
 382        > 1..2
 383        EOF
 384"
 385
 386################################################################
 387# Basics of the basics
 388
 389# updating a new file without --add should fail.
 390test_expect_success 'git update-index without --add should fail adding' '
 391        test_must_fail git update-index should-be-empty
 392'
 393
 394# and with --add it should succeed, even if it is empty (it used to fail).
 395test_expect_success 'git update-index with --add should succeed' '
 396        git update-index --add should-be-empty
 397'
 398
 399test_expect_success 'writing tree out with git write-tree' '
 400        tree=$(git write-tree)
 401'
 402
 403# we know the shape and contents of the tree and know the object ID for it.
 404test_expect_success 'validate object ID of a known tree' '
 405        test "$tree" = 7bb943559a305bdd6bdee2cef6e5df2413c3d30a
 406    '
 407
 408# Removing paths.
 409test_expect_success 'git update-index without --remove should fail removing' '
 410        rm -f should-be-empty full-of-directories &&
 411        test_must_fail git update-index should-be-empty
 412'
 413
 414test_expect_success 'git update-index with --remove should be able to remove' '
 415        git update-index --remove should-be-empty
 416'
 417
 418# Empty tree can be written with recent write-tree.
 419test_expect_success 'git write-tree should be able to write an empty tree' '
 420        tree=$(git write-tree)
 421'
 422
 423test_expect_success 'validate object ID of a known tree' '
 424        test "$tree" = 4b825dc642cb6eb9a060e54bf8d69288fbee4904
 425'
 426
 427# Various types of objects
 428
 429test_expect_success 'adding various types of objects with git update-index --add' '
 430        mkdir path2 path3 path3/subp3 &&
 431        paths="path0 path2/file2 path3/file3 path3/subp3/file3" &&
 432        (
 433                for p in $paths
 434                do
 435                        echo "hello $p" >$p || exit 1
 436                        test_ln_s_add "hello $p" ${p}sym || exit 1
 437                done
 438        ) &&
 439        find path* ! -type d -print | xargs git update-index --add
 440'
 441
 442# Show them and see that matches what we expect.
 443test_expect_success 'showing stage with git ls-files --stage' '
 444        git ls-files --stage >current
 445'
 446
 447test_expect_success 'validate git ls-files output for a known tree' '
 448        cat >expected <<-\EOF &&
 449        100644 f87290f8eb2cbbea7857214459a0739927eab154 0       path0
 450        120000 15a98433ae33114b085f3eb3bb03b832b3180a01 0       path0sym
 451        100644 3feff949ed00a62d9f7af97c15cd8a30595e7ac7 0       path2/file2
 452        120000 d8ce161addc5173867a3c3c730924388daedbc38 0       path2/file2sym
 453        100644 0aa34cae68d0878578ad119c86ca2b5ed5b28376 0       path3/file3
 454        120000 8599103969b43aff7e430efea79ca4636466794f 0       path3/file3sym
 455        100644 00fb5908cb97c2564a9783c0c64087333b3b464f 0       path3/subp3/file3
 456        120000 6649a1ebe9e9f1c553b66f5a6e74136a07ccc57c 0       path3/subp3/file3sym
 457        EOF
 458        test_cmp expected current
 459'
 460
 461test_expect_success 'writing tree out with git write-tree' '
 462        tree=$(git write-tree)
 463'
 464
 465test_expect_success 'validate object ID for a known tree' '
 466        test "$tree" = 087704a96baf1c2d1c869a8b084481e121c88b5b
 467'
 468
 469test_expect_success 'showing tree with git ls-tree' '
 470    git ls-tree $tree >current
 471'
 472
 473test_expect_success 'git ls-tree output for a known tree' '
 474        cat >expected <<-\EOF &&
 475        100644 blob f87290f8eb2cbbea7857214459a0739927eab154    path0
 476        120000 blob 15a98433ae33114b085f3eb3bb03b832b3180a01    path0sym
 477        040000 tree 58a09c23e2ca152193f2786e06986b7b6712bdbe    path2
 478        040000 tree 21ae8269cacbe57ae09138dcc3a2887f904d02b3    path3
 479        EOF
 480        test_cmp expected current
 481'
 482
 483# This changed in ls-tree pathspec change -- recursive does
 484# not show tree nodes anymore.
 485test_expect_success 'showing tree with git ls-tree -r' '
 486        git ls-tree -r $tree >current
 487'
 488
 489test_expect_success 'git ls-tree -r output for a known tree' '
 490        cat >expected <<-\EOF &&
 491        100644 blob f87290f8eb2cbbea7857214459a0739927eab154    path0
 492        120000 blob 15a98433ae33114b085f3eb3bb03b832b3180a01    path0sym
 493        100644 blob 3feff949ed00a62d9f7af97c15cd8a30595e7ac7    path2/file2
 494        120000 blob d8ce161addc5173867a3c3c730924388daedbc38    path2/file2sym
 495        100644 blob 0aa34cae68d0878578ad119c86ca2b5ed5b28376    path3/file3
 496        120000 blob 8599103969b43aff7e430efea79ca4636466794f    path3/file3sym
 497        100644 blob 00fb5908cb97c2564a9783c0c64087333b3b464f    path3/subp3/file3
 498        120000 blob 6649a1ebe9e9f1c553b66f5a6e74136a07ccc57c    path3/subp3/file3sym
 499        EOF
 500        test_cmp expected current
 501'
 502
 503# But with -r -t we can have both.
 504test_expect_success 'showing tree with git ls-tree -r -t' '
 505        git ls-tree -r -t $tree >current
 506'
 507
 508test_expect_success 'git ls-tree -r output for a known tree' '
 509        cat >expected <<-\EOF &&
 510        100644 blob f87290f8eb2cbbea7857214459a0739927eab154    path0
 511        120000 blob 15a98433ae33114b085f3eb3bb03b832b3180a01    path0sym
 512        040000 tree 58a09c23e2ca152193f2786e06986b7b6712bdbe    path2
 513        100644 blob 3feff949ed00a62d9f7af97c15cd8a30595e7ac7    path2/file2
 514        120000 blob d8ce161addc5173867a3c3c730924388daedbc38    path2/file2sym
 515        040000 tree 21ae8269cacbe57ae09138dcc3a2887f904d02b3    path3
 516        100644 blob 0aa34cae68d0878578ad119c86ca2b5ed5b28376    path3/file3
 517        120000 blob 8599103969b43aff7e430efea79ca4636466794f    path3/file3sym
 518        040000 tree 3c5e5399f3a333eddecce7a9b9465b63f65f51e2    path3/subp3
 519        100644 blob 00fb5908cb97c2564a9783c0c64087333b3b464f    path3/subp3/file3
 520        120000 blob 6649a1ebe9e9f1c553b66f5a6e74136a07ccc57c    path3/subp3/file3sym
 521        EOF
 522        test_cmp expected current
 523'
 524
 525test_expect_success 'writing partial tree out with git write-tree --prefix' '
 526        ptree=$(git write-tree --prefix=path3)
 527'
 528
 529test_expect_success 'validate object ID for a known tree' '
 530        test "$ptree" = 21ae8269cacbe57ae09138dcc3a2887f904d02b3
 531'
 532
 533test_expect_success 'writing partial tree out with git write-tree --prefix' '
 534        ptree=$(git write-tree --prefix=path3/subp3)
 535'
 536
 537test_expect_success 'validate object ID for a known tree' '
 538        test "$ptree" = 3c5e5399f3a333eddecce7a9b9465b63f65f51e2
 539'
 540
 541test_expect_success 'put invalid objects into the index' '
 542        rm -f .git/index &&
 543        cat >badobjects <<-\EOF &&
 544        100644 blob 1000000000000000000000000000000000000000    dir/file1
 545        100644 blob 2000000000000000000000000000000000000000    dir/file2
 546        100644 blob 3000000000000000000000000000000000000000    dir/file3
 547        100644 blob 4000000000000000000000000000000000000000    dir/file4
 548        100644 blob 5000000000000000000000000000000000000000    dir/file5
 549        EOF
 550        git update-index --index-info <badobjects
 551'
 552
 553test_expect_success 'writing this tree without --missing-ok' '
 554        test_must_fail git write-tree
 555'
 556
 557test_expect_success 'writing this tree with --missing-ok' '
 558        git write-tree --missing-ok
 559'
 560
 561
 562################################################################
 563test_expect_success 'git read-tree followed by write-tree should be idempotent' '
 564        rm -f .git/index
 565        git read-tree $tree &&
 566        test -f .git/index &&
 567        newtree=$(git write-tree) &&
 568        test "$newtree" = "$tree"
 569'
 570
 571test_expect_success 'validate git diff-files output for a know cache/work tree state' '
 572        cat >expected <<\EOF &&
 573:100644 100644 f87290f8eb2cbbea7857214459a0739927eab154 0000000000000000000000000000000000000000 M      path0
 574:120000 120000 15a98433ae33114b085f3eb3bb03b832b3180a01 0000000000000000000000000000000000000000 M      path0sym
 575:100644 100644 3feff949ed00a62d9f7af97c15cd8a30595e7ac7 0000000000000000000000000000000000000000 M      path2/file2
 576:120000 120000 d8ce161addc5173867a3c3c730924388daedbc38 0000000000000000000000000000000000000000 M      path2/file2sym
 577:100644 100644 0aa34cae68d0878578ad119c86ca2b5ed5b28376 0000000000000000000000000000000000000000 M      path3/file3
 578:120000 120000 8599103969b43aff7e430efea79ca4636466794f 0000000000000000000000000000000000000000 M      path3/file3sym
 579:100644 100644 00fb5908cb97c2564a9783c0c64087333b3b464f 0000000000000000000000000000000000000000 M      path3/subp3/file3
 580:120000 120000 6649a1ebe9e9f1c553b66f5a6e74136a07ccc57c 0000000000000000000000000000000000000000 M      path3/subp3/file3sym
 581EOF
 582        git diff-files >current &&
 583        test_cmp current expected
 584'
 585
 586test_expect_success 'git update-index --refresh should succeed' '
 587        git update-index --refresh
 588'
 589
 590test_expect_success 'no diff after checkout and git update-index --refresh' '
 591        git diff-files >current &&
 592        cmp -s current /dev/null
 593'
 594
 595################################################################
 596P=087704a96baf1c2d1c869a8b084481e121c88b5b
 597
 598test_expect_success 'git commit-tree records the correct tree in a commit' '
 599        commit0=$(echo NO | git commit-tree $P) &&
 600        tree=$(git show --pretty=raw $commit0 |
 601                 sed -n -e "s/^tree //p" -e "/^author /q") &&
 602        test "z$tree" = "z$P"
 603'
 604
 605test_expect_success 'git commit-tree records the correct parent in a commit' '
 606        commit1=$(echo NO | git commit-tree $P -p $commit0) &&
 607        parent=$(git show --pretty=raw $commit1 |
 608                sed -n -e "s/^parent //p" -e "/^author /q") &&
 609        test "z$commit0" = "z$parent"
 610'
 611
 612test_expect_success 'git commit-tree omits duplicated parent in a commit' '
 613        commit2=$(echo NO | git commit-tree $P -p $commit0 -p $commit0) &&
 614             parent=$(git show --pretty=raw $commit2 |
 615                sed -n -e "s/^parent //p" -e "/^author /q" |
 616                sort -u) &&
 617        test "z$commit0" = "z$parent" &&
 618        numparent=$(git show --pretty=raw $commit2 |
 619                sed -n -e "s/^parent //p" -e "/^author /q" |
 620                wc -l) &&
 621        test $numparent = 1
 622'
 623
 624test_expect_success 'update-index D/F conflict' '
 625        mv path0 tmp &&
 626        mv path2 path0 &&
 627        mv tmp path2 &&
 628        git update-index --add --replace path2 path0/file2 &&
 629        numpath0=$(git ls-files path0 | wc -l) &&
 630        test $numpath0 = 1
 631'
 632
 633test_expect_success 'very long name in the index handled sanely' '
 634
 635        a=a && # 1
 636        a=$a$a$a$a$a$a$a$a$a$a$a$a$a$a$a$a && # 16
 637        a=$a$a$a$a$a$a$a$a$a$a$a$a$a$a$a$a && # 256
 638        a=$a$a$a$a$a$a$a$a$a$a$a$a$a$a$a$a && # 4096
 639        a=${a}q &&
 640
 641        >path4 &&
 642        git update-index --add path4 &&
 643        (
 644                git ls-files -s path4 |
 645                sed -e "s/      .*/     /" |
 646                tr -d "\012"
 647                echo "$a"
 648        ) | git update-index --index-info &&
 649        len=$(git ls-files "a*" | wc -c) &&
 650        test $len = 4098
 651'
 652
 653test_done