##
# Copyright © 2019, Oracle and/or its affiliates. All rights reserved.
#
# Licensed under the Universal Permissive License v 1.0 as shown at
# http://oss.oracle.com/licenses/upl.
#
# Update this (and the VERSION_HISTORY in version.h) when the version changes.
VERSION = 1.58

#SAN = -fsanitize=thread
#SAN = -fsanitize=address
#GCOV_FLAGS = -fprofile-arcs -ftest-coverage
CFLAGS=-Wall -Wextra -Wshadow -Wconversion -Wpointer-arith -Wmissing-prototypes -Wwrite-strings -Wswitch-enum -Werror -g -O1 -pthread -std=gnu99 $(SAN) $(GCOV_FLAGS)
CPPFLAGS=-DVERSION=\"$(VERSION)\"
#CPPFLAGS+=-DSPEW_ENABLED

# It turns out that we need -lrt (probably because of clock_gettime()
# or else we'll end up with a dependency on glibc 2.17, which often is
# too advanced (e.g., on Oracle Linux 6.9)
LDLIBS=-lrt
LDFLAGS=-pthread $(SAN) $(GCOV_FLAGS)

VALGRIND = valgrind --leak-check=full --error-exitcode=3 -q

PARTAR = partar

default: $(PARTAR) parcp parrm $(PARTAR).1.gz parcp.1.gz parrm.1.gz

# Don't delete intermediate files (specify .SECONDARY with no dependencies)
.SECONDARY:

rpms: ../fss-parallel-tools-$(VERSION).tar.gz fss-parallel-tools.spec
	mkdir -p ~/rpmbuild/SOURCES
	mkdir -p ~/rpmbuild/SPECS
	cp ../fss-parallel-tools-$(VERSION).tar.gz ~/rpmbuild/SOURCES
	cp fss-parallel-tools.spec ~/rpmbuild/SPECS
	cd ~/rpmbuild/SPECS;rpmbuild -ba fss-parallel-tools.spec
fss-parallel-tools.spec: fss-parallel-tools.spec.in Makefile
	sed s/VERSION_DEFINED_IN_MAKEFILE/$(VERSION)/ < $< > $@
mkfile_path := $(abspath $(lastword $(MAKEFILE_LIST)))
current_dir := $(notdir $(patsubst %/,%,$(dir $(mkfile_path))))
SOURCES = gitrev.c $(wildcard *.c *.h common/*.c common/*.h) Makefile LICENSE

../fss-parallel-tools-$(VERSION).tar.gz: $(SOURCES)
	tar czf $@ --transform 's,^,fss-parallel-tools/,' $(SOURCES)
tarball: ../fss-parallel-tools-$(VERSION).tar.gz

todo.o: todo.h 
dircache.o: dircache.h malloc.h
htable.o: htable.h malloc.h
fwg.o: malloc.h fwg.h hashfun.h
stringset.o: stringset.h hashfun.h malloc.h

####################
# COMMON
####################
# sources
common/assert.o: common/assert.h common/backtrace.h common/spew.h version.h
COMMON_O += common/assert.o 
COMMON_O += common/backtrace.o
common/backtrace.o: common/spew.h common/simplest-defs.h common/sparse.h common/backtrace.h
COMMON_O += common/debug-tag.o
common/debug-tag.o: common/debug-tag.h common/simplest-defs.h common/sparse.h
COMMON_O += common/error.o
common/error.o: common/error.h common/simplest-defs.h common/sparse.h
COMMON_O += common/spew.o
common/spew.o: common/spew.h common/backtrace.h common/simplest-defs.h common/tsan.h version.h common/debug-tag.h common/sparse.h common/error.h 

fdleak.o: fdleak.h
putils.o: putils.h common/spew.h
parcp.o:  putils.h malloc.h version.h sched.h vector-of-strings.h common/spew.h
$(PARTAR).o: putils.h malloc.h version.h sched.h vector-of-strings.h inodemap.h stringset.h vec.h fdleak.h fwg.h common/spew.h
parrm.o:  putils.h malloc.h version.h sched.h vector-of-strings.h common/spew.h
vector-of-strings.o: vector-of-strings.h malloc.h
$(PARTAR): $(PARTAR).o putils.o sched.o vector-of-strings.o gitrev.o fwg.o stringset.o vec.o fdleak.o inodemap.o $(COMMON_O)
inodemap.o: inodemap.h malloc.h
parcp:  parcp.o  putils.o sched.o vector-of-strings.o gitrev.o inodemap.o todo.o $(COMMON_O)
parrm: parrm.o putils.o gitrev.o sched.o vector-of-strings.o $(COMMON_O)

.DELETE_ON_ERROR:

.SUFFIX: .1.gz
%.1.gz: %
	PATH=$$PATH:. help2man -N --name="parallel implementation of $(subst par,,$<)" $< | gzip - > $@

gitrev.o: gitrev.c
# Don't create a new gitrev.c file if nothing changed.  We don't want
# to rerun all the tests just because I modified the Makefile.
gitrev.c: $(filter-out gitrev.c,$(wildcard *.c *.h common/*.c common/*.h Makefile))
	echo \#include \"version.h\" > gitrev_new.c
	echo const char gitrev[] = \"$$(git diff-index --quiet HEAD -- || echo "++")$$(git rev-parse HEAD)\"\; >> gitrev_new.c
	if ! diff gitrev_new.c gitrev.c >> /dev/null ; then mv gitrev_new.c gitrev.c; fi
setup: $(PARTAR)
	rm -rf tar-1.30

# Tests

.PHONY: check
TESTS =  fifo tar-1.30 linux-4.15 longfilename3
TESTS_T = $(patsubst %, %.test, $(TESTS))
check: parrm_eaccess_test.test
check: parrm_eaccess_test2.test
check: parrm_eaccess_test3.test
check: parrm_eaccess_test4.test 
check: excld.test
check: excld-equal.test
check: error.test
check: linklink.test
check: permissions.test
check: $(TESTS_T) test_fib.run
check: decompression-errors.test
check: parcp0.test parcp1.test parcp2.test parcp3.test parcp4.test parcp5.test parcp6.test parcp7.test
.SUFFIX: .test
%.test: %.partar_test %.parcp_test %.parrm_test %.tar_test
	touch $@

.SUFFIX: .partar_test
%.partar_test: %.partar1_diff %.partar2_diff %.partar3_diff %.partar4_diff partar1.test
	touch $@

test_fib.run: test_fib
	./test_fib
	touch $@
	
$(info VAR="$(COMMON_O)")
	
test_fib: test_fib.o sched.o $(COMMON_O) gitrev.o
test_fib.o: malloc.h sched.h common/spew.h
sched.o: malloc.h sched.h common/spew.h

# 

# These tests run partar in various ways and compare the output to what happened with tar.
# partar_diff1_test runs "partar pxf %.tar"
# partar_diff2_test runs "partar pxf - < %.tar"
# partar_diff3_test runs "partar pxzf %.tar.gz"
# partar_diff4_test runs "partar pxzf - < %.tar.gz"

# partar_test has things that are fifos in it, and we want to ignore
# diff error messages about those.  That's what the grep is about in
# the diff line.

output-with-tar output-with-partar1 output-with-partar2 output-with-partar3 output-with-partar4 uncompressed-tars gzipped-tars:
	mkdir -p $@

uncompressed-tars/%.tar: test-tars/%.tar.xz | uncompressed-tars
	xzcat $< > $@

gzipped-tars/%.tar.gz: uncompressed-tars/%.tar | gzipped-tars
	gzip < $< > $@

%.tar_done:                        uncompressed-tars/%.tar | output-with-tar
	rm -rf          $(patsubst uncompressed-tars/%.tar,output-with-tar/%, $<)
	tar xf $< -C output-with-tar
	touch $@

# partar1 tests makes sure that partar works with a named file
%.partar1_done:                    uncompressed-tars/%.tar $(PARTAR) | output-with-partar1 
	rm -rf          $(patsubst uncompressed-tars/%.tar,output-with-partar1/%, $<)
	$(VALGRIND) ./$(PARTAR) xf     $< -C output-with-partar1
	touch $@

%.partar1_diff: %.tar_done %.partar1_done
	diff --no-dereference -r $(patsubst %.tar_done,output-with-tar/%,$<) $(patsubst %.tar_done,output-with-partar1/%,$<) | (! grep -v "is a fifo.*is a fifo")
	touch $@

# partar2 tests make sure that partar works from stdin
%.partar2_done:                             uncompressed-tars/%.tar  $(PARTAR) | output-with-partar2
	rm -rf                   $(patsubst uncompressed-tars/%.tar,output-with-partar2/%, $<)
	$(VALGRIND) ./$(PARTAR) xf - -C output-with-partar2 < $<
	touch $@

%.partar2_diff: %.tar_done %.partar2_done
	diff --no-dereference -r $(patsubst %.tar_done,output-with-tar/%,$<) $(patsubst %.tar_done,output-with-partar2/%,$<) | (! grep -v "is a fifo.*is a fifo")
	touch $@

# partar3 tests make sure that partar works with a gzipped named file.
.SUFFIX: .partar3_done
%.partar3_done:                         gzipped-tars/%.tar.gz $(PARTAR) | output-with-partar3
	rm -rf               $(patsubst gzipped-tars/%.tar.gz,output-with-partar3/%, $<)
	$(VALGRIND) ./$(PARTAR) xzf $< -C output-with-partar3
	touch $@

.SUFFIX: .partar3_diff
%.partar3_diff: %.tar_done %.partar3_done
	diff --no-dereference -r $(patsubst %.tar_done,output-with-tar/%,$<) $(patsubst %.tar_done,output-with-partar3/%,$<) | (! grep -v "is a fifo.*is a fifo")
	touch $@

# partar4 tests make sure that partar works with a gzipped stdin
%.partar4_done:                             gzipped-tars/%.tar.gz $(PARTAR) | output-with-partar4
	rm -rf                   $(patsubst gzipped-tars/%.tar.gz,output-with-partar4/%, $<)
	$(VALGRIND) ./$(PARTAR) xzf - -C output-with-partar4 < $<
	touch $@

%.partar4_diff: %.tar_done %.partar4_done
	diff --no-dereference -r $(patsubst %.tar_done,output-with-tar/%,$<) $(patsubst %.tar_done,output-with-partar4/%,$<) | (! grep -v "is a fifo.*is a fifo")
	touch $@

# Test untarring onto a read-only file
partar1.test: $(PARTAR) | partar1.test.dir
	rm -rf $@.dir/src $@.dir/dst
	mkdir -p $@.dir/src $@.dir/dst
	touch $@.dir/dst/readonly
	chmod guo-w $@.dir/dst/readonly
	echo contents > $@.dir/src/readonly
	chmod guo-w $@.dir/src/readonly
	set -e; set -o pipefail; $(VALGRIND) ./$(PARTAR) c -C $@.dir/src readonly|$(VALGRIND) ./$(PARTAR) x -C $@.dir/dst
	diff -r $@.dir/{src,dst}
	touch $@

output-with-parcp output-to-rm output-of-partarred:
	mkdir -p $@

.SUFFIX: .parcp_test
# Turn off valgrind for the big linux parcp
linux-4.15.parcp_test: VALGRIND=
%.parcp_test: parcp %.tar_done | output-with-parcp
	rm -rf $(patsubst %.parcp_test,output-with-parcp/%, $@)
	$(VALGRIND) ./parcp -P 3 $(patsubst %.parcp_test,output-with-tar/%, $@) $(patsubst %.parcp_test,output-with-parcp/%, $@)
	diff --no-dereference -r $(patsubst %.parcp_test,output-with-tar/%, $@) $(patsubst %.parcp_test,output-with-parcp/%, $@)  | (! grep -v "is a fifo.*is a fifo")
	touch $@

.SUFFIX: .parrm_test
%.parrm_test: uncompressed-tars/%.tar parrm $(PARTAR) | output-to-rm
	$(VALGRIND) ./$(PARTAR) xf - -C output-to-rm < $<
	test -d $(patsubst %.parrm_test,output-to-rm/%,$@)
	$(VALGRIND) ./parrm -P 3 $(patsubst %.parrm_test,output-to-rm/%,$@)
	test ! -d $(patsubst %.parrm_test,output-to-rm/%,$@)
	touch $@

# This test only works on a few cases, since the order of the files isn't unique
.SUFFIX: .tardiff_test
%.tardiff_test: %.tar_out %.partar_out
	diff $^
	touch $@

.SUFFIX: .tar_test
%.tar_test: %.partar_out %.tar_done | output-of-partarred
	rm -rf $(patsubst %.partar_out,output-of-partarred/%,$<)
	$(VALGRIND) ./$(PARTAR) xf $< -C output-of-partarred
	diff --no-dereference -r $(patsubst %.tar_test,output-with-tar/%,$@) $(patsubst %.tar_test,output-of-partarred/%,$@) | (! grep -v "is a fifo.*is a fifo")
	$(EXTRA_TEST)

# These two tests check to see what happens if parrm runs into a
# directory that it hasn't got permission to access.  The whole
# directory, or a subdirectory, respectively.

ED = parrm_eaccess_test_dir
parrm_eaccess_test.test: parrm
	-chmod u+rwx $(ED) > /dev/null 2>&1 ;true
	rm -rf $(ED)
	mkdir $(ED)
	touch $(ED)/foo
	chmod ugo-rwx $(ED)
	rm -rf $(ED) > parrm_eaccess_test.out 2>&1 ; test $$? = 1
	fgrep Permission parrm_eaccess_test.out > /dev/null
	./parrm $(ED) > parrm_eaccess_test.out 2>&1 ; test $$? = 1
	fgrep Permission parrm_eaccess_test.out > /dev/null
	touch $@

ED2 = parrm_eaccess_test2_dir
parrm_eaccess_test2.test: parrm
	chmod -R u+rwx $(ED2)  > /dev/null 2>&1 ;true
	rm -rf $(ED2)
	mkdir -p $(ED2)/$(ED2)
	touch $(ED2)/$(ED2)/foo
	touch $(ED2)/foo
	chmod ugo-rwx $(ED2)/$(ED2)
	./parrm $(ED2) > $(ED2).out 2>&1 ; test $$? = 1
	chmod -R u+rwx $(ED2)  > /dev/null 2>&1 ;true
	test ! -f $(ED2)/foo
	test -f $(ED2)/$(ED2)/foo
	touch $@

# And these are the same tests where we can access the dir but we cannot unlink it.
ED3 = parrm_eaccess_test3_dir
parrm_eaccess_test3.test: parrm
	-chmod u+rwx $(ED3) > /dev/null 2>&1 ;true
	rm -rf $(ED3)
	mkdir $(ED3)
	touch $(ED3)/foo
	chmod ugo-w $(ED3)
	ls -la $(ED3)
	rm -rf $(ED3) > $(ED3).rm.out 2>&1 ; test $$? = 1
	fgrep Permission $(ED3).rm.out > /dev/null
	./parrm $(ED3) > $(ED3).parrm.out 2>&1 ; test $$? = 1
	fgrep Permission $(ED3).parrm.out > /dev/null
	touch $@

ED4 = parrm_eaccess_test4_dir
parrm_eaccess_test4.test: parrm
	chmod -R u+rwx $(ED4)  > /dev/null 2>&1 ;true
	rm -rf $(ED4)
	mkdir -p $(ED4)/$(ED4)
	touch $(ED4)/$(ED4)/foo
	touch $(ED4)/foo
	chmod ugo-rx $(ED4)/$(ED4)
	./parrm $(ED4) > $(ED4).out 2>&1 ; test $$? = 1
	chmod -R u+rwx $(ED4)  > /dev/null 2>&1 ;true
	test ! -f $(ED4)/foo
	test -f $(ED4)/$(ED4)/foo
	touch $@

# Some tarballs have extra requirements that are hard to capture with diff.  We'd really like to verify that the topology of two directories is the same, but I don't know how to get diff to really do it.  So we'll have an ad hoc test that these two files really are the same. 
longfilename3.tar_test: EXTRA_TEST = test output-of-partarred/longfilename3/aaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbccccccccccccccccdddddddddddddddeeeeeeeeeeeeeeffffffffffffffg -ef output-of-partarred/longfilename3/bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb 

.SUFFIX: .tar_out .partar_out
%.tar_out: %.tar_done
	tar cf $@ $(patsubst %.tar_done,output-with-tar/%,$<)
%.partar_out: %.tar_done $(PARTAR)
	(cd output-with-tar;../$(PARTAR) cf - $(patsubst %.tar_done,%,$<)) > $@

error.test: $(PARTAR)
	! ./$(PARTAR) xf - < /dev/null 2> error.test.out
	fgrep -q ": This does not look like a tar archive" error.test.out
	fgrep -q ": Exiting with failure status due to previous errors" error.test.out
	! ./$(PARTAR) xzf - < /dev/null 2> error.test.out
	fgrep -q "gzip: stdin: unexpected end of file" error.test.out
	fgrep -q ": Child returned status 1" error.test.out
	fgrep -q ": Exiting with failure status due to previous errors" error.test.out
	! ./$(PARTAR) cf error.tar output-with-tar/fifo no-such-file output-with-tar/fifo 2> error.test.out
	fgrep -q ": no-such-file: Cannot stat: No such file or directory" error.test.out
	fgrep -q ": Exiting with failure status due to previous errors" error.test.out
	touch $@

# Test excluding files both in "c" mode and in "x" mode.
excld.test: tar-1.30.tar_done $(PARTAR)
	rm -rf excld.dir.tar excld.dir.partar excld.odir.tar excld.odir.partar
	mkdir excld.dir.tar excld.dir.partar excld.odir.tar excld.odir.partar
	tar      cf - -C output-with-tar/ --exclude d\?c tar-1.30 | tar xf - -C excld.dir.tar
	$(VALGRIND) ./$(PARTAR) cf - -C output-with-tar/ --exclude d\?c tar-1.30 | tar xf - -C excld.dir.partar
	diff -r excld.dir.tar excld.dir.partar
	tar      c    -C output-with-tar/                tar-1.30 | tar x    -C excld.odir.tar --exclude d\?c
	diff -r excld.dir.tar excld.odir.tar
	tar      c    -C output-with-tar/                tar-1.30 | $(VALGRIND) ./$(PARTAR) x    -C excld.odir.partar --exclude d\?c
	diff -r excld.dir.tar excld.odir.partar
	touch $@

# Test excluding files both in "c" mode and in "x" mode same as above but uses --exclude=PATTERN.
excld-equal.test: tar-1.30.tar_done $(PARTAR)
	rm -rf excld-equal.dir.tar excld-equal.dir.partar excld-equal.odir.tar excld-equal.odir.partar
	mkdir excld-equal.dir.tar excld-equal.dir.partar excld-equal.odir.tar excld-equal.odir.partar
	tar      cf - -C output-with-tar/ --exclude=d\?c tar-1.30 | tar xf - -C excld-equal.dir.tar
	$(VALGRIND) ./$(PARTAR) cf - -C output-with-tar/ --exclude=d\?c tar-1.30 | tar xf - -C excld-equal.dir.partar
	diff -r excld-equal.dir.tar excld-equal.dir.partar
	tar      c    -C output-with-tar/                tar-1.30 | tar x    -C excld-equal.odir.tar --exclude d\?c
	diff -r excld-equal.dir.tar excld-equal.odir.tar
	tar      c    -C output-with-tar/                tar-1.30 | $(VALGRIND) ./$(PARTAR) x    -C excld-equal.odir.partar --exclude=d\?c
	diff -r excld-equal.dir.tar excld-equal.odir.partar
	touch $@
	
# Test the same file appearing twice on the command line.   tar makes a hardlink from the file to itself.
linklink.test: $(PARTAR)
	echo a > linklink.txt
	tar      cf linklink.tar linklink.txt linklink.txt
	$(VALGRIND) ./$(PARTAR) cf linklink.partar linklink.txt linklink.txt
	# Don't run the diff unless we have a recent version of tar
	if (tar --version|head -1|fgrep 1.3 > /dev/null); then diff linklink.tar linklink.partar; fi
	mkdir -p linklink.tdir
	tar xf linklink.tar -C linklink.tdir
	mkdir -p linklink.pdir
	tar xf linklink.partar -C linklink.pdir
	diff -r linklink.tdir linklink.pdir
	touch $@

# This isn't part of the standard tests, since it requires sudo to run properly.
permissions.sudo.test: $(PARTAR)
	sudo rm -rf permissions.sudopartar.testdir permissions.sudountar.testdir
	mkdir -p permissions.sudopartar.testdir
	mkdir -p permissions.sudountar.testdir
	sudo tar      pxf test-tars/permissions.tar -C permissions.sudountar.testdir
	sudo ./$(PARTAR) pxf test-tars/permissions.tar -C permissions.sudopartar.testdir
	# for some reason tar doesn't set the mtime on partar/src/bin in those directories, so let's ignore bin.
	(cd permissions.sudopartar.testdir; ls -lR)|sort | egrep -v "bin$$" > permissions.sudopartar.out
	(cd permissions.sudountar.testdir;  ls -lR)|sort | egrep -v "bin$$" > permissions.sudountar.out
	diff permissions.sudopartar.out permissions.sudountar.out

# permissions test for not sudo
permissions.test: $(PARTAR)
	rm -rf permissions.in.dir permissions.tar.out.dir permissions.partar.out.dir permissions.tar.ls permissions.partar.ls
	mkdir -p permissions.in.dir/s
	mkdir -p permissions.in.dir/s/d1
	mkdir -p permissions.in.dir/s/d2
	ls -l permissions.in.dir/s
	chmod 770 permissions.in.dir/s/d1
	chmod 750 permissions.in.dir/s/d2
	ls -l permissions.in.dir/s
	mkdir -p permissions.tar.out.dir
	tar cf - -C permissions.in.dir s | tar xf - -C permissions.tar.out.dir
	ls -l permissions.tar.out.dir/s	| sort > permissions.tar.ls
	mkdir -p permissions.partar.out.dir
	tar cf - -C permissions.in.dir s | $(VALGRIND) ./$(PARTAR) xf - -C permissions.partar.out.dir
	ls -l permissions.partar.out.dir/s | sort > permissions.partar.ls
	diff permissions.tar.ls permissions.partar.ls
	touch $@

# Test for detecting .gz and .xz inputs.
decompression-errors.test: ./partar
	! ./partar xf test-tars/fifo.tar.xz 2> decompression-errors.out
	fgrep "Input does not appear to be a tar file." decompression-errors.out > /dev/null
	fgrep "Input appears to be xz compressed" decompression-errors.out > /dev/null
	!(xzcat test-tars/fifo.tar.xz |gzip|./partar xf - 2> decompression-errors.out)
	fgrep "Input does not appear to be a tar file." decompression-errors.out > /dev/null
	fgrep "appears to be gzipped" decompression-errors.out > /dev/null
	touch $@

%.dir:
	mkdir $@

# Some specific tests for parcp
parcp0.test: parcp tar-1.30.tar_done | parcp0.test.dir
	rm -rf $@.dir/*
	./parcp --restore -- output-with-tar/tar-1.30 $@.dir
	touch $@

parcp1.test: parcp
	./parcp --version |fgrep $(VERSION) > /dev/null
	./parcp --help |fgrep OPTION > /dev/null
	touch $@

# test that if we copy into an existing file that is longer, that it's properly trunated
parcp2.test: parcp | parcp2.test.dir
	rm -rf $@.dir/*
	mkdir -p $@.dir/src $@.dir/dst/src
	echo "hello" > $@.dir/src/hello
	echo "hello there" > $@.dir/dst/src/hello
	ls -i $@.dir/dst/src/hello > $@.dir/original.inode
	./parcp -P 3 $@.dir/src $@.dir/dst
	ls -i $@.dir/dst/src/hello > $@.dir/new.inode
	diff $@.dir/src/hello $@.dir/dst/src/hello
	diff $@.dir/new.inode $@.dir/original.inode
	touch $@

parcp3.test:  parcp | parcp3.dir
	rm -rf $@.dir/*
	mkdir -p $@.dir/src $@.dir/dst
	# source and dest are the same symlink, so expect no change
	ln -s unchanged $@.dir/src/uc
	ln -s unchanged $@.dir/dst/uc
	# source and dest are slightly different symlinks, the same length.
	ln -s changed0  $@.dir/src/ch
	ln -s changed1  $@.dir/dst/ch
	# source and dest are different symlinks of different length.
	ln -s shortch   $@.dir/src/chlen
	ln -s longerch  $@.dir/dst/chlen
	# source is symlink, dest is not there
	ln -s notthere  $@.dir/src/nt
	# source is a symlink, dest is a dir
	ln -s dest-was-dir $@.dir/src/wasdir
	mkdir $@.dir/dst/wasdir
	# source is a symlink, dest is a regular file.
	ln -s dest-was-reg $@.dir/src/wasreg
	touch $@.dir/dst/wasreg
	#ls -l $@.dir/dst	
	ls -i parcp3.test.dir/dst/uc > $@.dir/original.uc.symlink
	# source and dest are fifos.  Make sure the inode is reused
	mknod $@.dir/src/src_fifo_dst_fifo p
	mknod $@.dir/dst/src_fifo_dst_fifo p
	ls -i $@.dir/dst/src_fifo_dst_fifo > $@.dir/src_fifo_dst_fifo.original
	# source is fifo and dest is regular.  Make sure dest becomes fifo
	mknod $@.dir/src/src_fifo_dst_reg p
	touch $@.dir/dst/src_fifo_dst_reg
	# source is regular and dest is fifo.  Make sure dest becomes reg
	touch $@.dir/src/src_reg_dst_fifo
	mknod $@.dir/dst/src_reg_dst_fifo p
	# source is file, dest is dir
	touch $@.dir/src/src_reg_dst_dir
	mkdir $@.dir/dst/src_reg_dst_dir
	# source is dir, dest is file
	mkdir $@.dir/src/src_dir_dst_reg
	touch $@.dir/dst/src_dir_dst_reg
	# two files that are the same inode in src, nothing in dst
	touch  $@.dir/src/src_two_inodes_dst_null.1
	ln $@.dir/src/src_two_inodes_dst_null.1 $@.dir/src/src_two_inodes_dst_null.2
	# two files the same inode in src, a file in dst
	touch  $@.dir/src/src_two_inodes_dst_reg.1
	ln $@.dir/src/src_two_inodes_dst_reg.1 $@.dir/src/src_two_inodes_dst_reg.2
	touch $@.dir/dst/src_two_inodes_dst_reg.1
	# two files the same inode in src, two dirs in dst
	touch  $@.dir/src/src_two_inodes_dst_two_dirs.1
	ln $@.dir/src/src_two_inodes_dst_two_dirs.1 $@.dir/src/src_two_inodes_dst_two_dirs.2
	mkdir $@.dir/dst/src_two_inodes_dst_two_dirs.1
	mkdir $@.dir/dst/src_two_inodes_dst_two_dirs.2
	# three files the same inode in src, three files in dst, two of which are the same inode.
	touch  $@.dir/src/src_3_inodes_dst_3_files.1
	ln $@.dir/src/src_3_inodes_dst_3_files.1 $@.dir/src/src_3_inodes_dst_3_files.2
	ln $@.dir/src/src_3_inodes_dst_3_files.1 $@.dir/src/src_3_inodes_dst_3_files.3
	touch  $@.dir/dst/src_3_inodes_dst_3_files.1
	ln $@.dir/dst/src_3_inodes_dst_3_files.1 $@.dir/dst/src_3_inodes_dst_3_files.2
	touch $@.dir/dst/src_3_inodes_dst_3_files.3
	# do the copy
	$(VALGRIND) ./parcp $@.dir/src $@.dir/dst
	ls -l $@.dir/dst	
	test -h $@.dir/dst/ch
	ls -l $@.dir/dst/ch | fgrep "ch -> changed0"
	ls -l $@.dir/dst/nt | fgrep "nt -> notthere"
	ls -l $@.dir/dst/wasdir | fgrep "wasdir -> dest-was-dir"
	ls -l $@.dir/dst/chlen | fgrep "chlen -> shortch"
	test -h $@.dir/dst/wasreg
	ls -l $@.dir/dst/wasreg| fgrep "wasreg -> dest-was-reg"
	# test follows symlinks so we must do htis more carefully
	ls -i parcp3.test.dir/dst/uc > $@.dir/new.uc.symlink
	diff $@.dir/original.uc.symlink $@.dir/new.uc.symlink
	ls -i $@.dir/dst/src_fifo_dst_fifo > $@.dir/src_fifo_dst_fifo.new
	diff $@.dir/src_fifo_dst_fifo.new $@.dir/src_fifo_dst_fifo.original
	test -p $@.dir/dst/src_fifo_dst_reg
	test -f $@.dir/dst/src_reg_dst_fifo
	test -f $@.dir/dst/src_reg_dst_dir
	test -d $@.dir/dst/src_dir_dst_reg
	test  parcp3.test.dir/dst/src_two_inodes_dst_null.1 -ef parcp3.test.dir/dst/src_two_inodes_dst_null.2
	test  parcp3.test.dir/dst/src_two_inodes_dst_reg.1 -ef parcp3.test.dir/dst/src_two_inodes_dst_reg.2
	test  parcp3.test.dir/dst/src_3_inodes_dst_3_files.1 -ef parcp3.test.dir/dst/src_3_inodes_dst_3_files.2
	test  parcp3.test.dir/dst/src_3_inodes_dst_3_files.1 -ef parcp3.test.dir/dst/src_3_inodes_dst_3_files.3
	touch $@

# Check --delete
parcp4.test: parcp | parcp4.test.dir
	rm -rf $@.dir/*
	mkdir -p $@.dir/src $@.dir/dst
	mkdir -p $@.dir/dst/a/b/c/d/e
	touch $@.dir/dst/a/b/c/d/e/f
	mkdir -p $@.dir/dst/a/b/c/d/e2
	touch $@.dir/dst/a/b/c/d/e2/f
	mkdir -p $@.dir/src/x/y/z
	mkdir -p $@.dir/src/a/w
	touch  $@.dir/src/a/w/foo
	$(VALGRIND) ./parcp --delete $@.dir/src $@.dir/dst
	diff -r $@.dir/src $@.dir/dst
	touch $@

# Check --exclude-from
parcp5.test: parcp | parcp5.test.dir
	rm -rf $@.dir/*
	mkdir -p $@.dir/src $@.dir/dst
	mkdir $@.dir/src/wanted
	mkdir $@.dir/src/unwanted
	touch $@.dir/src/wanted/file1.keep
	touch $@.dir/src/wanted/file2.nokeep
	touch $@.dir/src/wanted/file3.nokeep
	echo unwanted > $@.dir/excludelist
	echo wanted/file2.nokeep >> $@.dir/excludelist
	echo file3.nokeep >> $@.dir/excludelist
	$(VALGRIND) ./parcp --exclude-from=$@.dir/excludelist $@.dir/src $@.dir/dst
	test -d $@.dir/dst/wanted
	test -f $@.dir/dst/wanted/file1.keep
	ls $@.dir/dst/wanted|fgrep -v file2.nokeep > /dev/null
	ls $@.dir/dst/wanted|fgrep -v file3.nokeep > /dev/null
	test ! -d $@.dir/dst/unwanted
	touch $@

# Check --exclude-from with --delete
parcp6.test: parcp Makefile | parcp6.test.dir
	rm -rf $@.dir/*
	mkdir -p $@.dir/src $@.dir/dst
	mkdir -p $@.dir/src/src_wanted
	mkdir -p $@.dir/dst/dst_wanted
	mkdir -p $@.dir/dst/dst_extra
	mkdir -p $@.dir/dst/dst_extra2
	mkdir -p $@.dir/dst/dst_kill
	touch $@.dir/dst/dst_wanted/keepme
	touch $@.dir/dst/dst_extra/dst_wanted_file
	touch $@.dir/dst/dst_extra2/keep2
	touch $@.dir/dst/dst_extra2/killme
	touch $@.dir/dst/dst_kill/killme2
	echo dst_wanted > $@.dir/excludelist
	echo dst_wanted_file >> $@.dir/excludelist
	echo dst_extra2/keep2 >> $@.dir/excludelist
	$(VALGRIND) ./parcp --exclude-from=$@.dir/excludelist --delete $@.dir/src $@.dir/dst
	test -f $@.dir/dst/dst_wanted/keepme
	test -f $@.dir/dst/dst_extra/dst_wanted_file
	test -f $@.dir/dst/dst_extra2/keep2
	test ! -f $@.dir/dst/dst_extra2/killme
	test ! -f $@.dir/dst/dst_kill/killme2
	test ! -d $@.dir/dst/dst_kill
	touch $@

# Check target contains a read-only file
#  Three cases: 1) No such file in src
#               2) Exactly the same file in src
#               3) A different file in src
parcp7.test: parcp | parcp7.test.dir
	rm -rf $@.dir/*
	mkdir -p $@.dir/src $@.dir/dst
	touch $@.dir/dst/no-such-file-in-src
	chmod ugo-w $@.dir/dst/no-such-file-in-src
	echo same in src >  $@.dir/src/same-file-in-src
	chmod ugo-w $@.dir/src/same-file-in-src
	cp -a $@.dir/src/same-file-in-src $@.dir/dst/same-file-in-src
	echo diffrent in src > $@.dir/src/diff-file-in-src
	chmod ugo-w $@.dir/src/diff-file-in-src
	echo diffrent in dst dst > $@.dir/dst/diff-file-in-src
	chmod ugo-w $@.dir/dst/diff-file-in-src
	ls -l $@.dir/{src,dst}
	$(VALGRIND) ./parcp --delete $@.dir/src $@.dir/dst
	ls -l $@.dir/{src,dst}
	test ! -f $@.dir/dst/no-such-file-in-src
	test -f $@.dir/dst/diff-file-in-src
	test -f $@.dir/dst/same-file-in-src
	diff -r $@.dir/{src,dst}
	touch $@

parcp8.test: parcp | parcp7.test.dir
	rm -rf $@.dir/*
	mkdir -p $@.dir/src $@.dir/dst
	touch $@.dir/src/rws-file
	chmod +sx $@.dir/src/rws-file
	./parcp $@.dir/src $@.dir/dst
	test -x parcp8.test.dir/dst/rws-file
	test -u parcp8.test.dir/dst/rws-file
	echo touch $@

.PHONY: clean
clean:
	rm -rf parrm parcp $(PARTAR) parrm.1.gz parcp.1.gz $(PARTAR).1.gz *.o output-with-tar output-to-rm output-with-parcp *.tar_done *.parrm_test *.parcp_test *.partar_test
	rm -rf gitrev.c
	rm -rf output-with-partar{1,2,3,4} output-of-partarred
	rm -rf uncompressed-tars gzipped-tars
	rm -rf  *.partar{1,2,3,4}_diff
	rm -rf  *.partar{1,2,3,4}_done
	rm -rf excld.dir.*tar excld.test
	rm -rf excld-equal.dir.*tar excld-equal.test
	if test -n "$$(find . -maxdepth 1 -name 'parrm_eaccess_test*_dir' -print -quit)"; then chmod -R u+rwx parrm_eaccess_test*_dir; fi
	rm -rf parrm_eaccess_test*{.out,_dir}
	rm -rf error.test.out error.tar linklink.tar linklink.partar linklink.tdir linklink.pdir linklink.txt  excld.odir.partar excld.odir.tar
	rm -rf permissions.in.dir permissions.tar.out.dir permissions.partar.out.dir permissions.tar.ls permissions.partar.ls
	rm -rf *.ls *.test *.tar_test
	rm -rf *.partar_out *.tar_out test1.out *.out
	rm -rf test_fin
	rm -f *.gcda *.gcno common/*.gcda common/*.gcno
	rm -rf *.dir/
	rm -rf *.1.gz
	rm -f $(COMMON_O)
	rm -rf partar_log
		
.PHONY: realclean
realclean: clean