[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 'setup' '
	test_oid_cache <<-EOF
	obj sha1:19f9c8273ec45a8938e6999cb59b3ff66739902a
	obj sha256:3c666f798798601571f5cec0adb57ce4aba8546875e7693177e0535f34d2c49b
	EOF
'

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-tool 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 'git archive --remote with configured remote' '
	git config remote.foo.url . &&
	(
		cd a &&
		git archive --remote=foo --output=../b5-nick.tar HEAD
	) &&
	test_cmp_bin b.tar b5-nick.tar
'

test_expect_success \
    'validate file modification time' \
    'mkdir extract &&
     "$TAR" xf b.tar -C extract a/a &&
     test-tool chmtime --get extract/a/a >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 GZIP 'git archive with --output and --remote creates .tgz' '
	git archive --output=d5.tgz --remote=. HEAD &&
	gzip -d -c <d5.tgz >d5.tar &&
	test_cmp_bin b.tar d5.tar
'

test_expect_success 'git archive --list outside of a git repo' '
	nongit git archive --list
'

test_expect_success 'git archive --remote outside of a git repo' '
	git archive HEAD >expect.tar &&
	nongit git archive --remote="$PWD" HEAD >actual.tar &&
	test_cmp_bin expect.tar actual.tar
'

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 LONG_IS_64BIT 'set up repository with huge blob' '
	obj=$(test_oid obj) &&
	path=$(test_oid_to_path $obj) &&
	mkdir -p .git/objects/$(dirname $path) &&
	cp "$TEST_DIRECTORY"/t5000/huge-object .git/objects/$path &&
	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 LONG_IS_64BIT '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,LONG_IS_64BIT '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 TIME_IS_64BIT '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 TIME_IS_64BIT 'generate tar with future mtime' '
	git archive HEAD >future.tar
'

test_expect_success TAR_HUGE,TIME_IS_64BIT,TIME_T_IS_64BIT '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
0b78a1b2	97	test_expect_success 'setup' '
	98	test_oid_cache <<-EOF
	99	obj sha1:19f9c8273ec45a8938e6999cb59b3ff66739902a
	100	obj sha256:3c666f798798601571f5cec0adb57ce4aba8546875e7693177e0535f34d2c49b
	101	EOF
	102	'
	103
d3d49c3d RS	104	test_expect_success \
d3d49c3d RS	105	'populate workdir' \
1355241b	106	'mkdir a &&
d3d49c3d	107	echo simple textfile >a/a &&
9bf1ac41 RS	108	ten=0123456789 && hundred=$ten$ten$ten$ten$ten$ten$ten$ten$ten$ten &&
9bf1ac41 RS	109	echo long filename >a/four$hundred &&
d3d49c3d	110	mkdir a/bin &&
c680668d	111	test-tool genrandom "frotz" 500000 >a/bin/sh &&
760da960 RS	112	printf "A\$Format:%s\$O" "$SUBSTFORMAT" >a/substfile1 &&
760da960 RS	113	printf "A not substituted O" >a/substfile2 &&
704a3143 JS	114	if test_have_prereq SYMLINKS; then
	115	ln -s a a/l1
	116	else
	117	printf %s a > a/l1
	118	fi &&
4c691724 RS	119	(p=long_path_to_a_file && cd a &&
	120	for depth in 1 2 3 4 5; do mkdir $p && cd $p; done &&
	121	echo text >file_with_long_path) &&
d3d49c3d RS	122	(cd a && find .) \| sort >a.lst'
d3d49c3d RS	123
008d896d RS	124	test_expect_success \
	125	'add ignored file' \
	126	'echo ignore me >a/ignored &&
ad94657f	127	echo ignored export-ignore >.git/info/attributes'
008d896d	128
21711ca4 RS	129	test_expect_success 'add files to repository' '
	130	git add a &&
	131	GIT_COMMITTER_DATE="2005-05-27 22:00" git commit -m initial
	132	'
d3d49c3d	133
c420df7b RS	134	test_expect_success 'setup export-subst' '
	135	echo "substfile?" export-subst >>.git/info/attributes &&
	136	git log --max-count=1 "--pretty=format:A${SUBSTFORMAT}O" HEAD \
	137	>a/substfile1
	138	'
	139
ddff8563 CB	140	test_expect_success \
	141	'create bare clone' \
	142	'git clone --bare . bare.git &&
ad94657f	143	cp .git/info/attributes bare.git/info/attributes'
ddff8563	144
008d896d RS	145	test_expect_success \
	146	'remove ignored file' \
	147	'rm a/ignored'
	148
8ff21b1a	149	test_expect_success \
5be60078 JH	150	'git archive' \
5be60078 JH	151	'git archive HEAD >b.tar'
8ff21b1a	152
deb9c8ed RS	153	check_tar b
deb9c8ed RS	154
03d9bc56 RS	155	test_expect_success 'git archive --prefix=prefix/' '
	156	git archive --prefix=prefix/ HEAD >with_prefix.tar
	157	'
	158
	159	check_tar with_prefix prefix/
	160
	161	test_expect_success 'git-archive --prefix=olde-' '
	162	git archive --prefix=olde- HEAD >with_olde-prefix.tar
	163	'
	164
	165	check_tar with_olde-prefix olde-
	166
5544049d NTND	167	test_expect_success 'git archive on large files' '
	168	test_config core.bigfilethreshold 1 &&
	169	git archive HEAD >b3.tar &&
b93e6e36	170	test_cmp_bin b.tar b3.tar
5544049d NTND	171	'
5544049d NTND	172
ddff8563 CB	173	test_expect_success \
	174	'git archive in a bare repo' \
	175	'(cd bare.git && git archive HEAD) >b3.tar'
	176
	177	test_expect_success \
	178	'git archive vs. the same in a bare repo' \
b93e6e36	179	'test_cmp_bin b.tar b3.tar'
ddff8563	180
aec0c1bb CMDV	181	test_expect_success 'git archive with --output' \
aec0c1bb CMDV	182	'git archive --output=b4.tar HEAD &&
b93e6e36	183	test_cmp_bin b.tar b4.tar'
aec0c1bb	184
1bc01efe	185	test_expect_success 'git archive --remote' \
48139269	186	'git archive --remote=. HEAD >b5.tar &&
b93e6e36	187	test_cmp_bin b.tar b5.tar'
48139269	188
eb0224c6 JH	189	test_expect_success 'git archive --remote with configured remote' '
	190	git config remote.foo.url . &&
	191	(
	192	cd a &&
	193	git archive --remote=foo --output=../b5-nick.tar HEAD
	194	) &&
	195	test_cmp_bin b.tar b5-nick.tar
	196	'
	197
d3d49c3d RS	198	test_expect_success \
d3d49c3d RS	199	'validate file modification time' \
30684dfa	200	'mkdir extract &&
bfce5087	201	"$TAR" xf b.tar -C extract a/a &&
deb9845a	202	test-tool chmtime --get extract/a/a >b.mtime &&
30684dfa	203	echo "1117231200" >expected.mtime &&
188c3827	204	test_cmp expected.mtime b.mtime'
d3d49c3d RS	205
d3d49c3d RS	206	test_expect_success \
5be60078 JH	207	'git get-tar-commit-id' \
5be60078 JH	208	'git get-tar-commit-id <b.tar >b.commitid &&
188c3827	209	test_cmp .git/$(git symbolic-ref HEAD) b.commitid'
d3d49c3d	210
fe12d8e8 RS	211	test_expect_success 'git archive with --output, override inferred format' '
fe12d8e8 RS	212	git archive --format=tar --output=d4.zip HEAD &&
b93e6e36	213	test_cmp_bin b.tar d4.zip
fe12d8e8 RS	214	'
fe12d8e8 RS	215
00436bf1 JS	216	test_expect_success GZIP 'git archive with --output and --remote creates .tgz' '
	217	git archive --output=d5.tgz --remote=. HEAD &&
	218	gzip -d -c <d5.tgz >d5.tar &&
	219	test_cmp_bin b.tar d5.tar
	220	'
	221
eb0224c6 JH	222	test_expect_success 'git archive --list outside of a git repo' '
	223	nongit git archive --list
	224	'
	225
	226	test_expect_success 'git archive --remote outside of a git repo' '
	227	git archive HEAD >expect.tar &&
	228	nongit git archive --remote="$PWD" HEAD >actual.tar &&
	229	test_cmp_bin expect.tar actual.tar
	230	'
265d5280	231
ee27ca4a JK	232	test_expect_success 'clients cannot access unreachable commits' '
ee27ca4a JK	233	test_commit unreachable &&
f5efd519	234	sha1=$(git rev-parse HEAD) &&
ee27ca4a JK	235	git reset --hard HEAD^ &&
	236	git archive $sha1 >remote.tar &&
	237	test_must_fail git archive --remote=. $sha1 >remote.tar
	238	'
	239
7671b632 SG	240	test_expect_success 'upload-archive can allow unreachable commits' '
7671b632 SG	241	test_commit unreachable1 &&
f5efd519	242	sha1=$(git rev-parse HEAD) &&
7671b632 SG	243	git reset --hard HEAD^ &&
	244	git archive $sha1 >remote.tar &&
	245	test_config uploadarchive.allowUnreachable true &&
	246	git archive --remote=. $sha1 >remote.tar
	247	'
	248
767cf457 JK	249	test_expect_success 'setup tar filters' '
767cf457 JK	250	git config tar.tar.foo.command "tr ab ba" &&
7b97730b	251	git config tar.bar.command "tr ab ba" &&
785a0429 JK	252	git config tar.bar.remote true &&
785a0429 JK	253	git config tar.invalid baz
767cf457 JK	254	'
	255
	256	test_expect_success 'archive --list mentions user filter' '
	257	git archive --list >output &&
	258	grep "^tar\.foo\$" output &&
	259	grep "^bar\$" output
	260	'
	261
1bc01efe	262	test_expect_success 'archive --list shows only enabled remote filters' '
767cf457	263	git archive --list --remote=. >output &&
7b97730b	264	! grep "^tar\.foo\$" output &&
767cf457 JK	265	grep "^bar\$" output
	266	'
	267
	268	test_expect_success 'invoke tar filter by format' '
	269	git archive --format=tar.foo HEAD >config.tar.foo &&
	270	tr ab ba <config.tar.foo >config.tar &&
b93e6e36	271	test_cmp_bin b.tar config.tar &&
767cf457 JK	272	git archive --format=bar HEAD >config.bar &&
767cf457 JK	273	tr ab ba <config.bar >config.tar &&
b93e6e36	274	test_cmp_bin b.tar config.tar
767cf457 JK	275	'
	276
	277	test_expect_success 'invoke tar filter by extension' '
	278	git archive -o config-implicit.tar.foo HEAD &&
b93e6e36	279	test_cmp_bin config.tar.foo config-implicit.tar.foo &&
767cf457	280	git archive -o config-implicit.bar HEAD &&
b93e6e36	281	test_cmp_bin config.tar.foo config-implicit.bar
767cf457 JK	282	'
	283
	284	test_expect_success 'default output format remains tar' '
	285	git archive -o config-implicit.baz HEAD &&
b93e6e36	286	test_cmp_bin b.tar config-implicit.baz
767cf457 JK	287	'
	288
	289	test_expect_success 'extension matching requires dot' '
	290	git archive -o config-implicittar.foo HEAD &&
b93e6e36	291	test_cmp_bin b.tar config-implicittar.foo
767cf457 JK	292	'
767cf457 JK	293
1bc01efe	294	test_expect_success 'only enabled filters are available remotely' '
7b97730b JK	295	test_must_fail git archive --remote=. --format=tar.foo HEAD \
	296	>remote.tar.foo &&
	297	git archive --remote=. --format=bar >remote.bar HEAD &&
b93e6e36	298	test_cmp_bin remote.bar config.bar
7b97730b JK	299	'
7b97730b JK	300
0e804e09 JK	301	test_expect_success GZIP 'git archive --format=tgz' '
	302	git archive --format=tgz HEAD >j.tgz
	303	'
	304
	305	test_expect_success GZIP 'git archive --format=tar.gz' '
	306	git archive --format=tar.gz HEAD >j1.tar.gz &&
b93e6e36	307	test_cmp_bin j.tgz j1.tar.gz
0e804e09 JK	308	'
	309
	310	test_expect_success GZIP 'infer tgz from .tgz filename' '
	311	git archive --output=j2.tgz HEAD &&
b93e6e36	312	test_cmp_bin j.tgz j2.tgz
0e804e09 JK	313	'
	314
	315	test_expect_success GZIP 'infer tgz from .tar.gz filename' '
	316	git archive --output=j3.tar.gz HEAD &&
b93e6e36	317	test_cmp_bin j.tgz j3.tar.gz
0e804e09 JK	318	'
0e804e09 JK	319
96174145 JK	320	test_expect_success GZIP 'extract tgz file' '
96174145 JK	321	gzip -d -c <j.tgz >j.tar &&
b93e6e36	322	test_cmp_bin b.tar j.tar
0e804e09 JK	323	'
0e804e09 JK	324
1bc01efe	325	test_expect_success GZIP 'remote tar.gz is allowed by default' '
7b97730b	326	git archive --remote=. --format=tar.gz HEAD >remote.tar.gz &&
b93e6e36	327	test_cmp_bin j.tgz remote.tar.gz
7b97730b JK	328	'
7b97730b JK	329
1bc01efe	330	test_expect_success GZIP 'remote tar.gz can be disabled' '
7b97730b JK	331	git config tar.tar.gz.remote false &&
	332	test_must_fail git archive --remote=. --format=tar.gz HEAD \
	333	>remote.tar.gz
	334	'
	335
ed22b417 NTND	336	test_expect_success 'archive and :(glob)' '
	337	git archive -v HEAD -- ":(glob)**/sh" >/dev/null 2>actual &&
	338	cat >expect <<EOF &&
	339	a/
	340	a/bin/
	341	a/bin/sh
	342	EOF
	343	test_cmp expect actual
	344	'
	345
	346	test_expect_success 'catch non-matching pathspec' '
	347	test_must_fail git archive -v HEAD -- "*.abc" >/dev/null
	348	'
	349
e51217e1 JK	350	# Pull the size and date of each entry in a tarfile using the system tar.
	351	#
	352	# We'll pull out only the year from the date; that avoids any question of
	353	# timezones impacting the result (as long as we keep our test times away from a
	354	# year boundary; our reference times are all in August).
	355	#
	356	# The output of tar_info is expected to be "<size> <year>", both in decimal. It
	357	# ignores the return value of tar. We have to do this, because some of our test
	358	# input is only partial (the real data is 64GB in some cases).
	359	tar_info () {
	360	"$TAR" tvf "$1" \|
	361	awk '{
	362	split($4, date, "-")
	363	print $3 " " date[1]
	364	}'
	365	}
	366
	367	# See if our system tar can handle a tar file with huge sizes and dates far in
	368	# the future, and that we can actually parse its output.
	369	#
	370	# The reference file was generated by GNU tar, and the magic time and size are
	371	# both octal 01000000000001, which overflows normal ustar fields.
	372	test_lazy_prereq TAR_HUGE '
	373	echo "68719476737 4147" >expect &&
	374	tar_info "$TEST_DIRECTORY"/t5000/huge-and-future.tar >actual &&
	375	test_cmp expect actual
	376	'
	377
29493589	378	test_expect_success LONG_IS_64BIT 'set up repository with huge blob' '
0b78a1b2	379	obj=$(test_oid obj) &&
	380	path=$(test_oid_to_path $obj) &&
	381	mkdir -p .git/objects/$(dirname $path) &&
	382	cp "$TEST_DIRECTORY"/t5000/huge-object .git/objects/$path &&
e51217e1 JK	383	rm -f .git/index &&
	384	git update-index --add --cacheinfo 100644,$obj,huge &&
	385	git commit -m huge
	386	'
	387
	388	# We expect git to die with SIGPIPE here (otherwise we
	389	# would generate the whole 64GB).
29493589	390	test_expect_success LONG_IS_64BIT 'generate tar with huge size' '
e51217e1 JK	391	{
	392	git archive HEAD
	393	echo $? >exit-code
	394	} \| test_copy_bytes 4096 >huge.tar &&
	395	echo 141 >expect &&
	396	test_cmp expect exit-code
	397	'
	398
29493589	399	test_expect_success TAR_HUGE,LONG_IS_64BIT 'system tar can read our huge size' '
e51217e1 JK	400	echo 68719476737 >expect &&
	401	tar_info huge.tar \| cut -d" " -f1 >actual &&
	402	test_cmp expect actual
	403	'
	404
a07fb050	405	test_expect_success TIME_IS_64BIT 'set up repository with far-future commit' '
e51217e1 JK	406	rm -f .git/index &&
	407	echo content >file &&
	408	git add file &&
	409	GIT_COMMITTER_DATE="@68719476737 +0000" \
	410	git commit -m "tempori parendum"
	411	'
	412
a07fb050	413	test_expect_success TIME_IS_64BIT 'generate tar with future mtime' '
e51217e1 JK	414	git archive HEAD >future.tar
	415	'
	416
efac8ac8	417	test_expect_success TAR_HUGE,TIME_IS_64BIT,TIME_T_IS_64BIT 'system tar can read our future mtime' '
e51217e1 JK	418	echo 4147 >expect &&
	419	tar_info future.tar \| cut -d" " -f2 >actual &&
	420	test_cmp expect actual
	421	'
	422
d3d49c3d	423	test_done