9783666546
Defer seeking the *input* image, or winding it forward, until we are certain we all ready in the cloop2 output, because when the input image is a pipe, we don't get a chance to seek back to the beginning and start from the top instead of restarting. If restart does fail, don't try to seek the input image back to the beginning unless we had already tried to seek or wind it forward. Add some automatic tests for this and related cases. XXX pullup to netbsd-7, netbsd-6
282 lines
9.4 KiB
Makefile
282 lines
9.4 KiB
Makefile
PROG= vndcompress
|
|
SRCS= main.c offtab.c utils.c vndcompress.c vnduncompress.c
|
|
|
|
LINKS= ${BINDIR}/vndcompress ${BINDIR}/vnduncompress
|
|
MLINKS= vndcompress.1 vnduncompress.1
|
|
|
|
DPADD+= ${LIBZ}
|
|
LDADD+= -lz
|
|
|
|
WARNS= 5
|
|
|
|
.include <bsd.prog.mk>
|
|
|
|
TESTFILES+= oneblock
|
|
XFAIL+= oneblock.in-outx
|
|
XFAIL+= oneblock.cl2-cl2x
|
|
oneblock.in:
|
|
head -c 512 < /usr/share/dict/words > ${.TARGET}.tmp \
|
|
&& mv -f ${.TARGET}.tmp ${.TARGET}
|
|
|
|
TESTFILES+= tenblock
|
|
XFAIL+= tenblock.in-outx
|
|
XFAIL+= tenblock.cl2-cl2x
|
|
tenblock.in:
|
|
head -c 5120 < /usr/share/dict/words > ${.TARGET}.tmp \
|
|
&& mv -f ${.TARGET}.tmp ${.TARGET}
|
|
|
|
TESTFILES+= smallfile
|
|
XFAIL+= smallfile.in-outx
|
|
XFAIL+= smallfile.cl2-cl2x
|
|
smallfile.in:
|
|
head -c 12345 < /usr/share/dict/words > ${.TARGET}.tmp \
|
|
&& mv -f ${.TARGET}.tmp ${.TARGET}
|
|
|
|
CHECKS+= check-pipe
|
|
CLEANFILES+= smallfile.cl2pipe
|
|
check-pipe: .PHONY smallfile.cl2 smallfile.cl2pipe
|
|
cmp ${.ALLSRC}
|
|
smallfile.cl2pipe: smallfile.in vndcompress
|
|
head -c 54321 < /usr/share/dict/words \
|
|
| ./vndcompress -l 12345 /dev/stdin ${.TARGET}.tmp \
|
|
&& mv -f ${.TARGET}.tmp ${.TARGET}
|
|
|
|
TESTFILES+= onechunk
|
|
onechunk.in:
|
|
head -c 65536 < /usr/share/dict/words > ${.TARGET}.tmp \
|
|
&& mv -f ${.TARGET}.tmp ${.TARGET}
|
|
|
|
TESTFILES+= tenchunk
|
|
tenchunk.in:
|
|
head -c 655360 < /usr/share/dict/words > ${.TARGET}.tmp \
|
|
&& mv -f ${.TARGET}.tmp ${.TARGET}
|
|
|
|
TESTFILES+= extrablock
|
|
XFAIL+= extrablock.in-outx
|
|
XFAIL+= extrablock.cl2-cl2x
|
|
extrablock.in:
|
|
head -c $$((65536 + 512)) < /usr/share/dict/words > ${.TARGET}.tmp \
|
|
&& mv -f ${.TARGET}.tmp ${.TARGET}
|
|
|
|
TESTFILES+= medfile
|
|
XFAIL+= medfile.in-outx
|
|
XFAIL+= medfile.cl2-cl2x
|
|
medfile.in:
|
|
head -c 123456 < /usr/share/dict/words > ${.TARGET}.tmp \
|
|
&& mv -f ${.TARGET}.tmp ${.TARGET}
|
|
|
|
TESTFILES+= onetinyblock
|
|
BLOCKSIZE.onetinyblock= 512
|
|
onetinyblock.in:
|
|
head -c 512 < /usr/share/dict/words > ${.TARGET}.tmp \
|
|
&& mv -f ${.TARGET}.tmp ${.TARGET}
|
|
|
|
TESTFILES+= tentinyblock
|
|
BLOCKSIZE.tentinyblock= 512
|
|
tentinyblock.in:
|
|
head -c 5120 < /usr/share/dict/words > ${.TARGET}.tmp \
|
|
&& mv -f ${.TARGET}.tmp ${.TARGET}
|
|
|
|
# Make sure we can restart from a pipe.
|
|
CHECKS+= check-pipe-restart
|
|
CLEANFILES+= piperestart.in piperestart.in.tmp
|
|
CLEANFILES+= piperestart.cl2 piperestart.cl2.tmp
|
|
CLEANFILES+= piperestart.cl2restart piperestart.cl2restart.tmp
|
|
CLEANFILES+= piperestart.cl2part piperestart.cl2part.tmp
|
|
check-pipe-restart: .PHONY piperestart.cl2 piperestart.cl2restart
|
|
cmp ${.ALLSRC}
|
|
piperestart.cl2restart: piperestart.cl2part vndcompress
|
|
cp piperestart.cl2part ${.TARGET}.tmp \
|
|
&& head -c 700000 < /usr/share/dict/words \
|
|
| ./vndcompress -l 655360 -k 1 -r -R /dev/stdin ${.TARGET}.tmp \
|
|
&& mv -f ${.TARGET}.tmp ${.TARGET}
|
|
# The following rule uses ; and not && on purpose: vndcompress is
|
|
# supposed to fail (and it is even OK to interrupt!) so we can restart
|
|
# and fill in the rest.
|
|
piperestart.cl2part: vndcompress
|
|
head -c 600000 < /usr/share/dict/words \
|
|
| ./vndcompress -l 655360 -k 1 /dev/stdin ${.TARGET}.tmp; \
|
|
mv -f ${.TARGET}.tmp ${.TARGET}
|
|
piperestart.in:
|
|
head -c 655360 < /usr/share/dict/words > ${.TARGET}.tmp \
|
|
&& mv -f ${.TARGET}.tmp ${.TARGET}
|
|
|
|
# Make sure we can restart from a pipe even if the original start was
|
|
# corrupted, as long as we don't pass -R.
|
|
CHECKS+= check-pipe-badstart
|
|
CLEANFILES+= pipebadstart.in pipebadstart.in.tmp
|
|
CLEANFILES+= pipebadstart.cl2 pipebadstart.cl2.tmp
|
|
CLEANFILES+= pipebadstart.cl2restart pipebadstart.cl2restart.tmp
|
|
CLEANFILES+= pipebadstart.cl2part pipebadstart.cl2part.tmp
|
|
check-pipe-badstart: .PHONY pipebadstart.cl2 pipebadstart.cl2restart
|
|
cmp ${.ALLSRC}
|
|
pipebadstart.cl2restart: pipebadstart.cl2part vndcompress
|
|
cp pipebadstart.cl2part ${.TARGET}.tmp \
|
|
&& head -c 700000 < /usr/share/dict/words \
|
|
| ./vndcompress -l 655360 -k 1 -r /dev/stdin ${.TARGET}.tmp \
|
|
&& mv -f ${.TARGET}.tmp ${.TARGET}
|
|
pipebadstart.cl2part:
|
|
touch ${.TARGET}
|
|
pipebadstart.in:
|
|
head -c 655360 < /usr/share/dict/words > ${.TARGET}.tmp \
|
|
&& mv -f ${.TARGET}.tmp ${.TARGET}
|
|
|
|
# Make sure we can `restart' even if there's nothing there.
|
|
CHECKS+= check-pipe-falsestart
|
|
CLEANFILES+= pipefalsestart.in pipefalsestart.in.tmp
|
|
CLEANFILES+= pipefalsestart.cl2 pipefalsestart.cl2.tmp
|
|
CLEANFILES+= pipefalsestart.cl2restart pipefalsestart.cl2restart.tmp
|
|
check-pipe-falsestart: .PHONY pipefalsestart.cl2 pipefalsestart.cl2restart
|
|
cmp ${.ALLSRC}
|
|
pipefalsestart.cl2restart: vndcompress
|
|
rm -f ${.TARGET}.tmp \
|
|
&& head -c 700000 < /usr/share/dict/words \
|
|
| ./vndcompress -l 655360 -k 1 -r /dev/stdin ${.TARGET}.tmp \
|
|
&& mv -f ${.TARGET}.tmp ${.TARGET}
|
|
pipefalsestart.in:
|
|
head -c 655360 < /usr/share/dict/words > ${.TARGET}.tmp \
|
|
&& mv -f ${.TARGET}.tmp ${.TARGET}
|
|
|
|
# Make sure we can restart from a file, simulated with `-p'.
|
|
CHECKS+= check-part
|
|
CLEANFILES+= part.orig part.orig.tmp
|
|
CLEANFILES+= part.cl2part part.cl2part.tmp
|
|
CLEANFILES+= part.cl2 part.cl2.tmp
|
|
CLEANFILES+= part.out part.out.tmp
|
|
check-part: .PHONY part.orig part.out
|
|
cmp part.orig part.out
|
|
part.cl2: part.orig part.cl2part vndcompress
|
|
cp part.cl2part ${.TARGET}.tmp \
|
|
&& ./vndcompress -b 512 -r -R part.orig ${.TARGET}.tmp \
|
|
&& mv -f ${.TARGET}.tmp ${.TARGET}
|
|
part.cl2part: part.orig vndcompress
|
|
./vndcompress -b 512 -p 10 part.orig ${.TARGET}.tmp \
|
|
&& mv -f ${.TARGET}.tmp ${.TARGET}
|
|
part.orig:
|
|
head -c 12345 < /usr/share/dict/words > ${.TARGET}.tmp \
|
|
&& mv -f ${.TARGET}.tmp ${.TARGET}
|
|
|
|
# Make sure we can `restart' even if there's nothing there.
|
|
CHECKS+= check-falsestart
|
|
CLEANFILES+= falsestart.in falsestart.in.tmp
|
|
CLEANFILES+= falsestart.cl2 falsestart.cl2.tmp
|
|
CLEANFILES+= falsestart.cl2restart falsestart.cl2restart.tmp
|
|
check-falsestart: .PHONY falsestart.cl2 falsestart.cl2restart
|
|
cmp ${.ALLSRC}
|
|
falsestart.cl2restart: vndcompress falsestart.in
|
|
rm -f ${.TARGET}.tmp \
|
|
&& ./vndcompress -r falsestart.in ${.TARGET}.tmp \
|
|
&& mv -f ${.TARGET}.tmp ${.TARGET}
|
|
falsestart.in:
|
|
head -c 655360 < /usr/share/dict/words > ${.TARGET}.tmp \
|
|
&& mv -f ${.TARGET}.tmp ${.TARGET}
|
|
|
|
TESTFILES+= smallwindow
|
|
smallwindow.in:
|
|
head -c 655360 < /usr/share/dict/words > ${.TARGET}.tmp \
|
|
&& mv -f ${.TARGET}.tmp ${.TARGET}
|
|
smallwindow.cl2: smallwindow.in
|
|
./vndcompress -w 1 ${.IMPSRC} ${.TARGET}.tmp \
|
|
&& mv -f ${.TARGET}.tmp ${.TARGET}
|
|
smallwindow.out: smallwindow.cl2
|
|
./vndcompress -w 1 -d ${.IMPSRC} ${.TARGET}.tmp \
|
|
&& mv -f ${.TARGET}.tmp ${.TARGET}
|
|
|
|
CHECKS+= check-pipewindow
|
|
check-pipewindow: smallwindow.cl2
|
|
@echo '# expecting failure...'
|
|
if cat smallwindow.cl2 | ./vndcompress -w 1 -d /dev/stdin /dev/null; \
|
|
then \
|
|
echo 'unexpected pass!' && exit 1; \
|
|
fi
|
|
|
|
# The following two tests try to ensure a limited window size means
|
|
# limited memory allocation. They don't work very well. The virtual
|
|
# address space rlimit (ulimit -v, RLIMIT_AS) must cover the stack size
|
|
# that is allocated automatically for the process, which varies from
|
|
# machine architecture to machine architecture (the kernel's MAXSSIZ
|
|
# parameter), as well as any shared libraries that get loaded in and
|
|
# other auxiliary crud the loader or libc might allocate.
|
|
#
|
|
# In principle, the overhead from that and the program image should be
|
|
# constant, and the only substantial memory allocation performed by
|
|
# vndcompress should be w*8 bytes or (n/b)*8, where w is the window
|
|
# size if specified, n is the size of the input, and b is the block
|
|
# size.
|
|
#
|
|
# We could perhaps do an exponential growth and then binary search on
|
|
# the virtual address space limit to determine the overhead, but that's
|
|
# more trouble than I care to do in a makefile right now. Currently
|
|
# this is calibrated for NetBSD/amd64 6, where 128 MB of virtual
|
|
# address space is allocated for the stack. (Note `ulimit -v' takes a
|
|
# number of kilobytes, not a number of bytes.) Since this is not
|
|
# reliable, however, these are commented out.
|
|
|
|
#CHECKS+= check-ulimit
|
|
#check-ulimit:
|
|
# @echo '# expecting failure...'
|
|
# if head -c $$((64 * 1024 * 1024)) < /dev/zero \
|
|
# | (ulimit -v $$((139 * 1024)) && \
|
|
# ./vndcompress -w 0 -l 64m -b 512 /dev/stdin /dev/null); then \
|
|
# echo 'unexpected pass!' && exit 1; \
|
|
# fi
|
|
#
|
|
#CHECKS+= check-ulimit-window
|
|
#check-ulimit-window:
|
|
# head -c $$((64 * 1024 * 1024)) < /dev/zero \
|
|
# | (ulimit -v $$((139 * 1024)) && \
|
|
# ./vndcompress -w 8192 -l 64m -b 512 /dev/stdin /dev/null)
|
|
|
|
TESTSUFFIXES+= in cl2 cl2x out outx
|
|
|
|
TESTFORMS+= cl2 cl2x
|
|
TESTFORMS+= in out
|
|
TESTFORMS+= in outx
|
|
|
|
.for testfile in ${TESTFILES}
|
|
. for suffix in ${TESTSUFFIXES}
|
|
CLEANFILES+= ${testfile}.${suffix}
|
|
CLEANFILES+= ${testfile}.${suffix}.tmp
|
|
. endfor
|
|
. for left right in ${TESTFORMS}
|
|
CHECKS.${testfile}+= check-${testfile}.${left}-${right}
|
|
check-${testfile}.${left}-${right}: .PHONY \
|
|
${testfile}.${left} ${testfile}.${right}
|
|
. if empty(XFAIL:M${testfile}.${left}-${right})
|
|
cmp ${testfile}.${left} ${testfile}.${right}
|
|
. else
|
|
@echo '# expecting failure...' \
|
|
&& echo 'cmp ${testfile}.${left} ${testfile}.${right}' \
|
|
&& if cmp ${testfile}.${left} ${testfile}.${right}; then \
|
|
echo 'unexpected pass!' \
|
|
&& exit 1; \
|
|
fi
|
|
. endif
|
|
. endfor
|
|
check-${testfile}: ${CHECKS.${testfile}}
|
|
CHECKS+= check-${testfile}
|
|
.endfor
|
|
|
|
check: .PHONY ${CHECKS}
|
|
|
|
.SUFFIXES: .cl2 .cl2x .in .out .outx
|
|
|
|
# XXX These tests should automatically try different window sizes, but
|
|
# that is tricky to express in make.
|
|
|
|
.in.cl2: vndcompress
|
|
./vndcompress ${.IMPSRC} ${.TARGET}.tmp ${BLOCKSIZE.${.PREFIX}} \
|
|
&& mv -f ${.TARGET}.tmp ${.TARGET}
|
|
|
|
.in.cl2x:
|
|
vndcompress ${.IMPSRC} ${.TARGET}.tmp ${BLOCKSIZE.${.PREFIX}} \
|
|
&& mv -f ${.TARGET}.tmp ${.TARGET}
|
|
|
|
.cl2.out: vndcompress
|
|
./vndcompress -d ${.IMPSRC} ${.TARGET}.tmp \
|
|
&& mv -f ${.TARGET}.tmp ${.TARGET}
|
|
|
|
.cl2.outx:
|
|
vnduncompress ${.IMPSRC} ${.TARGET}.tmp \
|
|
&& mv -f ${.TARGET}.tmp ${.TARGET}
|