kernel
/
git
mirror of https://git.kernel.org/pub/scm/git/git.git
1
0
Fork 0
Code Releases Activity

Merge branch 'as/pretty-truncate' 

* as/pretty-truncate:
  pretty.c: format string with truncate respects logOutputEncoding
  t4205, t6006: add tests that fail with i18n.logOutputEncoding set
  t4205 (log-pretty-format): use `tformat` rather than `format`
  t4041, t4205, t6006, t7102: don't hardcode tested encoding value
  t4205 (log-pretty-formats): don't hardcode SHA-1 in expected outputs
maint
Junio C Hamano 2014-06-16 10:07:12 -07:00
parent b0e2c999af 7d509878b8
commit 09e13ad5b0
5 changed files with 282 additions and 72 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
pretty.c
View File

@ -1506,13 +1506,18 @@ void format_commit_message(const struct commit *commit,
context.commit = commit; context.commit = commit;
context.pretty_ctx = pretty_ctx; context.pretty_ctx = pretty_ctx;
context.wrap_start = sb->len; context.wrap_start = sb->len;
/*
* convert a commit message to UTF-8 first
* as far as 'format_commit_item' assumes it in UTF-8
*/
context.message = logmsg_reencode(commit, context.message = logmsg_reencode(commit,
&context.commit_encoding, &context.commit_encoding,
output_enc); utf8);


strbuf_expand(sb, format, format_commit_item, &context); strbuf_expand(sb, format, format_commit_item, &context);
rewrap_message_tail(sb, &context, 0, 0, 0); rewrap_message_tail(sb, &context, 0, 0, 0);


/* then convert a commit message to an actual output encoding */
if (output_enc) { if (output_enc) {
if (same_encoding(utf8, output_enc)) if (same_encoding(utf8, output_enc))
output_enc = NULL; output_enc = NULL;

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

@ -11,6 +11,9 @@ This test tries to verify the sanity of the --submodule option of git diff.


. ./test-lib.sh . ./test-lib.sh


# Tested non-UTF-8 encoding
test_encoding="ISO8859-1"

# String "added" in German (translated with Google Translate), encoded in UTF-8, # String "added" in German (translated with Google Translate), encoded in UTF-8,
# used in sample commit log messages in add_file() function below. # used in sample commit log messages in add_file() function below.
added=$(printf "hinzugef\303\274gt") added=$(printf "hinzugef\303\274gt")
@ -23,8 +26,8 @@ add_file () {
echo "$name" >"$name" && echo "$name" >"$name" &&
git add "$name" && git add "$name" &&
test_tick && test_tick &&
msg_added_iso88591=$(echo "Add $name ($added $name)" | iconv -f utf-8 -t iso8859-1) && msg_added_iso88591=$(echo "Add $name ($added $name)" | iconv -f utf-8 -t $test_encoding) &&
git -c 'i18n.commitEncoding=iso8859-1' commit -m "$msg_added_iso88591" git -c "i18n.commitEncoding=$test_encoding" commit -m "$msg_added_iso88591"
done >/dev/null && done >/dev/null &&
git rev-parse --short --verify HEAD git rev-parse --short --verify HEAD
) )

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

@ -7,6 +7,9 @@
test_description='Test pretty formats' test_description='Test pretty formats'
. ./test-lib.sh . ./test-lib.sh


# Tested non-UTF-8 encoding
test_encoding="ISO8859-1"

sample_utf8_part=$(printf "f\303\244ng") sample_utf8_part=$(printf "f\303\244ng")


commit_msg () { commit_msg () {
@ -27,8 +30,8 @@ test_expect_success 'set up basic repos' '
>bar && >bar &&
git add foo && git add foo &&
test_tick && test_tick &&
git config i18n.commitEncoding iso8859-1 && git config i18n.commitEncoding $test_encoding &&
git commit -m "$(commit_msg iso8859-1)" && git commit -m "$(commit_msg $test_encoding)" &&
git add bar && git add bar &&
test_tick && test_tick &&
git commit -m "add bar" && git commit -m "add bar" &&
@ -56,8 +59,8 @@ test_expect_success 'alias user-defined format' '
test_cmp expected actual test_cmp expected actual
' '


test_expect_success 'alias user-defined tformat with %s (iso8859-1 encoding)' ' test_expect_success 'alias user-defined tformat with %s (ISO8859-1 encoding)' '
git config i18n.logOutputEncoding iso8859-1 && git config i18n.logOutputEncoding $test_encoding &&
git log --oneline >expected-s && git log --oneline >expected-s &&
git log --pretty="tformat:%h %s" >actual-s && git log --pretty="tformat:%h %s" >actual-s &&
git config --unset i18n.logOutputEncoding && git config --unset i18n.logOutputEncoding &&
@ -141,9 +144,7 @@ test_expect_success 'setup more commits' '
' '


test_expect_success 'left alignment formatting' ' test_expect_success 'left alignment formatting' '
git log --pretty="format:%<(40)%s" >actual && git log --pretty="tformat:%<(40)%s" >actual &&
# complete the incomplete line at the end
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
@ -153,10 +154,19 @@ EOF
test_cmp expected actual test_cmp expected actual
' '


test_expect_success 'left alignment formatting. i18n.logOutputEncoding' '
git -c i18n.logOutputEncoding=$test_encoding log --pretty="tformat:%<(40)%s" >actual &&
qz_to_tab_space <<EOF | iconv -f utf-8 -t $test_encoding >expected &&
message two Z
message one Z
add bar Z
$(commit_msg) Z
EOF
test_cmp expected actual
'

test_expect_success 'left alignment formatting at the nth column' ' test_expect_success 'left alignment formatting at the nth column' '
git log --pretty="format:%h %<|(40)%s" >actual && git log --pretty="tformat:%h %<|(40)%s" >actual &&
# complete the incomplete line at the end
echo >>actual &&
qz_to_tab_space <<EOF >expected && qz_to_tab_space <<EOF >expected &&
$head1 message two Z $head1 message two Z
$head2 message one Z $head2 message one Z
@ -166,10 +176,19 @@ EOF
test_cmp expected actual test_cmp expected actual
' '


test_expect_success 'left alignment formatting at the nth column. i18n.logOutputEncoding' '
git -c i18n.logOutputEncoding=$test_encoding log --pretty="tformat:%h %<|(40)%s" >actual &&
qz_to_tab_space <<EOF | iconv -f utf-8 -t $test_encoding >expected &&
$head1 message two Z
$head2 message one Z
$head3 add bar Z
$head4 $(commit_msg) Z
EOF
test_cmp expected actual
'

test_expect_success 'left alignment formatting with no padding' ' test_expect_success 'left alignment formatting with no padding' '
git log --pretty="format:%<(1)%s" >actual && git log --pretty="tformat:%<(1)%s" >actual &&
# complete the incomplete line at the end
echo >>actual &&
cat <<EOF >expected && cat <<EOF >expected &&
message two message two
message one message one
@ -179,10 +198,19 @@ EOF
test_cmp expected actual test_cmp expected actual
' '


test_expect_success 'left alignment formatting with no padding. i18n.logOutputEncoding' '
git -c i18n.logOutputEncoding=$test_encoding log --pretty="tformat:%<(1)%s" >actual &&
cat <<EOF | iconv -f utf-8 -t $test_encoding >expected &&
message two
message one
add bar
$(commit_msg)
EOF
test_cmp expected actual
'

test_expect_success 'left alignment formatting with trunc' ' test_expect_success 'left alignment formatting with trunc' '
git log --pretty="format:%<(10,trunc)%s" >actual && git log --pretty="tformat:%<(10,trunc)%s" >actual &&
# complete the incomplete line at the end
echo >>actual &&
qz_to_tab_space <<EOF >expected && qz_to_tab_space <<EOF >expected &&
message .. message ..
message .. message ..
@ -192,10 +220,19 @@ EOF
test_cmp expected actual test_cmp expected actual
' '


test_expect_success 'left alignment formatting with trunc. i18n.logOutputEncoding' '
git -c i18n.logOutputEncoding=$test_encoding log --pretty="tformat:%<(10,trunc)%s" >actual &&
qz_to_tab_space <<EOF | iconv -f utf-8 -t $test_encoding >expected &&
message ..
message ..
add bar Z
initial...
EOF
test_cmp expected actual
'

test_expect_success 'left alignment formatting with ltrunc' ' test_expect_success 'left alignment formatting with ltrunc' '
git log --pretty="format:%<(10,ltrunc)%s" >actual && git log --pretty="tformat:%<(10,ltrunc)%s" >actual &&
# complete the incomplete line at the end
echo >>actual &&
qz_to_tab_space <<EOF >expected && qz_to_tab_space <<EOF >expected &&
..sage two ..sage two
..sage one ..sage one
@ -205,10 +242,19 @@ EOF
test_cmp expected actual test_cmp expected actual
' '


test_expect_success 'left alignment formatting with ltrunc. i18n.logOutputEncoding' '
git -c i18n.logOutputEncoding=$test_encoding log --pretty="tformat:%<(10,ltrunc)%s" >actual &&
qz_to_tab_space <<EOF | iconv -f utf-8 -t $test_encoding >expected &&
..sage two
..sage one
add bar Z
..${sample_utf8_part}lich
EOF
test_cmp expected actual
'

test_expect_success 'left alignment formatting with mtrunc' ' test_expect_success 'left alignment formatting with mtrunc' '
git log --pretty="format:%<(10,mtrunc)%s" >actual && git log --pretty="tformat:%<(10,mtrunc)%s" >actual &&
# complete the incomplete line at the end
echo >>actual &&
qz_to_tab_space <<EOF >expected && qz_to_tab_space <<EOF >expected &&
mess.. two mess.. two
mess.. one mess.. one
@ -218,10 +264,19 @@ EOF
test_cmp expected actual test_cmp expected actual
' '


test_expect_success 'left alignment formatting with mtrunc. i18n.logOutputEncoding' '
git -c i18n.logOutputEncoding=$test_encoding log --pretty="tformat:%<(10,mtrunc)%s" >actual &&
qz_to_tab_space <<EOF | iconv -f utf-8 -t $test_encoding >expected &&
mess.. two
mess.. one
add bar Z
init..lich
EOF
test_cmp expected actual
'

test_expect_success 'right alignment formatting' ' test_expect_success 'right alignment formatting' '
git log --pretty="format:%>(40)%s" >actual && git log --pretty="tformat:%>(40)%s" >actual &&
# complete the incomplete line at the end
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
@ -231,10 +286,19 @@ EOF
test_cmp expected actual test_cmp expected actual
' '


test_expect_success 'right alignment formatting. i18n.logOutputEncoding' '
git -c i18n.logOutputEncoding=$test_encoding log --pretty="tformat:%>(40)%s" >actual &&
qz_to_tab_space <<EOF | iconv -f utf-8 -t $test_encoding >expected &&
Z message two
Z message one
Z add bar
Z $(commit_msg)
EOF
test_cmp expected actual
'

test_expect_success 'right alignment formatting at the nth column' ' test_expect_success 'right alignment formatting at the nth column' '
git log --pretty="format:%h %>|(40)%s" >actual && git log --pretty="tformat:%h %>|(40)%s" >actual &&
# complete the incomplete line at the end
echo >>actual &&
qz_to_tab_space <<EOF >expected && qz_to_tab_space <<EOF >expected &&
$head1 message two $head1 message two
$head2 message one $head2 message one
@ -244,10 +308,19 @@ EOF
test_cmp expected actual test_cmp expected actual
' '


test_expect_success 'right alignment formatting at the nth column. i18n.logOutputEncoding' '
git -c i18n.logOutputEncoding=$test_encoding log --pretty="tformat:%h %>|(40)%s" >actual &&
qz_to_tab_space <<EOF | iconv -f utf-8 -t $test_encoding >expected &&
$head1 message two
$head2 message one
$head3 add bar
$head4 $(commit_msg)
EOF
test_cmp expected actual
'

test_expect_success 'right alignment formatting with no padding' ' test_expect_success 'right alignment formatting with no padding' '
git log --pretty="format:%>(1)%s" >actual && git log --pretty="tformat:%>(1)%s" >actual &&
# complete the incomplete line at the end
echo >>actual &&
cat <<EOF >expected && cat <<EOF >expected &&
message two message two
message one message one
@ -257,10 +330,19 @@ EOF
test_cmp expected actual test_cmp expected actual
' '


test_expect_success 'right alignment formatting with no padding. i18n.logOutputEncoding' '
git -c i18n.logOutputEncoding=$test_encoding log --pretty="tformat:%>(1)%s" >actual &&
cat <<EOF | iconv -f utf-8 -t $test_encoding >expected &&
message two
message one
add bar
$(commit_msg)
EOF
test_cmp expected actual
'

test_expect_success 'center alignment formatting' ' test_expect_success 'center alignment formatting' '
git log --pretty="format:%><(40)%s" >actual && git log --pretty="tformat:%><(40)%s" >actual &&
# complete the incomplete line at the end
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
@ -270,10 +352,18 @@ EOF
test_cmp expected actual test_cmp expected actual
' '


test_expect_success 'center alignment formatting. i18n.logOutputEncoding' '
git -c i18n.logOutputEncoding=$test_encoding log --pretty="tformat:%><(40)%s" >actual &&
qz_to_tab_space <<EOF | iconv -f utf-8 -t $test_encoding >expected &&
Z message two Z
Z message one Z
Z add bar Z
Z $(commit_msg) Z
EOF
test_cmp expected actual
'
test_expect_success 'center alignment formatting at the nth column' ' test_expect_success 'center alignment formatting at the nth column' '
git log --pretty="format:%h %><|(40)%s" >actual && git log --pretty="tformat:%h %><|(40)%s" >actual &&
# complete the incomplete line at the end
echo >>actual &&
qz_to_tab_space <<EOF >expected && qz_to_tab_space <<EOF >expected &&
$head1 message two Z $head1 message two Z
$head2 message one Z $head2 message one Z
@ -283,10 +373,19 @@ EOF
test_cmp expected actual test_cmp expected actual
' '


test_expect_success 'center alignment formatting at the nth column. i18n.logOutputEncoding' '
git -c i18n.logOutputEncoding=$test_encoding log --pretty="tformat:%h %><|(40)%s" >actual &&
qz_to_tab_space <<EOF | iconv -f utf-8 -t $test_encoding >expected &&
$head1 message two Z
$head2 message one Z
$head3 add bar Z
$head4 $(commit_msg) Z
EOF
test_cmp expected actual
'

test_expect_success 'center alignment formatting with no padding' ' test_expect_success 'center alignment formatting with no padding' '
git log --pretty="format:%><(1)%s" >actual && git log --pretty="tformat:%><(1)%s" >actual &&
# complete the incomplete line at the end
echo >>actual &&
cat <<EOF >expected && cat <<EOF >expected &&
message two message two
message one message one
@ -296,11 +395,23 @@ EOF
test_cmp expected actual test_cmp expected actual
' '


# save HEAD's SHA-1 digest (with no abbreviations) to use it below
# as far as the next test amends HEAD
old_head1=$(git rev-parse --verify HEAD~0)
test_expect_success 'center alignment formatting with no padding. i18n.logOutputEncoding' '
git -c i18n.logOutputEncoding=$test_encoding log --pretty="tformat:%><(1)%s" >actual &&
cat <<EOF | iconv -f utf-8 -t $test_encoding >expected &&
message two
message one
add bar
$(commit_msg)
EOF
test_cmp expected actual
'

test_expect_success 'left/right alignment formatting with stealing' ' test_expect_success '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="tformat:%<(10,trunc)%s%>>(10,ltrunc)% an" >actual &&
# complete the incomplete line at the end
echo >>actual &&
cat <<EOF >expected && cat <<EOF >expected &&
short long long long short long long long
message .. A U Thor message .. A U Thor
@ -309,6 +420,20 @@ initial... A U Thor
EOF EOF
test_cmp expected actual test_cmp expected actual
' '
test_expect_success 'left/right alignment formatting with stealing. i18n.logOutputEncoding' '
git -c i18n.logOutputEncoding=$test_encoding log --pretty="tformat:%<(10,trunc)%s%>>(10,ltrunc)% an" >actual &&
cat <<EOF | iconv -f utf-8 -t $test_encoding >expected &&
short long long long
message .. A U Thor
add bar A U Thor
initial... A U Thor
EOF
test_cmp expected actual
'

# get new digests (with no abbreviations)
head1=$(git rev-parse --verify HEAD~0) &&
head2=$(git rev-parse --verify HEAD~1) &&


test_expect_success 'log decoration properly follows tag chain' ' test_expect_success 'log decoration properly follows tag chain' '
git tag -a tag1 -m tag1 && git tag -a tag1 -m tag1 &&
@ -317,9 +442,9 @@ test_expect_success 'log decoration properly follows tag chain' '
git commit --amend -m shorter && git commit --amend -m shorter &&
git log --no-walk --tags --pretty="%H %d" --decorate=full >actual && git log --no-walk --tags --pretty="%H %d" --decorate=full >actual &&
cat <<EOF >expected && cat <<EOF >expected &&
6a908c10688b2503073c39c9ba26322c73902bb5 (tag: refs/tags/tag2) $head1 (tag: refs/tags/tag2)
9f716384d92283fb915a4eee5073f030638e05f9 (tag: refs/tags/message-one) $head2 (tag: refs/tags/message-one)
b87e4cccdb77336ea79d89224737be7ea8e95367 (tag: refs/tags/message-two) $old_head1 (tag: refs/tags/message-two)
EOF EOF
sort actual >actual1 && sort actual >actual1 &&
test_cmp expected actual1 test_cmp expected actual1

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

@ -9,19 +9,32 @@ test_description='git rev-list --pretty=format test'
. "$TEST_DIRECTORY"/lib-terminal.sh . "$TEST_DIRECTORY"/lib-terminal.sh


test_tick test_tick
# Tested non-UTF-8 encoding
test_encoding="ISO8859-1"

# String "added" in German # String "added" in German
# (translated with Google Translate), # (translated with Google Translate),
# encoded in UTF-8, used as a commit log message below. # encoded in UTF-8, used as a commit log message below.
added=$(printf "added (hinzugef\303\274gt) foo") added_utf8_part=$(printf "\303\274")
added_iso88591=$(echo "$added" | iconv -f utf-8 -t iso8859-1) added_utf8_part_iso88591=$(echo "$added_utf8_part" | iconv -f utf-8 -t $test_encoding)
added=$(printf "added (hinzugef${added_utf8_part}gt) foo")
added_iso88591=$(echo "$added" | iconv -f utf-8 -t $test_encoding)
# same but "changed" # same but "changed"
changed=$(printf "changed (ge\303\244ndert) foo") changed_utf8_part=$(printf "\303\244")
changed_iso88591=$(echo "$changed" | iconv -f utf-8 -t iso8859-1) changed_utf8_part_iso88591=$(echo "$changed_utf8_part" | iconv -f utf-8 -t $test_encoding)
changed=$(printf "changed (ge${changed_utf8_part}ndert) foo")
changed_iso88591=$(echo "$changed" | iconv -f utf-8 -t $test_encoding)

# Count of char to truncate
# Number is chosen so, that non-ACSII characters
# (see $added_utf8_part and $changed_utf8_part)
# fall into truncated parts of appropriate words both from left and right
truncate_count=20


test_expect_success 'setup' ' test_expect_success 'setup' '
: >foo && : >foo &&
git add foo && git add foo &&
git config i18n.commitEncoding iso8859-1 && git config i18n.commitEncoding $test_encoding &&
git commit -m "$added_iso88591" && 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) &&
@ -124,9 +137,9 @@ EOF


test_format encoding %e <<EOF test_format encoding %e <<EOF
commit $head2 commit $head2
iso8859-1 $test_encoding
commit $head1 commit $head1
iso8859-1 $test_encoding
EOF EOF


test_format subject %s <<EOF test_format subject %s <<EOF
@ -136,6 +149,13 @@ commit $head1
$added $added
EOF EOF


test_format subject-truncated "%<($truncate_count,trunc)%s" <<EOF
commit $head2
changed (ge${changed_utf8_part}ndert)..
commit $head1
added (hinzugef${added_utf8_part}gt..
EOF

test_format body %b <<EOF test_format body %b <<EOF
commit $head2 commit $head2
commit $head1 commit $head1
@ -203,16 +223,16 @@ test_expect_success '%C(auto) respects --color=auto (stdout not tty)' '
) )
' '


iconv -f utf-8 -t iso8859-1 > commit-msg <<EOF iconv -f utf-8 -t $test_encoding > 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 $test_encoding. 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 $test_encoding &&
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)
@ -220,11 +240,11 @@ test_expect_success 'setup complex body' '


test_format complex-encoding %e <<EOF test_format complex-encoding %e <<EOF
commit $head3 commit $head3
iso8859-1 $test_encoding
commit $head2 commit $head2
iso8859-1 $test_encoding
commit $head1 commit $head1
iso8859-1 $test_encoding
EOF EOF


test_format complex-subject %s <<EOF test_format complex-subject %s <<EOF
@ -236,20 +256,47 @@ commit $head1
$added_iso88591 $added_iso88591
EOF EOF


test_format complex-subject-trunc "%<($truncate_count,trunc)%s" <<EOF
commit $head3
Test printing of c..
commit $head2
changed (ge${changed_utf8_part_iso88591}ndert)..
commit $head1
added (hinzugef${added_utf8_part_iso88591}gt..
EOF

test_format complex-subject-mtrunc "%<($truncate_count,mtrunc)%s" <<EOF
commit $head3
Test prin..ex bodies
commit $head2
changed (..dert) foo
commit $head1
added (hi..f${added_utf8_part_iso88591}gt) foo
EOF

test_format complex-subject-ltrunc "%<($truncate_count,ltrunc)%s" <<EOF
commit $head3
.. of complex bodies
commit $head2
..ged (ge${changed_utf8_part_iso88591}ndert) foo
commit $head1
.. (hinzugef${added_utf8_part_iso88591}gt) foo
EOF

test_expect_success 'prepare expected messages (for test %b)' ' test_expect_success 'prepare expected messages (for test %b)' '
cat <<-EOF >expected.utf-8 && cat <<-EOF >expected.utf-8 &&
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 $test_encoding. We should therefore
include an iso8859 character: ¡bueno! include an ISO8859 character: ¡bueno!


commit $head2 commit $head2
commit $head1 commit $head1
EOF EOF
iconv -f utf-8 -t iso8859-1 expected.utf-8 >expected.iso8859-1 iconv -f utf-8 -t $test_encoding expected.utf-8 >expected.ISO8859-1
' '


test_format complex-body %b <expected.iso8859-1 test_format complex-body %b <expected.ISO8859-1


# Git uses i18n.commitEncoding if no i18n.logOutputEncoding set # Git uses i18n.commitEncoding if no i18n.logOutputEncoding set
# so unset i18n.commitEncoding to test encoding conversion # so unset i18n.commitEncoding to test encoding conversion
@ -264,6 +311,33 @@ commit $head1
$added $added
EOF EOF


test_format complex-subject-commitencoding-unset-trunc "%<($truncate_count,trunc)%s" <<EOF
commit $head3
Test printing of c..
commit $head2
changed (ge${changed_utf8_part}ndert)..
commit $head1
added (hinzugef${added_utf8_part}gt..
EOF

test_format complex-subject-commitencoding-unset-mtrunc "%<($truncate_count,mtrunc)%s" <<EOF
commit $head3
Test prin..ex bodies
commit $head2
changed (..dert) foo
commit $head1
added (hi..f${added_utf8_part}gt) foo
EOF

test_format complex-subject-commitencoding-unset-ltrunc "%<($truncate_count,ltrunc)%s" <<EOF
commit $head3
.. of complex bodies
commit $head2
..ged (ge${changed_utf8_part}ndert) foo
commit $head1
.. (hinzugef${added_utf8_part}gt) foo
EOF

test_format complex-body-commitencoding-unset %b <expected.utf-8 test_format complex-body-commitencoding-unset %b <expected.utf-8


test_expect_success '%x00 shows NUL' ' test_expect_success '%x00 shows NUL' '

13
t/t7102-reset.sh
View File

@ -22,6 +22,9 @@ commit_msg () {
fi fi
} }


# Tested non-UTF-8 encoding
test_encoding="ISO8859-1"

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 &&
@ -41,7 +44,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 -c "i18n.commitEncoding=iso8859-1" commit -a -m "$(commit_msg iso8859-1)" && git -c "i18n.commitEncoding=$test_encoding" commit -a -m "$(commit_msg $test_encoding)" &&
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
@ -64,10 +67,10 @@ test_expect_success 'reset --hard message' '
test_cmp .expected .actual test_cmp .expected .actual
' '


test_expect_success 'reset --hard message (iso8859-1 logoutputencoding)' ' test_expect_success 'reset --hard message (ISO8859-1 logoutputencoding)' '
hex=$(git log -1 --format="%h") && hex=$(git log -1 --format="%h") &&
git -c "i18n.logOutputEncoding=iso8859-1" reset --hard > .actual && git -c "i18n.logOutputEncoding=$test_encoding" reset --hard > .actual &&
echo HEAD is now at $hex $(commit_msg iso8859-1) > .expected && echo HEAD is now at $hex $(commit_msg $test_encoding) > .expected &&
test_cmp .expected .actual test_cmp .expected .actual
' '


@ -331,7 +334,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 -c "i18n.commitEncoding=iso8859-1" commit -a -m "$(commit_msg iso8859-1)" && git -c "i18n.commitEncoding=$test_encoding" commit -a -m "$(commit_msg $test_encoding)" &&
check_changes $head5 check_changes $head5
' '