t/t0002-testlib-basic.sh

   1 #!/bin/sh
   2 #
   3 # Copyright (C) 2005 Junio C Hamano
   4 # Copyright (C) 2016 Kyle J. McKay
   5 # All rights reserved
   6 #
   7
   8 test_description='Test the very basics part #1.
   9
  10 The rest of the test suite does not check the basic operation of git
  11 plumbing commands to work very carefully.  Their job is to concentrate
  12 on tricky features that caused bugs in the past to detect regression.
  13
  14 This test runs very basic features, like registering things in cache,
  15 writing tree, etc.
  16
  17 Note that this test *deliberately* hard-codes many expected object
  18 IDs.  When object ID computation changes, like in the previous case of
  19 swapping compression and hashing order, the person who is making the
  20 modification *should* take notice and update the test vectors here.
  21 '
  22
  23 . ./test-lib.sh
  24
  25 test_plan \?
  26
  27 ################################################################
  28 # git init has been done in an empty repository.
  29 # make sure it is empty.
  30
  31 test_expect_success '.git/objects should be empty after git init in an empty repo' '
  32         find .git/objects -type f -print >should-be-empty &&
  33         test_line_count = 0 should-be-empty
  34 '
  35
  36 # also it should have 2 subdirectories; no fan-out anymore, pack, and info.
  37 # 3 is counting "objects" itself
  38 test_expect_success '.git/objects should have 3 subdirectories' '
  39         find .git/objects -type d -print >full-of-directories &&
  40         test_line_count = 3 full-of-directories
  41 '
  42
  43 ################################################################
  44 # Test harness
  45 test_expect_success 'success is reported like this' '
  46         :
  47 '
  48
  49 _run_sub_test_lib_test_common () {
  50         neg="$1" name="$2" descr="$3" # stdin is the body of the test code
  51         shift 3
  52         mkdir "$name" &&
  53         (
  54                 # Pretend we're not running under a test harness, whether we
  55                 # are or not. The test-lib output depends on the setting of
  56                 # this variable, so we need a stable setting under which to run
  57                 # the sub-test.
  58                 sane_unset HARNESS_ACTIVE &&
  59                 cd "$name" &&
  60                 ln -s "$TESTLIB_DIRECTORY/test-lib.sh" . &&
  61                 cat >"$name.sh" <<-EOF &&
  62                 #!$SHELL_PATH
  63
  64                 test_description='$descr (run in sub test-lib)
  65
  66                 This is run in a sub test-lib so that we do not get incorrect
  67                 passing metrics
  68                 '
  69
  70                 . ./test-lib.sh
  71
  72                 # Unset LINENO as it's not universally supported and we do not
  73                 # want to have to count lines to generate the expected output!
  74                 # Attempting this:
  75                 #   unset LINENO || :
  76                 # may cause some broken sh implementations to abruptly terminate!
  77                 # Instead just unalias all to avoid picking up the line numbers
  78                 # after making sure unalias itself is not a function and
  79                 # dealing with broken zsh that's missing a proper "unalias -a".
  80                 { "unset" -f unalias; } >/dev/null 2>&1 || :
  81                 { "unalias" -a || unalias -m "*"; } >/dev/null 2>&1 || :
  82
  83                 EOF
  84                 cat >>"$name.sh" &&
  85                 chmod +x "$name.sh" &&
  86                 TEST_OUTPUT_DIRECTORY=$(pwd) &&
  87                 export TEST_OUTPUT_DIRECTORY &&
  88                 if test -z "$neg"
  89                 then
  90                         ./"$name.sh" "$@" >out 2>err
  91                 else
  92                         ! ./"$name.sh" "$@" >out 2>err
  93                 fi
  94         )
  95 }
  96
  97 run_sub_test_lib_test () {
  98         _run_sub_test_lib_test_common '' "$@"
  99 }
 100
 101 run_sub_test_lib_test_err () {
 102         _run_sub_test_lib_test_common '!' "$@"
 103 }
 104
 105 check_sub_test_lib_test () {
 106         name="$1" # stdin is the expected output from the test
 107         (
 108                 cd "$name" &&
 109                 ! test -s err &&
 110                 sed -e 's/^> //' -e 's/Z$//' >expect &&
 111                 test_cmp expect out
 112         )
 113 }
 114
 115 check_sub_test_lib_test_err () {
 116         name="$1" # stdin is the expected output from the test
 117         # expected error output is in descriptior 3
 118         (
 119                 cd "$name" &&
 120                 sed -e 's/^> //' -e 's/Z$//' >expect.out &&
 121                 test_cmp expect.out out &&
 122                 sed -e 's/^> //' -e 's/Z$//' <&3 >expect.err &&
 123                 test_cmp expect.err err
 124         )
 125 }
 126
 127 test_expect_success 'pretend we have a fully passing test suite' "
 128         run_sub_test_lib_test full-pass '3 passing tests' <<-\\EOF &&
 129         test_plan 3
 130         for i in 1 2 3
 131         do
 132                 test_expect_success \"passing test #\$i\" 'true'
 133         done
 134         test_done
 135         EOF
 136         check_sub_test_lib_test full-pass <<-\\EOF
 137         > 1..3
 138         > ok 1 - passing test #1
 139         > ok 2 - passing test #2
 140         > ok 3 - passing test #3
 141         > # full passed all 3 test(s)
 142         EOF
 143 "
 144
 145 test_expect_success 'pretend we have a partially passing test suite' "
 146         test_must_fail run_sub_test_lib_test \
 147                 partial-pass '2/3 tests passing' <<-\\EOF &&
 148         test_plan 3
 149         test_expect_success 'passing test #1' 'true'
 150         test_expect_success 'failing test #2' 'false'
 151         test_expect_success 'passing test #3' 'true'
 152         test_done
 153         EOF
 154         check_sub_test_lib_test partial-pass <<-\\EOF
 155         > 1..3
 156         > ok 1 - passing test #1
 157         > not ok 2 - failing test #2
 158         #      failed: partial-pass.sh
 159         #
 160         #      false
 161         #
 162         > ok 3 - passing test #3
 163         > # partial failed 1 among 3 test(s)
 164         EOF
 165 "
 166
 167 test_expect_success 'pretend we have a known breakage' "
 168         run_sub_test_lib_test failing-todo 'A failing TODO test' <<-\\EOF &&
 169         test_plan 2
 170         test_expect_success 'passing test' 'true'
 171         test_expect_failure 'pretend we have a known breakage' 'false'
 172         test_done
 173         EOF
 174         check_sub_test_lib_test failing-todo <<-\\EOF
 175         > 1..2
 176         > ok 1 - passing test
 177         > not ok 2 - pretend we have a known breakage # TODO known breakage
 178         > # failing still have 1 known breakage(s)
 179         > # failing passed all remaining 1 test(s)
 180         EOF
 181 "
 182
 183 test_expect_success 'pretend we have fixed a known breakage' "
 184         run_sub_test_lib_test passing-todo 'A passing TODO test' <<-\\EOF &&
 185         test_plan 1
 186         test_expect_failure 'pretend we have fixed a known breakage' 'true'
 187         test_done
 188         EOF
 189         check_sub_test_lib_test passing-todo <<-\\EOF
 190         > 1..1
 191         > ok 1 - pretend we have fixed a known breakage # TODO known breakage vanished
 192         > # passing 1 known breakage(s) vanished; please update test(s)
 193         EOF
 194 "
 195
 196 test_expect_success 'pretend we have fixed one of two known breakages (run in sub test-lib)' "
 197         run_sub_test_lib_test partially-passing-todos \
 198                 '2 TODO tests, one passing' <<-\\EOF &&
 199         test_plan 3
 200         test_expect_failure 'pretend we have a known breakage' 'false'
 201         test_expect_success 'pretend we have a passing test' 'true'
 202         test_expect_failure 'pretend we have fixed another known breakage' 'true'
 203         test_done
 204         EOF
 205         check_sub_test_lib_test partially-passing-todos <<-\\EOF
 206         > 1..3
 207         > not ok 1 - pretend we have a known breakage # TODO known breakage
 208         > ok 2 - pretend we have a passing test
 209         > ok 3 - pretend we have fixed another known breakage # TODO known breakage vanished
 210         > # partially 1 known breakage(s) vanished; please update test(s)
 211         > # partially still have 1 known breakage(s)
 212         > # partially passed all remaining 1 test(s)
 213         EOF
 214 "
 215
 216 test_expect_success 'pretend we have a pass, fail, and known breakage' "
 217         test_must_fail run_sub_test_lib_test \
 218                 mixed-results1 'mixed results #1' <<-\\EOF &&
 219         test_plan 3
 220         test_expect_success 'passing test' 'true'
 221         test_expect_success 'failing test' 'false'
 222         test_expect_failure 'pretend we have a known breakage' 'false'
 223         test_done
 224         EOF
 225         check_sub_test_lib_test mixed-results1 <<-\\EOF
 226         > 1..3
 227         > ok 1 - passing test
 228         > not ok 2 - failing test
 229         > #      failed: mixed-results1.sh
 230         > #
 231         > #      false
 232         > #
 233         > not ok 3 - pretend we have a known breakage # TODO known breakage
 234         > # mixed still have 1 known breakage(s)
 235         > # mixed failed 1 among remaining 2 test(s)
 236         EOF
 237 "
 238
 239 test_expect_success 'pretend we have a mix of all possible results' "
 240         test_must_fail run_sub_test_lib_test \
 241                 mixed-results2 'mixed results #2' <<-\\EOF &&
 242         test_plan 10
 243         test_expect_success 'passing test' 'true'
 244         test_expect_success 'passing test' 'true'
 245         test_expect_success 'passing test' 'true'
 246         test_expect_success 'passing test' 'true'
 247         test_expect_success 'failing test' 'false'
 248         test_expect_success 'failing test' 'false'
 249         test_expect_success 'failing test' 'false'
 250         test_expect_failure 'pretend we have a known breakage' 'false'
 251         test_expect_failure 'pretend we have a known breakage' 'false'
 252         test_expect_failure 'pretend we have fixed a known breakage' 'true'
 253         test_done
 254         EOF
 255         check_sub_test_lib_test mixed-results2 <<-\\EOF
 256         > 1..10
 257         > ok 1 - passing test
 258         > ok 2 - passing test
 259         > ok 3 - passing test
 260         > ok 4 - passing test
 261         > not ok 5 - failing test
 262         > #      failed: mixed-results2.sh
 263         > #
 264         > #      false
 265         > #
 266         > not ok 6 - failing test
 267         > #      failed: mixed-results2.sh
 268         > #
 269         > #      false
 270         > #
 271         > not ok 7 - failing test
 272         > #      failed: mixed-results2.sh
 273         > #
 274         > #      false
 275         > #
 276         > not ok 8 - pretend we have a known breakage # TODO known breakage
 277         > not ok 9 - pretend we have a known breakage # TODO known breakage
 278         > ok 10 - pretend we have fixed a known breakage # TODO known breakage vanished
 279         > # mixed 1 known breakage(s) vanished; please update test(s)
 280         > # mixed still have 2 known breakage(s)
 281         > # mixed failed 3 among remaining 7 test(s)
 282         EOF
 283 "
 284
 285 test_expect_success 'test --verbose' '
 286         test_must_fail run_sub_test_lib_test \
 287                 test-verbose "test verbose" --verbose <<-\EOF &&
 288         test_plan 3
 289         test_expect_success "passing test" true
 290         test_expect_success "test with output" "echo foo"
 291         test_expect_success "failing test" false
 292         test_done
 293         EOF
 294         mv test-verbose/out test-verbose/out+ &&
 295         grep -v "^Initialized empty" test-verbose/out+ >test-verbose/out &&
 296         check_sub_test_lib_test test-verbose <<-\EOF
 297         > 1..3
 298         > expecting success: true
 299         > ok 1 - passing test
 300         > Z
 301         > expecting success: echo foo
 302         > foo
 303         > ok 2 - test with output
 304         > Z
 305         > expecting success: false
 306         > not ok 3 - failing test
 307         > #      failed: test-verbose.sh
 308         > #
 309         > #      false
 310         > #
 311         > Z
 312         > # test failed 1 among 3 test(s)
 313         EOF
 314 '
 315
 316 test_expect_success 'test --verbose-only' '
 317         test_must_fail run_sub_test_lib_test \
 318                 test-verbose-only-2 "test verbose-only=2" \
 319                 --verbose-only=2 <<-\EOF &&
 320         test_plan 3
 321         test_expect_success "passing test" true
 322         test_expect_success "test with output" "echo foo"
 323         test_expect_success "failing test" false
 324         test_done
 325         EOF
 326         check_sub_test_lib_test test-verbose-only-2 <<-\EOF
 327         > 1..3
 328         > ok 1 - passing test
 329         > Z
 330         > expecting success: echo foo
 331         > foo
 332         > ok 2 - test with output
 333         > Z
 334         > not ok 3 - failing test
 335         > #      failed: test-verbose-only-2.sh
 336         > #
 337         > #      false
 338         > #
 339         > # test failed 1 among 3 test(s)
 340         EOF
 341 '
 342
 343 test_expect_success 'TESTLIB_SKIP_TESTS' "
 344         (
 345                 TESTLIB_SKIP_TESTS='testlib.2' && export TESTLIB_SKIP_TESTS &&
 346                 run_sub_test_lib_test testlib-skip-tests-basic \
 347                         'TESTLIB_SKIP_TESTS' <<-\\EOF &&
 348                 test_plan 3
 349                 for i in 1 2 3
 350                 do
 351                         test_expect_success \"passing test #\$i\" 'true'
 352                 done
 353                 test_done
 354                 EOF
 355                 check_sub_test_lib_test testlib-skip-tests-basic <<-\\EOF
 356                 > 1..3
 357                 > ok 1 - passing test #1
 358                 > ok 2 # skip passing test #2 (TESTLIB_SKIP_TESTS)
 359                 > ok 3 - passing test #3
 360                 > # testlib passed all 3 test(s)
 361                 EOF
 362         )
 363 "
 364
 365 test_expect_success 'TESTLIB_SKIP_TESTS several tests' "
 366         (
 367                 TESTLIB_SKIP_TESTS='testlib.2 testlib.5' && export TESTLIB_SKIP_TESTS &&
 368                 run_sub_test_lib_test testlib-skip-tests-several \
 369                         'TESTLIB_SKIP_TESTS several tests' <<-\\EOF &&
 370                 test_plan 6
 371                 for i in 1 2 3 4 5 6
 372                 do
 373                         test_expect_success \"passing test #\$i\" 'true'
 374                 done
 375                 test_done
 376                 EOF
 377                 check_sub_test_lib_test testlib-skip-tests-several <<-\\EOF
 378                 > 1..6
 379                 > ok 1 - passing test #1
 380                 > ok 2 # skip passing test #2 (TESTLIB_SKIP_TESTS)
 381                 > ok 3 - passing test #3
 382                 > ok 4 - passing test #4
 383                 > ok 5 # skip passing test #5 (TESTLIB_SKIP_TESTS)
 384                 > ok 6 - passing test #6
 385                 > # testlib passed all 6 test(s)
 386                 EOF
 387         )
 388 "
 389
 390 test_expect_success 'TESTLIB_SKIP_TESTS sh pattern' "
 391         (
 392                 TESTLIB_SKIP_TESTS='testlib.[2-5]' && export TESTLIB_SKIP_TESTS &&
 393                 run_sub_test_lib_test testlib-skip-tests-sh-pattern \
 394                         'TESTLIB_SKIP_TESTS sh pattern' <<-\\EOF &&
 395                 test_plan 6
 396                 for i in 1 2 3 4 5 6
 397                 do
 398                         test_expect_success \"passing test #\$i\" 'true'
 399                 done
 400                 test_done
 401                 EOF
 402                 check_sub_test_lib_test testlib-skip-tests-sh-pattern <<-\\EOF
 403                 > 1..6
 404                 > ok 1 - passing test #1
 405                 > ok 2 # skip passing test #2 (TESTLIB_SKIP_TESTS)
 406                 > ok 3 # skip passing test #3 (TESTLIB_SKIP_TESTS)
 407                 > ok 4 # skip passing test #4 (TESTLIB_SKIP_TESTS)
 408                 > ok 5 # skip passing test #5 (TESTLIB_SKIP_TESTS)
 409                 > ok 6 - passing test #6
 410                 > # testlib passed all 6 test(s)
 411                 EOF
 412         )
 413 "
 414
 415 test_expect_success '--run basic' "
 416         run_sub_test_lib_test run-basic \
 417                 '--run basic' --run='1 3 5' --no-quiet <<-\\EOF &&
 418         test_plan 6
 419         for i in 1 2 3 4 5 6
 420         do
 421                 test_expect_success \"passing test #\$i\" 'true'
 422         done
 423         test_done
 424         EOF
 425         check_sub_test_lib_test run-basic <<-\\EOF
 426         > 1..6
 427         > ok 1 - passing test #1
 428         > ok 2 # skip passing test #2 (--run)
 429         > ok 3 - passing test #3
 430         > ok 4 # skip passing test #4 (--run)
 431         > ok 5 - passing test #5
 432         > ok 6 # skip passing test #6 (--run)
 433         > # run passed all 6 test(s)
 434         EOF
 435 "
 436
 437 test_expect_success '--run with a range' "
 438         run_sub_test_lib_test run-range \
 439                 '--run with a range' --run='1-3' --no-quiet <<-\\EOF &&
 440         test_plan 6
 441         for i in 1 2 3 4 5 6
 442         do
 443                 test_expect_success \"passing test #\$i\" 'true'
 444         done
 445         test_done
 446         EOF
 447         check_sub_test_lib_test run-range <<-\\EOF
 448         > 1..6
 449         > ok 1 - passing test #1
 450         > ok 2 - passing test #2
 451         > ok 3 - passing test #3
 452         > ok 4 # skip passing test #4 (--run)
 453         > ok 5 # skip passing test #5 (--run)
 454         > ok 6 # skip passing test #6 (--run)
 455         > # run passed all 6 test(s)
 456         EOF
 457 "
 458
 459 test_expect_success '--run with two ranges' "
 460         run_sub_test_lib_test run-two-ranges \
 461                 '--run with two ranges' --run='1-2 5-6' <<-\\EOF &&
 462         test_plan 6
 463         for i in 1 2 3 4 5 6
 464         do
 465                 test_expect_success \"passing test #\$i\" 'true'
 466         done
 467         test_done
 468         EOF
 469         check_sub_test_lib_test run-two-ranges <<-\\EOF
 470         > ok 1 - passing test #1
 471         > ok 2 - passing test #2
 472         > ok 5 - passing test #5
 473         > ok 6 - passing test #6
 474         > # run passed all 6 test(s)
 475         > 1..6
 476         EOF
 477 "
 478
 479 test_expect_success '--run with a left open range' "
 480         run_sub_test_lib_test run-left-open-range \
 481                 '--run with a left open range' --run='-3' --no-quiet <<-\\EOF &&
 482         test_plan 6
 483         for i in 1 2 3 4 5 6
 484         do
 485                 test_expect_success \"passing test #\$i\" 'true'
 486         done
 487         test_done
 488         EOF
 489         check_sub_test_lib_test run-left-open-range <<-\\EOF
 490         > 1..6
 491         > ok 1 - passing test #1
 492         > ok 2 - passing test #2
 493         > ok 3 - passing test #3
 494         > ok 4 # skip passing test #4 (--run)
 495         > ok 5 # skip passing test #5 (--run)
 496         > ok 6 # skip passing test #6 (--run)
 497         > # run passed all 6 test(s)
 498         EOF
 499 "
 500
 501 test_expect_success '--run with a right open range' "
 502         run_sub_test_lib_test run-right-open-range \
 503                 '--run with a right open range' --run='4-' --no-quiet <<-\\EOF &&
 504         test_plan 6
 505         for i in 1 2 3 4 5 6
 506         do
 507                 test_expect_success \"passing test #\$i\" 'true'
 508         done
 509         test_done
 510         EOF
 511         check_sub_test_lib_test run-right-open-range <<-\\EOF
 512         > 1..6
 513         > ok 1 # skip passing test #1 (--run)
 514         > ok 2 # skip passing test #2 (--run)
 515         > ok 3 # skip passing test #3 (--run)
 516         > ok 4 - passing test #4
 517         > ok 5 - passing test #5
 518         > ok 6 - passing test #6
 519         > # run passed all 6 test(s)
 520         EOF
 521 "
 522
 523 test_expect_success '--run with basic negation' "
 524         run_sub_test_lib_test run-basic-neg \
 525                 '--run with basic negation' --run='"'!3'"' <<-\\EOF &&
 526         test_plan 6
 527         for i in 1 2 3 4 5 6
 528         do
 529                 test_expect_success \"passing test #\$i\" 'true'
 530         done
 531         test_done
 532         EOF
 533         check_sub_test_lib_test run-basic-neg <<-\\EOF
 534         > ok 1 - passing test #1
 535         > ok 2 - passing test #2
 536         > ok 4 - passing test #4
 537         > ok 5 - passing test #5
 538         > ok 6 - passing test #6
 539         > # run passed all 6 test(s)
 540         > 1..6
 541         EOF
 542 "
 543
 544 test_expect_success '--run with two negations' "
 545         run_sub_test_lib_test run-two-neg \
 546                 '--run with two negations' --run='"'!3 !6'"' <<-\\EOF &&
 547         test_plan 6
 548         for i in 1 2 3 4 5 6
 549         do
 550                 test_expect_success \"passing test #\$i\" 'true'
 551         done
 552         test_done
 553         EOF
 554         check_sub_test_lib_test run-two-neg <<-\\EOF
 555         > ok 1 - passing test #1
 556         > ok 2 - passing test #2
 557         > ok 4 - passing test #4
 558         > ok 5 - passing test #5
 559         > # run passed all 6 test(s)
 560         > 1..6
 561         EOF
 562 "
 563
 564 test_expect_success '--run a range and negation' "
 565         run_sub_test_lib_test run-range-and-neg \
 566                 '--run a range and negation' --run='"'-4 !2'"' --no-quiet <<-\\EOF &&
 567         test_plan 6
 568         for i in 1 2 3 4 5 6
 569         do
 570                 test_expect_success \"passing test #\$i\" 'true'
 571         done
 572         test_done
 573         EOF
 574         check_sub_test_lib_test run-range-and-neg <<-\\EOF
 575         > 1..6
 576         > ok 1 - passing test #1
 577         > ok 2 # skip passing test #2 (--run)
 578         > ok 3 - passing test #3
 579         > ok 4 - passing test #4
 580         > ok 5 # skip passing test #5 (--run)
 581         > ok 6 # skip passing test #6 (--run)
 582         > # run passed all 6 test(s)
 583         EOF
 584 "
 585
 586 test_expect_success '--run range negation' "
 587         run_sub_test_lib_test run-range-neg \
 588                 '--run range negation' --run='"'!1-3'"' <<-\\EOF &&
 589         test_plan 6
 590         for i in 1 2 3 4 5 6
 591         do
 592                 test_expect_success \"passing test #\$i\" 'true'
 593         done
 594         test_done
 595         EOF
 596         check_sub_test_lib_test run-range-neg <<-\\EOF
 597         > ok 4 - passing test #4
 598         > ok 5 - passing test #5
 599         > ok 6 - passing test #6
 600         > # run passed all 6 test(s)
 601         > 1..6
 602         EOF
 603 "
 604
 605 test_expect_success '--run include, exclude and include' "
 606         run_sub_test_lib_test run-inc-neg-inc \
 607                 '--run include, exclude and include' \
 608                 --run='"'1-5 !1-3 2'"' <<-\\EOF &&
 609         test_plan 6
 610         for i in 1 2 3 4 5 6
 611         do
 612                 test_expect_success \"passing test #\$i\" 'true'
 613         done
 614         test_done
 615         EOF
 616         check_sub_test_lib_test run-inc-neg-inc <<-\\EOF
 617         > ok 2 - passing test #2
 618         > ok 4 - passing test #4
 619         > ok 5 - passing test #5
 620         > # run passed all 6 test(s)
 621         > 1..6
 622         EOF
 623 "
 624
 625 test_expect_success '--run include, exclude and include, comma separated' "
 626         run_sub_test_lib_test run-inc-neg-inc-comma \
 627                 '--run include, exclude and include, comma separated' \
 628                 --run=1-5,\!1-3,2 --no-quiet <<-\\EOF &&
 629         test_plan 6
 630         for i in 1 2 3 4 5 6
 631         do
 632                 test_expect_success \"passing test #\$i\" 'true'
 633         done
 634         test_done
 635         EOF
 636         check_sub_test_lib_test run-inc-neg-inc-comma <<-\\EOF
 637         > 1..6
 638         > ok 1 # skip passing test #1 (--run)
 639         > ok 2 - passing test #2
 640         > ok 3 # skip passing test #3 (--run)
 641         > ok 4 - passing test #4
 642         > ok 5 - passing test #5
 643         > ok 6 # skip passing test #6 (--run)
 644         > # run passed all 6 test(s)
 645         EOF
 646 "
 647
 648 test_expect_success '--run exclude and include' "
 649         run_sub_test_lib_test run-neg-inc \
 650                 '--run exclude and include' \
 651                 --run='"'!3- 5'"' <<-\\EOF &&
 652         test_plan 6
 653         for i in 1 2 3 4 5 6
 654         do
 655                 test_expect_success \"passing test #\$i\" 'true'
 656         done
 657         test_done
 658         EOF
 659         check_sub_test_lib_test run-neg-inc <<-\\EOF
 660         > ok 1 - passing test #1
 661         > ok 2 - passing test #2
 662         > ok 5 - passing test #5
 663         > # run passed all 6 test(s)
 664         > 1..6
 665         EOF
 666 "
 667
 668 test_expect_success '--run empty selectors' "
 669         run_sub_test_lib_test run-empty-sel \
 670                 '--run empty selectors' \
 671                 --run='1,,3,,,5' --no-quiet <<-\\EOF &&
 672         test_plan 6
 673         for i in 1 2 3 4 5 6
 674         do
 675                 test_expect_success \"passing test #\$i\" 'true'
 676         done
 677         test_done
 678         EOF
 679         check_sub_test_lib_test run-empty-sel <<-\\EOF
 680         > 1..6
 681         > ok 1 - passing test #1
 682         > ok 2 # skip passing test #2 (--run)
 683         > ok 3 - passing test #3
 684         > ok 4 # skip passing test #4 (--run)
 685         > ok 5 - passing test #5
 686         > ok 6 # skip passing test #6 (--run)
 687         > # run passed all 6 test(s)
 688         EOF
 689 "
 690
 691 test_expect_success '--run invalid range start' "
 692         run_sub_test_lib_test_err run-inv-range-start \
 693                 '--run invalid range start' \
 694                 --run='a-5' <<-\\EOF &&
 695         test_expect_success \"passing test #1\" 'true'
 696         test_done
 697         EOF
 698         check_sub_test_lib_test_err run-inv-range-start \
 699                 <<-\\EOF_OUT 3<<-\\EOF_ERR
 700         > FATAL: Unexpected exit with code 1
 701         EOF_OUT
 702         > error: --run: invalid non-numeric in range start: 'a-5'
 703         EOF_ERR
 704 "
 705
 706 test_expect_success '--run invalid range end' "
 707         run_sub_test_lib_test_err run-inv-range-end \
 708                 '--run invalid range end' \
 709                 --run='1-z' <<-\\EOF &&
 710         test_expect_success \"passing test #1\" 'true'
 711         test_done
 712         EOF
 713         check_sub_test_lib_test_err run-inv-range-end \
 714                 <<-\\EOF_OUT 3<<-\\EOF_ERR
 715         > FATAL: Unexpected exit with code 1
 716         EOF_OUT
 717         > error: --run: invalid non-numeric in range end: '1-z'
 718         EOF_ERR
 719 "
 720
 721 test_expect_success '--run invalid selector' "
 722         run_sub_test_lib_test_err run-inv-selector \
 723                 '--run invalid selector' \
 724                 --run='1?' <<-\\EOF &&
 725         test_expect_success \"passing test #1\" 'true'
 726         test_done
 727         EOF
 728         check_sub_test_lib_test_err run-inv-selector \
 729                 <<-\\EOF_OUT 3<<-\\EOF_ERR
 730         > FATAL: Unexpected exit with code 1
 731         EOF_OUT
 732         > error: --run: invalid non-numeric in test selector: '1?'
 733         EOF_ERR
 734 "
 735
 736
 737 test_set_prereq HAVEIT
 738 haveit=no
 739 echo "$haveit" >haveit
 740 test_expect_success HAVEIT 'test runs if prerequisite is satisfied' '
 741         test_have_prereq HAVEIT &&
 742         haveit=yes &&
 743         echo "$haveit" >haveit
 744 '
 745 donthaveit=yes
 746 echo "$donthaveit" >donthaveit
 747 test_expect_success DONTHAVEIT 'unmet prerequisite causes test to be skipped' '
 748         donthaveit=no &&
 749         echo "$donthaveit" >donthaveit
 750 '
 751 haveitf="$(cat haveit)"
 752 donthaveitf="$(cat donthaveit)"
 753 if test $haveit$donthaveit != noyes || test $haveitf$donthaveitf != yesyes
 754 then
 755         say "bug in test framework: prerequisite tags do not work reliably"
 756         exit 1
 757 fi
 758
 759 # Stop with the fussing with files
 760 TESTLIB_TEST_NO_SUBSHELL=1
 761
 762 test_set_prereq HAVETHIS
 763 haveit=no
 764 test_expect_success HAVETHIS,HAVEIT 'test runs if prerequisites are satisfied' '
 765         test_have_prereq HAVEIT &&
 766         test_have_prereq HAVETHIS &&
 767         haveit=yes
 768 '
 769 donthaveit=yes
 770 test_expect_success HAVEIT,DONTHAVEIT 'unmet prerequisites causes test to be skipped' '
 771         donthaveit=no
 772 '
 773 donthaveiteither=yes
 774 test_expect_success DONTHAVEIT,HAVEIT 'unmet prerequisites causes test to be skipped' '
 775         donthaveiteither=no
 776 '
 777 if test $haveit$donthaveit$donthaveiteither != yesyesyes
 778 then
 779         say "bug in test framework: multiple prerequisite tags do not work reliably"
 780         exit 1
 781 fi
 782
 783 test_lazy_prereq LAZY_TRUE true
 784 havetrue=no
 785 test_expect_success LAZY_TRUE 'test runs if lazy prereq is satisfied' '
 786         havetrue=yes
 787 '
 788 donthavetrue=yes
 789 test_expect_success !LAZY_TRUE 'missing lazy prereqs skip tests' '
 790         donthavetrue=no
 791 '
 792
 793 if test "$havetrue$donthavetrue" != yesyes
 794 then
 795         say 'bug in test framework: lazy prerequisites do not work'
 796         exit 1
 797 fi
 798
 799 test_lazy_prereq LAZY_FALSE false
 800 nothavefalse=no
 801 test_expect_success !LAZY_FALSE 'negative lazy prereqs checked' '
 802         nothavefalse=yes
 803 '
 804 havefalse=yes
 805 test_expect_success LAZY_FALSE 'missing negative lazy prereqs will skip' '
 806         havefalse=no
 807 '
 808
 809 if test "$nothavefalse$havefalse" != yesyes
 810 then
 811         say 'bug in test framework: negative lazy prerequisites do not work'
 812         exit 1
 813 fi
 814
 815 # Mostly done with the no subshell tests
 816 sane_unset TESTLIB_TEST_NO_SUBSHELL
 817
 818 clean=no
 819 test_expect_success 'tests clean up after themselves' '
 820         test_when_finished clean=yes
 821 '
 822
 823 if test $clean != yes
 824 then
 825         say "bug in test framework: basic cleanup command does not work reliably"
 826         exit 1
 827 fi
 828
 829 test_expect_success 'tests clean up even on failures' "
 830         test_must_fail run_sub_test_lib_test \
 831                 failing-cleanup 'Failing tests with cleanup commands' <<-\\EOF &&
 832         test_plan 2
 833         test_expect_success 'tests clean up even after a failure' '
 834                 touch clean-after-failure &&
 835                 test_when_finished rm clean-after-failure &&
 836                 (exit 1)
 837         '
 838         test_expect_success 'failure to clean up causes the test to fail' '
 839                 test_when_finished eval \"(exit 2)\"
 840         '
 841         test_done
 842         EOF
 843         check_sub_test_lib_test failing-cleanup <<-\\EOF
 844         > 1..2
 845         > not ok 1 - tests clean up even after a failure
 846         > #      failed: failing-cleanup.sh
 847         > #
 848         > #      touch clean-after-failure &&
 849         > #      test_when_finished rm clean-after-failure &&
 850         > #      (exit 1)
 851         > #
 852         > not ok 2 - failure to clean up causes the test to fail
 853         > #      failed: failing-cleanup.sh
 854         > #
 855         > #      test_when_finished eval \"(exit 2)\"
 856         > #
 857         > # failing failed 2 among 2 test(s)
 858         EOF
 859 "
 860
 861 ################################################################
 862 # Basics of the basics
 863
 864 # updating a new file without --add should fail.
 865 test_expect_success 'git update-index without --add should fail adding' '
 866         test_must_fail git update-index should-be-empty
 867 '
 868
 869 # and with --add it should succeed, even if it is empty (it used to fail).
 870 test_expect_success 'git update-index with --add should succeed' '
 871         git update-index --add should-be-empty
 872 '
 873
 874 TESTLIB_TEST_NO_SUBSHELL=1
 875 test_expect_success 'writing tree out with git write-tree' '
 876         tree=$(git write-tree)
 877 '
 878 sane_unset TESTLIB_TEST_NO_SUBSHELL
 879
 880 # we know the shape and contents of the tree and know the object ID for it.
 881 test_expect_success 'validate object ID of a known tree' '
 882         test "$tree" = 7bb943559a305bdd6bdee2cef6e5df2413c3d30a
 883     '
 884
 885 # Removing paths.
 886 test_expect_success 'git update-index without --remove should fail removing' '
 887         rm -f should-be-empty full-of-directories &&
 888         test_must_fail git update-index should-be-empty
 889 '
 890
 891 test_expect_success 'git update-index with --remove should be able to remove' '
 892         git update-index --remove should-be-empty
 893 '
 894
 895 # Empty tree can be written with recent write-tree.
 896 TESTLIB_TEST_NO_SUBSHELL=1
 897 test_tolerate_failure 'git write-tree should be able to write an empty tree' '
 898         tree=$(git write-tree)
 899 '
 900 sane_unset TESTLIB_TEST_NO_SUBSHELL
 901
 902 if test -n "$tree"
 903 then
 904         test_result='test_expect_success'
 905 else
 906         test_result='test_tolerate_failure'
 907 fi
 908 $test_result 'validate object ID of a known tree' '
 909         test "$tree" = $EMPTY_TREE
 910 '
 911
 912 # Various types of objects
 913
 914 test_expect_success 'adding various types of objects with git update-index --add' '
 915         mkdir path2 path3 path3/subp3 &&
 916         paths="path0 path2/file2 path3/file3 path3/subp3/file3" &&
 917         (
 918                 for p in $paths
 919                 do
 920                         echo "hello $p" >$p || exit 1
 921                         test_ln_s_add "hello $p" ${p}sym || exit 1
 922                 done
 923         ) &&
 924         find path* ! -type d -print | xargs git update-index --add
 925 '
 926
 927 # Show them and see that matches what we expect.
 928 test_expect_success 'showing stage with git ls-files --stage' '
 929         git ls-files --stage >current
 930 '
 931
 932 test_expect_success 'validate git ls-files output for a known tree' '
 933         cat >expected <<-\EOF &&
 934         100644 f87290f8eb2cbbea7857214459a0739927eab154 0       path0
 935         120000 15a98433ae33114b085f3eb3bb03b832b3180a01 0       path0sym
 936         100644 3feff949ed00a62d9f7af97c15cd8a30595e7ac7 0       path2/file2
 937         120000 d8ce161addc5173867a3c3c730924388daedbc38 0       path2/file2sym
 938         100644 0aa34cae68d0878578ad119c86ca2b5ed5b28376 0       path3/file3
 939         120000 8599103969b43aff7e430efea79ca4636466794f 0       path3/file3sym
 940         100644 00fb5908cb97c2564a9783c0c64087333b3b464f 0       path3/subp3/file3
 941         120000 6649a1ebe9e9f1c553b66f5a6e74136a07ccc57c 0       path3/subp3/file3sym
 942         EOF
 943         test_cmp expected current
 944 '
 945
 946 TESTLIB_TEST_NO_SUBSHELL=1
 947 test_expect_success 'writing tree out with git write-tree' '
 948         tree=$(git write-tree)
 949 '
 950 sane_unset TESTLIB_TEST_NO_SUBSHELL
 951
 952 test_expect_success 'validate object ID for a known tree' '
 953         test "$tree" = 087704a96baf1c2d1c869a8b084481e121c88b5b
 954 '
 955
 956 test_expect_success 'showing tree with git ls-tree' '
 957     git ls-tree $tree >current
 958 '
 959
 960 test_expect_success 'git ls-tree output for a known tree' '
 961         cat >expected <<-\EOF &&
 962         100644 blob f87290f8eb2cbbea7857214459a0739927eab154    path0
 963         120000 blob 15a98433ae33114b085f3eb3bb03b832b3180a01    path0sym
 964         040000 tree 58a09c23e2ca152193f2786e06986b7b6712bdbe    path2
 965         040000 tree 21ae8269cacbe57ae09138dcc3a2887f904d02b3    path3
 966         EOF
 967         test_cmp expected current
 968 '
 969
 970 # This changed in ls-tree pathspec change -- recursive does
 971 # not show tree nodes anymore.
 972 test_expect_success 'showing tree with git ls-tree -r' '
 973         git ls-tree -r $tree >current
 974 '
 975
 976 test_expect_success 'git ls-tree -r output for a known tree' '
 977         cat >expected <<-\EOF &&
 978         100644 blob f87290f8eb2cbbea7857214459a0739927eab154    path0
 979         120000 blob 15a98433ae33114b085f3eb3bb03b832b3180a01    path0sym
 980         100644 blob 3feff949ed00a62d9f7af97c15cd8a30595e7ac7    path2/file2
 981         120000 blob d8ce161addc5173867a3c3c730924388daedbc38    path2/file2sym
 982         100644 blob 0aa34cae68d0878578ad119c86ca2b5ed5b28376    path3/file3
 983         120000 blob 8599103969b43aff7e430efea79ca4636466794f    path3/file3sym
 984         100644 blob 00fb5908cb97c2564a9783c0c64087333b3b464f    path3/subp3/file3
 985         120000 blob 6649a1ebe9e9f1c553b66f5a6e74136a07ccc57c    path3/subp3/file3sym
 986         EOF
 987         test_cmp expected current
 988 '
 989
 990 # But with -r -t we can have both.
 991 test_expect_success 'showing tree with git ls-tree -r -t' '
 992         git ls-tree -r -t $tree >current
 993 '
 994
 995 test_expect_success 'git ls-tree -r output for a known tree' '
 996         cat >expected <<-\EOF &&
 997         100644 blob f87290f8eb2cbbea7857214459a0739927eab154    path0
 998         120000 blob 15a98433ae33114b085f3eb3bb03b832b3180a01    path0sym
 999         040000 tree 58a09c23e2ca152193f2786e06986b7b6712bdbe    path2
1000         100644 blob 3feff949ed00a62d9f7af97c15cd8a30595e7ac7    path2/file2
1001         120000 blob d8ce161addc5173867a3c3c730924388daedbc38    path2/file2sym
1002         040000 tree 21ae8269cacbe57ae09138dcc3a2887f904d02b3    path3
1003         100644 blob 0aa34cae68d0878578ad119c86ca2b5ed5b28376    path3/file3
1004         120000 blob 8599103969b43aff7e430efea79ca4636466794f    path3/file3sym
1005         040000 tree 3c5e5399f3a333eddecce7a9b9465b63f65f51e2    path3/subp3
1006         100644 blob 00fb5908cb97c2564a9783c0c64087333b3b464f    path3/subp3/file3
1007         120000 blob 6649a1ebe9e9f1c553b66f5a6e74136a07ccc57c    path3/subp3/file3sym
1008         EOF
1009         test_cmp expected current
1010 '
1011
1012 TESTLIB_TEST_NO_SUBSHELL=1
1013 test_expect_success 'writing partial tree out with git write-tree --prefix' '
1014         ptree=$(git write-tree --prefix=path3)
1015 '
1016 sane_unset TESTLIB_TEST_NO_SUBSHELL
1017
1018 test_expect_success 'validate object ID for a known tree' '
1019         test "$ptree" = 21ae8269cacbe57ae09138dcc3a2887f904d02b3
1020 '
1021
1022 TESTLIB_TEST_NO_SUBSHELL=1
1023 test_expect_success 'writing partial tree out with git write-tree --prefix' '
1024         ptree=$(git write-tree --prefix=path3/subp3)
1025 '
1026 sane_unset TESTLIB_TEST_NO_SUBSHELL
1027
1028 test_expect_success 'validate object ID for a known tree' '
1029         test "$ptree" = 3c5e5399f3a333eddecce7a9b9465b63f65f51e2
1030 '
1031
1032 test_expect_success 'put invalid objects into the index' '
1033         rm -f .git/index &&
1034         cat >badobjects <<-\EOF &&
1035         100644 blob 1000000000000000000000000000000000000000    dir/file1
1036         100644 blob 2000000000000000000000000000000000000000    dir/file2
1037         100644 blob 3000000000000000000000000000000000000000    dir/file3
1038         100644 blob 4000000000000000000000000000000000000000    dir/file4
1039         100644 blob 5000000000000000000000000000000000000000    dir/file5
1040         EOF
1041         git update-index --index-info <badobjects
1042 '
1043
1044 test_expect_success 'writing this tree without --missing-ok' '
1045         test_must_fail git write-tree
1046 '
1047
1048 test_expect_success 'writing this tree with --missing-ok' '
1049         git write-tree --missing-ok
1050 '
1051
1052
1053 ################################################################
1054 test_expect_success 'git read-tree followed by write-tree should be idempotent' '
1055         rm -f .git/index &&
1056         git read-tree $tree &&
1057         test -f .git/index &&
1058         newtree=$(git write-tree) &&
1059         test "$newtree" = "$tree"
1060 '
1061
1062 test_expect_success 'validate git diff-files output for a know cache/work tree state' '
1063         cat >expected <<\EOF &&
1064 :100644 100644 f87290f8eb2cbbea7857214459a0739927eab154 0000000000000000000000000000000000000000 M      path0
1065 :120000 120000 15a98433ae33114b085f3eb3bb03b832b3180a01 0000000000000000000000000000000000000000 M      path0sym
1066 :100644 100644 3feff949ed00a62d9f7af97c15cd8a30595e7ac7 0000000000000000000000000000000000000000 M      path2/file2
1067 :120000 120000 d8ce161addc5173867a3c3c730924388daedbc38 0000000000000000000000000000000000000000 M      path2/file2sym
1068 :100644 100644 0aa34cae68d0878578ad119c86ca2b5ed5b28376 0000000000000000000000000000000000000000 M      path3/file3
1069 :120000 120000 8599103969b43aff7e430efea79ca4636466794f 0000000000000000000000000000000000000000 M      path3/file3sym
1070 :100644 100644 00fb5908cb97c2564a9783c0c64087333b3b464f 0000000000000000000000000000000000000000 M      path3/subp3/file3
1071 :120000 120000 6649a1ebe9e9f1c553b66f5a6e74136a07ccc57c 0000000000000000000000000000000000000000 M      path3/subp3/file3sym
1072 EOF
1073         git diff-files >current &&
1074         test_cmp current expected
1075 '
1076
1077 test_expect_success 'git update-index --refresh should succeed' '
1078         git update-index --refresh
1079 '
1080
1081 test_expect_success 'no diff after checkout and git update-index --refresh' '
1082         git diff-files >current &&
1083         cmp -s current /dev/null
1084 '
1085
1086 ################################################################
1087 P=087704a96baf1c2d1c869a8b084481e121c88b5b
1088
1089 TESTLIB_TEST_NO_SUBSHELL=1
1090 test_expect_success 'git commit-tree records the correct tree in a commit' '
1091         commit0=$(echo NO | git commit-tree $P) &&
1092         tree=$(git show --pretty=raw $commit0 |
1093                  sed -n -e "s/^tree //p" -e "/^author /q") &&
1094         test "z$tree" = "z$P"
1095 '
1096 sane_unset TESTLIB_TEST_NO_SUBSHELL
1097
1098 test_expect_success 'git commit-tree records the correct parent in a commit' '
1099         commit1=$(echo NO | git commit-tree $P -p $commit0) &&
1100         parent=$(git show --pretty=raw $commit1 |
1101                 sed -n -e "s/^parent //p" -e "/^author /q") &&
1102         test "z$commit0" = "z$parent"
1103 '
1104
1105 test_expect_success 'git commit-tree omits duplicated parent in a commit' '
1106         commit2=$(echo NO | git commit-tree $P -p $commit0 -p $commit0) &&
1107              parent=$(git show --pretty=raw $commit2 |
1108                 sed -n -e "s/^parent //p" -e "/^author /q" |
1109                 sort -u) &&
1110         test "z$commit0" = "z$parent" &&
1111         numparent=$(git show --pretty=raw $commit2 |
1112                 sed -n -e "s/^parent //p" -e "/^author /q" |
1113                 wc -l) &&
1114         test $numparent = 1
1115 '
1116
1117 test_expect_success 'update-index D/F conflict' '
1118         mv path0 tmp &&
1119         mv path2 path0 &&
1120         mv tmp path2 &&
1121         git update-index --add --replace path2 path0/file2 &&
1122         numpath0=$(git ls-files path0 | wc -l) &&
1123         test $numpath0 = 1
1124 '
1125
1126 test_expect_success 'very long name in the index handled sanely' '
1127
1128         a=a && # 1
1129         a=$a$a$a$a$a$a$a$a$a$a$a$a$a$a$a$a && # 16
1130         a=$a$a$a$a$a$a$a$a$a$a$a$a$a$a$a$a && # 256
1131         a=$a$a$a$a$a$a$a$a$a$a$a$a$a$a$a$a && # 4096
1132         a=${a}q &&
1133
1134         >path4 &&
1135         git update-index --add path4 &&
1136         (
1137                 git ls-files -s path4 |
1138                 sed -e "s/      .*/     /" |
1139                 tr -d "\012"
1140                 echo "$a"
1141         ) | git update-index --index-info &&
1142         len=$(git ls-files "a*" | wc -c) &&
1143         test $len = 4098
1144 '
1145
1146 test_done