[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-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_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 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
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 &&
c680668d	104	test-tool 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
eb0224c6 JH	182	test_expect_success 'git archive --remote with configured remote' '
	183	git config remote.foo.url . &&
	184	(
	185	cd a &&
	186	git archive --remote=foo --output=../b5-nick.tar HEAD
	187	) &&
	188	test_cmp_bin b.tar b5-nick.tar
	189	'
	190
d3d49c3d RS	191	test_expect_success \
d3d49c3d RS	192	'validate file modification time' \
30684dfa	193	'mkdir extract &&
bfce5087	194	"$TAR" xf b.tar -C extract a/a &&
deb9845a	195	test-tool chmtime --get extract/a/a >b.mtime &&
30684dfa	196	echo "1117231200" >expected.mtime &&
188c3827	197	test_cmp expected.mtime b.mtime'
d3d49c3d RS	198
d3d49c3d RS	199	test_expect_success \
5be60078 JH	200	'git get-tar-commit-id' \
5be60078 JH	201	'git get-tar-commit-id <b.tar >b.commitid &&
188c3827	202	test_cmp .git/$(git symbolic-ref HEAD) b.commitid'
d3d49c3d	203
fe12d8e8 RS	204	test_expect_success 'git archive with --output, override inferred format' '
fe12d8e8 RS	205	git archive --format=tar --output=d4.zip HEAD &&
b93e6e36	206	test_cmp_bin b.tar d4.zip
fe12d8e8 RS	207	'
fe12d8e8 RS	208
00436bf1 JS	209	test_expect_success GZIP 'git archive with --output and --remote creates .tgz' '
	210	git archive --output=d5.tgz --remote=. HEAD &&
	211	gzip -d -c <d5.tgz >d5.tar &&
	212	test_cmp_bin b.tar d5.tar
	213	'
	214
eb0224c6 JH	215	test_expect_success 'git archive --list outside of a git repo' '
	216	nongit git archive --list
	217	'
	218
	219	test_expect_success 'git archive --remote outside of a git repo' '
	220	git archive HEAD >expect.tar &&
	221	nongit git archive --remote="$PWD" HEAD >actual.tar &&
	222	test_cmp_bin expect.tar actual.tar
	223	'
265d5280	224
ee27ca4a JK	225	test_expect_success 'clients cannot access unreachable commits' '
ee27ca4a JK	226	test_commit unreachable &&
f5efd519	227	sha1=$(git rev-parse HEAD) &&
ee27ca4a JK	228	git reset --hard HEAD^ &&
	229	git archive $sha1 >remote.tar &&
	230	test_must_fail git archive --remote=. $sha1 >remote.tar
	231	'
	232
7671b632 SG	233	test_expect_success 'upload-archive can allow unreachable commits' '
7671b632 SG	234	test_commit unreachable1 &&
f5efd519	235	sha1=$(git rev-parse HEAD) &&
7671b632 SG	236	git reset --hard HEAD^ &&
	237	git archive $sha1 >remote.tar &&
	238	test_config uploadarchive.allowUnreachable true &&
	239	git archive --remote=. $sha1 >remote.tar
	240	'
	241
767cf457 JK	242	test_expect_success 'setup tar filters' '
767cf457 JK	243	git config tar.tar.foo.command "tr ab ba" &&
7b97730b	244	git config tar.bar.command "tr ab ba" &&
785a0429 JK	245	git config tar.bar.remote true &&
785a0429 JK	246	git config tar.invalid baz
767cf457 JK	247	'
	248
	249	test_expect_success 'archive --list mentions user filter' '
	250	git archive --list >output &&
	251	grep "^tar\.foo\$" output &&
	252	grep "^bar\$" output
	253	'
	254
1bc01efe	255	test_expect_success 'archive --list shows only enabled remote filters' '
767cf457	256	git archive --list --remote=. >output &&
7b97730b	257	! grep "^tar\.foo\$" output &&
767cf457 JK	258	grep "^bar\$" output
	259	'
	260
	261	test_expect_success 'invoke tar filter by format' '
	262	git archive --format=tar.foo HEAD >config.tar.foo &&
	263	tr ab ba <config.tar.foo >config.tar &&
b93e6e36	264	test_cmp_bin b.tar config.tar &&
767cf457 JK	265	git archive --format=bar HEAD >config.bar &&
767cf457 JK	266	tr ab ba <config.bar >config.tar &&
b93e6e36	267	test_cmp_bin b.tar config.tar
767cf457 JK	268	'
	269
	270	test_expect_success 'invoke tar filter by extension' '
	271	git archive -o config-implicit.tar.foo HEAD &&
b93e6e36	272	test_cmp_bin config.tar.foo config-implicit.tar.foo &&
767cf457	273	git archive -o config-implicit.bar HEAD &&
b93e6e36	274	test_cmp_bin config.tar.foo config-implicit.bar
767cf457 JK	275	'
	276
	277	test_expect_success 'default output format remains tar' '
	278	git archive -o config-implicit.baz HEAD &&
b93e6e36	279	test_cmp_bin b.tar config-implicit.baz
767cf457 JK	280	'
	281
	282	test_expect_success 'extension matching requires dot' '
	283	git archive -o config-implicittar.foo HEAD &&
b93e6e36	284	test_cmp_bin b.tar config-implicittar.foo
767cf457 JK	285	'
767cf457 JK	286
1bc01efe	287	test_expect_success 'only enabled filters are available remotely' '
7b97730b JK	288	test_must_fail git archive --remote=. --format=tar.foo HEAD \
	289	>remote.tar.foo &&
	290	git archive --remote=. --format=bar >remote.bar HEAD &&
b93e6e36	291	test_cmp_bin remote.bar config.bar
7b97730b JK	292	'
7b97730b JK	293
0e804e09 JK	294	test_expect_success GZIP 'git archive --format=tgz' '
	295	git archive --format=tgz HEAD >j.tgz
	296	'
	297
	298	test_expect_success GZIP 'git archive --format=tar.gz' '
	299	git archive --format=tar.gz HEAD >j1.tar.gz &&
b93e6e36	300	test_cmp_bin j.tgz j1.tar.gz
0e804e09 JK	301	'
	302
	303	test_expect_success GZIP 'infer tgz from .tgz filename' '
	304	git archive --output=j2.tgz HEAD &&
b93e6e36	305	test_cmp_bin j.tgz j2.tgz
0e804e09 JK	306	'
	307
	308	test_expect_success GZIP 'infer tgz from .tar.gz filename' '
	309	git archive --output=j3.tar.gz HEAD &&
b93e6e36	310	test_cmp_bin j.tgz j3.tar.gz
0e804e09 JK	311	'
0e804e09 JK	312
96174145 JK	313	test_expect_success GZIP 'extract tgz file' '
96174145 JK	314	gzip -d -c <j.tgz >j.tar &&
b93e6e36	315	test_cmp_bin b.tar j.tar
0e804e09 JK	316	'
0e804e09 JK	317
1bc01efe	318	test_expect_success GZIP 'remote tar.gz is allowed by default' '
7b97730b	319	git archive --remote=. --format=tar.gz HEAD >remote.tar.gz &&
b93e6e36	320	test_cmp_bin j.tgz remote.tar.gz
7b97730b JK	321	'
7b97730b JK	322
1bc01efe	323	test_expect_success GZIP 'remote tar.gz can be disabled' '
7b97730b JK	324	git config tar.tar.gz.remote false &&
	325	test_must_fail git archive --remote=. --format=tar.gz HEAD \
	326	>remote.tar.gz
	327	'
	328
ed22b417 NTND	329	test_expect_success 'archive and :(glob)' '
	330	git archive -v HEAD -- ":(glob)**/sh" >/dev/null 2>actual &&
	331	cat >expect <<EOF &&
	332	a/
	333	a/bin/
	334	a/bin/sh
	335	EOF
	336	test_cmp expect actual
	337	'
	338
	339	test_expect_success 'catch non-matching pathspec' '
	340	test_must_fail git archive -v HEAD -- "*.abc" >/dev/null
	341	'
	342
e51217e1 JK	343	# Pull the size and date of each entry in a tarfile using the system tar.
	344	#
	345	# We'll pull out only the year from the date; that avoids any question of
	346	# timezones impacting the result (as long as we keep our test times away from a
	347	# year boundary; our reference times are all in August).
	348	#
	349	# The output of tar_info is expected to be "<size> <year>", both in decimal. It
	350	# ignores the return value of tar. We have to do this, because some of our test
	351	# input is only partial (the real data is 64GB in some cases).
	352	tar_info () {
	353	"$TAR" tvf "$1" \|
	354	awk '{
	355	split($4, date, "-")
	356	print $3 " " date[1]
	357	}'
	358	}
	359
	360	# See if our system tar can handle a tar file with huge sizes and dates far in
	361	# the future, and that we can actually parse its output.
	362	#
	363	# The reference file was generated by GNU tar, and the magic time and size are
	364	# both octal 01000000000001, which overflows normal ustar fields.
	365	test_lazy_prereq TAR_HUGE '
	366	echo "68719476737 4147" >expect &&
	367	tar_info "$TEST_DIRECTORY"/t5000/huge-and-future.tar >actual &&
	368	test_cmp expect actual
	369	'
	370
29493589	371	test_expect_success LONG_IS_64BIT 'set up repository with huge blob' '
e51217e1 JK	372	obj_d=19 &&
	373	obj_f=f9c8273ec45a8938e6999cb59b3ff66739902a &&
	374	obj=${obj_d}${obj_f} &&
	375	mkdir -p .git/objects/$obj_d &&
	376	cp "$TEST_DIRECTORY"/t5000/$obj .git/objects/$obj_d/$obj_f &&
	377	rm -f .git/index &&
	378	git update-index --add --cacheinfo 100644,$obj,huge &&
	379	git commit -m huge
	380	'
	381
	382	# We expect git to die with SIGPIPE here (otherwise we
	383	# would generate the whole 64GB).
29493589	384	test_expect_success LONG_IS_64BIT 'generate tar with huge size' '
e51217e1 JK	385	{
	386	git archive HEAD
	387	echo $? >exit-code
	388	} \| test_copy_bytes 4096 >huge.tar &&
	389	echo 141 >expect &&
	390	test_cmp expect exit-code
	391	'
	392
29493589	393	test_expect_success TAR_HUGE,LONG_IS_64BIT 'system tar can read our huge size' '
e51217e1 JK	394	echo 68719476737 >expect &&
	395	tar_info huge.tar \| cut -d" " -f1 >actual &&
	396	test_cmp expect actual
	397	'
	398
a07fb050	399	test_expect_success TIME_IS_64BIT 'set up repository with far-future commit' '
e51217e1 JK	400	rm -f .git/index &&
	401	echo content >file &&
	402	git add file &&
	403	GIT_COMMITTER_DATE="@68719476737 +0000" \
	404	git commit -m "tempori parendum"
	405	'
	406
a07fb050	407	test_expect_success TIME_IS_64BIT 'generate tar with future mtime' '
e51217e1 JK	408	git archive HEAD >future.tar
	409	'
	410
efac8ac8	411	test_expect_success TAR_HUGE,TIME_IS_64BIT,TIME_T_IS_64BIT 'system tar can read our future mtime' '
e51217e1 JK	412	echo 4147 >expect &&
	413	tar_info future.tar \| cut -d" " -f2 >actual &&
	414	test_cmp expect actual
	415	'
	416
d3d49c3d	417	test_done