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