undef/git-commit-vandalism
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

pretty: Add failing tests: --format output should honor logOutputEncoding

Browse Source 
One can set an alias
	$ git config alias.lg "log --graph --pretty=format:'%Cred%h%Creset
	-%C(yellow)%d%Creset %s %Cgreen(%cd) %C(bold blue)<%an>%Creset'
	--abbrev-commit --date=local"

to see the log as a pretty tree (like *gitk* but in a terminal).

However, log messages written in an encoding i18n.commitEncoding which differs
from terminal encoding are shown corrupted even when i18n.logOutputEncoding
and terminal encoding are the same (e.g. log messages committed on a Cygwin box
with Windows-1251 encoding seen on a Linux box with a UTF-8 encoding and vice versa).

To simplify an example we can say the following two commands are expected
to give the same output to a terminal:

	$ git log --oneline --no-color
	$ git log --pretty=format:'%h %s'

However, the former pays attention to i18n.logOutputEncoding
configuration, while the latter does not when it formats "%s".

The same corruption is true for
	$ git diff --submodule=log
and
	$ git rev-list --pretty=format:%s HEAD
and
	$ git reset --hard

This patch adds failing tests for the next patch that fixes them.

Signed-off-by: Alexey Shumkin <Alex.Crezoff@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
This commit is contained in:
Alexey Shumkin 2013-06-26 14:19:49 +04:00 committed by Junio C Hamano
parent a742f2a0a7
commit de6029a2d7
4 changed files with 199 additions and 97 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

35
t/t4041-diff-submodule-option.sh
View File

@ -1,6 +1,7 @@
#!/bin/sh #!/bin/sh
# #
# Copyright (c) 2009 Jens Lehmann, based on t7401 by Ping Yin # Copyright (c) 2009 Jens Lehmann, based on t7401 by Ping Yin
# Copyright (c) 2011 Alexey Shumkin (+ non-UTF-8 commit encoding tests)
# #
test_description='Support for verbose submodule differences in git diff test_description='Support for verbose submodule differences in git diff
@ -10,6 +11,9 @@ This test tries to verify the sanity of the --submodule option of git diff.
. ./test-lib.sh . ./test-lib.sh
# String "added" in German (translated with Google Translate), encoded in UTF-8,
# used in sample commit log messages in add_file() function below.
added=$(printf "hinzugef\303\274gt")
add_file () { add_file () {
( (
cd "$1" && cd "$1" &&
@ -19,7 +23,8 @@ add_file () {
echo "$name" >"$name" && echo "$name" >"$name" &&
git add "$name" && git add "$name" &&
test_tick && test_tick &&
git commit -m "Add $name" || exit msg_added_iso88591=$(echo "Add $name ($added $name)" | iconv -f utf-8 -t iso-8859-1) &&
git -c 'i18n.commitEncoding=iso-8859-1' commit -m "$msg_added_iso88591"
done >/dev/null && done >/dev/null &&
git rev-parse --short --verify HEAD git rev-parse --short --verify HEAD
) )
@ -89,29 +94,29 @@ test_expect_success 'diff.submodule does not affect plumbing' '
commit_file sm1 && commit_file sm1 &&
head2=$(add_file sm1 foo3) head2=$(add_file sm1 foo3)
test_expect_success 'modified submodule(forward)' ' test_expect_failure 'modified submodule(forward)' '
git diff-index -p --submodule=log HEAD >actual && git diff-index -p --submodule=log HEAD >actual &&
cat >expected <<-EOF && cat >expected <<-EOF &&
Submodule sm1 $head1..$head2: Submodule sm1 $head1..$head2:
> Add foo3 > Add foo3 ($added foo3)
EOF EOF
test_cmp expected actual test_cmp expected actual
' '
test_expect_success 'modified submodule(forward)' ' test_expect_failure 'modified submodule(forward)' '
git diff --submodule=log >actual && git diff --submodule=log >actual &&
cat >expected <<-EOF && cat >expected <<-EOF &&
Submodule sm1 $head1..$head2: Submodule sm1 $head1..$head2:
> Add foo3 > Add foo3 ($added foo3)
EOF EOF
test_cmp expected actual test_cmp expected actual
' '
test_expect_success 'modified submodule(forward) --submodule' ' test_expect_failure 'modified submodule(forward) --submodule' '
git diff --submodule >actual && git diff --submodule >actual &&
cat >expected <<-EOF && cat >expected <<-EOF &&
Submodule sm1 $head1..$head2: Submodule sm1 $head1..$head2:
> Add foo3 > Add foo3 ($added foo3)
EOF EOF
test_cmp expected actual test_cmp expected actual
' '
@ -138,25 +143,25 @@ head3=$(
git rev-parse --short --verify HEAD git rev-parse --short --verify HEAD
) )
test_expect_success 'modified submodule(backward)' ' test_expect_failure 'modified submodule(backward)' '
git diff-index -p --submodule=log HEAD >actual && git diff-index -p --submodule=log HEAD >actual &&
cat >expected <<-EOF && cat >expected <<-EOF &&
Submodule sm1 $head2..$head3 (rewind): Submodule sm1 $head2..$head3 (rewind):
< Add foo3 < Add foo3 ($added foo3)
< Add foo2 < Add foo2 ($added foo2)
EOF EOF
test_cmp expected actual test_cmp expected actual
' '
head4=$(add_file sm1 foo4 foo5) head4=$(add_file sm1 foo4 foo5)
test_expect_success 'modified submodule(backward and forward)' ' test_expect_failure 'modified submodule(backward and forward)' '
git diff-index -p --submodule=log HEAD >actual && git diff-index -p --submodule=log HEAD >actual &&
cat >expected <<-EOF && cat >expected <<-EOF &&
Submodule sm1 $head2...$head4: Submodule sm1 $head2...$head4:
> Add foo5 > Add foo5 ($added foo5)
> Add foo4 > Add foo4 ($added foo4)
< Add foo3 < Add foo3 ($added foo3)
< Add foo2 < Add foo2 ($added foo2)
EOF EOF
test_cmp expected actual test_cmp expected actual
' '

149
t/t4205-log-pretty-formats.sh
View File

@ -1,20 +1,43 @@
#!/bin/sh #!/bin/sh
# #
# Copyright (c) 2010, Will Palmer # Copyright (c) 2010, Will Palmer
# Copyright (c) 2011, Alexey Shumkin (+ non-UTF-8 commit encoding tests)
# #
test_description='Test pretty formats' test_description='Test pretty formats'
. ./test-lib.sh . ./test-lib.sh
commit_msg () {
# String "initial. initial" partly in German (translated with Google Translate),
# encoded in UTF-8, used as a commit log message below.
msg=$(printf "initial. anf\303\244nglich")
if test -n "$1"
then
msg=$(echo $msg | iconv -f utf-8 -t $1)
fi
if test -n "$2" -a -n "$3"
then
# cut string, replace cut part with two dots
# $2 - chars count from the beginning of the string
# $3 - "trailing" chars
# LC_ALL is set to make `sed` interpret "." as a UTF-8 char not a byte
# as it does with C locale
msg=$(echo $msg | LC_ALL=en_US.UTF-8 sed -e "s/^\(.\{$2\}\)$3/\1../")
fi
echo $msg
}
test_expect_success 'set up basic repos' ' test_expect_success 'set up basic repos' '
>foo && >foo &&
>bar && >bar &&
git add foo && git add foo &&
test_tick && test_tick &&
git commit -m initial && git config i18n.commitEncoding iso-8859-1 &&
git commit -m "$(commit_msg iso-8859-1)" &&
git add bar && git add bar &&
test_tick && test_tick &&
git commit -m "add bar" git commit -m "add bar" &&
git config --unset i18n.commitEncoding
' '
test_expect_success 'alias builtin format' ' test_expect_success 'alias builtin format' '
@ -38,6 +61,20 @@ test_expect_success 'alias user-defined format' '
test_cmp expected actual test_cmp expected actual
' '
test_expect_success 'alias user-defined tformat with %s (iso-8859-1 encoding)' '
git config i18n.logOutputEncoding iso-8859-1 &&
git log --oneline >expected-s &&
git log --pretty="tformat:%h %s" >actual-s &&
git config --unset i18n.logOutputEncoding &&
test_cmp expected-s actual-s
'
test_expect_failure 'alias user-defined tformat with %s (utf-8 encoding)' '
git log --oneline >expected-s &&
git log --pretty="tformat:%h %s" >actual-s &&
test_cmp expected-s actual-s
'
test_expect_success 'alias user-defined tformat' ' test_expect_success 'alias user-defined tformat' '
git log --pretty="tformat:%h" >expected && git log --pretty="tformat:%h" >expected &&
git config pretty.test-alias "tformat:%h" && git config pretty.test-alias "tformat:%h" &&
@ -71,22 +108,22 @@ test_expect_success 'alias loop' '
test_must_fail git log --pretty=test-foo test_must_fail git log --pretty=test-foo
' '
test_expect_success 'NUL separation' ' test_expect_failure 'NUL separation' '
printf "add bar\0initial" >expected && printf "add bar\0$(commit_msg)" >expected &&
git log -z --pretty="format:%s" >actual && git log -z --pretty="format:%s" >actual &&
test_cmp expected actual test_cmp expected actual
' '
test_expect_success 'NUL termination' ' test_expect_failure 'NUL termination' '
printf "add bar\0initial\0" >expected && printf "add bar\0$(commit_msg)\0" >expected &&
git log -z --pretty="tformat:%s" >actual && git log -z --pretty="tformat:%s" >actual &&
test_cmp expected actual test_cmp expected actual
' '
test_expect_success 'NUL separation with --stat' ' test_expect_failure 'NUL separation with --stat' '
stat0_part=$(git diff --stat HEAD^ HEAD) && stat0_part=$(git diff --stat HEAD^ HEAD) &&
stat1_part=$(git diff-tree --no-commit-id --stat --root HEAD^) && stat1_part=$(git diff-tree --no-commit-id --stat --root HEAD^) &&
printf "add bar\n$stat0_part\n\0initial\n$stat1_part\n" >expected && printf "add bar\n$stat0_part\n\0$(commit_msg)\n$stat1_part\n" >expected &&
git log -z --stat --pretty="format:%s" >actual && git log -z --stat --pretty="format:%s" >actual &&
test_i18ncmp expected actual test_i18ncmp expected actual
' '
@ -94,7 +131,7 @@ test_expect_success 'NUL separation with --stat' '
test_expect_failure 'NUL termination with --stat' ' test_expect_failure 'NUL termination with --stat' '
stat0_part=$(git diff --stat HEAD^ HEAD) && stat0_part=$(git diff --stat HEAD^ HEAD) &&
stat1_part=$(git diff-tree --no-commit-id --stat --root HEAD^) && stat1_part=$(git diff-tree --no-commit-id --stat --root HEAD^) &&
printf "add bar\n$stat0_part\n\0initial\n$stat1_part\n\0" >expected && printf "add bar\n$stat0_part\n\0$(commit_msg)\n$stat1_part\n0" >expected &&
git log -z --stat --pretty="tformat:%s" >actual && git log -z --stat --pretty="tformat:%s" >actual &&
test_i18ncmp expected actual test_i18ncmp expected actual
' '
@ -108,20 +145,20 @@ test_expect_success 'setup more commits' '
head4=$(git rev-parse --verify --short HEAD~3) head4=$(git rev-parse --verify --short HEAD~3)
' '
test_expect_success 'left alignment formatting' ' test_expect_failure 'left alignment formatting' "
git log --pretty="format:%<(40)%s" >actual && git log --pretty='format:%<(40)%s' >actual &&
# complete the incomplete line at the end # complete the incomplete line at the end
echo >>actual && echo >>actual &&
qz_to_tab_space <<\EOF >expected && qz_to_tab_space <<\EOF >expected &&
message two Z message two Z
message one Z message one Z
add bar Z add bar Z
initial Z $(commit_msg) Z
EOF EOF
test_cmp expected actual test_cmp expected actual
' "
test_expect_success 'left alignment formatting at the nth column' " test_expect_failure 'left alignment formatting at the nth column' "
git log --pretty='format:%h %<|(40)%s' >actual && git log --pretty='format:%h %<|(40)%s' >actual &&
# complete the incomplete line at the end # complete the incomplete line at the end
echo >>actual && echo >>actual &&
@ -129,77 +166,77 @@ test_expect_success 'left alignment formatting at the nth column' "
$head1 message two Z $head1 message two Z
$head2 message one Z $head2 message one Z
$head3 add bar Z $head3 add bar Z
$head4 initial Z $head4 $(commit_msg) Z
EOF EOF
test_cmp expected actual test_cmp expected actual
" "
test_expect_success 'left alignment formatting with no padding' ' test_expect_failure 'left alignment formatting with no padding' "
git log --pretty="format:%<(1)%s" >actual && git log --pretty='format:%<(1)%s' >actual &&
# complete the incomplete line at the end # complete the incomplete line at the end
echo >>actual && echo >>actual &&
cat <<\EOF >expected && cat <<\EOF >expected &&
message two message two
message one message one
add bar add bar
initial $(commit_msg)
EOF EOF
test_cmp expected actual test_cmp expected actual
' "
test_expect_success 'left alignment formatting with trunc' ' test_expect_failure 'left alignment formatting with trunc' "
git log --pretty="format:%<(10,trunc)%s" >actual && git log --pretty='format:%<(10,trunc)%s' >actual &&
# complete the incomplete line at the end # complete the incomplete line at the end
echo >>actual && echo >>actual &&
qz_to_tab_space <<\EOF >expected && qz_to_tab_space <<\EOF >expected &&
message .. message ..
message .. message ..
add bar Z add bar Z
initial Z $(commit_msg "" "8" ".\+$")
EOF EOF
test_cmp expected actual test_cmp expected actual
' "
test_expect_success 'left alignment formatting with ltrunc' ' test_expect_failure 'left alignment formatting with ltrunc' "
git log --pretty="format:%<(10,ltrunc)%s" >actual && git log --pretty='format:%<(10,ltrunc)%s' >actual &&
# complete the incomplete line at the end # complete the incomplete line at the end
echo >>actual && echo >>actual &&
qz_to_tab_space <<\EOF >expected && qz_to_tab_space <<\EOF >expected &&
..sage two ..sage two
..sage one ..sage one
add bar Z add bar Z
initial Z $(commit_msg "" "0" ".\{11\}")
EOF EOF
test_cmp expected actual test_cmp expected actual
' "
test_expect_success 'left alignment formatting with mtrunc' ' test_expect_failure 'left alignment formatting with mtrunc' "
git log --pretty="format:%<(10,mtrunc)%s" >actual && git log --pretty='format:%<(10,mtrunc)%s' >actual &&
# complete the incomplete line at the end # complete the incomplete line at the end
echo >>actual && echo >>actual &&
qz_to_tab_space <<\EOF >expected && qz_to_tab_space <<\EOF >expected &&
mess.. two mess.. two
mess.. one mess.. one
add bar Z add bar Z
initial Z $(commit_msg "" "4" ".\{11\}")
EOF EOF
test_cmp expected actual test_cmp expected actual
' "
test_expect_success 'right alignment formatting' ' test_expect_failure 'right alignment formatting' "
git log --pretty="format:%>(40)%s" >actual && git log --pretty='format:%>(40)%s' >actual &&
# complete the incomplete line at the end # complete the incomplete line at the end
echo >>actual && echo >>actual &&
qz_to_tab_space <<\EOF >expected && qz_to_tab_space <<\EOF >expected &&
Z message two Z message two
Z message one Z message one
Z add bar Z add bar
Z initial Z $(commit_msg)
EOF EOF
test_cmp expected actual test_cmp expected actual
' "
test_expect_success 'right alignment formatting at the nth column' " test_expect_failure 'right alignment formatting at the nth column' "
git log --pretty='format:%h %>|(40)%s' >actual && git log --pretty='format:%h %>|(40)%s' >actual &&
# complete the incomplete line at the end # complete the incomplete line at the end
echo >>actual && echo >>actual &&
@ -207,38 +244,38 @@ test_expect_success 'right alignment formatting at the nth column' "
$head1 message two $head1 message two
$head2 message one $head2 message one
$head3 add bar $head3 add bar
$head4 initial $head4 $(commit_msg)
EOF EOF
test_cmp expected actual test_cmp expected actual
" "
test_expect_success 'right alignment formatting with no padding' ' test_expect_failure 'right alignment formatting with no padding' "
git log --pretty="format:%>(1)%s" >actual && git log --pretty='format:%>(1)%s' >actual &&
# complete the incomplete line at the end # complete the incomplete line at the end
echo >>actual && echo >>actual &&
cat <<\EOF >expected && cat <<\EOF >expected &&
message two message two
message one message one
add bar add bar
initial $(commit_msg)
EOF EOF
test_cmp expected actual test_cmp expected actual
' "
test_expect_success 'center alignment formatting' ' test_expect_failure 'center alignment formatting' "
git log --pretty="format:%><(40)%s" >actual && git log --pretty='format:%><(40)%s' >actual &&
# complete the incomplete line at the end # complete the incomplete line at the end
echo >>actual && echo >>actual &&
qz_to_tab_space <<\EOF >expected && qz_to_tab_space <<\EOF >expected &&
Z message two Z Z message two Z
Z message one Z Z message one Z
Z add bar Z Z add bar Z
Z initial Z Z $(commit_msg) Z
EOF EOF
test_cmp expected actual test_cmp expected actual
' "
test_expect_success 'center alignment formatting at the nth column' " test_expect_failure 'center alignment formatting at the nth column' "
git log --pretty='format:%h %><|(40)%s' >actual && git log --pretty='format:%h %><|(40)%s' >actual &&
# complete the incomplete line at the end # complete the incomplete line at the end
echo >>actual && echo >>actual &&
@ -246,36 +283,36 @@ test_expect_success 'center alignment formatting at the nth column' "
$head1 message two Z $head1 message two Z
$head2 message one Z $head2 message one Z
$head3 add bar Z $head3 add bar Z
$head4 initial Z $head4 $(commit_msg) Z
EOF EOF
test_cmp expected actual test_cmp expected actual
" "
test_expect_success 'center alignment formatting with no padding' ' test_expect_failure 'center alignment formatting with no padding' "
git log --pretty="format:%><(1)%s" >actual && git log --pretty='format:%><(1)%s' >actual &&
# complete the incomplete line at the end # complete the incomplete line at the end
echo >>actual && echo >>actual &&
cat <<\EOF >expected && cat <<\EOF >expected &&
message two message two
message one message one
add bar add bar
initial $(commit_msg)
EOF EOF
test_cmp expected actual test_cmp expected actual
' "
test_expect_success 'left/right alignment formatting with stealing' ' test_expect_failure 'left/right alignment formatting with stealing' "
git commit --amend -m short --author "long long long <long@me.com>" && git commit --amend -m short --author 'long long long <long@me.com>' &&
git log --pretty="format:%<(10,trunc)%s%>>(10,ltrunc)% an" >actual && git log --pretty='format:%<(10,trunc)%s%>>(10,ltrunc)% an' >actual &&
# complete the incomplete line at the end # complete the incomplete line at the end
echo >>actual && echo >>actual &&
cat <<\EOF >expected && cat <<\EOF >expected &&
short long long long short long long long
message .. A U Thor message .. A U Thor
add bar A U Thor add bar A U Thor
initial A U Thor $(commit_msg "" "8" ".\+$") A U Thor
EOF EOF
test_cmp expected actual test_cmp expected actual
' "
test_done test_done

83
t/t6006-rev-list-format.sh
View File

@ -1,34 +1,60 @@
#!/bin/sh #!/bin/sh
# Copyright (c) 2009 Jens Lehmann
# Copyright (c) 2011 Alexey Shumkin (+ non-UTF-8 commit encoding tests)
test_description='git rev-list --pretty=format test' test_description='git rev-list --pretty=format test'
. ./test-lib.sh . ./test-lib.sh
. "$TEST_DIRECTORY"/lib-terminal.sh . "$TEST_DIRECTORY"/lib-terminal.sh
test_tick test_tick
# String "added" in German (translated with Google Translate), encoded in UTF-8,
# used as a commit log message below.
added=$(printf "added (hinzugef\303\274gt) foo")
added_iso88591=$(echo "$added" | iconv -f utf-8 -t iso-8859-1)
# same but "changed"
changed=$(printf "changed (ge\303\244ndert) foo")
changed_iso88591=$(echo "$changed" | iconv -f utf-8 -t iso-8859-1)
test_expect_success 'setup' ' test_expect_success 'setup' '
: >foo && : >foo &&
git add foo && git add foo &&
git commit -m "added foo" && git config i18n.commitEncoding iso-8859-1 &&
git commit -m "$added_iso88591" &&
head1=$(git rev-parse --verify HEAD) && head1=$(git rev-parse --verify HEAD) &&
head1_short=$(git rev-parse --verify --short $head1) && head1_short=$(git rev-parse --verify --short $head1) &&
tree1=$(git rev-parse --verify HEAD:) && tree1=$(git rev-parse --verify HEAD:) &&
tree1_short=$(git rev-parse --verify --short $tree1) && tree1_short=$(git rev-parse --verify --short $tree1) &&
echo changed >foo && echo "$changed" > foo &&
git commit -a -m "changed foo" && git commit -a -m "$changed_iso88591" &&
head2=$(git rev-parse --verify HEAD) && head2=$(git rev-parse --verify HEAD) &&
head2_short=$(git rev-parse --verify --short $head2) && head2_short=$(git rev-parse --verify --short $head2) &&
tree2=$(git rev-parse --verify HEAD:) && tree2=$(git rev-parse --verify HEAD:) &&
tree2_short=$(git rev-parse --verify --short $tree2) tree2_short=$(git rev-parse --verify --short $tree2)
git config --unset i18n.commitEncoding
' '
# usage: test_format name format_string <expected_output # usage: test_format [failure] name format_string <expected_output
test_format () { test_format () {
must_fail=0
# if parameters count is more than 2 then test must fail
if test $# -gt 2
then
must_fail=1
# remove first parameter which is flag for test failure
shift
fi
cat >expect.$1 cat >expect.$1
test_expect_success "format $1" " name="format $1"
git rev-list --pretty=format:'$2' master >output.$1 && command="git rev-list --pretty=format:'$2' master >output.$1 &&
test_cmp expect.$1 output.$1 test_cmp expect.$1 output.$1"
" if test $must_fail -eq 1
then
test_expect_failure "$name" "$command"
else
test_expect_success "$name" "$command"
fi
} }
# Feed to --format to provide predictable colored sequences. # Feed to --format to provide predictable colored sequences.
@ -110,14 +136,16 @@ EOF
test_format encoding %e <<EOF test_format encoding %e <<EOF
commit $head2 commit $head2
iso-8859-1
commit $head1 commit $head1
iso-8859-1
EOF EOF
test_format subject %s <<EOF test_format failure subject %s <<EOF
commit $head2 commit $head2
changed foo $changed
commit $head1 commit $head1
added foo $added
EOF EOF
test_format body %b <<EOF test_format body %b <<EOF
@ -125,12 +153,12 @@ commit $head2
commit $head1 commit $head1
EOF EOF
test_format raw-body %B <<EOF test_format failure raw-body %B <<EOF
commit $head2 commit $head2
changed foo $changed
commit $head1 commit $head1
added foo $added
EOF EOF
@ -190,42 +218,49 @@ test_expect_success '%C(auto) respects --color=auto (stdout not tty)' '
) )
' '
cat >commit-msg <<'EOF' iconv -f utf-8 -t iso8859-1 > commit-msg <<EOF
Test printing of complex bodies Test printing of complex bodies
This commit message is much longer than the others, This commit message is much longer than the others,
and it will be encoded in iso8859-1. We should therefore and it will be encoded in iso8859-1. We should therefore
include an iso8859 character: ¡bueno! include an iso8859 character: ¡bueno!
EOF EOF
test_expect_success 'setup complex body' ' test_expect_success 'setup complex body' '
git config i18n.commitencoding iso8859-1 && git config i18n.commitencoding iso8859-1 &&
echo change2 >foo && git commit -a -F commit-msg && echo change2 >foo && git commit -a -F commit-msg &&
head3=$(git rev-parse --verify HEAD) && head3=$(git rev-parse --verify HEAD) &&
head3_short=$(git rev-parse --short $head3) head3_short=$(git rev-parse --short $head3) &&
# unset commit encoding config
# otherwise %e does not print encoding value
# and following test fails
git config --unset i18n.commitEncoding
' '
test_format complex-encoding %e <<EOF test_format complex-encoding %e <<EOF
commit $head3 commit $head3
iso8859-1 iso8859-1
commit $head2 commit $head2
iso-8859-1
commit $head1 commit $head1
iso-8859-1
EOF EOF
test_format complex-subject %s <<EOF test_format failure complex-subject %s <<EOF
commit $head3 commit $head3
Test printing of complex bodies Test printing of complex bodies
commit $head2 commit $head2
changed foo $changed
commit $head1 commit $head1
added foo $added
EOF EOF
test_format complex-body %b <<EOF test_format failure complex-body %b <<EOF
commit $head3 commit $head3
This commit message is much longer than the others, This commit message is much longer than the others,
and it will be encoded in iso8859-1. We should therefore and it will be encoded in iso8859-1. We should therefore
include an iso8859 character: ¡bueno! include an iso8859 character: ¡bueno!
commit $head2 commit $head2
commit $head1 commit $head1
@ -279,12 +314,12 @@ test_expect_success 'add LF before non-empty (2)' '
test_expect_success 'add SP before non-empty (1)' ' test_expect_success 'add SP before non-empty (1)' '
git show -s --pretty=format:"%s% bThanks" HEAD^^ >actual && git show -s --pretty=format:"%s% bThanks" HEAD^^ >actual &&
test $(wc -w <actual) = 2 test $(wc -w <actual) = 3
' '
test_expect_success 'add SP before non-empty (2)' ' test_expect_success 'add SP before non-empty (2)' '
git show -s --pretty=format:"%s% sThanks" HEAD^^ >actual && git show -s --pretty=format:"%s% sThanks" HEAD^^ >actual &&
test $(wc -w <actual) = 4 test $(wc -w <actual) = 6
' '
test_expect_success '--abbrev' ' test_expect_success '--abbrev' '

29
t/t7102-reset.sh
View File

@ -9,6 +9,17 @@ Documented tests for git reset'
. ./test-lib.sh . ./test-lib.sh
commit_msg () {
# String "modify 2nd file (changed)" partly in German(translated with Google Translate),
# encoded in UTF-8, used as a commit log message below.
msg=$(printf "modify 2nd file (ge\303\244ndert)")
if test -n "$1"
then
msg=$(echo $msg | iconv -f utf-8 -t $1)
fi
echo $msg
}
test_expect_success 'creating initial files and commits' ' test_expect_success 'creating initial files and commits' '
test_tick && test_tick &&
echo "1st file" >first && echo "1st file" >first &&
@ -28,7 +39,7 @@ test_expect_success 'creating initial files and commits' '
echo "1st line 2nd file" >secondfile && echo "1st line 2nd file" >secondfile &&
echo "2nd line 2nd file" >>secondfile && echo "2nd line 2nd file" >>secondfile &&
git commit -a -m "modify 2nd file" && git -c "i18n.commitEncoding=iso-8859-1" commit -a -m "$(commit_msg iso-8859-1)" &&
head5=$(git rev-parse --verify HEAD) head5=$(git rev-parse --verify HEAD)
' '
# git log --pretty=oneline # to see those SHA1 involved # git log --pretty=oneline # to see those SHA1 involved
@ -44,6 +55,20 @@ check_changes () {
done | test_cmp .cat_expect - done | test_cmp .cat_expect -
} }
test_expect_failure 'reset --hard message' '
hex=$(git log -1 --format="%h") &&
git reset --hard > .actual &&
echo HEAD is now at $hex $(commit_msg) > .expected &&
test_cmp .expected .actual
'
test_expect_success 'reset --hard message (iso-8859-1 logoutencoding)' '
hex=$(git log -1 --format="%h") &&
git -c "i18n.logOutputEncoding=iso-8859-1" reset --hard > .actual &&
echo HEAD is now at $hex $(commit_msg iso-8859-1) > .expected &&
test_cmp .expected .actual
'
>.diff_expect >.diff_expect
>.cached_expect >.cached_expect
cat >.cat_expect <<EOF cat >.cat_expect <<EOF
@ -304,7 +329,7 @@ test_expect_success 'redoing the last two commits should succeed' '
echo "1st line 2nd file" >secondfile && echo "1st line 2nd file" >secondfile &&
echo "2nd line 2nd file" >>secondfile && echo "2nd line 2nd file" >>secondfile &&
git commit -a -m "modify 2nd file" && git -c "i18n.commitEncoding=iso-8859-1" commit -a -m "$(commit_msg iso-8859-1)" &&
check_changes $head5 check_changes $head5
' '