t/t4205-log-pretty-formats.sh

   1 #!/bin/sh
   2 #
   3 # Copyright (c) 2010, Will Palmer
   4 # Copyright (c) 2011, Alexey Shumkin (+ non-UTF-8 commit encoding tests)
   5 #
   6
   7 test_description='Test pretty formats'
   8 . ./test-lib.sh
   9
  10 # Tested non-UTF-8 encoding
  11 test_encoding="ISO8859-1"
  12
  13 sample_utf8_part=$(printf "f\303\244ng")
  14
  15 commit_msg () {
  16         # String "initial. initial" partly in German
  17         # (translated with Google Translate),
  18         # encoded in UTF-8, used as a commit log message below.
  19         msg="initial. an${sample_utf8_part}lich\n"
  20         if test -n "$1"
  21         then
  22                 printf "$msg" | iconv -f utf-8 -t "$1"
  23         else
  24                 printf "$msg"
  25         fi
  26 }
  27
  28 test_expect_success 'set up basic repos' '
  29         >foo &&
  30         >bar &&
  31         git add foo &&
  32         test_tick &&
  33         git config i18n.commitEncoding $test_encoding &&
  34         commit_msg $test_encoding | git commit -F - &&
  35         git add bar &&
  36         test_tick &&
  37         git commit -m "add bar" &&
  38         git config --unset i18n.commitEncoding
  39 '
  40
  41 test_expect_success 'alias builtin format' '
  42         git log --pretty=oneline >expected &&
  43         git config pretty.test-alias oneline &&
  44         git log --pretty=test-alias >actual &&
  45         test_cmp expected actual
  46 '
  47
  48 test_expect_success 'alias masking builtin format' '
  49         git log --pretty=oneline >expected &&
  50         git config pretty.oneline "%H" &&
  51         git log --pretty=oneline >actual &&
  52         test_cmp expected actual
  53 '
  54
  55 test_expect_success 'alias user-defined format' '
  56         git log --pretty="format:%h" >expected &&
  57         git config pretty.test-alias "format:%h" &&
  58         git log --pretty=test-alias >actual &&
  59         test_cmp expected actual
  60 '
  61
  62 test_expect_success 'alias user-defined tformat with %s (ISO8859-1 encoding)' '
  63         git config i18n.logOutputEncoding $test_encoding &&
  64         git log --oneline >expected-s &&
  65         git log --pretty="tformat:%h %s" >actual-s &&
  66         git config --unset i18n.logOutputEncoding &&
  67         test_cmp expected-s actual-s
  68 '
  69
  70 test_expect_success 'alias user-defined tformat with %s (utf-8 encoding)' '
  71         git log --oneline >expected-s &&
  72         git log --pretty="tformat:%h %s" >actual-s &&
  73         test_cmp expected-s actual-s
  74 '
  75
  76 test_expect_success 'alias user-defined tformat' '
  77         git log --pretty="tformat:%h" >expected &&
  78         git config pretty.test-alias "tformat:%h" &&
  79         git log --pretty=test-alias >actual &&
  80         test_cmp expected actual
  81 '
  82
  83 test_expect_success 'alias non-existent format' '
  84         git config pretty.test-alias format-that-will-never-exist &&
  85         test_must_fail git log --pretty=test-alias
  86 '
  87
  88 test_expect_success 'alias of an alias' '
  89         git log --pretty="tformat:%h" >expected &&
  90         git config pretty.test-foo "tformat:%h" &&
  91         git config pretty.test-bar test-foo &&
  92         git log --pretty=test-bar >actual && test_cmp expected actual
  93 '
  94
  95 test_expect_success 'alias masking an alias' '
  96         git log --pretty=format:"Two %H" >expected &&
  97         git config pretty.duplicate "format:One %H" &&
  98         git config --add pretty.duplicate "format:Two %H" &&
  99         git log --pretty=duplicate >actual &&
 100         test_cmp expected actual
 101 '
 102
 103 test_expect_success 'alias loop' '
 104         git config pretty.test-foo test-bar &&
 105         git config pretty.test-bar test-foo &&
 106         test_must_fail git log --pretty=test-foo
 107 '
 108
 109 test_expect_success 'NUL separation' '
 110         printf "add bar\0$(commit_msg)" >expected &&
 111         git log -z --pretty="format:%s" >actual &&
 112         test_cmp expected actual
 113 '
 114
 115 test_expect_success 'NUL termination' '
 116         printf "add bar\0$(commit_msg)\0" >expected &&
 117         git log -z --pretty="tformat:%s" >actual &&
 118         test_cmp expected actual
 119 '
 120
 121 test_expect_success 'NUL separation with --stat' '
 122         stat0_part=$(git diff --stat HEAD^ HEAD) &&
 123         stat1_part=$(git diff-tree --no-commit-id --stat --root HEAD^) &&
 124         printf "add bar\n$stat0_part\n\0$(commit_msg)\n$stat1_part\n" >expected &&
 125         git log -z --stat --pretty="format:%s" >actual &&
 126         test_i18ncmp expected actual
 127 '
 128
 129 test_expect_failure C_LOCALE_OUTPUT 'NUL termination with --stat' '
 130         stat0_part=$(git diff --stat HEAD^ HEAD) &&
 131         stat1_part=$(git diff-tree --no-commit-id --stat --root HEAD^) &&
 132         printf "add bar\n$stat0_part\n\0$(commit_msg)\n$stat1_part\n0" >expected &&
 133         git log -z --stat --pretty="tformat:%s" >actual &&
 134         test_cmp expected actual
 135 '
 136
 137 test_expect_success 'setup more commits' '
 138         test_commit "message one" one one message-one &&
 139         test_commit "message two" two two message-two &&
 140         head1=$(git rev-parse --verify --short HEAD~0) &&
 141         head2=$(git rev-parse --verify --short HEAD~1) &&
 142         head3=$(git rev-parse --verify --short HEAD~2) &&
 143         head4=$(git rev-parse --verify --short HEAD~3)
 144 '
 145
 146 test_expect_success 'left alignment formatting' '
 147         git log --pretty="tformat:%<(40)%s" >actual &&
 148         qz_to_tab_space <<-EOF >expected &&
 149         message two                            Z
 150         message one                            Z
 151         add bar                                Z
 152         $(commit_msg)                    Z
 153         EOF
 154         test_cmp expected actual
 155 '
 156
 157 test_expect_success 'left alignment formatting. i18n.logOutputEncoding' '
 158         git -c i18n.logOutputEncoding=$test_encoding log --pretty="tformat:%<(40)%s" >actual &&
 159         qz_to_tab_space <<-EOF | iconv -f utf-8 -t $test_encoding >expected &&
 160         message two                            Z
 161         message one                            Z
 162         add bar                                Z
 163         $(commit_msg)                    Z
 164         EOF
 165         test_cmp expected actual
 166 '
 167
 168 test_expect_success 'left alignment formatting at the nth column' '
 169         git log --pretty="tformat:%h %<|(40)%s" >actual &&
 170         qz_to_tab_space <<-EOF >expected &&
 171         $head1 message two                    Z
 172         $head2 message one                    Z
 173         $head3 add bar                        Z
 174         $head4 $(commit_msg)            Z
 175         EOF
 176         test_cmp expected actual
 177 '
 178
 179 test_expect_success 'left alignment formatting at the nth column' '
 180         COLUMNS=50 git log --pretty="tformat:%h %<|(-10)%s" >actual &&
 181         qz_to_tab_space <<-EOF >expected &&
 182         $head1 message two                    Z
 183         $head2 message one                    Z
 184         $head3 add bar                        Z
 185         $head4 $(commit_msg)            Z
 186         EOF
 187         test_cmp expected actual
 188 '
 189
 190 test_expect_success 'left alignment formatting at the nth column. i18n.logOutputEncoding' '
 191         git -c i18n.logOutputEncoding=$test_encoding log --pretty="tformat:%h %<|(40)%s" >actual &&
 192         qz_to_tab_space <<-EOF | iconv -f utf-8 -t $test_encoding >expected &&
 193         $head1 message two                    Z
 194         $head2 message one                    Z
 195         $head3 add bar                        Z
 196         $head4 $(commit_msg)            Z
 197         EOF
 198         test_cmp expected actual
 199 '
 200
 201 test_expect_success 'left alignment formatting with no padding' '
 202         git log --pretty="tformat:%<(1)%s" >actual &&
 203         cat <<-EOF >expected &&
 204         message two
 205         message one
 206         add bar
 207         $(commit_msg)
 208         EOF
 209         test_cmp expected actual
 210 '
 211
 212 test_expect_success 'left alignment formatting with no padding. i18n.logOutputEncoding' '
 213         git -c i18n.logOutputEncoding=$test_encoding log --pretty="tformat:%<(1)%s" >actual &&
 214         cat <<-EOF | iconv -f utf-8 -t $test_encoding >expected &&
 215         message two
 216         message one
 217         add bar
 218         $(commit_msg)
 219         EOF
 220         test_cmp expected actual
 221 '
 222
 223 test_expect_success 'left alignment formatting with trunc' '
 224         git log --pretty="tformat:%<(10,trunc)%s" >actual &&
 225         qz_to_tab_space <<-\EOF >expected &&
 226         message ..
 227         message ..
 228         add bar  Z
 229         initial...
 230         EOF
 231         test_cmp expected actual
 232 '
 233
 234 test_expect_success 'left alignment formatting with trunc. i18n.logOutputEncoding' '
 235         git -c i18n.logOutputEncoding=$test_encoding log --pretty="tformat:%<(10,trunc)%s" >actual &&
 236         qz_to_tab_space <<-\EOF | iconv -f utf-8 -t $test_encoding >expected &&
 237         message ..
 238         message ..
 239         add bar  Z
 240         initial...
 241         EOF
 242         test_cmp expected actual
 243 '
 244
 245 test_expect_success 'left alignment formatting with ltrunc' '
 246         git log --pretty="tformat:%<(10,ltrunc)%s" >actual &&
 247         qz_to_tab_space <<-EOF >expected &&
 248         ..sage two
 249         ..sage one
 250         add bar  Z
 251         ..${sample_utf8_part}lich
 252         EOF
 253         test_cmp expected actual
 254 '
 255
 256 test_expect_success 'left alignment formatting with ltrunc. i18n.logOutputEncoding' '
 257         git -c i18n.logOutputEncoding=$test_encoding log --pretty="tformat:%<(10,ltrunc)%s" >actual &&
 258         qz_to_tab_space <<-EOF | iconv -f utf-8 -t $test_encoding >expected &&
 259         ..sage two
 260         ..sage one
 261         add bar  Z
 262         ..${sample_utf8_part}lich
 263         EOF
 264         test_cmp expected actual
 265 '
 266
 267 test_expect_success 'left alignment formatting with mtrunc' '
 268         git log --pretty="tformat:%<(10,mtrunc)%s" >actual &&
 269         qz_to_tab_space <<-\EOF >expected &&
 270         mess.. two
 271         mess.. one
 272         add bar  Z
 273         init..lich
 274         EOF
 275         test_cmp expected actual
 276 '
 277
 278 test_expect_success 'left alignment formatting with mtrunc. i18n.logOutputEncoding' '
 279         git -c i18n.logOutputEncoding=$test_encoding log --pretty="tformat:%<(10,mtrunc)%s" >actual &&
 280         qz_to_tab_space <<-\EOF | iconv -f utf-8 -t $test_encoding >expected &&
 281         mess.. two
 282         mess.. one
 283         add bar  Z
 284         init..lich
 285         EOF
 286         test_cmp expected actual
 287 '
 288
 289 test_expect_success 'right alignment formatting' '
 290         git log --pretty="tformat:%>(40)%s" >actual &&
 291         qz_to_tab_space <<-EOF >expected &&
 292         Z                            message two
 293         Z                            message one
 294         Z                                add bar
 295         Z                    $(commit_msg)
 296         EOF
 297         test_cmp expected actual
 298 '
 299
 300 test_expect_success 'right alignment formatting. i18n.logOutputEncoding' '
 301         git -c i18n.logOutputEncoding=$test_encoding log --pretty="tformat:%>(40)%s" >actual &&
 302         qz_to_tab_space <<-EOF | iconv -f utf-8 -t $test_encoding >expected &&
 303         Z                            message two
 304         Z                            message one
 305         Z                                add bar
 306         Z                    $(commit_msg)
 307         EOF
 308         test_cmp expected actual
 309 '
 310
 311 test_expect_success 'right alignment formatting at the nth column' '
 312         git log --pretty="tformat:%h %>|(40)%s" >actual &&
 313         qz_to_tab_space <<-EOF >expected &&
 314         $head1                      message two
 315         $head2                      message one
 316         $head3                          add bar
 317         $head4              $(commit_msg)
 318         EOF
 319         test_cmp expected actual
 320 '
 321
 322 test_expect_success 'right alignment formatting at the nth column' '
 323         COLUMNS=50 git log --pretty="tformat:%h %>|(-10)%s" >actual &&
 324         qz_to_tab_space <<-EOF >expected &&
 325         $head1                      message two
 326         $head2                      message one
 327         $head3                          add bar
 328         $head4              $(commit_msg)
 329         EOF
 330         test_cmp expected actual
 331 '
 332
 333 test_expect_success 'right alignment formatting at the nth column. i18n.logOutputEncoding' '
 334         git -c i18n.logOutputEncoding=$test_encoding log --pretty="tformat:%h %>|(40)%s" >actual &&
 335         qz_to_tab_space <<-EOF | iconv -f utf-8 -t $test_encoding >expected &&
 336         $head1                      message two
 337         $head2                      message one
 338         $head3                          add bar
 339         $head4              $(commit_msg)
 340         EOF
 341         test_cmp expected actual
 342 '
 343
 344 # Note: Space between 'message' and 'two' should be in the same column
 345 # as in previous test.
 346 test_expect_success 'right alignment formatting at the nth column with --graph. i18n.logOutputEncoding' '
 347         git -c i18n.logOutputEncoding=$test_encoding log --graph --pretty="tformat:%h %>|(40)%s" >actual &&
 348         iconv -f utf-8 -t $test_encoding >expected <<-EOF &&
 349         * $head1                    message two
 350         * $head2                    message one
 351         * $head3                        add bar
 352         * $head4            $(commit_msg)
 353         EOF
 354         test_cmp expected actual
 355 '
 356
 357 test_expect_success 'right alignment formatting with no padding' '
 358         git log --pretty="tformat:%>(1)%s" >actual &&
 359         cat <<-EOF >expected &&
 360         message two
 361         message one
 362         add bar
 363         $(commit_msg)
 364         EOF
 365         test_cmp expected actual
 366 '
 367
 368 test_expect_success 'right alignment formatting with no padding and with --graph' '
 369         git log --graph --pretty="tformat:%>(1)%s" >actual &&
 370         cat <<-EOF >expected &&
 371         * message two
 372         * message one
 373         * add bar
 374         * $(commit_msg)
 375         EOF
 376         test_cmp expected actual
 377 '
 378
 379 test_expect_success 'right alignment formatting with no padding. i18n.logOutputEncoding' '
 380         git -c i18n.logOutputEncoding=$test_encoding log --pretty="tformat:%>(1)%s" >actual &&
 381         cat <<-EOF | iconv -f utf-8 -t $test_encoding >expected &&
 382         message two
 383         message one
 384         add bar
 385         $(commit_msg)
 386         EOF
 387         test_cmp expected actual
 388 '
 389
 390 test_expect_success 'center alignment formatting' '
 391         git log --pretty="tformat:%><(40)%s" >actual &&
 392         qz_to_tab_space <<-EOF >expected &&
 393         Z             message two              Z
 394         Z             message one              Z
 395         Z               add bar                Z
 396         Z         $(commit_msg)          Z
 397         EOF
 398         test_cmp expected actual
 399 '
 400
 401 test_expect_success 'center alignment formatting. i18n.logOutputEncoding' '
 402         git -c i18n.logOutputEncoding=$test_encoding log --pretty="tformat:%><(40)%s" >actual &&
 403         qz_to_tab_space <<-EOF | iconv -f utf-8 -t $test_encoding >expected &&
 404         Z             message two              Z
 405         Z             message one              Z
 406         Z               add bar                Z
 407         Z         $(commit_msg)          Z
 408         EOF
 409         test_cmp expected actual
 410 '
 411 test_expect_success 'center alignment formatting at the nth column' '
 412         git log --pretty="tformat:%h %><|(40)%s" >actual &&
 413         qz_to_tab_space <<-EOF >expected &&
 414         $head1           message two          Z
 415         $head2           message one          Z
 416         $head3             add bar            Z
 417         $head4       $(commit_msg)      Z
 418         EOF
 419         test_cmp expected actual
 420 '
 421
 422 test_expect_success 'center alignment formatting at the nth column' '
 423         COLUMNS=70 git log --pretty="tformat:%h %><|(-30)%s" >actual &&
 424         qz_to_tab_space <<-EOF >expected &&
 425         $head1           message two          Z
 426         $head2           message one          Z
 427         $head3             add bar            Z
 428         $head4       $(commit_msg)      Z
 429         EOF
 430         test_cmp expected actual
 431 '
 432
 433 test_expect_success 'center alignment formatting at the nth column. i18n.logOutputEncoding' '
 434         git -c i18n.logOutputEncoding=$test_encoding log --pretty="tformat:%h %><|(40)%s" >actual &&
 435         qz_to_tab_space <<-EOF | iconv -f utf-8 -t $test_encoding >expected &&
 436         $head1           message two          Z
 437         $head2           message one          Z
 438         $head3             add bar            Z
 439         $head4       $(commit_msg)      Z
 440         EOF
 441         test_cmp expected actual
 442 '
 443
 444 test_expect_success 'center alignment formatting with no padding' '
 445         git log --pretty="tformat:%><(1)%s" >actual &&
 446         cat <<-EOF >expected &&
 447         message two
 448         message one
 449         add bar
 450         $(commit_msg)
 451         EOF
 452         test_cmp expected actual
 453 '
 454
 455 # save HEAD's SHA-1 digest (with no abbreviations) to use it below
 456 # as far as the next test amends HEAD
 457 old_head1=$(git rev-parse --verify HEAD~0)
 458 test_expect_success 'center alignment formatting with no padding. i18n.logOutputEncoding' '
 459         git -c i18n.logOutputEncoding=$test_encoding log --pretty="tformat:%><(1)%s" >actual &&
 460         cat <<-EOF | iconv -f utf-8 -t $test_encoding >expected &&
 461         message two
 462         message one
 463         add bar
 464         $(commit_msg)
 465         EOF
 466         test_cmp expected actual
 467 '
 468
 469 test_expect_success 'left/right alignment formatting with stealing' '
 470         git commit --amend -m short --author "long long long <long@me.com>" &&
 471         git log --pretty="tformat:%<(10,trunc)%s%>>(10,ltrunc)% an" >actual &&
 472         cat <<-\EOF >expected &&
 473         short long  long long
 474         message ..   A U Thor
 475         add bar      A U Thor
 476         initial...   A U Thor
 477         EOF
 478         test_cmp expected actual
 479 '
 480 test_expect_success 'left/right alignment formatting with stealing. i18n.logOutputEncoding' '
 481         git -c i18n.logOutputEncoding=$test_encoding log --pretty="tformat:%<(10,trunc)%s%>>(10,ltrunc)% an" >actual &&
 482         cat <<-\EOF | iconv -f utf-8 -t $test_encoding >expected &&
 483         short long  long long
 484         message ..   A U Thor
 485         add bar      A U Thor
 486         initial...   A U Thor
 487         EOF
 488         test_cmp expected actual
 489 '
 490
 491 test_expect_success 'strbuf_utf8_replace() not producing NUL' '
 492         git log --color --pretty="tformat:%<(10,trunc)%s%>>(10,ltrunc)%C(auto)%d" |
 493                 test_decode_color |
 494                 nul_to_q >actual &&
 495         ! grep Q actual
 496 '
 497
 498 # ISO strict date format
 499 test_expect_success 'ISO and ISO-strict date formats display the same values' '
 500         git log --format=%ai%n%ci |
 501         sed -e "s/ /T/; s/ //; s/..\$/:&/" >expected &&
 502         git log --format=%aI%n%cI >actual &&
 503         test_cmp expected actual
 504 '
 505
 506 # get new digests (with no abbreviations)
 507 test_expect_success 'set up log decoration tests' '
 508         head1=$(git rev-parse --verify HEAD~0) &&
 509         head2=$(git rev-parse --verify HEAD~1)
 510 '
 511
 512 test_expect_success 'log decoration properly follows tag chain' '
 513         git tag -a tag1 -m tag1 &&
 514         git tag -a tag2 -m tag2 tag1 &&
 515         git tag -d tag1 &&
 516         git commit --amend -m shorter &&
 517         git log --no-walk --tags --pretty="%H %d" --decorate=full >actual &&
 518         cat <<-EOF >expected &&
 519         $head2  (tag: refs/tags/message-one)
 520         $old_head1  (tag: refs/tags/message-two)
 521         $head1  (tag: refs/tags/tag2)
 522         EOF
 523         sort -k3 actual >actual1 &&
 524         test_cmp expected actual1
 525 '
 526
 527 test_expect_success 'clean log decoration' '
 528         git log --no-walk --tags --pretty="%H %D" --decorate=full >actual &&
 529         cat >expected <<-EOF &&
 530         $head2 tag: refs/tags/message-one
 531         $old_head1 tag: refs/tags/message-two
 532         $head1 tag: refs/tags/tag2
 533         EOF
 534         sort -k3 actual >actual1 &&
 535         test_cmp expected actual1
 536 '
 537
 538 cat >trailers <<EOF
 539 Signed-off-by: A U Thor <author@example.com>
 540 Acked-by: A U Thor <author@example.com>
 541 [ v2 updated patch description ]
 542 Signed-off-by: A U Thor
 543   <author@example.com>
 544 EOF
 545
 546 unfold () {
 547         perl -0pe 's/\n\s+/ /g'
 548 }
 549
 550 test_expect_success 'set up trailer tests' '
 551         echo "Some contents" >trailerfile &&
 552         git add trailerfile &&
 553         git commit -F - <<-EOF
 554         trailers: this commit message has trailers
 555
 556         This commit is a test commit with trailers at the end. We parse this
 557         message and display the trailers using %(trailers).
 558
 559         $(cat trailers)
 560         EOF
 561 '
 562
 563 test_expect_success 'pretty format %(trailers) shows trailers' '
 564         git log --no-walk --pretty="%(trailers)" >actual &&
 565         {
 566                 cat trailers &&
 567                 echo
 568         } >expect &&
 569         test_cmp expect actual
 570 '
 571
 572 test_expect_success '%(trailers:only) shows only "key: value" trailers' '
 573         git log --no-walk --pretty="%(trailers:only)" >actual &&
 574         {
 575                 grep -v patch.description <trailers &&
 576                 echo
 577         } >expect &&
 578         test_cmp expect actual
 579 '
 580
 581 test_expect_success '%(trailers:unfold) unfolds trailers' '
 582         git log --no-walk --pretty="%(trailers:unfold)" >actual &&
 583         {
 584                 unfold <trailers &&
 585                 echo
 586         } >expect &&
 587         test_cmp expect actual
 588 '
 589
 590 test_expect_success ':only and :unfold work together' '
 591         git log --no-walk --pretty="%(trailers:only,unfold)" >actual &&
 592         git log --no-walk --pretty="%(trailers:unfold,only)" >reverse &&
 593         test_cmp actual reverse &&
 594         {
 595                 grep -v patch.description <trailers | unfold &&
 596                 echo
 597         } >expect &&
 598         test_cmp expect actual
 599 '
 600
 601 test_expect_success 'trailer parsing not fooled by --- line' '
 602         git commit --allow-empty -F - <<-\EOF &&
 603         this is the subject
 604
 605         This is the body. The message has a "---" line which would confuse a
 606         message+patch parser. But here we know we have only a commit message,
 607         so we get it right.
 608
 609         trailer: wrong
 610         ---
 611         This is more body.
 612
 613         trailer: right
 614         EOF
 615
 616         {
 617                 echo "trailer: right" &&
 618                 echo
 619         } >expect &&
 620         git log --no-walk --format="%(trailers)" >actual &&
 621         test_cmp expect actual
 622 '
 623
 624 test_expect_success 'set up %S tests' '
 625         git checkout --orphan source-a &&
 626         test_commit one &&
 627         test_commit two &&
 628         git checkout -b source-b HEAD^ &&
 629         test_commit three
 630 '
 631
 632 test_expect_success 'log --format=%S paints branch names' '
 633         cat >expect <<-\EOF &&
 634         source-b
 635         source-a
 636         source-b
 637         EOF
 638         git log --format=%S source-a source-b >actual &&
 639         test_cmp expect actual
 640 '
 641
 642 test_expect_success 'log --format=%S paints tag names' '
 643         git tag -m tagged source-tag &&
 644         cat >expect <<-\EOF &&
 645         source-tag
 646         source-a
 647         source-tag
 648         EOF
 649         git log --format=%S source-tag source-a >actual &&
 650         test_cmp expect actual
 651 '
 652
 653 test_expect_success 'log --format=%S paints symmetric ranges' '
 654         cat >expect <<-\EOF &&
 655         source-b
 656         source-a
 657         EOF
 658         git log --format=%S source-a...source-b >actual &&
 659         test_cmp expect actual
 660 '
 661
 662 test_expect_success '%S in git log --format works with other placeholders (part 1)' '
 663         git log --format="source-b %h" source-b >expect &&
 664         git log --format="%S %h" source-b >actual &&
 665         test_cmp expect actual
 666 '
 667
 668 test_expect_success '%S in git log --format works with other placeholders (part 2)' '
 669         git log --format="%h source-b" source-b >expect &&
 670         git log --format="%h %S" source-b >actual &&
 671         test_cmp expect actual
 672 '
 673
 674 test_done