[thirdparty/git.git] / t / t5000-tar-tree.sh

#!/bin/sh
#
# Copyright (C) 2005 Rene Scharfe
#

test_description='git archive and git get-tar-commit-id test

This test covers the topics of file contents, commit date handling and
commit id embedding:

  The contents of the repository is compared to the extracted tar
  archive.  The repository contains simple text files, symlinks and a
  binary file (/bin/sh).  Only paths shorter than 99 characters are
  used.

  git archive applies the commit date to every file in the archive it
  creates.  The test sets the commit date to a specific value and checks
  if the tar archive contains that value.

  When giving git archive a commit id (in contrast to a tree id) it
  embeds this commit id into the tar archive as a comment.  The test
  checks the ability of git get-tar-commit-id to figure it out from the
  tar file.

'

. ./test-lib.sh

SUBSTFORMAT=%H%n

test_lazy_prereq TAR_NEEDS_PAX_FALLBACK '
	(
		mkdir pax &&
		cd pax &&
		"$TAR" xf "$TEST_DIRECTORY"/t5000/pax.tar &&
		test -f PaxHeaders.1791/file
	)
'

test_lazy_prereq GZIP 'gzip --version'

get_pax_header() {
	file=$1
	header=$2=

	while read len rest
	do
		if test "$len" = $(echo "$len $rest" | wc -c)
		then
			case "$rest" in
			$header*)
				echo "${rest#$header}"
				;;
			esac
		fi
	done <"$file"
}

check_tar() {
	tarfile=$1.tar
	listfile=$1.lst
	dir=$1
	dir_with_prefix=$dir/$2

	test_expect_success ' extract tar archive' '
		(mkdir $dir && cd $dir && "$TAR" xf -) <$tarfile
	'

	test_expect_success TAR_NEEDS_PAX_FALLBACK ' interpret pax headers' '
		(
			cd $dir &&
			for header in *.paxheader
			do
				data=${header%.paxheader}.data &&
				if test -h $data || test -e $data
				then
					path=$(get_pax_header $header path) &&
					if test -n "$path"
					then
						mv "$data" "$path"
					fi
				fi
			done
		)
	'

	test_expect_success ' validate filenames' '
		(cd ${dir_with_prefix}a && find .) | sort >$listfile &&
		test_cmp a.lst $listfile
	'

	test_expect_success ' validate file contents' '
		diff -r a ${dir_with_prefix}a
	'
}

test_expect_success \
    'populate workdir' \
    'mkdir a &&
     echo simple textfile >a/a &&
     ten=0123456789 && hundred=$ten$ten$ten$ten$ten$ten$ten$ten$ten$ten &&
     echo long filename >a/four$hundred &&
     mkdir a/bin &&
     test-genrandom "frotz" 500000 >a/bin/sh &&
     printf "A\$Format:%s\$O" "$SUBSTFORMAT" >a/substfile1 &&
     printf "A not substituted O" >a/substfile2 &&
     if test_have_prereq SYMLINKS; then
	ln -s a a/l1
     else
	printf %s a > a/l1
     fi &&
     (p=long_path_to_a_file && cd a &&
      for depth in 1 2 3 4 5; do mkdir $p && cd $p; done &&
      echo text >file_with_long_path) &&
     (cd a && find .) | sort >a.lst'

test_expect_success \
    'add ignored file' \
    'echo ignore me >a/ignored &&
     echo ignored export-ignore >.git/info/attributes'

test_expect_success 'add files to repository' '
	git add a &&
	GIT_COMMITTER_DATE="2005-05-27 22:00" git commit -m initial
'

test_expect_success 'setup export-subst' '
	echo "substfile?" export-subst >>.git/info/attributes &&
	git log --max-count=1 "--pretty=format:A${SUBSTFORMAT}O" HEAD \
		>a/substfile1
'

test_expect_success \
    'create bare clone' \
    'git clone --bare . bare.git &&
     cp .git/info/attributes bare.git/info/attributes'

test_expect_success \
    'remove ignored file' \
    'rm a/ignored'

test_expect_success \
    'git archive' \
    'git archive HEAD >b.tar'

check_tar b

test_expect_success 'git archive --prefix=prefix/' '
	git archive --prefix=prefix/ HEAD >with_prefix.tar
'

check_tar with_prefix prefix/

test_expect_success 'git-archive --prefix=olde-' '
	git archive --prefix=olde- HEAD >with_olde-prefix.tar
'

check_tar with_olde-prefix olde-

test_expect_success 'git archive on large files' '
    test_config core.bigfilethreshold 1 &&
    git archive HEAD >b3.tar &&
    test_cmp_bin b.tar b3.tar
'

test_expect_success \
    'git archive in a bare repo' \
    '(cd bare.git && git archive HEAD) >b3.tar'

test_expect_success \
    'git archive vs. the same in a bare repo' \
    'test_cmp_bin b.tar b3.tar'

test_expect_success 'git archive with --output' \
    'git archive --output=b4.tar HEAD &&
    test_cmp_bin b.tar b4.tar'

test_expect_success 'git archive --remote' \
    'git archive --remote=. HEAD >b5.tar &&
    test_cmp_bin b.tar b5.tar'

test_expect_success \
    'validate file modification time' \
    'mkdir extract &&
     "$TAR" xf b.tar -C extract a/a &&
     test-chmtime -v +0 extract/a/a |cut -f 1 >b.mtime &&
     echo "1117231200" >expected.mtime &&
     test_cmp expected.mtime b.mtime'

test_expect_success \
    'git get-tar-commit-id' \
    'git get-tar-commit-id <b.tar >b.commitid &&
     test_cmp .git/$(git symbolic-ref HEAD) b.commitid'

test_expect_success 'git archive with --output, override inferred format' '
	git archive --format=tar --output=d4.zip HEAD &&
	test_cmp_bin b.tar d4.zip
'

test_expect_success \
    'git archive --list outside of a git repo' \
    'GIT_DIR=some/non-existing/directory git archive --list'

test_expect_success 'clients cannot access unreachable commits' '
	test_commit unreachable &&
	sha1=$(git rev-parse HEAD) &&
	git reset --hard HEAD^ &&
	git archive $sha1 >remote.tar &&
	test_must_fail git archive --remote=. $sha1 >remote.tar
'

test_expect_success 'upload-archive can allow unreachable commits' '
	test_commit unreachable1 &&
	sha1=$(git rev-parse HEAD) &&
	git reset --hard HEAD^ &&
	git archive $sha1 >remote.tar &&
	test_config uploadarchive.allowUnreachable true &&
	git archive --remote=. $sha1 >remote.tar
'

test_expect_success 'setup tar filters' '
	git config tar.tar.foo.command "tr ab ba" &&
	git config tar.bar.command "tr ab ba" &&
	git config tar.bar.remote true &&
	git config tar.invalid baz
'

test_expect_success 'archive --list mentions user filter' '
	git archive --list >output &&
	grep "^tar\.foo\$" output &&
	grep "^bar\$" output
'

test_expect_success 'archive --list shows only enabled remote filters' '
	git archive --list --remote=. >output &&
	! grep "^tar\.foo\$" output &&
	grep "^bar\$" output
'

test_expect_success 'invoke tar filter by format' '
	git archive --format=tar.foo HEAD >config.tar.foo &&
	tr ab ba <config.tar.foo >config.tar &&
	test_cmp_bin b.tar config.tar &&
	git archive --format=bar HEAD >config.bar &&
	tr ab ba <config.bar >config.tar &&
	test_cmp_bin b.tar config.tar
'

test_expect_success 'invoke tar filter by extension' '
	git archive -o config-implicit.tar.foo HEAD &&
	test_cmp_bin config.tar.foo config-implicit.tar.foo &&
	git archive -o config-implicit.bar HEAD &&
	test_cmp_bin config.tar.foo config-implicit.bar
'

test_expect_success 'default output format remains tar' '
	git archive -o config-implicit.baz HEAD &&
	test_cmp_bin b.tar config-implicit.baz
'

test_expect_success 'extension matching requires dot' '
	git archive -o config-implicittar.foo HEAD &&
	test_cmp_bin b.tar config-implicittar.foo
'

test_expect_success 'only enabled filters are available remotely' '
	test_must_fail git archive --remote=. --format=tar.foo HEAD \
		>remote.tar.foo &&
	git archive --remote=. --format=bar >remote.bar HEAD &&
	test_cmp_bin remote.bar config.bar
'

test_expect_success GZIP 'git archive --format=tgz' '
	git archive --format=tgz HEAD >j.tgz
'

test_expect_success GZIP 'git archive --format=tar.gz' '
	git archive --format=tar.gz HEAD >j1.tar.gz &&
	test_cmp_bin j.tgz j1.tar.gz
'

test_expect_success GZIP 'infer tgz from .tgz filename' '
	git archive --output=j2.tgz HEAD &&
	test_cmp_bin j.tgz j2.tgz
'

test_expect_success GZIP 'infer tgz from .tar.gz filename' '
	git archive --output=j3.tar.gz HEAD &&
	test_cmp_bin j.tgz j3.tar.gz
'

test_expect_success GZIP 'extract tgz file' '
	gzip -d -c <j.tgz >j.tar &&
	test_cmp_bin b.tar j.tar
'

test_expect_success GZIP 'remote tar.gz is allowed by default' '
	git archive --remote=. --format=tar.gz HEAD >remote.tar.gz &&
	test_cmp_bin j.tgz remote.tar.gz
'

test_expect_success GZIP 'remote tar.gz can be disabled' '
	git config tar.tar.gz.remote false &&
	test_must_fail git archive --remote=. --format=tar.gz HEAD \
		>remote.tar.gz
'

test_expect_success 'archive and :(glob)' '
	git archive -v HEAD -- ":(glob)**/sh" >/dev/null 2>actual &&
	cat >expect <<EOF &&
a/
a/bin/
a/bin/sh
EOF
	test_cmp expect actual
'

test_expect_success 'catch non-matching pathspec' '
	test_must_fail git archive -v HEAD -- "*.abc" >/dev/null
'

# Pull the size and date of each entry in a tarfile using the system tar.
#
# We'll pull out only the year from the date; that avoids any question of
# timezones impacting the result (as long as we keep our test times away from a
# year boundary; our reference times are all in August).
#
# The output of tar_info is expected to be "<size> <year>", both in decimal. It
# ignores the return value of tar. We have to do this, because some of our test
# input is only partial (the real data is 64GB in some cases).
tar_info () {
	"$TAR" tvf "$1" |
	awk '{
		split($4, date, "-")
		print $3 " " date[1]
	}'
}

# See if our system tar can handle a tar file with huge sizes and dates far in
# the future, and that we can actually parse its output.
#
# The reference file was generated by GNU tar, and the magic time and size are
# both octal 01000000000001, which overflows normal ustar fields.
test_lazy_prereq TAR_HUGE '
	echo "68719476737 4147" >expect &&
	tar_info "$TEST_DIRECTORY"/t5000/huge-and-future.tar >actual &&
	test_cmp expect actual
'

test_expect_success 'set up repository with huge blob' '
	obj_d=19 &&
	obj_f=f9c8273ec45a8938e6999cb59b3ff66739902a &&
	obj=${obj_d}${obj_f} &&
	mkdir -p .git/objects/$obj_d &&
	cp "$TEST_DIRECTORY"/t5000/$obj .git/objects/$obj_d/$obj_f &&
	rm -f .git/index &&
	git update-index --add --cacheinfo 100644,$obj,huge &&
	git commit -m huge
'

# We expect git to die with SIGPIPE here (otherwise we
# would generate the whole 64GB).
test_expect_success 'generate tar with huge size' '
	{
		git archive HEAD
		echo $? >exit-code
	} | test_copy_bytes 4096 >huge.tar &&
	echo 141 >expect &&
	test_cmp expect exit-code
'

test_expect_success TAR_HUGE 'system tar can read our huge size' '
	echo 68719476737 >expect &&
	tar_info huge.tar | cut -d" " -f1 >actual &&
	test_cmp expect actual
'

test_expect_success 'set up repository with far-future commit' '
	rm -f .git/index &&
	echo content >file &&
	git add file &&
	GIT_COMMITTER_DATE="@68719476737 +0000" \
		git commit -m "tempori parendum"
'

test_expect_success 'generate tar with future mtime' '
	git archive HEAD >future.tar
'

test_expect_success TAR_HUGE 'system tar can read our future mtime' '
	echo 4147 >expect &&
	tar_info future.tar | cut -d" " -f2 >actual &&
	test_cmp expect actual
'

test_done
Commit	Line	Data
d3d49c3d RS	1	#!/bin/sh
	2	#
	3	# Copyright (C) 2005 Rene Scharfe
	4	#
	5
925ceccf	6	test_description='git archive and git get-tar-commit-id test
d3d49c3d	7
5b860406 RS	8	This test covers the topics of file contents, commit date handling and
5b860406 RS	9	commit id embedding:
d3d49c3d RS	10
	11	The contents of the repository is compared to the extracted tar
	12	archive. The repository contains simple text files, symlinks and a
3dff5379	13	binary file (/bin/sh). Only paths shorter than 99 characters are
5b860406	14	used.
d3d49c3d	15
925ceccf	16	git archive applies the commit date to every file in the archive it
d3d49c3d RS	17	creates. The test sets the commit date to a specific value and checks
	18	if the tar archive contains that value.
	19
925ceccf	20	When giving git archive a commit id (in contrast to a tree id) it
d3d49c3d	21	embeds this commit id into the tar archive as a comment. The test
5be60078	22	checks the ability of git get-tar-commit-id to figure it out from the
d3d49c3d RS	23	tar file.
	24
	25	'
	26
	27	. ./test-lib.sh
	28
38c9c9b7	29	SUBSTFORMAT=%H%n
8460b2fc	30
9bf1ac41 RS	31	test_lazy_prereq TAR_NEEDS_PAX_FALLBACK '
	32	(
	33	mkdir pax &&
	34	cd pax &&
	35	"$TAR" xf "$TEST_DIRECTORY"/t5000/pax.tar &&
	36	test -f PaxHeaders.1791/file
	37	)
	38	'
	39
96174145 JK	40	test_lazy_prereq GZIP 'gzip --version'
96174145 JK	41
9bf1ac41 RS	42	get_pax_header() {
	43	file=$1
	44	header=$2=
	45
	46	while read len rest
	47	do
	48	if test "$len" = $(echo "$len $rest" \| wc -c)
	49	then
	50	case "$rest" in
	51	$header*)
	52	echo "${rest#$header}"
	53	;;
	54	esac
	55	fi
	56	done <"$file"
	57	}
	58
deb9c8ed RS	59	check_tar() {
	60	tarfile=$1.tar
	61	listfile=$1.lst
	62	dir=$1
	63	dir_with_prefix=$dir/$2
	64
	65	test_expect_success ' extract tar archive' '
	66	(mkdir $dir && cd $dir && "$TAR" xf -) <$tarfile
	67	'
	68
9bf1ac41 RS	69	test_expect_success TAR_NEEDS_PAX_FALLBACK ' interpret pax headers' '
	70	(
	71	cd $dir &&
	72	for header in *.paxheader
	73	do
	74	data=${header%.paxheader}.data &&
d0b30a3d	75	if test -h $data \|\| test -e $data
9bf1ac41 RS	76	then
	77	path=$(get_pax_header $header path) &&
	78	if test -n "$path"
	79	then
	80	mv "$data" "$path"
	81	fi
	82	fi
	83	done
	84	)
	85	'
	86
deb9c8ed RS	87	test_expect_success ' validate filenames' '
	88	(cd ${dir_with_prefix}a && find .) \| sort >$listfile &&
	89	test_cmp a.lst $listfile
	90	'
	91
	92	test_expect_success ' validate file contents' '
	93	diff -r a ${dir_with_prefix}a
	94	'
	95	}
	96
d3d49c3d RS	97	test_expect_success \
d3d49c3d RS	98	'populate workdir' \
1355241b	99	'mkdir a &&
d3d49c3d	100	echo simple textfile >a/a &&
9bf1ac41 RS	101	ten=0123456789 && hundred=$ten$ten$ten$ten$ten$ten$ten$ten$ten$ten &&
9bf1ac41 RS	102	echo long filename >a/four$hundred &&
d3d49c3d	103	mkdir a/bin &&
bba5fccc	104	test-genrandom "frotz" 500000 >a/bin/sh &&
760da960 RS	105	printf "A\$Format:%s\$O" "$SUBSTFORMAT" >a/substfile1 &&
760da960 RS	106	printf "A not substituted O" >a/substfile2 &&
704a3143 JS	107	if test_have_prereq SYMLINKS; then
	108	ln -s a a/l1
	109	else
	110	printf %s a > a/l1
	111	fi &&
4c691724 RS	112	(p=long_path_to_a_file && cd a &&
	113	for depth in 1 2 3 4 5; do mkdir $p && cd $p; done &&
	114	echo text >file_with_long_path) &&
d3d49c3d RS	115	(cd a && find .) \| sort >a.lst'
d3d49c3d RS	116
008d896d RS	117	test_expect_success \
	118	'add ignored file' \
	119	'echo ignore me >a/ignored &&
ad94657f	120	echo ignored export-ignore >.git/info/attributes'
008d896d	121
21711ca4 RS	122	test_expect_success 'add files to repository' '
	123	git add a &&
	124	GIT_COMMITTER_DATE="2005-05-27 22:00" git commit -m initial
	125	'
d3d49c3d	126
c420df7b RS	127	test_expect_success 'setup export-subst' '
	128	echo "substfile?" export-subst >>.git/info/attributes &&
	129	git log --max-count=1 "--pretty=format:A${SUBSTFORMAT}O" HEAD \
	130	>a/substfile1
	131	'
	132
ddff8563 CB	133	test_expect_success \
	134	'create bare clone' \
	135	'git clone --bare . bare.git &&
ad94657f	136	cp .git/info/attributes bare.git/info/attributes'
ddff8563	137
008d896d RS	138	test_expect_success \
	139	'remove ignored file' \
	140	'rm a/ignored'
	141
8ff21b1a	142	test_expect_success \
5be60078 JH	143	'git archive' \
5be60078 JH	144	'git archive HEAD >b.tar'
8ff21b1a	145
deb9c8ed RS	146	check_tar b
deb9c8ed RS	147
03d9bc56 RS	148	test_expect_success 'git archive --prefix=prefix/' '
	149	git archive --prefix=prefix/ HEAD >with_prefix.tar
	150	'
	151
	152	check_tar with_prefix prefix/
	153
	154	test_expect_success 'git-archive --prefix=olde-' '
	155	git archive --prefix=olde- HEAD >with_olde-prefix.tar
	156	'
	157
	158	check_tar with_olde-prefix olde-
	159
5544049d NTND	160	test_expect_success 'git archive on large files' '
	161	test_config core.bigfilethreshold 1 &&
	162	git archive HEAD >b3.tar &&
b93e6e36	163	test_cmp_bin b.tar b3.tar
5544049d NTND	164	'
5544049d NTND	165
ddff8563 CB	166	test_expect_success \
	167	'git archive in a bare repo' \
	168	'(cd bare.git && git archive HEAD) >b3.tar'
	169
	170	test_expect_success \
	171	'git archive vs. the same in a bare repo' \
b93e6e36	172	'test_cmp_bin b.tar b3.tar'
ddff8563	173
aec0c1bb CMDV	174	test_expect_success 'git archive with --output' \
aec0c1bb CMDV	175	'git archive --output=b4.tar HEAD &&
b93e6e36	176	test_cmp_bin b.tar b4.tar'
aec0c1bb	177
1bc01efe	178	test_expect_success 'git archive --remote' \
48139269	179	'git archive --remote=. HEAD >b5.tar &&
b93e6e36	180	test_cmp_bin b.tar b5.tar'
48139269	181
d3d49c3d RS	182	test_expect_success \
d3d49c3d RS	183	'validate file modification time' \
30684dfa	184	'mkdir extract &&
bfce5087	185	"$TAR" xf b.tar -C extract a/a &&
111539a3	186	test-chmtime -v +0 extract/a/a \|cut -f 1 >b.mtime &&
30684dfa	187	echo "1117231200" >expected.mtime &&
188c3827	188	test_cmp expected.mtime b.mtime'
d3d49c3d RS	189
d3d49c3d RS	190	test_expect_success \
5be60078 JH	191	'git get-tar-commit-id' \
5be60078 JH	192	'git get-tar-commit-id <b.tar >b.commitid &&
188c3827	193	test_cmp .git/$(git symbolic-ref HEAD) b.commitid'
d3d49c3d	194
fe12d8e8 RS	195	test_expect_success 'git archive with --output, override inferred format' '
fe12d8e8 RS	196	git archive --format=tar --output=d4.zip HEAD &&
b93e6e36	197	test_cmp_bin b.tar d4.zip
fe12d8e8 RS	198	'
fe12d8e8 RS	199
265d5280	200	test_expect_success \
5be60078 JH	201	'git archive --list outside of a git repo' \
5be60078 JH	202	'GIT_DIR=some/non-existing/directory git archive --list'
265d5280	203
ee27ca4a JK	204	test_expect_success 'clients cannot access unreachable commits' '
ee27ca4a JK	205	test_commit unreachable &&
f5efd519	206	sha1=$(git rev-parse HEAD) &&
ee27ca4a JK	207	git reset --hard HEAD^ &&
	208	git archive $sha1 >remote.tar &&
	209	test_must_fail git archive --remote=. $sha1 >remote.tar
	210	'
	211
7671b632 SG	212	test_expect_success 'upload-archive can allow unreachable commits' '
7671b632 SG	213	test_commit unreachable1 &&
f5efd519	214	sha1=$(git rev-parse HEAD) &&
7671b632 SG	215	git reset --hard HEAD^ &&
	216	git archive $sha1 >remote.tar &&
	217	test_config uploadarchive.allowUnreachable true &&
	218	git archive --remote=. $sha1 >remote.tar
	219	'
	220
767cf457 JK	221	test_expect_success 'setup tar filters' '
767cf457 JK	222	git config tar.tar.foo.command "tr ab ba" &&
7b97730b	223	git config tar.bar.command "tr ab ba" &&
785a0429 JK	224	git config tar.bar.remote true &&
785a0429 JK	225	git config tar.invalid baz
767cf457 JK	226	'
	227
	228	test_expect_success 'archive --list mentions user filter' '
	229	git archive --list >output &&
	230	grep "^tar\.foo\$" output &&
	231	grep "^bar\$" output
	232	'
	233
1bc01efe	234	test_expect_success 'archive --list shows only enabled remote filters' '
767cf457	235	git archive --list --remote=. >output &&
7b97730b	236	! grep "^tar\.foo\$" output &&
767cf457 JK	237	grep "^bar\$" output
	238	'
	239
	240	test_expect_success 'invoke tar filter by format' '
	241	git archive --format=tar.foo HEAD >config.tar.foo &&
	242	tr ab ba <config.tar.foo >config.tar &&
b93e6e36	243	test_cmp_bin b.tar config.tar &&
767cf457 JK	244	git archive --format=bar HEAD >config.bar &&
767cf457 JK	245	tr ab ba <config.bar >config.tar &&
b93e6e36	246	test_cmp_bin b.tar config.tar
767cf457 JK	247	'
	248
	249	test_expect_success 'invoke tar filter by extension' '
	250	git archive -o config-implicit.tar.foo HEAD &&
b93e6e36	251	test_cmp_bin config.tar.foo config-implicit.tar.foo &&
767cf457	252	git archive -o config-implicit.bar HEAD &&
b93e6e36	253	test_cmp_bin config.tar.foo config-implicit.bar
767cf457 JK	254	'
	255
	256	test_expect_success 'default output format remains tar' '
	257	git archive -o config-implicit.baz HEAD &&
b93e6e36	258	test_cmp_bin b.tar config-implicit.baz
767cf457 JK	259	'
	260
	261	test_expect_success 'extension matching requires dot' '
	262	git archive -o config-implicittar.foo HEAD &&
b93e6e36	263	test_cmp_bin b.tar config-implicittar.foo
767cf457 JK	264	'
767cf457 JK	265
1bc01efe	266	test_expect_success 'only enabled filters are available remotely' '
7b97730b JK	267	test_must_fail git archive --remote=. --format=tar.foo HEAD \
	268	>remote.tar.foo &&
	269	git archive --remote=. --format=bar >remote.bar HEAD &&
b93e6e36	270	test_cmp_bin remote.bar config.bar
7b97730b JK	271	'
7b97730b JK	272
0e804e09 JK	273	test_expect_success GZIP 'git archive --format=tgz' '
	274	git archive --format=tgz HEAD >j.tgz
	275	'
	276
	277	test_expect_success GZIP 'git archive --format=tar.gz' '
	278	git archive --format=tar.gz HEAD >j1.tar.gz &&
b93e6e36	279	test_cmp_bin j.tgz j1.tar.gz
0e804e09 JK	280	'
	281
	282	test_expect_success GZIP 'infer tgz from .tgz filename' '
	283	git archive --output=j2.tgz HEAD &&
b93e6e36	284	test_cmp_bin j.tgz j2.tgz
0e804e09 JK	285	'
	286
	287	test_expect_success GZIP 'infer tgz from .tar.gz filename' '
	288	git archive --output=j3.tar.gz HEAD &&
b93e6e36	289	test_cmp_bin j.tgz j3.tar.gz
0e804e09 JK	290	'
0e804e09 JK	291
96174145 JK	292	test_expect_success GZIP 'extract tgz file' '
96174145 JK	293	gzip -d -c <j.tgz >j.tar &&
b93e6e36	294	test_cmp_bin b.tar j.tar
0e804e09 JK	295	'
0e804e09 JK	296
1bc01efe	297	test_expect_success GZIP 'remote tar.gz is allowed by default' '
7b97730b	298	git archive --remote=. --format=tar.gz HEAD >remote.tar.gz &&
b93e6e36	299	test_cmp_bin j.tgz remote.tar.gz
7b97730b JK	300	'
7b97730b JK	301
1bc01efe	302	test_expect_success GZIP 'remote tar.gz can be disabled' '
7b97730b JK	303	git config tar.tar.gz.remote false &&
	304	test_must_fail git archive --remote=. --format=tar.gz HEAD \
	305	>remote.tar.gz
	306	'
	307
ed22b417 NTND	308	test_expect_success 'archive and :(glob)' '
	309	git archive -v HEAD -- ":(glob)**/sh" >/dev/null 2>actual &&
	310	cat >expect <<EOF &&
	311	a/
	312	a/bin/
	313	a/bin/sh
	314	EOF
	315	test_cmp expect actual
	316	'
	317
	318	test_expect_success 'catch non-matching pathspec' '
	319	test_must_fail git archive -v HEAD -- "*.abc" >/dev/null
	320	'
	321
e51217e1 JK	322	# Pull the size and date of each entry in a tarfile using the system tar.
	323	#
	324	# We'll pull out only the year from the date; that avoids any question of
	325	# timezones impacting the result (as long as we keep our test times away from a
	326	# year boundary; our reference times are all in August).
	327	#
	328	# The output of tar_info is expected to be "<size> <year>", both in decimal. It
	329	# ignores the return value of tar. We have to do this, because some of our test
	330	# input is only partial (the real data is 64GB in some cases).
	331	tar_info () {
	332	"$TAR" tvf "$1" \|
	333	awk '{
	334	split($4, date, "-")
	335	print $3 " " date[1]
	336	}'
	337	}
	338
	339	# See if our system tar can handle a tar file with huge sizes and dates far in
	340	# the future, and that we can actually parse its output.
	341	#
	342	# The reference file was generated by GNU tar, and the magic time and size are
	343	# both octal 01000000000001, which overflows normal ustar fields.
	344	test_lazy_prereq TAR_HUGE '
	345	echo "68719476737 4147" >expect &&
	346	tar_info "$TEST_DIRECTORY"/t5000/huge-and-future.tar >actual &&
	347	test_cmp expect actual
	348	'
	349
	350	test_expect_success 'set up repository with huge blob' '
	351	obj_d=19 &&
	352	obj_f=f9c8273ec45a8938e6999cb59b3ff66739902a &&
	353	obj=${obj_d}${obj_f} &&
	354	mkdir -p .git/objects/$obj_d &&
	355	cp "$TEST_DIRECTORY"/t5000/$obj .git/objects/$obj_d/$obj_f &&
	356	rm -f .git/index &&
	357	git update-index --add --cacheinfo 100644,$obj,huge &&
	358	git commit -m huge
	359	'
	360
	361	# We expect git to die with SIGPIPE here (otherwise we
	362	# would generate the whole 64GB).
d1657b57	363	test_expect_success 'generate tar with huge size' '
e51217e1 JK	364	{
	365	git archive HEAD
	366	echo $? >exit-code
	367	} \| test_copy_bytes 4096 >huge.tar &&
	368	echo 141 >expect &&
	369	test_cmp expect exit-code
	370	'
	371
d1657b57	372	test_expect_success TAR_HUGE 'system tar can read our huge size' '
e51217e1 JK	373	echo 68719476737 >expect &&
	374	tar_info huge.tar \| cut -d" " -f1 >actual &&
	375	test_cmp expect actual
	376	'
	377
	378	test_expect_success 'set up repository with far-future commit' '
	379	rm -f .git/index &&
	380	echo content >file &&
	381	git add file &&
	382	GIT_COMMITTER_DATE="@68719476737 +0000" \
	383	git commit -m "tempori parendum"
	384	'
	385
6e8e0991	386	test_expect_success 'generate tar with future mtime' '
e51217e1 JK	387	git archive HEAD >future.tar
	388	'
	389
6e8e0991	390	test_expect_success TAR_HUGE 'system tar can read our future mtime' '
e51217e1 JK	391	echo 4147 >expect &&
	392	tar_info future.tar \| cut -d" " -f2 >actual &&
	393	test_cmp expect actual
	394	'
	395
d3d49c3d	396	test_done