diff options
Diffstat (limited to 'src/sanity.sh')
| -rwxr-xr-x | src/sanity.sh | 35660 |
1 files changed, 35660 insertions, 0 deletions
diff --git a/src/sanity.sh b/src/sanity.sh new file mode 100755 index 0000000..6d068ad --- /dev/null +++ b/src/sanity.sh @@ -0,0 +1,35660 @@ +#! /bin/sh +: +# sanity.sh -- a growing testsuite for cvs. +# +# The copyright notice said: "Copyright (C) 1992, 1993 Cygnus Support" +# I'm not adding new copyright notices for new years as our recent +# practice has been to include copying terms without copyright notices. +# +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2, or (at your option) +# any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# Original Author: K. Richard Pixley + +# usage: +usage () +{ + echo "Usage: `basename $0` --help" + echo "Usage: `basename $0` [--eklr] [-c CONFIG-FILE] [-f FROM-TEST] \\" + echo " [-h HOSTNAME] [-s CVS-FOR-CVS-SERVER] CVS-TO-TEST \\" + echo " [TESTS-TO-RUN...]" +} + +exit_usage () +{ + usage 1>&2 + exit 2 +} + +exit_help () +{ + usage + echo + echo "-H|--help display this text" + echo "-c CONFIG-FILE" + echo "--config=CONFIG_FILE" + echo " use an alternate test suite config file (defaults to" + echo " \`sanity.config.sh' in the same directory as" + echo " CVS-TO-TEST is found in)" + echo "-e|--skipfail Treat tests that would otherwise be nonfatally skipped" + echo " for reasons like missing tools as failures, exiting" + echo " with an error message. Also treat warnings as" + echo " failures." + echo "-f FROM-TEST" + echo "--from-test=FROM-TEST" + echo " run TESTS-TO-RUN, skipping all tests in the list before" + echo " FROM-TEST" + echo "-h HOSTNAME" + echo "--hostname HOSTNAME" + echo " Use :ext:HOSTNAME to run remote tests rather than" + echo " :fork:. Implies --remote and assumes that \$TESTDIR" + echo " resolves to the same directory on both the client and" + echo " the server." + echo "-k|--keep try to keep directories created by individual tests" + echo " around, exiting after the first test which supports" + echo " --keep" + echo "-l|--link-root" + echo " test CVS using a symlink to a real CVSROOT" + echo "-n|--noredirect" + echo " test a secondary/primary CVS server (writeproxy)" + echo " configuration with the Redirect response disabled" + echo " (implies --proxy)." + echo "-p|--proxy test a secondary/primary CVS server (writeproxy)" + echo " configuration (implies --remote)." + echo "-r|--remote test client/server, as opposed to local, CVS" + echo "-s CVS-FOR-CVS-SERVER" + echo "--server=CVS-FOR-CVS-SERVER" + echo " use CVS-FOR-CVS-SERVER as the path to the CVS SERVER" + echo " executable to be tested (defaults to CVS-TO-TEST and" + echo " implies --remote)" + echo + echo "CVS-TO-TEST the path to the CVS executable to be tested; used as" + echo " the path to the CVS client when CVS-FOR-CVS-SERVER is" + echo " specified" + echo "TESTS-TO-RUN the names of the tests to run (defaults to all tests)" + exit 2 +} + +checklongoptarg() +{ + if test "x$1" != xoptional && test -z "$OPTARG"; then + echo "option \`--$LONGOPT' requires an argument" >&2 + exit_usage + fi +} + +# See TODO list at end of file. + +# required to make this script work properly. +unset CVSREAD + +# We want to invoke a predictable set of i18n behaviors, not whatever +# the user running this script might have set. +# In particular: +# 'sort' and tabs and spaces (LC_COLLATE). +# Messages from getopt (LC_MESSAGES) (in the future, CVS itself might +# also alter its messages based on LC_MESSAGES). +LANG=C +export LANG +LC_ALL=C +export LC_ALL + +# And a few tests want a predictable umask. +umask 0002 + +# +# Initialize the test counts. +# +passed=0 +skipped=0 +warnings=0 + + + +# +# read our options +# +unset configfile +unset fromtest +unset remotehost +unset rootoptions +keep=false +linkroot=false +noredirect=false +proxy=false +remote=false +servercvs=false +skipfail=false +while getopts Hc:ef:h:klnprs:-: option ; do + # convert the long opts to short opts + if test x$option = x-; then + # remove any argument + if echo "$OPTARG" |grep = >/dev/null; then + LONGOPT=`echo "$OPTARG" |sed 's/=.*$//'` + OPTARG=`echo "$OPTARG" |sed -e 's/^.*=//'` + else + LONGOPT=$OPTARG + OPTARG= + fi + # Convert LONGOPT to lower case + LONGOPT=`echo "$LONGOPT" |sed 'y/ABCDEFGHIJKLMNOPQRSTUVWXYZ/abcdefghijklmnopqrstuvwxyz/'` + case "$LONGOPT" in + c|co|con|conf|confi|config) + option=c + checklongoptarg + ;; + f|fr|fro|from|from-|from-t|from-te|from-tes|from-test) + option=f + checklongoptarg + ;; + h) + echo "\`--h' is ambiguous. Could mean \`--help' or \`--hostname'" >&2 + exit_usage + ;; + he|hel|help) + option=H + OPTARG= + ;; + ho|hos|host|hostn|hostna|hostnam|hostname) + option=h + checklongoptarg + ;; + k|ke|kee|keep) + option=k + OPTARG= + ;; + l|li|lin|link|link-|link-r]|link-ro|link-roo|link-root) + option=l + OPTARG= + ;; + n|no|nor|nore|nored|noredi|noredir|noredire|noredirec|noredirect) + option=n + OPTARG= + ;; + p|pr|pro|prox|proxy) + option=p + OPTARG= + ;; + r|re|rem|remo|remot|remote) + option=r + OPTARG= + ;; + s) + echo "\`--s' is ambiguous. Could mean \`--server' or \`--skipfail'" >&2 + exit_usage + ;; + se|ser|serv|serve|server) + option=s + checklongoptarg + ;; + sk|ski|skip|skipf|skipfa|skipfai|skipfail) + option=e + OPTARG= + ;; + *) + option=\? + OPTARG= + esac + fi + case "$option" in + c) + configfile="$OPTARG" + ;; + e) + skipfail=: + ;; + f) + fromtest="$OPTARG" + ;; + h) + # Set a remotehost to run the remote tests on via :ext: + # Implies `-r' and assumes that $TESTDIR resolves to the same + # directory on the client and the server. + remotehost="$OPTARG" + remote=: + ;; + H) + exit_help + ;; + k) + # The -k (keep) option will eventually cause all the tests to + # leave around the contents of the /tmp directory; right now only + # some implement it. Not originally intended to be useful with + # more than one test, but this should work if each test uses a + # uniquely named dir (use the name of the test). + keep=: + ;; + l) + linkroot=: + ;; + n) + proxy=: + noredirect=: + remote=: + ;; + p) + proxy=: + remote=: + ;; + r) + remote=: + ;; + s) + servercvs="$OPTARG" + remote=: + ;; + \?) + exit_usage + ;; + esac +done + +# boot the arguments we used above +while test $OPTIND -gt 1 ; do + shift + OPTIND=`expr $OPTIND - 1` +done + +# Use full path for CVS executable, so that CVS_SERVER gets set properly +# for remote. +case $1 in +"") + exit_usage + ;; +/*) + testcvs=$1 + ;; +*) + testcvs=`pwd`/$1 + ;; +esac +shift + +# Verify that $testcvs looks like CVS. +# we can't use test -x since BSD 4.3 doesn't support it. +if test ! -f $testcvs || test ! -r $testcvs; then + echo "No such file or file not readable: $testcvs" >&2 + exit 1 +fi +if $testcvs --version </dev/null 2>/dev/null | + grep '^Concurrent Versions System' >/dev/null 2>&1; then :; else + echo "Not a CVS executable: $testcvs" >&2 + exit 1 +fi + +# If $remotehost is set, warn if $TESTDIR isn't since we are pretty sure +# that its default value of `/tmp/cvs-sanity' will not resolve to the same +# directory on two different machines. +if test -n "$remotehost" && test -z "$TESTDIR"; then + echo "WARNING: CVS server hostname is set and \$TESTDIR is not. If" >&2 + echo "$remotehost is not the local machine, then it is unlikely that" >&2 + echo "the default value assigned to \$TESTDIR will resolve to the same" >&2 + echo "directory on both this client and the CVS server." >&2 +fi + +# Read our config file if we can find it. +# +# The config file should always be located in the same directory as the CVS +# executable, unless we are testing an executable outside of the build +# directory. In this case, we echo a warning and attempt to assume the most +# portable configuration. +if test -z "$configfile"; then + configfile=`dirname $testcvs`/sanity.config.sh +fi +if test -r "$configfile"; then + . "$configfile" +else + echo "WARNING: Failed to locate test suite config file" >&2 + echo " \`$configfile'." >&2 +fi + + + +# Set a default value for $CVS_RSH. The sanity.config.sh file will +# have the configured value in the RSH_DFLT variable. +# +: ${CVS_RSH=${RSH_DFLT:-ssh}}; export CVS_RSH + +if test -n "$remotehost"; then + # Verify that $CVS_RSH $remotehost works. + result=`$CVS_RSH $remotehost 'echo test'` + if test $? != 0 || test "x$result" != "xtest"; then + echo "\`$CVS_RSH $remotehost' failed." >&2 + exit 1 + fi +fi + +case "$servercvs" in +"") + exit_usage + ;; +false) + ;; +/*) + ;; +*) + servercvs=`pwd`/$servercvs + ;; +esac + +if test false != $servercvs; then + # Allow command line to override $CVS_SERVER + CVS_SERVER=$servercvs +else + # default $CVS_SERVER to ${testcvs} + : ${CVS_SERVER=$testcvs} + # With the previous command, effectively defaults $servercvs to $CVS_SERVER, + # then $testcvs + servercvs=$CVS_SERVER +fi +export CVS_SERVER +servercvs_orig=$servercvs + +# Fail in client/server mode if our ${servercvs} does not contain server +# support. +if $remote; then + if test -n "$remotehost"; then + if $CVS_RSH $remotehost "test ! -f ${servercvs} || test ! -r ${servercvs}" + then + echo "No such file or file not readable: $remotehost:${testcvs}" >&2 + exit 1 + fi + if $CVS_RSH $remotehost "${servercvs} --version </dev/null 2>/dev/null | + grep '^Concurrent Versions System' >/dev/null 2>&1"; then :; else + echo "Not a CVS executable: $remotehost:${servercvs}" >&2 + exit 1 + fi + if $CVS_RSH $remotehost "${servercvs} --version </dev/null | + grep '^Concurrent.*(.*server)$' >/dev/null 2>&1"; then :; else + echo "CVS executable \`$remotehost:${servercvs}' does not contain server support." >&2 + exit 1 + fi + else + if test ! -f ${servercvs} || test ! -r ${servercvs}; then + echo "No such file or file not readable: ${testcvs}" >&2 + exit 1 + fi + if ${servercvs} --version </dev/null 2>/dev/null | + grep '^Concurrent Versions System' >/dev/null 2>&1; then :; else + echo "Not a CVS executable: ${servercvs}" >&2 + exit 1 + fi + if ${servercvs} --version </dev/null | + grep '^Concurrent.*(.*server)$' >/dev/null 2>&1; then :; else + echo "CVS executable \`${servercvs}' does not contain server support." >&2 + exit 1 + fi + fi +fi + +# Fail in client/server mode if our ${testcvs} does not contain client +# support. +if $remote; then + if ${testcvs} --version </dev/null | + grep '^Concurrent.*(client.*)$' >/dev/null 2>&1; then :; else + echo "CVS executable \`${testcvs}' does not contain client support." >&2 + exit 1 + fi +fi + +# For the "fork" tests. +if ${testcvs} --version </dev/null | + grep '^Concurrent.*(.*server)$' >/dev/null 2>&1 +then + testcvs_server_support=: +else + testcvs_server_support=false +fi + + + +dokeep() +{ + if ${keep}; then + echo "Keeping ${TESTDIR} for test case \`${what}' and exiting due to --keep" + exit 0 + fi +} + + + +### +### GUTS +### + +# "debugger" +#set -x + +echo 'This test should produce no other output than this message, and a final "OK".' +echo '(Note that the test can take an hour or more to run and periodically stops' +echo 'for as long as one minute. Do not assume there is a problem just because' +echo 'nothing seems to happen for a long time. If you cannot live without' +echo "running status, try the command: \`tail -f check.log' from another window.)" + +# Regexp to match what the CVS client will call itself in output that it prints. +# FIXME: we don't properly quote this--if the name contains . we'll +# just spuriously match a few things; if the name contains other regexp +# special characters we are probably in big trouble. +CPROG=`basename ${testcvs} |sed 's/\.exe$//'` +# And the regexp for the CVS server when we have one. In local mode, this +# defaults to $CPROG since $servercvs already did. +# FIXCVS: There are a few places in error messages where CVS suggests a command +# and outputs $SPROG as the suggested executable. This could hopefully use +# MT (tagged text - see doc/cvs-client.texi) to request that the client print +# its own name. +SPROG=`basename ${servercvs} |sed 's/\.exe$//'` + + +# Match the hostname +hostname="[-_.a-zA-Z0-9]*" + +# Regexp to match a commitid +commitid="[a-zA-Z0-9]*" + +# Regexp to match the name of a temporary file (from cvs_temp_name). +# This appears in certain diff output. +tempfile="cvs[-a-zA-Z0-9.%_]*" +# $tempname set after $TMPDIR, below. + +# Regexp to match a date in RFC822 format (as amended by RFC1123). +RFCDATE="[a-zA-Z0-9 ][a-zA-Z0-9 ]* [0-9:][0-9:]* -0000" +RFCDATE_EPOCH="1 Jan 1970 00:00:00 -0000" + +# Special times used in touch -t commands and the regular expresions +# to match them. Now that the tests set TZ=UTC0, it +# should be easier to be more exact in their regexp. +TOUCH1971="197107040343" +# This date regexp was 1971/07/0[3-5] [0-9][0-9]:43:[0-9][0-9] +ISO8601DATE1971="1971-07-04 03:43:[0-9][0-9] [+-]0000" + +TOUCH2034="203412251801" +# This date regexp was 2034/12/2[4-6] [0-9][0-9]:01:[0-9][0-9] +ISO8601DATE2034="2034-12-25 18:01:[0-9][0-9] [+-]0000" + +# Used in admin tests for exporting RCS files. +# The RAWRCSDATE..... format is for internal ,v files and +# the ISO8601DATE..... format is to allow for a regular expression in +# 'cvs log' output patterns. The tests that use this set of specific +# ${ISO8601DATE.....} variables also force TZ=UTC0 for the test. +RAWRCSDATE2000A="2000.11.24.15.58.37" +RAWRCSDATE1996A="96.11.24.15.57.41" +RAWRCSDATE1996B="96.11.24.15.56.05" +ISO8601DATE2000A="2000-11-24 15:58:37 [+-]0000" +ISO8601DATE1996A="1996-11-24 15:57:41 [+-]0000" +ISO8601DATE1996B="1996-11-24 15:56:05 [+-]0000" + +# Regexp to match the date in cvs log command output +# This format has been enhanced in the future to accept either +# old-style cvs log output dates or new-style ISO8601 timezone +# information similar to the ISODATE format. The RCSKEYDATE is +# similar, but uses '/' instead of '-' to sepearate year/month/day +# and does not include the optional timezone offset. +ISO8601DATE="[0-9][0-9][0-9][0-9]-[0-1][0-9]-[0-3][0-9] [0-2][0-9]:[0-6][0-9]:[0-6][0-9] [-+][0-1][0-9][0-6][0-9]" + +# Regexp to match the dates found in rcs keyword strings +RCSKEYDATE="[0-9][0-9][0-9][0-9]/[0-9][0-9]/[0-9][0-9] [0-9][0-9]:[0-9][0-9]:[0-9][0-9]" + +# Regexp to match the date in the delta section of rcs format files. +# Dates in very old RCS files may not have included the century. +RCSDELTADATE="[0-9][0-9]*\.[0-9][0-9]\.[0-9][0-9]\.[0-9][0-9]\.[0-9][0-9]\.[0-9][0-9]" + +# Regexp to match a date in standard Unix format as used by rdiff +# FIXCVS: There's no reason for rdiff to use a different date format +# than diff does +DATE="[a-zA-Z]* [a-zA-Z]* [ 1-3][0-9] [0-9:]* [0-9]*" +# ISO 8601 format "yyyy-mm-dd hh:mm -0000" +ISODATE="[0-9][0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9] [0-9][0-9]:[0-9][0-9] [+-][0-9][0-9][0-9][0-9]" +# %p format is not well defined (nil) and hex digits are common. Using +# ..* is a bad idea as the tests take a very long time to run due to +# the complexity of the expressions. If you run into any other characters +# that are used in a %p format, add them here. +PFMT="[0-9a-zA-Z()][0-9a-zA-Z()]*" + +# Which directories should Which and find_tool search for executables? +SEARCHPATH=$PATH:/usr/local/bin:/usr/contrib/bin:/usr/contrib:/usr/gnu/bin:/local/bin:/local/gnu/bin:/gnu/bin:/sw/bin:/usr/pkg/bin + +# Do not assume that `type -p cmd` is portable +# Usage: Which [-a] [-x|-f|-r] prog [$SEARCHPATH:/with/directories:/to/search] +Which() { + # Optional first argument for file type, defaults to -x. + # Second argument is the file or directory to be found. + # Third argument is the PATH to search. + # By default, print only the first file that matches, + # -a will cause all matches to be printed. + notevery=: + if [ "x$1" = "x-a" ]; then notevery=false; shift; fi + case "$1" in + -*) t=$1; shift ;; + *) t=-x ;; + esac + case "$1" in + # FIXME: Someday this may need to be fixed + # to deal better with C:\some\path\to\ssh values... + /*) test $t $1 && echo $1 ;; + *) for d in `IFS=:; echo ${2-$SEARCHPATH}` + do + test $t $d/$1 && { echo $d/$1; if $notevery; then break; fi; } + done + ;; + esac +} + + +# On cygwin32, we may not have /bin/sh. +if test -r /bin/sh; then + TESTSHELL="/bin/sh" +else + TESTSHELL=`Which -f sh` + if test ! -r "$TESTSHELL"; then + TESTSHELL="/bin/sh" + fi +fi + +# FIXME: try things (what things? checkins?) without -m. +# +# Some of these tests are written to expect -Q. But testing with +# -Q is kind of bogus, it is not the way users actually use CVS (usually). +# So new tests probably should invoke ${testcvs} directly, rather than ${CVS}. +# and then they've obviously got to do something with the output.... +# +CVS="${testcvs} -Q" + +LOGFILE=`pwd`/check.log + +# Save the previous log in case the person running the tests decides +# they want to look at it. The extension ".plog" is chosen for consistency +# with dejagnu. +test -f check.plog && mv check.plog check.plog~ +test -f check.log && mv check.log check.plog + +# Create the log file so check.log can be tailed almost immediately after +# this script is started. Otherwise it can take up to a minute or two before +# the log file gets created when $remotehost is specified on some systems, +# which makes for a lot of failed `tail -f' attempts. +touch check.log + +# Workaround any X11Forwarding by ssh. Otherwise this text: +# Warning: No xauth data; using fake authentication data for X11 forwarding. +# has been known to end up in the test results below +# causing the test to fail. +[ -n "$DISPLAY" ] && unset DISPLAY + +# The default value of /tmp/cvs-sanity for TESTDIR is dubious, +# because it loses if two people/scripts try to run the tests +# at the same time. Some possible solutions: +# 1. Use /tmp/cvs-test$$. One disadvantage is that the old +# cvs-test* directories would pile up, because they wouldn't +# necessarily get removed. +# 2. Have everyone/everything running the testsuite set +# TESTDIR to some appropriate directory. +# 3. Have the default value of TESTDIR be some variation of +# `pwd`/cvs-sanity. The biggest problem here is that we have +# been fairly careful to test that CVS prints in messages the +# actual pathnames that we pass to it, rather than a different +# pathname for the same directory, as may come out of `pwd`. +# So this would be lost if everything was `pwd`-based. I suppose +# if we wanted to get baroque we could start making symlinks +# to ensure the two are different. +if test -n "$remotehost"; then + # We need to set $tmp on the server since $TMPDIR is compared against + # messages generated by the server. + tmp=`$CVS_RSH $remotehost 'cd /tmp; /bin/pwd || pwd' 2>/dev/null` + if test $? != 0; then + echo "$CVS_RSH $remotehost failed." >&2 + exit 1 + fi +else + tmp=`(cd /tmp; /bin/pwd || pwd) 2>/dev/null` +fi + +# Now: +# 1) Set TESTDIR if it's not set already +# 2) Remove any old test remnants +# 3) Create $TESTDIR +# 4) Normalize TESTDIR with `cd && (/bin/pwd || pwd)` +# (This will match CVS output later) +: ${TESTDIR=$tmp/cvs-sanity} +# clean any old remnants (we need the chmod because some tests make +# directories read-only) +if test -d $TESTDIR; then + chmod -R a+wx $TESTDIR + rm -rf $TESTDIR +fi +# These exits are important. The first time I tried this, if the `mkdir && cd` +# failed then the build directory would get blown away. Some people probably +# wouldn't appreciate that. +mkdir $TESTDIR || exit 1 +cd $TESTDIR || exit 1 +# Ensure $TESTDIR is absolute +if echo "$TESTDIR" |grep '^[^/]'; then + # Don't resolve this unless we have to. This keeps symlinks intact. This + # is important at least when testing using -h $remotehost, because the same + # value for $TESTDIR must resolve to the same directory on the client and + # the server and we likely used Samba, and possibly symlinks, to do this. + TESTDIR=`(/bin/pwd || pwd) 2>/dev/null` +fi + +if test -z "$TESTDIR" || echo "$TESTDIR" |grep '^[^/]'; then + echo "Unable to resolve TESTDIR to an absolute directory." >&2 + exit 1 +fi +cd $TESTDIR + + + +: ${TIMING=false} +if $remote; then + # Now override our CVS_RSH in order to forward variables which affect the + # test suite through. This always needs to be done when $remotehost is + # set, needs to be done in $proxy mode for the crerepos tests, and needs to + # be done in $remote mode for the writeproxy-ssh tests. + if $TIMING; then + time="/usr/bin/time -ao'$TESTDIR/time.out'" + else + time= + fi + cat >$TESTDIR/ssh-wrapper-env <<EOF +#! $TESTSHELL +while [ \$# -gt 0 ] +do + case "\$1" in + *=*) + eval "\$1" + var=\`echo "\$1" | sed 's/^\\(.*\\)=.*\$/\\1/'\` + export \$var + ;; + *) break;; + esac + shift +done +exec \${1+"\$@"} +EOF + chmod a+x $TESTDIR/ssh-wrapper-env + cat >$TESTDIR/ssh-wrapper <<EOF +#! $TESTSHELL +hostname=\$1 +shift +exec \ +$CVS_RSH \ + \$hostname \ + $TESTDIR/ssh-wrapper-env \ + "CVS_SERVER='\$CVS_SERVER'" \ + "CVS_SERVER_SLEEP='\$CVS_SERVER_SLEEP'" \ + "CVS_PARENT_SERVER_SLEEP='\$CVS_PARENT_SERVER_SLEEP'" \ + "CVS_SERVER_LOG='\$CVS_SERVER_LOG'" \ + "CVS_SECONDARY_LOG='\$CVS_SECONDARY_LOG'" \ + "TMPDIR='\$TMPDIR'" \ + "CVS_RSH='$TESTDIR/ssh-wrapper'" \ + "CVSUMASK='\$CVSUMASK'" \ + "CVS_PID='\$CVS_PID'" \ + $time \ + \${1+"\$@"} +EOF + chmod a+x $TESTDIR/ssh-wrapper + CVS_RSH=$TESTDIR/ssh-wrapper +fi # $remotehost + + + +# Now set $TMPDIR if the user hasn't overridden it. +# +# We use a $TMPDIR under $TESTDIR by default so that two tests may be run at +# the same time without bumping heads without requiring the user to specify +# more than $TESTDIR. See the test for leftover cvs-serv* directories near the +# end of this script at the end of "The big loop". +: ${TMPDIR=$TESTDIR/tmp} +export TMPDIR +if test -d $TMPDIR; then :; else + mkdir $TMPDIR +fi + + +# Regexp to match the the full path to a temporary file (from cvs_temp_name). +# This appears in certain diff output. +tempname=$TMPDIR/$tempfile + +# Make sure various tools work the way we expect, or try to find +# versions that do. +: ${AWK=awk} +: ${EXPR=expr} +: ${ID=id} +: ${TR=tr} + +# Keep track of tools that are found, but do NOT work as we hope +# in order to avoid them in future +badtools= +set_bad_tool () +{ + badtools=$badtools:$1 +} +is_bad_tool () +{ + case ":$badtools:" in *:$1:*) return 0 ;; *) return 1 ; esac +} + +version_test () +{ + vercmd=$1 + verbad=: + if RES=`$vercmd --version </dev/null 2>&1`; then + if test "X$RES" != "X--version" && test "X$RES" != "X" ; then + echo "$RES" + verbad=false + fi + fi + if $verbad; then + echo "The command \`$vercmd' does not support the --version option." + fi + # It does not really matter that --version is not supported + return 0 +} + +# Try to find a tool that satisfies all of the tests. +# Usage: list:of:colon:separated:alternatives test1 test2 test3 test4... +# Example: find_tool awk:gawk:nawk awk_tooltest1 awk_tooltest2 +find_tool () +{ + default_TOOL=$1 + echo find_tool: ${1+"$@"} >>$LOGFILE + cmds="`IFS=:; echo $1`"; shift; tooltests="${1+$@}" + if test -z "$tooltests"; then tooltests=version_test; fi + clist=; for cmd in $cmds; do clist="$clist `Which -a $cmd`"; done + # Make sure the default tool is just the first real command name + for default_TOOL in $clist `IFS=:; echo $default_TOOL`; do break; done + TOOL="" + for trytool in $clist ; do + pass=: + for tooltest in $tooltests; do + result=`eval $tooltest $trytool` + rc=$? + echo "Running $tooltest $trytool" >>$LOGFILE + if test -n "$result"; then + echo "$result" >>$LOGFILE + fi + if test "$rc" = "0"; then + echo "PASS: $tooltest $trytool" >>$LOGFILE + elif test "$rc" = "77"; then + echo "MARGINAL: $tooltest $trytool; rc=$rc" >>$LOGFILE + TOOL=$trytool + pass=false + else + set_bad_tool $trytool + echo "FAIL: $tooltest $trytool; rc=$rc" >>$LOGFILE + pass=false + fi + done + if $pass; then + echo $trytool + return 0 + fi + done + if test -n "$TOOL"; then + echo "Notice: The default version of \`$default_TOOL' is defective." >>$LOGFILE + echo "using \`$TOOL' and hoping for the best." >>$LOGFILE + echo "Notice: The default version of \`$default_TOOL' is defective." >&2 + echo "using \`$TOOL' and hoping for the best." >&2 + echo $TOOL + else + echo $default_TOOL + fi +} + +id_tool_test () +{ + id=$1 + if $id -u >/dev/null 2>&1 && $id -un >/dev/null 2>&1; then + return 0 + else + echo "Running these tests requires an \`id' program that understands the" + echo "-u and -n flags. Make sure that such an id (GNU, or many but not" + echo "all vendor-supplied versions) is in your path." + return 1 + fi +} + +ID=`find_tool id version_test id_tool_test` +echo "Using ID=$ID" >>$LOGFILE + +# You can't run CVS as root; print a nice error message here instead +# of somewhere later, after making a mess. +for pass in false :; do + case "`$ID -u 2>/dev/null`" in + "0") + echo "Test suite does not work correctly when run as root" >&2 + exit 1 + ;; + + *) + break + ;; + esac +done + +# Cause NextStep 3.3 users to lose in a more graceful fashion. +expr_tooltest1 () +{ +expr=$1 +if $expr 'abc +def' : 'abc +def' >/dev/null; then + # good, it works + return 0 +else + echo 'Running these tests requires an "expr" program that can handle' + echo 'multi-line patterns. Make sure that such an expr (GNU, or many but' + echo 'not all vendor-supplied versions) is in your path.' + return 1 +fi +} + +# Warn SunOS, SysVr3.2, etc., users that they may be partially losing +# if we can't find a GNU expr to ease their troubles... +expr_tooltest2 () +{ +expr=$1 +if $expr 'a +b' : 'a +c' >/dev/null; then + echo 'Warning: you are using a version of expr that does not correctly' + echo 'match multi-line patterns. Some tests may spuriously pass or fail.' + echo 'You may wish to make sure GNU expr is in your path.' + return 1 +else + return 0 +fi +} + +expr_create_bar () +{ +echo 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ' >${TESTDIR}/foo +cat ${TESTDIR}/foo ${TESTDIR}/foo ${TESTDIR}/foo ${TESTDIR}/foo >${TESTDIR}/bar +cat ${TESTDIR}/bar ${TESTDIR}/bar ${TESTDIR}/bar ${TESTDIR}/bar >${TESTDIR}/foo +cat ${TESTDIR}/foo ${TESTDIR}/foo ${TESTDIR}/foo ${TESTDIR}/foo >${TESTDIR}/bar +rm -f ${TESTDIR}/foo +} + +expr_tooltest3 () +{ +expr=$1 +# More SunOS lossage... +test ! -f ${TESTDIR}/bar && expr_create_bar +if $expr "`cat ${TESTDIR}/bar`" : "`cat ${TESTDIR}/bar`" >/dev/null; then + : good, it works +else + echo 'Warning: you are using a version of expr that does not correctly' + echo 'match large patterns. Some tests may spuriously pass or fail.' + echo 'You may wish to make sure GNU expr is in your path.' + return 1 +fi +if $expr "`cat ${TESTDIR}/bar`x" : "`cat ${TESTDIR}/bar`y" >/dev/null; then + echo 'Warning: you are using a version of expr that does not correctly' + echo 'match large patterns. Some tests may spuriously pass or fail.' + echo 'You may wish to make sure GNU expr is in your path.' + return 1 +fi +# good, it works +return 0 +} + +# That we should have to do this is total bogosity, but GNU expr +# version 1.9.4-1.12 uses the emacs definition of "$" instead of the unix +# (e.g. SunOS 4.1.3 expr) one. Rumor has it this will be fixed in the +# next release of GNU expr after 1.12 (but we still have to cater to the old +# ones for some time because they are in many linux distributions). +ENDANCHOR="$" +expr_set_ENDANCHOR () +{ +expr=$1 +ENDANCHOR="$" +if $expr 'abc +def' : 'abc$' >/dev/null; then + ENDANCHOR='\'\' + echo "Notice: An ENDANCHOR of dollar does not work." + echo "Using a workaround for GNU expr versions 1.9.4 thru 1.12" +fi +return 0 +} + +# Work around another GNU expr (version 1.10-1.12) bug/incompatibility. +# "." doesn't appear to match a newline (it does with SunOS 4.1.3 expr). +# Note that the workaround is not a complete equivalent of .* because +# the first parenthesized expression in the regexp must match something +# in order for expr to return a successful exit status. +# Rumor has it this will be fixed in the +# next release of GNU expr after 1.12 (but we still have to cater to the old +# ones for some time because they are in many linux distributions). +DOTSTAR='.*' +expr_set_DOTSTAR () +{ +expr=$1 +DOTSTAR='.*' +if $expr 'abc +def' : "a${DOTSTAR}f" >/dev/null; then + : good, it works +else + DOTSTAR='\(.\| +\)*' + echo "Notice: DOTSTAR changed from sane \`.*' value to \`$DOTSTAR\`" + echo "to workaround GNU expr version 1.10 thru 1.12 bug where \`.'" + echo "does not match a newline." +fi +return 0 +} + +# Now that we have DOTSTAR, make sure it works with big matches +expr_tooltest_DOTSTAR () +{ +expr=$1 +test ! -f ${TESTDIR}/bar && expr_create_bar +if $expr "`cat ${TESTDIR}/bar`" : "${DOTSTAR}xyzABC${DOTSTAR}$" >/dev/null; then + # good, it works + return 0 +else + echo 'Warning: you are using a version of expr that does not correctly' + echo 'match large patterns. Some tests may spuriously pass or fail.' + echo 'You may wish to make sure GNU expr is in your path.' + return 77 +fi +} + +EXPR=`find_tool ${EXPR}:gexpr \ + version_test expr_tooltest1 expr_tooltest2 expr_tooltest3 \ +expr_set_ENDANCHOR expr_set_DOTSTAR expr_tooltest_DOTSTAR` + +# Set the ENDANCHOR and DOTSTAR for the chosen expr version. +expr_set_ENDANCHOR ${EXPR} >/dev/null +expr_tooltest_DOTSTAR ${EXPR} >/dev/null + +echo "Using EXPR=$EXPR" >>$LOGFILE +echo "Using ENDANCHOR=$ENDANCHOR" >>$LOGFILE +echo "Using DOTSTAR=$DOTSTAR" >>$LOGFILE + +# Cleanup +rm -f ${TESTDIR}/bar + +# Work around yet another GNU expr (version 1.10) bug/incompatibility. +# "+" is a special character, yet for unix expr (e.g. SunOS 4.1.3) +# it is not. I doubt that POSIX allows us to use \+ and assume it means +# (non-special) +, so here is another workaround +# Rumor has it this will be fixed in the +# next release of GNU expr after 1.12 (but we still have to cater to the old +# ones for some time because they are in many linux distributions). +PLUS='+' +if $EXPR 'a +b' : "a ${PLUS}b" >/dev/null; then + : good, it works +else + PLUS='\+' +fi + +# Likewise, for ? +QUESTION='?' +if $EXPR 'a?b' : "a${QUESTION}b" >/dev/null; then + : good, it works +else + QUESTION='\?' +fi + +# Now test the username to make sure it contains only valid characters +username=`$ID -un` +if $EXPR "${username}" : "${username}" >/dev/null; then + : good, it works +else + echo "Test suite does not work correctly when run by a username" >&2 + echo "containing regular expression meta-characters." >&2 + exit 1 +fi + +# Only 8 characters of $username appear in some output. +if test `echo $username |wc -c` -gt 8; then + username8=`echo $username |sed 's/^\(........\).*/\1/'` +else + username8=$username +fi + +# Rarely, we need to match any username, not just the name of the user +# running this test. This variable usually shouldn't be used. $username +# contains the name of the user actually running this test. +# +# I believe this only ever actually gets compared to usernames created by this +# test. It used to be compared to the username of the user running this test, +# but this hasn't been true for a long time. Regardless, I tried to get the +# allowed character set right, based on a list in a private email from Mark +# Baushke, basically the allowed names from Linux systems (plus `.', which is +# only allowed on Gentoo Linux as of 2005-09-13). +anyusername="[_a-zA-Z0-9][-_.$a-zA-Z0-9]*" + +# now make sure that tr works on NULs +tr_tooltest1 () +{ +tr=$1 +if $EXPR `echo "123" | $tr '2' '\0'` : "123" >/dev/null 2>&1; then + echo 'Warning: you are using a version of tr which does not correctly' + echo 'handle NUL bytes. Some tests may spuriously pass or fail.' + echo 'You may wish to make sure GNU tr is in your path.' + return 77 +fi +# good, it works +return 0 +} + +TR=`find_tool ${TR}:gtr version_test tr_tooltest1` +echo "Using TR=$TR" >>$LOGFILE + +# MacOS X (10.2.8) has a /bin/ls that does not work correctly in that +# it will return true even if the wildcard argument does not match any +# files. +ls_tooltest () +{ +ls=$1 +# Force cleanup +if test -d $TESTDIR/ls-test; then + chmod -R a+wx $TESTDIR/ls-test + rm -rf $TESTDIR/ls-test +fi +if $ls $TESTDIR/ls-test >/dev/null 2>&1; then + echo "Notice: \`$ls' is defective." + echo 'This is a version of ls which does not correctly' + echo 'return false for files that do not exist. Some tests may' + echo 'spuriously pass or fail.' + echo 'You may wish to put a an ls from GNU coreutils into your path.' + return 77 +else + return 0 +fi +} +LS=`find_tool ls:gls version_test ls_tooltest` +echo "Using LS=$LS" >>$LOGFILE + +# Awk testing + +awk_tooltest1 () +{ +awk=$1 +$awk 'BEGIN {printf("one\ntwo\nthree\nfour\nfive\nsix")}' </dev/null >abc +if $EXPR "`cat abc`" : \ +'one +two +three +four +five +six'; then + rm abc + return 0 +else + rm abc + echo "Notice: awk BEGIN clause or printf is not be working properly." + return 1 +fi +} + +# Format item %c check +awk_tooltest2 () +{ +awk=$1 +$awk 'BEGIN { printf "%c%c%c", 2, 3, 4 }' </dev/null \ + | ${TR} '\002\003\004' '123' >abc +if $EXPR "`cat abc`" : "123" ; then + : good, found it +else + echo "Notice: awk format %c string may not be working properly." + rm abc + return 77 +fi +rm abc +return 0 +} + +AWK=`find_tool gawk:nawk:awk version_test awk_tooltest1 awk_tooltest2` +echo "Using AWK=$AWK" >>$LOGFILE + + +### +### Functions used by tests. +### + +# Execute a command on the repository, syncing when done if necessary. +# +# Syntax is as `eval'. +modify_repo () +{ + eval "$*" + if $proxy; then + # And now resync the secondary. + $TESTDIR/sync-secondary "repo modification" modify_repo ALL "$@" + fi +} + +# Restore changes to CVSROOT admin files. +restore_adm () +{ + modify_repo rm -rf $CVSROOT_DIRNAME/CVSROOT + modify_repo cp -Rp $TESTDIR/CVSROOT.save $CVSROOT_DIRNAME/CVSROOT +} + +# Test that $RSYNC supports the options we need or try to find a +# replacement. If $RSYNC works or we replace it, and return 0. +# Otherwise, set $skipreason and return 77. +require_rsync () +{ + rsyncworks=false + # rsync is NOT a GNU tool, so do NOT use find_tool for name munging. + for rsync in ${RSYNC} `Which -a rsync`; + do + + if is_bad_tool `Which $rsync` ; then continue ; fi + # Make some data to test rsync on. + mkdir $TESTDIR/rsync-test + mkdir $TESTDIR/rsync-test/Attic && touch $TESTDIR/rsync-test/Attic/6 + mkdir $TESTDIR/rsync-test/otherdir && touch $TESTDIR/rsync-test/otherdir/7 + for file in 1 2 3 4 5; do + touch $TESTDIR/rsync-test/$file + done + + if test -f "$rsync" && test -r "$rsync" \ + && $rsync -rglop --delete $TESTDIR/rsync-test/ $TESTDIR/rsync-test-copy \ + >/dev/null 2>&1 \ + && $rsync -rglop --delete --include Attic --exclude '*/' \ + $TESTDIR/rsync-test/ $TESTDIR/rsync-test-copy2 \ + >/dev/null 2>&1 \ + && test -f $TESTDIR/rsync-test/5 \ + && mv $TESTDIR/rsync-test/5 $TESTDIR/rsync-test/Attic/5 \ + && test -f $TESTDIR/rsync-test-copy/Attic/6 \ + && $rsync -rglop --delete $TESTDIR/rsync-test/ $TESTDIR/rsync-test-copy \ + >/dev/null 2>&1 \ + && $rsync -rglop --delete --include Attic --exclude '*/' \ + $TESTDIR/rsync-test/ $TESTDIR/rsync-test-copy2 \ + >/dev/null 2>&1 \ + && test ! -f $TESTDIR/rsync-test-copy/5 \ + && test ! -f $TESTDIR/rsync-test-copy2/5 \ + && test -f $TESTDIR/rsync-test-copy2/Attic/5 \ + && test ! -f $TESTDIR/rsync-test-copy2/otherdir/7 + then + # good, it works + rsyncworks=: + RSYNC=$rsync + else + # Only use Which because of ${RSYNC} in the for loop. + set_bad_tool `Which $rsync` + fi + + rm -rf $TESTDIR/rsync-test $TESTDIR/rsync-test-copy \ + $TESTDIR/rsync-test-copy2 + + if $rsyncworks; then + return 0 + else + (echo $rsync failed to work properly;\ + echo "$rsync --version"; $rsync --version) >>$LOGFILE 2>&1 + fi + done + + unset RSYNC + skipreason="unusable or no rsync found" + return 77 +} + +# Test that $1 works as a remote shell. If so, set $host, $CVS_RSH, & +# $save_CVS_RSH to match and return 0. Otherwise, set $skipreason and return +# 77. +require_rsh () +{ + host=${remotehost-"`hostname`"} + result=`$1 $host 'echo test'` + rc=$? + if test $? != 0 || test "x$result" != "xtest"; then + skipreason="\`$1 $host' failed rc=$rc result=$result" + return 77 + fi + + save_CVS_RSH=$CVS_RSH + CVS_RSH=$1; export CVS_RSH + return 0 +} + +# Find a usable SSH. When a usable ssh is found, set $host, $CVS_RSH, and +# $save_CVS_RSH and return 0. Otherwise, set $skipreason and return 77. +require_ssh () +{ + case "$CVS_RSH" in + *ssh*|*putty*) + tryssh=`Which $CVS_RSH` + if [ ! -n "$tryssh" ]; then + skipreason="Unable to find CVS_RSH=$CVS_RSH executable" + return 77 + elif [ ! -x "$tryssh" ]; then + skipreason="Unable to execute $tryssh program" + return 77 + fi + ;; + *) + # Look in the user's PATH for "ssh" + tryssh=`Which ssh` + if test ! -r "$tryssh"; then + skipreason="Unable to find ssh program" + return 77 + fi + ;; + esac + + require_rsh "$tryssh" + return $? +} + +pass () +{ + echo "PASS: $1" >>${LOGFILE} + passed=`expr $passed + 1` +} + +# Like skip(), but don't fail when $skipfail is set. +skip_always () +{ + echo "SKIP: $1${2+ ($2)}" >>$LOGFILE + skipped=`expr $skipped + 1` +} + +skip () +{ + if $skipfail; then + # exits + fail "$1${2+ ($2)}" + fi + + skip_always ${1+"$@"} +} + +# Convenience function for skipping tests run only in remote mode. +remoteonly () +{ + skip_always $1 "only tested in remote mode" +} + +# Convenience function for skipping tests not run in proxy mode. +notproxy () +{ + skip_always $1 "not tested in proxy mode" +} + +# Convenience function for skipping tests not run in proxy mode. +notnoredirect () +{ + skip_always $1 "not tested in proxy-noredirect mode" +} + +warn () +{ + if $skipfail; then + fail "$1${2+ ($2)}" + else + echo "WARNING: $1${2+ ($2)}" >>$LOGFILE + fi + warnings=`expr $warnings + 1` +} + +fail () +{ + echo "FAIL: $1" | tee -a ${LOGFILE} + echo "*** Please see the \`TESTS' and \`check.log' files for more information." >&2 + # This way the tester can go and see what remnants were left + exit 1 +} + +verify_tmp_empty () +{ + # Test our temp directory for cvs-serv* directories and cvsXXXXXX temp + # files. We would like to not leave any behind. + if $remote && $LS $TMPDIR/cvs-serv* >/dev/null 2>&1; then + # A true value means ls found files/directories with these names. + # Give the server some time to finish, then retry. + sleep 1 + if $LS $TMPDIR/cvs-serv* >/dev/null 2>&1; then + warn "$1" "Found cvs-serv* directories in $TMPDIR." + # The above will exit if $skipfail + rm -rf $TMPDIR/cvs-serv* + fi + fi + if $LS $TMPDIR/cvs?????? >/dev/null 2>&1; then + # A true value means ls found files/directories with these names. + warn "$1" "Found cvsXXXXXX temp files in $TMPDIR." + # The above will exit if $skipfail + rm -f ls $TMPDIR/cvs?????? + fi +} + +# See dotest and dotest_fail for explanation (this is the parts +# of the implementation common to the two). +dotest_internal () +{ + if $EXPR "`cat ${TESTDIR}/dotest.tmp`" : "$3${ENDANCHOR}" >/dev/null; then + # Why, I hear you ask, do we write this to the logfile + # even when the test passes? The reason is that the test + # may give us the regexp which we were supposed to match, + # but sometimes it may be useful to look at the exact + # text which was output. For example, suppose one wants + # to grep for a particular warning, and make _sure_ that + # CVS never hits it (even in cases where the tests might + # match it with .*). Or suppose one wants to see the exact + # date format output in a certain case (where the test will + # surely use a somewhat non-specific pattern). + cat ${TESTDIR}/dotest.tmp >>${LOGFILE} + pass "$1" + verify_tmp_empty "$1" + # expr can't distinguish between "zero characters matched" and "no match", + # so special-case it. + elif test -z "$3" && test ! -s ${TESTDIR}/dotest.tmp; then + pass "$1" + verify_tmp_empty "$1" + elif test x"$4" != x; then + if $EXPR "`cat ${TESTDIR}/dotest.tmp`" : "$4${ENDANCHOR}" >/dev/null; then + cat ${TESTDIR}/dotest.tmp >>${LOGFILE} + pass "$1" + verify_tmp_empty "$1" + else + echo "** expected: " >>${LOGFILE} + echo "$3" >>${LOGFILE} + echo "$3" > ${TESTDIR}/dotest.ex1 + echo "** or: " >>${LOGFILE} + echo "$4" >>${LOGFILE} + echo "$4" > ${TESTDIR}/dotest.ex2 + echo "** got: " >>${LOGFILE} + cat ${TESTDIR}/dotest.tmp >>${LOGFILE} + fail "$1" + fi + else + echo "** expected: " >>${LOGFILE} + echo "$3" >>${LOGFILE} + echo "$3" > ${TESTDIR}/dotest.exp + echo "** got: " >>${LOGFILE} + cat ${TESTDIR}/dotest.tmp >>${LOGFILE} + fail "$1" + fi +} + +dotest_all_in_one () +{ + if $EXPR "`cat ${TESTDIR}/dotest.tmp`" : \ + "`cat ${TESTDIR}/dotest.exp`" >/dev/null; then + return 0 + fi + return 1 +} + +# WARNING: this won't work with REs that match newlines.... +# +dotest_line_by_line () +{ + line=1 + while [ $line -le `wc -l <${TESTDIR}/dotest.tmp` ] ; do + if $EXPR "`sed -n ${line}p ${TESTDIR}/dotest.tmp`" : \ + "`sed -n ${line}p ${TESTDIR}/dotest.exp`" >/dev/null; then + : + elif test -z "`sed -n ${line}p ${TESTDIR}/dotest.tmp`" && + test -z "`sed -n ${line}p ${TESTDIR}/dotest.exp`"; then + : + else + echo "Line $line:" >> ${LOGFILE} + echo "**** expected: " >>${LOGFILE} + sed -n ${line}p ${TESTDIR}/dotest.exp >>${LOGFILE} + echo "**** got: " >>${LOGFILE} + sed -n ${line}p ${TESTDIR}/dotest.tmp >>${LOGFILE} + unset line + return 1 + fi + line=`expr $line + 1` + done + unset line + return 0 +} + +# If you are having trouble telling which line of a multi-line +# expression is not being matched, replace calls to dotest_internal() +# with calls to this function: +# +dotest_internal_debug () +{ + if test -z "$3"; then + if test -s ${TESTDIR}/dotest.tmp; then + echo "** expected: " >>${LOGFILE} + echo "$3" >>${LOGFILE} + echo "$3" > ${TESTDIR}/dotest.exp + rm -f ${TESTDIR}/dotest.ex2 + echo "** got: " >>${LOGFILE} + cat ${TESTDIR}/dotest.tmp >>${LOGFILE} + fail "$1" + else + pass "$1" + verify_tmp_empty "$1" + fi + else + echo "$3" > ${TESTDIR}/dotest.exp + if dotest_line_by_line "$1" "$2"; then + pass "$1" + verify_tmp_empty "$1" + else + if test x"$4" != x; then + mv ${TESTDIR}/dotest.exp ${TESTDIR}/dotest.ex1 + echo "$4" > ${TESTDIR}/dotest.exp + if dotest_line_by_line "$1" "$2"; then + pass "$1" + verify_tmp_empty "$1" + else + mv ${TESTDIR}/dotest.exp ${TESTDIR}/dotest.ex2 + echo "** expected: " >>${LOGFILE} + echo "$3" >>${LOGFILE} + echo "** or: " >>${LOGFILE} + echo "$4" >>${LOGFILE} + echo "** got: " >>${LOGFILE} + cat ${TESTDIR}/dotest.tmp >>${LOGFILE} + fail "$1" + fi + else + echo "** expected: " >>${LOGFILE} + echo "$3" >>${LOGFILE} + echo "** got: " >>${LOGFILE} + cat ${TESTDIR}/dotest.tmp >>${LOGFILE} + fail "$1" + fi + fi + fi +} + +# This function allows the test output to be filtered before being verified. +# The dotest_* functions all call this function, which runs the command +# in the env var $TEST_FILTER on its argument if $TEST_FILTER is set. If +# $TEST_FILTER is not set, this function does nothing. +# +# I found this primarily useful when running the test suite on a CVS +# executable linked with memory and function profilers which can generate +# spurious output. +run_filter () +{ + if test -n "$TEST_FILTER"; then + # Make sure there is an EOL + echo >>$1 + sed '${/^$/d}' <$1 >$1.filter1 + # Run the filter + eval "$TEST_FILTER" <$1.filter1 >$1.filter2 + diff -u $1 $1.filter2 \ + >$1.diff + mv $1.filter2 $1 + rm $1.filter1 + fi +} + +# Usage: +# dotest TESTNAME COMMAND OUTPUT [OUTPUT2] +# TESTNAME is the name used in the log to identify the test. +# COMMAND is the command to run; for the test to pass, it exits with +# exitstatus zero. +# OUTPUT is a regexp which is compared against the output (stdout and +# stderr combined) from the test. It is anchored to the start and end +# of the output, so should start or end with ".*" if that is what is desired. +# Trailing newlines are stripped from the command's actual output before +# matching against OUTPUT. +# If OUTPUT2 is specified and the output matches it, then it is also +# a pass (partial workaround for the fact that some versions of expr +# lack \|). +dotest () +{ + rm -f $TESTDIR/dotest.ex? 2>&1 + eval "$2" >$TESTDIR/dotest.tmp 2>&1 + status=$? + run_filter $TESTDIR/dotest.tmp + if test "$status" != 0; then + cat $TESTDIR/dotest.tmp >>$LOGFILE + echo "exit status was $status" >>${LOGFILE} + fail "$1" + fi + dotest_internal "$@" +} + +# Like dotest except only 2 args and result must exactly match stdin +dotest_lit () +{ + rm -f $TESTDIR/dotest.ex? 2>&1 + eval "$2" >$TESTDIR/dotest.tmp 2>&1 + status=$? + run_filter $TESTDIR/dotest.tmp + if test "$status" != 0; then + cat $TESTDIR/dotest.tmp >>$LOGFILE + echo "exit status was $status" >>$LOGFILE + fail "$1" + fi + cat >$TESTDIR/dotest.exp + if cmp $TESTDIR/dotest.exp $TESTDIR/dotest.tmp >/dev/null 2>&1; then + pass "$1" + verify_tmp_empty "$1" + else + echo "** expected: " >>$LOGFILE + cat $TESTDIR/dotest.exp >>$LOGFILE + echo "** got: " >>$LOGFILE + cat $TESTDIR/dotest.tmp >>$LOGFILE + fail "$1" + fi +} + +# Like dotest except exitstatus should be nonzero. +dotest_fail () +{ + rm -f $TESTDIR/dotest.ex? 2>&1 + eval "$2" >$TESTDIR/dotest.tmp 2>&1 + status=$? + run_filter $TESTDIR/dotest.tmp + if test "$status" = 0; then + cat $TESTDIR/dotest.tmp >>$LOGFILE + echo "exit status was $status" >>$LOGFILE + fail "$1" + fi + dotest_internal "$@" +} + +# Like dotest except output is sorted. +dotest_sort () +{ + rm -f $TESTDIR/dotest.ex? 2>&1 + eval "$2" >$TESTDIR/dotest.tmp1 2>&1 + status=$? + run_filter $TESTDIR/dotest.tmp1 + if test "$status" != 0; then + cat $TESTDIR/dotest.tmp1 >>$LOGFILE + echo "exit status was $status" >>$LOGFILE + fail "$1" + fi + $TR ' ' ' ' < $TESTDIR/dotest.tmp1 | sort > $TESTDIR/dotest.tmp + dotest_internal "$@" +} + +# Like dotest_fail except output is sorted. +dotest_fail_sort () +{ + rm -f $TESTDIR/dotest.ex? 2>&1 + eval "$2" >$TESTDIR/dotest.tmp1 2>&1 + status=$? + run_filter $TESTDIR/dotest.tmp1 + if test "$status" = 0; then + cat $TESTDIR/dotest.tmp1 >>$LOGFILE + echo "exit status was $status" >>$LOGFILE + fail "$1" + fi + $TR ' ' ' ' < $TESTDIR/dotest.tmp1 | sort > $TESTDIR/dotest.tmp + dotest_internal "$@" +} + +# A function for fetching the timestamp of a revison of a file +getrlogdate () { + ${testcvs} -n rlog -N ${1+"$@"} | + while read token value; do + case "$token" in + date:) + echo $value | sed "s,;.*,," + break; + ;; + esac + done +} + +# Avoid picking up any stray .cvsrc, etc., from the user running the tests +mkdir home +HOME=$TESTDIR/home; export HOME + +# Make sure this variable is not defined to anything that would +# change the format of rcs dates. Otherwise people using e.g., +# RCSINIT=-zLT get lots of spurious failures. +RCSINIT=; export RCSINIT + +# Remaining arguments are the names of tests to run. +# +# The testsuite is broken up into (hopefully manageably-sized) +# independently runnable tests, so that one can quickly get a result +# from a cvs or testsuite change, and to facilitate understanding the +# tests. + +if test x"$*" = x; then + # Basic/miscellaneous functionality + tests="version basica basicb basicc basic1 deep basic2 ls" + tests="$tests parseroot parseroot2 parseroot3 files spacefiles" + tests="${tests} commit-readonly commit-add-missing" + tests="${tests} status" + # Branching, tagging, removing, adding, multiple directories + tests="${tests} rdiff rdiff-short" + tests="${tests} rdiff2 diff diffnl death death2" + tests="${tests} rm-update-message rmadd rmadd2 rmadd3 resurrection" + tests="${tests} dirs dirs2 branches branches2 branches3" + tests="${tests} branches4 tagc tagf tag-space" + tests="${tests} rcslib multibranch import importb importc importX" + tests="$tests importX2 import-CVS import-quirks" + tests="${tests} update-p import-after-initial branch-after-import" + tests="${tests} join join2 join3 join4 join5 join6 join7" + tests="${tests} join-readonly-conflict join-admin join-admin-2" + tests="${tests} join-rm" + tests="${tests} new newb conflicts conflicts2 conflicts3" + tests="${tests} clean" + tests="${tests} keywordexpand" + # Checking out various places (modules, checkout -d, &c) + tests="${tests} modules modules2 modules3 modules4 modules5 modules6" + tests="${tests} modules7 mkmodules co-d" + tests="${tests} cvsadm emptydir abspath abspath2 toplevel toplevel2" + tests="${tests} rstar-toplevel trailingslashes checkout_repository" + # Log messages, error messages. + tests="${tests} mflag editor env errmsg1 errmsg2 adderrmsg opterrmsg" + tests="${tests} errmsg3" + tests="${tests} close-stdout" + tests="$tests debug-log-nonfatal" + # Watches, binary files, history browsing, &c. + tests="${tests} devcom devcom2 devcom3 watch4 watch5 watch6-0 watch6" + tests="${tests} edit-check" + tests="${tests} unedit-without-baserev" + tests="${tests} ignore ignore-on-branch binfiles binfiles2 binfiles3" + tests="${tests} mcopy binwrap binwrap2" + tests="${tests} binwrap3 mwrap info taginfo posttag" + tests="$tests config config2 config3 config4" + tests="${tests} serverpatch log log2 logopt ann ann-id" + # Repository Storage (RCS file format, CVS lock files, creating + # a repository without "cvs init", &c). + tests="${tests} crerepos rcs rcs2 rcs3 rcs4 rcs5" + tests="$tests lockfiles backuprecover" + tests="${tests} sshstdio" + # More history browsing, &c. + tests="${tests} history" + tests="${tests} big modes modes2 modes3 stamps" + # PreservePermissions stuff: permissions, symlinks et al. + # tests="${tests} perms symlinks symlinks2 hardlinks" + # More tag and branch tests, keywords. + tests="${tests} sticky keyword keywordlog keywordname keyword2" + tests="${tests} head tagdate multibranch2 tag8k" + # "cvs admin", reserved checkouts. + tests="${tests} admin reserved" + # Nuts and bolts of diffing/merging (diff library, &c) + tests="${tests} diffmerge1 diffmerge2" + # Release of multiple directories + tests="${tests} release" + tests="${tests} recase" + # Multiple root directories and low-level protocol tests. + tests="${tests} multiroot multiroot2 multiroot3 multiroot4" + tests="${tests} rmroot reposmv pserver server server2 client" + tests="${tests} dottedroot fork commit-d template" + tests="${tests} writeproxy writeproxy-noredirect writeproxy-ssh" + tests="${tests} writeproxy-ssh-noredirect" +else + tests="$*" +fi + +# Now check the -f argument for validity. +if test -n "$fromtest"; then + # Don't allow spaces - they are our delimiters in tests + count=0 + for sub in $fromtest; do + count=`expr $count + 1` + done + if test $count != 1; then + echo "No such test \`$fromtest'." >&2 + exit 2 + fi + # make sure it is in $tests + case " $tests " in + *" $fromtest "*) + ;; + *) + echo "No such test \`$fromtest'." >&2 + exit 2 + ;; + esac +fi + + + +# a simple function to compare directory contents +# +# Returns: 0 for same, 1 for different +# +directory_cmp () +{ + OLDPWD=`pwd` + DIR_1=$1 + DIR_2=$2 + + cd $DIR_1 + find . -print | fgrep -v /CVS | sort > $TESTDIR/dc$$d1 + + # go back where we were to avoid symlink hell... + cd $OLDPWD + cd $DIR_2 + find . -print | fgrep -v /CVS | sort > $TESTDIR/dc$$d2 + + if diff $TESTDIR/dc$$d1 $TESTDIR/dc$$d2 >/dev/null 2>&1 + then + : + else + return 1 + fi + cd $OLDPWD + while read a + do + if test -f $DIR_1/"$a" ; then + cmp -s $DIR_1/"$a" $DIR_2/"$a" + if test $? -ne 0 ; then + return 1 + fi + fi + done < $TESTDIR/dc$$d1 + rm -f $TESTDIR/dc$$* + return 0 +} + + + +# +# The following 4 functions are used by the diffmerge1 test case. They set up, +# respectively, the four versions of the files necessary: +# +# 1. Ancestor revisions. +# 2. "Your" changes. +# 3. "My" changes. +# 4. Expected merge result. +# + +# Create ancestor revisions for diffmerge1 +diffmerge_create_older_files() { + # This test case was supplied by Noah Friedman: + cat >testcase01 <<EOF +// Button.java + +package random.application; + +import random.util.*; + +public class Button +{ + /* Instantiates a Button with origin (0, 0) and zero width and height. + * You must call an initializer method to properly initialize the Button. + */ + public Button () + { + super (); + + _titleColor = Color.black; + _disabledTitleColor = Color.gray; + _titleFont = Font.defaultFont (); + } + + /* Convenience constructor for instantiating a Button with + * bounds x, y, width, and height. Equivalent to + * foo = new Button (); + * foo.init (x, y, width, height); + */ + public Button (int x, int y, int width, int height) + { + this (); + init (x, y, width, height); + } +} +EOF + + # This test case was supplied by Jacob Burckhardt: + cat >testcase02 <<EOF +a +a +a +a +a +EOF + + # This test case was supplied by Karl Tomlinson who also wrote the + # patch which lets CVS correctly handle this and several other cases: + cat >testcase03 <<EOF +x +s +a +b +s +y +EOF + + # This test case was supplied by Karl Tomlinson: + cat >testcase04 <<EOF +s +x +m +m +x +s +v +s +x +m +m +x +s +EOF + + # This test case was supplied by Karl Tomlinson: + cat >testcase05 <<EOF +s +x +m +m +x +x +x +x +x +x +x +x +x +x +s +s +s +s +s +s +s +s +s +s +v +EOF + + # This test case was supplied by Jacob Burckhardt: + cat >testcase06 <<EOF +g + + + + + + + + + + + +i +EOF + + # This test is supposed to verify that the horizon lines are the same + # for both 2-way diffs, but unfortunately, it does not fail with the + # old version of cvs. However, Karl Tomlinson still thought it would + # be good to test it anyway: + cat >testcase07 <<EOF +h +f + + + + + + + + + +g +r + + + +i + + + + + + + + + + +i +EOF + + # This test case was supplied by Jacob Burckhardt: + cat >testcase08 <<EOF +Both changes move this line to the end of the file. + +no +changes +here + +First change will delete this line. + +First change will also delete this line. + + no + changes + here + +Second change will change it here. + + no + changes + here +EOF + + # This test case was supplied by Jacob Burckhardt. Note that I do not + # think cvs has ever failed with this case, but I include it anyway, + # since I think it is a hard case. It is hard because Peter Miller's + # fmerge utility fails on it: + cat >testcase09 <<EOF +m +a +{ +} +b +{ +} +EOF + + # This test case was supplied by Martin Dorey and simplified by Jacob + # Burckhardt: + cat >testcase10 <<EOF + + petRpY ( MtatRk ); + fV ( MtatRk != Zy ) UDTXUK_DUUZU ( BGKT_ZFDK_qjT_HGTG ); + + MtatRk = MQfr_GttpfIRte_MtpeaL ( &acI, jfle_Uecopd_KRLIep * jfle_Uecopd_MfJe_fY_nEtek ); + OjZy MtatRk = Uead_GttpfIRte_MtpeaL ( &acI, jfle_Uecopd_MfJe_fY_nEtek, nRVVep ); + + Bloke_GttpfIRte_MtpeaL ( &acI ); +MTGTXM Uead_Ktz_qjT_jfle_Uecopd ( fYt Y, uofd *nRVVep ) +{ + fV ( Y < 16 ) + { + petRpY ( Uead_Mectopk ( noot_Uecopd.qVtHatabcY0 * noot_Uecopd.MectopkFepBlRktep + + Y * jfle_Uecopd_MfJe_fY_Mectopk, + jfle_Uecopd_MfJe_fY_Mectopk, + nRVVep ) ); + } + elke + { + petRpY ( Uead_Mectopk ( noot_Uecopd.qVtqfppHatabcY0 * noot_Uecopd.MectopkFepBlRktep + + ( Y - 16 ) * jfle_Uecopd_MfJe_fY_Mectopk, + jfle_Uecopd_MfJe_fY_Mectopk, + nRVVep ) ); + } + +} + + +/**************************************************************************** +* * +* Uead Mectopk ( Uelatfue to tze cRppeYt raptftfoY ) * +* * +****************************************************************************/ + +MTGTXM Uead_Mectopk ( RfYt64 Mtapt_Mectop, RfYt64 KRL_Mectopk, uofd *nRVVep ) +{ +MTGTXM MtatRk = Zy; + + MtatRk = Uead_HfkQ ( FaptftfoY_TaIle.Uelatfue_Mectop + Mtapt_Mectop, KRL_Mectopk, nRVVep ); + + petRpY ( MtatRk ); + +} + HfkQipfte ( waYdle, /* waYdle */ + waYdleFok, /* ZVVket VpoL ktapt oV dfkQ */ + (coYkt RfYt8*) nRVVep, /* nRVVep */ + 0, /* MRrepVlRoRk KfxoYfkL */ + beYgtz /* nEtek to Apfte */ + ); + + petRpY ( Zy ); +} +EOF +} + +# Create "your" revisions for diffmerge1 +diffmerge_create_your_files() { + # remove the Button() method + cat >testcase01 <<\EOF +// Button.java + +package random.application; + +import random.util.*; + +public class Button +{ + /* Instantiates a Button with origin (0, 0) and zero width and height. + * You must call an initializer method to properly initialize the Button. + */ + public Button () + { + super (); + + _titleColor = Color.black; + _disabledTitleColor = Color.gray; + _titleFont = Font.defaultFont (); + } +} +EOF + + cat >testcase02 <<\EOF +y +a +a +a +a +EOF + + cat >testcase03 <<\EOF +x +s +a +b +s +b +s +y +EOF + + cat >testcase04 <<\EOF +s +m +s +v +s +m +s +EOF + + cat >testcase05 <<\EOF +v +s +m +s +s +s +s +s +s +s +s +s +s +v +EOF + + # Test case 6 and test case 7 both use the same input files, but they + # order the input files differently. In one case, a certain file is + # used as the older file, but in the other test case, that same file + # is used as the file which has changes. I could have put echo + # commands here, but since the echo lines would be the same as those + # in the previous function, I decided to save space and avoid repeating + # several lines of code. Instead, I merely swap the files: + mv testcase07 tmp + mv testcase06 testcase07 + mv tmp testcase06 + + # Make the date newer so that cvs thinks that the files are changed: + touch testcase06 testcase07 + + cat >testcase08 <<\EOF +no +changes +here + +First change has now added this in. + + no + changes + here + +Second change will change it here. + + no + changes + here + +Both changes move this line to the end of the file. +EOF + + cat >testcase09 <<\EOF + +m +a +{ +} +b +{ +} +c +{ +} +EOF + + cat >testcase10 <<\EOF + + fV ( BzQkV_URYYfYg ) (*jfle_Uecopdk)[0].jfle_Uecopd_KRLIep = ZpfgfYal_jUK; + + petRpY ( MtatRk ); + fV ( MtatRk != Zy ) UDTXUK_DUUZU ( BGKT_ZFDK_qjT_HGTG ); + + fV ( jfle_Uecopd_KRLIep < 16 ) + { + MtatRk = Uead_Ktz_qjT_jfle_Uecopd ( jfle_Uecopd_KRLIep, (uofd*)nRVVep ); + } + elke + { + MtatRk = ZreY_GttpfIRte_MtpeaL ( qjT_jfle_Uecopdk, qjT_jfle_Uecopd_BoRYt, HGTG_TvFD, KXbb, KXbb, &acI ); + fV ( MtatRk != Zy ) UDTXUK_DUUZU ( BGKT_ZFDK_qjT_HGTG ); + + MtatRk = MQfr_GttpfIRte_MtpeaL ( &acI, jfle_Uecopd_KRLIep * jfle_Uecopd_MfJe_fY_nEtek ); + OjZy MtatRk = Uead_GttpfIRte_MtpeaL ( &acI, jfle_Uecopd_MfJe_fY_nEtek, nRVVep ); + + Bloke_GttpfIRte_MtpeaL ( &acI ); +MTGTXM Uead_Ktz_qjT_jfle_Uecopd ( fYt Y, uofd *nRVVep ) +{ +MTGTXM MtatRk = Zy; + + fV ( Y < 16 ) + { + petRpY ( Uead_Mectopk ( noot_Uecopd.qVtHatabcY0 * noot_Uecopd.MectopkFepBlRktep + + Y * jfle_Uecopd_MfJe_fY_Mectopk, + jfle_Uecopd_MfJe_fY_Mectopk, + nRVVep ) ); + } + elke + { + petRpY ( Uead_Mectopk ( noot_Uecopd.qVtqfppHatabcY0 * noot_Uecopd.MectopkFepBlRktep + + ( Y - 16 ) * jfle_Uecopd_MfJe_fY_Mectopk, + jfle_Uecopd_MfJe_fY_Mectopk, + nRVVep ) ); + } + + petRpY ( MtatRk ); + +} + + +/**************************************************************************** +* * +* Uead Mectopk ( Uelatfue to tze cRppeYt raptftfoY ) * +* * +****************************************************************************/ + +MTGTXM Uead_Mectopk ( RfYt64 Mtapt_Mectop, RfYt64 KRL_Mectopk, uofd *nRVVep ) +{ +MTGTXM MtatRk = Zy; + + MtatRk = Uead_HfkQ ( FaptftfoY_TaIle.Uelatfue_Mectop + Mtapt_Mectop, KRL_Mectopk, nRVVep ); + + petRpY ( MtatRk ); + +} + HfkQipfte ( waYdle, /* waYdle */ + waYdleFok, /* ZVVket VpoL ktapt oV dfkQ */ + (coYkt RfYt8*) nRVVep, /* nRVVep */ + 0, /* MRrepVlRoRk KfxoYfkL */ + beYgtz /* nEtek to Apfte */ + ); + + petRpY ( Zy ); +} + +EOF +} + +# Create "my" revisions for diffmerge1 +diffmerge_create_my_files() { + # My working copy still has the Button() method, but I + # comment out some code at the top of the class. + cat >testcase01 <<\EOF +// Button.java + +package random.application; + +import random.util.*; + +public class Button +{ + /* Instantiates a Button with origin (0, 0) and zero width and height. + * You must call an initializer method to properly initialize the Button. + */ + public Button () + { + super (); + + // _titleColor = Color.black; + // _disabledTitleColor = Color.gray; + // _titleFont = Font.defaultFont (); + } + + /* Convenience constructor for instantiating a Button with + * bounds x, y, width, and height. Equivalent to + * foo = new Button (); + * foo.init (x, y, width, height); + */ + public Button (int x, int y, int width, int height) + { + this (); + init (x, y, width, height); + } +} +EOF + + cat >testcase02 <<\EOF +a +a +a +a +m +EOF + + cat >testcase03 <<\EOF +x +s +c +s +b +s +y +EOF + + cat >testcase04 <<\EOF +v +s +x +m +m +x +s +v +s +x +m +m +x +s +v +EOF + + # Note that in test case 5, there are no changes in the "mine" + # section, which explains why there is no command here which writes to + # file testcase05. + + # no changes for testcase06 + + # The two branches make the same changes: + cp ../yours/testcase07 . + + cat >testcase08 <<\EOF +no +changes +here + +First change will delete this line. + +First change will also delete this line. + + no + changes + here + +Second change has now changed it here. + + no + changes + here + +Both changes move this line to the end of the file. +EOF + + cat >testcase09 <<\EOF +m +a +{ +} +b +{ +} +c +{ +} +EOF + + cat >testcase10 <<\EOF + + petRpY ( MtatRk ); + fV ( MtatRk != Zy ) UDTXUK_DUUZU ( BGKT_ZFDK_qjT_HGTG ); + + MtatRk = MQfr_GttpfIRte_MtpeaL ( &acI, jfle_Uecopd_KRLIep * jfle_Uecopd_MfJe_fY_nEtek ); + OjZy MtatRk = Uead_GttpfIRte_MtpeaL ( &acI, jfle_Uecopd_MfJe_fY_nEtek, nRVVep ); + + Bloke_GttpfIRte_MtpeaL ( &acI ); +MTGTXM Uead_Ktz_qjT_jfle_Uecopd ( fYt Y, uofd *nRVVep ) +{ + fV ( Y < 16 ) + { + petRpY ( Uead_Mectopk ( noot_Uecopd.qVtHatabcY0 * noot_Uecopd.MectopkFepBlRktep + + Y * jfle_Uecopd_MfJe_fY_Mectopk, + jfle_Uecopd_MfJe_fY_Mectopk, + nRVVep ) ); + } + elke + { + petRpY ( Uead_Mectopk ( noot_Uecopd.qVtqfppHatabcY0 * noot_Uecopd.MectopkFepBlRktep + + ( Y - 16 ) * jfle_Uecopd_MfJe_fY_Mectopk, + jfle_Uecopd_MfJe_fY_Mectopk, + nRVVep ) ); + } + +} + + +/**************************************************************************** +* * +* Uead Mectopk ( Uelatfue to tze cRppeYt raptftfoY ) * +* * +****************************************************************************/ + +MTGTXM Uead_Mectopk ( RfYt64 Mtapt_Mectop, RfYt64 KRL_Mectopk, uofd *nRVVep ) +{ +MTGTXM MtatRk = Zy; + + MtatRk = Uead_HfkQ ( FaptftfoY_TaIle.Uelatfue_Mectop + Mtapt_Mectop, KRL_Mectopk, nRVVep ); + + petRpY ( MtatRk ); + +} + HfkQipfte ( waYdle, /* waYdle */ + waYdleFok, /* ZVVket VpoL ktapt oV dfkQ */ + (coYkt RfYt8*) nRVVep, /* nRVVep */ + beYgtz /* nEtek to Apfte */ + ); + + petRpY ( Zy ); +} + +EOF +} + +# Create expected results of merge for diffmerge1 +diffmerge_create_expected_files() { + cat >testcase01 <<\EOF +// Button.java + +package random.application; + +import random.util.*; + +public class Button +{ + /* Instantiates a Button with origin (0, 0) and zero width and height. + * You must call an initializer method to properly initialize the Button. + */ + public Button () + { + super (); + + // _titleColor = Color.black; + // _disabledTitleColor = Color.gray; + // _titleFont = Font.defaultFont (); + } +} +EOF + + cat >testcase02 <<\EOF +y +a +a +a +m +EOF + + cat >testcase03 <<\EOF +x +s +c +s +b +s +b +s +y +EOF + + cat >testcase04 <<\EOF +v +s +m +s +v +s +m +s +v +EOF + + # Since there are no changes in the "mine" section, just take exactly + # the version in the "yours" section: + cp ../yours/testcase05 . + + cp ../yours/testcase06 . + + # Since the two branches make the same changes, the result should be + # the same as both branches. Here, I happen to pick yours to copy from, + # but I could have also picked mine, since the source of the copy is + # the same in either case. However, the mine has already been + # altered by the update command, so don't use it. Instead, use the + # yours section which has not had an update on it and so is unchanged: + cp ../yours/testcase07 . + + cat >testcase08 <<\EOF +no +changes +here + +First change has now added this in. + + no + changes + here + +Second change has now changed it here. + + no + changes + here + +Both changes move this line to the end of the file. +EOF + + cat >testcase09 <<\EOF + +m +a +{ +} +b +{ +} +c +{ +} +EOF + + cat >testcase10 <<\EOF + + fV ( BzQkV_URYYfYg ) (*jfle_Uecopdk)[0].jfle_Uecopd_KRLIep = ZpfgfYal_jUK; + + petRpY ( MtatRk ); + fV ( MtatRk != Zy ) UDTXUK_DUUZU ( BGKT_ZFDK_qjT_HGTG ); + + fV ( jfle_Uecopd_KRLIep < 16 ) + { + MtatRk = Uead_Ktz_qjT_jfle_Uecopd ( jfle_Uecopd_KRLIep, (uofd*)nRVVep ); + } + elke + { + MtatRk = ZreY_GttpfIRte_MtpeaL ( qjT_jfle_Uecopdk, qjT_jfle_Uecopd_BoRYt, HGTG_TvFD, KXbb, KXbb, &acI ); + fV ( MtatRk != Zy ) UDTXUK_DUUZU ( BGKT_ZFDK_qjT_HGTG ); + + MtatRk = MQfr_GttpfIRte_MtpeaL ( &acI, jfle_Uecopd_KRLIep * jfle_Uecopd_MfJe_fY_nEtek ); + OjZy MtatRk = Uead_GttpfIRte_MtpeaL ( &acI, jfle_Uecopd_MfJe_fY_nEtek, nRVVep ); + + Bloke_GttpfIRte_MtpeaL ( &acI ); +MTGTXM Uead_Ktz_qjT_jfle_Uecopd ( fYt Y, uofd *nRVVep ) +{ +MTGTXM MtatRk = Zy; + + fV ( Y < 16 ) + { + petRpY ( Uead_Mectopk ( noot_Uecopd.qVtHatabcY0 * noot_Uecopd.MectopkFepBlRktep + + Y * jfle_Uecopd_MfJe_fY_Mectopk, + jfle_Uecopd_MfJe_fY_Mectopk, + nRVVep ) ); + } + elke + { + petRpY ( Uead_Mectopk ( noot_Uecopd.qVtqfppHatabcY0 * noot_Uecopd.MectopkFepBlRktep + + ( Y - 16 ) * jfle_Uecopd_MfJe_fY_Mectopk, + jfle_Uecopd_MfJe_fY_Mectopk, + nRVVep ) ); + } + + petRpY ( MtatRk ); + +} + + +/**************************************************************************** +* * +* Uead Mectopk ( Uelatfue to tze cRppeYt raptftfoY ) * +* * +****************************************************************************/ + +MTGTXM Uead_Mectopk ( RfYt64 Mtapt_Mectop, RfYt64 KRL_Mectopk, uofd *nRVVep ) +{ +MTGTXM MtatRk = Zy; + + MtatRk = Uead_HfkQ ( FaptftfoY_TaIle.Uelatfue_Mectop + Mtapt_Mectop, KRL_Mectopk, nRVVep ); + + petRpY ( MtatRk ); + +} + HfkQipfte ( waYdle, /* waYdle */ + waYdleFok, /* ZVVket VpoL ktapt oV dfkQ */ + (coYkt RfYt8*) nRVVep, /* nRVVep */ + beYgtz /* nEtek to Apfte */ + ); + + petRpY ( Zy ); +} + +EOF +} + + + +# Echo a new CVSROOT based on $1, $remote, and $remotehost +newroot() { + if $remote; then + if test -n "$remotehost"; then + echo :ext$rootoptions:$remotehost$1 + else + echo :fork$rootoptions:$1 + fi + else + echo $1 + fi +} + + + +# Set up CVSROOT (the crerepos tests will test operating without CVSROOT set). +# +# Currently we test :fork: and :ext: (see crerepos test). There is a +# known difference between the two in modes-15 (see comments there). +# +# :ext: can be tested against a remote machine if: +# +# 1. $remotehost is set using the `-h' option to this script. +# 2. ${CVS_RSH=rsh} $remotehost works. +# 3. The path to $TESTDIR is the same on both machines (symlinks are okay) +# 4. The path to $testcvs is the same on both machines (symlinks are okay) +# or $CVS_SERVER is overridden in this script's environment to point to +# a working CVS exectuable on the remote machine. +# +# Testing :pserver: would be hard (inetd issues). (How about using tcpserver +# and some high port number? DRP) + +if $linkroot; then + mkdir ${TESTDIR}/realcvsroot + ln -s realcvsroot ${TESTDIR}/cvsroot +fi +CVSROOT_DIRNAME=${TESTDIR}/cvsroot +CVSROOT=`newroot $CVSROOT_DIRNAME`; export CVSROOT + + + +### +### Initialize the repository +### +dotest init-1 "$testcvs init" + +# Now hide the primary root behind a secondary if requested. +if $proxy; then + # Save the primary root. + PRIMARY_CVSROOT=$CVSROOT + PRIMARY_CVSROOT_DIRNAME=$CVSROOT_DIRNAME + # Where the secondary root will be + SECONDARY_CVSROOT_DIRNAME=$TESTDIR/secondary_cvsroot + if $noredirect; then + rootoptions=";Redirect=no" + SECONDARY_CVSROOT=`newroot $PRIMARY_CVSROOT_DIRNAME` + else + SECONDARY_CVSROOT=`newroot $SECONDARY_CVSROOT_DIRNAME` + fi + # Now set the global CVSROOT to use the secondary. + CVSROOT=$SECONDARY_CVSROOT; export CVSROOT + + require_rsync + if test $? -eq 77; then + echo "Unable to test in proxy mode: $skipreason" >&2 + skip all "missing or broken rsync command." + exit 0 + fi + + if $noredirect; then + # Wrap the CVS server to allow --primary-root to be set by the + # secondary. + cat <<EOF >$TESTDIR/secondary-wrapper +#! $TESTSHELL +CVS_SERVER=$TESTDIR/primary-wrapper +export CVS_SERVER + +# No need to check the PID of the last client since we are testing with +# Redirect disabled. +proot_arg="--allow-root=$SECONDARY_CVSROOT_DIRNAME" +exec $CVS_SERVER \$proot_arg "\$@" +EOF + cat <<EOF >$TESTDIR/primary-wrapper +#! $TESTSHELL +if test -n "$CVS_SERVER_LOG"; then + CVS_SERVER_LOG=`dirname "$CVS_SERVER_LOG"`/cvsprimarylog + export CVS_SERVER_LOG +fi +exec $CVS_SERVER "\$@" +EOF + + CVS_SERVER_secondary=$TESTDIR/secondary-wrapper + CVS_SERVER=$CVS_SERVER_secondary + + chmod a+x $TESTDIR/secondary-wrapper \ + $TESTDIR/primary-wrapper + fi + + # Script to sync the secondary root. + cat >$TESTDIR/sync-secondary <<EOF +#! $TESTSHELL +# date >>$TESTDIR/update-log + +ps=\$1 +cmd=\$2 +dir=\$3 +shift +shift +shift + +# echo "updating from \$ps for command \\\`\$cmd' in dir \\\`\$dir'" \${1+"\$@"} \\ +# >>$TESTDIR/update-log + +# If multiple CVS executables could attempt to access the repository, we would +# Need to lock for this sync and sleep +case "\$dir" in + ALL) + # This is a hack to allow a few of the tests to play with the + # UseNewInfoFmtStrings key in CVSROOT/config. It's inefficient, but there + # aren't many tests than need it and the alternative is an awful lot of + # special casing. + $RSYNC -rglop --delete --exclude '#cvs.*' \\ + $PRIMARY_CVSROOT_DIRNAME/ \\ + $SECONDARY_CVSROOT_DIRNAME + ;; + + *) + # For the majority of the tests we will only sync the directories that + # were written to. + case "\$cmd" in + add|import) + # For \`add', we need a recursive update due to quirks in rsync syntax, + # but it shouldn't affect efficiency since any new dir should be empty. + # + # For \`import', a recursive update is necessary since subdirs may have + # been added underneath the root dir we were passed. + $RSYNC -rglop \\ + $PRIMARY_CVSROOT_DIRNAME/"\$dir" \\ + $SECONDARY_CVSROOT_DIRNAME/\`dirname -- "\$dir"\` + ;; + + tag) + # \`tag' may have changed CVSROOT/val-tags too. + $RSYNC -glop \\ + $PRIMARY_CVSROOT_DIRNAME/CVSROOT/val-tags \\ + $SECONDARY_CVSROOT_DIRNAME/CVSROOT + # Otherwise it is identical to other write commands. + $RSYNC -rglop --delete \\ + --include Attic --include CVS \ + --exclude '#cvs.*' --exclude '*/' \\ + $PRIMARY_CVSROOT_DIRNAME/"\$dir"/ \\ + $SECONDARY_CVSROOT_DIRNAME/"\$dir" + ;; + + *) + # By default, sync just what changed. + $RSYNC -rglop --delete \\ + --include Attic --include CVS \ + --exclude '#cvs.*' --exclude '*/' \\ + $PRIMARY_CVSROOT_DIRNAME/"\$dir"/ \\ + $SECONDARY_CVSROOT_DIRNAME/"\$dir" + ;; + esac # \$cmd + + # And keep the history file up to date for all commands. + $RSYNC -glop \\ + $PRIMARY_CVSROOT_DIRNAME/CVSROOT/history \\ + $SECONDARY_CVSROOT_DIRNAME/CVSROOT + ;; # \$dir = * +esac # \$dir + +# Avoid timestamp comparison issues with rsync. +sleep 1 +EOF + chmod a+x $TESTDIR/sync-secondary + + # And now init the secondary. + $TESTDIR/sync-secondary "- no, before - create secondary root" \ + sanity-setup ALL + + # Initialize the primary repository + mkdir proxy-init; cd proxy-init + dotest proxy-init-1 "$testcvs -Qd$PRIMARY_CVSROOT co CVSROOT" + cd CVSROOT + cat >>config <<EOF +PrimaryServer=$PRIMARY_CVSROOT +EOF + cat >>loginfo <<EOF +ALL $TESTDIR/sync-secondary loginfo %c %p %{sVv} +EOF + cat >>postadmin <<EOF +ALL $TESTDIR/sync-secondary postadmin %c %p +EOF + cat >>posttag <<EOF +ALL $TESTDIR/sync-secondary posttag %c %p %o %b %t %{sVv} +EOF + cat >>postwatch <<EOF +ALL $TESTDIR/sync-secondary postwatch %c %p +EOF + dotest proxy-init-2 \ +"$testcvs -Q ci -mconfigure-writeproxy" + + # Save these files for later reference + cp config $TESTDIR/config-clean + cp loginfo $TESTDIR/loginfo-clean + cp postadmin $TESTDIR/postadmin-clean + cp posttag $TESTDIR/posttag-clean + cp postwatch $TESTDIR/postwatch-clean + + # done in here + cd ../.. + rm -rf proxy-init +else # !$proxy + # Set this even when not testing $proxy to match messages, like $SPROG. + SECONDARY_CVSROOT_DIRNAME=$CVSROOT_DIRNAME +fi # $proxy + +# Save a copy of the initial repository so that it may be restored after the +# tests that alter it. +cp -Rp $CVSROOT_DIRNAME/CVSROOT $TESTDIR/CVSROOT.save + + +### +### The tests +### +dotest init-2 "$testcvs init" + + + +### +### The big loop +### +for what in $tests; do + if test -n "$fromtest" ; then + if test $fromtest = $what ; then + unset fromtest + else + continue + fi + fi + case $what in + + version) + # We've had cases where the version command started dumping core, + # so we might as well test it + dotest version-1 "${testcvs} --version" \ +' +Concurrent Versions System (CVS) [0-9.]*.* + +Copyright (C) [0-9]* Free Software Foundation, Inc. + +Senior active maintainers include Larry Jones, Derek R. Price, +and Mark D. Baushke. Please see the AUTHORS and README files from the CVS +distribution kit for a complete list of contributors and copyrights. + +CVS may be copied only under the terms of the GNU General Public License, +a copy of which can be found with the CVS distribution kit. + +Specify the --help option for further information about CVS' + +# Maybe someday... +# if $proxy; then +# dotest version-2r "${testcvs} version" \ +#'Client: Concurrent Versions System (CVS) [0-9p.]* (client.*) +#Server: Concurrent Versions System (CVS) [0-9p.]* (.*server) +#Secondary Server: Concurrent Versions System (CVS) [0-9p.]* (.*server)' + if $remote; then + dotest version-2r "${testcvs} version" \ +'Client: Concurrent Versions System (CVS) [0-9p.]* (client.*) +Server: Concurrent Versions System (CVS) [0-9p.]* (.*server)' + else + dotest version-2 "${testcvs} version" \ +'Concurrent Versions System (CVS) [0-9.]*.*' + fi + ;; + + + + basica) + # Similar in spirit to some of the basic1, and basic2 + # tests, but hopefully a lot faster. Also tests operating on + # files two directories down *without* operating on the parent dirs. + + # Tests basica-0a and basica-0b provide the equivalent of the: + # mkdir ${CVSROOT_DIRNAME}/first-dir + # used by many of the tests. It is "more official" in the sense + # that is does everything through CVS; the reason most of the + # tests don't use it is mostly historical. + mkdir 1; cd 1 + dotest basica-0a "$testcvs -q co -l ." + mkdir first-dir + dotest basica-0b "$testcvs add first-dir" \ +"Directory ${CVSROOT_DIRNAME}/first-dir added to the repository" + cd .. + rm -r 1 + + dotest basica-1 "$testcvs -q co first-dir" '' + cd first-dir + + # Test a few operations, to ensure they gracefully do + # nothing in an empty directory. + dotest basica-1a0 "$testcvs -q update" + dotest basica-1a1 "$testcvs -q diff -c" + dotest basica-1a2 "$testcvs -q status" + dotest basica-1a3 "$testcvs -q update ." + dotest basica-1a4 "$testcvs -q update ./" + + mkdir sdir + # Remote CVS gives the "cannot open CVS/Entries" error, which is + # clearly a bug, but not a simple one to fix. + dotest basica-1a10 "$testcvs -n add sdir" \ +"Directory $CVSROOT_DIRNAME/first-dir/sdir added to the repository" \ +"$SPROG add: cannot open CVS/Entries for reading: No such file or directory +Directory $CVSROOT_DIRNAME/first-dir/sdir added to the repository" + dotest_fail basica-1a11 \ + "test -d $CVSROOT_DIRNAME/first-dir/sdir" + dotest basica-2 "$testcvs add sdir" \ +"Directory $CVSROOT_DIRNAME/first-dir/sdir added to the repository" + cd sdir + mkdir ssdir + dotest basica-3 "$testcvs add ssdir" \ +"Directory $CVSROOT_DIRNAME/first-dir/sdir/ssdir added to the repository" + cd ssdir + echo ssfile >ssfile + + # Trying to commit it without a "cvs add" should be an error. + # The "use `cvs add' to create an entry" message is the one + # that I consider to be more correct, but local cvs prints the + # "nothing known" message and noone has gotten around to fixing it. + dotest_fail basica-notadded "${testcvs} -q ci ssfile" \ +"${CPROG} commit: use .${CPROG} add. to create an entry for \`ssfile' +${CPROG}"' \[commit aborted\]: correct above errors first!' \ +"${CPROG}"' commit: nothing known about `ssfile'\'' +'"${CPROG}"' \[commit aborted\]: correct above errors first!' + + dotest basica-4 "${testcvs} add ssfile" \ +"${SPROG}"' add: scheduling file `ssfile'\'' for addition +'"${SPROG}"' add: use .'"${SPROG}"' commit. to add this file permanently' + dotest_fail basica-4a "${testcvs} tag tag0 ssfile" \ +"${SPROG} tag: nothing known about ssfile +${SPROG} "'\[tag aborted\]: correct the above errors first!' + cd ../.. + dotest basica-5 "${testcvs} -q ci -m add-it" \ +"$CVSROOT_DIRNAME/first-dir/sdir/ssdir/ssfile,v <-- sdir/ssdir/ssfile +initial revision: 1\.1" + dotest_fail basica-5a \ + "${testcvs} -q tag BASE sdir/ssdir/ssfile" \ +"${SPROG} tag: Attempt to add reserved tag name BASE +${SPROG} \[tag aborted\]: failed to set tag BASE to revision 1\.1 in ${CVSROOT_DIRNAME}/first-dir/sdir/ssdir/ssfile,v" + dotest basica-5b "${testcvs} -q tag NOT_RESERVED" \ +'T sdir/ssdir/ssfile' + + dotest basica-6 "${testcvs} -q update" '' + echo "ssfile line 2" >>sdir/ssdir/ssfile + dotest_fail basica-6.2 "${testcvs} -q diff -c" \ +"Index: sdir/ssdir/ssfile +=================================================================== +RCS file: ${CVSROOT_DIRNAME}/first-dir/sdir/ssdir/ssfile,v +retrieving revision 1\.1 +diff -c -r1\.1 ssfile +\*\*\* sdir/ssdir/ssfile ${RFCDATE} 1\.1 +--- sdir/ssdir/ssfile ${RFCDATE} +\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* +\*\*\* 1 \*\*\*\* +--- 1,2 ---- + ssfile +${PLUS} ssfile line 2" + dotest_fail basica-6.3 "${testcvs} -q diff -c -rBASE" \ +"Index: sdir/ssdir/ssfile +=================================================================== +RCS file: ${CVSROOT_DIRNAME}/first-dir/sdir/ssdir/ssfile,v +retrieving revision 1\.1 +diff -c -r1\.1 ssfile +\*\*\* sdir/ssdir/ssfile ${RFCDATE} 1\.1 +--- sdir/ssdir/ssfile ${RFCDATE} +\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* +\*\*\* 1 \*\*\*\* +--- 1,2 ---- + ssfile +${PLUS} ssfile line 2" + dotest_fail basica-6.4 "${testcvs} -q diff -c -rBASE -C3isacrowd" \ +"Index: sdir/ssdir/ssfile +=================================================================== +RCS file: ${CVSROOT_DIRNAME}/first-dir/sdir/ssdir/ssfile,v +retrieving revision 1\.1 +diff -c -C 3isacrowd -r1\.1 ssfile +${SPROG} diff: invalid context length argument" + dotest basica-7 "${testcvs} -q ci -m modify-it" \ +"$CVSROOT_DIRNAME/first-dir/sdir/ssdir/ssfile,v <-- sdir/ssdir/ssfile +new revision: 1\.2; previous revision: 1\.1" + dotest_fail basica-nonexist "${testcvs} -q ci nonexist" \ +"${CPROG}"' commit: nothing known about `nonexist'\'' +'"${CPROG}"' \[commit aborted\]: correct above errors first!' + dotest basica-8 "${testcvs} -q update ." '' + + # Test the -f option to ci + cd sdir/ssdir + dotest basica-8a0 "${testcvs} -q ci -m not-modified ssfile" '' + dotest basica-8a "${testcvs} -q ci -f -m force-it" \ +"$CVSROOT_DIRNAME/first-dir/sdir/ssdir/ssfile,v <-- ssfile +new revision: 1\.3; previous revision: 1\.2" + dotest basica-8a1 "${testcvs} -q ci -m bump-it -r 2.0" \ +"$CVSROOT_DIRNAME/first-dir/sdir/ssdir/ssfile,v <-- ssfile +new revision: 2\.0; previous revision: 1\.3" + dotest basica-8a1a "${testcvs} -q ci -m bump-it -r 2.9" \ +"${CVSROOT_DIRNAME}/first-dir/sdir/ssdir/ssfile,v <-- ssfile +new revision: 2\.9; previous revision: 2\.0" + # Test string-based revion number increment rollover + dotest basica-8a1b "${testcvs} -q ci -m bump-it -f -r 2" \ +"${CVSROOT_DIRNAME}/first-dir/sdir/ssdir/ssfile,v <-- ssfile +new revision: 2\.10; previous revision: 2\.9" + dotest basica-8a1c "${testcvs} -q ci -m bump-it -r 2.99" \ +"${CVSROOT_DIRNAME}/first-dir/sdir/ssdir/ssfile,v <-- ssfile +new revision: 2\.99; previous revision: 2\.10" + # Test string-based revion number increment rollover + dotest basica-8a1d "${testcvs} -q ci -m bump-it -f -r 2" \ +"${CVSROOT_DIRNAME}/first-dir/sdir/ssdir/ssfile,v <-- ssfile +new revision: 2\.100; previous revision: 2\.99" + dotest basica-8a1e "${testcvs} -q ci -m bump-it -r 2.1099" \ +"${CVSROOT_DIRNAME}/first-dir/sdir/ssdir/ssfile,v <-- ssfile +new revision: 2\.1099; previous revision: 2\.100" + # Test string-based revion number increment rollover + dotest basica-8a1f "${testcvs} -q ci -m bump-it -f -r 2" \ +"${CVSROOT_DIRNAME}/first-dir/sdir/ssdir/ssfile,v <-- ssfile +new revision: 2\.1100; previous revision: 2\.1099" + # -f should not be necessary, but it should be harmless. + # Also test the "-r 3" (rather than "-r 3.0") usage. + dotest basica-8a2 "${testcvs} -q ci -m bump-it -f -r 3" \ +"$CVSROOT_DIRNAME/first-dir/sdir/ssdir/ssfile,v <-- ssfile +new revision: 3\.1; previous revision: 2\.1100" + + # Test using -r to create a branch + dotest_fail basica-8a3 "${testcvs} -q ci -m bogus -r 3.0.0" \ +"$CVSROOT_DIRNAME/first-dir/sdir/ssdir/ssfile,v <-- ssfile +$SPROG commit: $CVSROOT_DIRNAME/first-dir/sdir/ssdir/ssfile,v: can't find branch point 3\.0 +$SPROG commit: could not check in ssfile" + dotest basica-8a4 "${testcvs} -q ci -m valid -r 3.1.2" \ +"$CVSROOT_DIRNAME/first-dir/sdir/ssdir/ssfile,v <-- ssfile +new revision: 3\.1\.2\.1; previous revision: 3\.1" + # now get rid of the sticky tag and go back to the trunk + dotest basica-8a5 "${testcvs} -q up -A ./" "[UP] ssfile" + + cd ../.. + dotest basica-8b "${testcvs} -q diff -r1.2 -r1.3" + + dotest basica-8b1 "${testcvs} -q diff -r1.2 -r1.3 -C 3isacrowd" + + # The .* here will normally be "No such file or directory", + # but if memory serves some systems (AIX?) have a different message. +: dotest_fail basica-9 \ + "${testcvs} -q -d ${TESTDIR}/nonexist update" \ +"${SPROG}: cannot access cvs root ${TESTDIR}/nonexist: .*" + dotest_fail basica-9a \ + "${testcvs} -q -d ${TESTDIR}/nonexist update" \ +"${CPROG} \[update aborted\]: ${TESTDIR}/nonexist/CVSROOT: .*" + + dotest basica-10 "${testcvs} annotate" \ +' +Annotations for sdir/ssdir/ssfile +\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* +1\.1 .'"$username8"' *[0-9a-zA-Z-]*.: ssfile +1\.2 .'"$username8"' *[0-9a-zA-Z-]*.: ssfile line 2' + + # Test resurrecting with strange revision numbers + cd sdir/ssdir + dotest basica-r1 "${testcvs} rm -f ssfile" \ +"${SPROG} remove: scheduling .ssfile. for removal +${SPROG} remove: use .${SPROG} commit. to remove this file permanently" + dotest basica-r2 "${testcvs} -q ci -m remove" \ +"$CVSROOT_DIRNAME/first-dir/sdir/ssdir/ssfile,v <-- ssfile +new revision: delete; previous revision: 3\.1" + dotest basica-r3 "${testcvs} -q up -p -r 3.1 ./ssfile >ssfile" "" + dotest basica-r4 "${testcvs} add ssfile" \ +"${SPROG} add: Re-adding file .ssfile. after dead revision 3\.2\. +${SPROG} add: use .${SPROG} commit. to add this file permanently" + dotest basica-r5 "${testcvs} -q ci -m resurrect" \ +"$CVSROOT_DIRNAME/first-dir/sdir/ssdir/ssfile,v <-- ssfile +new revision: 3\.3; previous revision: 3\.2" + cd ../.. + + # As long as we have a file with a few revisions, test + # a few "cvs admin -o" invocations. + cd sdir/ssdir + dotest_fail basica-o1 "${testcvs} admin -o 1.2::1.2" \ +"${CPROG} admin: while processing more than one file: +${CPROG} \[admin aborted\]: attempt to specify a numeric revision" + dotest basica-o2 "${testcvs} admin -o 1.2::1.2 ssfile" \ +"RCS file: ${CVSROOT_DIRNAME}/first-dir/sdir/ssdir/ssfile,v +done" + dotest basica-o2a "${testcvs} admin -o 1.1::NOT_RESERVED ssfile" \ +"RCS file: ${CVSROOT_DIRNAME}/first-dir/sdir/ssdir/ssfile,v +done" + dotest_fail basica-o2b "${testcvs} admin -o 1.1::NOT_EXIST ssfile" \ +"RCS file: ${CVSROOT_DIRNAME}/first-dir/sdir/ssdir/ssfile,v +${SPROG} admin: ${CVSROOT_DIRNAME}/first-dir/sdir/ssdir/ssfile,v: Revision NOT_EXIST doesn't exist. +${SPROG} admin: RCS file for .ssfile. not modified\." + dotest basica-o3 "${testcvs} admin -o 1.2::1.3 ssfile" \ +"RCS file: ${CVSROOT_DIRNAME}/first-dir/sdir/ssdir/ssfile,v +done" + dotest basica-o4 "${testcvs} admin -o 3.1:: ssfile" \ +"RCS file: ${CVSROOT_DIRNAME}/first-dir/sdir/ssdir/ssfile,v +deleting revision 3\.3 +deleting revision 3\.2 +done" + dotest basica-o5 "${testcvs} admin -o ::1.1 ssfile" \ +"RCS file: ${CVSROOT_DIRNAME}/first-dir/sdir/ssdir/ssfile,v +done" + dotest basica-o5a "${testcvs} -n admin -o 1.2::3.1 ssfile" \ +"RCS file: ${CVSROOT_DIRNAME}/first-dir/sdir/ssdir/ssfile,v +deleting revision 2\.1100 +deleting revision 2\.1099 +deleting revision 2\.100 +deleting revision 2\.99 +deleting revision 2\.10 +deleting revision 2\.9 +deleting revision 2\.0 +deleting revision 1\.3 +done" + dotest basica-o6 "${testcvs} admin -o 1.2::3.1 ssfile" \ +"RCS file: ${CVSROOT_DIRNAME}/first-dir/sdir/ssdir/ssfile,v +deleting revision 2\.1100 +deleting revision 2\.1099 +deleting revision 2\.100 +deleting revision 2\.99 +deleting revision 2\.10 +deleting revision 2\.9 +deleting revision 2\.0 +deleting revision 1\.3 +done" + dotest basica-o6a "${testcvs} admin -o 3.1.2: ssfile" \ +"RCS file: ${CVSROOT_DIRNAME}/first-dir/sdir/ssdir/ssfile,v +deleting revision 3\.1\.2\.1 +done" + dotest basica-o7 "${testcvs} log -N ssfile" " +RCS file: ${CVSROOT_DIRNAME}/first-dir/sdir/ssdir/ssfile,v +Working file: ssfile +head: 3\.1 +branch: +locks: strict +access list: +keyword substitution: kv +total revisions: 3; selected revisions: 3 +description: +---------------------------- +revision 3\.1 +date: ${ISO8601DATE}; author: ${username}; state: Exp; lines: ${PLUS}0 -0; commitid: ${commitid}; +bump-it +---------------------------- +revision 1\.2 +date: ${ISO8601DATE}; author: ${username}; state: Exp; lines: ${PLUS}1 -0; commitid: ${commitid}; +modify-it +---------------------------- +revision 1\.1 +date: ${ISO8601DATE}; author: ${username}; state: Exp; commitid: ${commitid}; +add-it +=============================================================================" + dotest basica-o8 "${testcvs} -q update -p -r 1.1 ./ssfile" "ssfile" + cd ../.. + + cd .. + + modify_repo rm -rf $CVSROOT_DIRNAME/first-dir + rm -r first-dir + ;; + + + + basicb) + # More basic tests, including non-branch tags and co -d. + mkdir 1; cd 1 + dotest basicb-0a "${testcvs} -q co -l ." '' + touch topfile + dotest basicb-0b "${testcvs} add topfile" \ +"${SPROG} add: scheduling file .topfile. for addition +${SPROG} add: use .${SPROG} commit. to add this file permanently" + dotest basicb-0c "${testcvs} -q ci -m add-it topfile" \ +"$CVSROOT_DIRNAME/topfile,v <-- topfile +initial revision: 1\.1" + cd .. + rm -r 1 + mkdir 2; cd 2 + dotest basicb-0d "${testcvs} -q co -l ." "U topfile" + # Now test the ability to run checkout on an existing working + # directory without having it lose its mind. I don't know + # whether this is tested elsewhere in sanity.sh. A more elaborate + # test might also have modified files, make sure it works if + # the modules file was modified to add new directories to the + # module, and such. + dotest basicb-0d0 "${testcvs} -q co -l ." "" + mkdir first-dir + dotest basicb-0e "${testcvs} add first-dir" \ +"Directory ${CVSROOT_DIRNAME}/first-dir added to the repository" + cd .. + rm -r 2 + + dotest basicb-1 "${testcvs} -q co first-dir" '' + + # The top-level CVS directory is not created by default. + # I'm leaving basicb-1a and basicb-1b untouched, mostly, in + # case we decide that the default should be reversed... + + dotest_fail basicb-1a "test -d CVS" '' + + dotest basicb-1c "cat first-dir/CVS/Repository" "first-dir" + + cd first-dir + # Note that the name Emptydir is chosen to test that CVS just + # treats it like any other directory name. It should be + # special only when it is directly in $CVSROOT/CVSROOT. + mkdir Emptydir sdir2 + dotest basicb-2 "${testcvs} add Emptydir sdir2" \ +"Directory ${CVSROOT_DIRNAME}/first-dir/Emptydir added to the repository +Directory ${CVSROOT_DIRNAME}/first-dir/sdir2 added to the repository" + cd Emptydir + echo sfile1 starts >sfile1 + dotest basicb-2a10 "${testcvs} -n add sfile1" \ +"${SPROG} add: scheduling file .sfile1. for addition +${SPROG} add: use .${SPROG} commit. to add this file permanently" + dotest basicb-2a11 "${testcvs} status sfile1" \ +"${SPROG} status: use \`${SPROG} add' to create an entry for \`sfile1' +=================================================================== +File: sfile1 Status: Unknown + + Working revision: No entry for sfile1 + Repository revision: No revision control file" + dotest basicb-3 "${testcvs} add sfile1" \ +"${SPROG} add: scheduling file .sfile1. for addition +${SPROG} add: use .${SPROG} commit. to add this file permanently" + dotest basicb-3a1 "${testcvs} status sfile1" \ +"=================================================================== +File: sfile1 Status: Locally Added + + Working revision: New file! + Repository revision: No revision control file + Sticky Tag: (none) + Sticky Date: (none) + Sticky Options: (none)" + + cd ../sdir2 + echo sfile2 starts >sfile2 + dotest basicb-4 "${testcvs} add sfile2" \ +"${SPROG} add: scheduling file .sfile2. for addition +${SPROG} add: use .${SPROG} commit. to add this file permanently" + dotest basicb-4a "${testcvs} -q ci CVS" \ +"${CPROG} commit: warning: directory CVS specified in argument +${CPROG} commit: but CVS uses CVS for its own purposes; skipping CVS directory" + cd .. + dotest basicb-5 "${testcvs} -q ci -m add" \ +"$CVSROOT_DIRNAME/first-dir/Emptydir/sfile1,v <-- Emptydir/sfile1 +initial revision: 1\.1 +$CVSROOT_DIRNAME/first-dir/sdir2/sfile2,v <-- sdir2/sfile2 +initial revision: 1\.1" + echo sfile1 develops >Emptydir/sfile1 + dotest basicb-6 "${testcvs} -q ci -m modify" \ +"$CVSROOT_DIRNAME/first-dir/Emptydir/sfile1,v <-- Emptydir/sfile1 +new revision: 1\.2; previous revision: 1\.1" + dotest basicb-7 "${testcvs} -q tag release-1" 'T Emptydir/sfile1 +T sdir2/sfile2' + echo not in time for release-1 >sdir2/sfile2 + dotest basicb-8 "${testcvs} -q ci -m modify-2" \ +"$CVSROOT_DIRNAME/first-dir/sdir2/sfile2,v <-- sdir2/sfile2 +new revision: 1\.2; previous revision: 1\.1" + # See if CVS can correctly notice when an invalid numeric + # revision is specified. + # Commented out until we get around to fixing CVS +: dotest basicb-8a0 "${testcvs} diff -r 1.5 -r 1.7 sfile2" 'error msg' + cd .. + + # Test that we recurse into the correct directory when checking + # for existing files, even if co -d is in use. + touch first-dir/extra + dotest basicb-cod-1 "${testcvs} -q co -d first-dir1 first-dir" \ +'U first-dir1/Emptydir/sfile1 +U first-dir1/sdir2/sfile2' + rm -r first-dir1 + + rm -r first-dir + + # FIXME? basicb-9 used to check things out like this: + # U newdir/Emptydir/sfile1 + # U newdir/sdir2/sfile2 + # but that's difficult to do. The whole "shorten" thing + # is pretty bogus, because it will break on things + # like "cvs co foo/bar baz/quux". Unless there's some + # pretty detailed expansion and analysis of the command-line + # arguments, we shouldn't do "shorten" stuff at all. + + dotest basicb-9 \ +"${testcvs} -q co -d newdir -r release-1 first-dir/Emptydir first-dir/sdir2" \ +'U newdir/first-dir/Emptydir/sfile1 +U newdir/first-dir/sdir2/sfile2' + + # basicb-9a and basicb-9b: see note about basicb-1a + + dotest_fail basicb-9a "test -d CVS" '' + + dotest basicb-9c "cat newdir/CVS/Repository" "\." + dotest basicb-9d "cat newdir/first-dir/CVS/Repository" \ +"${CVSROOT_DIRNAME}/first-dir" \ +"first-dir" + dotest basicb-9e "cat newdir/first-dir/Emptydir/CVS/Repository" \ +"${CVSROOT_DIRNAME}/first-dir/Emptydir" \ +"first-dir/Emptydir" + dotest basicb-9f "cat newdir/first-dir/sdir2/CVS/Repository" \ +"${CVSROOT_DIRNAME}/first-dir/sdir2" \ +"first-dir/sdir2" + + dotest basicb-10 "cat newdir/first-dir/Emptydir/sfile1 newdir/first-dir/sdir2/sfile2" \ +"sfile1 develops +sfile2 starts" + + rm -r newdir + + # Hmm, this might be a case for CVSNULLREPOS, but CVS doesn't + # seem to deal with it... + if false; then + dotest basicb-11 "${testcvs} -q co -d sub1/sub2 first-dir" \ +"U sub1/sub2/Emptydir/sfile1 +U sub1/sub2/sdir2/sfile2" + cd sub1 + dotest basicb-12 "${testcvs} -q update ./." '' + touch xx + dotest basicb-13 "${testcvs} add xx" fixme + cd .. + rm -r sub1 + # to test: sub1/sub2/sub3 + fi # end of tests commented out. + + # Create a second directory. + mkdir 1 + cd 1 + dotest basicb-14 "${testcvs} -q co -l ." 'U topfile' + mkdir second-dir + dotest basicb-15 "${testcvs} add second-dir" \ +"Directory ${CVSROOT_DIRNAME}/second-dir added to the repository" + cd second-dir + touch aa + dotest basicb-16 "${testcvs} add aa" \ +"${SPROG} add: scheduling file .aa. for addition +${SPROG} add: use .${SPROG} commit. to add this file permanently" + dotest basicb-17 "${testcvs} -q ci -m add" \ +"$CVSROOT_DIRNAME/second-dir/aa,v <-- aa +initial revision: 1\.1" + cd .. + + # Try to remove all revisions in a file. + dotest_fail basicb-o1 "${testcvs} admin -o1.1 topfile" \ +"RCS file: ${CVSROOT_DIRNAME}/topfile,v +deleting revision 1\.1 +${SPROG} \[admin aborted\]: attempt to delete all revisions" + dotest basicb-o2 "${testcvs} -q update -d first-dir" \ +"U first-dir/Emptydir/sfile1 +U first-dir/sdir2/sfile2" + dotest_fail basicb-o3 \ +"${testcvs} admin -o1.1:1.2 first-dir/sdir2/sfile2" \ +"RCS file: ${CVSROOT_DIRNAME}/first-dir/sdir2/sfile2,v +deleting revision 1\.2 +deleting revision 1\.1 +${SPROG} \[admin aborted\]: attempt to delete all revisions" + cd .. + rm -r 1 + + mkdir 1; cd 1 + # Note that -H is an invalid option. + # I suspect that the choice between "illegal" and "invalid" + # depends on the user's environment variables, the phase + # of the moon (weirdness with optind), and who knows what else. + # I've been seeing "illegal"... + # And I switched it to "invalid". -DRP + # POSIX 1003.2 specifies the format should be 'illegal option' + # many other folks are still using the older 'invalid option' + # lib/getopt.c will use POSIX when __posixly_correct + # otherwise the other, so accept both of them. -- mdb + dotest_fail basicb-21 "${testcvs} -q admin -H" \ +"admin: invalid option -- H +${CPROG} \[admin aborted\]: specify ${CPROG} -H admin for usage information" \ +"admin: illegal option -- H +${CPROG} \[admin aborted\]: specify ${CPROG} -H admin for usage information" + cd .. + rmdir 1 + + if $keep; then + echo Keeping ${TESTDIR} and exiting due to --keep + exit 0 + fi + + modify_repo rm -rf $CVSROOT_DIRNAME/first-dir \ + $CVSROOT_DIRNAME/second-dir + modify_repo rm -f $CVSROOT_DIRNAME/topfile,v + ;; + + + + basicc) + # More tests of basic/miscellaneous functionality. + mkdir 1; cd 1 + dotest_fail basicc-1 "$testcvs diff" \ +"$CPROG diff: in directory \.: +$CPROG \[diff aborted\]: there is no version here; run .$CPROG checkout. first" + dotest basicc-2 "$testcvs -q co -l ." + mkdir first-dir second-dir + dotest basicc-3 "${testcvs} add first-dir second-dir" \ +"Directory ${CVSROOT_DIRNAME}/first-dir added to the repository +Directory ${CVSROOT_DIRNAME}/second-dir added to the repository" + # Old versions of CVS often didn't create this top-level CVS + # directory in the first place. I think that maybe the only + # way to get it to work currently is to let CVS create it, + # and then blow it away (don't complain if it does not + # exist). But that is perfectly valid; people who are used + # to the old behavior especially may be interested. + # FIXME: this test is intended for the TopLevelAdmin=yes case; + # should adjust/move it accordingly. + rm -rf CVS + dotest basicc-4 "echo *" "first-dir second-dir" + dotest basicc-5 "${testcvs} update" \ +"${SPROG} update: Updating first-dir +${SPROG} update: Updating second-dir" \ +"${SPROG} update: Updating \. +${SPROG} update: Updating first-dir +${SPROG} update: Updating second-dir" + + cd first-dir + dotest basicc-6 "${testcvs} release -d" "" + dotest basicc-7 "test -d ../first-dir" "" + # The Linux 2.2 kernel lets you delete ".". That's OK either way, + # the point is that CVS must not mess with anything *outside* "." + # the way that CVS 1.10 and older tried to. + dotest basicc-8 "${testcvs} -Q release -d ." \ +"" "${CPROG} release: deletion of directory \. failed: .*" + dotest basicc-9 "test -d ../second-dir" "" + # For CVS to make a syntactic check for "." wouldn't suffice. + # On Linux 2.2 systems, the cwd may be gone, so we recreate it + # to allow basicc-11 to actually happen + if test ! -d ../first-dir; then + # Apparently `cd ..' doesn't work with Linux 2.2 & Bash 2.05b. + cd $TESTDIR/1 + mkdir ./first-dir + cd ./first-dir + fi + dotest basicc-11 "${testcvs} -Q release -d ./." \ +"" "${CPROG} release: deletion of directory \./\. failed: .*" + dotest basicc-11a "test -d ../second-dir" "" + + cd ../.. + + mkdir 2; cd 2 + dotest basicc-12 "${testcvs} -Q co ." "" + # actual entries can be in either Entries or Entries.log, do + # an update to get them consolidated into Entries + dotest basicc-12a "${testcvs} -Q up" "" + dotest basicc-12b "cat CVS/Entries" \ +"D/CVSROOT//// +D/first-dir//// +D/second-dir////" + dotest basicc-13 "echo *" "CVS CVSROOT first-dir second-dir" + dotest basicc-14 "${testcvs} -Q release first-dir second-dir" "" + # a normal release shouldn't affect the Entries file + dotest basicc-14b "cat CVS/Entries" \ +"D/CVSROOT//// +D/first-dir//// +D/second-dir////" + # FIXCVS: but release -d probably should + dotest basicc-15 "${testcvs} -Q release -d first-dir second-dir" "" + dotest basicc-16 "echo *" "CVS CVSROOT" + dotest basicc-17 "cat CVS/Entries" \ +"D/CVSROOT//// +D/first-dir//// +D/second-dir////" + # FIXCVS: if not, update should notice the missing directories + # and update Entries accordingly + dotest basicc-18 "${testcvs} -Q up" "" + dotest basicc-19 "cat CVS/Entries" \ +"D/CVSROOT//// +D/first-dir//// +D/second-dir////" + + cd .. + rm -r 1 2 + modify_repo rm -rf $CVSROOT_DIRNAME/first-dir \ + $CVSROOT_DIRNAME/second-dir + ;; + + + + basic1) + # first dive - add a files, first singly, then in a group. + modify_repo mkdir $CVSROOT_DIRNAME/first-dir + mkdir basic1; cd basic1 + # check out an empty directory + dotest basic1-1 "${testcvs} -q co first-dir" '' + + cd first-dir + echo file2 >file2 + echo file3 >file3 + echo file4 >file4 + echo file5 >file5 + + dotest basic1-14-add-add "${testcvs} add file2 file3 file4 file5" \ +"${SPROG} add: scheduling file \`file2' for addition +${SPROG} add: scheduling file \`file3' for addition +${SPROG} add: scheduling file \`file4' for addition +${SPROG} add: scheduling file \`file5' for addition +${SPROG} add: use .${SPROG} commit. to add these files permanently" + dotest basic1-15-add-add \ +"${testcvs} -q update file2 file3 file4 file5" \ +"A file2 +A file3 +A file4 +A file5" + dotest basic1-16-add-add "${testcvs} -q update" \ +"A file2 +A file3 +A file4 +A file5" + dotest basic1-17-add-add "${testcvs} -q status" \ +"=================================================================== +File: file2 Status: Locally Added + + Working revision: New file! + Repository revision: No revision control file + Sticky Tag: (none) + Sticky Date: (none) + Sticky Options: (none) + +=================================================================== +File: file3 Status: Locally Added + + Working revision: New file! + Repository revision: No revision control file + Sticky Tag: (none) + Sticky Date: (none) + Sticky Options: (none) + +=================================================================== +File: file4 Status: Locally Added + + Working revision: New file! + Repository revision: No revision control file + Sticky Tag: (none) + Sticky Date: (none) + Sticky Options: (none) + +=================================================================== +File: file5 Status: Locally Added + + Working revision: New file! + Repository revision: No revision control file + Sticky Tag: (none) + Sticky Date: (none) + Sticky Options: (none)" + dotest basic1-18-add-add "${testcvs} -q log" \ +"${SPROG} log: file2 has been added, but not committed +${SPROG} log: file3 has been added, but not committed +${SPROG} log: file4 has been added, but not committed +${SPROG} log: file5 has been added, but not committed" + cd .. + dotest basic1-21-add-add "${testcvs} -q update" \ +"A first-dir/file2 +A first-dir/file3 +A first-dir/file4 +A first-dir/file5" + # FIXCVS? Shouldn't this read first-dir/file2 instead of file2? + dotest basic1-22-add-add "${testcvs} log first-dir" \ +"${SPROG} log: Logging first-dir +${SPROG} log: file2 has been added, but not committed +${SPROG} log: file3 has been added, but not committed +${SPROG} log: file4 has been added, but not committed +${SPROG} log: file5 has been added, but not committed" + dotest basic1-23-add-add "${testcvs} status first-dir" \ +"${SPROG} status: Examining first-dir +=================================================================== +File: file2 Status: Locally Added + + Working revision: New file! + Repository revision: No revision control file + Sticky Tag: (none) + Sticky Date: (none) + Sticky Options: (none) + +=================================================================== +File: file3 Status: Locally Added + + Working revision: New file! + Repository revision: No revision control file + Sticky Tag: (none) + Sticky Date: (none) + Sticky Options: (none) + +=================================================================== +File: file4 Status: Locally Added + + Working revision: New file! + Repository revision: No revision control file + Sticky Tag: (none) + Sticky Date: (none) + Sticky Options: (none) + +=================================================================== +File: file5 Status: Locally Added + + Working revision: New file! + Repository revision: No revision control file + Sticky Tag: (none) + Sticky Date: (none) + Sticky Options: (none)" + dotest basic1-24-add-add "${testcvs} update first-dir" \ +"${SPROG} update: Updating first-dir +A first-dir/file2 +A first-dir/file3 +A first-dir/file4 +A first-dir/file5" + dotest basic1-27-add-add "${testcvs} co first-dir" \ +"${SPROG} checkout: Updating first-dir +A first-dir/file2 +A first-dir/file3 +A first-dir/file4 +A first-dir/file5" + cd first-dir + dotest basic1-14-add-ci \ +"$testcvs commit -m test file2 file3 file4 file5" \ +"$CVSROOT_DIRNAME/first-dir/file2,v <-- file2 +initial revision: 1\.1 +$CVSROOT_DIRNAME/first-dir/file3,v <-- file3 +initial revision: 1\.1 +$CVSROOT_DIRNAME/first-dir/file4,v <-- file4 +initial revision: 1\.1 +$CVSROOT_DIRNAME/first-dir/file5,v <-- file5 +initial revision: 1\.1" + dotest basic1-15-add-ci \ +"${testcvs} -q update file2 file3 file4 file5" '' + dotest basic1-16-add-ci "${testcvs} -q update" '' + dotest basic1-17-add-ci "${testcvs} -q status" \ +"=================================================================== +File: file2 Status: Up-to-date + + Working revision: 1\.1.* + Repository revision: 1\.1 ${CVSROOT_DIRNAME}/first-dir/file2,v + Commit Identifier: ${commitid} + Sticky Tag: (none) + Sticky Date: (none) + Sticky Options: (none) + +=================================================================== +File: file3 Status: Up-to-date + + Working revision: 1\.1.* + Repository revision: 1\.1 ${CVSROOT_DIRNAME}/first-dir/file3,v + Commit Identifier: ${commitid} + Sticky Tag: (none) + Sticky Date: (none) + Sticky Options: (none) + +=================================================================== +File: file4 Status: Up-to-date + + Working revision: 1\.1.* + Repository revision: 1\.1 ${CVSROOT_DIRNAME}/first-dir/file4,v + Commit Identifier: ${commitid} + Sticky Tag: (none) + Sticky Date: (none) + Sticky Options: (none) + +=================================================================== +File: file5 Status: Up-to-date + + Working revision: 1\.1.* + Repository revision: 1\.1 ${CVSROOT_DIRNAME}/first-dir/file5,v + Commit Identifier: ${commitid} + Sticky Tag: (none) + Sticky Date: (none) + Sticky Options: (none)" + # The "log" tests and friends probably already test the output + # from log quite adequately. + # Note: using dotest fails here. It seems to be related + # to the output being sufficiently large (Red Hat 4.1). + # dotest basic1-18-add-ci "${testcvs} log" "${DOTSTAR}" + if ${testcvs} -q log >>${LOGFILE}; then + pass basic1-18-add-ci + else + pass basic1-18-add-ci + fi + cd .. + dotest basic1-21-add-ci "${testcvs} -q update" '' + # See test basic1-18-add-ci for explanation of non-use of dotest. + if ${testcvs} -q log first-dir >>${LOGFILE}; then + pass basic1-22-add-ci + else + pass basic1-22-add-ci + fi + # At least for the moment I am going to consider 17-add-ci + # an adequate test of the output here. + # See test basic1-18-add-ci for explanation of non-use of dotest. + if ${testcvs} -q status first-dir >>${LOGFILE}; then + pass basic1-23-add-ci + else + pass basic1-23-add-ci + fi + dotest basic1-24-add-ci "${testcvs} -q update first-dir" '' + dotest basic1-27-add-ci "${testcvs} -q co first-dir" '' + + cd first-dir + rm file2 file3 file4 file5 + dotest basic1-14-rm-rm "${testcvs} rm file2 file3 file4 file5" \ +"${SPROG} remove: scheduling .file2. for removal +${SPROG} remove: scheduling .file3. for removal +${SPROG} remove: scheduling .file4. for removal +${SPROG} remove: scheduling .file5. for removal +${SPROG} remove: use .${SPROG} commit. to remove these files permanently" + # 15-rm-rm was commented out. Why? + dotest basic1-15-rm-rm \ +"${testcvs} -q update file2 file3 file4 file5" \ +"R file2 +R file3 +R file4 +R file5" + dotest basic1-16-rm-rm "${testcvs} -q update" \ +"R file2 +R file3 +R file4 +R file5" + dotest basic1-17-rm-rm "${testcvs} -q status" \ +"=================================================================== +File: no file file2 Status: Locally Removed + + Working revision: -1\.1.* + Repository revision: 1\.1 ${CVSROOT_DIRNAME}/first-dir/file2,v + Commit Identifier: ${commitid} + Sticky Tag: (none) + Sticky Date: (none) + Sticky Options: (none) + +=================================================================== +File: no file file3 Status: Locally Removed + + Working revision: -1\.1.* + Repository revision: 1\.1 ${CVSROOT_DIRNAME}/first-dir/file3,v + Commit Identifier: ${commitid} + Sticky Tag: (none) + Sticky Date: (none) + Sticky Options: (none) + +=================================================================== +File: no file file4 Status: Locally Removed + + Working revision: -1\.1.* + Repository revision: 1\.1 ${CVSROOT_DIRNAME}/first-dir/file4,v + Commit Identifier: ${commitid} + Sticky Tag: (none) + Sticky Date: (none) + Sticky Options: (none) + +=================================================================== +File: no file file5 Status: Locally Removed + + Working revision: -1\.1.* + Repository revision: 1\.1 ${CVSROOT_DIRNAME}/first-dir/file5,v + Commit Identifier: ${commitid} + Sticky Tag: (none) + Sticky Date: (none) + Sticky Options: (none)" + # Would be nice to test that real logs appear (with dead state + # and all), either here or someplace like log2 tests. + if ${testcvs} -q log >>${LOGFILE}; then + pass basic1-18-rm-rm + else + fail basic1-18-rm-rm + fi + cd .. + dotest basic1-21-rm-rm "${testcvs} -q update" \ +"R first-dir/file2 +R first-dir/file3 +R first-dir/file4 +R first-dir/file5" + if ${testcvs} -q log first-dir >>${LOGFILE}; then + pass basic1-22-rm-rm + else + fail basic1-22-rm-rm + fi + if ${testcvs} -q status first-dir >>${LOGFILE}; then + pass basic1-23-rm-rm + else + fail basic1-23-rm-rm + fi + dotest basic1-24-rm-rm "${testcvs} -q update first-dir" \ +"R first-dir/file2 +R first-dir/file3 +R first-dir/file4 +R first-dir/file5" + dotest basic1-27-rm-rm "${testcvs} -q co first-dir" \ +"R first-dir/file2 +R first-dir/file3 +R first-dir/file4 +R first-dir/file5" + cd first-dir + dotest basic1-14-rm-ci "${testcvs} -q commit -m test" \ +"$CVSROOT_DIRNAME/first-dir/file2,v <-- file2 +new revision: delete; previous revision: 1\.1 +$CVSROOT_DIRNAME/first-dir/file3,v <-- file3 +new revision: delete; previous revision: 1\.1 +$CVSROOT_DIRNAME/first-dir/file4,v <-- file4 +new revision: delete; previous revision: 1\.1 +$CVSROOT_DIRNAME/first-dir/file5,v <-- file5 +new revision: delete; previous revision: 1\.1" + dotest basic1-15-rm-ci \ +"${testcvs} -q update file2 file3 file4 file5" '' + dotest basic1-16-rm-ci "${testcvs} -q update" '' + dotest basic1-17-rm-ci "${testcvs} -q status" '' + # Would be nice to test that real logs appear (with dead state + # and all), either here or someplace like log2 tests. + if ${testcvs} -q log >>${LOGFILE}; then + pass basic1-18-rm-ci + else + fail basic1-18-rm-ci + fi + cd .. + dotest basic1-21-rm-ci "${testcvs} -q update" '' + if ${testcvs} -q log first-dir >>${LOGFILE}; then + pass basic1-22-rm-ci + else + fail basic1-22-rm-ci + fi + if ${testcvs} -q status first-dir >>${LOGFILE}; then + pass basic1-23-rm-ci + else + fail basic1-23-rm-ci + fi + dotest basic1-24-rm-ci "${testcvs} -q update first-dir" '' + dotest basic1-27-rm-ci "${testcvs} -q co first-dir" '' + cd first-dir + # All the files are removed, so nothing gets tagged. + dotest basic1-28 "${testcvs} -q tag first-dive" '' + cd .. + cd .. + + if $keep; then + echo Keeping ${TESTDIR} and exiting due to --keep + exit 0 + fi + + rm -r basic1 + modify_repo rm -rf $CVSROOT_DIRNAME/first-dir + ;; + + + + deep) + # Test the ability to operate on directories nested rather deeply. + modify_repo mkdir $CVSROOT_DIRNAME/first-dir + dotest deep-1 "${testcvs} -q co first-dir" '' + cd first-dir + for i in dir1 dir2 dir3 dir4 dir5 dir6 dir7 dir8; do + mkdir $i + dotest deep-2-$i "${testcvs} add $i" \ +"Directory ${CVSROOT_DIRNAME}/first-dir/dir1[/dir0-9]* added to the repository" + cd $i + echo file1 >file1 + dotest deep-3-$i "${testcvs} add file1" \ +"${SPROG}"' add: scheduling file `file1'\'' for addition +'"${SPROG}"' add: use .'"${SPROG}"' commit. to add this file permanently' + done + cd ../../../../../../../../.. + dotest_lit deep-4 "$testcvs -q ci -m add-them first-dir" <<HERE +$CVSROOT_DIRNAME/first-dir/dir1/file1,v <-- first-dir/dir1/file1 +initial revision: 1.1 +$CVSROOT_DIRNAME/first-dir/dir1/dir2/file1,v <-- first-dir/dir1/dir2/file1 +initial revision: 1.1 +$CVSROOT_DIRNAME/first-dir/dir1/dir2/dir3/file1,v <-- first-dir/dir1/dir2/dir3/file1 +initial revision: 1.1 +$CVSROOT_DIRNAME/first-dir/dir1/dir2/dir3/dir4/file1,v <-- first-dir/dir1/dir2/dir3/dir4/file1 +initial revision: 1.1 +$CVSROOT_DIRNAME/first-dir/dir1/dir2/dir3/dir4/dir5/file1,v <-- first-dir/dir1/dir2/dir3/dir4/dir5/file1 +initial revision: 1.1 +$CVSROOT_DIRNAME/first-dir/dir1/dir2/dir3/dir4/dir5/dir6/file1,v <-- first-dir/dir1/dir2/dir3/dir4/dir5/dir6/file1 +initial revision: 1.1 +$CVSROOT_DIRNAME/first-dir/dir1/dir2/dir3/dir4/dir5/dir6/dir7/file1,v <-- first-dir/dir1/dir2/dir3/dir4/dir5/dir6/dir7/file1 +initial revision: 1.1 +$CVSROOT_DIRNAME/first-dir/dir1/dir2/dir3/dir4/dir5/dir6/dir7/dir8/file1,v <-- first-dir/dir1/dir2/dir3/dir4/dir5/dir6/dir7/dir8/file1 +initial revision: 1.1 +HERE + + cd first-dir/dir1/dir2/dir3/dir4/dir5/dir6/dir7/dir8 + rm file1 + dotest deep-4a0 "$testcvs rm file1" \ +"$SPROG remove: scheduling .file1. for removal +$SPROG remove: use .$SPROG commit. to remove this file permanently" + dotest deep-4a1 "$testcvs -q ci -m rm-it" \ +"$CVSROOT_DIRNAME/first-dir/dir1/dir2/dir3/dir4/dir5/dir6/dir7/dir8/file1,v <-- file1 +new revision: delete; previous revision: 1\.1" + cd ../../.. + dotest deep-4a2 "${testcvs} -q update -P dir6/dir7" '' + # Should be using "test -e", but it's not portable enough - + # Solaris 2.5 does not have it. + dotest_fail deep-4a3 "test -d dir6/dir7/dir8" '' + + # Test that if we remove the working directory, CVS does not + # recreate it. (I realize that this behavior is what the + # users expect, but in the longer run we might want to + # re-think it. The corresponding behavior for a file is that + # CVS *will* recreate it, and we might want to make it so + # that "cvs release -d" is the way to delete the directory + # and have it stay gone -kingdon, Oct1996). + rm -r dir6 + dotest deep-4b0a "${testcvs} -q diff" + dotest deep-4b0b "${testcvs} -q ci" + dotest deep-4b1 "${testcvs} -q update" + dotest deep-4b2 "${testcvs} -q update -d -P" \ +'U dir6/file1 +U dir6/dir7/file1' + + # Test what happens if one uses -P when there are files removed + # but not committed. + cd dir6/dir7 + dotest deep-rm1 "${testcvs} rm -f file1" \ +"${SPROG} remove: scheduling .file1. for removal +${SPROG} remove: use .${SPROG} commit. to remove this file permanently" + cd .. + dotest deep-rm2 "${testcvs} -q update -d -P" 'R dir7/file1' + dotest deep-rm3 "test -d dir7" '' + dotest deep-rm4 "$testcvs -q ci -m rm-it" \ +"$CVSROOT_DIRNAME/first-dir/dir1/dir2/dir3/dir4/dir5/dir6/dir7/file1,v <-- dir7/file1 +new revision: delete; previous revision: 1\.1" + dotest deep-rm5 "${testcvs} -q update -d -P" '' + dotest_fail deep-rm6 "test -d dir7" '' + + # Test rm -f -R. + cd ../.. + dotest deep-rm7 "${testcvs} rm -f -R dir5" \ +"${SPROG} remove: Removing dir5 +${SPROG} remove: scheduling .dir5/file1. for removal +${SPROG} remove: Removing dir5/dir6 +${SPROG} remove: scheduling .dir5/dir6/file1. for removal +${SPROG} remove: use .${SPROG} commit. to remove these files permanently" + dotest deep-rm8 "${testcvs} -q ci -m rm-it" \ +"$CVSROOT_DIRNAME/first-dir/dir1/dir2/dir3/dir4/dir5/file1,v <-- dir5/file1 +new revision: delete; previous revision: 1\.1 +$CVSROOT_DIRNAME/first-dir/dir1/dir2/dir3/dir4/dir5/dir6/file1,v <-- dir5/dir6/file1 +new revision: delete; previous revision: 1\.1" + dotest deep-rm9 "${testcvs} -q update -d -P" '' + dotest_fail deep-rm10 "test -d dir5" + + cd ../../../../.. + + if echo "yes" | $testcvs release -d first-dir >>$LOGFILE 2>&1; then + pass deep-5 + else + fail deep-5 + fi + modify_repo rm -rf $CVSROOT_DIRNAME/first-dir + ;; + + + + basic2) + # Test rtag, import, history, various miscellaneous operations + + # NOTE: this section has reached the size and + # complexity where it is getting to be a good idea to + # add new tests to a new section rather than + # continuing to piggyback them onto the tests here. + + # First empty the history file + modify_repo rm -rf $CVSROOT_DIRNAME/CVSROOT/history + modify_repo touch $CVSROOT_DIRNAME/CVSROOT/history + + modify_repo mkdir $CVSROOT_DIRNAME/first-dir + dotest basic2-1 "$testcvs -q co first-dir" + for i in first-dir dir1 dir2 ; do + if test ! -d $i ; then + mkdir $i + dotest basic2-2-$i "${testcvs} add $i" \ +"Directory ${CVSROOT_DIRNAME}/.*/$i added to the repository" + fi + + cd $i + + for j in file6 file7; do + echo $j > $j + done + + dotest basic2-3-$i "${testcvs} add file6 file7" \ +"${SPROG} add: scheduling file .file6. for addition +${SPROG} add: scheduling file .file7. for addition +${SPROG} add: use .${SPROG} commit. to add these files permanently" + + done + cd ../../.. + dotest basic2-4 "${testcvs} update first-dir" \ +"${SPROG} update: Updating first-dir +A first-dir/file6 +A first-dir/file7 +${SPROG} update: Updating first-dir/dir1 +A first-dir/dir1/file6 +A first-dir/dir1/file7 +${SPROG} update: Updating first-dir/dir1/dir2 +A first-dir/dir1/dir2/file6 +A first-dir/dir1/dir2/file7" + + # fixme: doesn't work right for added files. + dotest basic2-5 "${testcvs} log first-dir" \ +"${SPROG} log: Logging first-dir +${SPROG} log: file6 has been added, but not committed +${SPROG} log: file7 has been added, but not committed +${SPROG} log: Logging first-dir/dir1 +${SPROG} log: file6 has been added, but not committed +${SPROG} log: file7 has been added, but not committed +${SPROG} log: Logging first-dir/dir1/dir2 +${SPROG} log: file6 has been added, but not committed +${SPROG} log: file7 has been added, but not committed" + + dotest basic2-6 "${testcvs} status first-dir" \ +"${SPROG} status: Examining first-dir +=================================================================== +File: file6 Status: Locally Added + + Working revision: New file! + Repository revision: No revision control file + Sticky Tag: (none) + Sticky Date: (none) + Sticky Options: (none) + +=================================================================== +File: file7 Status: Locally Added + + Working revision: New file! + Repository revision: No revision control file + Sticky Tag: (none) + Sticky Date: (none) + Sticky Options: (none) + +${SPROG} status: Examining first-dir/dir1 +=================================================================== +File: file6 Status: Locally Added + + Working revision: New file! + Repository revision: No revision control file + Sticky Tag: (none) + Sticky Date: (none) + Sticky Options: (none) + +=================================================================== +File: file7 Status: Locally Added + + Working revision: New file! + Repository revision: No revision control file + Sticky Tag: (none) + Sticky Date: (none) + Sticky Options: (none) + +${SPROG} status: Examining first-dir/dir1/dir2 +=================================================================== +File: file6 Status: Locally Added + + Working revision: New file! + Repository revision: No revision control file + Sticky Tag: (none) + Sticky Date: (none) + Sticky Options: (none) + +=================================================================== +File: file7 Status: Locally Added + + Working revision: New file! + Repository revision: No revision control file + Sticky Tag: (none) + Sticky Date: (none) + Sticky Options: (none)" + +# XXX why is this commented out??? +# if ${CVS} diff -u first-dir >> ${LOGFILE} || test $? = 1 ; then +# pass 34 +# else +# fail 34 +# fi + + dotest basic2-8 "${testcvs} -q ci -m 'second dive' first-dir" \ +"$CVSROOT_DIRNAME/first-dir/file6,v <-- first-dir/file6 +initial revision: 1\.1 +$CVSROOT_DIRNAME/first-dir/file7,v <-- first-dir/file7 +initial revision: 1\.1 +$CVSROOT_DIRNAME/first-dir/dir1/file6,v <-- first-dir/dir1/file6 +initial revision: 1\.1 +$CVSROOT_DIRNAME/first-dir/dir1/file7,v <-- first-dir/dir1/file7 +initial revision: 1\.1 +$CVSROOT_DIRNAME/first-dir/dir1/dir2/file6,v <-- first-dir/dir1/dir2/file6 +initial revision: 1\.1 +$CVSROOT_DIRNAME/first-dir/dir1/dir2/file7,v <-- first-dir/dir1/dir2/file7 +initial revision: 1\.1" + + dotest basic2-9 "${testcvs} tag second-dive first-dir" \ +"${SPROG} tag: Tagging first-dir +T first-dir/file6 +T first-dir/file7 +${SPROG} tag: Tagging first-dir/dir1 +T first-dir/dir1/file6 +T first-dir/dir1/file7 +${SPROG} tag: Tagging first-dir/dir1/dir2 +T first-dir/dir1/dir2/file6 +T first-dir/dir1/dir2/file7" + + # third dive - in bunch o' directories, add bunch o' files, + # delete some, change some. + + for i in first-dir dir1 dir2 ; do + cd $i + + # modify a file + echo file6 >>file6 + + # delete a file + rm file7 + + dotest basic2-10-$i "${testcvs} rm file7" \ +"${SPROG} remove: scheduling .file7. for removal +${SPROG} remove: use .${SPROG} commit. to remove this file permanently" + + # and add a new file + echo file14 >file14 + + dotest basic2-11-$i "${testcvs} add file14" \ +"${SPROG} add: scheduling file .file14. for addition +${SPROG} add: use .${SPROG} commit. to add this file permanently" + done + + cd ../../.. + dotest basic2-12 "${testcvs} update first-dir" \ +"${SPROG} update: Updating first-dir +A first-dir/file14 +M first-dir/file6 +R first-dir/file7 +${SPROG} update: Updating first-dir/dir1 +A first-dir/dir1/file14 +M first-dir/dir1/file6 +R first-dir/dir1/file7 +${SPROG} update: Updating first-dir/dir1/dir2 +A first-dir/dir1/dir2/file14 +M first-dir/dir1/dir2/file6 +R first-dir/dir1/dir2/file7" + + # FIXME: doesn't work right for added files + dotest basic2-13 "${testcvs} log first-dir" \ +"${SPROG} log: Logging first-dir +${SPROG} log: file14 has been added, but not committed + +RCS file: ${CVSROOT_DIRNAME}/first-dir/file6,v +Working file: first-dir/file6 +head: 1\.1 +branch: +locks: strict +access list: +symbolic names: + second-dive: 1\.1 +keyword substitution: kv +total revisions: 1; selected revisions: 1 +description: +---------------------------- +revision 1\.1 +date: ${ISO8601DATE}; author: ${username}; state: Exp; commitid: ${commitid}; +second dive +============================================================================= + +RCS file: ${CVSROOT_DIRNAME}/first-dir/file7,v +Working file: first-dir/file7 +head: 1\.1 +branch: +locks: strict +access list: +symbolic names: + second-dive: 1\.1 +keyword substitution: kv +total revisions: 1; selected revisions: 1 +description: +---------------------------- +revision 1\.1 +date: ${ISO8601DATE}; author: ${username}; state: Exp; commitid: ${commitid}; +second dive +============================================================================= +${SPROG} log: Logging first-dir/dir1 +${SPROG} log: file14 has been added, but not committed + +RCS file: ${CVSROOT_DIRNAME}/first-dir/dir1/file6,v +Working file: first-dir/dir1/file6 +head: 1\.1 +branch: +locks: strict +access list: +symbolic names: + second-dive: 1\.1 +keyword substitution: kv +total revisions: 1; selected revisions: 1 +description: +---------------------------- +revision 1\.1 +date: ${ISO8601DATE}; author: ${username}; state: Exp; commitid: ${commitid}; +second dive +============================================================================= + +RCS file: ${CVSROOT_DIRNAME}/first-dir/dir1/file7,v +Working file: first-dir/dir1/file7 +head: 1\.1 +branch: +locks: strict +access list: +symbolic names: + second-dive: 1\.1 +keyword substitution: kv +total revisions: 1; selected revisions: 1 +description: +---------------------------- +revision 1\.1 +date: ${ISO8601DATE}; author: ${username}; state: Exp; commitid: ${commitid}; +second dive +============================================================================= +${SPROG} log: Logging first-dir/dir1/dir2 +${SPROG} log: file14 has been added, but not committed + +RCS file: ${CVSROOT_DIRNAME}/first-dir/dir1/dir2/file6,v +Working file: first-dir/dir1/dir2/file6 +head: 1\.1 +branch: +locks: strict +access list: +symbolic names: + second-dive: 1\.1 +keyword substitution: kv +total revisions: 1; selected revisions: 1 +description: +---------------------------- +revision 1\.1 +date: ${ISO8601DATE}; author: ${username}; state: Exp; commitid: ${commitid}; +second dive +============================================================================= + +RCS file: ${CVSROOT_DIRNAME}/first-dir/dir1/dir2/file7,v +Working file: first-dir/dir1/dir2/file7 +head: 1\.1 +branch: +locks: strict +access list: +symbolic names: + second-dive: 1\.1 +keyword substitution: kv +total revisions: 1; selected revisions: 1 +description: +---------------------------- +revision 1\.1 +date: ${ISO8601DATE}; author: ${username}; state: Exp; commitid: ${commitid}; +second dive +=============================================================================" + + dotest basic2-14 "${testcvs} status first-dir" \ +"${SPROG} status: Examining first-dir +=================================================================== +File: file14 Status: Locally Added + + Working revision: New file! + Repository revision: No revision control file + Sticky Tag: (none) + Sticky Date: (none) + Sticky Options: (none) + +=================================================================== +File: file6 Status: Locally Modified + + Working revision: 1\.1.* + Repository revision: 1\.1 ${CVSROOT_DIRNAME}/first-dir/file6,v + Commit Identifier: ${commitid} + Sticky Tag: (none) + Sticky Date: (none) + Sticky Options: (none) + +=================================================================== +File: no file file7 Status: Locally Removed + + Working revision: -1\.1.* + Repository revision: 1\.1 ${CVSROOT_DIRNAME}/first-dir/file7,v + Commit Identifier: ${commitid} + Sticky Tag: (none) + Sticky Date: (none) + Sticky Options: (none) + +${SPROG} status: Examining first-dir/dir1 +=================================================================== +File: file14 Status: Locally Added + + Working revision: New file! + Repository revision: No revision control file + Sticky Tag: (none) + Sticky Date: (none) + Sticky Options: (none) + +=================================================================== +File: file6 Status: Locally Modified + + Working revision: 1\.1.* + Repository revision: 1\.1 ${CVSROOT_DIRNAME}/first-dir/dir1/file6,v + Commit Identifier: ${commitid} + Sticky Tag: (none) + Sticky Date: (none) + Sticky Options: (none) + +=================================================================== +File: no file file7 Status: Locally Removed + + Working revision: -1\.1.* + Repository revision: 1\.1 ${CVSROOT_DIRNAME}/first-dir/dir1/file7,v + Commit Identifier: ${commitid} + Sticky Tag: (none) + Sticky Date: (none) + Sticky Options: (none) + +${SPROG} status: Examining first-dir/dir1/dir2 +=================================================================== +File: file14 Status: Locally Added + + Working revision: New file! + Repository revision: No revision control file + Sticky Tag: (none) + Sticky Date: (none) + Sticky Options: (none) + +=================================================================== +File: file6 Status: Locally Modified + + Working revision: 1\.1.* + Repository revision: 1\.1 ${CVSROOT_DIRNAME}/first-dir/dir1/dir2/file6,v + Commit Identifier: ${commitid} + Sticky Tag: (none) + Sticky Date: (none) + Sticky Options: (none) + +=================================================================== +File: no file file7 Status: Locally Removed + + Working revision: -1\.1.* + Repository revision: 1\.1 ${CVSROOT_DIRNAME}/first-dir/dir1/dir2/file7,v + Commit Identifier: ${commitid} + Sticky Tag: (none) + Sticky Date: (none) + Sticky Options: (none)${DOTSTAR}" + +# XXX why is this commented out? +# if ${CVS} diff -u first-dir >> ${LOGFILE} || test $? = 1 ; then +# pass 42 +# else +# fail 42 +# fi + + dotest basic2-16 "${testcvs} ci -m 'third dive' first-dir" \ +"${CPROG} commit: Examining first-dir +${CPROG} commit: Examining first-dir/dir1 +${CPROG} commit: Examining first-dir/dir1/dir2 +${CVSROOT_DIRNAME}/first-dir/file14,v <-- first-dir/file14 +initial revision: 1\.1 +${CVSROOT_DIRNAME}/first-dir/file6,v <-- first-dir/file6 +new revision: 1\.2; previous revision: 1\.1 +${CVSROOT_DIRNAME}/first-dir/file7,v <-- first-dir/file7 +new revision: delete; previous revision: 1\.1 +${CVSROOT_DIRNAME}/first-dir/dir1/file14,v <-- first-dir/dir1/file14 +initial revision: 1\.1 +${CVSROOT_DIRNAME}/first-dir/dir1/file6,v <-- first-dir/dir1/file6 +new revision: 1\.2; previous revision: 1\.1 +${CVSROOT_DIRNAME}/first-dir/dir1/file7,v <-- first-dir/dir1/file7 +new revision: delete; previous revision: 1\.1 +${CVSROOT_DIRNAME}/first-dir/dir1/dir2/file14,v <-- first-dir/dir1/dir2/file14 +initial revision: 1\.1 +${CVSROOT_DIRNAME}/first-dir/dir1/dir2/file6,v <-- first-dir/dir1/dir2/file6 +new revision: 1\.2; previous revision: 1\.1 +${CVSROOT_DIRNAME}/first-dir/dir1/dir2/file7,v <-- first-dir/dir1/dir2/file7 +new revision: delete; previous revision: 1\.1" + dotest basic2-17 "${testcvs} -q update first-dir" '' + + dotest basic2-18 "${testcvs} tag third-dive first-dir" \ +"${SPROG} tag: Tagging first-dir +T first-dir/file14 +T first-dir/file6 +${SPROG} tag: Tagging first-dir/dir1 +T first-dir/dir1/file14 +T first-dir/dir1/file6 +${SPROG} tag: Tagging first-dir/dir1/dir2 +T first-dir/dir1/dir2/file14 +T first-dir/dir1/dir2/file6" + + dotest basic2-19 "echo yes | ${testcvs} release -d first-dir" \ +"You have \[0\] altered files in this repository\. +Are you sure you want to release (and delete) directory .first-dir.: " + + # end of third dive + dotest_fail basic2-20 "test -d first-dir" "" + + # now try some rtags + + # rtag HEADS + dotest basic2-21 "${testcvs} rtag rtagged-by-head first-dir" \ +"${SPROG} rtag: Tagging first-dir +${SPROG} rtag: Tagging first-dir/dir1 +${SPROG} rtag: Tagging first-dir/dir1/dir2" + + dotest basic2-21b "${testcvs} co -p -r rtagged-by-head first-dir/file6" \ +"=================================================================== +Checking out first-dir/file6 +RCS: $CVSROOT_DIRNAME/first-dir/file6,v +VERS: 1\.2 +\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* +file6 +file6" + # see what happens when val-tags is removed + modify_repo mv $CVSROOT_DIRNAME/CVSROOT/val-tags \ + $CVSROOT_DIRNAME/CVSROOT/val-tags.save + # The output for this used to be something like: + # "${SPROG} checkout: cannot open CVS/Entries for reading: No such file or directory + # ${SPROG} \[checkout aborted\]: no such tag \`rtagged-by-head'" + + dotest basic2-21c \ +"${testcvs} co -p -r rtagged-by-head first-dir/file6" \ +"=================================================================== +Checking out first-dir/file6 +RCS: $CVSROOT_DIRNAME/first-dir/file6,v +VERS: 1\.2 +\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* +file6 +file6" + modify_repo mv $CVSROOT_DIRNAME/CVSROOT/val-tags.save \ + $CVSROOT_DIRNAME/CVSROOT/val-tags + + # tag by tag + dotest basic2-22 "${testcvs} rtag -r rtagged-by-head rtagged-by-tag first-dir" \ +"${SPROG} rtag: Tagging first-dir +${SPROG} rtag: Tagging first-dir/dir1 +${SPROG} rtag: Tagging first-dir/dir1/dir2" + + # tag by revision + dotest basic2-23 "${testcvs} rtag -r1.1 rtagged-by-revision first-dir" \ +"${SPROG} rtag: Tagging first-dir +${SPROG} rtag: Tagging first-dir/dir1 +${SPROG} rtag: Tagging first-dir/dir1/dir2" + + # rdiff by revision + dotest basic2-24 "${testcvs} rdiff -r1.1 -rrtagged-by-head first-dir" \ +"${SPROG} rdiff: Diffing first-dir +Index: first-dir/file6 +diff -c first-dir/file6:1\.1 first-dir/file6:1\.2 +\*\*\* first-dir/file6:1\.1 ${DATE} +--- first-dir/file6 ${DATE} +\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* +\*\*\* 1 \*\*\*\* +--- 1,2 ---- + file6 +${PLUS} file6 +Index: first-dir/file7 +diff -c first-dir/file7:1\.1 first-dir/file7:removed +\*\*\* first-dir/file7:1.1 ${DATE} +--- first-dir/file7 ${DATE} +\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* +\*\*\* 1 \*\*\*\* +- file7 +--- 0 ---- +${SPROG} rdiff: Diffing first-dir/dir1 +Index: first-dir/dir1/file6 +diff -c first-dir/dir1/file6:1\.1 first-dir/dir1/file6:1\.2 +\*\*\* first-dir/dir1/file6:1\.1 ${DATE} +--- first-dir/dir1/file6 ${DATE} +\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* +\*\*\* 1 \*\*\*\* +--- 1,2 ---- + file6 +${PLUS} file6 +Index: first-dir/dir1/file7 +diff -c first-dir/dir1/file7:1\.1 first-dir/dir1/file7:removed +\*\*\* first-dir/dir1/file7:1\.1 ${DATE} +--- first-dir/dir1/file7 ${DATE} +\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* +\*\*\* 1 \*\*\*\* +- file7 +--- 0 ---- +${SPROG} rdiff: Diffing first-dir/dir1/dir2 +Index: first-dir/dir1/dir2/file6 +diff -c first-dir/dir1/dir2/file6:1\.1 first-dir/dir1/dir2/file6:1\.2 +\*\*\* first-dir/dir1/dir2/file6:1\.1 ${DATE} +--- first-dir/dir1/dir2/file6 ${DATE} +\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* +\*\*\* 1 \*\*\*\* +--- 1,2 ---- + file6 +${PLUS} file6 +Index: first-dir/dir1/dir2/file7 +diff -c first-dir/dir1/dir2/file7:1\.1 first-dir/dir1/dir2/file7:removed +\*\*\* first-dir/dir1/dir2/file7:1\.1 ${DATE} +--- first-dir/dir1/dir2/file7 ${DATE} +\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* +\*\*\* 1 \*\*\*\* +- file7 +--- 0 ----" + dotest basic2-24a "${testcvs} rdiff -l -r1.1 -rrtagged-by-head first-dir" \ +"${SPROG} rdiff: Diffing first-dir +Index: first-dir/file6 +diff -c first-dir/file6:1\.1 first-dir/file6:1\.2 +\*\*\* first-dir/file6:1\.1 ${DATE} +--- first-dir/file6 ${DATE} +\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* +\*\*\* 1 \*\*\*\* +--- 1,2 ---- + file6 +${PLUS} file6 +Index: first-dir/file7 +diff -c first-dir/file7:1\.1 first-dir/file7:removed +\*\*\* first-dir/file7:1.1 ${DATE} +--- first-dir/file7 ${DATE} +\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* +\*\*\* 1 \*\*\*\* +- file7 +--- 0 ----" + # now export by rtagged-by-head and rtagged-by-tag and compare. + dotest basic2-25 "${testcvs} export -r rtagged-by-head -d 1dir first-dir" \ +"${SPROG} export: Updating 1dir +U 1dir/file14 +U 1dir/file6 +${SPROG} export: Updating 1dir/dir1 +U 1dir/dir1/file14 +U 1dir/dir1/file6 +${SPROG} export: Updating 1dir/dir1/dir2 +U 1dir/dir1/dir2/file14 +U 1dir/dir1/dir2/file6" + dotest_fail basic2-25a "test -d 1dir/CVS" + dotest_fail basic2-25b "test -d 1dir/dir1/CVS" + dotest_fail basic2-25c "test -d 1dir/dir1/dir2/CVS" + + dotest basic2-26 "${testcvs} export -r rtagged-by-tag first-dir" \ +"${SPROG} export: Updating first-dir +U first-dir/file14 +U first-dir/file6 +${SPROG} export: Updating first-dir/dir1 +U first-dir/dir1/file14 +U first-dir/dir1/file6 +${SPROG} export: Updating first-dir/dir1/dir2 +U first-dir/dir1/dir2/file14 +U first-dir/dir1/dir2/file6" + dotest_fail basic2-26a "test -d first-dir/CVS" + dotest_fail basic2-26b "test -d first-dir/dir1/CVS" + dotest_fail basic2-26c "test -d first-dir/dir1/dir2/CVS" + + dotest basic2-27 "directory_cmp 1dir first-dir" + rm -r 1dir first-dir + + # checkout by revision vs export by rtagged-by-revision and compare. + mkdir export-dir + dotest basic2-28 "${testcvs} export -rrtagged-by-revision -d export-dir first-dir" \ +"${SPROG} export: Updating export-dir +U export-dir/file14 +U export-dir/file6 +U export-dir/file7 +${SPROG} export: Updating export-dir/dir1 +U export-dir/dir1/file14 +U export-dir/dir1/file6 +U export-dir/dir1/file7 +${SPROG} export: Updating export-dir/dir1/dir2 +U export-dir/dir1/dir2/file14 +U export-dir/dir1/dir2/file6 +U export-dir/dir1/dir2/file7" + dotest_fail basic2-28a "test -d export-dir/CVS" + dotest_fail basic2-28b "test -d export-dir/dir1/CVS" + dotest_fail basic2-28c "test -d export-dir/dir1/dir2/CVS" + + dotest basic2-29 "${testcvs} co -r1.1 first-dir" \ +"${SPROG} checkout: Updating first-dir +U first-dir/file14 +U first-dir/file6 +U first-dir/file7 +${SPROG} checkout: Updating first-dir/dir1 +U first-dir/dir1/file14 +U first-dir/dir1/file6 +U first-dir/dir1/file7 +${SPROG} checkout: Updating first-dir/dir1/dir2 +U first-dir/dir1/dir2/file14 +U first-dir/dir1/dir2/file6 +U first-dir/dir1/dir2/file7" + + # directory copies are done in an oblique way in order to avoid a bug in sun's tmp filesystem. + mkdir first-dir.cpy ; (cd first-dir ; tar cf - . | (cd ../first-dir.cpy ; tar xf -)) + + dotest basic2-30 "directory_cmp first-dir export-dir" + + # interrupt, while we've got a clean 1.1 here, let's import it + # into a couple of other modules. + cd export-dir + dotest_sort basic2-31 \ +"$testcvs import -m first-import second-dir first-immigration immigration1 immigration1_0" \ +" + +N second-dir/dir1/dir2/file14 +N second-dir/dir1/dir2/file6 +N second-dir/dir1/dir2/file7 +N second-dir/dir1/file14 +N second-dir/dir1/file6 +N second-dir/dir1/file7 +N second-dir/file14 +N second-dir/file6 +N second-dir/file7 +No conflicts created by this import +${SPROG} import: Importing ${CVSROOT_DIRNAME}/second-dir/dir1 +${SPROG} import: Importing ${CVSROOT_DIRNAME}/second-dir/dir1/dir2" + cd .. + + dotest basic2-32 "${testcvs} export -r HEAD second-dir" \ +"${SPROG} export: Updating second-dir +U second-dir/file14 +U second-dir/file6 +U second-dir/file7 +${SPROG} export: Updating second-dir/dir1 +U second-dir/dir1/file14 +U second-dir/dir1/file6 +U second-dir/dir1/file7 +${SPROG} export: Updating second-dir/dir1/dir2 +U second-dir/dir1/dir2/file14 +U second-dir/dir1/dir2/file6 +U second-dir/dir1/dir2/file7" + + dotest basic2-33 "directory_cmp first-dir second-dir" + + rm -r second-dir + + rm -r export-dir first-dir + mkdir first-dir + (cd first-dir.cpy ; tar cf - . | (cd ../first-dir ; tar xf -)) + + # update the top, cancelling sticky tags, retag, update other copy, compare. + cd first-dir + dotest basic2-34 "${testcvs} update -A -l *file*" \ +"[UP] file6 +${SPROG} update: \`file7' is no longer in the repository" + + # If we don't delete the tag first, cvs won't retag it. + # This would appear to be a feature. + dotest basic2-35 "${testcvs} tag -l -d rtagged-by-revision" \ +"${SPROG} tag: Untagging \. +D file14 +D file6" + dotest basic2-36 "${testcvs} tag -l rtagged-by-revision" \ +"${SPROG} tag: Tagging \. +T file14 +T file6" + + cd .. + mv first-dir 1dir + mv first-dir.cpy first-dir + cd first-dir + + dotest basic2-37 "${testcvs} -q diff -u" '' + + dotest basic2-38 "${testcvs} update" \ +"${SPROG} update: Updating . +${SPROG} update: Updating dir1 +${SPROG} update: Updating dir1/dir2" + + cd .. + + #### FIXME: is this expected to work??? Need to investigate + #### and fix or remove the test. +# dotest basic2-39 "directory_cmp 1dir first-dir" + + rm -r 1dir first-dir + + # Test the cvs history command. + # + # Just skip these in write proxy mode for now. We should only + # see write commands and maybe the last few reads in the + # secondary history file the way we currently sync, but I'm not + # going to try and test this yet. + if $proxy; then :; else + + # The reason that there are two patterns rather than using + # \(${TESTDIR}\|<remote>\) is that we are trying to + # make this portable. Perhaps at some point we should + # ditch that notion and require GNU expr (or dejagnu or....) + # since it seems to be so painful. + + dotest basic2-64 "${testcvs} his -x TOFWUPCGMAR -a" \ +"O [0-9-]* [0-9:]* ${PLUS}0000 ${username} first-dir =first-dir= ${TESTDIR}/\* +A [0-9-]* [0-9:]* ${PLUS}0000 ${username} 1\.1 file6 first-dir == ${TESTDIR} +A [0-9-]* [0-9:]* ${PLUS}0000 ${username} 1\.1 file7 first-dir == ${TESTDIR} +A [0-9-]* [0-9:]* ${PLUS}0000 ${username} 1\.1 file6 first-dir/dir1 == ${TESTDIR} +A [0-9-]* [0-9:]* ${PLUS}0000 ${username} 1\.1 file7 first-dir/dir1 == ${TESTDIR} +A [0-9-]* [0-9:]* ${PLUS}0000 ${username} 1\.1 file6 first-dir/dir1/dir2 == ${TESTDIR} +A [0-9-]* [0-9:]* ${PLUS}0000 ${username} 1\.1 file7 first-dir/dir1/dir2 == ${TESTDIR} +A [0-9-]* [0-9:]* ${PLUS}0000 ${username} 1\.1 file14 first-dir == ${TESTDIR} +M [0-9-]* [0-9:]* ${PLUS}0000 ${username} 1\.2 file6 first-dir == ${TESTDIR} +R [0-9-]* [0-9:]* ${PLUS}0000 ${username} 1\.2 file7 first-dir == ${TESTDIR} +A [0-9-]* [0-9:]* ${PLUS}0000 ${username} 1\.1 file14 first-dir/dir1 == ${TESTDIR} +M [0-9-]* [0-9:]* ${PLUS}0000 ${username} 1\.2 file6 first-dir/dir1 == ${TESTDIR} +R [0-9-]* [0-9:]* ${PLUS}0000 ${username} 1\.2 file7 first-dir/dir1 == ${TESTDIR} +A [0-9-]* [0-9:]* ${PLUS}0000 ${username} 1\.1 file14 first-dir/dir1/dir2 == ${TESTDIR} +M [0-9-]* [0-9:]* ${PLUS}0000 ${username} 1\.2 file6 first-dir/dir1/dir2 == ${TESTDIR} +R [0-9-]* [0-9:]* ${PLUS}0000 ${username} 1\.2 file7 first-dir/dir1/dir2 == ${TESTDIR} +F [0-9-]* [0-9:]* ${PLUS}0000 ${username} =first-dir= ${TESTDIR}/\* +T [0-9-]* [0-9:]* ${PLUS}0000 ${username} first-dir \[rtagged-by-head:A\] +T [0-9-]* [0-9:]* ${PLUS}0000 ${username} first-dir \[rtagged-by-tag:rtagged-by-head\] +T [0-9-]* [0-9:]* ${PLUS}0000 ${username} first-dir \[rtagged-by-revision:1\.1\] +O [0-9-]* [0-9:]* ${PLUS}0000 ${username} \[1\.1\] first-dir =first-dir= ${TESTDIR}/\* +U [0-9-]* [0-9:]* ${PLUS}0000 ${username} 1\.2 file6 first-dir == ${TESTDIR}/first-dir +W [0-9-]* [0-9:]* ${PLUS}0000 ${username} file7 first-dir == ${TESTDIR}/first-dir" \ +"O [0-9-]* [0-9:]* ${PLUS}0000 ${username} first-dir =first-dir= <remote>/\* +A [0-9-]* [0-9:]* ${PLUS}0000 ${username} 1\.1 file6 first-dir == <remote> +A [0-9-]* [0-9:]* ${PLUS}0000 ${username} 1\.1 file7 first-dir == <remote> +A [0-9-]* [0-9:]* ${PLUS}0000 ${username} 1\.1 file6 first-dir/dir1 == <remote> +A [0-9-]* [0-9:]* ${PLUS}0000 ${username} 1\.1 file7 first-dir/dir1 == <remote> +A [0-9-]* [0-9:]* ${PLUS}0000 ${username} 1\.1 file6 first-dir/dir1/dir2 == <remote> +A [0-9-]* [0-9:]* ${PLUS}0000 ${username} 1\.1 file7 first-dir/dir1/dir2 == <remote> +A [0-9-]* [0-9:]* ${PLUS}0000 ${username} 1\.1 file14 first-dir == <remote> +M [0-9-]* [0-9:]* ${PLUS}0000 ${username} 1\.2 file6 first-dir == <remote> +R [0-9-]* [0-9:]* ${PLUS}0000 ${username} 1\.2 file7 first-dir == <remote> +A [0-9-]* [0-9:]* ${PLUS}0000 ${username} 1\.1 file14 first-dir/dir1 == <remote> +M [0-9-]* [0-9:]* ${PLUS}0000 ${username} 1\.2 file6 first-dir/dir1 == <remote> +R [0-9-]* [0-9:]* ${PLUS}0000 ${username} 1\.2 file7 first-dir/dir1 == <remote> +A [0-9-]* [0-9:]* ${PLUS}0000 ${username} 1\.1 file14 first-dir/dir1/dir2 == <remote> +M [0-9-]* [0-9:]* ${PLUS}0000 ${username} 1\.2 file6 first-dir/dir1/dir2 == <remote> +R [0-9-]* [0-9:]* ${PLUS}0000 ${username} 1\.2 file7 first-dir/dir1/dir2 == <remote> +F [0-9-]* [0-9:]* ${PLUS}0000 ${username} =first-dir= <remote>/\* +T [0-9-]* [0-9:]* ${PLUS}0000 ${username} first-dir \[rtagged-by-head:A\] +T [0-9-]* [0-9:]* ${PLUS}0000 ${username} first-dir \[rtagged-by-tag:rtagged-by-head\] +T [0-9-]* [0-9:]* ${PLUS}0000 ${username} first-dir \[rtagged-by-revision:1\.1\] +O [0-9-]* [0-9:]* ${PLUS}0000 ${username} \[1\.1\] first-dir =first-dir= <remote>/\* +P [0-9-]* [0-9:]* ${PLUS}0000 ${username} 1\.2 file6 first-dir == <remote> +W [0-9-]* [0-9:]* ${PLUS}0000 ${username} file7 first-dir == <remote>" + fi + + dokeep + modify_repo rm -rf $CVSROOT_DIRNAME/first-dir \ + $CVSROOT_DIRNAME/second-dir + ;; + + + + ls) + # Test the ls & rls commands. There are some tests of + # Interaction of ls, rls, and branches in branches2. + mkdir ls; cd ls + dotest ls-init-1 "$testcvs -Q co -dtop ." + cd top + dotest ls-1 "$testcvs ls CVSROOT" \ +"checkoutlist +commitinfo +config +cvswrappers +loginfo +modules +notify +postadmin +postproxy +posttag +postwatch +preproxy +rcsinfo +taginfo +verifymsg" + dotest ls-2 "$testcvs ls -R" \ +"\.: +CVSROOT + +CVSROOT: +checkoutlist +commitinfo +config +cvswrappers +loginfo +modules +notify +postadmin +postproxy +posttag +postwatch +preproxy +rcsinfo +taginfo +verifymsg" + # This used to cause a fatal error. + modify_repo mkdir $CVSROOT_DIRNAME/notcheckedout + dotest ls-3 "$testcvs ls -RP" \ +"\.: +CVSROOT +notcheckedout + +CVSROOT: +checkoutlist +commitinfo +config +cvswrappers +loginfo +modules +notify +postadmin +postproxy +posttag +postwatch +preproxy +rcsinfo +taginfo +verifymsg" + + # Make sure the previous command did not create the notcheckedout + # directory. + dotest_fail ls-4 "test -d notcheckedout" + + dotest ls-5 "$testcvs ls -R" \ +"\.: +CVSROOT +notcheckedout + +CVSROOT: +checkoutlist +commitinfo +config +cvswrappers +loginfo +modules +notify +postadmin +postproxy +posttag +postwatch +preproxy +rcsinfo +taginfo +verifymsg + +notcheckedout:" + dotest_fail ls-6 "test -d notcheckedout" + + # Several test for ls -d, which shows dead revisions + + # Set up the dead files + mkdir cemetery + dotest ls-d-init-1 "$testcvs -Q add cemetery" + cd cemetery + touch dead living + dotest ls-d-init-2 "$testcvs -Q add dead living" + dotest ls-d-init-3 "$testcvs -Q ci -mm dead living" + dotest ls-d-init-4 "$testcvs -Q tag -b branch" + dotest ls-d-init-5 "$testcvs -Q up -A" + rm dead + dotest ls-d-init-6 "$testcvs -Q rm dead" + dotest ls-d-init-7 "$testcvs -Q ci -mm dead" + dotest ls-d-init-8 "$testcvs -Q up -r branch" + rm dead + dotest ls-d-init-9 "$testcvs -Q rm dead" + dotest ls-d-init-10 "$testcvs -Q ci -mm dead" + + # Possible output + output_living="living" + output_dead="dead +living" + + # The basic test is to make sure that dead revisions are shown if and + # only if -d is speficified (and that live revisions are always + # shown). The following test cases cover all combinations of these + # factors: + # + # + Working directory is on branch or trunk + # + ls or rls + # + implicit branch, explicit trunk, or explicit branch + # + -d present or absent + + # Working directory on trunk + $testcvs -Q up -A + + ## ls + dotest ls-d-1 "$testcvs ls" "$output_living" + dotest ls-d-2 "$testcvs ls -d" "$output_dead" + + dotest ls-d-3 "$testcvs ls -rHEAD" "$output_living" + dotest ls-d-4 "$testcvs ls -drHEAD" "$output_dead" + + dotest ls-d-5 "$testcvs ls -rbranch" "$output_living" + dotest ls-d-6 "$testcvs ls -drbranch" "$output_dead" + + ## rls + dotest ls-d-7 "$testcvs rls cemetery" \ +"$SPROG rls: Listing module: \`cemetery' +$output_living" + dotest ls-d-8 "$testcvs rls -d cemetery" \ +"$SPROG rls: Listing module: \`cemetery' +$output_dead" + + dotest ls-d-9 "$testcvs -q rls -rHEAD cemetery" "$output_living" + dotest ls-d-10 "$testcvs -q rls -drHEAD cemetery" "$output_dead" + + dotest ls-d-11 "$testcvs -q rls -rbranch cemetery" "$output_living" + dotest ls-d-12 "$testcvs -q rls -drbranch cemetery" "$output_dead" + + # Working directory on branch + $testcvs -Q up -r branch + + ## ls + dotest ls-d-13 "$testcvs ls" "$output_living" + dotest ls-d-14 "$testcvs ls -d" "$output_dead" + + dotest ls-d-15 "$testcvs ls -r HEAD" "$output_living" + dotest ls-d-16 "$testcvs ls -d -r HEAD" "$output_dead" + + dotest ls-d-17 "$testcvs ls -r branch" "$output_living" + dotest ls-d-18 "$testcvs ls -d -r branch" "$output_dead" + + ## rls + dotest ls-d-19 "$testcvs -q rls cemetery" "$output_living" + dotest ls-d-20 "$testcvs -q rls -d cemetery" "$output_dead" + + dotest ls-d-21 "$testcvs -q rls -rHEAD cemetery" "$output_living" + dotest ls-d-22 "$testcvs -q rls -drHEAD cemetery" "$output_dead" + + dotest ls-d-23 "$testcvs -q rls -rbranch cemetery" "$output_living" + dotest ls-d-24 "$testcvs -q rls -drbranch cemetery" "$output_dead" + + # Some tests to cover specifying a file name as an option + # Combinations of factors: + # + # + file in CVS/Entries or not + # + current directory or subdirectory + # + file dead or not + + # Switch back to the trunk + $testcvs -Q up -A + + ## file in CVS/Entries + dotest ls-filename-1 "$testcvs ls dead" + + # ls'ing a file that already exists once caused an assertion failure. + dotest ls-filename-2 "$testcvs ls living" "living" + + cd .. + dotest ls-filename-3 "$testcvs ls cemetery/dead" + + # ls'ing a file that already exists once caused an assertion failure. + dotest ls-filename-4 "$testcvs ls cemetery/living" "cemetery/living" + cd cemetery + + ## file not in CVS/Entries + echo D > CVS/Entries + + dotest ls-filename-5 "$testcvs ls dead" + + # ls'ing a file that already exists once caused an assertion failure. + dotest ls-filename-6 "$testcvs ls living" "living" + + cd .. + dotest ls-filename-7 "$testcvs ls cemetery/dead" + + # ls'ing a file that already exists once caused an assertion failure. + dotest ls-filename-8 "$testcvs ls cemetery/living" "cemetery/living" + + cd cemetery + + # Test the -D date option to cvs ls + + # try and list a file before it's created, during an old revision, in + # a period when it was dead and in the future + time_prebirth=`date '+%Y-%m-%d %H:%M:%S'` ; sleep 1 + touch dated + dotest ls-D-init-1 "$testcvs -Q add dated" + dotest ls-D-init-2 "$testcvs -Q ci -mm dated" + time_newborn=`date '+%Y-%m-%d %H:%M:%S'` ; sleep 1 + echo mm >> dated + dotest ls-D-init-2 "$testcvs -Q ci -mm dated" + time_predeath=`date '+%Y-%m-%d %H:%M:%S'` ; sleep 1 + rm dated + dotest ls-D-init-3 "$testcvs -Q rm dated" + dotest ls-D-init-4 "$testcvs -Q ci -mm dated" + time_postdeath=`date '+%Y-%m-%d %H:%M:%S'` + + dotest ls-D-1 "$testcvs ls -D '$time_prebirth' -e dated" + + # ls'ing a file that already exists once caused an assertion failure. + dotest ls-D-2 "$testcvs ls -D '$time_newborn' -e dated" \ +"/dated/1\.1/.*" + + # ls'ing a file that already exists once caused an assertion failure. + dotest ls-D-3 "$testcvs ls -D '$time_predeath' -e dated" \ +"/dated/1.2/.*" + + dotest ls-D-4 "$testcvs ls -D '$time_postdeath' -e dated" + + dokeep + cd ../../.. + rm -r ls + modify_repo rm -rf $CVSROOT_DIRNAME/notcheckedout \ + $CVSROOT_DIRNAME/cemetery + unset output_living output_dead + ;; + + + + parseroot) + mkdir 1; cd 1 + # Test odd cases involving CVSROOT. At the moment, that means we + # are testing roots with '/'s on the end, which CVS should parse off. + CVSROOT_save=${CVSROOT} + CVSROOT="${CVSROOT}/////" + dotest parseroot-1 "${testcvs} -q co CVSROOT/modules" \ +"U CVSROOT/modules" + dotest parseroot-2 "${testcvs} -q ci -fmnull-change CVSROOT/modules" \ +"$CVSROOT_DIRNAME/CVSROOT/modules,v <-- CVSROOT/modules +new revision: 1\.2; previous revision: 1\.1 +$SPROG commit: Rebuilding administrative file database" + + if $remote; then + # I only test these when testing remote in case CVS was compiled + # without client support. + + # logout does not try to contact the server. + CVSROOT=":pserver;proxy=localhost;proxyport=8080:localhost/dev/null" + dotest parseroot-3r "$testcvs -d'$CVSROOT' logout" \ +"Logging out of :pserver:$username@localhost:2401/dev/null +$CPROG logout: warning: failed to open $HOME/\.cvspass for reading: No such file or directory +$CPROG logout: Entry not found." + CVSROOT=":pserver;proxyport=8080:localhost/dev/null" + dotest_fail parseroot-4r "$testcvs -d'$CVSROOT' logout" \ +"$CPROG logout: Proxy port specified in CVSROOT without proxy host\. +$CPROG \[logout aborted\]: Bad CVSROOT: \`:pserver;proxyport=8080:localhost/dev/null'\." + CVSROOT=":pserver;optionnoarg:localhost/dev/null" + dotest_fail parseroot-5r "$testcvs -d'$CVSROOT' logout" \ +"$CPROG logout: Option (\`optionnoarg') has no argument in CVSROOT\. +$CPROG \[logout aborted\]: Bad CVSROOT: \`:pserver;optionnoarg:localhost/dev/null'\." + CVSROOT=":pserver;notanoption=anything:localhost/dev/null" + dotest_fail parseroot-6r "$testcvs -d'$CVSROOT' logout" \ +"$CPROG logout: Unknown option (\`notanoption') in CVSROOT\. +$CPROG \[logout aborted\]: Bad CVSROOT: \`:pserver;notanoption=anything:localhost/dev/null'\." + CVSROOT=":local;proxy=localhost:/dev/null" + dotest_fail parseroot-7r "$testcvs -d'$CVSROOT' logout" \ +"$CPROG logout: CVSROOT proxy specification is only valid for gserver and +$CPROG logout: pserver connection methods\. +$CPROG \[logout aborted\]: Bad CVSROOT: \`:local;proxy=localhost:/dev/null'\." + CVSROOT="::pserver@anonymous@test.org:/cvs" + dotest_fail parseroot-8r "$testcvs -d'$CVSROOT' co test" \ +"$CPROG checkout: Unknown method (\`') in CVSROOT\. +$CPROG \[checkout aborted\]: Bad CVSROOT: \`$CVSROOT'\." + fi + + dokeep + + # Clean up + CVSROOT=$CVSROOT_save + cd .. + rm -r 1 + ;; + + + + files) + # Test of how we specify files on the command line + # (recurse.c and that sort of thing). Vaguely similar to + # tests like basic* and deep. See modules and such tests + # for what happens when we throw in modules and co -d, &c. + + # This particular test is fairly carefully crafted, to spot + # one particular issue with remote. + mkdir 1; cd 1 + dotest files-1 "${testcvs} -q co -l ." "" + mkdir first-dir + dotest files-2 "${testcvs} add first-dir" \ +"Directory ${CVSROOT_DIRNAME}/first-dir added to the repository" + cd first-dir + touch tfile + dotest files-3 "${testcvs} add tfile" \ +"${SPROG} add: scheduling file .tfile. for addition +${SPROG} add: use .${SPROG} commit. to add this file permanently" + dotest files-4 "${testcvs} -q ci -m add" \ +"$CVSROOT_DIRNAME/first-dir/tfile,v <-- tfile +initial revision: 1\.1" + dotest files-5 "${testcvs} -q tag -b C" "T tfile" + dotest files-6 "${testcvs} -q update -r C" "" + mkdir dir + dotest files-7 "${testcvs} add dir" \ +"Directory ${CVSROOT_DIRNAME}/first-dir/dir added to the repository +--> Using per-directory sticky tag .C'" + cd dir + touch .file + dotest files-7b "${testcvs} add .file" \ +"${SPROG} add: scheduling file .\.file' for addition on branch .C. +${SPROG} add: use .${SPROG} commit. to add this file permanently" + mkdir sdir + dotest files-7c "${testcvs} add sdir" \ +"Directory ${CVSROOT_DIRNAME}/first-dir/dir/sdir added to the repository +--> Using per-directory sticky tag .C'" + cd sdir + mkdir ssdir + dotest files-8 "${testcvs} add ssdir" \ +"Directory ${CVSROOT_DIRNAME}/first-dir/dir/sdir/ssdir added to the repository +--> Using per-directory sticky tag .C'" + cd ssdir + touch .file + dotest files-9 "${testcvs} add .file" \ +"${SPROG} add: scheduling file .\.file' for addition on branch .C. +${SPROG} add: use .${SPROG} commit. to add this file permanently" + cd ../.. + dotest files-10 "${testcvs} -q ci -m test" \ +"$CVSROOT_DIRNAME/first-dir/dir/Attic/\.file,v <-- \.file +new revision: 1\.1\.2\.1; previous revision: 1\.1 +$CVSROOT_DIRNAME/first-dir/dir/sdir/ssdir/Attic/\.file,v <-- sdir/ssdir/\.file +new revision: 1\.1\.2\.1; previous revision: 1\.1" + dotest files-11 \ +"${testcvs} commit -m test -f ./.file ./sdir/ssdir/.file" \ +"${CVSROOT_DIRNAME}/first-dir/dir/Attic/\.file,v <-- \.file +new revision: 1\.1\.2\.2; previous revision: 1\.1\.2\.1 +${CVSROOT_DIRNAME}/first-dir/dir/sdir/ssdir/Attic/\.file,v <-- \./sdir/ssdir/\.file +new revision: 1\.1\.2\.2; previous revision: 1\.1\.2\.1" + if $remote; then + # FIXCVS: + # This is a bug, looks like that toplevel_repos cruft in + # client.c is coming back to haunt us. + # May want to think about the whole issue, toplevel_repos + # has always been crufty and trying to patch it up again + # might be a mistake. + dotest files-12r \ +"$testcvs commit -f -m test ./sdir/ssdir/.file ./.file" \ +"$CVSROOT_DIRNAME/first-dir/dir/sdir/ssdir/Attic/\.file,v <-- \./sdir/ssdir/\.file +new revision: 1\.1\.2\.3; previous revision: 1\.1\.2\.2" + + # Sync up the version numbers so that the rest of the + # tests don't need to expect different numbers based + # local or remote. + dotest files-12rworkaround \ +"$testcvs commit -f -m test .file" \ +"$CVSROOT_DIRNAME/first-dir/dir/Attic/\.file,v <-- \.file +new revision: 1\.1\.2\.3; previous revision: 1\.1\.2\.2" + else + dotest files-12 \ +"${testcvs} commit -f -m test ./sdir/ssdir/.file ./.file" \ +"${CVSROOT_DIRNAME}/first-dir/dir/sdir/ssdir/Attic/\.file,v <-- \./sdir/ssdir/\.file +new revision: 1\.1\.2\.3; previous revision: 1\.1\.2\.2 +${CVSROOT_DIRNAME}/first-dir/dir/Attic/\.file,v <-- \.file +new revision: 1\.1\.2\.3; previous revision: 1\.1\.2\.2" + fi + dotest files-13 \ +"${testcvs} commit -fmtest ./sdir/../sdir/ssdir/..///ssdir/.file" \ +"${CVSROOT_DIRNAME}/first-dir/dir/sdir/ssdir/Attic/\.file,v <-- \./sdir/\.\./sdir/ssdir/\.\.///ssdir/\.file +new revision: 1\.1\.2\.4; previous revision: 1\.1\.2\.3" + dotest files-14 \ +"${testcvs} commit -fmtest ../../first-dir/dir/.file" \ +"${CVSROOT_DIRNAME}/first-dir/dir/Attic/\.file,v <-- \.\./\.\./first-dir/dir/\.file +new revision: 1\.1\.2\.4; previous revision: 1\.1\.2\.3" + + dokeep + cd ../../.. + rm -r 1 + modify_repo rm -rf $CVSROOT_DIRNAME/first-dir + ;; + + + + spacefiles) + # More filename tests, in particular spaces in file names. + # (it might be better to just change a few of the names in + # basica or some other test instead, always good to keep the + # testsuite concise). + + mkdir 1; cd 1 + dotest spacefiles-1 "${testcvs} -q co -l ." "" + touch ./-c + dotest spacefiles-2 "${testcvs} add -- -c" \ +"${SPROG} add: scheduling file .-c. for addition +${SPROG} add: use .${SPROG} commit. to add this file permanently" + dotest spacefiles-3 "${testcvs} -q ci -m add" \ +"$CVSROOT_DIRNAME/-c,v <-- -c +initial revision: 1\.1" + mkdir 'first dir' + dotest spacefiles-4 "${testcvs} add 'first dir'" \ +"Directory ${CVSROOT_DIRNAME}/first dir added to the repository" + mkdir ./-b + dotest spacefiles-5 "${testcvs} add -- -b" \ +"Directory ${CVSROOT_DIRNAME}/-b added to the repository" + cd 'first dir' + touch 'a file' + dotest spacefiles-6 "${testcvs} add 'a file'" \ +"${SPROG} add: scheduling file .a file. for addition +${SPROG} add: use .${SPROG} commit. to add this file permanently" + dotest spacefiles-7 "${testcvs} -q ci -m add" \ +"$CVSROOT_DIRNAME/first dir/a file,v <-- a file +initial revision: 1\.1" + dotest spacefiles-8 "${testcvs} -q tag new-tag" "T a file" + cd ../.. + + mkdir 2; cd 2 + dotest spacefiles-10 "${testcvs} co -- -b" \ +"${SPROG} checkout: Updating -b" + dotest spacefiles-11 "${testcvs} -q co -- -c" "U \./-c" + rm ./-c + dotest spacefiles-13 "${testcvs} -q co 'first dir'" \ +"U first dir/a file" + cd .. + + mkdir 3; cd 3 + dotest spacefiles-14 "${testcvs} -q co 'first dir/a file'" \ +"U first dir/a file" + cd .. + + rm -r 1 2 3 + modify_repo rm -rf "'$CVSROOT_DIRNAME/first dir'" \ + $CVSROOT_DIRNAME/-b $CVSROOT_DIRNAME/-c,v + ;; + + + + commit-readonly) + mkdir 1; cd 1 + module=x + + : > junk + dotest commit-readonly-1 "$testcvs -Q import -m . $module X Y" '' + dotest commit-readonly-2 "$testcvs -Q co $module" '' + cd $module + + file=m + + # Include an rcs keyword to be expanded. + echo '$Id''$' > $file + + dotest commit-readonly-3 "$testcvs add $file" \ +"$SPROG add: scheduling file .$file. for addition +$SPROG add: use .$SPROG commit. to add this file permanently" + dotest commit-readonly-4 "$testcvs -Q ci -m . $file" + + echo line2 >> $file + # Make the file read-only. + chmod a-w $file + + dotest commit-readonly-5 "$testcvs -Q ci -m . $file" + + dokeep + cd ../.. + rm -rf 1 + modify_repo rm -rf $CVSROOT_DIRNAME/"$module" + ;; + + + + status) + # This tests for a bug in the status command which failed to + # notice resolved conflicts. + mkdir status; cd status + dotest status-init-1 "$testcvs -q co -l ." + mkdir first-dir + dotest status-init-2 "${testcvs} add first-dir" \ +"Directory ${CVSROOT_DIRNAME}/first-dir added to the repository" + cd first-dir + echo a line >tfile + dotest status-init-3 "${testcvs} add tfile" \ +"${SPROG} add: scheduling file .tfile. for addition +${SPROG} add: use .${SPROG} commit. to add this file permanently" + dotest status-init-4 "${testcvs} -q ci -m add" \ +"$CVSROOT_DIRNAME/first-dir/tfile,v <-- tfile +initial revision: 1\.1" + cd .. + dotest status-init-5 "${testcvs} -q co -dsecond-dir first-dir" \ +"U second-dir/tfile" + cd second-dir + echo some junk >>tfile + dotest status-init-6 "${testcvs} -q ci -maline" \ +"$CVSROOT_DIRNAME/first-dir/tfile,v <-- tfile +new revision: 1\.2; previous revision: 1\.1" + cd ../first-dir + echo force a conflict >>tfile + dotest status-init-7 "${testcvs} -q up" \ +"RCS file: ${CVSROOT_DIRNAME}/first-dir/tfile,v +retrieving revision 1\.1 +retrieving revision 1\.2 +Merging differences between 1\.1 and 1\.2 into tfile +rcsmerge: warning: conflicts during merge +${SPROG} update: conflicts found in tfile +C tfile" + + # Now note our status + dotest status-1 "${testcvs} status tfile" \ +"=================================================================== +File: tfile Status: Unresolved Conflict + + Working revision: 1\.2.* + Repository revision: 1\.2 ${CVSROOT_DIRNAME}/first-dir/tfile,v + Commit Identifier: ${commitid} + Sticky Tag: (none) + Sticky Date: (none) + Sticky Options: (none)" + + # touch the file, leaving conflict markers in place + # and note our status + touch tfile + dotest status-2 "${testcvs} status tfile" \ +"=================================================================== +File: tfile Status: File had conflicts on merge + + Working revision: 1\.2.* + Repository revision: 1\.2 ${CVSROOT_DIRNAME}/first-dir/tfile,v + Commit Identifier: ${commitid} + Sticky Tag: (none) + Sticky Date: (none) + Sticky Options: (none)" + + # resolve the conflict + echo resolution >tfile + dotest status-3 "${testcvs} status tfile" \ +"=================================================================== +File: tfile Status: Locally Modified + + Working revision: 1\.2.* + Repository revision: 1\.2 ${CVSROOT_DIRNAME}/first-dir/tfile,v + Commit Identifier: ${commitid} + Sticky Tag: (none) + Sticky Date: (none) + Sticky Options: (none)" + + # Check that there are no problems just using CVS/Root too. + save_CVSROOT=$CVSROOT + unset CVSROOT + dotest status-3a "${testcvs} status tfile" \ +"=================================================================== +File: tfile Status: Locally Modified + + Working revision: 1\.2.* + Repository revision: 1\.2 ${CVSROOT_DIRNAME}/first-dir/tfile,v + Commit Identifier: ${commitid} + Sticky Tag: (none) + Sticky Date: (none) + Sticky Options: (none)" + CVSROOT=$save_CVSROOT + export CVSROOT + + # FIXCVS: + # Update is supposed to re-Register() the file when it + # finds resolved conflicts: + dotest status-4 "grep 'Result of merge' CVS/Entries" \ +"/tfile/1\.2/Result of merge${PLUS}[a-zA-Z0-9 :]*//" + + cd .. + mkdir fourth-dir + dotest status-init-8 "$testcvs add fourth-dir" \ +"Directory $CVSROOT_DIRNAME/fourth-dir added to the repository" + cd fourth-dir + echo yet another line >t3file + dotest status-init-9 "$testcvs add t3file" \ +"$SPROG add: scheduling file .t3file. for addition +$SPROG add: use .$SPROG commit. to add this file permanently" + dotest status-init-10 "$testcvs -q ci -m add" \ +"$CVSROOT_DIRNAME/fourth-dir/t3file,v <-- t3file +initial revision: 1\.1" + cd ../first-dir + mkdir third-dir + dotest status-init-11 "$testcvs add third-dir" \ +"Directory $CVSROOT_DIRNAME/first-dir/third-dir added to the repository" + cd third-dir + echo another line >t2file + dotest status-init-12 "$testcvs add t2file" \ +"$SPROG add: scheduling file .t2file. for addition +$SPROG add: use .$SPROG commit. to add this file permanently" + dotest status-init-13 "$testcvs -q ci -m add" \ +"$CVSROOT_DIRNAME/first-dir/third-dir/t2file,v <-- t2file +initial revision: 1\.1" + dotest status-5 "$testcvs status ../tfile" \ +"=================================================================== +File: tfile Status: Locally Modified + + Working revision: 1\.2.* + Repository revision: 1\.2 $CVSROOT_DIRNAME/first-dir/tfile,v + Commit Identifier: ${commitid} + Sticky Tag: (none) + Sticky Date: (none) + Sticky Options: (none)" + dotest status-6 "$testcvs status ../../fourth-dir/t3file" \ +"=================================================================== +File: t3file Status: Up-to-date + + Working revision: 1\.1.* + Repository revision: 1\.1 $CVSROOT_DIRNAME/fourth-dir/t3file,v + Commit Identifier: ${commitid} + Sticky Tag: (none) + Sticky Date: (none) + Sticky Options: (none)" + + dokeep + cd ../../.. + rm -rf status + modify_repo rm -rf $CVSROOT_DIRNAME/first-dir \ + $CVSROOT_DIRNAME/fourth-dir + ;; + + + + commit-readonlyfs) + mkdir 1; cd 1 + module=x + : > junk + dotest commit-readonlyfs-1 "${testcvs} -Q import -m . $module X Y" '' + if $remote; then + dotest_fail commit-readonlyfs-2r1 "${testcvs} -Q -R co $module" \ +"${CPROG} \[checkout aborted\]: Read-only repository feature unavailable with remote roots (cvsroot = ${CVSROOT_DIRNAME})" + dotest commit-readonlyfs-2r2 "${testcvs} -Q co $module" '' + else + dotest commit-readonlyfs-2 "${testcvs} -Q -R co $module" '' + rm -rf $module + dotest commit-readonlyfs-2r3 "${testcvs} -q -R co $module" \ +"U $module/junk" + rm -rf $module + dotest commit-readonlyfs-2r4 "${testcvs} -R co $module" \ +"${SPROG}: WARNING: Read-only repository access mode selected via \`cvs -R'\. +Using this option to access a repository which some users write to may +cause intermittent sandbox corruption\. +${SPROG} checkout: Updating $module +U $module/junk" + fi + cd $module + echo test > junk + if $remote; then + dotest_fail commit-readonlyfs-3r "${testcvs} -Q -R ci -m. junk" \ +"${SPROG} \[commit aborted\]: Read-only repository feature unavailable with remote roots (cvsroot = ${CVSROOT_DIRNAME})" + else + dotest_fail commit-readonlyfs-3 "${testcvs} -Q -R ci -m. junk" \ +"${SPROG} commit: write lock failed\. +WARNING: Read-only repository access mode selected via \`cvs -R'\. +Attempting to write to a read-only filesystem is not allowed\. +${SPROG} \[commit aborted\]: lock failed - giving up" + fi + + dokeep + cd ../.. + rm -rf 1 + modify_repo rm -rf $CVSROOT_DIRNAME/"$module" + ;; + + + + rdiff) + # Test rdiff + # XXX for now this is just the most essential test... + cd ${TESTDIR} + + mkdir testimport + cd testimport + echo '$''Id$' > foo + echo '$''Name$' >> foo + echo '$''Id$' > bar + echo '$''Name$' >> bar + dotest_sort rdiff-1 \ + "${testcvs} import -I ! -m test-import-with-keyword trdiff TRDIFF T1" \ +' + +N trdiff/bar +N trdiff/foo +No conflicts created by this import' + dotest rdiff-2 \ + "${testcvs} co -ko trdiff" \ +"${SPROG} checkout: Updating trdiff +U trdiff/bar +U trdiff/foo" + cd trdiff + echo something >> foo + dotest rdiff-3 \ + "${testcvs} ci -m added-something foo" \ +"${CVSROOT_DIRNAME}/trdiff/foo,v <-- foo +new revision: 1\.2; previous revision: 1\.1" + echo '#ident "@(#)trdiff:$''Name$:$''Id$"' > new + echo "new file" >> new + dotest rdiff-4 \ + "${testcvs} add -m new-file-description new" \ +"${SPROG} add: scheduling file \`new' for addition +${SPROG} add: use .${SPROG} commit. to add this file permanently" + dotest rdiff-5 \ + "${testcvs} commit -m added-new-file new" \ +"${CVSROOT_DIRNAME}/trdiff/new,v <-- new +initial revision: 1\.1" + dotest rdiff-6 \ + "${testcvs} tag local-v0" \ +"${SPROG} tag: Tagging . +T bar +T foo +T new" + dotest rdiff-7 \ + "${testcvs} status -v foo" \ +"=================================================================== +File: foo Status: Up-to-date + + Working revision: 1\.2.* + Repository revision: 1\.2 ${CVSROOT_DIRNAME}/trdiff/foo,v + Commit Identifier: ${commitid} + Sticky Tag: (none) + Sticky Date: (none) + Sticky Options: -ko + + Existing Tags: + local-v0 (revision: 1\.2) + T1 (revision: 1\.1\.1\.1) + TRDIFF (branch: 1\.1\.1)" + + cd .. + rm -r trdiff + + dotest rdiff-8 \ + "${testcvs} rdiff -r T1 -r local-v0 trdiff" \ +"${SPROG}"' rdiff: Diffing trdiff +Index: trdiff/foo +diff -c trdiff/foo:1\.1\.1\.1 trdiff/foo:1\.2 +\*\*\* trdiff/foo:1\.1\.1\.1 '"${DATE}"' +--- trdiff/foo '"${DATE}"' +\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* +\*\*\* 1,2 \*\*\*\* +! \$''Id: foo,v 1\.1\.1\.1 [0-9/]* [0-9:]* '"${username}"' Exp \$ +! \$''Name: T1 \$ +--- 1,3 ---- +! \$''Id: foo,v 1\.2 [0-9/]* [0-9:]* '"${username}"' Exp \$ +! \$''Name: local-v0 \$ +! something +Index: trdiff/new +diff -c /dev/null trdiff/new:1\.1 +\*\*\* /dev/null '"${DATE}"' +--- trdiff/new '"${DATE}"' +\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* +\*\*\* 0 \*\*\*\* +--- 1,2 ---- +'"${PLUS}"' #ident "@(#)trdiff:\$''Name: local-v0 \$:\$''Id: new,v 1\.1 [0-9/]* [0-9:]* '"${username}"' Exp \$" +'"${PLUS}"' new file' + + dokeep + cd .. + rm -r testimport + modify_repo rm -rf $CVSROOT_DIRNAME/trdiff + ;; + + + + rdiff-short) + # Test that the short patch behaves as expected + # 1) Added file. + # 2) Removed file. + # 3) Different revision number with no difference. + # 4) Different revision number with changes. + # 5) Against trunk. + # 6) Same revision number (no difference). + mkdir rdiff-short; cd rdiff-short + mkdir abc + dotest rdiff-short-init-1 \ +"${testcvs} -q import -I ! -m initial-import abc vendor initial" \ +' +No conflicts created by this import' + + dotest rdiff-short-init-2 "${testcvs} -q get abc" '' + cd abc + echo "abc" >file1.txt + dotest rdiff-short-init-3 "${testcvs} add file1.txt" \ +"${SPROG} add: scheduling file .file1\.txt' for addition +${SPROG} add: use \`${SPROG} commit' to add this file permanently" + dotest rdiff-short-init-4 \ +"${testcvs} commit -madd-file1 file1.txt" \ +"${CVSROOT_DIRNAME}/abc/file1\.txt,v <-- file1\.txt +initial revision: 1\.1" + echo def >>file1.txt + dotest rdiff-short-init-5 \ +"${testcvs} commit -mchange-file1 file1.txt" \ +"${CVSROOT_DIRNAME}/abc/file1\.txt,v <-- file1\.txt +new revision: 1\.2; previous revision: 1\.1" + echo "abc" >file1.txt + dotest rdiff-short-init-6 \ +"${testcvs} commit -mrestore-file1-rev1 file1.txt" \ +"${CVSROOT_DIRNAME}/abc/file1\.txt,v <-- file1\.txt +new revision: 1\.3; previous revision: 1\.2" + dotest rdiff-short-init-7 \ +"${testcvs} tag -r 1.1 tag1 file1.txt" \ +"T file1\.txt" + dotest rdiff-short-init-8 \ +"${testcvs} tag -r 1.2 tag2 file1.txt" \ +"T file1\.txt" + dotest rdiff-short-init-9 \ +"${testcvs} tag -r 1.3 tag3 file1.txt" \ +"T file1\.txt" + echo "abc" >file2.txt + dotest rdiff-short-init-10 \ +"${testcvs} add file2.txt" \ +"${SPROG} add: scheduling file .file2\.txt' for addition +${SPROG} add: use \`${SPROG} commit' to add this file permanently" + dotest rdiff-add-remove-nodiff-init-11 \ +"${testcvs} commit -madd-file2 file2.txt" \ +"${CVSROOT_DIRNAME}/abc/file2\.txt,v <-- file2\.txt +initial revision: 1\.1" + dotest rdiff-short-init-12 \ +"${testcvs} tag -r 1.1 tag4 file2.txt" \ +"T file2\.txt" + dotest rdiff-short-init-13 \ +"${testcvs} tag -r 1.1 tag5 file2.txt" \ +"T file2\.txt" + cd ../.. + rm -fr rdiff-short + + # 3) Different revision number with no difference. + dotest rdiff-short-no-real-change \ +"${testcvs} -q rdiff -s -r tag1 -r tag3 abc" + + # 4) Different revision number with changes. + dotest rdiff-short-real-change \ +"${testcvs} -q rdiff -s -r tag1 -r tag2 abc" \ +'File abc/file1.txt changed from revision 1\.1 to 1\.2' + + # 1) Added file. + # 2) Removed file. + dotest_sort rdiff-short-remove-add \ +"${testcvs} -q rdiff -s -r tag2 -r tag4 abc" \ +'File abc/file1\.txt is removed; tag2 revision 1\.2 +File abc/file2\.txt is new; tag4 revision 1\.1' + + # 6) Same revision number (no difference). + dotest rdiff-short-no-change \ +"${testcvs} -q rdiff -s -r tag4 -r tag5 abc" + + # 5) Against trunk. + # Check that the messages change when we diff against the trunk + # rather than a tag or date. + dotest rdiff-short-against-trunk-1 \ +"${testcvs} -q rdiff -s -rtag4 abc" \ +"File abc/file1\.txt is new; current revision 1\.3" + + dotest rdiff-short-against-trunk-2 \ +"${testcvs} -q rdiff -s -rtag2 abc" \ +"File abc/file1\.txt changed from revision 1\.2 to 1\.3 +File abc/file2\.txt is new; current revision 1\.1" + + modify_repo rm -rf $CVSROOT_DIRNAME/abc + ;; + + + + rdiff2) + # Test for the segv problem reported by James Cribb + # Somewhere to work + mkdir rdiff2; cd rdiff2 + # Create a module "m" with files "foo" and "d/bar" + mkdir m; cd m + echo foo >foo + mkdir d + echo bar >d/bar + dotest_sort rdiff2-1 \ +"${testcvs} -q import -I ! -m initial-import m vendor initial" \ +' + +N m/d/bar +N m/foo +No conflicts created by this import' + + cd .. + rm -r m + + # Remove "foo" + dotest rdiff2-2 "${testcvs} get m" \ +"${SPROG} checkout: Updating m +U m/foo +${SPROG} checkout: Updating m/d +U m/d/bar" + cd m + dotest rdiff2-3 "${testcvs} rm -f foo" \ +"${SPROG} remove: scheduling .foo. for removal +${SPROG} remove: use .${SPROG} commit. to remove this file permanently" + + dotest rdiff2-4 "${testcvs} commit -m Removed foo" \ +"${CVSROOT_DIRNAME}/m/foo,v <-- foo +new revision: delete; previous revision: 1\.1\.1\.1" + + # Modify "d/bar" + echo foo >d/bar + dotest rdiff2-5 "${testcvs} commit -m Changed d/bar" \ +"${CVSROOT_DIRNAME}/m/d/bar,v <-- d/bar +new revision: 1\.2; previous revision: 1\.1" + + # Crash before showing d/bar diffs + dotest_fail rdiff2-6 "${testcvs} rdiff -t m" \ +"${SPROG} rdiff: Diffing m +${SPROG} rdiff: Diffing m/d +Index: m/d/bar +diff -c m/d/bar:1\.1\.1\.1 m/d/bar:1\.2 +\*\*\* m/d/bar:1\.1\.1\.1 ${DATE} +--- m/d/bar ${DATE} +\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* +\*\*\* 1 \*\*\*\* +! bar +--- 1 ---- +! foo" + + dokeep + cd ../.. + rm -rf rdiff2 + modify_repo rm -rf $CVSROOT_DIRNAME/m + ;; + + + + diff) + # Various tests specific to the "cvs diff" command. + # Related tests: + # death2: -N + # rcslib: cvs diff and $Name. + # rdiff: cvs rdiff. + # diffmerge*: nuts and bolts (stuff within diff library) + mkdir 1; cd 1 + dotest diff-1 "$testcvs -q co -l ." + mkdir first-dir + dotest diff-2 "$testcvs add first-dir" \ +"Directory $CVSROOT_DIRNAME/first-dir added to the repository" + cd first-dir + + # diff is anomalous. Most CVS commands print the "nothing + # known" message (or worse yet, no message in some cases) but + # diff says "I know nothing". Shrug. + dotest_fail diff-3 "${testcvs} diff xyzpdq" \ +"${SPROG} diff: I know nothing about xyzpdq" + touch abc + dotest diff-4 "${testcvs} add abc" \ +"${SPROG} add: scheduling file .abc. for addition +${SPROG} add: use .${SPROG} commit. to add this file permanently" + dotest diff-5 "${testcvs} -q ci -mtest" \ +"$CVSROOT_DIRNAME/first-dir/abc,v <-- abc +initial revision: 1\.1" + echo "extern int gethostname ();" >abc + dotest diff-6 "${testcvs} -q ci -mtest" \ +"$CVSROOT_DIRNAME/first-dir/abc,v <-- abc +new revision: 1\.2; previous revision: 1\.1" + echo "#include <winsock.h>" >abc + # check the behavior of the --ifdef=MACRO option + dotest_fail diff-7 "${testcvs} -q diff --ifdef=HAVE_WINSOCK_H" \ +"Index: abc +=================================================================== +RCS file: ${CVSROOT_DIRNAME}/first-dir/abc,v +retrieving revision 1\.2 +diff --ifdef HAVE_WINSOCK_H -r1\.2 abc +#ifndef HAVE_WINSOCK_H +extern int gethostname (); +#else /\* HAVE_WINSOCK_H \*/ +#include <winsock\.h> +#endif /\* HAVE_WINSOCK_H \*/" + + dokeep + cd ../.. + modify_repo rm -rf $CVSROOT_DIRNAME/first-dir + rm -r 1 + ;; + + + + diffnl) + # Test handling of 'cvs diff' of files without newlines + mkdir 1; cd 1 + dotest diffnl-000 "${testcvs} -q co -l ." '' + mkdir first-dir + dotest diffnl-001 "${testcvs} add first-dir" \ +"Directory ${CVSROOT_DIRNAME}/first-dir added to the repository" + cd first-dir + + ${AWK} 'BEGIN {printf("one\ntwo\nthree\nfour\nfive\nsix")}' </dev/null >abc + dotest diffnl-002 "${testcvs} add abc" \ +"${SPROG} add: scheduling file .abc. for addition +${SPROG} add: use .${SPROG} commit. to add this file permanently" + dotest diffnl-003 "${testcvs} -q ci -mtest" \ +"$CVSROOT_DIRNAME/first-dir/abc,v <-- abc +initial revision: 1\.1" + + # change to line near EOF + ${AWK} 'BEGIN {printf("one\ntwo\nthree\nfour\nsix")}' </dev/null >abc + dotest_fail diffnl-100 "${testcvs} diff abc" \ +"Index: abc +=================================================================== +RCS file: ${CVSROOT_DIRNAME}/first-dir/abc,v +retrieving revision 1\.1 +diff -r1\.1 abc +5d4 +< five" + dotest_fail diffnl-101 "${testcvs} diff -u abc" \ +"Index: abc +=================================================================== +RCS file: ${CVSROOT_DIRNAME}/first-dir/abc,v +retrieving revision 1\.1 +diff -u -r1\.1 abc +--- abc ${RFCDATE} 1\.1 ++++ abc ${RFCDATE} +@@ -2,5 +2,4 @@ + two + three + four +-five + six +\\\\ No newline at end of file" + dotest diffnl-102 "${testcvs} -q ci -mtest abc" \ +"$CVSROOT_DIRNAME/first-dir/abc,v <-- abc +new revision: 1\.2; previous revision: 1\.1" + + # Change to last line + ${AWK} 'BEGIN {printf("one\ntwo\nthree\nfour\nseven")}' </dev/null >abc + dotest_fail diffnl-200 "${testcvs} diff abc" \ +"Index: abc +=================================================================== +RCS file: ${CVSROOT_DIRNAME}/first-dir/abc,v +retrieving revision 1\.2 +diff -r1\.2 abc +5c5 +< six +\\\\ No newline at end of file +--- +> seven +\\\\ No newline at end of file" + dotest_fail diffnl-201 "${testcvs} diff -u abc" \ +"Index: abc +=================================================================== +RCS file: ${CVSROOT_DIRNAME}/first-dir/abc,v +retrieving revision 1\.2 +diff -u -r1\.2 abc +--- abc ${RFCDATE} 1\.2 ++++ abc ${RFCDATE} +@@ -2,4 +2,4 @@ + two + three + four +-six +\\\\ No newline at end of file ++seven +\\\\ No newline at end of file" + dotest diffnl-202 "${testcvs} ci -mtest abc" \ +"${CVSROOT_DIRNAME}/first-dir/abc,v <-- abc +new revision: 1\.3; previous revision: 1\.2" + + # Addition of newline + echo "one +two +three +four +seven" > abc + dotest_fail diffnl-300 "${testcvs} diff abc" \ +"Index: abc +=================================================================== +RCS file: ${CVSROOT_DIRNAME}/first-dir/abc,v +retrieving revision 1\.3 +diff -r1\.3 abc +5c5 +< seven +\\\\ No newline at end of file +--- +> seven" + dotest_fail diffnl-301 "${testcvs} diff -u abc" \ +"Index: abc +=================================================================== +RCS file: ${CVSROOT_DIRNAME}/first-dir/abc,v +retrieving revision 1\.3 +diff -u -r1\.3 abc +--- abc ${RFCDATE} 1\.3 ++++ abc ${RFCDATE} +@@ -2,4 +2,4 @@ + two + three + four +-seven +\\\\ No newline at end of file ++seven" + dotest diffnl-302 "${testcvs} ci -mtest abc" \ +"${CVSROOT_DIRNAME}/first-dir/abc,v <-- abc +new revision: 1\.4; previous revision: 1\.3" + + # Removal of newline + ${AWK} 'BEGIN {printf("one\ntwo\nthree\nfour\nseven")}' </dev/null >abc + dotest_fail diffnl-400 "${testcvs} diff abc" \ +"Index: abc +=================================================================== +RCS file: ${CVSROOT_DIRNAME}/first-dir/abc,v +retrieving revision 1\.4 +diff -r1\.4 abc +5c5 +< seven +--- +> seven +\\\\ No newline at end of file" + dotest_fail diffnl-401 "${testcvs} diff -u abc" \ +"Index: abc +=================================================================== +RCS file: ${CVSROOT_DIRNAME}/first-dir/abc,v +retrieving revision 1\.4 +diff -u -r1\.4 abc +--- abc ${RFCDATE} 1\.4 ++++ abc ${RFCDATE} +@@ -2,4 +2,4 @@ + two + three + four +-seven ++seven +\\\\ No newline at end of file" + + dokeep + cd ../.. + rm -r 1 + modify_repo rm -rf $CVSROOT_DIRNAME/first-dir + ;; + + + + death) + # next dive. test death support. + + # NOTE: this section has reached the size and + # complexity where it is getting to be a good idea to + # add new death support tests to a new section rather + # than continuing to piggyback them onto the tests here. + + modify_repo mkdir $CVSROOT_DIRNAME/first-dir + dotest death-init-1 "$testcvs -Q co first-dir" + + cd first-dir + + # Create a directory with only dead files, to make sure CVS + # doesn't get confused by it. + mkdir subdir + dotest 65a0 "${testcvs} add subdir" \ +"Directory ${CVSROOT_DIRNAME}/first-dir/subdir added to the repository" + cd subdir + echo file in subdir >sfile + dotest 65a1 "${testcvs} add sfile" \ +"${SPROG}"' add: scheduling file `sfile'\'' for addition +'"${SPROG}"' add: use .'"${SPROG}"' commit. to add this file permanently' + dotest 65a2 "${testcvs} -q ci -m add-it" \ +"$CVSROOT_DIRNAME/first-dir/subdir/sfile,v <-- sfile +initial revision: 1\.1" + rm sfile + dotest 65a3 "${testcvs} rm sfile" \ +"${SPROG}"' remove: scheduling `sfile'\'' for removal +'"${SPROG}"' remove: use .'"${SPROG}"' commit. to remove this file permanently' + dotest 65a4 "${testcvs} -q ci -m remove-it" \ +"$CVSROOT_DIRNAME/first-dir/subdir/sfile,v <-- sfile +new revision: delete; previous revision: 1\.1" + cd .. + dotest 65a5 "${testcvs} -q update -P" '' + dotest_fail 65a6 "test -d subdir" '' + + # add a file. + touch file1 + if ${CVS} add file1 2>> ${LOGFILE}; then + pass 66 + else + fail 66 + fi + + # commit + if ${CVS} ci -m test >> ${LOGFILE} 2>&1; then + pass 67 + else + fail 67 + fi + + # remove + rm file1 + if ${CVS} rm file1 2>> ${LOGFILE}; then + pass 68 + else + fail 68 + fi + + # commit + if ${CVS} ci -m test >>${LOGFILE} ; then + pass 69 + else + fail 69 + fi + + dotest_fail 69a0 "test -f file1" '' + # get the old contents of file1 back + if ${testcvs} update -p -r 1.1 file1 >file1 2>>${LOGFILE}; then + pass 69a1 + else + fail 69a1 + fi + dotest 69a2 "cat file1" '' + + # create second file + touch file2 + if ${CVS} add file1 file2 2>> ${LOGFILE}; then + pass 70 + else + fail 70 + fi + + # commit + if ${CVS} ci -m test >> ${LOGFILE} 2>&1; then + pass 71 + else + fail 71 + fi + + # log + if ${CVS} log file1 >> ${LOGFILE}; then + pass 72 + else + fail 72 + fi + + # file4 will be dead at the time of branching and stay dead. + echo file4 > file4 + dotest death-file4-add "${testcvs} add file4" \ +"${SPROG}"' add: scheduling file `file4'\'' for addition +'"${SPROG}"' add: use .'"${SPROG}"' commit. to add this file permanently' + dotest death-file4-ciadd "${testcvs} -q ci -m add file4" \ +"$CVSROOT_DIRNAME/first-dir/file4,v <-- file4 +initial revision: 1\.1" + rm file4 + dotest death-file4-rm "${testcvs} remove file4" \ +"${SPROG}"' remove: scheduling `file4'\'' for removal +'"${SPROG}"' remove: use .'"${SPROG}"' commit. to remove this file permanently' + dotest death-file4-cirm "${testcvs} -q ci -m remove file4" \ +"$CVSROOT_DIRNAME/first-dir/file4,v <-- file4 +new revision: delete; previous revision: 1\.1" + + # Tag the branchpoint. + dotest death-72a "${testcvs} -q tag bp_branch1" 'T file1 +T file2' + + # branch1 + if ${CVS} tag -b branch1 ; then + pass 73 + else + fail 73 + fi + + # and move to the branch. + if ${CVS} update -r branch1 ; then + pass 74 + else + fail 74 + fi + + dotest_fail death-file4-3 "test -f file4" '' + + # add a file in the branch + echo line1 from branch1 >> file3 + if ${CVS} add file3 2>> ${LOGFILE}; then + pass 75 + else + fail 75 + fi + + # commit + if ${CVS} ci -m test >> ${LOGFILE} 2>&1; then + pass 76 + else + fail 76 + fi + + dotest death-76a0 \ +"${testcvs} -q rdiff -r bp_branch1 -r branch1 first-dir" \ +"Index: first-dir/file3 +diff -c /dev/null first-dir/file3:1\.1\.2\.1 +\*\*\* /dev/null ${DATE} +--- first-dir/file3 ${DATE} +\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* +\*\*\* 0 \*\*\*\* +--- 1 ---- +${PLUS} line1 from branch1" + dotest death-76a1 \ +"${testcvs} -q rdiff -r branch1 -r bp_branch1 first-dir" \ +"Index: first-dir/file3 +diff -c first-dir/file3:1\.1\.2\.1 first-dir/file3:removed +\*\*\* first-dir/file3:1\.1\.2\.1 ${DATE} +--- first-dir/file3 ${DATE} +\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* +\*\*\* 1 \*\*\*\* +- line1 from branch1 +--- 0 ----" + + # remove + rm file3 + if ${CVS} rm file3 2>> ${LOGFILE}; then + pass 77 + else + fail 77 + fi + + # commit + if ${CVS} ci -m test >>${LOGFILE} ; then + pass 78 + else + fail 78 + fi + + # add again + echo line1 from branch1 >> file3 + if ${CVS} add file3 2>> ${LOGFILE}; then + pass 79 + else + fail 79 + fi + + # commit + if ${CVS} ci -m test >> ${LOGFILE} 2>&1; then + pass 80 + else + fail 80 + fi + + # change the first file + echo line2 from branch1 >> file1 + + # commit + if ${CVS} ci -m test >> ${LOGFILE} 2>&1; then + pass 81 + else + fail 81 + fi + + # remove the second + rm file2 + if ${CVS} rm file2 2>> ${LOGFILE}; then + pass 82 + else + fail 82 + fi + + # commit + if ${CVS} ci -m test >>${LOGFILE}; then + pass 83 + else + fail 83 + fi + + # back to the trunk. + if ${CVS} update -A 2>> ${LOGFILE}; then + pass 84 + else + fail 84 + fi + + dotest_fail death-file4-4 "test -f file4" '' + + if test -f file3 ; then + fail 85 + else + pass 85 + fi + + # join + dotest death-86 "$testcvs -q update -j branch1" \ +"RCS file: $CVSROOT_DIRNAME/first-dir/file1,v +retrieving revision 1\.3 +retrieving revision 1\.3\.2\.1 +Merging differences between 1\.3 and 1\.3\.2\.1 into file1 +${SPROG} update: scheduling \`file2' for removal +U file3" + + dotest_fail death-file4-5 "test -f file4" '' + + if test -f file3 ; then + pass 87 + else + fail 87 + fi + + # Make sure that we joined the correct change to file1 + if echo line2 from branch1 | cmp - file1 >/dev/null; then + pass 87a + else + fail 87a + fi + + # update + if ${CVS} update ; then + pass 88 + else + fail 88 + fi + + # commit + dotest 89 "${testcvs} -q ci -m test" \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +new revision: 1\.4; previous revision: 1\.3 +$CVSROOT_DIRNAME/first-dir/file2,v <-- file2 +new revision: delete; previous revision: 1\.1 +$CVSROOT_DIRNAME/first-dir/file3,v <-- file3 +new revision: 1\.2; previous revision: 1\.1" + cd .. + mkdir 2 + cd 2 + dotest 89a "${testcvs} -q co first-dir" 'U first-dir/file1 +U first-dir/file3' + cd .. + rm -r 2 + cd first-dir + + # remove first file. + rm file1 + if ${CVS} rm file1 2>> ${LOGFILE}; then + pass 90 + else + fail 90 + fi + + # commit + if ${CVS} ci -m test >>${LOGFILE}; then + pass 91 + else + fail 91 + fi + + if test -f file1 ; then + fail 92 + else + pass 92 + fi + + # typo; try to get to the branch and fail + dotest_fail 92.1a "$testcvs update -r brnach1" \ + "$SPROG \[update aborted\]: no such tag \`brnach1'" + # Make sure we are still on the trunk + if test -f file1 ; then + fail 92.1b + else + pass 92.1b + fi + if test -f file3 ; then + pass 92.1c + else + fail 92.1c + fi + + # back to branch1 + if ${CVS} update -r branch1 2>> ${LOGFILE}; then + pass 93 + else + fail 93 + fi + + dotest_fail death-file4-6 "test -f file4" '' + + if test -f file1 ; then + pass 94 + else + fail 94 + fi + + # and join + dotest 95 "${testcvs} -q update -j HEAD" \ +"${SPROG}"' update: file file1 has been modified, but has been removed in revision HEAD +'"${SPROG}"' update: file file3 exists, but has been added in revision HEAD' + + dotest_fail death-file4-7 "test -f file4" '' + + # file2 should not have been recreated. It was + # deleted on the branch, and has not been modified on + # the trunk. That means that there have been no + # changes between the greatest common ancestor (the + # trunk version) and HEAD. + dotest_fail death-file2-1 "test -f file2" '' + + dokeep + cd .. + rm -r first-dir + modify_repo rm -rf $CVSROOT_DIRNAME/first-dir + ;; + + + + death2) + # More tests of death support. + modify_repo mkdir $CVSROOT_DIRNAME/first-dir + dotest death2-1 "$testcvs -q co first-dir" + + cd first-dir + + # Add two files on the trunk. + echo "first revision" > file1 + echo "file4 first revision" > file4 + dotest death2-2 "${testcvs} add file1 file4" \ +"${SPROG}"' add: scheduling file `file1'\'' for addition +'"${SPROG}"' add: scheduling file `file4'\'' for addition +'"${SPROG}"' add: use .'"${SPROG}"' commit. to add these files permanently' + + dotest death2-3 "${testcvs} -q commit -m add" \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +initial revision: 1\.1 +$CVSROOT_DIRNAME/first-dir/file4,v <-- file4 +initial revision: 1\.1" + + # Make a branch and a non-branch tag. + dotest death2-4 "${testcvs} -q tag -b branch" \ +'T file1 +T file4' + dotest death2-5 "${testcvs} -q tag tag" \ +'T file1 +T file4' + + # Switch over to the branch. + dotest death2-6 "${testcvs} -q update -r branch" '' + + # Delete the file on the branch. + rm file1 + dotest death2-7 "${testcvs} rm file1" \ +"${SPROG} remove: scheduling .file1. for removal +${SPROG} remove: use .${SPROG} commit. to remove this file permanently" + + # Test diff of the removed file before it is committed. + dotest_fail death2-diff-1 "${testcvs} -q diff file1" \ +"${SPROG} diff: file1 was removed, no comparison available" + + dotest_fail death2-diff-2 "${testcvs} -q diff -N -c file1" \ +"Index: file1 +=================================================================== +RCS file: file1 +diff -N file1 +\*\*\* file1 ${RFCDATE} [0-9.]* +--- /dev/null ${RFCDATE_EPOCH} +\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* +\*\*\* 1 \*\*\*\* +- first revision +--- 0 ----" + + dotest death2-8 "${testcvs} -q ci -m removed" \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +new revision: delete; previous revision: 1\.1" + + # Test diff of a dead file. + dotest_fail death2-diff-3 \ +"${testcvs} -q diff -r1.1 -rbranch -c file1" \ +"${SPROG} diff: Tag branch refers to a dead (removed) revision in file .file1.\. +${SPROG} diff: No comparison available\. Pass .-N. to .${SPROG} diff.${QUESTION}" + # and in reverse + dotest_fail death2-diff-3a \ +"${testcvs} -q diff -rbranch -r1.1 -c file1" \ +"${SPROG} diff: Tag branch refers to a dead (removed) revision in file .file1.\. +${SPROG} diff: No comparison available\. Pass .-N. to .${SPROG} diff.${QUESTION}" + + dotest_fail death2-diff-4 \ +"${testcvs} -q diff -r1.1 -rbranch -N -c file1" \ +"Index: file1 +=================================================================== +RCS file: file1 +diff -N file1 +\*\*\* file1 ${RFCDATE} [0-9.]* +--- /dev/null ${RFCDATE_EPOCH} +\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* +\*\*\* 1 \*\*\*\* +- first revision +--- 0 ----" + # and in reverse + dotest_fail death2-diff-4a \ +"${testcvs} -q diff -rbranch -r1.1 -N -c file1" \ +"Index: file1 +=================================================================== +RCS file: file1 +diff -N file1 +\*\*\* /dev/null ${RFCDATE_EPOCH} +--- file1 ${RFCDATE} [0-9.]* +\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* +\*\*\* 0 \*\*\*\* +--- 1 ---- ++ first revision" + + + dotest_fail death2-diff-5 "${testcvs} -q diff -rtag -c ." \ +"${SPROG} diff: file1 no longer exists, no comparison available" + + dotest_fail death2-diff-6 "${testcvs} -q diff -rtag -N -c ." \ +"Index: file1 +=================================================================== +RCS file: file1 +diff -N file1 +\*\*\* file1 [-a-zA-Z0-9: ]* [0-9.]* +--- /dev/null ${RFCDATE_EPOCH} +\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* +\*\*\* 1 \*\*\*\* +- first revision +--- 0 ----" + + # Test rdiff of a dead file. + dotest death2-rdiff-1 \ +"${testcvs} -q rtag -rbranch rdiff-tag first-dir" '' + + dotest death2-rdiff-2 "${testcvs} -q rdiff -rtag -rbranch first-dir" \ +"Index: first-dir/file1 +diff -c first-dir/file1:1\.1 first-dir/file1:removed +\*\*\* first-dir/file1:1\.1 [a-zA-Z0-9: ]* +--- first-dir/file1 [a-zA-Z0-9: ]* +\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* +\*\*\* 1 \*\*\*\* +- first revision +--- 0 ----" + + # Readd the file to the branch. + echo "second revision" > file1 + dotest death2-9 "${testcvs} add file1" \ +"${SPROG} add: Re-adding file \`file1' on branch \`branch' after dead revision 1\.1\.2\.1\. +${SPROG} add: use \`${SPROG} commit' to add this file permanently" + + # Test diff of the added file before it is committed. + dotest_fail death2-diff-7 "${testcvs} -q diff file1" \ +"${SPROG} diff: file1 is a new entry, no comparison available" + + dotest_fail death2-diff-8 "${testcvs} -q diff -N -c file1" \ +"Index: file1 +=================================================================== +RCS file: file1 +diff -N file1 +\*\*\* /dev/null ${RFCDATE_EPOCH} +--- file1 ${RFCDATE} +\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* +\*\*\* 0 \*\*\*\* +--- 1 ---- +${PLUS} second revision" + + dotest death2-10 "${testcvs} -q commit -m add" \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +new revision: 1\.1\.2\.2; previous revision: 1\.1\.2\.1" + + # Delete file4 from the branch + dotest death2-10a "${testcvs} rm -f file4" \ +"${SPROG} remove: scheduling .file4. for removal +${SPROG} remove: use .${SPROG} commit. to remove this file permanently" + dotest death2-10b "${testcvs} -q ci -m removed" \ +"$CVSROOT_DIRNAME/first-dir/file4,v <-- file4 +new revision: delete; previous revision: 1\.1" + + # Back to the trunk. + dotest death2-11 "${testcvs} -q update -A" \ +"[UP] file1 +U file4" + + # Add another file on the trunk. + echo "first revision" > file2 + dotest death2-12 "${testcvs} add file2" \ +"${SPROG}"' add: scheduling file `file2'\'' for addition +'"${SPROG}"' add: use .'"${SPROG}"' commit. to add this file permanently' + dotest death2-13 "${testcvs} -q commit -m add" \ +"$CVSROOT_DIRNAME/first-dir/file2,v <-- file2 +initial revision: 1\.1" + + # Modify file4 on the trunk. + echo "new file4 revision" > file4 + dotest death2-13a "${testcvs} -q commit -m mod" \ +"$CVSROOT_DIRNAME/first-dir/file4,v <-- file4 +new revision: 1\.2; previous revision: 1\.1" + + # Back to the branch. + # The ``no longer in the repository'' message doesn't really + # look right to me, but that's what CVS currently prints for + # this case. + dotest death2-14 "${testcvs} -q update -r branch" \ +"[UP] file1 +${SPROG} update: \`file2' is no longer in the repository +${SPROG} update: \`file4' is no longer in the repository" + + # Add a file on the branch with the same name. + echo "branch revision" > file2 + dotest death2-15 "${testcvs} add file2" \ +"${SPROG}"' add: scheduling file `file2'\'' for addition on branch `branch'\'' +'"${SPROG}"' add: use .'"${SPROG}"' commit. to add this file permanently' + dotest death2-16 "${testcvs} -q commit -m add" \ +"$CVSROOT_DIRNAME/first-dir/file2,v <-- file2 +new revision: 1\.1\.2\.2; previous revision: 1\.1\.2\.1" + + # Add a new file on the branch. + echo "first revision" > file3 + dotest death2-17 "${testcvs} add file3" \ +"${SPROG}"' add: scheduling file `file3'\'' for addition on branch `branch'\'' +'"${SPROG}"' add: use .'"${SPROG}"' commit. to add this file permanently' + dotest death2-18 "${testcvs} -q commit -m add" \ +"$CVSROOT_DIRNAME/first-dir/Attic/file3,v <-- file3 +new revision: 1\.1\.2\.1; previous revision: 1\.1" + + # Test diff of a nonexistent tag + dotest_fail death2-diff-9 "$testcvs -q diff -rtag -c file3" \ +"$SPROG diff: tag tag is not in file file3" + + dotest_fail death2-diff-10 "${testcvs} -q diff -rtag -N -c file3" \ +"Index: file3 +=================================================================== +RCS file: file3 +diff -N file3 +\*\*\* /dev/null ${RFCDATE_EPOCH} +--- file3 ${RFCDATE} [0-9.]* +\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* +\*\*\* 0 \*\*\*\* +--- 1 ---- +${PLUS} first revision" + + dotest_fail death2-diff-11 "${testcvs} -q diff -rtag -c ." \ +"Index: file1 +=================================================================== +RCS file: ${CVSROOT_DIRNAME}/first-dir/file1,v +retrieving revision 1\.1 +retrieving revision 1\.1\.2\.2 +diff -c -r1\.1 -r1\.1\.2\.2 +\*\*\* file1 ${RFCDATE} [0-9.]* +--- file1 ${RFCDATE} [0-9.]* +\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* +\*\*\* 1 \*\*\*\* +! first revision +--- 1 ---- +! second revision +${SPROG} diff: tag tag is not in file file2 +${SPROG} diff: tag tag is not in file file3 +${SPROG} diff: file4 no longer exists, no comparison available" + + dotest_fail death2-diff-12 "${testcvs} -q diff -rtag -c -N ." \ +"Index: file1 +=================================================================== +RCS file: ${CVSROOT_DIRNAME}/first-dir/file1,v +retrieving revision 1\.1 +retrieving revision 1\.1\.2\.2 +diff -c -r1\.1 -r1\.1\.2\.2 +\*\*\* file1 ${RFCDATE} [0-9.]* +--- file1 ${RFCDATE} [0-9.]* +\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* +\*\*\* 1 \*\*\*\* +! first revision +--- 1 ---- +! second revision +Index: file2 +=================================================================== +RCS file: file2 +diff -N file2 +\*\*\* /dev/null ${RFCDATE_EPOCH} +--- file2 ${RFCDATE} [0-9.]* +\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* +\*\*\* 0 \*\*\*\* +--- 1 ---- +${PLUS} branch revision +Index: file3 +=================================================================== +RCS file: file3 +diff -N file3 +\*\*\* /dev/null ${RFCDATE_EPOCH} +--- file3 ${RFCDATE} [0-9.]* +\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* +\*\*\* 0 \*\*\*\* +--- 1 ---- +${PLUS} first revision +Index: file4 +=================================================================== +RCS file: file4 +diff -N file4 +\*\*\* file4 ${RFCDATE} [0-9.]* +--- /dev/null ${RFCDATE_EPOCH} +\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* +\*\*\* 1 \*\*\*\* +- file4 first revision +--- 0 ----" + + # Switch to the nonbranch tag. + dotest death2-19 "${testcvs} -q update -r tag" \ +"[UP] file1 +${SPROG} update: \`file2' is no longer in the repository +${SPROG} update: \`file3' is no longer in the repository +U file4" + + dotest_fail death2-20 "test -f file2" + + # Make sure diff only reports appropriate files. + dotest_fail death2-diff-13 "${testcvs} -q diff -r rdiff-tag" \ +"${SPROG} diff: Tag rdiff-tag refers to a dead (removed) revision in file .file1.\. +${SPROG} diff: No comparison available\. Pass .-N. to .${SPROG} diff.${QUESTION}" + + dotest_fail death2-diff-14 "${testcvs} -q diff -r rdiff-tag -c -N" \ +"Index: file1 +=================================================================== +RCS file: file1 +diff -N file1 +\*\*\* /dev/null ${RFCDATE_EPOCH} +--- file1 ${RFCDATE} [0-9.]* +\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* +\*\*\* 0 \*\*\*\* +--- 1 ---- +${PLUS} first revision" + + # now back to the trunk + dotest death2-21 "${testcvs} -q update -A" \ +"U file2 +[UP] file4" + + # test merging with a dead file + dotest death2-22 "${testcvs} -q co first-dir" \ +"U first-dir/file1 +U first-dir/file2 +U first-dir/file4" + + cd first-dir + dotest death2-23 "${testcvs} rm -f file4" \ +"${SPROG} remove: scheduling .file4. for removal +${SPROG} remove: use .${SPROG} commit. to remove this file permanently" + dotest death2-24 "${testcvs} -q ci -m removed file4" \ +"$CVSROOT_DIRNAME/first-dir/file4,v <-- file4 +new revision: delete; previous revision: 1\.2" + cd .. + echo "new stuff" >file4 + dotest_fail death2-25 "${testcvs} up file4" \ +"${SPROG} update: conflict: \`file4' is modified but no longer in the repository +C file4" + + dokeep + cd .. + rm -r first-dir + modify_repo rm -rf $CVSROOT_DIRNAME/first-dir + ;; + + + + rm-update-message) + # FIXME + # local CVS prints a warning message when update notices a missing + # file and client/server CVS doesn't. These should be identical. + mkdir rm-update-message; cd rm-update-message + modify_repo mkdir $CVSROOT_DIRNAME/rm-update-message + dotest rm-update-message-setup-1 "$testcvs -q co rm-update-message" '' + cd rm-update-message + file=x + echo >$file + dotest rm-update-message-setup-2 "$testcvs -q add $file" \ +"${SPROG} add: use .${SPROG} commit. to add this file permanently" + dotest rm-update-message-setup-3 "$testcvs -q ci -mcreate $file" \ +"$CVSROOT_DIRNAME/rm-update-message/$file,v <-- $file +initial revision: 1\.1" + + rm $file + dotest rm-update-message-1 "$testcvs up $file" \ +"${SPROG} update: warning: \`$file' was lost +U $file" + + dokeep + cd ../.. + rm -r rm-update-message + modify_repo rm -rf $CVSROOT_DIRNAME/rm-update-message + ;; + + + + rmadd) + # More tests of adding and removing files. + # In particular ci -r. + # Other ci -r tests: + # * editor-9: checking in a modified file, + # where "ci -r" means a branch. + # * basica-8a1: checking in a modified file with numeric revision. + # * basica-8a2: likewise. + # * keywordlog-4: adding a new file with numeric revision. + mkdir 1; cd 1 + dotest rmadd-1 "$testcvs -q co -l ." + mkdir first-dir + dotest rmadd-2 "${testcvs} add first-dir" \ +"Directory ${CVSROOT_DIRNAME}/first-dir added to the repository" + cd first-dir + echo first file1 >file1 + dotest rmadd-3 "${testcvs} add file1" \ +"${SPROG} add: scheduling file .file1. for addition +${SPROG} add: use .${SPROG} commit. to add this file permanently" + + dotest_fail rmadd-4 "${testcvs} -q ci -r 1.2.2.4 -m add" \ +"${SPROG} commit: cannot add file .file1' with revision .1\.2\.2\.4'; must be on trunk +${SPROG} \[commit aborted\]: correct above errors first!" + dotest_fail rmadd-5 "${testcvs} -q ci -r 1.2.2 -m add" \ +"${SPROG} commit: cannot add file .file1' with revision .1\.2\.2'; must be on trunk +${SPROG} \[commit aborted\]: correct above errors first!" + dotest_fail rmadd-6 "$testcvs -q ci -r mybranch -m add" \ +"$SPROG \[commit aborted\]: no such tag \`mybranch'" + + # The thing with the trailing periods strikes me as a very + # bizarre behavior, but it would seem to be intentional + # (see commit.c). It probably could go away.... + dotest rmadd-7 "${testcvs} -q ci -r 7.... -m add" \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +initial revision: 7\.1" + if $remote; then + # I guess remote doesn't set a sticky tag in this case. + # Kind of odd, in the sense that rmadd-24a does set one + # both local and remote. + dotest_fail rmadd-7a "test -f CVS/Tag" + echo T7 >CVS/Tag + else + dotest rmadd-7a "cat CVS/Tag" "T7" + fi + + dotest rmadd-8 "${testcvs} -q tag -b mybranch" "T file1" + dotest rmadd-9 "${testcvs} -q tag mynonbranch" "T file1" + + touch file2 + # The previous "cvs ci -r" set a sticky tag of '7'. Seems a + # bit odd, and I guess commit.c (findmaxrev) makes '7' sticky + # tags unnecessary (?). I kind of suspect that it should be + # saying "sticky tag is not a branch" like keywordlog-4b. + # Or something. + dotest rmadd-10 "${testcvs} add file2" \ +"${SPROG} add: scheduling file .file2. for addition on branch .7' +${SPROG} add: use .${SPROG} commit. to add this file permanently" + # As in the previous example, CVS is confused.... + dotest rmadd-11 "${testcvs} -q ci -m add" \ +"$CVSROOT_DIRNAME/first-dir/file2,v <-- file2 +initial revision: 7\.1" + + dotest rmadd-12 "${testcvs} -q update -A" "" + touch file3 + dotest rmadd-13 "${testcvs} add file3" \ +"${SPROG} add: scheduling file .file3. for addition +${SPROG} add: use .${SPROG} commit. to add this file permanently" + # Huh? file2 is not up to date? Seems buggy to me.... + dotest_fail rmadd-14 "${testcvs} -q ci -r mybranch -m add" \ +"${SPROG} commit: Up-to-date check failed for .file2' +${SPROG} \[commit aborted\]: correct above errors first!" + # Whatever, let's not let file2 distract us.... + dotest rmadd-15 "${testcvs} -q ci -r mybranch -m add file3" \ +"$CVSROOT_DIRNAME/first-dir/Attic/file3,v <-- file3 +new revision: 1\.1\.2\.1; previous revision: 1\.1" + + touch file4 + dotest rmadd-16 "${testcvs} add file4" \ +"${SPROG} add: scheduling file .file4. for addition +${SPROG} add: use .${SPROG} commit. to add this file permanently" + # Prior to CVS 1.12.10, this would fail with a, "no such tag" message + # since val-tags used to be updated the first time the tag was used + # rather than when it was created. + + # Try to make CVS write val-tags. + if $proxy; then :; else + # First remove the tag. + grep -v mynonbranch $CVSROOT_DIRNAME/CVSROOT/val-tags \ + >$CVSROOT_DIRNAME/CVSROOT/val-tags-tmp + mv $CVSROOT_DIRNAME/CVSROOT/val-tags-tmp \ + $CVSROOT_DIRNAME/CVSROOT/val-tags + + dotest rmadd-18 "$testcvs -q update -p -r mynonbranch file1" \ +"first file1" + # Oops, -p suppresses writing val-tags (probably a questionable + # behavior). + dotest_fail rmadd-19 \ +"$testcvs -q ci -r mynonbranch -m add file4" \ +"$SPROG \[commit aborted\]: no such tag \`mynonbranch'" + # Now make CVS write val-tags for real. + dotest rmadd-20 "$testcvs -q update -r mynonbranch file1" + fi # !$proxy + + # Oops - CVS isn't distinguishing between a branch tag and + # a non-branch tag. + dotest rmadd-21 \ +"${testcvs} -q ci -r mynonbranch -m add file4" \ +"$CVSROOT_DIRNAME/first-dir/Attic/file4,v <-- file4 +new revision: 1\.1\.2\.1; previous revision: 1\.1" + + # OK, we add this one in a vanilla way, but then check in + # a modification with ci -r and sniff around for sticky tags. + echo file5 >file5 + dotest rmadd-22 "${testcvs} add file5" \ +"${SPROG} add: scheduling file .file5. for addition +${SPROG} add: use .${SPROG} commit. to add this file permanently" + if $remote; then + # Interesting bug (or missing feature) here. findmaxrev + # gets the major revision from the Entries. Well, remote + # doesn't send the entries for files which are not involved. + dotest rmadd-23r "${testcvs} -q ci -m add" \ +"$CVSROOT_DIRNAME/first-dir/file5,v <-- file5 +initial revision: 1\.1" + dotest rmadd-23-workaroundr \ +"${testcvs} -q ci -r 7 -m bump-it file5" \ +"$CVSROOT_DIRNAME/first-dir/file5,v <-- file5 +new revision: 7\.1; previous revision: 1\.1" + else + dotest rmadd-23 "${testcvs} -q ci -m add" \ +"$CVSROOT_DIRNAME/first-dir/file5,v <-- file5 +initial revision: 7\.1" + fi + echo change it >file5 + dotest_fail rmadd-24 "$testcvs -q ci -r 4.8 -m change file5" \ +"$CVSROOT_DIRNAME/first-dir/file5,v <-- file5 +$SPROG commit: $CVSROOT_DIRNAME/first-dir/file5,v: revision 4\.8 too low; must be higher than 7\.1 +$SPROG commit: could not check in file5" + dotest rmadd-24a "${testcvs} -q ci -r 8.4 -m change file5" \ +"$CVSROOT_DIRNAME/first-dir/file5,v <-- file5 +new revision: 8\.4; previous revision: 7\.1" + # I'm not really sure that a sticky tag make sense here. + # It seems to be longstanding behavior for what that is worth. + dotest rmadd-25 "${testcvs} status file5" \ +"=================================================================== +File: file5 Status: Up-to-date + + Working revision: 8\.4.* + Repository revision: 8\.4 ${CVSROOT_DIRNAME}/first-dir/file5,v + Commit Identifier: ${commitid} + Sticky Tag: 8\.4 + Sticky Date: (none) + Sticky Options: (none)" + + # now try forced revision with recursion + mkdir sub + dotest rmadd-26 "${testcvs} -q add sub" \ +"Directory ${CVSROOT_DIRNAME}/first-dir/sub added to the repository" + echo hello >sub/subfile + dotest rmadd-27 "${testcvs} -q add sub/subfile" \ +"${SPROG} add: use .${SPROG} commit. to add this file permanently" + + dotest rmadd-28 "${testcvs} -q ci -m. sub" \ +"$CVSROOT_DIRNAME/first-dir/sub/subfile,v <-- sub/subfile +initial revision: 1\.1" + + # lose the branch + dotest rmadd-29 "${testcvs} -q up -A" \ +"${SPROG} update: \`file3' is no longer in the repository +${SPROG} update: \`file4' is no longer in the repository" + + # -f disables recursion + dotest rmadd-30 "${testcvs} -q ci -f -r9 -m." \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +new revision: 9\.1; previous revision: 7\.1 +$CVSROOT_DIRNAME/first-dir/file2,v <-- file2 +new revision: 9\.1; previous revision: 7\.1 +$CVSROOT_DIRNAME/first-dir/file5,v <-- file5 +new revision: 9\.1; previous revision: 8\.4" + + # add -R to force recursion + dotest rmadd-31 "${testcvs} -q ci -f -r9 -R -m." \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +new revision: 9\.2; previous revision: 9\.1 +$CVSROOT_DIRNAME/first-dir/file2,v <-- file2 +new revision: 9\.2; previous revision: 9\.1 +$CVSROOT_DIRNAME/first-dir/file5,v <-- file5 +new revision: 9\.2; previous revision: 9\.1 +$CVSROOT_DIRNAME/first-dir/sub/subfile,v <-- sub/subfile +new revision: 9\.1; previous revision: 1\.1" + + if $remote; then + # as noted above, remote doesn't set a sticky tag + : + else + dotest rmadd-32 "cat CVS/Tag" "T9" + dotest rmadd-33 "cat sub/CVS/Tag" "T9" + fi + + dokeep + cd ../.. + rm -r 1 + modify_repo rm -rf $CVSROOT_DIRNAME/first-dir + ;; + + + + rmadd2) + # Tests of undoing commits, including in the presence of + # adding and removing files. See join for a list of -j tests. + mkdir 1; cd 1 + dotest rmadd2-1 "${testcvs} -q co -l ." '' + mkdir first-dir + dotest rmadd2-2 "${testcvs} add first-dir" \ +"Directory ${CVSROOT_DIRNAME}/first-dir added to the repository" + cd first-dir + echo 'initial contents' >file1 + dotest rmadd2-3 "${testcvs} add file1" \ +"${SPROG} add: scheduling file .file1. for addition +${SPROG} add: use .${SPROG} commit. to add this file permanently" + dotest rmadd2-4 "${testcvs} -q ci -m add" \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +initial revision: 1\.1" + dotest rmadd2-4a "${testcvs} -Q tag tagone" "" + dotest rmadd2-5 "${testcvs} rm -f file1" \ +"${SPROG} remove: scheduling .file1. for removal +${SPROG} remove: use .${SPROG} commit. to remove this file permanently" + dotest rmadd2-6 "${testcvs} -q ci -m remove" \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +new revision: delete; previous revision: 1\.1" + dotest rmadd2-7 "$testcvs -q update -j 1.2 -j 1.1 file1" "U file1" + dotest rmadd2-8 "${testcvs} -q ci -m readd" \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +new revision: 1\.3; previous revision: 1\.2" + echo 'new contents' >file1 + dotest rmadd2-9 "${testcvs} -q ci -m modify" \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +new revision: 1\.4; previous revision: 1\.3" + dotest rmadd2-10 "${testcvs} -q update -j 1.4 -j 1.3 file1" \ +"RCS file: ${CVSROOT_DIRNAME}/first-dir/file1,v +retrieving revision 1\.4 +retrieving revision 1\.3 +Merging differences between 1\.4 and 1\.3 into file1" + dotest rmadd2-11 "${testcvs} -q ci -m undo" \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +new revision: 1\.5; previous revision: 1\.4" + dotest rmadd2-12 "cat file1" "initial contents" + dotest rmadd2-13 "${testcvs} -q update -p -r 1.3" "initial contents" + + # Hmm, might be a bit odd that this works even if 1.3 is not + # the head. + dotest rmadd2-14 "${testcvs} -q update -j 1.3 -j 1.2 file1" \ +"${SPROG} update: scheduling \`file1' for removal" + + # Check that -p can get arbitrary revisions of a removed file + dotest rmadd2-14a "${testcvs} -q update -p" "initial contents" + dotest rmadd2-14b "${testcvs} -q update -p -r 1.5" "initial contents" + dotest rmadd2-14c "${testcvs} -q update -p -r 1.3" "initial contents" + + dotest rmadd2-15 "${testcvs} -q ci -m re-remove" \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +new revision: delete; previous revision: 1\.5" + dotest rmadd2-16 "${testcvs} log -h file1" " +RCS file: ${CVSROOT_DIRNAME}/first-dir/Attic/file1,v +Working file: file1 +head: 1\.6 +branch: +locks: strict +access list: +symbolic names: + tagone: 1\.1 +keyword substitution: kv +total revisions: 6 +=============================================================================" + dotest rmadd2-17 "${testcvs} status -v file1" \ +"=================================================================== +File: no file file1 Status: Up-to-date + + Working revision: No entry for file1 + Repository revision: 1\.6 ${CVSROOT_DIRNAME}/first-dir/Attic/file1,v + Commit Identifier: ${commitid} + + Existing Tags: + tagone (revision: 1.1)" + + dokeep + cd ../.. + rm -r 1 + modify_repo rm -rf $CVSROOT_DIRNAME/first-dir + ;; + + + + rmadd3) + # This test demonstrates that CVS notices that file1 exists rather + # that deleting or writing over it after: + # + # cvs remove -f file1; touch file1; cvs add file1. + # + # According to the manual, this should work for: + # + # rm file1; cvs remove file1; cvs add file1 + # + # but in past version of CVS, new content in file1 would be + # erroneously deleted when file1 reappeared between the remove and + # the add. + # + # Later versions of CVS would refuse to perform the add, but still + # allow a subsequent local commit to erase the file from the + # workspace, possibly losing data. + mkdir 1; cd 1 + dotest rmadd3-init1 "${testcvs} -q co -l ." '' + mkdir first-dir + dotest rmadd3-init2 "${testcvs} add first-dir" \ +"Directory ${CVSROOT_DIRNAME}/first-dir added to the repository" + cd first-dir + + echo initial content for file1 >file1 + dotest rmadd3-init3 "${testcvs} add file1" \ +"${SPROG} add: scheduling file \`file1' for addition +${SPROG} add: use \`${SPROG} commit' to add this file permanently" + dotest rmadd3-init4 "${testcvs} -q ci -m add" \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +initial revision: 1\.1" + + # Here begins the guts of this test, as detailed above. + dotest rmadd3-1 "${testcvs} rm -f file1" \ +"${SPROG} remove: scheduling \`file1' for removal +${SPROG} remove: use \`${SPROG} commit' to remove this file permanently" + + # Now recreate the file: + echo desired future contents for file1 >file1 + + # And attempt to resurrect it at the same time: + dotest_fail rmadd3-2 "${testcvs} add file1" \ +"${SPROG} add: \`file1' should be removed and is still there (or is back again)" + + # Now prove that commit knows that it shouldn't erase files. + dotest_fail rmadd3-3 "${testcvs} -q ci -m." \ +"$CPROG commit: \`file1' should be removed and is still there (or is back again) +$CPROG \[commit aborted\]: correct above errors first!" + + # Then these should pass too: + dotest rmadd3-4 "test -f file1" + dotest rmadd3-5 "cat file1" "desired future contents for file1" + + if $keep; then + echo Keeping ${TESTDIR} and exiting due to --keep + exit 0 + fi + + dokeep + cd ../.. + rm -r 1 + modify_repo rm -rf $CVSROOT_DIRNAME/first-dir + ;; + + + + resurrection) + # This test tests a few file resurrection scenarios. + mkdir 1; cd 1 + dotest resurrection-init1 "$testcvs -q co -l ." '' + mkdir first-dir + dotest resurrection-init2 "$testcvs add first-dir" \ +"Directory $CVSROOT_DIRNAME/first-dir added to the repository" + cd first-dir + + echo initial content for file1 >file1 + dotest resurrection-init3 "$testcvs add file1" \ +"$SPROG add: scheduling file \`file1' for addition +$SPROG add: use \`$SPROG commit' to add this file permanently" + dotest resurrection-init4 "$testcvs -q ci -m add" \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +initial revision: 1\.1" + + dotest resurrection-init5 "$testcvs -Q rm -f file1" + + # The first test is that `cvs add' will resurrect a file before its + # removal has been committed. + dotest_sort resurrection-1 "$testcvs add file1" \ +"U file1 +$SPROG add: \`file1', version 1\.1, resurrected" + dotest resurrection-2 "$testcvs -Q diff file1" "" + + dotest resurrection-init6 "$testcvs -Q tag -b resurrection" + dotest resurrection-init7 "$testcvs -Q rm -f file1" + dotest resurrection-init8 "$testcvs -Q ci -mrm" + + # The next test is that CVS will resurrect a committed removal. + dotest_sort resurrection-3 "$testcvs add file1" \ +"U file1 +$SPROG add: Re-adding file \`file1' after dead revision 1\.2\. +$SPROG add: Resurrecting file \`file1' from revision 1\.1\. +$SPROG add: use \`$SPROG commit' to add this file permanently" + dotest resurrection-4 "$testcvs -q diff -r1.1 file1" "" + dotest resurrection-5 "$testcvs -q ci -mreadd" \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +new revision: 1\.3; previous revision: 1\.2" + + dotest resurrection-init9 "$testcvs -Q up -rresurrection" + dotest resurrection-init10 "$testcvs -Q rm -f file1" + dotest resurrection-init11 "$testcvs -Q ci -mrm-on-resurrection" + + # The next test is that CVS will resurrect a committed removal to a + # branch. + dotest_sort resurrection-6 "$testcvs -r add file1" \ +"U file1 +$SPROG add: Re-adding file \`file1' on branch \`resurrection' after dead revision 1\.1\.2\.1\. +$SPROG add: Resurrecting file \`file1' from revision 1\.1\. +$SPROG add: use \`$SPROG commit' to add this file permanently" + # If the file is modified, it had better be read-write + # regardless of what the user has requested with the CVSREAD + # environment variable or the global -r switch + dotest resurrection-6b 'test -w file1' '' + dotest resurrection-7 "$testcvs -Q diff -r1.1 file1" "" + dotest resurrection-8 "$testcvs -q ci -mreadd" \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +new revision: 1\.1\.2\.2; previous revision: 1\.1\.2\.1" + + # The next few tests verify that an attempted resurrection of a file + # with no previous revision on the trunk fails. + touch file2 + dotest resurrection-9 "$testcvs -Q add file2" + dotest resurrection-10 "$testcvs -Q ci -mnew-file2" + dotest resurrection-11 "$testcvs -Q up -A" + + # This command once caused an assertion failure. + dotest resurrection-12 "$testcvs add file2" \ +"$SPROG add: File \`file2' has no previous revision to resurrect\." + + # Check what 'cvs -r add' does with resurrected files. + dotest resurrection-13 "$testcvs -Q rm -f file1" + dotest_sort resurrection-14 "$testcvs -r add file1" \ +"U file1 +$SPROG add: \`file1', version 1\.3, resurrected" + dotest_fail resurrection-15 'test -w file1' '' + + dokeep + cd ../.. + rm -rf 1 + modify_repo rm -rf $CVSROOT_DIRNAME/first-dir + ;; + + + + dirs) + # Tests related to removing and adding directories. + # See also: + # conflicts (especially dir1 in conflicts-130): What happens if + # directory exists in repository and a non-CVS-controlled + # directory in the working directory? + # conflicts3-15. More cases, especially where CVS directory + # exists but without CVS/Repository and friends. + # conflicts3-22. Similar to conflicts-130 but there is a file + # in the directory. + # dirs2. Sort of similar to conflicts3-22 but somewhat different. + mkdir imp-dir; cd imp-dir + echo file1 >file1 + mkdir sdir + echo sfile >sdir/sfile + dotest_sort dirs-1 \ +"${testcvs} import -m import-it dir1 vend rel" " + +N dir1/file1 +N dir1/sdir/sfile +No conflicts created by this import +${SPROG} import: Importing ${CVSROOT_DIRNAME}/dir1/sdir" + cd .. + + mkdir 1; cd 1 + dotest dirs-2 "$testcvs -Q co dir1" "" + + # Various CVS administrators are in the habit of removing + # the repository directory for things they don't want any + # more. I've even been known to do it myself (on rare + # occasions). Not the usual recommended practice, but we want + # to try to come up with some kind of reasonable/documented/sensible + # behavior. + modify_repo rm -rf $CVSROOT_DIRNAME/dir1/sdir + + dotest dirs-3 "${testcvs} update" \ +"${SPROG} update: Updating dir1 +${SPROG} update: Updating dir1/sdir +${SPROG} update: cannot open directory ${CVSROOT_DIRNAME}/dir1/sdir: No such file or directory +${SPROG} update: skipping directory dir1/sdir" + dotest dirs-3a "${testcvs} update -d" \ +"${SPROG} update: Updating dir1 +${SPROG} update: Updating dir1/sdir +${SPROG} update: cannot open directory ${CVSROOT_DIRNAME}/dir1/sdir: No such file or directory +${SPROG} update: skipping directory dir1/sdir" + + # If we say "yes", then CVS gives errors about not being able to + # create lock files. + # The fact that it says "skipping directory " rather than + # "skipping directory dir1/sdir" is some kind of bug. + dotest dirs-4 "echo no | ${testcvs} release -d dir1/sdir" \ +"${SPROG} update: cannot open directory ${CVSROOT_DIRNAME}/dir1/sdir: No such file or directory +${SPROG} update: skipping directory +You have \[0\] altered files in this repository\. +Are you sure you want to release (and delete) directory .dir1/sdir': .. .release' aborted by user choice." + + # OK, if "cvs release" won't help, we'll try it the other way... + rm -r dir1/sdir + + dotest dirs-5 "cat dir1/CVS/Entries" \ +"/file1/1.1.1.1/[a-zA-Z0-9 :]*// +D/sdir////" + dotest dirs-6 "${testcvs} update" "${SPROG} update: Updating dir1" + dotest dirs-7 "cat dir1/CVS/Entries" \ +"/file1/1.1.1.1/[a-zA-Z0-9 :]*// +D/sdir////" + dotest dirs-8 "${testcvs} update -d dir1" \ +"${SPROG} update: Updating dir1" + + dokeep + cd .. + rm -r imp-dir 1 + modify_repo rm -rf $CVSROOT_DIRNAME/dir1 + ;; + + + + dirs2) + # See "dirs" for a list of tests involving adding and + # removing directories. + mkdir 1; cd 1 + dotest dirs2-1 "$testcvs -q co -l ." + mkdir first-dir + dotest dirs2-2 "${testcvs} add first-dir" \ +"Directory ${CVSROOT_DIRNAME}/first-dir added to the repository" + cd first-dir + mkdir sdir + dotest dirs2-3 "${testcvs} add sdir" \ +"Directory ${CVSROOT_DIRNAME}/first-dir/sdir added to the repository" + touch sdir/file1 + dotest dirs2-4 "${testcvs} add sdir/file1" \ +"${SPROG} add: scheduling file .sdir/file1. for addition +${SPROG} add: use .${SPROG} commit. to add this file permanently" + dotest dirs2-5 "${testcvs} -q ci -m add" \ +"$CVSROOT_DIRNAME/first-dir/sdir/file1,v <-- sdir/file1 +initial revision: 1\.1" + rm -r sdir/CVS + if $remote; then + # This is just like conflicts3-23 + dotest_fail dirs2-6r "${testcvs} update -d" \ +"${QUESTION} sdir +${SPROG} update: Updating \. +${SPROG} update: Updating sdir +${CPROG} update: move away \`sdir/file1'; it is in the way +C sdir/file1" + rm sdir/file1 + rm -r sdir/CVS + + # This is where things are not just like conflicts3-23 + dotest dirs2-7r "${testcvs} update -d" \ +"${QUESTION} sdir +${SPROG} update: Updating \. +${SPROG} update: Updating sdir +U sdir/file1" + else + dotest dirs2-6 "${testcvs} update -d" \ +"${CPROG} update: Updating \. +${QUESTION} sdir" + rm sdir/file1 + dotest dirs2-7 "${testcvs} update -d" \ +"${CPROG} update: Updating \. +${QUESTION} sdir" + fi + cd ../.. + + # Now, the same thing (more or less) on a branch. + mkdir 2; cd 2 + dotest dirs2-8 "${testcvs} -q co first-dir" 'U first-dir/sdir/file1' + cd first-dir + dotest dirs2-9 "${testcvs} -q tag -b br" "T sdir/file1" + rm -r sdir/CVS + + if $remote; then + # val-tags used to have a cute little quirk; if an update didn't + # recurse into the directories where the tag is defined, val-tags + # wouldn't get updated. This is no longer a problem as of 1.12.10. + dotest_fail dirs2-10-againr "$testcvs update -d -r br" \ +"$QUESTION sdir +$SPROG update: Updating \. +$SPROG update: Updating sdir +$CPROG update: move away \`sdir/file1'; it is in the way +C sdir/file1" + else + dotest dirs2-10 "${testcvs} update -d -r br" \ +"$SPROG update: Updating \. +$QUESTION sdir" +# This is what used to happen. I'm not sure why it changed with 1.12.10, but +# as near as I can tell from the comments in update_direntproc, the new +# behavior was the intended behavior. +#"$CPROG update: in directory \`sdir': +#$CPROG \[update aborted\]: there is no version here; do \`$CPROG checkout' first" + fi + cd ../.. + + # OK, the above tests make the situation somewhat harder + # than it might be, in the sense that they actually have a + # file which is alive on the branch we are updating. Let's + # try it where it is just a directory where all the files + # have been removed. + mkdir 3; cd 3 + dotest dirs2-11 "${testcvs} -q co -r br first-dir" \ +"U first-dir/sdir/file1" + cd first-dir + # Hmm, this doesn't mention the branch like add does. That's + # an odd non-orthogonality. + dotest dirs2-12 "${testcvs} rm -f sdir/file1" \ +"${SPROG} remove: scheduling .sdir/file1. for removal +${SPROG} remove: use .${SPROG} commit. to remove this file permanently" + dotest dirs2-13 "${testcvs} -q ci -m remove" \ +"$CVSROOT_DIRNAME/first-dir/sdir/file1,v <-- sdir/file1 +new revision: delete; previous revision: 1\.1" + cd ../../2/first-dir + if $remote; then + dotest dirs2-14 "${testcvs} update -d -r br" \ +"${QUESTION} sdir/file1 +${SPROG} update: Updating \. +${SPROG} update: Updating sdir" + else + dotest dirs2-14 "${testcvs} update -d -r br" \ +"${CPROG} update: Updating \. +${QUESTION} sdir" + fi + + dokeep + cd ../.. + rm -r 1 2 3 + modify_repo rm -rf $CVSROOT_DIRNAME/first-dir + ;; + + + + branches) + # More branch tests, including branches off of branches + modify_repo mkdir $CVSROOT_DIRNAME/first-dir + dotest branches-1 "$testcvs -q co first-dir" + cd first-dir + echo 1:ancest >file1 + echo 2:ancest >file2 + echo 3:ancest >file3 + echo 4:trunk-1 >file4 + dotest branches-2 "${testcvs} add file1 file2 file3 file4" \ +"$SPROG add: scheduling file \`file1' for addition +$SPROG add: scheduling file \`file2' for addition +$SPROG add: scheduling file \`file3' for addition +$SPROG add: scheduling file \`file4' for addition +$SPROG add: use .$SPROG commit. to add these files permanently" + dotest branches-2a "$testcvs -n -q ci -m dont-commit" + dotest_lit branches-3 "$testcvs -q ci -m add-it" <<HERE +$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +initial revision: 1.1 +$CVSROOT_DIRNAME/first-dir/file2,v <-- file2 +initial revision: 1.1 +${CVSROOT_DIRNAME}/first-dir/file3,v <-- file3 +initial revision: 1.1 +${CVSROOT_DIRNAME}/first-dir/file4,v <-- file4 +initial revision: 1.1 +HERE + echo 4:trunk-2 >file4 + dotest branches-3.2 "${testcvs} -q ci -m trunk-before-branch" \ +"$CVSROOT_DIRNAME/first-dir/file4,v <-- file4 +new revision: 1\.2; previous revision: 1\.1" + # The "cvs log file4" in test branches-14.3 will test that we + # didn't really add the tag. + dotest branches-3.3 "${testcvs} -qn tag dont-tag" \ +"T file1 +T file2 +T file3 +T file4" + # Modify this file before branching, to deal with the case where + # someone is hacking along, says "oops, I should be doing this on + # a branch", and only then creates the branch. + echo 1:br1 >file1 + dotest branches-4 "${testcvs} tag -b br1" "${SPROG}"' tag: Tagging \. +T file1 +T file2 +T file3 +T file4' + dotest branches-5 "${testcvs} update -r br1" \ +"${SPROG} update: Updating \. +M file1" + echo 2:br1 >file2 + echo 4:br1 >file4 + dotest branches-6 "${testcvs} -q ci -m modify" \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +new revision: 1\.1\.2\.1; previous revision: 1\.1 +$CVSROOT_DIRNAME/first-dir/file2,v <-- file2 +new revision: 1\.1\.2\.1; previous revision: 1\.1 +$CVSROOT_DIRNAME/first-dir/file4,v <-- file4 +new revision: 1\.2\.2\.1; previous revision: 1\.2" + dotest branches-7 "${testcvs} -q tag -b brbr" 'T file1 +T file2 +T file3 +T file4' + dotest branches-8 "${testcvs} -q update -r brbr" '' + echo 1:brbr >file1 + echo 4:brbr >file4 + dotest branches-9 "${testcvs} -q ci -m modify" \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +new revision: 1\.1\.2\.1\.2\.1; previous revision: 1\.1\.2\.1 +$CVSROOT_DIRNAME/first-dir/file4,v <-- file4 +new revision: 1\.2\.2\.1\.2\.1; previous revision: 1\.2\.2\.1" + dotest branches-10 "cat file1 file2 file3 file4" '1:brbr +2:br1 +3:ancest +4:brbr' + dotest branches-11 "${testcvs} -q update -r br1" \ +'[UP] file1 +[UP] file4' + dotest branches-12 "cat file1 file2 file3 file4" '1:br1 +2:br1 +3:ancest +4:br1' + echo 4:br1-2 >file4 + dotest branches-12.2 "${testcvs} -q ci -m change-on-br1" \ +"$CVSROOT_DIRNAME/first-dir/file4,v <-- file4 +new revision: 1\.2\.2\.2; previous revision: 1\.2\.2\.1" + dotest branches-13 "${testcvs} -q update -A" '[UP] file1 +[UP] file2 +[UP] file4' + dotest branches-14 "cat file1 file2 file3 file4" '1:ancest +2:ancest +3:ancest +4:trunk-2' + echo 4:trunk-3 >file4 + dotest branches-14.2 \ + "${testcvs} -q ci -m trunk-change-after-branch" \ +"$CVSROOT_DIRNAME/first-dir/file4,v <-- file4 +new revision: 1\.3; previous revision: 1\.2" + dotest branches-14.3 "${testcvs} log file4" \ +" +RCS file: ${CVSROOT_DIRNAME}/first-dir/file4,v +Working file: file4 +head: 1\.3 +branch: +locks: strict +access list: +symbolic names: + brbr: 1\.2\.2\.1\.0\.2 + br1: 1\.2\.0\.2 +keyword substitution: kv +total revisions: 6; selected revisions: 6 +description: +---------------------------- +revision 1\.3 +date: ${ISO8601DATE}; author: ${username}; state: Exp; lines: ${PLUS}1 -1; commitid: ${commitid}; +trunk-change-after-branch +---------------------------- +revision 1\.2 +date: ${ISO8601DATE}; author: ${username}; state: Exp; lines: ${PLUS}1 -1; commitid: ${commitid}; +branches: 1\.2\.2; +trunk-before-branch +---------------------------- +revision 1\.1 +date: ${ISO8601DATE}; author: ${username}; state: Exp; commitid: ${commitid}; +add-it +---------------------------- +revision 1\.2\.2\.2 +date: ${ISO8601DATE}; author: ${username}; state: Exp; lines: ${PLUS}1 -1; commitid: ${commitid}; +change-on-br1 +---------------------------- +revision 1\.2\.2\.1 +date: ${ISO8601DATE}; author: ${username}; state: Exp; lines: ${PLUS}1 -1; commitid: ${commitid}; +branches: 1\.2\.2\.1\.2; +modify +---------------------------- +revision 1\.2\.2\.1\.2\.1 +date: ${ISO8601DATE}; author: ${username}; state: Exp; lines: ${PLUS}1 -1; commitid: ${commitid}; +modify +=============================================================================" + dotest_fail branches-14.4 \ + "${testcvs} diff -c -r 1.1 -r 1.3 file4" \ +"Index: file4 +=================================================================== +RCS file: ${CVSROOT_DIRNAME}/first-dir/file4,v +retrieving revision 1\.1 +retrieving revision 1\.3 +diff -c -r1\.1 -r1\.3 +\*\*\* file4 ${RFCDATE} 1\.1 +--- file4 ${RFCDATE} 1\.3 +\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* +\*\*\* 1 \*\*\*\* +! 4:trunk-1 +--- 1 ---- +! 4:trunk-3" + dotest_fail branches-14.5 \ + "${testcvs} diff -c -r 1.1 -r 1.2.2.1 file4" \ +"Index: file4 +=================================================================== +RCS file: ${CVSROOT_DIRNAME}/first-dir/file4,v +retrieving revision 1\.1 +retrieving revision 1\.2\.2\.1 +diff -c -r1\.1 -r1\.2\.2\.1 +\*\*\* file4 ${RFCDATE} 1\.1 +--- file4 ${RFCDATE} 1\.2\.2\.1 +\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* +\*\*\* 1 \*\*\*\* +! 4:trunk-1 +--- 1 ---- +! 4:br1" + dotest branches-15 \ + "${testcvs} update -j 1.1.2.1 -j 1.1.2.1.2.1 file1" \ + "RCS file: ${CVSROOT_DIRNAME}/first-dir/file1,v +retrieving revision 1\.1\.2\.1 +retrieving revision 1\.1\.2\.1\.2\.1 +Merging differences between 1\.1\.2\.1 and 1\.1\.2\.1\.2\.1 into file1 +rcsmerge: warning: conflicts during merge" + dotest branches-16 "cat file1" '<<<<<<< file1 +1:ancest +[=]====== +1:brbr +[>]>>>>>> 1\.1\.2\.1\.2\.1' + + dotest branches-o1 "${testcvs} -q admin -o ::brbr" \ +"RCS file: ${CVSROOT_DIRNAME}/first-dir/file1,v +done +RCS file: ${CVSROOT_DIRNAME}/first-dir/file2,v +done +RCS file: ${CVSROOT_DIRNAME}/first-dir/file3,v +done +RCS file: ${CVSROOT_DIRNAME}/first-dir/file4,v +done" + + dokeep + cd .. + modify_repo rm -rf $CVSROOT_DIRNAME/first-dir + rm -r first-dir + ;; + + + + branches2) + # More branch tests. + # Test that when updating a new subdirectory in a directory + # which was checked out on a branch, the new subdirectory is + # created on the appropriate branch. Test this when joining + # as well. + + modify_repo mkdir $CVSROOT_DIRNAME/first-dir + mkdir trunk; cd trunk + + # Create a file. + dotest branches2-1 "${testcvs} -q co first-dir" + cd first-dir + echo "file1 first revision" > file1 + dotest branches2-2 "${testcvs} add file1" \ +"${SPROG} add: scheduling file .file1. for addition +${SPROG} add: use .${SPROG} commit. to add this file permanently" + dotest branches2-3 "${testcvs} commit -m add file1" \ +"${CVSROOT_DIRNAME}/first-dir/file1,v <-- file1 +initial revision: 1\.1" + + # Tag the file. + dotest branches2-4 "${testcvs} -q tag tag1" 'T file1' + + # Make two branches. + dotest branches2-5 "${testcvs} -q rtag -b -r tag1 b1 first-dir" '' + dotest branches2-6 "${testcvs} -q rtag -b -r tag1 b2 first-dir" '' + + # Create some files and a subdirectory on branch b1. + cd ../.. + mkdir b1; cd b1 + dotest branches2-7 "${testcvs} -q co -r b1 first-dir" \ +"U first-dir/file1" + cd first-dir + echo "file2 first revision" > file2 + dotest branches2-8 "${testcvs} add file2" \ +"${SPROG}"' add: scheduling file `file2'\'' for addition on branch `b1'\'' +'"${SPROG}"' add: use .'"${SPROG}"' commit. to add this file permanently' + mkdir dir1 + dotest branches2-9 "${testcvs} add dir1" \ +"Directory ${CVSROOT_DIRNAME}/first-dir/dir1 added to the repository +--> Using per-directory sticky tag "'`'"b1'" + echo "file3 first revision" > dir1/file3 + dotest branches2-10 "${testcvs} add dir1/file3" \ +"${SPROG}"' add: scheduling file `dir1/file3'\'' for addition on branch `b1'\'' +'"${SPROG}"' add: use .'"${SPROG}"' commit. to add this file permanently' + dotest branches2-11 "${testcvs} -q ci -madd ." \ +"$CVSROOT_DIRNAME/first-dir/Attic/file2,v <-- file2 +new revision: 1\.1\.2\.1; previous revision: 1\.1 +$CVSROOT_DIRNAME/first-dir/dir1/Attic/file3,v <-- dir1/file3 +new revision: 1\.1\.2\.1; previous revision: 1\.1" + + # Check out the second branch, and update the working + # directory to the first branch, to make sure the right + # happens with dir1. + cd ../.. + mkdir b2; cd b2 + dotest branches2-12 "${testcvs} -q co -r b2 first-dir" \ +'U first-dir/file1' + cd first-dir + dotest branches2-13 "${testcvs} update -d -r b1 dir1" \ +"${SPROG} update: Updating dir1 +U dir1/file3" + dotest branches2-14 "${testcvs} -q status" \ +"=================================================================== +File: file1 Status: Up-to-date + + Working revision: 1\.1.* + Repository revision: 1\.1 ${CVSROOT_DIRNAME}/first-dir/file1,v + Commit Identifier: ${commitid} + Sticky Tag: b2 (branch: 1\.1\.4) + Sticky Date: (none) + Sticky Options: (none) + +=================================================================== +File: file3 Status: Up-to-date + + Working revision: 1\.1\.2\.1.* + Repository revision: 1\.1\.2\.1 ${CVSROOT_DIRNAME}/first-dir/dir1/Attic/file3,v + Commit Identifier: ${commitid} + Sticky Tag: b1 (branch: 1\.1\.2) + Sticky Date: (none) + Sticky Options: (none)" + + # Test some calls to rls here because we can. These should probably + # be somewhere else, but we already have some directories set up. + dotest branches2-14-rls-1 "$testcvs rls" \ +"$SPROG rls: Listing module: \`.' +CVSROOT +first-dir" + dotest branches2-14-rls-2 "$testcvs rls -R" \ +"$SPROG rls: Listing module: \`.' +\.: +CVSROOT +first-dir + +CVSROOT: +checkoutlist +commitinfo +config +cvswrappers +loginfo +modules +notify +postadmin +postproxy +posttag +postwatch +preproxy +rcsinfo +taginfo +verifymsg +Emptydir + +CVSROOT/Emptydir: + +first-dir: +file1 +dir1 + +first-dir/dir1:" + dotest branches2-14-rls-3 "$testcvs rls -l -R" \ +"$SPROG rls: Listing module: \`.' +\.: +d--- $ISO8601DATE CVSROOT +d--- $ISO8601DATE first-dir + +CVSROOT: +---- $ISO8601DATE 1\.[0-9][0-9]* checkoutlist +---- $ISO8601DATE 1\.[0-9][0-9]* commitinfo +---- $ISO8601DATE 1\.[0-9][0-9]* config +---- $ISO8601DATE 1\.[0-9][0-9]* cvswrappers +---- $ISO8601DATE 1\.[0-9][0-9]* loginfo +---- $ISO8601DATE 1\.[0-9][0-9]* modules +---- $ISO8601DATE 1\.[0-9][0-9]* notify +---- $ISO8601DATE 1\.[0-9][0-9]* postadmin +---- $ISO8601DATE 1\.[0-9][0-9]* postproxy +---- $ISO8601DATE 1\.[0-9][0-9]* posttag +---- $ISO8601DATE 1\.[0-9][0-9]* postwatch +---- $ISO8601DATE 1\.[0-9][0-9]* preproxy +---- $ISO8601DATE 1\.[0-9][0-9]* rcsinfo +---- $ISO8601DATE 1\.[0-9][0-9]* taginfo +---- $ISO8601DATE 1\.[0-9][0-9]* verifymsg +d--- $ISO8601DATE Emptydir + +CVSROOT/Emptydir: + +first-dir: +---- $ISO8601DATE 1\.1 file1 +d--- $ISO8601DATE dir1 + +first-dir/dir1:" + dotest branches2-14-rls-4 "$testcvs rls -eR" \ +"$SPROG rls: Listing module: \`.' +\.: +D/CVSROOT//// +D/first-dir//// + +CVSROOT: +/checkoutlist/1\.[0-9][0-9]*/$DATE// +/commitinfo/1\.[0-9][0-9]*/$DATE// +/config/1\.[0-9][0-9]*/$DATE// +/cvswrappers/1\.[0-9][0-9]*/$DATE// +/loginfo/1\.[0-9][0-9]*/$DATE// +/modules/1\.[0-9][0-9]*/$DATE// +/notify/1\.[0-9][0-9]*/$DATE// +/postadmin/1\.[0-9][0-9]*/$DATE// +/postproxy/1\.[0-9][0-9]*/$DATE// +/posttag/1\.[0-9][0-9]*/$DATE// +/postwatch/1\.[0-9][0-9]*/$DATE// +/preproxy/1\.[0-9][0-9]*/$DATE// +/rcsinfo/1\.[0-9][0-9]*/$DATE// +/taginfo/1\.[0-9][0-9]*/$DATE// +/verifymsg/1\.[0-9][0-9]*/$DATE// +D/Emptydir//// + +CVSROOT/Emptydir: + +first-dir: +/file1/1\.1/$DATE// +D/dir1//// + +first-dir/dir1:" + dotest branches2-14-rls-5 "$testcvs -q rls -R" \ +"\.: +CVSROOT +first-dir + +CVSROOT: +checkoutlist +commitinfo +config +cvswrappers +loginfo +modules +notify +postadmin +postproxy +posttag +postwatch +preproxy +rcsinfo +taginfo +verifymsg +Emptydir + +CVSROOT/Emptydir: + +first-dir: +file1 +dir1 + +first-dir/dir1:" + dotest branches2-14-rls-6 "$testcvs -q rls -lRrb1" \ +"\.: +d--- $ISO8601DATE CVSROOT +d--- $ISO8601DATE first-dir + +CVSROOT: +d--- $ISO8601DATE Emptydir + +CVSROOT/Emptydir: + +first-dir: +---- $ISO8601DATE 1\.1 file1 +---- $ISO8601DATE 1\.1\.2\.1 file2 +d--- $ISO8601DATE dir1 + +first-dir/dir1: +---- $ISO8601DATE 1\.1\.2\.1 file3" + dotest branches2-14-rls-7 "$testcvs -q rls -lRrb2" \ +"\.: +d--- $ISO8601DATE CVSROOT +d--- $ISO8601DATE first-dir + +CVSROOT: +d--- $ISO8601DATE Emptydir + +CVSROOT/Emptydir: + +first-dir: +---- $ISO8601DATE 1\.1 file1 +d--- $ISO8601DATE dir1 + +first-dir/dir1:" + + # Now some calls to ls. These are more appropriate here. + dotest branches2-14-ls-1 "$testcvs ls" \ +"file1 +dir1" + dotest branches2-14-ls-2 "$testcvs ls -e" \ +"/file1/1\.1/$DATE// +D/dir1////" + dotest branches2-14-ls-3 "$testcvs ls -R" \ +"\.: +file1 +dir1 + +dir1: +file3" + dotest branches2-14-ls-4 "$testcvs ls -eRrHEAD" \ +"\.: +/file1/1\.1/$DATE//THEAD +D/dir1//// + +dir1:" + dotest branches2-14-ls-5 "$testcvs ls -eRrb1" \ +"\.: +/file1/1\.1/$DATE//Tb1 +/file2/1\.1\.2\.1/$DATE//Tb1 +D/dir1//// + +dir1: +/file3/1\.1\.2\.1/$DATE//Tb1" + dotest branches2-14-ls-6 "$testcvs ls -eRrb2" \ +"\.: +/file1/1.1/$DATE//Tb2 +D/dir1//// + +dir1:" + # Nonexistant tags used to cause assertion failures. + dotest_fail branches2-14-ls-7 "$testcvs ls -eRrnosuchtag" \ +"$SPROG \[ls aborted\]: no such tag \`nosuchtag'" + + # FIXME: Just clobbering the directory like this is a bit + # tacky, although people generally expect it to work. Maybe + # we should release it instead. We do it a few other places + # below as well. + rm -r dir1 + dotest branches2-15 "${testcvs} update -d -j b1 dir1" \ +"${SPROG} update: Updating dir1 +U dir1/file3" + # FIXCVS: The `No revision control file' stuff seems to be + # CVS's way of telling us that we're adding the file on a + # branch, and the file is not on that branch yet. This + # should be nicer. + dotest branches2-16 "${testcvs} -q status" \ +"=================================================================== +File: file1 Status: Up-to-date + + Working revision: 1\.1.* + Repository revision: 1\.1 ${CVSROOT_DIRNAME}/first-dir/file1,v + Commit Identifier: ${commitid} + Sticky Tag: b2 (branch: 1\.1\.4) + Sticky Date: (none) + Sticky Options: (none) + +=================================================================== +File: file3 Status: Locally Added + + Working revision: New file! + Repository revision: No revision control file + Sticky Tag: b2 - MISSING from RCS file! + Sticky Date: (none) + Sticky Options: (none)" + + cd ../../trunk/first-dir + dotest branches2-17 "${testcvs} update -d -P dir1" \ +"${SPROG} update: Updating dir1" + dotest_fail branches2-18 "test -d dir1" + dotest branches2-19 "${testcvs} update -d -P -r b1 dir1" \ +"${SPROG} update: Updating dir1 +U dir1/file3" + dotest branches2-20 "${testcvs} -q status" \ +"=================================================================== +File: file1 Status: Up-to-date + + Working revision: 1\.1.* + Repository revision: 1\.1 ${CVSROOT_DIRNAME}/first-dir/file1,v + Commit Identifier: ${commitid} + Sticky Tag: (none) + Sticky Date: (none) + Sticky Options: (none) + +=================================================================== +File: file3 Status: Up-to-date + + Working revision: 1\.1\.2\.1.* + Repository revision: 1\.1\.2\.1 ${CVSROOT_DIRNAME}/first-dir/dir1/Attic/file3,v + Commit Identifier: ${commitid} + Sticky Tag: b1 (branch: 1\.1\.2) + Sticky Date: (none) + Sticky Options: (none)" + + rm -r dir1 + dotest branches2-21 "${testcvs} update -d -P -j b1 dir1" \ +"${SPROG} update: Updating dir1 +U dir1/file3" + dotest branches2-22 "${testcvs} -q status" \ +"=================================================================== +File: file1 Status: Up-to-date + + Working revision: 1\.1.* + Repository revision: 1\.1 ${CVSROOT_DIRNAME}/first-dir/file1,v + Commit Identifier: ${commitid} + Sticky Tag: (none) + Sticky Date: (none) + Sticky Options: (none) + +=================================================================== +File: file3 Status: Locally Added + + Working revision: New file! + Repository revision: 1\.1 ${CVSROOT_DIRNAME}/first-dir/dir1/Attic/file3,v + Commit Identifier: ${commitid} + Sticky Tag: (none) + Sticky Date: (none) + Sticky Options: (none)" + + cd ../.. + rm -r b1 b2 + + # Check out branch b1 twice. Crate a new directory in one + # working directory, then do a cvs update in the other + # working directory and see if the tags are right. + mkdir b1a + mkdir b1b + cd b1b + dotest branches2-23 "${testcvs} -q co -r b1 first-dir" \ +'U first-dir/file1 +U first-dir/file2 +U first-dir/dir1/file3' + cd ../b1a + dotest branches2-24 "${testcvs} -q co -r b1 first-dir" \ +'U first-dir/file1 +U first-dir/file2 +U first-dir/dir1/file3' + cd first-dir + mkdir dir2 + dotest branches2-25 "${testcvs} add dir2" \ +"Directory ${CVSROOT_DIRNAME}/first-dir/dir2 added to the repository +--> Using per-directory sticky tag "'`'"b1'" + echo "file4 first revision" > dir2/file4 + dotest branches2-26 "${testcvs} add dir2/file4" \ +"${SPROG}"' add: scheduling file `dir2/file4'\'' for addition on branch `b1'\'' +'"${SPROG}"' add: use .'"${SPROG}"' commit. to add this file permanently' + dotest branches2-27 "${testcvs} -q commit -madd" \ +"$CVSROOT_DIRNAME/first-dir/dir2/Attic/file4,v <-- dir2/file4 +new revision: 1\.1\.2\.1; previous revision: 1\.1" + + cd ../../b1b/first-dir + dotest branches2-28 "${testcvs} update -d dir2" \ +"${SPROG} update: Updating dir2 +U dir2/file4" + cd dir2 + dotest branches2-29 "${testcvs} -q status" \ +"=================================================================== +File: file4 Status: Up-to-date + + Working revision: 1\.1\.2\.1.* + Repository revision: 1\.1\.2\.1 ${CVSROOT_DIRNAME}/first-dir/dir2/Attic/file4,v + Commit Identifier: ${commitid} + Sticky Tag: b1 (branch: 1\.1\.2) + Sticky Date: (none) + Sticky Options: (none)" + dotest branches2-30 "cat CVS/Tag" 'Tb1' + + # Test update -A on a subdirectory + cd .. + rm -r dir2 + dotest branches2-31 "${testcvs} update -A -d dir2" \ +"${SPROG} update: Updating dir2" + cd dir2 + dotest branches2-32 "${testcvs} -q status" '' + dotest_fail branches2-33 "test -f CVS/Tag" + + # Add a file on the trunk. + echo "file5 first revision" > file5 + dotest branches2-34 "${testcvs} add file5" \ +"${SPROG}"' add: scheduling file `file5'\'' for addition +'"${SPROG}"' add: use .'"${SPROG}"' commit. to add this file permanently' + dotest branches2-35 "${testcvs} -q commit -madd" \ +"$CVSROOT_DIRNAME/first-dir/dir2/file5,v <-- file5 +initial revision: 1\.1" + + cd ../../../trunk/first-dir + dotest branches2-36 "${testcvs} -q update -d dir2" 'U dir2/file5' + cd dir2 + dotest branches2-37 "${testcvs} -q status" \ +"=================================================================== +File: file5 Status: Up-to-date + + Working revision: 1\.1.* + Repository revision: 1\.1 ${CVSROOT_DIRNAME}/first-dir/dir2/file5,v + Commit Identifier: ${commitid} + Sticky Tag: (none) + Sticky Date: (none) + Sticky Options: (none)" + dotest_fail branches2-38 "test -f CVS/status" + + dotest branches2-39 "$testcvs rls -rb1 -l -R first-dir" \ +"$SPROG rls: Listing module: \`first-dir' +first-dir: +---- $ISO8601DATE 1\.1 file1 +---- $ISO8601DATE 1\.1\.2\.1 file2 +d--- $ISO8601DATE dir1 +d--- $ISO8601DATE dir2 + +first-dir/dir1: +---- $ISO8601DATE 1\.1\.2\.1 file3 + +first-dir/dir2: +---- $ISO8601DATE 1\.1\.2\.1 file4" + + dokeep + cd ../../.. + modify_repo rm -rf $CVSROOT_DIRNAME/first-dir + rm -r trunk b1a b1b + ;; + + + + branches3) + # test local branch number support + + # This test is skipped in $remotehost mode since the + # CVS_LOCAL_BRANCH_NUM is not inherited by the server process as it + # is with :fork:, for hopefully obvious reasons. + # + # FIXCVS? Is this correct? Should CVS_LOCAL_BRANCH_NUM be sent as + # a protocol extension or is it reasonable to only want this set on + # the server? + + if test -n "$remotehost"; then :;else + modify_repo mkdir $CVSROOT_DIRNAME/first-dir + mkdir branches3; cd branches3 + + dotest branches3-1 "$testcvs -q co first-dir" + cd first-dir + echo "file1 first revision" > file1 + dotest branches3-2 "${testcvs} add file1" \ +"${SPROG} add: scheduling file .file1. for addition +${SPROG} add: use .${SPROG} commit. to add this file permanently" + dotest branches3-3 "${testcvs} commit -m add file1" \ +"${CVSROOT_DIRNAME}/first-dir/file1,v <-- file1 +initial revision: 1\.1" + + # Tag the file using a CVS_LOCAL_BRANCH_NUM of 1000 + CVS_LOCAL_BRANCH_NUM=1000; export CVS_LOCAL_BRANCH_NUM + dotest branches3-4 "${testcvs} -q tag -b tag1" 'T file1' + unset CVS_LOCAL_BRANCH_NUM + dotest branches3-5 "${testcvs} -q log file1" \ +" +RCS file: ${CVSROOT_DIRNAME}/first-dir/file1,v +Working file: file1 +head: 1\.1 +branch: +locks: strict +access list: +symbolic names: + tag1: 1\.1\.0\.1000 +keyword substitution: kv +total revisions: 1; selected revisions: 1 +description: +---------------------------- +revision 1.1 +date: ${ISO8601DATE}; author: ${username}; state: Exp; commitid: ${commitid}; +add +=============================================================================" + + dokeep + cd ../.. + modify_repo rm -rf $CVSROOT_DIRNAME/first-dir + rm -r branches3 + fi # !$remotehost + ;; + + + + branches4) + # test where a tag is a branch tag in some files and a revision + # tag in others + + modify_repo mkdir $CVSROOT_DIRNAME/first-dir + mkdir branches4; cd branches4 + + dotest branches4-1 "$testcvs -q co first-dir" + cd first-dir + mkdir branches mixed mixed2 versions + dotest branches4-2 "${testcvs} -q add branches mixed mixed2 versions" \ +"Directory ${CVSROOT_DIRNAME}/first-dir/branches added to the repository +Directory ${CVSROOT_DIRNAME}/first-dir/mixed added to the repository +Directory ${CVSROOT_DIRNAME}/first-dir/mixed2 added to the repository +Directory ${CVSROOT_DIRNAME}/first-dir/versions added to the repository" + + echo file1 >branches/file1 + echo file2 >branches/file2 + echo file3 >branches/file3 + echo file4 >branches/file4 + cp branches/file* mixed + cp branches/file* mixed2 + cp branches/file* versions + + dotest branches4-3 "${testcvs} -q add */file*" \ +"${SPROG} add: use .${SPROG} commit. to add these files permanently" + dotest branches4-3a "${testcvs} -Q ci -m." + + dotest branches4-4 "${testcvs} -q tag xxx versions/file* mixed*/file1 mixed*/file3" \ +"T versions/file1 +T versions/file2 +T versions/file3 +T versions/file4 +T mixed/file1 +T mixed/file3 +T mixed2/file1 +T mixed2/file3" + + dotest branches4-5 "${testcvs} -q tag -b xxx branches/file* mixed*/file2 mixed*/file4" \ +"T branches/file1 +T branches/file2 +T branches/file3 +T branches/file4 +T mixed/file2 +T mixed/file4 +T mixed2/file2 +T mixed2/file4" + + # make sure we get the appropriate warnings when updating + dotest branches4-6 "${testcvs} update -r xxx" \ +"${SPROG} update: Updating \. +${SPROG} update: Updating branches +${SPROG} update: Updating mixed +${SPROG} update: warning: xxx is a branch tag in some files and a revision tag in others\. +${SPROG} update: Updating mixed2 +${SPROG} update: warning: xxx is a branch tag in some files and a revision tag in others\. +${SPROG} update: Updating versions" + + # make sure we don't get warned in quiet modes + dotest branches4-7 "${testcvs} -q update -A" + dotest branches4-8 "${testcvs} -q update -r xxx" + dotest branches4-9 "${testcvs} -q update -A" + dotest branches4-10 "${testcvs} -Q update -r xxx" + + # make sure the Tag files are correct + dotest branches4-11 "cat branches/CVS/Tag" "Txxx" + dotest branches4-12 "cat mixed/CVS/Tag" "Nxxx" + dotest branches4-13 "cat mixed2/CVS/Tag" "Nxxx" + dotest branches4-14 "cat versions/CVS/Tag" "Nxxx" + + # We only warn if there's mixed usage in a single directory. + # We may want to consider changing that in the future. + dotest branches4-15 "${testcvs} update -r xxx branches versions" \ +"${SPROG} update: Updating branches +${SPROG} update: Updating versions" + + dokeep + cd ../.. + modify_repo rm -rf $CVSROOT_DIRNAME/first-dir + rm -r branches4 + ;; + + + + tagc) + # Test the tag -c option. + mkdir 1; cd 1 + dotest tagc-1 "${testcvs} -q co -l ." '' + mkdir first-dir + dotest tagc-2 "${testcvs} add first-dir" \ +"Directory ${CVSROOT_DIRNAME}/first-dir added to the repository" + cd first-dir + touch file1 file2 + dotest tagc-3 "${testcvs} add file1 file2" \ +"${SPROG} add: scheduling file .file1. for addition +${SPROG} add: scheduling file .file2. for addition +${SPROG} add: use .${SPROG} commit. to add these files permanently" + dotest tagc-4 "${testcvs} -q ci -m add" \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +initial revision: 1\.1 +$CVSROOT_DIRNAME/first-dir/file2,v <-- file2 +initial revision: 1\.1" + dotest tagc-5 "${testcvs} -q tag -c tag1" \ +"T file1 +T file2" + touch file1 file2 + dotest tagc-6 "${testcvs} -q tag -c tag2" \ +"T file1 +T file2" + # Avoid timestamp granularity bugs (FIXME: CVS should be + # doing the sleep, right?). + sleep 1 + echo myedit >>file1 + dotest tagc-6a "${testcvs} rm -f file2" \ +"${SPROG} remove: scheduling .file2. for removal +${SPROG} remove: use .${SPROG} commit. to remove this file permanently" + touch file3 + dotest tagc-6b "${testcvs} add file3" \ +"${SPROG} add: scheduling file .file3. for addition +${SPROG} add: use .${SPROG} commit. to add this file permanently" + dotest_fail tagc-7 "${testcvs} -q tag -c tag3" \ +"${SPROG} tag: file1 is locally modified +${SPROG} tag: file2 is locally modified +${SPROG} tag: file3 is locally modified +${SPROG} \[tag aborted\]: correct the above errors first!" + cd ../.. + mkdir 2 + cd 2 + dotest tagc-8 "${testcvs} -q co first-dir" \ +"U first-dir/file1 +U first-dir/file2" + cd ../1/first-dir + dotest tagc-9 "${testcvs} -q ci -m modify" \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +new revision: 1\.2; previous revision: 1\.1 +$CVSROOT_DIRNAME/first-dir/file2,v <-- file2 +new revision: delete; previous revision: 1\.1 +$CVSROOT_DIRNAME/first-dir/file3,v <-- file3 +initial revision: 1\.1" + cd ../../2/first-dir + dotest tagc-10 "${testcvs} -q tag -c tag4" \ +"${SPROG} tag: \`file2' is no longer in the repository +T file1 +T file2" + + dokeep + cd ../.. + rm -r 1 2 + modify_repo rm -rf $CVSROOT_DIRNAME/first-dir + ;; + + + + update-p) + # Make sure `cvs update -p -rT FILE' works from a branch when + # FILE is already on the trunk and is being added to that branch. + + mkdir 1; cd 1 + module=x + + echo > unused-file + + # Create the module. + dotest update-p-1 \ + "$testcvs -Q import -m. $module X Y" '' + + file=F + # Check it out and tag it. + dotest update-p-2 "$testcvs -Q co $module" '' + cd $module + dotest update-p-3 "$testcvs -Q tag -b B" '' + echo v1 > $file + dotest update-p-4 "$testcvs -Q add $file" '' + dotest update-p-5 "$testcvs -Q ci -m. $file" + dotest update-p-6 "$testcvs -Q tag T $file" '' + dotest update-p-7 "$testcvs -Q update -rB" '' + + # This merge effectively adds file F on branch B. + dotest update-p-8 "$testcvs -Q update -jT" '' + + # Before the fix that prompted the addition of this test, + # the following command would fail with this diagnostic: + # cvs update: conflict: F created independently by second party + dotest update-p-9 "$testcvs update -p -rT $file" \ +"=================================================================== +Checking out $file +RCS: ${CVSROOT_DIRNAME}/$module/$file,v +VERS: 1\.1 +\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* +v1" + + # Repeat the above, but with $file removed. + # This exercises a slightly different code path. + rm $file + # Before the fix that prompted the addition of this test, + # the following command would fail with this diagnostic: + # cvs update: warning: new-born \`F' has disappeared + dotest update-p-10 "$testcvs update -p -rT $file" \ +"=================================================================== +Checking out $file +RCS: ${CVSROOT_DIRNAME}/$module/$file,v +VERS: 1\.1 +\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* +v1" + + # Exercise yet another code path: + # the one that involves reviving a `dead' file. + # And a little more, for good measure... + touch new + dotest update-p-a1 "$testcvs -Q add new" '' + dotest update-p-a2 "$testcvs -Q update -p new" '' + dotest update-p-a3 "$testcvs -Q rm -f new" '' + + # Both an update -A, *and* the following update are required + # to return to the state of being on the trunk with a $file + # that we can then remove. + dotest update-p-undead-0 "$testcvs update -A" \ +"${SPROG} update: Updating \. +${SPROG} update: warning: new-born \`$file' has disappeared" + dotest update-p-undead-1 "$testcvs update" \ +"${SPROG} update: Updating \. +U $file" + dotest update-p-undead-2 "$testcvs -Q update -p -rT $file" v1 + dotest update-p-undead-3 "$testcvs -Q rm -f $file" '' + dotest update-p-undead-4 "$testcvs -Q update -p -rT $file" v1 + dotest update-p-undead-5 "$testcvs -Q ci -m. $file" + dotest update-p-undead-6 "$testcvs -Q update -p -rT $file" v1 + echo v2 > $file + dotest update-p-undead-7 "$testcvs -Q update -p -rT $file" v1 + dotest update-p-undead-8 "$testcvs add $file" \ +"$SPROG add: Re-adding file .$file. after dead revision 1\.2\. +$SPROG add: use \`$SPROG commit' to add this file permanently" + + dotest update-p-undead-9 "$testcvs -Q update -p -rT $file" v1 + + dokeep + cd ../.. + rm -rf 1 + modify_repo rm -rf $CVSROOT_DIRNAME/$module + ;; + + + + tagf) + # More tagging tests, including using tag -F -B to convert a + # branch tag to a regular tag and recovering thereof. + + # Setup; check in first-dir/file1 + mkdir 1; cd 1 + dotest tagf-1 "${testcvs} -q co -l ." '' + mkdir first-dir + dotest tagf-2 "${testcvs} add first-dir" \ +"Directory ${CVSROOT_DIRNAME}/first-dir added to the repository" + cd first-dir + touch file1 file2 + dotest tagf-3 "${testcvs} add file1 file2" \ +"${SPROG} add: scheduling file .file1. for addition +${SPROG} add: scheduling file .file2. for addition +${SPROG} add: use .${SPROG} commit. to add these files permanently" + dotest tagf-4 "${testcvs} -q ci -m add" \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +initial revision: 1\.1 +$CVSROOT_DIRNAME/first-dir/file2,v <-- file2 +initial revision: 1\.1" + + # Now create a branch and commit a revision there. + dotest tagf-5 "${testcvs} -q tag -b br" "T file1 +T file2" + dotest tagf-6 "${testcvs} -q update -r br" "" + echo brmod >> file1 + echo brmod >> file2 + dotest tagf-7 "${testcvs} -q ci -m modify" \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +new revision: 1\.1\.2\.1; previous revision: 1\.1 +$CVSROOT_DIRNAME/first-dir/file2,v <-- file2 +new revision: 1\.1\.2\.1; previous revision: 1\.1" + # Here we try to make it a non-branch tag, but will + # succeed in getting only warnings, even with -F + # because converting a branch tag to non-branch + # is potentially catastrophic. + dotest tagf-8a "${testcvs} -q tag -F br" \ +"${SPROG} tag: file1: Not moving branch tag .br. from 1\.1\.2\.1 to 1\.1\\.2\.1\. +${SPROG} tag: file2: Not moving branch tag .br. from 1\.1\.2\.1 to 1\.1\.2\.1\." + # however, if we *really* are sure we want to move a branch tag, + # "-F -B" will do the trick + dotest tagf-8 "${testcvs} -q tag -F -B br" "T file1 +T file2" + echo moremod >> file1 + echo moremod >> file2 + dotest tagf-9 "${testcvs} -q status -v file1" \ +"=================================================================== +File: file1 Status: Locally Modified + + Working revision: 1\.1\.2\.1.* + Repository revision: 1\.1\.2\.1 ${CVSROOT_DIRNAME}/first-dir/file1,v + Commit Identifier: ${commitid} + Sticky Tag: br (revision: 1\.1\.2\.1) + Sticky Date: (none) + Sticky Options: (none) + + Existing Tags: + br (revision: 1\.1\.2\.1)" + + # Now, how do we recover? + dotest tagf-10 "${testcvs} -q tag -d br" "D file1 +D file2" + # This creates a new branch, 1.1.4. See the code in RCS_magicrev + # which will notice that there is a (non-magic) 1.1.2 and thus + # skip that number. + dotest tagf-11 "${testcvs} -q tag -r 1.1 -b br file1" "T file1" + # Fix it with admin -n (cf admin-18, admin-26-4). + dotest tagf-12 "${testcvs} -q admin -nbr:1.1.2 file2" \ +"RCS file: ${CVSROOT_DIRNAME}/first-dir/file2,v +done" + # Another variation on the file2 test would be to use two working + # directories so that the update -r br would need to + # a merge to get from 1.1.2.1 to the head of the 1.1.2 branch. + dotest tagf-13 "${testcvs} -q update -r br" \ +"RCS file: ${CVSROOT_DIRNAME}/first-dir/file1,v +retrieving revision 1\.1\.2\.1 +retrieving revision 1\.1 +Merging differences between 1\.1\.2\.1 and 1\.1 into file1 +rcsmerge: warning: conflicts during merge +${SPROG} update: conflicts found in file1 +C file1 +M file2" + # CVS is giving a conflict because we are trying to get back to + # 1.1.4. I'm not sure why it is a conflict rather than just + # "M file1". + dotest tagf-14 "cat file1" \ +"<<<<<<< file1 +brmod +moremod +[=]====== +[>]>>>>>> 1\.1" + echo resolve >file1 + dotest tagf-15 "${testcvs} -q ci -m recovered" \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +new revision: 1\.1\.4\.1; previous revision: 1\.1 +$CVSROOT_DIRNAME/first-dir/file2,v <-- file2 +new revision: 1\.1\.2\.2; previous revision: 1\.1\.2\.1" + # try accidentally deleting branch tag, "tag -d" + dotest_fail tagf-16 "${testcvs} tag -d br" \ +"${SPROG} tag: Untagging \. +${SPROG} tag: Not removing branch tag .br. from .${CVSROOT_DIRNAME}/first-dir/file1,v.\. +${SPROG} tag: Not removing branch tag .br. from .${CVSROOT_DIRNAME}/first-dir/file2,v.\." + # try accidentally deleting branch tag, "rtag -d" + dotest_fail tagf-17 "${testcvs} rtag -d br first-dir" \ +"${SPROG} rtag: Untagging first-dir +${SPROG} rtag: Not removing branch tag .br. from .${CVSROOT_DIRNAME}/first-dir/file1,v.\. +${SPROG} rtag: Not removing branch tag .br. from .${CVSROOT_DIRNAME}/first-dir/file2,v.\." + # try accidentally converting branch tag to non-branch tag "tag -F" + dotest tagf-18 "${testcvs} tag -r1.1 -F br file1" \ +"${SPROG} tag: file1: Not moving branch tag .br. from 1\.1\.4\.1 to 1\.1\." + # try accidentally converting branch tag to non-branch tag "rtag -F" + dotest tagf-19 "${testcvs} rtag -r1.1 -F br first-dir" \ +"${SPROG} rtag: Tagging first-dir +${SPROG} rtag: first-dir/file1: Not moving branch tag .br. from 1\.1\.4\.1 to 1\.1\. +${SPROG} rtag: first-dir/file2: Not moving branch tag .br. from 1\.1\.2\.2 to 1\.1\." + # create a non-branch tag + dotest tagf-20 "${testcvs} rtag regulartag first-dir" \ +"${SPROG} rtag: Tagging first-dir" + # try accidentally converting non-branch tag to branch tag (tag -F -B -b) + dotest tagf-21 "${testcvs} tag -F -B -b regulartag file1" \ +"${SPROG} tag: file1: Not moving non-branch tag .regulartag. from 1\.1 to 1\.1\.4\.1\.0\.2 due to .-B. option\." + # try accidentally converting non-branch tag to branch rtag (rtag -F -B -b) + dotest tagf-22 "${testcvs} rtag -F -B -b regulartag first-dir" \ +"${SPROG} rtag: Tagging first-dir +${SPROG} rtag: first-dir/file1: Not moving non-branch tag .regulartag. from 1\.1 to 1\.1\.0\.6 due to .-B. option\. +${SPROG} rtag: first-dir/file2: Not moving non-branch tag .regulartag. from 1\.1 to 1\.1\.0\.4 due to .-B. option\." + # Try accidentally deleting non-branch: (tag -d -B) + dotest_fail tagf-23 "${testcvs} tag -d -B regulartag file1" \ +"${SPROG} tag: Not removing non-branch tag .regulartag. from .${CVSROOT_DIRNAME}/first-dir/file1,v. due to .-B. option\." + # Try accidentally deleting non-branch: (rtag -d -B) + dotest_fail tagf-24 \ + "${testcvs} rtag -d -B regulartag first-dir" \ +"${SPROG} rtag: Untagging first-dir +${SPROG} rtag: Not removing non-branch tag .regulartag. from .${CVSROOT_DIRNAME}/first-dir/file1,v. due to .-B. option\. +${SPROG} rtag: Not removing non-branch tag .regulartag. from .${CVSROOT_DIRNAME}/first-dir/file2,v. due to .-B. option\." + + # the following tests (throught the next commit) keep moving the same + # tag back and forth between 1.1.6 & 1.1.8 in file1 and between + # 1.1.4 and 1.1.6 in file2 since nothing was checked in on some of + # these branches and CVS only tracks branches via tags unless they contain data. + + # try intentionally converting non-branch tag to branch tag (tag -F -b) + dotest tagf-25a "${testcvs} tag -F -b regulartag file1" "T file1" + # try intentionally moving a branch tag to a newly created branch (tag -F -b -B) + dotest tagf-25b "${testcvs} tag -F -B -b -r1.1 regulartag file1" \ +"T file1" + # try intentionally converting mixed tags to branch tags (rtag -F -b) + dotest tagf-26a "${testcvs} rtag -F -b regulartag first-dir" \ +"${SPROG} rtag: Tagging first-dir +${SPROG} rtag: first-dir/file1: Not moving branch tag .regulartag. from 1\.1 to 1\.1\.0\.8\." + # try intentionally converting a branch to a new branch tag (rtag -F -b -B) + dotest tagf-26b "${testcvs} rtag -F -B -b -r1.1 regulartag first-dir" \ +"${SPROG} rtag: Tagging first-dir" + # update to our new branch + dotest tagf-27 "${testcvs} update -r regulartag" \ +"${SPROG} update: Updating \. +U file1 +U file2" + # commit some changes and see that all rev numbers look right + echo changes >> file1 + echo changes >> file2 + dotest tagf-28 "${testcvs} ci -m changes" \ +"${CPROG} commit: Examining \. +${CVSROOT_DIRNAME}/first-dir/file1,v <-- file1 +new revision: 1\.1\.8\.1; previous revision: 1\.1 +${CVSROOT_DIRNAME}/first-dir/file2,v <-- file2 +new revision: 1\.1\.6\.1; previous revision: 1\.1" + # try intentional branch to non-branch (tag -F -B) + dotest tagf-29 "${testcvs} tag -F -B -r1.1 regulartag file1" \ +"T file1" + # try non-branch to non-branch (tag -F -B) + dotest tagf-29a "${testcvs} tag -F -B -r br regulartag file1" \ +"${SPROG} tag: file1: Not moving non-branch tag .regulartag. from 1\.1 to 1\.1\.4\.1 due to .-B. option\." + # try mixed-branch to non-branch (rtag -F -B ) + dotest tagf-29b "${testcvs} rtag -F -B -r br regulartag first-dir" \ +"${SPROG} rtag: Tagging first-dir +${SPROG} rtag: first-dir/file1: Not moving non-branch tag .regulartag. from 1\.1 to 1\.1\.4\.1 due to .-B. option\." + # at this point, regulartag is a regular tag within + # file1 and file2 + + # try intentional branch to non-branch (rtag -F -B) + dotest tagf-30 "${testcvs} rtag -F -B -r1.1 br first-dir" \ +"${SPROG} rtag: Tagging first-dir" + # create a branch tag so we can try to delete it. + dotest tagf-31 "${testcvs} rtag -b brtag first-dir" \ +"${SPROG} rtag: Tagging first-dir" + + # try intentinal deletion of branch tag (tag -d -B) + dotest tagf-32 "${testcvs} tag -d -B brtag file1" "D file1" + # try intentinal deletion of branch tag (rtag -d -B) + dotest tagf-33 "${testcvs} rtag -d -B brtag first-dir" \ +"${SPROG} rtag: Untagging first-dir" + + dokeep + cd ../.. + rm -r 1 + modify_repo rm -rf $CVSROOT_DIRNAME/first-dir + ;; + + + + tag-space) + # Test tags with spaces in the names. + # + # Prior to releases 1.11.18 & 1.12.10, some commands used with + # tags with spaces in the names could hang CVS. + + # Setup; check in first-dir/file1 + mkdir 1; cd 1 + dotest tag-space-init-1 "$testcvs -q co -l ." + mkdir first-dir + dotest tag-space-init-2 "$testcvs add first-dir" \ +"Directory $CVSROOT_DIRNAME/first-dir added to the repository" + cd first-dir + touch file1 + dotest tag-space-init-3 "$testcvs add file1" \ +"$SPROG add: scheduling file \`file1' for addition +$SPROG add: use \`$SPROG commit' to add this file permanently" + dotest tag-space-init-4 "$testcvs -Q ci -m add" + + # Reportedly, the following two tags make it past WinCVS. + dotest_fail tag-space-1 "$testcvs tag ' spacetag '" \ +"$SPROG \[tag aborted\]: tag \` spacetag ' must start with a letter" + dotest_fail tag-space-2 "$testcvs tag 'spacetag '" \ +"$SPROG \[tag aborted\]: tag \`spacetag ' has non-visible graphic characters" + + if $remote; then + # Verify that this isn't a client check. + dotest tag-space-3 "$testcvs server" \ +"E $SPROG \[tag aborted\]: tag \` spacetag ' must start with a letter +error " <<EOF +Root $CVSROOT_DIRNAME +UseUnchanged +Argument -- +Argument spacetag +Directory . +$CVSROOT_DIRNAME/first-dir +Entry /file1/1.1/// +Unchanged file1 +tag +EOF + + dotest tag-space-4 "$testcvs server" \ +"E $SPROG \[tag aborted\]: tag \`spacetag ' has non-visible graphic characters +error " <<EOF +Root $CVSROOT_DIRNAME +UseUnchanged +Argument -- +Argument spacetag +Directory . +$CVSROOT_DIRNAME/first-dir +Entry /file1/1.1/// +Unchanged file1 +tag +EOF + fi # $remote + + # Any number of normal tags and branches were handled correctly. + dotest tag-space-5 "$testcvs -Q tag t1" + dotest tag-space-5b "$testcvs -Q tag t2" + dotest tag-space-5c "$testcvs -Q tag -b b1" + + cd ../.. + mkdir 2; cd 2 + + # But once a vendor branch exists, it's all over. + mkdir project; cd project + touch file1 + dotest tag-space-init-4 \ +"$testcvs -Q import -mimport second-dir VENDOR RELEASE" + + cd .. + + dotest_fail tag-space-6 "$testcvs -Q co -r ' spacetag ' first-dir" \ +"$SPROG \[checkout aborted\]: tag \` spacetag ' must start with a letter" + + # But when any files were imported, this test hung prior to CVS + # versions 1.11.18 & 1.12.10. + dotest_fail tag-space-7 "$testcvs -Q co -r ' spacetag ' second-dir" \ +"$SPROG \[checkout aborted\]: tag \` spacetag ' must start with a letter" + + if $remote; then + # I based the client input in the next two tests on actual input + # from WinCVS 1.2. + dotest tag-space-8 "$testcvs server" \ +"E $SPROG \[checkout aborted\]: tag \` spacetag ' must start with a letter +error " <<EOF +Root $CVSROOT_DIRNAME +Argument -P +Argument -r +Argument spacetag +Argument first-dir +Directory . +$CVSROOT_DIRNAME +co +EOF + + # Verify the test is not on the client side. + dotest tag-space-9 "$testcvs server" \ +"E $SPROG \[checkout aborted\]: tag \` spacetag ' must start with a letter +error " <<EOF +Root $CVSROOT_DIRNAME +Argument -P +Argument -r +Argument spacetag +Argument second-dir +Directory . +$CVSROOT_DIRNAME +co +EOF + fi # $remote + + dotest tag-space-10 "$testcvs -Q co second-dir" + cd second-dir + + # This test would also hang. + dotest_fail tag-space-11 "$testcvs -Q up -r ' spacetag '" \ +"$SPROG \[update aborted\]: tag \` spacetag ' must start with a letter" + + if $remote; then + dotest tag-space-12 "$testcvs server" \ +"E $SPROG \[update aborted\]: tag \` spacetag ' must start with a letter +error " <<EOF +Root $CVSROOT_DIRNAME +Argument -r +Argument spacetag +Argument -u +Argument -- +Directory . +$CVSROOT_DIRNAME +Unchanged file1 +update +EOF + fi # $remote + + # I'm skipping tests for other commands that may have had the same + # problem. Hopefully, if a new issue arises, one of the above tests + # will catch the problem. + + if $keep; then + echo Keeping $TESTDIR and exiting due to --keep + exit 0 + fi + + cd ../.. + rm -r 1 2 + modify_repo rm -rf $CVSROOT_DIRNAME/first-dir \ + $CVSROOT_DIRNAME/second-dir + ;; + + + + rcslib) + # Test librarification of RCS. + # First: test whether `cvs diff' handles $Name expansion + # correctly. We diff two revisions with their symbolic tags; + # neither tag should be expanded in the output. Also diff + # one revision with the working copy. + + modify_repo mkdir $CVSROOT_DIRNAME/first-dir + dotest rcsdiff-1 "${testcvs} -q co first-dir" '' + cd first-dir + echo "I am the first foo, and my name is $""Name$." > foo.c + dotest rcsdiff-2 "${testcvs} add -m new-file foo.c" \ +"${SPROG} add: scheduling file .foo\.c. for addition +${SPROG} add: use .${SPROG} commit. to add this file permanently" + dotest rcsdiff-3 "${testcvs} commit -m rev1 foo.c" \ +"${CVSROOT_DIRNAME}/first-dir/foo.c,v <-- foo\.c +initial revision: 1\.1" + dotest rcsdiff-4 "${testcvs} tag first foo.c" "T foo\.c" + dotest rcsdiff-5 "${testcvs} update -p -r first foo.c" \ +"=================================================================== +Checking out foo\.c +RCS: ${CVSROOT_DIRNAME}/first-dir/foo\.c,v +VERS: 1\.1 +\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* +I am the first foo, and my name is \$""Name: first \$\." + + echo "I am the second foo, and my name is $""Name$." > foo.c + dotest rcsdiff-6 "${testcvs} commit -m rev2 foo.c" \ +"${CVSROOT_DIRNAME}/first-dir/foo\.c,v <-- foo\.c +new revision: 1\.2; previous revision: 1\.1" + dotest rcsdiff-7 "${testcvs} tag second foo.c" "T foo\.c" + dotest rcsdiff-8 "${testcvs} update -p -r second foo.c" \ +"=================================================================== +Checking out foo\.c +RCS: ${CVSROOT_DIRNAME}/first-dir/foo\.c,v +VERS: 1\.2 +\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* +I am the second foo, and my name is \$""Name: second \$\." + + dotest_fail rcsdiff-9 "${testcvs} diff -r first -r second" \ +"${SPROG} diff: Diffing \. +Index: foo\.c +=================================================================== +RCS file: ${CVSROOT_DIRNAME}/first-dir/foo\.c,v +retrieving revision 1\.1 +retrieving revision 1\.2 +diff -r1\.1 -r1\.2 +1c1 +< I am the first foo, and my name is \$""Name: \$\. +--- +> I am the second foo, and my name is \$""Name: \$\." + + echo "I am the once and future foo, and my name is $""Name$." > foo.c + dotest_fail rcsdiff-10 "${testcvs} diff -r first" \ +"${SPROG} diff: Diffing \. +Index: foo\.c +=================================================================== +RCS file: ${CVSROOT_DIRNAME}/first-dir/foo\.c,v +retrieving revision 1\.1 +diff -r1\.1 foo\.c +1c1 +< I am the first foo, and my name is \$""Name: \$\. +--- +> I am the once and future foo, and my name is \$""Name\$\." + + # Test handling of libdiff options. diff gets quite enough + # of a workout elsewhere in sanity.sh, so we assume that it's + # mostly working properly if it passes all the other tests. + # The main one we want to try is regex handling, since we are + # using CVS's regex matcher and not diff's. + + cat >rgx.c <<EOF +test_regex (whiz, bang) +{ +foo; +bar; +baz; +grumble; +} +EOF + + dotest rcslib-diffrgx-1 "${testcvs} -q add -m '' rgx.c" \ +"${SPROG} add: use .${SPROG} commit. to add this file permanently" + dotest rcslib-diffrgx-2 "${testcvs} -q ci -m '' rgx.c" \ +"$CVSROOT_DIRNAME/first-dir/rgx\.c,v <-- rgx\.c +initial revision: 1\.1" + cat >rgx.c <<EOF +test_regex (whiz, bang) +{ +foo; +bar; +baz; +mumble; +} +EOF + # Use dotest_fail because exit status from `cvs diff' must be 1. + # + # Incidentally test that CVS no longer splits diff arguments on + # spaces. + dotest_fail rcslib-diffrgx-3 "$testcvs diff -c -F'.* (' rgx.c" \ +"Index: rgx\.c +=================================================================== +RCS file: ${CVSROOT_DIRNAME}/first-dir/rgx\.c,v +retrieving revision 1\.1 +diff -c -F '\.\* (' -r1\.1 rgx\.c +\*\*\* rgx\.c ${RFCDATE} 1\.1 +--- rgx\.c ${RFCDATE} +\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* test_regex (whiz, bang) +\*\*\* 3,7 \*\*\*\* + foo; + bar; + baz; +! grumble; + } +--- 3,7 ---- + foo; + bar; + baz; +! mumble; + }" + + # Tests of rcsmerge/diff3. Merge operations get a good general + # workout elsewhere; we want to make sure that options are still + # handled properly. Try merging two branches with -kv, to test + # both -j and -k switches. + + cd .. + + modify_repo rm -rf $CVSROOT_DIRNAME/first-dir + rm -r first-dir + + mkdir 1; cd 1 + dotest rcslib-merge-1 "$testcvs -q co -l ." + mkdir first-dir + dotest rcslib-merge-2 "$testcvs -q add first-dir" \ +"Directory $CVSROOT_DIRNAME.*/first-dir added to the repository" + cd ..; rm -r 1 + + dotest rcslib-merge-3 "$testcvs -q co first-dir" "" + cd first-dir + + echo '$''Revision$' > file1 + echo '2' >> file1 + echo '3' >> file1 + dotest rcslib-merge-4 "${testcvs} -q add file1" \ +"${SPROG} add: use .${SPROG} commit. to add this file permanently" + dotest rcslib-merge-5 "${testcvs} -q commit -m '' file1" \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +initial revision: 1\.1" + sed -e 's/2/two/' file1 > f; mv f file1 + dotest rcslib-merge-6 "${testcvs} -q commit -m '' file1" \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +new revision: 1\.2; previous revision: 1\.1" + dotest rcslib-merge-7 "${testcvs} -q tag -b -r 1.1 patch1" "T file1" + dotest rcslib-merge-8 "${testcvs} -q update -r patch1" "[UP] file1" + dotest rcslib-merge-9 "${testcvs} -q status" \ +"=================================================================== +File: file1 Status: Up-to-date + + Working revision: 1\.1.* + Repository revision: 1\.1 ${CVSROOT_DIRNAME}/first-dir/file1,v + Commit Identifier: ${commitid} + Sticky Tag: patch1 (branch: 1\.1\.2) + Sticky Date: (none) + Sticky Options: (none)" + dotest rcslib-merge-10 "cat file1" \ +'$''Revision: 1\.1 $ +2 +3' + sed -e 's/3/three/' file1 > f; mv f file1 + dotest rcslib-merge-11 "${testcvs} -q commit -m '' file1" \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +new revision: 1\.1\.2\.1; previous revision: 1\.1" + dotest rcslib-merge-12 "${testcvs} -q update -kv -j1.2" \ +"U file1 +RCS file: ${CVSROOT_DIRNAME}/first-dir/file1,v +retrieving revision 1\.1 +retrieving revision 1\.2 +Merging differences between 1\.1 and 1\.2 into file1 +rcsmerge: warning: conflicts during merge" + dotest rcslib-merge-13 "cat file1" \ +"<<<<<<< file1 +1\.1\.2\.1 +2 +three +[=]====== +1\.2 +two +3 +[>]>>>>>> 1\.2" + + # Test behavior of symlinks in the repository. + if test -n "$remotehost"; then + # Create the link on the remote system. This is because Cygwin's + # Windows support creates *.lnk files for Windows. When creating + # these in an SMB share from UNIX, these links won't work from the + # UNIX side. + modify_repo $CVS_RSH $remotehost "'ln -s file1,v $CVSROOT_DIRNAME/first-dir/file2,v'" + else + modify_repo ln -s file1,v $CVSROOT_DIRNAME/first-dir/file2,v + fi + dotest rcslib-symlink-2 "$testcvs update file2" "U file2" + echo "This is a change" >> file2 + dotest rcslib-symlink-3 "$testcvs ci -m because file2" \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file2 +new revision: 1\.1\.2\.2; previous revision: 1\.1\.2\.1" + + # Switch as for rcslib-symlink-1 + if test -n "$remotehost"; then + dotest rcslib-symlink-4 "$CVS_RSH $remotehost 'ls -l $CVSROOT_DIRNAME/first-dir/file2,v'" \ +".*$CVSROOT_DIRNAME/first-dir/file2,v -> file1,v" + else + dotest rcslib-symlink-4 "ls -l $CVSROOT_DIRNAME/first-dir/file2,v" \ +".*$CVSROOT_DIRNAME/first-dir/file2,v -> file1,v" + fi + + # CVS was failing to check both the symlink and the file + # for timestamp changes for a while. Test that. + rm file1 + dotest rcslib-symlink-3a "${testcvs} -q up file1" \ +"${SPROG} update: warning: \`file1' was lost +U file1" + echo "This is a change" >> file1 + dotest rcslib-symlink-3b "${testcvs} ci -m because file1" \ +"${CVSROOT_DIRNAME}/first-dir/file1,v <-- file1 +new revision: 1\.1\.2\.[0-9]*; previous revision: 1\.1\.2\.[0-9]*" + dotest rcslib-symlink-3c "${testcvs} update file2" "[UP] file2" + + echo some new text >file3 + dotest rcslib-symlink-3d "${testcvs} -Q add file3" '' + dotest rcslib-symlink-3e "$testcvs -Q ci -mtest file3" + + rm -f ${CVSROOT_DIRNAME}/first-dir/file2,v + # As for rcslib-symlink-1 + if test -n "$remotehost"; then + modify_repo "$CVS_RSH $remotehost 'ln -s Attic/file3,v $CVSROOT_DIRNAME/first-dir/file2,v'" + else + modify_repo ln -s Attic/file3,v $CVSROOT_DIRNAME/first-dir/file2,v + fi + + dotest rcslib-symlink-3g "$testcvs update file2" "U file2" + + # restore the link to file1 for the following tests + dotest rcslib-symlink-3i "$testcvs -Q rm -f file3" '' + dotest rcslib-symlink-3j "$testcvs -Q ci -mwhatever file3" + rm -f $CVSROOT_DIRNAME/first-dir/file2,v + rm -f $CVSROOT_DIRNAME/first-dir/Attic/file3,v + # As for rcslib-symlink-1 + if test -n "$remotehost"; then + modify_repo "$CVS_RSH $remotehost 'ln -s file1,v $CVSROOT_DIRNAME/first-dir/file2,v'" + else + modify_repo ln -s file1,v $CVSROOT_DIRNAME/first-dir/file2,v + fi + + # Test 5 reveals a problem with having symlinks in the + # repository. CVS will try to tag both of the files + # separately. After processing one, it will do the same + # operation to the other, which is actually the same file, + # so the tag will already be there. FIXME: do we bother + # changing operations to notice cases like this? This + # strikes me as a difficult problem. -Noel + dotest rcslib-symlink-5 "$testcvs tag the_tag" \ +"$SPROG tag: Tagging . +T file1 +W file2 : the_tag already exists on version 1.1.2.3 : NOT MOVING tag to version 1.1.2.1" + # As for rcslib-symlink-1 + if test -n "$remotehost"; then + dotest rcslib-symlink-6 "$CVS_RSH $remotehost 'ls -l $CVSROOT_DIRNAME/first-dir/file2,v'" \ +".*$CVSROOT_DIRNAME/first-dir/file2,v -> file1,v" + else + dotest rcslib-symlink-6 "ls -l $CVSROOT_DIRNAME/first-dir/file2,v" \ +".*$CVSROOT_DIRNAME/first-dir/file2,v -> file1,v" + fi + + # Symlinks tend to interact poorly with the Attic. + cd .. + mkdir 2; cd 2 + dotest rcslib-symlink-7 "$testcvs -q co first-dir" \ +"U first-dir/file1 +U first-dir/file2" + cd first-dir + dotest rcslib-symlink-8 "$testcvs rm -f file2" \ +"$SPROG remove: scheduling .file2. for removal +$SPROG remove: use .$SPROG commit. to remove this file permanently" + dotest rcslib-symlink-9 "$testcvs -q ci -m rm-it" \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file2 +new revision: delete; previous revision: 1\.2" + # OK, why this message happens twice is relatively clear + # (the check_* and rtag_* calls to start_recursion). + # Why it happens a third time I didn't try to find out. + # + # DRP: One of the error messages disappeared while I was making + # proxy modifications. Until I detect a deeper issue, I'm not + # going to stress over it. + # + # DRP: Both messages disappear starting with glibc 2.3.3 due to a bug + # in the glob function which causes it to fail to return broken + # symlinks. I'm submitting a bug fix to glibc which will hopefully + # be released with glibc 2.3.6. Once it is released and versions + # 2.3.3-2.3.5 of glibc become uncommon, the first, empty case below + # should be removed again. + dotest rcslib-symlink-10 \ +"$testcvs -q rtag -b -r the_tag brtag first-dir" "" \ +"$SPROG rtag: could not read RCS file for first-dir/file2 +$SPROG rtag: could not read RCS file for first-dir/file2" + + # Restore file1 for the next test. + dotest rcslib-long-symlink-init-1 "$testcvs -Q up -A" + dotest rcslib-long-symlink-init-2 "$testcvs -Q add file1" + dotest rcslib-long-symlink-init-3 "$testcvs -Q ci -mback" + + cd ../.. # $TESTDIR + + # CVS has a hard-coded default link path size of 127 characters. + # Make sure it knows how to exceed that. + longpath=$CVSROOT_DIRNAME + count=0 + while test $count -lt 10; do + # 10 * 30 characters + len $CVSROOT_DIRNAME + count=`expr $count + 1` + longpath=$longpath/123456789012345678901234567890 + modify_repo mkdir $longpath + done + modify_repo cp $CVSROOT_DIRNAME/first-dir/file1,v $longpath + modify_repo mkdir $CVSROOT_DIRNAME/second-dir + + # Switch as for rcslib-symlink-1 + if test -n "$remotehost"; then + modify_repo $CVS_RSH $remotehost \ + 'ln -s $longpath/file1,v $CVSROOT_DIRNAME/second-dir/fileX,v' + else + modify_repo ln -s $longpath/file1,v \ + $CVSROOT_DIRNAME/second-dir/fileX,v + fi + + dotest rcslib-long-symlink-2 "$testcvs co second-dir" \ +"$SPROG checkout: Updating second-dir +U second-dir/fileX" + + cd second-dir + echo change-it >>fileX + + # Writes actually cause symlinks to be resolved. + dotest rcslib-long-symlink-3 "$testcvs -q ci -mwrite-it" \ +"$CVSROOT_DIRNAME/123456789012345678901234567890/123456789012345678901234567890/123456789012345678901234567890/123456789012345678901234567890/123456789012345678901234567890/123456789012345678901234567890/123456789012345678901234567890/123456789012345678901234567890/123456789012345678901234567890/123456789012345678901234567890/file1,v <-- fileX +new revision: 1\.5; previous revision: 1\.4" + + dokeep + cd .. + + # Must remove the symlink first. Samba doesn't appear to show + # broken symlink across the SMB share, and rm -rf by itself + # will remove file1,v first and leave file2,v a broken link and the + # rm -rf will fail since it doesn't find file2,v and it still gets + # directory not empty errors removing cvsroot/first-dir. + # + # I'm not sure why I need to do this on $remotehost. The rm above + # rcslib-symlink-3j works fine, but the next one doesn't unless run + # remotely under Cygwin and using a TESTDIR on a Samba share. + if test -n "$remotehost"; then + $CVS_RSH $remotehost \ +"rm -f $CVSROOT_DIRNAME/first-dir/file2,v $CVSROOT_DIRNAME/second-dir/fileX,v" + fi + modify_repo rm -rf $CVSROOT_DIRNAME/first-dir \ + $CVSROOT_DIRNAME/second-dir \ + $CVSROOT_DIRNAME/123456789012345678901234567890 + rm -r first-dir second-dir 2 + ;; + + + + multibranch) + # Test the ability to have several branchpoints coming off the + # same revision. + modify_repo mkdir $CVSROOT_DIRNAME/first-dir + dotest multibranch-1 "${testcvs} -q co first-dir" '' + cd first-dir + echo 1:trunk-1 >file1 + dotest multibranch-2 "${testcvs} add file1" \ +"${SPROG}"' add: scheduling file `file1'\'' for addition +'"${SPROG}"' add: use .'"${SPROG}"' commit. to add this file permanently' + dotest_lit multibranch-3 "${testcvs} -q ci -m add-it" <<HERE +$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +initial revision: 1.1 +HERE + dotest multibranch-4 "${testcvs} tag -b br1" \ +"${SPROG} tag: Tagging \. +T file1" + dotest multibranch-5 "${testcvs} tag -b br2" \ +"${SPROG} tag: Tagging \. +T file1" + dotest multibranch-6 "${testcvs} -q update -r br1" '' + echo on-br1 >file1 + dotest multibranch-7 "${testcvs} -q ci -m modify-on-br1" \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +new revision: 1\.1\.2\.1; previous revision: 1\.1" + dotest multibranch-8 "${testcvs} -q update -r br2" '[UP] file1' + echo br2 adds a line >>file1 + dotest multibranch-9 "${testcvs} -q ci -m modify-on-br2" \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +new revision: 1\.1\.4\.1; previous revision: 1\.1" + dotest multibranch-10 "${testcvs} -q update -r br1" '[UP] file1' + dotest multibranch-11 "cat file1" 'on-br1' + dotest multibranch-12 "${testcvs} -q update -r br2" '[UP] file1' + dotest multibranch-13 "cat file1" '1:trunk-1 +br2 adds a line' + + dotest multibranch-14 "${testcvs} log file1" \ +" +RCS file: ${CVSROOT_DIRNAME}/first-dir/file1,v +Working file: file1 +head: 1\.1 +branch: +locks: strict +access list: +symbolic names: + br2: 1\.1\.0\.4 + br1: 1\.1\.0\.2 +keyword substitution: kv +total revisions: 3; selected revisions: 3 +description: +---------------------------- +revision 1\.1 +date: ${ISO8601DATE}; author: ${username}; state: Exp; commitid: ${commitid}; +branches: 1\.1\.2; 1\.1\.4; +add-it +---------------------------- +revision 1\.1\.4\.1 +date: ${ISO8601DATE}; author: ${username}; state: Exp; lines: ${PLUS}1 -0; commitid: ${commitid}; +modify-on-br2 +---------------------------- +revision 1\.1\.2\.1 +date: ${ISO8601DATE}; author: ${username}; state: Exp; lines: ${PLUS}1 -1; commitid: ${commitid}; +modify-on-br1 +=============================================================================" + + dokeep + cd .. + modify_repo rm -rf $CVSROOT_DIRNAME/first-dir + rm -r first-dir + ;; + + + + import) # test death after import + # Tests of "cvs import": + # basic2 + # rdiff -- imports with keywords + # import -- more tests of imports with keywords + # importb -- -b option. + # importc -- bunch o' files in bunch o' directories + # importX -- -X option. + # importX2 -- CVSROOT/config ImportNewFilesToVendorBranchOnly + # flag + # modules3 + # mflag -- various -m messages + # ignore -- import and cvsignore + # binwrap -- import and -k wrappers + # info -- imports which are rejected by verifymsg + # head -- intended to test vendor branches and HEAD, + # although it doesn't really do it yet. + # import-CVS -- refuse to import directories named "CVS". + # import-quirks -- short tests of import quirks. + + # import + mkdir import-dir ; cd import-dir + + for i in 1 2 3 4 ; do + echo imported file"$i" > imported-f"$i" + done + + # This directory should be on the default ignore list, + # so it shouldn't get imported. + mkdir RCS + echo ignore.me >RCS/ignore.me + + echo 'import should not expand $''Id$' >>imported-f2 + cp imported-f2 ../imported-f2-orig.tmp + + dotest_sort import-96 \ +"${testcvs} import -m first-import first-dir vendor-branch junk-1_0" \ +" + +I first-dir/RCS +N first-dir/imported-f1 +N first-dir/imported-f2 +N first-dir/imported-f3 +N first-dir/imported-f4 +No conflicts created by this import" + + dotest import-96.5 "cmp ../imported-f2-orig.tmp imported-f2" '' + + cd .. + + # co + dotest import-97 "${testcvs} -q co first-dir" \ +"U first-dir/imported-f1 +U first-dir/imported-f2 +U first-dir/imported-f3 +U first-dir/imported-f4" + + cd first-dir + + for i in 1 2 3 4 ; do + dotest import-98-$i "test -f imported-f$i" '' + done + dotest_fail import-98.5 "test -d RCS" '' + + # remove + rm imported-f1 + dotest import-99 "${testcvs} rm imported-f1" \ +"${SPROG}"' remove: scheduling `imported-f1'\'' for removal +'"${SPROG}"' remove: use .'"${SPROG}"' commit. to remove this file permanently' + + # change + echo local-change >> imported-f2 + + # commit + dotest import-100 "${testcvs} ci -m local-changes" \ +"${CPROG} commit: Examining . +${CVSROOT_DIRNAME}/first-dir/imported-f1,v <-- imported-f1 +new revision: delete; previous revision: 1\.1\.1\.1 +${CVSROOT_DIRNAME}/first-dir/imported-f2,v <-- imported-f2 +new revision: 1\.2; previous revision: 1\.1" + + # log + dotest import-101 "${testcvs} log imported-f1" \ +" +RCS file: ${CVSROOT_DIRNAME}/first-dir/Attic/imported-f1,v +Working file: imported-f1 +head: 1\.2 +branch: +locks: strict +access list: +symbolic names: + junk-1_0: 1\.1\.1\.1 + vendor-branch: 1\.1\.1 +keyword substitution: kv +total revisions: 3; selected revisions: 3 +description: +---------------------------- +revision 1\.2 +date: ${ISO8601DATE}; author: ${username}; state: dead; lines: ${PLUS}0 -0; commitid: ${commitid}; +local-changes +---------------------------- +revision 1\.1 +date: ${ISO8601DATE}; author: ${username}; state: Exp; commitid: ${commitid}; +branches: 1\.1\.1; +Initial revision +---------------------------- +revision 1\.1\.1\.1 +date: ${ISO8601DATE}; author: ${username}; state: Exp; lines: ${PLUS}0 -0; commitid: ${commitid}; +first-import +=============================================================================" + + # update into the vendor branch. + dotest import-102 "${testcvs} update -rvendor-branch" \ +"${SPROG} update: Updating . +[UP] imported-f1 +[UP] imported-f2" + + # remove file4 on the vendor branch + rm imported-f4 + dotest import-103 "${testcvs} rm imported-f4" \ +"${SPROG}"' remove: scheduling `imported-f4'\'' for removal +'"${SPROG}"' remove: use .'"${SPROG}"' commit. to remove this file permanently' + + # commit + dotest import-104 \ +"${testcvs} ci -m vendor-removed imported-f4" \ +"${CVSROOT_DIRNAME}/first-dir/imported-f4,v <-- imported-f4 +new revision: delete; previous revision: 1\.1\.1\.1" + + # update to main line + dotest import-105 "${testcvs} -q update -A" \ +"${SPROG} update: \`imported-f1' is no longer in the repository +[UP] imported-f2" + + # second import - file4 deliberately unchanged + cd ../import-dir + for i in 1 2 3 ; do + echo rev 2 of file $i >> imported-f"$i" + done + cp imported-f2 ../imported-f2-orig.tmp + + dotest_sort import-106 \ +"${testcvs} import -m second-import first-dir vendor-branch junk-2_0" \ +" + + + ${CPROG} checkout -j<prev_rel_tag> -jjunk-2_0 first-dir +2 conflicts created by this import. +C first-dir/imported-f1 +C first-dir/imported-f2 +I first-dir/RCS +U first-dir/imported-f3 +U first-dir/imported-f4 +Use the following command to help the merge:" + + dotest import-106.5 "cmp ../imported-f2-orig.tmp imported-f2" \ +'' + + cd .. + + rm imported-f2-orig.tmp + + # co + dotest import-107 "${testcvs} co first-dir" \ +"${SPROG} checkout: Updating first-dir +[UP] first-dir/imported-f3 +[UP] first-dir/imported-f4" + + cd first-dir + + dotest_fail import-108 "test -f imported-f1" '' + + for i in 2 3 ; do + dotest import-109-$i "test -f imported-f$i" '' + done + + # check vendor branch for file4 + dotest import-110 "${testcvs} -q update -rvendor-branch" \ +"[UP] imported-f1 +[UP] imported-f2" + + dotest import-111 "test -f imported-f4" '' + + # update to main line + dotest import-112 "${testcvs} -q update -A" \ +"${SPROG} update: \`imported-f1' is no longer in the repository +[UP] imported-f2" + + cd .. + + dotest import-113 \ +"${testcvs} -q co -jjunk-1_0 -jjunk-2_0 first-dir" \ +"${SPROG} checkout: file first-dir/imported-f1 does not exist, but is present in revision junk-2_0 +RCS file: ${CVSROOT_DIRNAME}/first-dir/imported-f2,v +retrieving revision 1\.1\.1\.1 +retrieving revision 1\.1\.1\.2 +Merging differences between 1\.1\.1\.1 and 1\.1\.1\.2 into imported-f2 +rcsmerge: warning: conflicts during merge +first-dir/imported-f3 already contains the differences between 1\.1\.1\.1 and 1\.1\.1\.2 +first-dir/imported-f4 already contains the differences between 1\.1\.1\.1 and 1\.1\.1\.3" + + cd first-dir + + dotest_fail import-114 "test -f imported-f1" '' + + for i in 2 3 ; do + dotest import-115-$i "test -f imported-f$i" '' + done + + dotest import-116 'cat imported-f2' \ +'imported file2 +[<]<<<<<< imported-f2 +import should not expand \$''Id: imported-f2,v 1\.2 [0-9/]* [0-9:]* '"${username}"' Exp \$ +local-change +[=]====== +import should not expand \$''Id: imported-f2,v 1\.1\.1\.2 [0-9/]* [0-9:]* '"${username}"' Exp \$ +rev 2 of file 2 +[>]>>>>>> 1\.1\.1\.2' + + dokeep + cd .. + rm -r first-dir + modify_repo rm -rf $CVSROOT_DIRNAME/first-dir + rm -r import-dir + ;; + + + + importb) + # More cvs import tests, especially -b option. + + # OK, first we get some sources from the NetMunger project, and + # import them into the 1.1.1 vendor branch. + mkdir imp-dir + cd imp-dir + echo 'OpenMunger sources' >file1 + echo 'OpenMunger sources' >file2 + dotest_sort importb-1 \ +"${testcvs} import -m add first-dir openmunger openmunger-1_0" \ +" + +N first-dir/file1 +N first-dir/file2 +No conflicts created by this import" + cd .. + rm -r imp-dir + + # Now we put the sources we get from FreeMunger into 1.1.3 + mkdir imp-dir + cd imp-dir + echo 'FreeMunger sources' >file1 + echo 'FreeMunger sources' >file2 + # Not completely sure how the conflict detection is supposed to + # be working here (haven't really thought about it). + # We use an explicit -d option to test that it is reflected + # in the suggested checkout. + dotest_sort importb-2 \ +"$testcvs -d '$CVSROOT' import -m add -b 1.1.3 \ + first-dir freemunger freemunger-1_0" \ +" + + + ${CPROG} -d ${CVSROOT} checkout -j<prev_rel_tag> -jfreemunger-1_0 first-dir +2 conflicts created by this import. +C first-dir/file1 +C first-dir/file2 +Use the following command to help the merge:" + cd .. + rm -r imp-dir + + # Now a test of main branch import (into second-dir, not first-dir). + mkdir imp-dir + cd imp-dir + echo 'my own stuff' >mine1.c + echo 'my own stuff' >mine2.c + dotest_fail importb-3 \ +"${testcvs} import -m add -b 1 second-dir dummy really_dumb_y" \ +"$CPROG \[import aborted\]: Only numeric branch specifications with two dots are +supported by import, not \`1'\. For example: \`1\.1\.1'\." + : when we implement main-branch import, should be \ +"N second-dir/mine1\.c +N second-dir/mine2\.c + +No conflicts created by this import" + cd .. + rm -r imp-dir + + mkdir 1 + cd 1 + # when we implement main branch import, will want to + # add "second-dir" here. + dotest importb-4 "${testcvs} -q co first-dir" \ +"U first-dir/file1 +U first-dir/file2" + cd first-dir + dotest importb-5 "${testcvs} -q log file1" " +RCS file: ${CVSROOT_DIRNAME}/first-dir/file1,v +Working file: file1 +head: 1\.1 +branch: 1\.1\.1 +locks: strict +access list: +symbolic names: + freemunger-1_0: 1\.1\.3\.1 + freemunger: 1\.1\.3 + openmunger-1_0: 1\.1\.1\.1 + openmunger: 1\.1\.1 +keyword substitution: kv +total revisions: 3; selected revisions: 3 +description: +---------------------------- +revision 1\.1 +date: ${ISO8601DATE}; author: ${username}; state: Exp; commitid: ${commitid}; +branches: 1\.1\.1; 1\.1\.3; +Initial revision +---------------------------- +revision 1\.1\.3\.1 +date: ${ISO8601DATE}; author: ${username}; state: Exp; lines: ${PLUS}1 -1; commitid: ${commitid}; +add +---------------------------- +revision 1\.1\.1\.1 +date: ${ISO8601DATE}; author: ${username}; state: Exp; lines: ${PLUS}0 -0; commitid: ${commitid}; +add +=============================================================================" + + dokeep + cd ../.. + rm -r 1 + modify_repo rm -rf $CVSROOT_DIRNAME/first-dir \ + $CVSROOT_DIRNAME/second-dir + ;; + + + + importc) + # Test importing a bunch o' files in a bunch o' directories. + # Also the -d option. + + # Set a predictable time zone for these tests. + save_TZ=$TZ + TZ=UTC0; export TZ + + mkdir 1; cd 1 + mkdir adir bdir cdir + mkdir adir/sub1 adir/sub2 + mkdir adir/sub1/ssdir + mkdir bdir/subdir + touch adir/sub1/file1 adir/sub2/file2 adir/sub1/ssdir/ssfile + touch -t ${TOUCH1971} bdir/subdir/file1 + touch -t ${TOUCH2034} cdir/cfile + dotest_sort importc-1 \ +"${testcvs} import -d -m import-it first-dir vendor release" \ +" + +N first-dir/adir/sub1/file1 +N first-dir/adir/sub1/ssdir/ssfile +N first-dir/adir/sub2/file2 +N first-dir/bdir/subdir/file1 +N first-dir/cdir/cfile +No conflicts created by this import +${SPROG} import: Importing ${CVSROOT_DIRNAME}/first-dir/adir +${SPROG} import: Importing ${CVSROOT_DIRNAME}/first-dir/adir/sub1 +${SPROG} import: Importing ${CVSROOT_DIRNAME}/first-dir/adir/sub1/ssdir +${SPROG} import: Importing ${CVSROOT_DIRNAME}/first-dir/adir/sub2 +${SPROG} import: Importing ${CVSROOT_DIRNAME}/first-dir/bdir +${SPROG} import: Importing ${CVSROOT_DIRNAME}/first-dir/bdir/subdir +${SPROG} import: Importing ${CVSROOT_DIRNAME}/first-dir/cdir" + cd .. + mkdir 2; cd 2 + dotest importc-2 "${testcvs} -q co first-dir" \ +"U first-dir/adir/sub1/file1 +U first-dir/adir/sub1/ssdir/ssfile +U first-dir/adir/sub2/file2 +U first-dir/bdir/subdir/file1 +U first-dir/cdir/cfile" + cd first-dir + dotest importc-3 "${testcvs} update adir/sub1" \ +"${SPROG} update: Updating adir/sub1 +${SPROG} update: Updating adir/sub1/ssdir" + dotest importc-4 "${testcvs} update adir/sub1 bdir/subdir" \ +"${SPROG} update: Updating adir/sub1 +${SPROG} update: Updating adir/sub1/ssdir +${SPROG} update: Updating bdir/subdir" + + echo modify >>cdir/cfile + dotest importc-5 \ +"${testcvs} -q rtag -b -r release wip_test first-dir" "" + dotest importc-6 "${testcvs} -q update -r wip_test" "M cdir/cfile" + + # This used to fail in local mode + dotest importc-7 "${testcvs} -q ci -m modify -r wip_test" \ +"$CVSROOT_DIRNAME/first-dir/cdir/cfile,v <-- cdir/cfile +new revision: 1\.1\.1\.1\.2\.1; previous revision: 1\.1\.1\.1" + + # TODO: should also be testing "import -d" when we update + # an existing file. + dotest importc-8 "${testcvs} -q log cdir/cfile" " +RCS file: ${CVSROOT_DIRNAME}/first-dir/cdir/cfile,v +Working file: cdir/cfile +head: 1\.1 +branch: 1\.1\.1 +locks: strict +access list: +symbolic names: + wip_test: 1\.1\.1\.1\.0\.2 + release: 1\.1\.1\.1 + vendor: 1\.1\.1 +keyword substitution: kv +total revisions: 3; selected revisions: 3 +description: +---------------------------- +revision 1\.1 +date: ${ISO8601DATE2034}; author: ${username}; state: Exp; commitid: ${commitid}; +branches: 1\.1\.1; +Initial revision +---------------------------- +revision 1\.1\.1\.1 +date: ${ISO8601DATE2034}; author: ${username}; state: Exp; lines: ${PLUS}0 -0; commitid: ${commitid}; +branches: 1\.1\.1\.1\.2; +import-it +---------------------------- +revision 1\.1\.1\.1\.2\.1 +date: ${ISO8601DATE}; author: ${username}; state: Exp; lines: ${PLUS}1 -0; commitid: ${commitid}; +modify +=============================================================================" + + dotest importc-9 "${testcvs} -q log bdir/subdir/file1" " +RCS file: ${CVSROOT_DIRNAME}/first-dir/bdir/subdir/file1,v +Working file: bdir/subdir/file1 +head: 1\.1 +branch: 1\.1\.1 +locks: strict +access list: +symbolic names: + wip_test: 1\.1\.1\.1\.0\.2 + release: 1\.1\.1\.1 + vendor: 1\.1\.1 +keyword substitution: kv +total revisions: 2; selected revisions: 2 +description: +---------------------------- +revision 1\.1 +date: ${ISO8601DATE1971}; author: ${username}; state: Exp; commitid: ${commitid}; +branches: 1\.1\.1; +Initial revision +---------------------------- +revision 1\.1\.1\.1 +date: ${ISO8601DATE1971}; author: ${username}; state: Exp; lines: ${PLUS}0 -0; commitid: ${commitid}; +import-it +=============================================================================" + cd .. + + # Now tests of absolute pathnames and .. as repository directory. + cd ../1 + dotest_fail importc-10 \ +"${testcvs} import -m imp ../other vendor release2" \ +"${CPROG} \[import aborted\]: directory \.\./other not relative within the repository" + dotest_fail importc-11 \ +"${testcvs} import -m imp ${TESTDIR}/other vendor release3" \ +"${CPROG} \[import aborted\]: directory ${TESTDIR}/other not relative within the repository" + dotest_fail importc-12 "test -d ${TESTDIR}/other" "" + + dokeep + TZ=$save_TZ + cd .. + rm -r 1 2 + modify_repo rm -rf $CVSROOT_DIRNAME/first-dir + ;; + + + + importX) + # More cvs import tests, especially -X option. + + # OK, first we get some sources from the Munger version 0.9, + # and import them into the 1.1.1 vendor branch (w/o -X). (This + # will be used to test subsequent imports of the same file + # with -X.) + mkdir imp-dir + cd imp-dir + echo 'Munger sources 0.9' >file0 + dotest_sort importX-1 \ +"${testcvs} import -m add first-dir munger munger-0_9" \ +" + +N first-dir/file0 +No conflicts created by this import" + cd .. + rm -r imp-dir + + # Now we put the sources we get from Munger version 1.0 on + # to the 1.1.1 vendor branch using -X. (This imports a new + # version of file0, and imports all-new files file1 and file2.) + mkdir imp-dir + cd imp-dir + echo 'Munger sources' >file0 + echo 'Munger sources' >file1 + echo 'Munger sources' >file2 + dotest_sort importX-2 \ +"${testcvs} import -X -m add first-dir munger munger-1_0" \ +" + + + ${CPROG} checkout -j<prev_rel_tag> -jmunger-1_0 first-dir +N first-dir/file1 +N first-dir/file2 +No conflicts created by this import. +U first-dir/file0 +Use the following command to help the merge:" + cd .. + rm -r imp-dir + + # Now we put the sources we get from Munger version 1.1 on + # to the 1.1.1 vendor branch using -X. (This imports unchanged + # versions of file0 and file2, a changed version of file1, and + # an all-new file3.) + mkdir imp-dir + cd imp-dir + echo 'Munger sources' >file0 + echo 'Munger sources 1.1' >file1 + echo 'Munger sources' >file2 + echo 'Munger sources 1.1' >file3 + dotest_sort importX-3 \ +"$testcvs -d '$CVSROOT' import -X -m add first-dir munger munger-1_1" \ +" + + + ${CPROG} -d ${CVSROOT} checkout -j<prev_rel_tag> -jmunger-1_1 first-dir +1 conflicts created by this import. +C first-dir/file1 +N first-dir/file3 +U first-dir/file0 +U first-dir/file2 +Use the following command to help the merge:" + cd .. + rm -r imp-dir + + mkdir 1 + cd 1 + # only file0 should be checked out + dotest importX-4 "${testcvs} -q co first-dir" \ +"U first-dir/file0" + cd first-dir + + dotest importX-5 "${testcvs} -q log file0" " +RCS file: ${CVSROOT_DIRNAME}/first-dir/file0,v +Working file: file0 +head: 1\.1 +branch: 1\.1\.1 +locks: strict +access list: +symbolic names: + munger-1_1: 1\.1\.1\.2 + munger-1_0: 1\.1\.1\.2 + munger-0_9: 1\.1\.1\.1 + munger: 1\.1\.1 +keyword substitution: kv +total revisions: 3; selected revisions: 3 +description: +---------------------------- +revision 1\.1 +date: ${ISO8601DATE}; author: ${username}; state: Exp; commitid: ${commitid}; +branches: 1\.1\.1; +Initial revision +---------------------------- +revision 1\.1\.1\.2 +date: ${ISO8601DATE}; author: ${username}; state: Exp; lines: ${PLUS}1 -1; commitid: ${commitid}; +add +---------------------------- +revision 1\.1\.1\.1 +date: ${ISO8601DATE}; author: ${username}; state: Exp; lines: ${PLUS}0 -0; commitid: ${commitid}; +add +=============================================================================" + + dotest importX-6 "${testcvs} -q log file1" " +RCS file: ${CVSROOT_DIRNAME}/first-dir/Attic/file1,v +Working file: file1 +head: 1\.2 +branch: +locks: strict +access list: +symbolic names: + munger-1_1: 1\.1\.1\.2 + munger-1_0: 1\.1\.1\.1 + munger: 1\.1\.1 +keyword substitution: kv +total revisions: 4; selected revisions: 4 +description: +---------------------------- +revision 1\.2 +date: ${ISO8601DATE}; author: ${username}; state: dead; lines: ${PLUS}0 -0; commitid: ${commitid}; +Revision 1\.1 was added on the vendor branch\. +---------------------------- +revision 1\.1 +date: ${ISO8601DATE}; author: ${username}; state: Exp; commitid: ${commitid}; +branches: 1\.1\.1; +Initial revision +---------------------------- +revision 1\.1\.1\.2 +date: ${ISO8601DATE}; author: ${username}; state: Exp; lines: ${PLUS}1 -1; commitid: ${commitid}; +add +---------------------------- +revision 1\.1\.1\.1 +date: ${ISO8601DATE}; author: ${username}; state: Exp; lines: ${PLUS}0 -0; commitid: ${commitid}; +add +=============================================================================" + + cd ../.. + rm -r 1 + modify_repo rm -rf ${CVSROOT_DIRNAME}/first-dir + ;; + + + + importX2) + # Test ImportNewFilesToVendorBranchOnly config file option. + + # On Windows, we can't check out CVSROOT, because the case + # insensitivity means that this conflicts with cvsroot. + mkdir wnt + cd wnt + + dotest importX2-1 "${testcvs} -q co CVSROOT" "[UP] CVSROOT${DOTSTAR}" + cd CVSROOT + echo "ImportNewFilesToVendorBranchOnly=yes" >> config + + dotest importX2-2 "$testcvs -q ci -m force-cvs-import-X" \ +"$TESTDIR/cvsroot/CVSROOT/config,v <-- config +new revision: 1\.[0-9]*; previous revision: 1\.[0-9]* +$SPROG commit: Rebuilding administrative file database" + + cd ../.. + + # Import a sources file, but do NOT specify -X. The new file + # should be killed, anyway (because of the config option). + mkdir imp-dir + cd imp-dir + echo 'source' >file1 + dotest_sort importX2-3 \ +"${testcvs} import -m add first-dir source source-1_0" \ +" + + + ${CPROG} checkout -j<prev_rel_tag> -jsource-1_0 first-dir +N first-dir/file1 +No conflicts created by this import. +Use the following command to help the merge:" + cd .. + rm -r imp-dir + + mkdir 1 + cd 1 + # **nothing** should be checked out** + dotest importX2-4 "${testcvs} -q co first-dir" "" + + cd first-dir + dotest importX2-5 "${testcvs} -q log file1" " +RCS file: ${CVSROOT_DIRNAME}/first-dir/Attic/file1,v +Working file: file1 +head: 1\.2 +branch: +locks: strict +access list: +symbolic names: + source-1_0: 1\.1\.1\.1 + source: 1\.1\.1 +keyword substitution: kv +total revisions: 3; selected revisions: 3 +description: +---------------------------- +revision 1\.2 +date: ${ISO8601DATE}; author: ${username}; state: dead; lines: ${PLUS}0 -0; commitid: ${commitid}; +Revision 1\.1 was added on the vendor branch\. +---------------------------- +revision 1\.1 +date: ${ISO8601DATE}; author: ${username}; state: Exp; commitid: ${commitid}; +branches: 1\.1\.1; +Initial revision +---------------------------- +revision 1\.1\.1\.1 +date: ${ISO8601DATE}; author: ${username}; state: Exp; lines: ${PLUS}0 -0; commitid: ${commitid}; +add +=============================================================================" + + dokeep + cd ../.. + restore_adm + rm -r 1 + rm -r wnt + modify_repo rm -rf $CVSROOT_DIRNAME/first-dir + ;; + + + + import-CVS) + mkdir import-CVS + cd import-CVS + touch file1 file2 file3 + dotest_fail import-CVS-1 "$testcvs import CVS vtag rtag" \ +"$CPROG import: The word \`CVS' is reserved by CVS and may not be used +$CPROG \[import aborted\]: as a directory in a path or as a file name\." + mkdir sdir + mkdir sdir/CVS + touch sdir/CVS/file4 sdir/CVS/file5 sdir/file6 sdir/file7 + # Calling the imported directory import-CVS is dual purpose in the + # following test. It makes sure the path test which matched above + # wasn't too strict. + dotest_sort import-CVS-2 \ +"$testcvs import -I! -mimport import-CVS vtag rtag" \ +" + +I import-CVS/sdir/CVS +N import-CVS/file1 +N import-CVS/file2 +N import-CVS/file3 +N import-CVS/sdir/file6 +N import-CVS/sdir/file7 +No conflicts created by this import +$SPROG import: Importing $CVSROOT_DIRNAME/import-CVS/sdir" + + dokeep + cd .. + rm -r import-CVS + modify_repo rm -rf $CVSROOT_DIRNAME/import-CVS + ;; + + + + import-quirks) + # Short tests of quirky import behavior. + # + # For a list of other import tests with short descriptions, see the + # comment header of the "import" test. + mkdir import-quirks + cd import-quirks + touch file1 file2 file3 + + # CVS prior to 1.11.18 and 1.12.10 used to happily import to + # "branch 1.1", creating RCS archives with revisions like, + # "1.1..1". That double-dot is *not* a typo. + dotest_fail import-quirks-1 \ +"$testcvs import -b1.1. -mbad-bad-bad import-quirks VB RT" \ +"$CPROG \[import aborted\]: Only numeric branch specifications with two dots are +supported by import, not \`1\.1\.'\. For example: \`1\.1\.1'\." + + dotest_fail import-quirks-2 \ +"$testcvs import -b1.1.1.. -mbad-bad-bad import-quirks VB RT" \ +"$CPROG \[import aborted\]: Only numeric branch specifications with two dots are +supported by import, not \`1\.1\.1\.\.'\. For example: \`1\.1\.1'\." + + # Try a few odd numbers. This is hardly comprehensive. + dotest_sort import-quirks-2 \ +"$testcvs import -b10.10.101 -mthis-ones-ok import-quirks-2 VB RT" \ +" + +N import-quirks-2/file1 +N import-quirks-2/file2 +N import-quirks-2/file3 +No conflicts created by this import" + + dotest_sort import-quirks-3 \ +"$testcvs import -b2345678901.2345678901.2345678901 -mthis-ones-ok import-quirks-3 VB RT" \ +" + +N import-quirks-3/file1 +N import-quirks-3/file2 +N import-quirks-3/file3 +No conflicts created by this import" + + dotest_sort import-quirks-4 \ +"$testcvs import -b1.1.2 -mthis-ones-ok import-quirks-4 VB RT" \ +" + +N import-quirks-4/file1 +N import-quirks-4/file2 +N import-quirks-4/file3 +No conflicts created by this import" + + dokeep + cd .. + rm -r import-quirks + rm -rf $CVSROOT_DIRNAME/import-quirks-2 \ + $CVSROOT_DIRNAME/import-quirks-3 \ + $CVSROOT_DIRNAME/import-quirks-4 + ;; + + + + import-after-initial) + # Properly handle the case in which the first version of a + # file is created by a regular cvs add and commit, and there + # is a subsequent cvs import of the same file. cvs update with + # a date tag must resort to searching the vendor branch only if + # the initial version of the file was created at the same time + # as the initial version on the vendor branch. + + mkdir 1; cd 1 + module=x + + echo > unused-file + + # Create the module. + dotest import-after-initial-1 \ + "$testcvs -Q import -m. $module X Y" '' + + file=m + # Check it out and add a file. + dotest import-after-initial-2 "$testcvs -Q co $module" '' + cd $module + echo original > $file + dotest import-after-initial-3 "${testcvs} -Q add $file" "" + dotest import-after-initial-4 "$testcvs -Q ci -m. $file" + + # Delay a little so the following import isn't done in the same + # second as the preceding commit. + sleep 2 + + # Do the first import of $file *after* $file already has an + # initial version. + mkdir sub + cd sub + echo newer-via-import > $file + dotest import-after-initial-5 \ + "$testcvs -Q import -m. $module X Y2" '' + cd .. + + # Sleep a second so we're sure to be after the second of the import. + sleep 1 + + dotest import-after-initial-6 \ + "$testcvs -Q update -p -D now $file" 'original' + + dokeep + cd ../.. + rm -rf 1 + modify_repo rm -rf $CVSROOT_DIRNAME/$module + ;; + + + + branch-after-import) + # Test branching after an import via both cvs tag -b and + # cvs add to verify that the HEAD remains at 1.1.1.1 + # This was a FreeBSD bug documented at the URL: + # http://www.freebsd.org/cgi/query-pr.cgi?pr=4033 + + mkdir branch-after-import + cd branch-after-import + + # OK, first we get some sources from the NetMunger project, + # and import them into the 1.1.1 vendor branch. + mkdir imp-dir + cd imp-dir + echo 'OpenMunger sources' >file1 + echo 'OpenMunger sources' >file2 + dotest_sort branch-after-import-1 \ +"${testcvs} import -m add first-dir openmunger openmunger-1_0" \ +' + +N first-dir/file1 +N first-dir/file2 +No conflicts created by this import' + cd .. + + # Next checkout the new module + dotest branch-after-import-2 \ +"${testcvs} -q co first-dir" \ +'U first-dir/file1 +U first-dir/file2' + cd first-dir + # Branch tag the file1 and cvs add file2, + # the branch should remain the same in both cases + # such that a new import will not require a conflict + # resolution. + dotest branch-after-import-3 \ +"${testcvs} tag -b TESTTOTRON file1" \ +'T file1' + dotest branch-after-import-4 \ +"${testcvs} -q update -r TESTTOTRON" \ +"${SPROG} update: \`file2' is no longer in the repository" + + cp ../imp-dir/file2 . + dotest branch-after-import-5 \ +"${testcvs} add file2" \ +"${SPROG} add: scheduling file .file2. for addition on branch .TESTTOTRON. +${SPROG} add: use .${SPROG} commit. to add this file permanently" + + dotest branch-after-import-6 \ +"$testcvs commit -m cvs-add file2" \ +"$CVSROOT_DIRNAME/first-dir/file2,v <-- file2 +new revision: 1\.1\.1\.1\.2\.2; previous revision: 1\.1\.1\.1\.2\.1" + + dokeep + cd ../.. + rm -r branch-after-import + modify_repo rm -rf $CVSROOT_DIRNAME/first-dir + ;; + + + + join) + # Test doing joins which involve adding and removing files. + # Variety of scenarios (see list below), in the context of: + # * merge changes from T1 to T2 into the main line + # * merge changes from branch 'branch' into the main line + # * merge changes from branch 'branch' into branch 'br2'. + # See also binfile2, which does similar things with binary files. + # See also join2, which tests joining (and update -A) on only + # a single file, rather than a directory. + # See also rmadd2, which tests -j cases not involving branches + # (e.g. undoing a commit) + # See also join3, which tests some cases involving the greatest + # common ancestor. Here is a list of tests according to branch + # topology: + # + # --->bp---->trunk too many to mention + # \----->branch + # + # /----->branch1 + # --->bp---->trunk multibranch, multibranch2 + # \----->branch2 + # + # --->bp1----->bp2---->trunk join3 + # \->br1 \->br2 + # + # --->bp1----->trunk + # \----bp2---->branch branches + # \------>branch-of-branch + + # We check merging changes from T1 to T2 into the main line. + # Here are the interesting cases I can think of: + # 1) File added between T1 and T2, not on main line. + # File should be marked for addition. + # 2) File added between T1 and T2, also added on main line. + # Conflict. + # 3) File removed between T1 and T2, unchanged on main line. + # File should be marked for removal. + # 4) File removed between T1 and T2, modified on main line. + # If mod checked in, file should be marked for removal. + # If mod still in working directory, conflict. + # 5) File removed between T1 and T2, was never on main line. + # Nothing should happen. + # 6) File removed between T1 and T2, also removed on main line. + # Nothing should happen. + # 7) File not added between T1 and T2, added on main line. + # Nothing should happen. + # 8) File not modified between T1 and T2, removed on main line. + # Nothing should happen. + # 9) File modified between T1 and T2, removed on main line. + # Conflict. + # 10) File was never on branch, removed on main line. + # Nothing should happen. + + # We also check merging changes from a branch into the main + # line. Here are the interesting cases: + # 1) File added on branch, not on main line. + # File should be marked for addition. + # 2) File added on branch, also added on main line. + # Conflict. + # 3) File removed on branch, unchanged on main line. + # File should be marked for removal. + # 4) File removed on branch, modified on main line. + # Conflict. + # 5) File removed on branch, was never on main line. + # Nothing should happen. + # 6) File removed on branch, also removed on main line. + # Nothing should happen. + # 7) File added on main line, not added on branch. + # Nothing should happen. + # 8) File removed on main line, not modified on branch. + # Nothing should happen. + # 9) File modified on branch, removed on main line. + # Conflict. + # 10) File was never on branch, removed on main line. + # Nothing should happen. + + # In the tests below, fileN represents case N in the above + # lists. + + modify_repo mkdir $CVSROOT_DIRNAME/first-dir + mkdir 1 + cd 1 + dotest join-1 "$testcvs -q co first-dir" + + cd first-dir + + # Add two files. + echo 'first revision of file3' > file3 + echo 'first revision of file4' > file4 + echo 'first revision of file6' > file6 + echo 'first revision of file8' > file8 + echo 'first revision of file9' > file9 + dotest join-2 "${testcvs} add file3 file4 file6 file8 file9" \ +"${SPROG}"' add: scheduling file `file3'\'' for addition +'"${SPROG}"' add: scheduling file `file4'\'' for addition +'"${SPROG}"' add: scheduling file `file6'\'' for addition +'"${SPROG}"' add: scheduling file `file8'\'' for addition +'"${SPROG}"' add: scheduling file `file9'\'' for addition +'"${SPROG}"' add: use .'"${SPROG}"' commit. to add these files permanently' + + dotest join-3 "${testcvs} -q commit -m add" \ +"$CVSROOT_DIRNAME/first-dir/file3,v <-- file3 +initial revision: 1\.1 +$CVSROOT_DIRNAME/first-dir/file4,v <-- file4 +initial revision: 1\.1 +$CVSROOT_DIRNAME/first-dir/file6,v <-- file6 +initial revision: 1\.1 +$CVSROOT_DIRNAME/first-dir/file8,v <-- file8 +initial revision: 1\.1 +$CVSROOT_DIRNAME/first-dir/file9,v <-- file9 +initial revision: 1\.1" + + # Make a branch. + dotest join-4 "${testcvs} -q tag -b branch ." \ +'T file3 +T file4 +T file6 +T file8 +T file9' + + # Add file2, file7, and file10, modify file4, and remove + # file6, file8, and file9. + echo 'first revision of file2' > file2 + echo 'second revision of file4' > file4 + echo 'first revision of file7' > file7 + rm file6 file8 file9 + echo 'first revision of file10' > file10 + dotest join-5 "${testcvs} add file2 file7 file10" \ +"${SPROG}"' add: scheduling file `file2'\'' for addition +'"${SPROG}"' add: scheduling file `file7'\'' for addition +'"${SPROG}"' add: scheduling file `file10'\'' for addition +'"${SPROG}"' add: use .'"${SPROG}"' commit. to add these files permanently' + dotest join-6 "${testcvs} rm file6 file8 file9" \ +"${SPROG}"' remove: scheduling `file6'\'' for removal +'"${SPROG}"' remove: scheduling `file8'\'' for removal +'"${SPROG}"' remove: scheduling `file9'\'' for removal +'"${SPROG}"' remove: use .'"${SPROG}"' commit. to remove these files permanently' + dotest join-7 "${testcvs} -q ci -mx ." \ +"$CVSROOT_DIRNAME/first-dir/file10,v <-- file10 +initial revision: 1\.1 +$CVSROOT_DIRNAME/first-dir/file2,v <-- file2 +initial revision: 1\.1 +$CVSROOT_DIRNAME/first-dir/file4,v <-- file4 +new revision: 1\.2; previous revision: 1\.1 +$CVSROOT_DIRNAME/first-dir/file6,v <-- file6 +new revision: delete; previous revision: 1\.1 +$CVSROOT_DIRNAME/first-dir/file7,v <-- file7 +initial revision: 1\.1 +$CVSROOT_DIRNAME/first-dir/file8,v <-- file8 +new revision: delete; previous revision: 1\.1 +$CVSROOT_DIRNAME/first-dir/file9,v <-- file9 +new revision: delete; previous revision: 1\.1" + + # Remove file10 + dotest join-7a "${testcvs} rm -f file10" \ +"${SPROG}"' remove: scheduling `file10'\'' for removal +'"${SPROG}"' remove: use .'"${SPROG}"' commit. to remove this file permanently' + dotest join-7b "${testcvs} -q ci -mx ." \ +"$CVSROOT_DIRNAME/first-dir/file10,v <-- file10 +new revision: delete; previous revision: 1\.1" + + # Check out the branch. + cd ../.. + mkdir 2 + cd 2 + dotest join-8 "${testcvs} -q co -r branch first-dir" \ +'U first-dir/file3 +U first-dir/file4 +U first-dir/file6 +U first-dir/file8 +U first-dir/file9' + + cd first-dir + + # Modify the files on the branch, so that T1 is not an + # ancestor of the main line, and add file5 + echo 'first branch revision of file3' > file3 + echo 'first branch revision of file4' > file4 + echo 'first branch revision of file5' > file5 + echo 'first branch revision of file6' > file6 + echo 'first branch revision of file9' > file9 + dotest join-9 "${testcvs} add file5" \ +"${SPROG}"' add: scheduling file `file5'\'' for addition on branch `branch'\'' +'"${SPROG}"' add: use .'"${SPROG}"' commit. to add this file permanently' + dotest join-10 "${testcvs} -q ci -mx ." \ +"$CVSROOT_DIRNAME/first-dir/file3,v <-- file3 +new revision: 1\.1\.2\.1; previous revision: 1\.1 +$CVSROOT_DIRNAME/first-dir/file4,v <-- file4 +new revision: 1\.1\.2\.1; previous revision: 1\.1 +$CVSROOT_DIRNAME/first-dir/Attic/file5,v <-- file5 +new revision: 1\.1\.2\.1; previous revision: 1\.1 +$CVSROOT_DIRNAME/first-dir/Attic/file6,v <-- file6 +new revision: 1\.1\.2\.1; previous revision: 1\.1 +$CVSROOT_DIRNAME/first-dir/Attic/file9,v <-- file9 +new revision: 1\.1\.2\.1; previous revision: 1\.1" + + # Tag the current revisions on the branch. + dotest join-11 "${testcvs} -q tag T1 ." \ +'T file3 +T file4 +T file5 +T file6 +T file8 +T file9' + + # Add file1 and file2, modify file9, and remove the other files. + echo 'first branch revision of file1' > file1 + echo 'first branch revision of file2' > file2 + echo 'second branch revision of file9' > file9 + rm file3 file4 file5 file6 + dotest join-12 "${testcvs} add file1 file2" \ +"${SPROG}"' add: scheduling file `file1'\'' for addition on branch `branch'\'' +'"${SPROG}"' add: scheduling file `file2'\'' for addition on branch `branch'\'' +'"${SPROG}"' add: use .'"${SPROG}"' commit. to add these files permanently' + dotest join-13 "${testcvs} rm file3 file4 file5 file6" \ +"${SPROG}"' remove: scheduling `file3'\'' for removal +'"${SPROG}"' remove: scheduling `file4'\'' for removal +'"${SPROG}"' remove: scheduling `file5'\'' for removal +'"${SPROG}"' remove: scheduling `file6'\'' for removal +'"${SPROG}"' remove: use .'"${SPROG}"' commit. to remove these files permanently' + dotest join-14 "${testcvs} -q ci -mx ." \ +"$CVSROOT_DIRNAME/first-dir/Attic/file1,v <-- file1 +new revision: 1\.1\.2\.1; previous revision: 1\.1 +$CVSROOT_DIRNAME/first-dir/file2,v <-- file2 +new revision: 1\.1\.2\.2; previous revision: 1\.1\.2\.1 +$CVSROOT_DIRNAME/first-dir/file3,v <-- file3 +new revision: delete; previous revision: 1\.1\.2\.1 +$CVSROOT_DIRNAME/first-dir/file4,v <-- file4 +new revision: delete; previous revision: 1\.1\.2\.1 +$CVSROOT_DIRNAME/first-dir/Attic/file5,v <-- file5 +new revision: delete; previous revision: 1\.1\.2\.1 +$CVSROOT_DIRNAME/first-dir/Attic/file6,v <-- file6 +new revision: delete; previous revision: 1\.1\.2\.1 +$CVSROOT_DIRNAME/first-dir/Attic/file9,v <-- file9 +new revision: 1\.1\.2\.2; previous revision: 1\.1\.2\.1" + + # Tag the current revisions on the branch. + dotest join-15 "${testcvs} -q tag T2 ." \ +'T file1 +T file2 +T file8 +T file9' + + # Do a checkout with a merge. + cd ../.. + mkdir 3 + cd 3 + dotest join-16 "${testcvs} -q co -jT1 -jT2 first-dir" \ +"U first-dir/file1 +U first-dir/file2 +${SPROG} checkout: file first-dir/file2 exists, but has been added in revision T2 +U first-dir/file3 +${SPROG} checkout: scheduling \`first-dir/file3' for removal +U first-dir/file4 +${SPROG} checkout: scheduling \`first-dir/file4' for removal +U first-dir/file7 +${SPROG} checkout: file first-dir/file9 does not exist, but is present in revision T2" + + # Verify that the right changes have been scheduled. + cd first-dir + dotest join-17 "${testcvs} -q update" \ +'A file1 +R file3 +R file4' + + # Modify file4 locally, and do an update with a merge. + cd ../../1/first-dir + echo 'third revision of file4' > file4 + dotest join-18 "${testcvs} -q update -jT1 -jT2 ." \ +"U file1 +$SPROG update: file file2 exists, but has been added in revision T2 +$SPROG update: scheduling \`file3' for removal +M file4 +$SPROG update: file file4 is locally modified, but has been removed in revision T2 +$SPROG update: file file9 does not exist, but is present in revision T2" + + # Verify that the right changes have been scheduled. + dotest join-19 "${testcvs} -q update" \ +'A file1 +R file3 +M file4' + + # Do a checkout with a merge from a single revision. + + # FIXME: CVS currently gets this wrong. file2 has been + # added on both the branch and the main line, and so should + # be regarded as a conflict. However, given the way that + # CVS sets up the RCS file, there is no way to distinguish + # this case from the case of file2 having existed before the + # branch was made. This could be fixed by reserving + # a revision somewhere, perhaps 1.1, as an always dead + # revision which can be used as the source for files added + # on branches. + cd ../../3 + rm -r first-dir + dotest join-20 "${testcvs} -q co -jbranch first-dir" \ +"U first-dir/file1 +U first-dir/file2 +RCS file: ${CVSROOT_DIRNAME}/first-dir/file2,v +retrieving revision 1\.1 +retrieving revision 1\.1\.2\.2 +Merging differences between 1\.1 and 1\.1\.2\.2 into file2 +U first-dir/file3 +${SPROG} checkout: scheduling \`first-dir/file3' for removal +U first-dir/file4 +${SPROG} checkout: file first-dir/file4 has been modified, but has been removed in revision branch +U first-dir/file7 +${SPROG} checkout: file first-dir/file9 does not exist, but is present in revision branch" + + # Verify that the right changes have been scheduled. + # The M file2 line is a bug; see above join-20. + cd first-dir + dotest join-21 "${testcvs} -q update" \ +'A file1 +M file2 +R file3' + + # Checkout the main line again. + cd ../../1 + rm -r first-dir + dotest join-22 "${testcvs} -q co first-dir" \ +'U first-dir/file2 +U first-dir/file3 +U first-dir/file4 +U first-dir/file7' + + # Modify file4 locally, and do an update with a merge from a + # single revision. + # The file2 handling is a bug; see above join-20. + cd first-dir + echo 'third revision of file4' > file4 + dotest join-23 "${testcvs} -q update -jbranch ." \ +"U file1 +RCS file: ${CVSROOT_DIRNAME}/first-dir/file2,v +retrieving revision 1\.1 +retrieving revision 1\.1\.2\.2 +Merging differences between 1\.1 and 1\.1\.2\.2 into file2 +${SPROG} update: scheduling \`file3' for removal +M file4 +${SPROG} update: file file4 is locally modified, but has been removed in revision branch +${SPROG} update: file file9 does not exist, but is present in revision branch" + + # Verify that the right changes have been scheduled. + # The M file2 line is a bug; see above join-20 + dotest join-24 "${testcvs} -q update" \ +'A file1 +M file2 +R file3 +M file4' + + cd .. + + # Checkout the main line again and make a new branch which we + # merge to. + rm -r first-dir + dotest join-25 "${testcvs} -q co first-dir" \ +'U first-dir/file2 +U first-dir/file3 +U first-dir/file4 +U first-dir/file7' + cd first-dir + dotest join-26 "${testcvs} -q tag -b br2" \ +"T file2 +T file3 +T file4 +T file7" + dotest join-27 "${testcvs} -q update -r br2" "" + # The handling of file8 and file9 here look fishy to me. I don't + # see why it should be different from the case where we merge to + # the trunk (e.g. join-23). + dotest join-28 "${testcvs} -q update -j branch" \ +"U file1 +RCS file: ${CVSROOT_DIRNAME}/first-dir/file2,v +retrieving revision 1.1 +retrieving revision 1.1.2.2 +Merging differences between 1.1 and 1.1.2.2 into file2 +${SPROG} update: scheduling \`file3' for removal +${SPROG} update: file file4 has been modified, but has been removed in revision branch +U file8 +U file9" + # Verify that the right changes have been scheduled. + dotest join-29 "${testcvs} -q update" \ +"A file1 +M file2 +R file3 +A file8 +A file9" + + # Checkout the mainline again to try updating and merging between two + # branches in the same step + # this seems a likely scenario - the user finishes up on branch and + # updates to br2 and merges in the same step - and there was a bug + # once that if the file was removed in the update then it wouldn't be + # readded in the merge + cd .. + rm -r first-dir + dotest join-twobranch-1 "${testcvs} -q co -rbranch first-dir" \ +'U first-dir/file1 +U first-dir/file2 +U first-dir/file8 +U first-dir/file9' + cd first-dir + dotest join-twobranch-2 "${testcvs} -q update -rbr2 -jbranch" \ +"${SPROG} update: \`file1' is no longer in the repository +U file1 +U file2 +RCS file: ${CVSROOT_DIRNAME}/first-dir/file2,v +retrieving revision 1\.1 +retrieving revision 1\.1\.2\.2 +Merging differences between 1\.1 and 1\.1\.2\.2 into file2 +U file3 +${SPROG} update: scheduling \`file3' for removal +U file4 +${SPROG} update: file file4 has been modified, but has been removed in revision branch +U file7 +${SPROG} update: \`file8' is no longer in the repository +U file8 +${SPROG} update: \`file9' is no longer in the repository +U file9" + # Verify that the right changes have been scheduled. + dotest join-twobranch-3 "${testcvs} -q update" \ +"A file1 +M file2 +R file3 +A file8 +A file9" + + # Checkout the mainline again to try merging from the trunk + # to a branch. + cd .. + rm -r first-dir + dotest join-30 "${testcvs} -q co first-dir" \ +'U first-dir/file2 +U first-dir/file3 +U first-dir/file4 +U first-dir/file7' + cd first-dir + + # Tag the current revisions on the trunk. + dotest join-31 "${testcvs} -q tag T3 ." \ +'T file2 +T file3 +T file4 +T file7' + + # Modify file7. + echo 'second revision of file7' > file7 + dotest join-32 "${testcvs} -q ci -mx ." \ +"$CVSROOT_DIRNAME/first-dir/file7,v <-- file7 +new revision: 1\.2; previous revision: 1\.1" + + # And Tag again. + dotest join-33 "${testcvs} -q tag T4 ." \ +'T file2 +T file3 +T file4 +T file7' + + # Now update branch to T3. + cd ../../2/first-dir + dotest join-34 "${testcvs} -q up -jT3" \ +"${SPROG} update: file file4 does not exist, but is present in revision T3 +U file7" + + # Verify that the right changes have been scheduled. + dotest join-35 "${testcvs} -q update" \ +'A file7' + + # Now update to T4. + # This is probably a bug, although in this particular case it just + # happens to do the right thing; see above join-20. + dotest join-36 "${testcvs} -q up -j T3 -j T4" \ +"A file7 +RCS file: ${CVSROOT_DIRNAME}/first-dir/file7,v +retrieving revision 1\.1 +retrieving revision 1\.2 +Merging differences between 1\.1 and 1\.2 into file7" + + # Verify that the right changes have been scheduled. + dotest join-37 "${testcvs} -q update" \ +'A file7' + + dokeep + cd ../.. + rm -r 1 2 3 + modify_repo rm -rf $CVSROOT_DIRNAME/first-dir + ;; + + + + join2) + # More joining tests. + + # First the usual setup; create a directory first-dir, a file + # first-dir/file1, and a branch br1. + mkdir 1; cd 1 + dotest join2-1 "${testcvs} -q co -l ." '' + mkdir first-dir + dotest join2-2 "${testcvs} add first-dir" \ +"Directory ${CVSROOT_DIRNAME}/first-dir added to the repository" + cd first-dir + echo 'initial contents of file1' >file1 + dotest join2-3 "${testcvs} add file1" \ +"${SPROG} add: scheduling file .file1. for addition +${SPROG} add: use .${SPROG} commit. to add this file permanently" + dotest join2-4 "${testcvs} -q ci -m add" \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +initial revision: 1\.1" + dotest join2-5 "${testcvs} -q tag -b br1" "T file1" + dotest join2-6 "${testcvs} -q update -r br1" "" + echo 'modify on branch' >>file1 + touch bradd + dotest join2-6a "${testcvs} add bradd" \ +"${SPROG} add: scheduling file .bradd. for addition on branch .br1. +${SPROG} add: use .${SPROG} commit. to add this file permanently" + dotest join2-7 "${testcvs} -q ci -m modify" \ +"$CVSROOT_DIRNAME/first-dir/Attic/bradd,v <-- bradd +new revision: 1\.1\.2\.1; previous revision: 1\.1 +$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +new revision: 1\.1\.2\.1; previous revision: 1\.1" + + # Here is the unusual/pathological part. We switch back to + # the trunk *for file1 only*, not for the whole directory. + dotest join2-8 "${testcvs} -q update -A file1" '[UP] file1' + dotest join2-9 "${testcvs} -q status file1" \ +"=================================================================== +File: file1 Status: Up-to-date + + Working revision: 1\.1.* + Repository revision: 1\.1 ${CVSROOT_DIRNAME}/first-dir/file1,v + Commit Identifier: ${commitid} + Sticky Tag: (none) + Sticky Date: (none) + Sticky Options: (none)" + dotest join2-10 "cat CVS/Tag" "Tbr1" + + dotest join2-11 "${testcvs} -q update -j br1 file1" \ +"RCS file: ${CVSROOT_DIRNAME}/first-dir/file1,v +retrieving revision 1\.1 +retrieving revision 1\.1\.2\.1 +Merging differences between 1\.1 and 1\.1\.2\.1 into file1" + dotest join2-12 "cat file1" "initial contents of file1 +modify on branch" + # We should have no sticky tag on file1 + dotest join2-13 "${testcvs} -q status file1" \ +"=================================================================== +File: file1 Status: Locally Modified + + Working revision: 1\.1.* + Repository revision: 1\.1 ${CVSROOT_DIRNAME}/first-dir/file1,v + Commit Identifier: ${commitid} + Sticky Tag: (none) + Sticky Date: (none) + Sticky Options: (none)" + dotest join2-14 "cat CVS/Tag" "Tbr1" + # And the checkin should go to the trunk + dotest join2-15 "${testcvs} -q ci -m modify file1" \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +new revision: 1\.2; previous revision: 1\.1" + + # OK, the above is all well and good and has worked for some + # time. Now try the case where the file had been added on + # the branch. + dotest join2-16 "${testcvs} -q update -r br1" "[UP] file1" + # The workaround is to update the whole directory. + # The non-circumvented version won't work. The reason is that + # update removes the entry from CVS/Entries, so of course we get + # the tag from CVS/Tag and not Entries. I suppose maybe + # we could invent some new format in Entries which would handle + # this, but doing so, and handling it properly throughout + # CVS, would be a lot of work and I'm not sure this case justifies + # it. + dotest join2-17-circumvent "${testcvs} -q update -A" \ +"${SPROG} update: \`bradd' is no longer in the repository +[UP] file1" +: dotest join2-17 "${testcvs} -q update -A bradd" \ +"${SPROG} update: warning: \`bradd' is not (any longer) pertinent" + dotest join2-18 "${testcvs} -q update -j br1 bradd" "U bradd" + dotest join2-19 "${testcvs} -q status bradd" \ +"=================================================================== +File: bradd Status: Locally Added + + Working revision: New file! + Repository revision: 1\.1 ${CVSROOT_DIRNAME}/first-dir/Attic/bradd,v + Commit Identifier: ${commitid} + Sticky Tag: (none) + Sticky Date: (none) + Sticky Options: (none)" + dotest join2-20 "${testcvs} -q ci -m modify bradd" \ +"$CVSROOT_DIRNAME/first-dir/bradd,v <-- bradd +new revision: 1\.2; previous revision: 1\.1" + + dokeep + cd ../.. + rm -r 1 + modify_repo rm -rf $CVSROOT_DIRNAME/first-dir + ;; + + + + join3) + # See "join" for a list of other joining/branching tests. + # First the usual setup; create a directory first-dir, a file + # first-dir/file1, and a branch br1. + mkdir 1; cd 1 + dotest join3-1 "${testcvs} -q co -l ." '' + mkdir first-dir + dotest join3-2 "${testcvs} add first-dir" \ +"Directory ${CVSROOT_DIRNAME}/first-dir added to the repository" + cd first-dir + echo 'initial contents of file1' >file1 + dotest join3-3 "${testcvs} add file1" \ +"${SPROG} add: scheduling file .file1. for addition +${SPROG} add: use .${SPROG} commit. to add this file permanently" + dotest join3-4 "${testcvs} -q ci -m add" \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +initial revision: 1\.1" + dotest join3-5 "${testcvs} -q tag -b br1" "T file1" + dotest join3-6 "${testcvs} -q update -r br1" "" + echo 'br1:line1' >>file1 + dotest join3-7 "${testcvs} -q ci -m modify" \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +new revision: 1\.1\.2\.1; previous revision: 1\.1" + + # Now back to the trunk for: + # another revision and another branch for file1. + # add file2, which will exist on trunk and br2 but not br1. + dotest join3-8 "${testcvs} -q update -A" "[UP] file1" + echo 'trunk:line1' > file2 + dotest join3-8a "${testcvs} add file2" \ +"${SPROG} add: scheduling file .file2. for addition +${SPROG} add: use .${SPROG} commit. to add this file permanently" + echo 'trunk:line1' >>file1 + dotest join3-9 "${testcvs} -q ci -m modify" \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +new revision: 1\.2; previous revision: 1\.1 +$CVSROOT_DIRNAME/first-dir/file2,v <-- file2 +initial revision: 1\.1" + dotest join3-10 "${testcvs} -q tag -b br2" "T file1 +T file2" + + # Before we actually have any revision on br2, let's try a join + dotest join3-11 "${testcvs} -q update -r br1" "[UP] file1 +${SPROG} update: \`file2' is no longer in the repository" + dotest join3-12 "${testcvs} -q update -j br2" \ +"RCS file: ${CVSROOT_DIRNAME}/first-dir/file1,v +retrieving revision 1\.1 +retrieving revision 1\.2 +Merging differences between 1\.1 and 1\.2 into file1 +rcsmerge: warning: conflicts during merge +U file2" + dotest join3-13 "cat file1" \ +"initial contents of file1 +[<]<<<<<< file1 +br1:line1 +[=]====== +trunk:line1 +[>]>>>>>> 1\.2" + rm file1 + + # OK, we'll try the same thing with a revision on br2. + dotest join3-14 "${testcvs} -q update -r br2 file1" \ +"${SPROG} update: warning: \`file1' was lost +U file1" "U file1" + echo 'br2:line1' >>file1 + dotest join3-15 "${testcvs} -q ci -m modify file1" \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +new revision: 1\.2\.2\.1; previous revision: 1\.2" + + # OK, now we can join br2 to br1 + dotest join3-16 "${testcvs} -q update -r br1 file1" "[UP] file1" + # It may seem odd, to merge a higher branch into a lower + # branch, but in fact CVS defines the ancestor as 1.1 + # and so it merges both the 1.1->1.2 and 1.2->1.2.2.1 changes. + # This seems like a reasonably plausible behavior. + dotest join3-17 "${testcvs} -q update -j br2 file1" \ +"RCS file: ${CVSROOT_DIRNAME}/first-dir/file1,v +retrieving revision 1\.1 +retrieving revision 1\.2\.2\.1 +Merging differences between 1\.1 and 1\.2\.2\.1 into file1 +rcsmerge: warning: conflicts during merge" + dotest join3-18 "cat file1" \ +"initial contents of file1 +[<]<<<<<< file1 +br1:line1 +[=]====== +trunk:line1 +br2:line1 +[>]>>>>>> 1\.2\.2\.1" + + dokeep + cd ../.. + rm -r 1 + modify_repo rm -rf $CVSROOT_DIRNAME/first-dir + ;; + + + + join4) + # Like join, but with local (uncommitted) modifications. + + modify_repo mkdir $CVSROOT_DIRNAME/first-dir + mkdir 1 + cd 1 + dotest join4-1 "${testcvs} -q co first-dir" '' + + cd first-dir + + # Add two files. + echo 'first revision of file3' > file3 + echo 'first revision of file4' > file4 + echo 'first revision of file6' > file6 + echo 'first revision of file8' > file8 + echo 'first revision of file9' > file9 + dotest join4-2 "${testcvs} add file3 file4 file6 file8 file9" \ +"${SPROG}"' add: scheduling file `file3'\'' for addition +'"${SPROG}"' add: scheduling file `file4'\'' for addition +'"${SPROG}"' add: scheduling file `file6'\'' for addition +'"${SPROG}"' add: scheduling file `file8'\'' for addition +'"${SPROG}"' add: scheduling file `file9'\'' for addition +'"${SPROG}"' add: use .'"${SPROG}"' commit. to add these files permanently' + + dotest join4-3 "${testcvs} -q commit -m add" \ +"$CVSROOT_DIRNAME/first-dir/file3,v <-- file3 +initial revision: 1\.1 +$CVSROOT_DIRNAME/first-dir/file4,v <-- file4 +initial revision: 1\.1 +$CVSROOT_DIRNAME/first-dir/file6,v <-- file6 +initial revision: 1\.1 +$CVSROOT_DIRNAME/first-dir/file8,v <-- file8 +initial revision: 1\.1 +$CVSROOT_DIRNAME/first-dir/file9,v <-- file9 +initial revision: 1\.1" + + # Make a branch. + dotest join4-4 "${testcvs} -q tag -b branch ." \ +'T file3 +T file4 +T file6 +T file8 +T file9' + + # Add file10 + echo 'first revision of file10' > file10 + dotest join4-7a "${testcvs} add file10" \ +"${SPROG}"' add: scheduling file `file10'\'' for addition +'"${SPROG}"' add: use .'"${SPROG}"' commit. to add this file permanently' + dotest join4-7b "${testcvs} -q ci -mx ." \ +"$CVSROOT_DIRNAME/first-dir/file10,v <-- file10 +initial revision: 1\.1" + + # Add file2 and file7, modify file4, and remove + # file6, file8, file9, and file10. + echo 'first revision of file2' > file2 + echo 'second revision of file4' > file4 + echo 'first revision of file7' > file7 + rm file6 file8 file9 file10 + dotest join4-5 "${testcvs} add file2 file7" \ +"${SPROG}"' add: scheduling file `file2'\'' for addition +'"${SPROG}"' add: scheduling file `file7'\'' for addition +'"${SPROG}"' add: use .'"${SPROG}"' commit. to add these files permanently' + dotest join4-6 "${testcvs} rm file6 file8 file9 file10" \ +"${SPROG}"' remove: scheduling `file6'\'' for removal +'"${SPROG}"' remove: scheduling `file8'\'' for removal +'"${SPROG}"' remove: scheduling `file9'\'' for removal +'"${SPROG}"' remove: scheduling `file10'\'' for removal +'"${SPROG}"' remove: use .'"${SPROG}"' commit. to remove these files permanently' + + # Check out the branch. + cd ../.. + mkdir 2 + cd 2 + dotest join4-8 "${testcvs} -q co -r branch first-dir" \ +'U first-dir/file3 +U first-dir/file4 +U first-dir/file6 +U first-dir/file8 +U first-dir/file9' + + cd first-dir + + # Modify the files on the branch, so that T1 is not an + # ancestor of the main line, and add file5 + echo 'first branch revision of file3' > file3 + echo 'first branch revision of file4' > file4 + echo 'first branch revision of file5' > file5 + echo 'first branch revision of file6' > file6 + echo 'first branch revision of file9' > file9 + dotest join4-9 "${testcvs} add file5" \ +"${SPROG}"' add: scheduling file `file5'\'' for addition on branch `branch'\'' +'"${SPROG}"' add: use .'"${SPROG}"' commit. to add this file permanently' + dotest join4-10 "${testcvs} -q ci -mx ." \ +"$CVSROOT_DIRNAME/first-dir/file3,v <-- file3 +new revision: 1\.1\.2\.1; previous revision: 1\.1 +$CVSROOT_DIRNAME/first-dir/file4,v <-- file4 +new revision: 1\.1\.2\.1; previous revision: 1\.1 +$CVSROOT_DIRNAME/first-dir/Attic/file5,v <-- file5 +new revision: 1\.1\.2\.1; previous revision: 1\.1 +$CVSROOT_DIRNAME/first-dir/file6,v <-- file6 +new revision: 1\.1\.2\.1; previous revision: 1\.1 +$CVSROOT_DIRNAME/first-dir/file9,v <-- file9 +new revision: 1\.1\.2\.1; previous revision: 1\.1" + + # Tag the current revisions on the branch. + dotest join4-11 "${testcvs} -q tag T1 ." \ +'T file3 +T file4 +T file5 +T file6 +T file8 +T file9' + + # Add file1 and file2, modify file9, and remove the other files. + echo 'first branch revision of file1' > file1 + echo 'first branch revision of file2' > file2 + echo 'second branch revision of file9' > file9 + rm file3 file4 file5 file6 + dotest join4-12 "${testcvs} add file1 file2" \ +"${SPROG}"' add: scheduling file `file1'\'' for addition on branch `branch'\'' +'"${SPROG}"' add: scheduling file `file2'\'' for addition on branch `branch'\'' +'"${SPROG}"' add: use .'"${SPROG}"' commit. to add these files permanently' + dotest join4-13 "${testcvs} rm file3 file4 file5 file6" \ +"${SPROG}"' remove: scheduling `file3'\'' for removal +'"${SPROG}"' remove: scheduling `file4'\'' for removal +'"${SPROG}"' remove: scheduling `file5'\'' for removal +'"${SPROG}"' remove: scheduling `file6'\'' for removal +'"${SPROG}"' remove: use .'"${SPROG}"' commit. to remove these files permanently' + dotest join4-14 "${testcvs} -q ci -mx ." \ +"$CVSROOT_DIRNAME/first-dir/Attic/file1,v <-- file1 +new revision: 1\.1\.2\.1; previous revision: 1\.1 +$CVSROOT_DIRNAME/first-dir/Attic/file2,v <-- file2 +new revision: 1\.1\.2\.1; previous revision: 1\.1 +$CVSROOT_DIRNAME/first-dir/file3,v <-- file3 +new revision: delete; previous revision: 1\.1\.2\.1 +$CVSROOT_DIRNAME/first-dir/file4,v <-- file4 +new revision: delete; previous revision: 1\.1\.2\.1 +$CVSROOT_DIRNAME/first-dir/Attic/file5,v <-- file5 +new revision: delete; previous revision: 1\.1\.2\.1 +$CVSROOT_DIRNAME/first-dir/file6,v <-- file6 +new revision: delete; previous revision: 1\.1\.2\.1 +$CVSROOT_DIRNAME/first-dir/file9,v <-- file9 +new revision: 1\.1\.2\.2; previous revision: 1\.1\.2\.1" + + # Tag the current revisions on the branch. + dotest join4-15 "${testcvs} -q tag T2 ." \ +'T file1 +T file2 +T file8 +T file9' + + # Modify file4 locally, and do an update with a merge. + cd ../../1/first-dir + echo 'third revision of file4' > file4 + dotest join4-18 "${testcvs} -q update -jT1 -jT2 ." \ +"U file1 +R file10 +A file2 +${SPROG} update: file file2 exists, but has been added in revision T2 +${SPROG} update: scheduling \`file3' for removal +M file4 +${SPROG} update: file file4 is locally modified, but has been removed in revision T2 +R file6 +A file7 +R file8 +R file9 +${SPROG} update: file file9 does not exist, but is present in revision T2" + + # Verify that the right changes have been scheduled. + dotest join4-19 "${testcvs} -q update" \ +'A file1 +R file10 +A file2 +R file3 +M file4 +R file6 +A file7 +R file8 +R file9' + + dokeep + cd ../.. + rm -r 1 2 + modify_repo rm -rf $CVSROOT_DIRNAME/first-dir + ;; + + + + join5) + # This test verifies that CVS can handle filenames starting with a + # dash (`-') properly. What used to happen was that CVS handled it + # just fine, until it went to pass them as arguments to the diff + # library, at which point it neglected to pass `--' before the file + # list, causing the diff library to attempt to interpret the file + # name as an argument. + mkdir join5; cd join5 + mkdir 1; cd 1 + dotest join5-init-1 "${testcvs} -Q co -l ." + mkdir join5 + dotest join5-init-2 "${testcvs} -Q add join5" + cd join5 + echo "there once was a file from harrisburg" >-file + echo "who's existance it seems was quiteabsurd" >>-file + dotest join5-init-3 "${testcvs} -Q add -- -file" + dotest join5-init-4 "${testcvs} -q ci -minitial" \ +"$CVSROOT_DIRNAME/join5/-file,v <-- -file +initial revision: 1\.1" + cd ../.. + + mkdir 2; cd 2 + dotest join5-init-5 "${testcvs} -Q co join5" + cd join5 + echo "it tested for free" >>-file + echo "when paid it should be" >>-file + dotest join5-init-4 "${testcvs} -q ci -msecond" \ +"$CVSROOT_DIRNAME/join5/-file,v <-- -file +new revision: 1\.2; previous revision: 1\.1" + cd ../.. + + cd 1/join5 + echo "but maybe it could charge bytheword" >>-file + # This is the test that used to spew complaints from diff3: + dotest join5 "${testcvs} up" \ +"${SPROG} update: Updating \. +RCS file: ${CVSROOT_DIRNAME}/join5/-file,v +retrieving revision 1\.1 +retrieving revision 1\.2 +Merging differences between 1\.1 and 1\.2 into -file +rcsmerge: warning: conflicts during merge +${SPROG} update: conflicts found in -file +C -file" + + dokeep + cd ../../.. + rm -r join5 + modify_repo rm -rf $CVSROOT_DIRNAME/join5 + ;; + + + + join6) + mkdir join6; cd join6 + mkdir 1; cd 1 + dotest join6-init-1 "${testcvs} -Q co -l ." + mkdir join6 + dotest join6-init-2 "${testcvs} -Q add join6" + cd join6 + echo aaa >temp.txt + echo bbb >>temp.txt + echo ccc >>temp.txt + dotest join6-1 "${testcvs} -Q add temp.txt" + dotest join6-2 "${testcvs} -q commit -minitial temp.txt" \ +"$CVSROOT_DIRNAME/join6/temp\.txt,v <-- temp\.txt +initial revision: 1\.1" + cp temp.txt temp2.txt + echo ddd >>temp.txt + dotest join6-3 "${testcvs} -q commit -madd temp.txt" \ +"$CVSROOT_DIRNAME/join6/temp.txt,v <-- temp\.txt +new revision: 1\.2; previous revision: 1\.1" + + # The case where the merge target is up-to-date and its base revision + # matches the second argument to -j: CVS doesn't bother attempting + # the merge since it already knows that the target contains the + # change. + dotest join6-3.3 "${testcvs} update -j1.1 -j1.2 temp.txt" \ +"temp\.txt already contains the differences between 1\.1 and 1\.2" + dotest join6-3.4 "${testcvs} diff temp.txt" "" + + # The case where the merge target is modified but already contains + # the change. + echo bbb >temp.txt + echo ccc >>temp.txt + echo ddd >>temp.txt + dotest join6-3.5 "${testcvs} update -j1.1 -j1.2 temp.txt" \ +"M temp\.txt +RCS file: ${CVSROOT_DIRNAME}/join6/temp\.txt,v +retrieving revision 1\.1 +retrieving revision 1\.2 +Merging differences between 1\.1 and 1\.2 into temp\.txt +temp\.txt already contains the differences between 1\.1 and 1\.2" + dotest_fail join6-3.6 "${testcvs} diff temp.txt" \ +"Index: temp\.txt +=================================================================== +RCS file: ${CVSROOT_DIRNAME}/join6/temp\.txt,v +retrieving revision 1\.2 +diff -r1\.2 temp.txt +1d0 +< aaa" + + cp temp2.txt temp.txt + dotest_fail join6-4 "${testcvs} diff temp.txt" \ +"Index: temp.txt +=================================================================== +RCS file: ${CVSROOT_DIRNAME}/join6/temp\.txt,v +retrieving revision 1\.2 +diff -r1\.2 temp\.txt +4d3 +< ddd" + + dotest join6-5 "${testcvs} update -j1.1 -j1.2 temp.txt" \ +"M temp\.txt +RCS file: ${CVSROOT_DIRNAME}/join6/temp\.txt,v +retrieving revision 1\.1 +retrieving revision 1\.2 +Merging differences between 1\.1 and 1\.2 into temp\.txt" + dotest join6-6 "${testcvs} diff temp.txt" "" + mv temp.txt temp3.txt + dotest join6-7 "sed 's/ddd/dddd/' < temp3.txt > temp.txt" "" + dotest join6-8 "${testcvs} update -j1.1 -j1.2 temp.txt" \ +"M temp\.txt +RCS file: ${CVSROOT_DIRNAME}/join6/temp\.txt,v +retrieving revision 1\.1 +retrieving revision 1\.2 +Merging differences between 1\.1 and 1\.2 into temp\.txt +rcsmerge: warning: conflicts during merge" + dotest_fail join6-9 "${testcvs} diff temp.txt" \ +"Index: temp\.txt +=================================================================== +RCS file: ${CVSROOT_DIRNAME}/join6/temp.txt,v +retrieving revision 1\.2 +diff -r1\.2 temp\.txt +3a4,6 +> <<<<<<< temp\.txt +> dddd +> ======= +4a8 +> >>>>>>> 1\.2" + cp temp2.txt temp.txt + dotest join6-10 "${testcvs} -q ci -m del temp.txt" \ +"$CVSROOT_DIRNAME/join6/temp.txt,v <-- temp\.txt +new revision: 1\.3; previous revision: 1\.2" + cp temp3.txt temp.txt + dotest_fail join6-11 "${testcvs} diff temp.txt" \ +"Index: temp\.txt +=================================================================== +RCS file: ${CVSROOT_DIRNAME}/join6/temp.txt,v +retrieving revision 1\.3 +diff -r1\.3 temp\.txt +3a4 +> ddd" + dotest join6-12 "${testcvs} update -j1.2 -j1.3 temp.txt" \ +"M temp\.txt +RCS file: ${CVSROOT_DIRNAME}/join6/temp\.txt,v +retrieving revision 1\.2 +retrieving revision 1\.3 +Merging differences between 1\.2 and 1\.3 into temp\.txt" + dotest join6-13 "${testcvs} diff temp.txt" "" + + # The case where the merge target wasn't created until after the + # first tag was applied + rm temp2.txt temp3.txt + dotest join6-20 "${testcvs} -q tag -r1.1 t1" \ +"T temp.txt" + echo xxx >temp2.txt + dotest join6-21 "${testcvs} -Q add temp2.txt" + dotest join6-22 "${testcvs} -q ci -m." \ +"$CVSROOT_DIRNAME/join6/temp2\.txt,v <-- temp2\.txt +initial revision: 1\.1" + dotest join6-23 "${testcvs} -q tag t2" \ +"T temp.txt +T temp2.txt" + echo xxx >>temp.txt + dotest join6-24 "${testcvs} -q ci -m." \ +"$CVSROOT_DIRNAME/join6/temp.txt,v <-- temp\.txt +new revision: 1\.4; previous revision: 1\.3" + dotest join6-25 "${testcvs} -q up -jt1 -jt2" \ +"RCS file: ${CVSROOT_DIRNAME}/join6/temp.txt,v +retrieving revision 1\.1 +retrieving revision 1\.3 +Merging differences between 1\.1 and 1\.3 into temp.txt +temp.txt already contains the differences between 1\.1 and 1\.3 +temp2.txt already contains the differences between creation and 1\.1" + + # Now for my next trick: delete the file, recreate it, and + # try to merge + dotest join6-30 "${testcvs} -q rm -f temp2.txt" \ +"${SPROG} remove: use .${SPROG} commit. to remove this file permanently" + dotest join6-31 "${testcvs} -q ci -m. temp2.txt" \ +"$CVSROOT_DIRNAME/join6/temp2\.txt,v <-- temp2\.txt +new revision: delete; previous revision: 1\.1" + echo new >temp2.txt + # FIXCVS: Local and remote really shouldn't be different and there + # really shouldn't be two different status lines for temp2.txt + if $remote; then + dotest_fail join6-32 "${testcvs} -q up -jt1 -jt2" \ +"? temp2\.txt +RCS file: ${CVSROOT_DIRNAME}/join6/temp.txt,v +retrieving revision 1\.1 +retrieving revision 1\.3 +Merging differences between 1\.1 and 1\.3 into temp.txt +temp.txt already contains the differences between 1\.1 and 1\.3 +$CPROG update: move away .\./temp2\.txt.; it is in the way +C temp2\.txt" + else + dotest join6-32 "${testcvs} -q up -jt1 -jt2" \ +"RCS file: ${CVSROOT_DIRNAME}/join6/temp.txt,v +retrieving revision 1\.1 +retrieving revision 1\.3 +Merging differences between 1\.1 and 1\.3 into temp.txt +temp.txt already contains the differences between 1\.1 and 1\.3 +${SPROG} update: use .${SPROG} add. to create an entry for .temp2\.txt. +U temp2\.txt +? temp2\.txt" + fi + + dokeep + cd ../../.. + rm -r join6 + modify_repo rm -rf $CVSROOT_DIRNAME/join6 + ;; + + + + join7) + # This test deals with joins that happen with the -n switch + mkdir join7; cd join7 + mkdir impdir; cd impdir + echo aaa >temp.txt + echo bbb >>temp.txt + echo ccc >>temp.txt + dotest join7-1 \ +"${testcvs} -Q import -minitial join7 vendor vers-1" \ +"" + cd .. + dotest join7-2 "${testcvs} -Q co join7" "" + cd join7 + echo ddd >> temp.txt + dotest join7-3 "${testcvs} -Q ci -madded-line temp.txt" "" + cd ../impdir + echo aaaa >temp.txt + echo bbbb >>temp.txt + echo ccc >>temp.txt + echo eee >>temp.txt + dotest join7-4 \ +"${testcvs} -Q import -minitial join7 vendor vers-2" \ +"" + cd ../join7 + dotest join7-5 \ +"${testcvs} -n update -jvers-1 -jvers-2 temp.txt" \ +"RCS file: $CVSROOT_DIRNAME/join7/temp.txt,v +retrieving revision 1\.1\.1\.1 +retrieving revision 1\.1\.1\.2 +Merging differences between 1\.1\.1\.1 and 1\.1\.1\.2 into temp.txt +rcsmerge: warning: conflicts during merge" + touch temp.txt + dotest join7-6 "${testcvs} -n update -jvers-1 -jvers-2 temp.txt" \ +"RCS file: $CVSROOT_DIRNAME/join7/temp.txt,v +retrieving revision 1\.1\.1\.1 +retrieving revision 1\.1\.1\.2 +Merging differences between 1\.1\.1\.1 and 1\.1\.1\.2 into temp.txt +rcsmerge: warning: conflicts during merge" \ +"RCS file: $CVSROOT_DIRNAME/join7/temp.txt,v +retrieving revision 1\.1\.1\.1 +retrieving revision 1\.1\.1\.2 +Merging differences between 1\.1\.1\.1 and 1\.1\.1\.2 into temp.txt +rcsmerge: warning: conflicts during merge" + + dokeep + cd ../.. + rm -r join7 + modify_repo rm -rf $CVSROOT_DIRNAME/join7 + ;; + + + + join-readonly-conflict) + # Previously, only tests 1 & 11 were being tested. I added the + # intermediate dotest's to try and diagnose a different failure + # + # Demonstrate that cvs-1.9.29 can fail on 2nd and subsequent + # conflict-evoking join attempts. + # Even with that version of CVS, This test failed only in + # client-server mode, and would have been noticed in normal + # operation only for files that were read-only (either due to + # use of cvs' global -r option, setting the CVSREAD envvar, + # or use of watch lists). + mkdir join-readonly-conflict; cd join-readonly-conflict + dotest join-readonly-conflict-1 "$testcvs -q co -l ." '' + module=join-readonly-conflict + mkdir $module + $testcvs -q add $module >>$LOGFILE 2>&1 + cd $module + + file=m + echo trunk > $file + dotest join-readonly-conflict-2 "$testcvs -Q add $file" '' + + dotest join-readonly-conflict-3 "$testcvs -q ci -m . $file" \ +"$CVSROOT_DIRNAME/$module/$file,v <-- $file +initial revision: 1\.1" + + dotest join-readonly-conflict-4 "$testcvs tag -b B $file" "T $file" + dotest join-readonly-conflict-5 "$testcvs -q update -rB $file" '' + echo branch B > $file + dotest join-readonly-conflict-6 "$testcvs -q ci -m . $file" \ +"$CVSROOT_DIRNAME/$module/$file,v <-- $file +new revision: 1\.1\.2\.1; previous revision: 1\.1" + + rm $file + dotest join-readonly-conflict-7 "$testcvs -Q update -A $file" '' + # Make sure $file is read-only. This can happen more realistically + # via patch -- which could be used to apply a delta, yet would + # preserve a file's read-only permissions. + echo conflict > $file; chmod u-w $file + dotest join-readonly-conflict-8 "$testcvs update -r B $file" \ +"RCS file: $CVSROOT_DIRNAME/$module/$file,v +retrieving revision 1\.1 +retrieving revision 1\.1\.2\.1 +Merging differences between 1\.1 and 1\.1\.2\.1 into $file +rcsmerge: warning: conflicts during merge +${SPROG} update: conflicts found in $file +C $file" + + # restore to the trunk + rm -f $file + dotest join-readonly-conflict-9 "$testcvs -Q update -A $file" '' + + # This one would fail because cvs couldn't open the existing + # (and read-only) .# file for writing. + echo conflict > $file + + # verify that the backup file is not writable + if test -w ".#$file.1.1"; then + fail "join-readonly-conflict-10 : .#$file.1.1 is writable" + else + pass "join-readonly-conflict-10" + fi + dotest join-readonly-conflict-11 "$testcvs update -r B $file" \ +"RCS file: $CVSROOT_DIRNAME/$module/$file,v +retrieving revision 1\.1 +retrieving revision 1\.1\.2\.1 +Merging differences between 1\.1 and 1\.1\.2\.1 into $file +rcsmerge: warning: conflicts during merge +${SPROG} update: conflicts found in $file +C m" + + dokeep + cd ../.. + rm -r join-readonly-conflict + modify_repo rm -rf $CVSROOT_DIRNAME/$module + ;; + + + + join-admin) + mkdir 1; cd 1 + dotest join-admin-0-1 "$testcvs -q co -l ." + module=x + mkdir $module + dotest join-admin-0-2 "$testcvs -q add $module" \ +"Directory $CVSROOT_DIRNAME/$module added to the repository" + cd $module + + # Create a file so applying the first tag works. + echo foo > a + dotest join-admin-0-3 "$testcvs -Q add a" '' + dotest join-admin-0-4 "$testcvs -Q ci -m. a" '' + + dotest join-admin-0-5 "$testcvs -Q tag -b B" '' + dotest join-admin-0-6 "$testcvs -Q tag -b M1" '' + echo '$''Id$' > b + dotest join-admin-0-7 "$testcvs -Q add b" '' + dotest join-admin-0-8 "$testcvs -Q ci -m. b" '' + dotest join-admin-0-9 "$testcvs -Q tag -b M2" '' + + dotest join-admin-0-10 "$testcvs -Q update -r B" '' + dotest join-admin-0-11 "$testcvs -Q update -kk -jM1 -jM2" '' + dotest join-admin-0-12 "$testcvs -Q ci -m. b" '' + + dotest join-admin-0-13 "$testcvs -Q update -A" '' + + # Verify that the -kk flag from the update did not + # propagate to the repository. + dotest join-admin-1 "$testcvs status b" \ +"=================================================================== +File: b Status: Up-to-date + + Working revision: 1\.1.* + Repository revision: 1\.1 ${CVSROOT_DIRNAME}/x/b,v + Commit Identifier: ${commitid} + Sticky Tag: (none) + Sticky Date: (none) + Sticky Options: (none)" + + dokeep + cd ../.. + rm -rf 1 + modify_repo rm -rf $CVSROOT_DIRNAME/$module + ;; + + + + join-admin-2) + # Show that when a merge (via update -kk -jtag1 -jtag2) first + # removes a file, then modifies another containing an $Id...$ line, + # the resulting file contains the unexpanded `$Id.$' string, as + # -kk requires. + mkdir 1; cd 1 + dotest join-admin-2-1 "$testcvs -q co -l ." '' + module=x + mkdir $module + dotest join-admin-2-2 "$testcvs -q add $module" \ +"Directory ${CVSROOT_DIRNAME}/x added to the repository" + cd $module + + # Create a file so applying the first tag works. + echo '$''Id$' > e0 + cp e0 e + dotest join-admin-2-3 "$testcvs -Q add e" + dotest join-admin-2-4 "$testcvs -Q ci -m. e" + + dotest join-admin-2-5 "$testcvs -Q tag -b T" '' "${QUESTION} e0" + dotest join-admin-2-6 "$testcvs -Q update -r T" '' "${QUESTION} e0" + cp e0 e + dotest join-admin-2-7 "$testcvs -Q ci -m. e" + + dotest join-admin-2-8 "$testcvs -Q update -A" '' "${QUESTION} e0" + dotest join-admin-2-9 "$testcvs -Q tag -b M1" '' "${QUESTION} e0" + + echo '$''Id$' > b + dotest join-admin-2-10 "$testcvs -Q add b" '' + cp e0 e + dotest join-admin-2-11 "$testcvs -Q ci -m. b e" + + dotest join-admin-2-12 "$testcvs -Q tag -b M2" '' "${QUESTION} e0" + + dotest join-admin-2-13 "$testcvs -Q update -r T" '' "${QUESTION} e0" + dotest join-admin-2-14 "$testcvs update -kk -jM1 -jM2" \ +"${SPROG} update: Updating . +U b +U e +RCS file: ${CVSROOT_DIRNAME}/x/e,v +retrieving revision 1\.1 +retrieving revision 1\.2 +Merging differences between 1\.1 and 1\.2 into e +e already contains the differences between 1\.1 and 1\.2 +${QUESTION} e0" \ +"${QUESTION} e0 +${SPROG} update: Updating . +U b +U e +RCS file: ${CVSROOT_DIRNAME}/x/e,v +retrieving revision 1\.1 +retrieving revision 1\.2 +Merging differences between 1\.1 and 1\.2 into e +e already contains the differences between 1\.1 and 1\.2" + + # Verify that the $Id.$ string is not expanded. + dotest join-admin-2-15 "cat e" '$''Id$' + + dokeep + cd ../.. + rm -rf 1 + modify_repo rm -rf $CVSROOT_DIRNAME/$module + ;; + + + + join-rm) + # This first half of this test checks that a single-argument merge + # from a branch is capable of removing files. + # + # The second half verifies that an update to another location with an + # uncommitted removal will transfer the destination branch of the + # removal. + + module=join-rm + mkdir $module; cd $module + + dotest join-rm-init-1 "$testcvs -q co -l ." '' + mkdir $module + dotest join-rm-init-2 "$testcvs -q add $module" \ +"Directory $CVSROOT_DIRNAME/$module added to the repository" + cd $module + + # add some files. + touch a b c d e f g + dotest join-rm-init-3 "$testcvs -Q add a b c d e f g" + dotest join-rm-init-4 "$testcvs -Q ci -m add-em" + + # create the branch and update to it + dotest join-rm-init-5 "$testcvs -Q tag -b br" + dotest join-rm-init-6 "$testcvs -Q up -rbr" + + # remove a few files from the branch + dotest join-rm-init-7 "$testcvs -Q rm -f b d g" + dotest join-rm-init-8 "$testcvs -Q ci -mrm" + + # update to the trunk + dotest join-rm-init-9 "$testcvs -Q up -A" + + # now for the test - try and merge the removals. + dotest join-rm-1 "$testcvs -q up -jbr" \ +"$SPROG update: scheduling \`b' for removal +$SPROG update: scheduling \`d' for removal +$SPROG update: scheduling \`g' for removal" + + # And make sure the merge took + dotest join-rm-2 "$testcvs -qn up" \ +"R b +R d +R g" + + dotest join-rm-3 "$testcvs -q ci -m 'save the merge'" \ +"$CVSROOT_DIRNAME/join-rm/b,v <-- b +new revision: delete; previous revision: 1\.1 +$CVSROOT_DIRNAME/join-rm/d,v <-- d +new revision: delete; previous revision: 1\.1 +$CVSROOT_DIRNAME/join-rm/g,v <-- g +new revision: delete; previous revision: 1\.1" + + # and verify that it was the head revision which was removed. + dotest join-rm-4 "$testcvs -q log b" " +RCS file: $CVSROOT_DIRNAME/join-rm/Attic/b,v +Working file: b +head: 1\.2 +branch: +locks: strict +access list: +symbolic names: + br: 1\.1\.0\.2 +keyword substitution: kv +total revisions: 3; selected revisions: 3 +description: +---------------------------- +revision 1\.2 +date: ${ISO8601DATE}; author: $username; state: dead; lines: ${PLUS}0 -0; commitid: ${commitid}; +save the merge +---------------------------- +revision 1\.1 +date: ${ISO8601DATE}; author: $username; state: Exp; commitid: ${commitid}; +branches: 1.1.2; +add-em +---------------------------- +revision 1\.1\.2\.1 +date: ${ISO8601DATE}; author: $username; state: dead; lines: ${PLUS}0 -0; commitid: ${commitid}; +rm +=============================================================================" + + # go back to the branch to set up for the second set of tests + dotest join-rm-init-10 "$testcvs -Q up -rbr" + dotest join-rm-init-11 "$testcvs -Q rm -f a" + dotest join-rm-init-12 "$testcvs -Q ci -m rma" + + # now the test: update to the trunk + # + # FIXCVS: This update should merge the removal to the trunk. It does + # not. + dotest join-rm-5 "$testcvs -q up -A" "U a" + + # and verify that there is no sticky tag + dotest join-rm-6 "$testcvs status a" \ +"=================================================================== +File: a Status: Up-to-date + + Working revision: 1\.1.* + Repository revision: 1\.1 $CVSROOT_DIRNAME/join-rm/a,v + Commit Identifier: ${commitid} + Sticky Tag: (none) + Sticky Date: (none) + Sticky Options: (none)" + + dokeep + cd ../.. + modify_repo rm -rf $CVSROOT_DIRNAME/$module + rm -r $module + ;; + + + + new) # look for stray "no longer pertinent" messages. + modify_repo mkdir $CVSROOT_DIRNAME/first-dir + dotest new-init-1 "$testcvs -Q co first-dir" + + cd first-dir + touch a + + dotest new-1 "$testcvs -Q add a" + + dotest new-2 "$testcvs -Q ci -m added" + rm a + + dotest new-3 "$testcvs -Q rm a" + dotest new-4 "$testcvs -Q ci -m removed" + dotest new-5 "$testcvs -Q update -A" + dotest new-6 "$testcvs -Q update -rHEAD" + + dokeep + cd .. + rm -r first-dir + modify_repo rm -rf $CVSROOT_DIRNAME/first-dir + ;; + + + + newb) + # Test removing a file on a branch and then checking it out. + + # We call this "newb" only because it, like the "new" tests, + # has something to do with "no longer pertinent" messages. + # Not necessarily the most brilliant nomenclature. + + # Create file 'a'. + modify_repo mkdir $CVSROOT_DIRNAME/first-dir + dotest newb-123a "${testcvs} -q co first-dir" '' + cd first-dir + touch a + dotest newb-123b "${testcvs} add a" \ +"${SPROG} add: scheduling file .a. for addition +${SPROG} add: use .${SPROG} commit. to add this file permanently" + dotest newb-123c "${testcvs} -q ci -m added" \ +"$CVSROOT_DIRNAME/first-dir/a,v <-- a +initial revision: 1\.1" + + # Make a branch. + dotest newb-123d "${testcvs} -q tag -b branch" "T a" + + # Check out the branch. + cd .. + rm -r first-dir + mkdir 1 + cd 1 + dotest newb-123e "${testcvs} -q co -r branch first-dir" \ +"U first-dir/a" + + # Remove 'a' on another copy of the branch. + cd .. + mkdir 2 + cd 2 + dotest newb-123f "${testcvs} -q co -r branch first-dir" \ +"U first-dir/a" + cd first-dir + rm a + dotest newb-123g "${testcvs} rm a" \ +"${SPROG} remove: scheduling .a. for removal +${SPROG} remove: use .${SPROG} commit. to remove this file permanently" + dotest newb-123h "${testcvs} -q ci -m removed" \ +"$CVSROOT_DIRNAME/first-dir/a,v <-- a +new revision: delete; previous revision: 1\.1" + + # Check out the file on the branch. This should report + # that the file is not pertinent, but it should not + # say anything else. + cd .. + rm -r first-dir + dotest newb-123i "${testcvs} -q co -r branch first-dir/a" \ +"${SPROG} checkout: warning: \`first-dir/a' is not (any longer) pertinent" + + # Update the other copy, and make sure that a is removed. + cd ../1/first-dir + # "Entry Invalid" is a rather strange output here. Something like + # "Removed in Repository" would make more sense. + dotest newb-123j0 "${testcvs} status a" \ +"${SPROG} status: \`a' is no longer in the repository +=================================================================== +File: a Status: Entry Invalid + + Working revision: 1\.1.* + Repository revision: 1\.1\.2\.1 ${CVSROOT_DIRNAME}/first-dir/a,v + Commit Identifier: ${commitid} + Sticky Tag: branch (branch: 1\.1\.2) + Sticky Date: (none) + Sticky Options: (none)${DOTSTAR}" + dotest newb-123j "${testcvs} -q update" \ +"${SPROG} update: \`a' is no longer in the repository" + + if test -f a; then + fail newb-123k + else + pass newb-123k + fi + + dokeep + cd ../.. + rm -r 1 2 + modify_repo rm -rf $CVSROOT_DIRNAME/first-dir + ;; + + + + conflicts) + modify_repo mkdir $CVSROOT_DIRNAME/first-dir + + mkdir 1 + cd 1 + + dotest conflicts-124 "${testcvs} -q co first-dir" '' + + cd first-dir + touch a + + dotest conflicts-125 "${testcvs} add a" \ +"${SPROG} add: scheduling file .a. for addition +${SPROG} add: use .${SPROG} commit. to add this file permanently" + dotest conflicts-126 "${testcvs} -q ci -m added" \ +"$CVSROOT_DIRNAME/first-dir/a,v <-- a +initial revision: 1\.1" + + cd ../.. + mkdir 2 + cd 2 + + dotest conflicts-126.5 "${testcvs} co -p first-dir" \ +"${SPROG} checkout: Updating first-dir +=================================================================== +Checking out first-dir/a +RCS: ${CVSROOT_DIRNAME}/first-dir/a,v +VERS: 1\.1 +\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*" + dotest conflicts-127 "${testcvs} -Q co first-dir" '' + cd first-dir + dotest conflicts-127a "test -f a" '' + + cd ../../1/first-dir + echo add a line >>a + mkdir dir1 + dotest conflicts-127b "${testcvs} add dir1" \ +"Directory ${CVSROOT_DIRNAME}/first-dir/dir1 added to the repository" + dotest conflicts-128 "${testcvs} -q ci -m changed" \ +"$CVSROOT_DIRNAME/first-dir/a,v <-- a +new revision: 1\.2; previous revision: 1\.1" + cd ../.. + + # Similar to conflicts-126.5, but now the file has nonempty + # contents. + mkdir 3 + cd 3 + dotest conflicts-128.5 "${testcvs} co -p -l first-dir" \ +"${SPROG} checkout: Updating first-dir +=================================================================== +Checking out first-dir/a +RCS: ${CVSROOT_DIRNAME}/first-dir/a,v +VERS: 1\.2 +\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* +add a line" + cd .. + rmdir 3 + + # Now go over the to the other working directory and + # start testing conflicts + cd 2/first-dir + echo add a conflicting line >>a + dotest_fail conflicts-129 "${testcvs} -q ci -m changed" \ +"${SPROG}"' commit: Up-to-date check failed for `a'\'' +'"${SPROG}"' \[commit aborted\]: correct above errors first!' + mkdir dir1 + mkdir sdir + dotest conflicts-status-0 "${testcvs} status a" \ +"=================================================================== +File: a Status: Needs Merge + + Working revision: 1\.1.* + Repository revision: 1\.2 ${CVSROOT_DIRNAME}/first-dir/a,v + Commit Identifier: ${commitid} + Sticky Tag: (none) + Sticky Date: (none) + Sticky Options: (none)" + dotest conflicts-129a "${testcvs} -nq update a" \ +"RCS file: ${CVSROOT_DIRNAME}/first-dir/a,v +retrieving revision 1\.1 +retrieving revision 1\.2 +Merging differences between 1\.1 and 1\.2 into a +rcsmerge: warning: conflicts during merge +${SPROG} update: conflicts found in a +C a" + dotest conflicts-130 "${testcvs} -q update" \ +"RCS file: ${CVSROOT_DIRNAME}/first-dir/a,v +retrieving revision 1\.1 +retrieving revision 1\.2 +Merging differences between 1\.1 and 1\.2 into a +rcsmerge: warning: conflicts during merge +${SPROG} update: conflicts found in a +C a +${QUESTION} dir1 +${QUESTION} sdir" \ +"${QUESTION} dir1 +${QUESTION} sdir +RCS file: ${CVSROOT_DIRNAME}/first-dir/a,v +retrieving revision 1\.1 +retrieving revision 1\.2 +Merging differences between 1\.1 and 1\.2 into a +rcsmerge: warning: conflicts during merge +${SPROG} update: conflicts found in a +C a" + rmdir dir1 sdir + + dotest conflicts-status-1 "${testcvs} status a" \ +"=================================================================== +File: a Status: Unresolved Conflict + + Working revision: 1\.2.* + Repository revision: 1\.2 ${CVSROOT_DIRNAME}/first-dir/a,v + Commit Identifier: ${commitid} + Sticky Tag: (none) + Sticky Date: (none) + Sticky Options: (none)" + dotest_fail conflicts-131 "${testcvs} -q ci -m try" \ +"${SPROG} commit: file .a. had a conflict and has not been modified +${SPROG} \[commit aborted\]: correct above errors first!" + + # Try to check in the file with the conflict markers in it. + # Make sure we detect any one of the three conflict markers + mv a aa + grep '^<<<<<<<' aa >a + dotest conflicts-status-2 "${testcvs} -nq ci -m try a" \ +"${SPROG} commit: warning: file .a. seems to still contain conflict indicators" + + grep '^=======' aa >a + dotest conflicts-status-3 "${testcvs} -nq ci -m try a" \ +"${SPROG} commit: warning: file .a. seems to still contain conflict indicators" + + grep '^>>>>>>>' aa >a + dotest conflicts-status-4 "${testcvs} -qn ci -m try a" \ +"${SPROG} commit: warning: file .a. seems to still contain conflict indicators" + + mv aa a + echo lame attempt at resolving it >>a + dotest conflicts-status-5 "${testcvs} status a" \ +"=================================================================== +File: a Status: File had conflicts on merge + + Working revision: 1\.2.* + Repository revision: 1\.2 ${CVSROOT_DIRNAME}/first-dir/a,v + Commit Identifier: ${commitid} + Sticky Tag: (none) + Sticky Date: (none) + Sticky Options: (none)" + dotest conflicts-132 "$testcvs -q ci -m try" \ +"$SPROG commit: warning: file .a. seems to still contain conflict indicators +$CVSROOT_DIRNAME/first-dir/a,v <-- a +new revision: 1\.3; previous revision: 1\.2" + + # OK, the user saw the warning (good user), and now + # resolves it for real. + echo resolve conflict >a + dotest conflicts-status-6 "${testcvs} status a" \ +"=================================================================== +File: a Status: Locally Modified + + Working revision: 1\.3.* + Repository revision: 1\.3 ${CVSROOT_DIRNAME}/first-dir/a,v + Commit Identifier: ${commitid} + Sticky Tag: (none) + Sticky Date: (none) + Sticky Options: (none)" + dotest conflicts-133 "${testcvs} -q ci -m resolved" \ +"$CVSROOT_DIRNAME/first-dir/a,v <-- a +new revision: 1\.4; previous revision: 1\.3" + dotest conflicts-status-7 "${testcvs} status a" \ +"=================================================================== +File: a Status: Up-to-date + + Working revision: 1\.4.* + Repository revision: 1\.4 ${CVSROOT_DIRNAME}/first-dir/a,v + Commit Identifier: ${commitid} + Sticky Tag: (none) + Sticky Date: (none) + Sticky Options: (none)" + + # Now test that we can add a file in one working directory + # and have an update in another get it. + cd ../../1/first-dir + echo abc >abc + if ${testcvs} add abc >>${LOGFILE} 2>&1; then + pass 134 + else + fail 134 + fi + if ${testcvs} ci -m 'add abc' abc >>${LOGFILE} 2>&1; then + pass 135 + else + fail 135 + fi + cd ../../2 + mkdir first-dir/dir1 first-dir/sdir + dotest conflicts-136 "${testcvs} -q update first-dir" \ +'[UP] first-dir/abc +'"${QUESTION}"' first-dir/dir1 +'"${QUESTION}"' first-dir/sdir' \ +''"${QUESTION}"' first-dir/dir1 +'"${QUESTION}"' first-dir/sdir +[UP] first-dir/abc' + dotest conflicts-137 'test -f first-dir/abc' '' + rmdir first-dir/dir1 first-dir/sdir + + # Now test something similar, but in which the parent directory + # (not the directory in question) has the Entries.Static flag + # set. + cd ../1/first-dir + mkdir subdir + dotest conflicts-138 "${testcvs} add subdir" "${DOTSTAR}" + cd ../.. + mkdir 3 + cd 3 + dotest conflicts-139 \ +"${testcvs} -q co first-dir/abc first-dir/subdir" "${DOTSTAR}" + cd ../1/first-dir/subdir + echo sss >sss + dotest conflicts-140 "${testcvs} add sss" "${DOTSTAR}" + dotest conflicts-140a "${testcvs} ci -m adding sss" \ +"${DOTSTAR}" + cd ../../../3/first-dir + dotest conflicts-141 "${testcvs} -q update" "${DOTSTAR}" + dotest conflicts-142 "test -f subdir/sss" + + dokeep + cd ../.. + rm -r 1 2 3 + modify_repo rm -rf $CVSROOT_DIRNAME/first-dir + restore_adm + ;; + + + + conflicts2) + # More conflicts tests; separate from conflicts to keep each + # test a manageable size. + modify_repo mkdir $CVSROOT_DIRNAME/first-dir + + mkdir 1 + cd 1 + + dotest conflicts2-142a1 "${testcvs} -q co first-dir" '' + + cd first-dir + touch a abc + + dotest conflicts2-142a2 "${testcvs} add a abc" \ +"${SPROG} add: scheduling file .a. for addition +${SPROG} add: scheduling file .abc. for addition +${SPROG} add: use .${SPROG} commit. to add these files permanently" + dotest conflicts2-142a3 "${testcvs} -q ci -m added" \ +"$CVSROOT_DIRNAME/first-dir/a,v <-- a +initial revision: 1\.1 +${CVSROOT_DIRNAME}/first-dir/abc,v <-- abc +initial revision: 1\.1" + + cd ../.. + mkdir 2 + cd 2 + + dotest conflicts2-142a4 "${testcvs} -q co first-dir" 'U first-dir/a +U first-dir/abc' + cd .. + + # BEGIN TESTS USING THE FILE A + # FIXME: would be cleaner to separate them out into their own + # tests; conflicts2 is getting long. + # Now test that if one person modifies and commits a + # file and a second person removes it, it is a + # conflict + cd 1/first-dir + echo modify a >>a + dotest conflicts2-142b2 "${testcvs} -q ci -m modify-a" \ +"$CVSROOT_DIRNAME/first-dir/a,v <-- a +new revision: 1\.2; previous revision: 1\.1" + cd ../../2/first-dir + rm a + dotest conflicts2-142b3 "${testcvs} rm a" \ +"${SPROG} remove: scheduling .a. for removal +${SPROG} remove: use .${SPROG} commit. to remove this file permanently" + dotest_fail conflicts2-142b4 "${testcvs} -q update" \ +"${SPROG} update: conflict: removed \`a' was modified by second party +C a" + # Resolve the conflict by deciding not to remove the file + # after all. + dotest_sort conflicts2-142b5 "$testcvs add a" "U a +${SPROG} add: \`a', version 1\.1, resurrected" + dotest conflicts2-142b5b1 "$testcvs status a" \ +"=================================================================== +File: a Status: Needs Patch + + Working revision: 1\.1.* + Repository revision: 1\.2 $CVSROOT_DIRNAME/first-dir/a,v + Commit Identifier: ${commitid} + Sticky Tag: (none) + Sticky Date: (none) + Sticky Options: (none)" + dotest conflicts2-142b6 "$testcvs -q update" 'U a' + + # Now one level up. + cd .. + dotest conflicts2-142b7 "${testcvs} rm -f first-dir/a" \ +"${SPROG} remove: scheduling \`first-dir/a' for removal +${SPROG} remove: use \`${SPROG} commit' to remove this file permanently" + + if $remote; then + # Haven't investigated this one. + dotest_fail conflicts2-142b8r "$testcvs add first-dir/a" \ +"${CPROG} add: in directory \`\.': +${CPROG} \[add aborted\]: there is no version here; do \`${CPROG} checkout' first" + cd first-dir + else + dotest conflicts2-142b8 "${testcvs} add first-dir/a" \ +"U first-dir/a +$SPROG add: \`first-dir/a', version 1\.2, resurrected" + cd first-dir + # Now recover from the damage that the 142b8 test did. + dotest conflicts2-142b9 "${testcvs} rm -f a" \ +"${SPROG} remove: scheduling \`a' for removal +${SPROG} remove: use \`${SPROG} commit' to remove this file permanently" + fi + + # As before, 1.2 instead of 1.1 is a bug. + dotest_sort conflicts2-142b10 "$testcvs add a" "U a +${SPROG} add: \`a', version 1\.2, resurrected" + # As with conflicts2-142b6, check that things are normal again. + dotest conflicts2-142b11 "${testcvs} -q update" '' + cd ../.. + # END TESTS USING THE FILE A + + # Now test that if one person removes a file and + # commits it, and a second person removes it, is it + # not a conflict. + cd 1/first-dir + rm abc + dotest conflicts2-142c0 "${testcvs} rm abc" \ +"${SPROG} remove: scheduling \`abc' for removal +${SPROG} remove: use \`${SPROG} commit' to remove this file permanently" + dotest conflicts2-142c1 "${testcvs} -q ci -m remove-abc" \ +"$CVSROOT_DIRNAME/first-dir/abc,v <-- abc +new revision: delete; previous revision: 1\.1" + cd ../../2/first-dir + rm abc + dotest conflicts2-142c2 "${testcvs} rm abc" \ +"${SPROG} remove: scheduling \`abc' for removal +${SPROG} remove: use \`${SPROG} commit' to remove this file permanently" + dotest conflicts2-142c3 "${testcvs} update" \ +"${SPROG} update: Updating \." + cd ../.. + + # conflicts2-142d*: test that if one party adds a file, and another + # party has a file of the same name, cvs notices + cd 1/first-dir + touch aa.c + echo 'contents unchanged' >same.c + dotest conflicts2-142d0 "${testcvs} add aa.c same.c" \ +"${SPROG} add: scheduling file .aa\.c. for addition +${SPROG} add: scheduling file .same\.c. for addition +${SPROG} add: use .${SPROG} commit. to add these files permanently" + dotest conflicts2-142d1 "${testcvs} -q ci -m added" \ +"$CVSROOT_DIRNAME/first-dir/aa\.c,v <-- aa\.c +initial revision: 1\.1 +$CVSROOT_DIRNAME/first-dir/same\.c,v <-- same\.c +initial revision: 1\.1" + + # Test the case where the second user manages the add before the + # first commits + touch bb.c + dotest conflicts2-142d1a "$testcvs add bb.c" \ +"$SPROG add: scheduling file .bb\.c. for addition +$SPROG add: use .$SPROG commit. to add this file permanently" + cd ../../2/first-dir + echo "don't you dare obliterate this text" >bb.c + dotest conflicts2-142d1b "$testcvs add bb.c" \ +"$SPROG add: scheduling file .bb\.c. for addition +$SPROG add: use .$SPROG commit. to add this file permanently" + cd ../../1/first-dir + dotest conflicts2-142d1c "$testcvs -q ci -m added" \ +"$CVSROOT_DIRNAME/first-dir/bb\.c,v <-- bb\.c +initial revision: 1\.1" + + cd ../../2/first-dir + echo "don't you dare obliterate this text either" >aa.c + echo 'contents unchanged' >same.c + # Note the discrepancy between local and remote in the handling + # of same.c. I kind + # of suspect that the local CVS behavior is the more useful one + # although I do sort of wonder whether we should make people run + # cvs add just to get them in that habit (also, trying to implement + # the local CVS behavior for remote without the cvs add seems + # pretty difficult). + if $remote; then + dotest_fail conflicts2-142d2r "${testcvs} -q update" \ +"${QUESTION} aa\.c +${QUESTION} same\.c +${CPROG} update: move away \`\./aa\.c'; it is in the way +C aa\.c +${SPROG} update: conflict: \`bb\.c' created independently by second party +C bb\.c +${CPROG} update: move away \`\./same\.c'; it is in the way +C same\.c" + else + dotest_fail conflicts2-142d2 "${testcvs} -q update" \ +"${CPROG} update: move away \`aa\.c'; it is in the way +C aa\.c +${CPROG} update: conflict: \`bb\.c' created independently by second party +C bb\.c +U same\.c" + fi + dotest conflicts2-142d3 "${testcvs} -q status aa.c" \ +"${SPROG} status: move away \`aa\.c'; it is in the way +=================================================================== +File: aa\.c Status: Unresolved Conflict + + Working revision: No entry for aa\.c + Repository revision: 1\.1 ${CVSROOT_DIRNAME}/first-dir/aa\.c,v + Commit Identifier: ${commitid}" + dotest conflicts2-142d3a "${testcvs} -q status bb.c" \ +"${SPROG} status: conflict: \`bb\.c' created independently by second party +=================================================================== +File: bb\.c Status: Unresolved Conflict + + Working revision: New file! + Repository revision: 1\.1 ${CVSROOT_DIRNAME}/first-dir/bb\.c,v + Commit Identifier: ${commitid} + Sticky Tag: (none) + Sticky Date: (none) + Sticky Options: (none)" + + # FIXCVS + # This message seems somewhat bogus. I mean, parallel development + # means that we get to work in parallel if we choose, right? And + # then at commit time it would be a conflict. + # + # Well, the status is "Unresolved conflict" before _and_ after + # the update/merge (when conflicts happen, not at commit time). + # It is possible that this message could be changed to something + # more infomrative to novice users, like "File of same name exists + # in repository", or "File of same name committed independantly by + # second party", but these two messages look too long for the Status + # field and the move away & added independantly error messages _are_ + # displayed. Still, we get a lot of questions about this on the + # email lists. Somehow we need to get more information to users + # via these messages and the ones generated by update. -DRP + dotest_fail conflicts2-142d4 "${testcvs} -q add aa.c" \ +"${SPROG} add: \`aa.c' added independently by second party" + + # The user might want to see just what the conflict is. + # Don't bother, diff seems to kind of lose its mind, with or + # without -N. This is a CVS bug(s). + #dotest conflicts2-142d5 \ + #"${testcvs} -q diff -r HEAD -N aa.c" FIXCVS THEN FIXME + + # Now: "how can the user resolve this conflict", I hear you cry. + # Well, one way is to forget about the file in the working + # directory. + # Since it didn't let us do the add in conflicts2-142d4, there + # is no need to run cvs rm here. + #dotest conflicts2-142d6 "${testcvs} -q rm -f aa.c" fixme + dotest conflicts2-142d6 "rm aa.c" '' + dotest conflicts2-142d7 "${testcvs} -q update aa.c" "U aa\.c" + dotest conflicts2-142d8 "cat aa.c" '' + + # The other way is to use the version from the working directory + # instead of the version from the repository. Unfortunately, + # there doesn't seem to be any particularly clear way to do + # this (?). + + dokeep + cd ../.. + rm -r 1 2 + modify_repo rm -rf $CVSROOT_DIRNAME/first-dir + ;; + + + + conflicts3) + # More tests of conflicts and/or multiple working directories + # in general. + + mkdir 1; cd 1 + dotest conflicts3-1 "$testcvs -q co -l ." + mkdir first-dir + dotest conflicts3-2 "${testcvs} add first-dir" \ +"Directory ${CVSROOT_DIRNAME}/first-dir added to the repository" + cd .. + mkdir 2; cd 2 + dotest conflicts3-3 "${testcvs} -q co -l first-dir" '' + cd ../1/first-dir + touch file1 file2 + dotest conflicts3-4 "${testcvs} add file1 file2" \ +"${SPROG} add: scheduling file .file1. for addition +${SPROG} add: scheduling file .file2. for addition +${SPROG} add: use .${SPROG} commit. to add these files permanently" + dotest conflicts3-5 "${testcvs} -q ci -m add-them" \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +initial revision: 1\.1 +$CVSROOT_DIRNAME/first-dir/file2,v <-- file2 +initial revision: 1\.1" + cd ../../2/first-dir + # Check that -n doesn't make CVS lose its mind as it creates + # (or rather, doesn't) a new file. + dotest conflicts3-6 "${testcvs} -nq update" \ +"U file1 +U file2" + dotest_fail conflicts3-7 "test -f file1" '' + dotest conflicts3-8 "${testcvs} -q update" \ +"U file1 +U file2" + dotest conflicts3-9 "test -f file2" '' + + # OK, now remove two files at once + dotest conflicts3-10 "${testcvs} rm -f file1 file2" \ +"${SPROG} remove: scheduling .file1. for removal +${SPROG} remove: scheduling .file2. for removal +${SPROG} remove: use .${SPROG} commit. to remove these files permanently" + dotest conflicts3-11 "${testcvs} -q ci -m remove-them" \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +new revision: delete; previous revision: 1\.1 +$CVSROOT_DIRNAME/first-dir/file2,v <-- file2 +new revision: delete; previous revision: 1\.1" + cd ../../1/first-dir + dotest conflicts3-12 "${testcvs} -n -q update" \ +"${SPROG} update: \`file1' is no longer in the repository +${SPROG} update: \`file2' is no longer in the repository" + dotest conflicts3-13 "${testcvs} -q update" \ +"${SPROG} update: \`file1' is no longer in the repository +${SPROG} update: \`file2' is no longer in the repository" + + # OK, now add a directory to both working directories + # and see that CVS doesn't lose its mind. + mkdir sdir + dotest conflicts3-14 "${testcvs} add sdir" \ +"Directory ${CVSROOT_DIRNAME}/first-dir/sdir added to the repository" + touch sdir/sfile + dotest conflicts3-14a "${testcvs} add sdir/sfile" \ +"${SPROG} add: scheduling file .sdir/sfile. for addition +${SPROG} add: use .${SPROG} commit. to add this file permanently" + dotest conflicts3-14b "${testcvs} -q ci -m add" \ +"$CVSROOT_DIRNAME/first-dir/sdir/sfile,v <-- sdir/sfile +initial revision: 1\.1" + + cd ../../2/first-dir + + # Create a CVS directory without the proper administrative + # files in it. This can happen for example if you hit ^C + # in the middle of a checkout. + mkdir sdir + mkdir sdir/CVS + # OK, in the local case CVS sees that the directory exists + # in the repository and recurses into it. In the remote case + # CVS can't see the repository and has no way of knowing + # that sdir is even a directory (stat'ing everything would be + # too slow). The remote behavior makes more sense to me (but + # would this affect other cases?). + if $remote; then + dotest conflicts3-15 "${testcvs} -q update" \ +"${QUESTION} sdir" + else + dotest conflicts3-15 "${testcvs} -q update" \ +"${QUESTION} sdir +${SPROG} update: ignoring sdir (CVS/Repository missing)" + touch sdir/CVS/Repository + dotest conflicts3-16 "${testcvs} -q update" \ +"${QUESTION} sdir +${SPROG} update: ignoring sdir (CVS/Entries missing)" + cd .. + dotest conflicts3-16a "${testcvs} -q update first-dir" \ +"${QUESTION} first-dir/sdir +${SPROG} update: ignoring first-dir/sdir (CVS/Entries missing)" + cd first-dir + fi + rm -r sdir + + # OK, now the same thing, but the directory doesn't exist + # in the repository. + mkdir newdir + mkdir newdir/CVS + dotest conflicts3-17 "${testcvs} -q update" "${QUESTION} newdir" + echo "D/newdir////" >> CVS/Entries + dotest conflicts3-18 "${testcvs} -q update" \ +"${CPROG} update: ignoring newdir (CVS/Repository missing)" + touch newdir/CVS/Repository + dotest conflicts3-19 "${testcvs} -q update" \ +"${CPROG} update: ignoring newdir (CVS/Entries missing)" + cd .. + dotest conflicts3-20 "${testcvs} -q update first-dir" \ +"${CPROG} update: ignoring first-dir/newdir (CVS/Entries missing)" + cd first-dir + rm -r newdir + + # The previous tests have left CVS/Entries in something of a mess. + # While we "should" be able to deal with that (maybe), for now + # we just start over. + cd .. + rm -r first-dir + dotest conflicts3-20a "${testcvs} -q co -l first-dir" '' + cd first-dir + + dotest conflicts3-21 "${testcvs} -q update -d sdir" "U sdir/sfile" + rm -r sdir/CVS + dotest conflicts3-22 "${testcvs} -q update" "${QUESTION} sdir" + if $remote; then + dotest_fail conflicts3-23 "${testcvs} -q update -PdA" \ +"${QUESTION} sdir +${CPROG} update: move away \`sdir/sfile'; it is in the way +C sdir/sfile" + else + dotest conflicts3-23 "${testcvs} -q update -PdA" \ +"${QUESTION} sdir" + fi + + # Not that it should really affect much, but let's do the case + # where sfile has been removed. For example, suppose that sdir + # had been a CVS-controlled directory which was then removed + # by removing each file (and using update -P or some such). Then + # suppose that the build process creates an sdir directory which + # is not supposed to be under CVS. + rm -r sdir + dotest conflicts3-24 "${testcvs} -q update -d sdir" "U sdir/sfile" + rm sdir/sfile + dotest conflicts3-25 "${testcvs} rm sdir/sfile" \ +"${SPROG} remove: scheduling .sdir/sfile. for removal +${SPROG} remove: use .${SPROG} commit. to remove this file permanently" + dotest conflicts3-26 "${testcvs} ci -m remove sdir/sfile" \ +"${CVSROOT_DIRNAME}/first-dir/sdir/sfile,v <-- sdir/sfile +new revision: delete; previous revision: 1\.1" + rm -r sdir/CVS + dotest conflicts3-27 "${testcvs} -q update" "${QUESTION} sdir" + dotest conflicts3-28 "${testcvs} -q update -PdA" \ +"${QUESTION} sdir" + + dokeep + cd ../.. + rm -r 1 2 + modify_repo rm -rf $CVSROOT_DIRNAME/first-dir + ;; + + + + clean) + # Test update -C (overwrite local mods w/ repository copies) + mkdir 1; cd 1 + dotest clean-1 "${testcvs} -q co -l ." '' + mkdir first-dir + dotest clean-2 "${testcvs} add first-dir" \ +"Directory ${CVSROOT_DIRNAME}/first-dir added to the repository" + cd first-dir + echo "The usual boring test text." > cleanme.txt + dotest clean-3 "${testcvs} add cleanme.txt" \ +"${SPROG} add: scheduling file .cleanme\.txt. for addition +${SPROG} add: use .${SPROG} commit. to add this file permanently" + dotest clean-4 "${testcvs} -q ci -m clean-3" \ +"$CVSROOT_DIRNAME/first-dir/cleanme\.txt,v <-- cleanme\.txt +initial revision: 1\.1" + # Okay, preparation is done, now test. + # Check that updating an unmodified copy works. + dotest clean-5 "${testcvs} -q update" '' + # Check that updating -C an unmodified copy works. + dotest clean-6 "${testcvs} -q update -C" '' + # Check that updating a modified copy works. + echo "fish" >> cleanme.txt + dotest clean-7 "${testcvs} -q update" 'M cleanme\.txt' + # Check that updating -C a modified copy works. + dotest clean-8 "${testcvs} -q update -C" \ +"(Locally modified cleanme\.txt moved to \.#cleanme\.txt\.1\.1) +U cleanme\.txt" + # And check that the backup copy really was made. + dotest clean-9 "cat .#cleanme.txt.1.1" \ +"The usual boring test text\. +fish" + + # Do it all again, this time naming the file explicitly. + rm .#cleanme.txt.1.1 + dotest clean-10 "${testcvs} -q update cleanme.txt" '' + dotest clean-11 "${testcvs} -q update -C cleanme.txt" '' + echo "bluegill" >> cleanme.txt + dotest clean-12 "${testcvs} -q update cleanme.txt" 'M cleanme\.txt' + dotest clean-13 "${testcvs} -q update -C cleanme.txt" \ +"(Locally modified cleanme\.txt moved to \.#cleanme\.txt\.1\.1) +U cleanme\.txt" + # And check that the backup copy really was made. + dotest clean-14 "cat .#cleanme.txt.1.1" \ +"The usual boring test text\. +bluegill" + + # Now try with conflicts + cd .. + dotest clean-15 "${testcvs} -q co -d second-dir first-dir" \ +'U second-dir/cleanme\.txt' + cd second-dir + echo "conflict test" >> cleanme.txt + dotest clean-16 "${testcvs} -q ci -m." \ +"$CVSROOT_DIRNAME/first-dir/cleanme\.txt,v <-- cleanme\.txt +new revision: 1\.2; previous revision: 1\.1" + cd ../first-dir + echo "fish" >> cleanme.txt + dotest clean-17 "${testcvs} -nq update" \ +"RCS file: ${CVSROOT_DIRNAME}/first-dir/cleanme\.txt,v +retrieving revision 1\.1 +retrieving revision 1\.2 +Merging differences between 1\.1 and 1\.2 into cleanme\.txt +rcsmerge: warning: conflicts during merge +${SPROG} update: conflicts found in cleanme\.txt +C cleanme\.txt" + dotest clean-18 "${testcvs} -q update -C" \ +"(Locally modified cleanme\.txt moved to \.#cleanme\.txt\.1\.1) +U cleanme\.txt" + dotest clean-19 "cat .#cleanme.txt.1.1" \ +"The usual boring test text\. +fish" + + # Done. Clean up. + dokeep + cd ../.. + rm -rf 1 + modify_repo rm -rf $CVSROOT_DIRNAME/first-dir + ;; + + + + keywordexpand) + # Tests of the original *BSD tag= and keywordexpand= features + # are done via the LocalKeyword= and KeywordExpand features. + + # Skip this in noredirect mode because it is too easy for the primary + # and secondary error messages to get out of sync when the + # CVSROOT/config files are broken. This is intentional, since it is + # possible and even likely that an administrator might want to set up + # different configurations on the two servers and the paths to the + # config files on the secondary and primary were intentionally left + # intact even though they might be different. + if $noredirect; then + notnoredirect keywordexpand + continue + fi + + mkdir keywordexpand; cd keywordexpand + + dotest keywordexpand-1 "${testcvs} -q co CVSROOT" \ +'U CVSROOT/checkoutlist +U CVSROOT/commitinfo +U CVSROOT/config +U CVSROOT/cvswrappers +U CVSROOT/loginfo +U CVSROOT/modules +U CVSROOT/notify +U CVSROOT/postadmin +U CVSROOT/postproxy +U CVSROOT/posttag +U CVSROOT/postwatch +U CVSROOT/preproxy +U CVSROOT/rcsinfo +U CVSROOT/taginfo +U CVSROOT/verifymsg' + cd CVSROOT + echo LocalKeyword=MyBSD=CVSHeader >> config + # First do not expand any keywords + echo KeywordExpand=i >> config + dotest keywordexpand-2 "${testcvs} -Q ci -mkeywordexpand config" + + cd .. + + mkdir testimport; cd testimport + echo '$''Author$' > file1 + echo '$''Date$' >> file1 + echo '$''CVSHeader$' >> file1 + echo '$''Header$' >> file1 + echo '$''Id$' >> file1 + echo '$''Locker$' >> file1 + echo '$''Log$' >> file1 + echo '$''Name$' >> file1 + echo '$''RCSfile$' >> file1 + echo '$''Revision$' >> file1 + echo '$''Source$' >> file1 + echo '$''State$' >> file1 + echo '$''MyBSD$' >> file1 + dotest keywordexpand-3 \ +"${testcvs} -Q import -I ! -m test-import-with-bsd-keyword keywordexpand vendor v1" \ +'' + cd .. + + dotest keywordexpand-4 "${testcvs} -Q checkout keywordexpand" '' + cd keywordexpand + dotest keywordexpand-5 "cat file1" \ +"\$""Author\$ +\$""Date\$ +\$""CVSHeader\$ +\$""Header\$ +\$""Id\$ +\$""Locker\$ +\$""Log\$ +\$""Name\$ +\$""RCSfile\$ +\$""Revision\$ +\$""Source\$ +\$""State\$ +\$MyBSD\$" + cd ../CVSROOT + # Now expand just the MyBSD and Id keywords + mv config config.old + sed -e 's/KeywordExpand=i/KeywordExpand=iMyBSD,Id/' < config.old > config + rm -f config.old + dotest keywordexpand-6 "${testcvs} -Q ci -mkeywordexpand config" + cd ../keywordexpand + echo 'a change' >> file1 + dotest keywordexpand-7 "${testcvs} -Q ci -madd" + dotest keywordexpand-8 "cat file1" \ +"\$""Author\$ +\$""Date\$ +\$""CVSHeader\$ +\$""Header\$ +\$""Id: file1,v 1\.2 [0-9/]* [0-9:]* ${username} Exp \$ +\$""Locker\$ +\$""Log\$ +\$""Name\$ +\$""RCSfile\$ +\$""Revision\$ +\$""Source\$ +\$""State\$ +\$MyBSD: keywordexpand/file1,v 1\.2 [0-9/]* [0-9:]* ${username} Exp \$ +a change" + + cd ../CVSROOT + mv config config.old + sed -e 's/LocalKeyword=MyBSD/LocalKeyword=My_BSD/' \ + <config.old >config + dotest keywordexpand-9 "$testcvs -Q ci -minvalidlocalkeyword config" + dotest keywordexpand-10 "$testcvs -Q update config" \ +"$SPROG [a-z]*: $SECONDARY_CVSROOT_DIRNAME/CVSROOT/config \[[1-9][0-9]*\]: LocalKeyword ignored: Bad character \`_' in key \`My_BSD'" + cp config.old config + dotest keywordexpand-11 "$testcvs -Q ci -mfixit config" \ +"$SPROG [a-z]*: $SECONDARY_CVSROOT_DIRNAME/CVSROOT/config \[[1-9][0-9]*\]: LocalKeyword ignored: Bad character \`_' in key \`My_BSD'" \ +"$SPROG [a-z]*: $SECONDARY_CVSROOT_DIRNAME/CVSROOT/config \[[1-9][0-9]*\]: LocalKeyword ignored: Bad character \`_' in key \`My_BSD' +$SPROG [a-z]*: $CVSROOT_DIRNAME/CVSROOT/config \[[1-9][0-9]*\]: LocalKeyword ignored: Bad character \`_' in key \`My_BSD'" + dotest keywordexpand-12 "$testcvs -Q update config" + sed -e 's/LocalKeyword=MyBSD=CVSHeader/LocalKeyword=MyBSD=Name/' \ + <config.old >config + dotest keywordexpand-13 \ +"$testcvs -Q ci -minvalidlocalkeyword2 config" + dotest keywordexpand-14 "$testcvs -Q update config" \ +"$SPROG [a-z]*: $SECONDARY_CVSROOT_DIRNAME/CVSROOT/config \[[1-9][0-9]*\]: LocalKeyword ignored: Unknown LocalId mode: \`Name'" + cp config.old config + dotest keywordexpand-15 "$testcvs -Q ci -mfixit2 config" \ +"$SPROG [a-z]*: $SECONDARY_CVSROOT_DIRNAME/CVSROOT/config \[[1-9][0-9]*\]: LocalKeyword ignored: Unknown LocalId mode: \`Name'" \ +"$SPROG [a-z]*: $SECONDARY_CVSROOT_DIRNAME/CVSROOT/config \[[1-9][0-9]*\]: LocalKeyword ignored: Unknown LocalId mode: \`Name' +$SPROG [a-z]*: $CVSROOT_DIRNAME/CVSROOT/config \[[1-9][0-9]*\]: LocalKeyword ignored: Unknown LocalId mode: \`Name'" + dotest keywordexpand-16 "$testcvs -Q update config" + + dokeep + # Done. Clean up. + cd ../.. + rm -rf $TESTDIR/keywordexpand + modify_repo rm -rf $CVSROOT_DIRNAME/keywordexpand + restore_adm + ;; + + + + modules) + # Tests of various ways to define and use modules. + # Roadmap to various modules tests: + # -a: + # error on incorrect placement: modules + # error combining with other options: modules2-a* + # infinite loops: modules148a1.1 - modules148a1.2 + # use to specify a file more than once: modules3 + # use with ! feature: modules4 + # regular modules: modules, modules2, cvsadm + # ampersand modules: modules2 + # -s: modules. + # -d: modules, modules3, cvsadm + # -i, -o, -u, -e, -t: modules5 + # slashes in module names: modules3 + # invalid module definitions: modules6 + + ############################################################ + # These tests are to make sure that administrative files get + # rebuilt, regardless of how and where files are checked + # out. + ############################################################ + # Check out the whole repository + mkdir 1; cd 1 + dotest modules-1 "${testcvs} -q co ." 'U CVSROOT/checkoutlist +U CVSROOT/commitinfo +U CVSROOT/config +U CVSROOT/cvswrappers +U CVSROOT/loginfo +U CVSROOT/modules +U CVSROOT/notify +U CVSROOT/postadmin +U CVSROOT/postproxy +U CVSROOT/posttag +U CVSROOT/postwatch +U CVSROOT/preproxy +U CVSROOT/rcsinfo +U CVSROOT/taginfo +U CVSROOT/verifymsg' + echo "# made a change" >>CVSROOT/modules + dotest modules-1d "${testcvs} -q ci -m add-modules" \ +"$CVSROOT_DIRNAME/CVSROOT/modules,v <-- CVSROOT/modules +new revision: 1\.[0-9]*; previous revision: 1\.[0-9]* +$SPROG commit: Rebuilding administrative file database" + cd .. + rm -rf 1 + + ############################################################ + # Check out CVSROOT + mkdir 1; cd 1 + dotest modules-2 "${testcvs} -q co CVSROOT" 'U CVSROOT/checkoutlist +U CVSROOT/commitinfo +U CVSROOT/config +U CVSROOT/cvswrappers +U CVSROOT/loginfo +U CVSROOT/modules +U CVSROOT/notify +U CVSROOT/postadmin +U CVSROOT/postproxy +U CVSROOT/posttag +U CVSROOT/postwatch +U CVSROOT/preproxy +U CVSROOT/rcsinfo +U CVSROOT/taginfo +U CVSROOT/verifymsg' + echo "# made a change" >>CVSROOT/modules + dotest modules-2d "${testcvs} -q ci -m add-modules" \ +"$CVSROOT_DIRNAME/CVSROOT/modules,v <-- CVSROOT/modules +new revision: 1\.[0-9]*; previous revision: 1\.[0-9]* +$SPROG commit: Rebuilding administrative file database" + cd .. + rm -rf 1 + + ############################################################ + # Check out CVSROOT in some other directory + modify_repo mkdir $CVSROOT_DIRNAME/somedir + mkdir 1; cd 1 + dotest modules-3 "${testcvs} -q co somedir" '' + cd somedir + dotest modules-3d "${testcvs} -q co CVSROOT" 'U CVSROOT/checkoutlist +U CVSROOT/commitinfo +U CVSROOT/config +U CVSROOT/cvswrappers +U CVSROOT/loginfo +U CVSROOT/modules +U CVSROOT/notify +U CVSROOT/postadmin +U CVSROOT/postproxy +U CVSROOT/posttag +U CVSROOT/postwatch +U CVSROOT/preproxy +U CVSROOT/rcsinfo +U CVSROOT/taginfo +U CVSROOT/verifymsg' + echo "# made a change" >>CVSROOT/modules + dotest modules-3g "${testcvs} -q ci -m add-modules" \ +"$CVSROOT_DIRNAME/CVSROOT/modules,v <-- CVSROOT/modules +new revision: 1\.[0-9]*; previous revision: 1\.[0-9]* +$SPROG commit: Rebuilding administrative file database" + cd ../.. + rm -rf 1 + modify_repo rm -rf $CVSROOT_DIRNAME/somedir + ############################################################ + # end rebuild tests + ############################################################ + + + modify_repo mkdir $CVSROOT_DIRNAME/first-dir + + mkdir 1 + cd 1 + + dotest modules-143 "${testcvs} -q co first-dir" "" + + cd first-dir + mkdir subdir + dotest modules-143a "${testcvs} add subdir" \ +"Directory ${CVSROOT_DIRNAME}/first-dir/subdir added to the repository" + + cd subdir + mkdir ssdir + dotest modules-143b "${testcvs} add ssdir" \ +"Directory ${CVSROOT_DIRNAME}/first-dir/subdir/ssdir added to the repository" + + touch a b + + dotest modules-144 "${testcvs} add a b" \ +"${SPROG} add: scheduling file .a. for addition +${SPROG} add: scheduling file .b. for addition +${SPROG} add: use .${SPROG} commit. to add these files permanently" + + dotest modules-145 "$testcvs ci -m added" \ +"$CPROG commit: Examining . +$CPROG commit: Examining ssdir +$CVSROOT_DIRNAME/first-dir/subdir/a,v <-- a +initial revision: 1\.1 +$CVSROOT_DIRNAME/first-dir/subdir/b,v <-- b +initial revision: 1\.1" + + cd .. + dotest modules-146 "$testcvs -q co CVSROOT" \ +"U CVSROOT/checkoutlist +U CVSROOT/commitinfo +U CVSROOT/config +U CVSROOT/cvswrappers +U CVSROOT/loginfo +U CVSROOT/modules +U CVSROOT/notify +U CVSROOT/postadmin +U CVSROOT/postproxy +U CVSROOT/posttag +U CVSROOT/postwatch +U CVSROOT/preproxy +U CVSROOT/rcsinfo +U CVSROOT/taginfo +U CVSROOT/verifymsg" + + # Here we test that CVS can deal with CVSROOT (whose repository + # is at top level) in the same directory as subdir (whose repository + # is a subdirectory of first-dir). TODO: Might want to check that + # files can actually get updated in this state. + dotest modules-147 "$testcvs -q update" + + cat >CVSROOT/modules <<EOF +realmodule first-dir/subdir a +dirmodule first-dir/subdir +namedmodule -d nameddir first-dir/subdir +aliasmodule -a first-dir/subdir/a +aliasnested -a first-dir/subdir/ssdir +topfiles -a first-dir/file1 first-dir/file2 +world -a . +statusmod -s Mungeable +# Check for ability to block infinite loops. +infinitealias -a infinitealias +# Prior to 1.11.12 & 1.12.6, the infinite alias loop check didn't strip +# slashes or work if a module called a module which then called itself +# (A -> A was blocked, but not A -> B -> A or deeper). +infinitealias2 -a infinitealias2/ +infinitealias3 -a infinitealias4/ +infinitealias4 -a aliasmodule infinitealias5 +infinitealias5 -a infinitealias3/ +# Options must come before arguments. It is possible this should +# be relaxed at some point (though the result would be bizarre for +# -a); for now test the current behavior. +bogusalias first-dir/subdir/a -a +EOF + dotest modules-148 "$testcvs ci -m 'add modules' CVSROOT/modules" \ +"$CVSROOT_DIRNAME/CVSROOT/modules,v <-- CVSROOT/modules +new revision: 1\.[0-9]*; previous revision: 1\.[0-9]* +$SPROG commit: Rebuilding administrative file database" + + cd .. + # The "statusmod" module contains an error; trying to use it + # will produce "modules file missing directory" I think. + # However, that shouldn't affect the ability of "cvs co -c" or + # "cvs co -s" to do something reasonable with it. + dotest modules-148a0 "$testcvs co -c" \ +'aliasmodule -a first-dir/subdir/a +aliasnested -a first-dir/subdir/ssdir +bogusalias first-dir/subdir/a -a +dirmodule first-dir/subdir +infinitealias -a infinitealias +infinitealias2 -a infinitealias2/ +infinitealias3 -a infinitealias4/ +infinitealias4 -a aliasmodule infinitealias5 +infinitealias5 -a infinitealias3/ +namedmodule -d nameddir first-dir/subdir +realmodule first-dir/subdir a +statusmod -s Mungeable +topfiles -a first-dir/file1 first-dir/file2 +world -a \.' + # There is code in modules.c:save_d which explicitly skips + # modules defined with -a, which is why aliasmodule is not + # listed. + dotest modules-148a1 "${testcvs} co -s" \ +'statusmod Mungeable +bogusalias NONE first-dir/subdir/a -a +dirmodule NONE first-dir/subdir +namedmodule NONE first-dir/subdir +realmodule NONE first-dir/subdir a' + + # Check that infinite loops are avoided + dotest modules-148a1.1 "${testcvs} co infinitealias" \ +"$CPROG checkout: module \`infinitealias' in modules file contains infinite loop" \ +"$SPROG server: module \`infinitealias' in modules file contains infinite loop +$SPROG checkout: module \`infinitealias' in modules file contains infinite loop" + # Prior to 1.11.12 & 1.12.6, the inifinte alias loop check did not + # strip slashes. + dotest modules-148a1.2 "${testcvs} co infinitealias2" \ +"$CPROG checkout: module \`infinitealias2' in modules file contains infinite loop" \ +"$SPROG server: module \`infinitealias2' in modules file contains infinite loop +$SPROG checkout: module \`infinitealias2' in modules file contains infinite loop" + # Prior to 1.11.12 & 1.12.6, the inifinte alias loop check did not + # notice when A -> B -> A, it only noticed A -> A. + dotest modules-148a1.3 "${testcvs} co infinitealias3/" \ +"$CPROG checkout: module \`infinitealias3' in modules file contains infinite loop" \ +"$SPROG server: module \`infinitealias3' in modules file contains infinite loop +$SPROG checkout: module \`infinitealias3' in modules file contains infinite loop" + + # Test that real modules check out to realmodule/a, not subdir/a. + dotest modules-149a1 "${testcvs} co realmodule" "U realmodule/a" + dotest modules-149a2 "test -d realmodule && test -f realmodule/a" "" + dotest_fail modules-149a3 "test -f realmodule/b" "" + dotest modules-149a4 "${testcvs} -q co realmodule" "" + dotest modules-149a5 "echo yes | ${testcvs} release -d realmodule" \ +"You have \[0\] altered files in this repository\. +Are you sure you want to release (and delete) directory .realmodule.: " + + dotest_fail modules-149b1 "${testcvs} co realmodule/a" \ +"${SPROG}"' checkout: module `realmodule/a'\'' is a request for a file in a module which is not a directory' \ +"${SPROG}"' server: module `realmodule/a'\'' is a request for a file in a module which is not a directory +'"${CPROG}"' \[checkout aborted\]: cannot expand modules' + + # Now test the ability to check out a single file from a directory + dotest modules-150c "${testcvs} co dirmodule/a" "U dirmodule/a" + dotest modules-150d "test -d dirmodule && test -f dirmodule/a" "" + dotest_fail modules-150e "test -f dirmodule/b" "" + dotest modules-150f "echo yes | ${testcvs} release -d dirmodule" \ +"You have \[0\] altered files in this repository\. +Are you sure you want to release (and delete) directory .dirmodule.: " + # Now test the ability to correctly reject a non-existent filename. + # For maximum studliness we would check that an error message is + # being output. + # We accept a zero exit status because it is what CVS does + # (Dec 95). Probably the exit status should be nonzero, + # however. + dotest modules-150g1 "${testcvs} co dirmodule/nonexist" \ +"${SPROG} checkout: warning: new-born \`dirmodule/nonexist' has disappeared" + # We tolerate the creation of the dirmodule directory, since that + # is what CVS does, not because we view that as preferable to not + # creating it. + dotest_fail modules-150g2 "test -f dirmodule/a || test -f dirmodule/b" "" + rm -r dirmodule + + # Now test that a module using -d checks out to the specified + # directory. + dotest modules-150h1 "${testcvs} -q co namedmodule" \ +'U nameddir/a +U nameddir/b' + dotest modules-150h2 "test -f nameddir/a && test -f nameddir/b" "" + echo add line >>nameddir/a + dotest modules-150h3 "${testcvs} -q co namedmodule" 'M nameddir/a' + rm nameddir/a + dotest modules-150h4 "${testcvs} -q co namedmodule" 'U nameddir/a' + dotest modules-150h99 "echo yes | ${testcvs} release -d nameddir" \ +"You have \[0\] altered files in this repository\. +Are you sure you want to release (and delete) directory .nameddir.: " + + # Now test that alias modules check out to subdir/a, not + # aliasmodule/a. + dotest modules-151 "${testcvs} co aliasmodule" "" + dotest_fail modules-152 "test -d aliasmodule" "" + echo abc >>first-dir/subdir/a + dotest modules-153 "${testcvs} -q co aliasmodule" "M first-dir/subdir/a" + + cd .. + rm -r 1 + + mkdir 2 + cd 2 + dotest modules-155a0 "${testcvs} co aliasnested" \ +"${SPROG} checkout: Updating first-dir/subdir/ssdir" + dotest modules-155a1 "test -d first-dir" '' + dotest modules-155a2 "test -d first-dir/subdir" '' + dotest modules-155a3 "test -d first-dir/subdir/ssdir" '' + # Test that nothing extraneous got created. + dotest modules-155a4 "ls" "first-dir" \ +"CVS +first-dir" + cd .. + rm -r 2 + + # Test checking out everything. + mkdir 1 + cd 1 + dotest modules-155b "${testcvs} -q co world" \ +"U CVSROOT/${DOTSTAR} +U first-dir/subdir/a +U first-dir/subdir/b" + cd .. + rm -r 1 + + # Test checking out a module which lists at least two + # specific files twice. At one time, this failed over + # remote CVS. + mkdir 1 + cd 1 + dotest modules-155c1 "${testcvs} -q co first-dir" \ +"U first-dir/subdir/a +U first-dir/subdir/b" + + cd first-dir + echo 'first revision' > file1 + echo 'first revision' > file2 + dotest modules-155c2 "${testcvs} add file1 file2" \ +"${SPROG}"' add: scheduling file `file1'\'' for addition +'"${SPROG}"' add: scheduling file `file2'\'' for addition +'"${SPROG}"' add: use .'"${SPROG}"' commit. to add these files permanently' + dotest modules-155c3 "${testcvs} -q ci -m add-it" \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +initial revision: 1\.1 +$CVSROOT_DIRNAME/first-dir/file2,v <-- file2 +initial revision: 1\.1" + + cd .. + rm -r first-dir + dotest modules-155c4 "${testcvs} -q co topfiles" \ +"U first-dir/file1 +U first-dir/file2" + dotest modules-155c5 "${testcvs} -q co topfiles" "" + + # Make sure the right thing happens if we remove a file. + cd first-dir + dotest modules-155c6 "${testcvs} -q rm -f file1" \ +"${SPROG} remove: use .${SPROG} commit. to remove this file permanently" + dotest modules-155c7 "${testcvs} -q ci -m remove-it" \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +new revision: delete; previous revision: 1\.1" + cd .. + rm -r first-dir + dotest modules-155c8 "${testcvs} -q co topfiles" \ +"${SPROG} checkout: warning: \`first-dir/file1' is not (any longer) pertinent +U first-dir/file2" + + dokeep + cd .. + rm -r 1 + modify_repo rm -rf $CVSROOT_DIRNAME/first-dir + ;; + + + + modules2) + # More tests of modules, in particular the & feature. + mkdir 1; cd 1 + dotest modules2-setup-1 "${testcvs} -q co -l ." '' + mkdir first-dir second-dir third-dir + dotest modules2-setup-2 \ +"${testcvs} add first-dir second-dir third-dir" \ +"Directory ${CVSROOT_DIRNAME}/first-dir added to the repository +Directory ${CVSROOT_DIRNAME}/second-dir added to the repository +Directory ${CVSROOT_DIRNAME}/third-dir added to the repository" + cd third-dir + touch file3 + dotest modules2-setup-3 "${testcvs} add file3" \ +"${SPROG} add: scheduling file .file3. for addition +${SPROG} add: use .${SPROG} commit. to add this file permanently" + dotest modules2-setup-4 "${testcvs} -q ci -m add file3" \ +"$CVSROOT_DIRNAME/third-dir/file3,v <-- file3 +initial revision: 1\.1" + cd ../.. + rm -r 1 + + mkdir 1 + cd 1 + + dotest modules2-1 "${testcvs} -q co CVSROOT/modules" \ +'U CVSROOT/modules' + cd CVSROOT + cat >> modules << EOF +ampermodule &first-dir &second-dir +combmodule third-dir file3 &first-dir +ampdirmod -d newdir &first-dir &second-dir +badmod -d newdir +messymod first-dir &messymodchild +messymodchild -d sdir/child second-dir +EOF + # Depending on whether the user also ran the modules test + # we will be checking in revision 1.2 or 1.3. + dotest modules2-2 "${testcvs} -q ci -m add-modules" \ +"$CVSROOT_DIRNAME/CVSROOT/modules,v <-- modules +new revision: 1\.[0-9]*; previous revision: 1\.[0-9]* +$SPROG commit: Rebuilding administrative file database" + + cd .. + + dotest modules2-3 "${testcvs} -q co ampermodule" '' + dotest modules2-4 "test -d ampermodule/first-dir" '' + dotest modules2-5 "test -d ampermodule/second-dir" '' + + # Test ability of cvs release to handle multiple arguments + # See comment at "release" for list of other cvs release tests. + cd ampermodule + if ${testcvs} release -d first-dir second-dir <<EOF >>${LOGFILE} +yes +yes +EOF + then + pass modules2-6 + else + fail modules2-6 + fi + dotest_fail modules2-7 "test -d first-dir" '' + dotest_fail modules2-8 "test -d second-dir" '' + + cd .. + + # There used to be a nasty-hack that made CVS skip creation of the + # module dir (in this case ampermodule) when -n was specified + dotest modules2-ampermod-1 "${testcvs} -q co -n ampermodule" '' + dotest modules2-ampermod-2 "test -d ampermodule/first-dir" '' + dotest modules2-ampermod-3 "test -d ampermodule/second-dir" '' + + # Test release of a module + if echo yes |${testcvs} release -d ampermodule >>${LOGFILE}; then + pass modules2-ampermod-release-1 + else + fail modules2-ampermod-release-1 + fi + dotest_fail modules2-ampermod-release-2 "test -d ampermodule" '' + + # and the '-n' test again, but in conjunction with '-d' + dotest modules2-ampermod-4 "${testcvs} -q co -n -d newname ampermodule" '' + dotest modules2-ampermod-5 "test -d newname/first-dir" '' + dotest modules2-ampermod-6 "test -d newname/second-dir" '' + rm -rf newname + + # Now we create another directory named first-dir and make + # sure that CVS doesn't get them mixed up. + mkdir first-dir + # Note that this message should say "Updating ampermodule/first-dir" + # I suspect. This is a long-standing behavior/bug.... + dotest modules2-9 "${testcvs} co ampermodule" \ +"${SPROG} checkout: Updating first-dir +${SPROG} checkout: Updating second-dir" + touch ampermodule/first-dir/amper1 + cd ampermodule + dotest modules2-10 "${testcvs} add first-dir/amper1" \ +"${SPROG} add: scheduling file .first-dir/amper1. for addition +${SPROG} add: use .${SPROG} commit. to add this file permanently" + cd .. + + # As with the "Updating xxx" message, the "U first-dir/amper1" + # message (instead of "U ampermodule/first-dir/amper1") is + # rather fishy. + dotest modules2-12 "${testcvs} co ampermodule" \ +"${SPROG} checkout: Updating first-dir +A first-dir/amper1 +${SPROG} checkout: Updating second-dir" + + if $remote; then + dotest modules2-13r "$testcvs -q ci -m add-it ampermodule" \ +"$CVSROOT_DIRNAME/first-dir/amper1,v <-- ampermodule/first-dir/amper1 +initial revision: 1\.1" + else + # Trying this as above led to a "protocol error" message. + # Work around this bug. + cd ampermodule + dotest modules2-13 "$testcvs -q ci -m add-it" \ +"$CVSROOT_DIRNAME/first-dir/amper1,v <-- first-dir/amper1 +initial revision: 1\.1" + cd .. + fi + cd .. + rm -r 1 + + # Now test the "combmodule" module (combining regular modules + # and ampersand modules in the same module definition). + mkdir 1; cd 1 + dotest modules2-14 "${testcvs} co combmodule" \ +"U combmodule/file3 +${SPROG} checkout: Updating first-dir +U first-dir/amper1" + dotest modules2-15 "test -f combmodule/file3" "" + dotest modules2-16 "test -f combmodule/first-dir/amper1" "" + cd combmodule + rm -r first-dir + # At least for now there is no way to tell CVS that + # some files/subdirectories come from one repository directory, + # and others from another. + # This seems like a pretty sensible behavior to me, in the + # sense that first-dir doesn't "really" exist within + # third-dir, so CVS just acts as if there is nothing there + # to do. + dotest modules2-17 "${testcvs} update -d" \ +"${SPROG} update: Updating \." + + cd .. + dotest modules2-18 "${testcvs} -q co combmodule" \ +"U first-dir/amper1" + dotest modules2-19 "test -f combmodule/first-dir/amper1" "" + cd .. + rm -r 1 + + # Now test the "ampdirmod" and "badmod" modules to be sure that + # options work with ampersand modules but don't prevent the + # "missing directory" error message. + mkdir 1; cd 1 + dotest modules2-20 "${testcvs} co ampdirmod" \ +"${SPROG} checkout: Updating first-dir +U first-dir/amper1 +${SPROG} checkout: Updating second-dir" + dotest modules2-21 "test -f newdir/first-dir/amper1" "" + dotest modules2-22 "test -d newdir/second-dir" "" + dotest_fail modules2-23 "${testcvs} co badmod" \ +"${SPROG} checkout: modules file missing directory for module badmod" \ +"${SPROG} server: modules file missing directory for module badmod +${CPROG} \[checkout aborted\]: cannot expand modules" + cd .. + rm -r 1 + + # Confirm that a rename with added depth nested in an ampersand + # module works. + mkdir 1; cd 1 + dotest modules2-nestedrename-1 "${testcvs} -q co messymod" \ +"U messymod/amper1" + dotest modules2-nestedrename-2 "test -d messymod/sdir" '' + dotest modules2-nestedrename-3 "test -d messymod/sdir/CVS" '' + dotest modules2-nestedrename-4 "test -d messymod/sdir/child" '' + dotest modules2-nestedrename-5 "test -d messymod/sdir/child/CVS" '' + cd ..; rm -r 1 + + # FIXME: client/server has a bug. It should be working like a local + # repository in this case, but fails to check out the second module + # in the list when a branch is specified. + mkdir 1; cd 1 + dotest modules2-ampertag-setup-1 \ +"${testcvs} -Q rtag tag first-dir second-dir third-dir" \ +'' + dotest modules2-ampertag-1 "${testcvs} -q co -rtag ampermodule" \ +"U first-dir/amper1" + if $remote; then + dotest_fail modules2-ampertag-2 "test -d ampermodule/second-dir" '' + dotest_fail modules2-ampertag-3 "test -d ampermodule/second-dir/CVS" '' + else + dotest modules2-ampertag-2 "test -d ampermodule/second-dir" '' + dotest modules2-ampertag-3 "test -d ampermodule/second-dir/CVS" '' + fi + cd ..; rm -r 1 + + # Test for tag files when an ampermod is renamed with more path + # elements than it started with. + # + # FIXME: This is currently broken in the remote case, possibly only + # because the messymodchild isn't being checked out at all. + mkdir 1; cd 1 +# dotest modules2-tagfiles-setup-1 \ +#"${testcvs} -Q rtag -b branch first-dir second-dir" \ +#'' + dotest modules2-tagfiles-1 "${testcvs} -q co -rtag messymod" \ +"U messymod/amper1" + if $remote; then + dotest_fail modules2-tagfiles-2r "test -d messymod/sdir" '' + else + dotest modules2-tagfiles-2 "cat messymod/sdir/CVS/Tag" 'Ttag' + fi + cd ..; rm -r 1 + + # Test that CVS gives an error if one combines -a with + # other options. + # Probably would be better to break this out into a separate + # test. Although it is short, it shares no files/state with + # the rest of the modules2 tests. + mkdir 1; cd 1 + dotest modules2-a0.5 "${testcvs} -q co CVSROOT/modules" \ +'U CVSROOT/modules' + cd CVSROOT + echo 'aliasopt -a -d onedir first-dir' >modules + dotest modules2-a0 "${testcvs} -q ci -m add-modules" \ +"$CVSROOT_DIRNAME/CVSROOT/modules,v <-- modules +new revision: 1\.[0-9]*; previous revision: 1\.[0-9]* +$SPROG commit: Rebuilding administrative file database" + cd .. + dotest_fail modules2-a1 "${testcvs} -q co aliasopt" \ +"${SPROG} checkout: -a cannot be specified in the modules file along with other options" \ +"${SPROG} server: -a cannot be specified in the modules file along with other options +${CPROG} \[checkout aborted\]: cannot expand modules" + cd ..; rm -r 1 + + # Clean up. + modify_repo rm -rf $CVSROOT_DIRNAME/first-dir \ + $CVSROOT_DIRNAME/second-dir \ + $CVSROOT_DIRNAME/third-dir + ;; + + + + modules3) + # More tests of modules, in particular what happens if several + # modules point to the same file. + + # First just set up a directory first-dir and a file file1 in it. + mkdir 1; cd 1 + + dotest modules3-0 "$testcvs -q co -l ." + mkdir first-dir + dotest modules3-1 "${testcvs} add first-dir" \ +"Directory ${CVSROOT_DIRNAME}/first-dir added to the repository" + + cd first-dir + echo file1 >file1 + dotest modules3-2 "${testcvs} add file1" \ +"${SPROG} add: scheduling file \`file1' for addition +${SPROG} add: use \`${SPROG} commit' to add this file permanently" + dotest modules3-3 "${testcvs} -q ci -m add-it" \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +initial revision: 1\.1" + cd .. + + dotest modules3-4 "${testcvs} -q update -d CVSROOT" \ +"U CVSROOT${DOTSTAR}" + cd CVSROOT + cat >modules <<EOF +mod1 -a first-dir/file1 +bigmod -a mod1 first-dir/file1 +namednest -d src/sub/dir first-dir +nestdeeper -d src/sub1/sub2/sub3/dir first-dir +nestshallow -d src/dir second-dir/suba/subb +path/in/modules &mod1 +another/path/test -d another/path/test first-dir +EOF + dotest modules3-5 "${testcvs} -q ci -m add-modules" \ +"$CVSROOT_DIRNAME/CVSROOT/modules,v <-- modules +new revision: 1\.[0-9]*; previous revision: 1\.[0-9]* +$SPROG commit: Rebuilding administrative file database" + cd .. + + dotest modules3-6 "${testcvs} -q co bigmod" '' + rm -r first-dir + dotest modules3-7 "${testcvs} -q co bigmod" 'U first-dir/file1' + cd .. + rm -r 1 + + mkdir 1; cd 1 + mkdir suba + mkdir suba/subb + # This fails to work remote (it doesn't notice the directories, + # I suppose because they contain no files). Bummer, especially + # considering this is a documented technique and everything. + dotest modules3-7a \ +"${testcvs} import -m add-dirs second-dir tag1 tag2" \ +"${SPROG} import: Importing ${CVSROOT_DIRNAME}/second-dir/suba +${SPROG} import: Importing ${CVSROOT_DIRNAME}/second-dir/suba/subb + +No conflicts created by this import" " +No conflicts created by this import" + cd ..; rm -r 1 + mkdir 1; cd 1 + dotest modules3-7b "${testcvs} co second-dir" \ +"${SPROG} checkout: Updating second-dir +${SPROG} checkout: Updating second-dir/suba +${SPROG} checkout: Updating second-dir/suba/subb" \ +"${SPROG} checkout: Updating second-dir" + + if $remote; then + cd second-dir + mkdir suba + dotest modules3-7-workaround1 "${testcvs} add suba" \ +"Directory ${CVSROOT_DIRNAME}/second-dir/suba added to the repository" + cd suba + mkdir subb + dotest modules3-7-workaround2 "${testcvs} add subb" \ +"Directory ${CVSROOT_DIRNAME}/second-dir/suba/subb added to the repository" + cd ../.. + fi + + cd second-dir/suba/subb + touch fileb + dotest modules3-7c "${testcvs} add fileb" \ +"${SPROG} add: scheduling file .fileb. for addition +${SPROG} add: use .${SPROG} commit. to add this file permanently" + dotest modules3-7d "${testcvs} -q ci -m add-it" \ +"$CVSROOT_DIRNAME/second-dir/suba/subb/fileb,v <-- fileb +initial revision: 1\.1" + cd ../../.. + cd ..; rm -r 1 + + mkdir 1 + cd 1 + dotest modules3-8 "${testcvs} -q co namednest" \ +'U src/sub/dir/file1' + dotest modules3-9 "test -f src/sub/dir/file1" '' + cd .. + rm -r 1 + + # Try the same thing, but with the directories nested even + # deeper (deeply enough so they are nested more deeply than + # the number of directories from / to ${TESTDIR}). + mkdir 1 + cd 1 + dotest modules3-10 "${testcvs} -q co nestdeeper" \ +'U src/sub1/sub2/sub3/dir/file1' + dotest modules3-11 "test -f src/sub1/sub2/sub3/dir/file1" '' + + # While we are doing things like twisted uses of '/' (e.g. + # modules3-12), try this one. + if $remote; then + dotest_fail modules3-11b \ +"${testcvs} -q update ${TESTDIR}/1/src/sub1/sub2/sub3/dir/file1" \ +"absolute pathnames invalid for server (specified .${TESTDIR}/1/src/sub1/sub2/sub3/dir.)" + fi # end of remote-only tests + + cd .. + rm -r 1 + + # This one is almost too twisted for words. The pathname output + # in the message from "co" doesn't include the "path/in/modules", + # but those directories do get created (with no CVSADM except + # in "modules" which has a CVSNULLREPOS). + # I'm not sure anyone is relying on this nonsense or whether we + # need to keep doing it, but it is what CVS currently does... + # Skip it for remote; the remote code has the good sense to + # not deal with it (on the minus side it gives + # "internal error: repository string too short." (CVS 1.9) or + # "warning: server is not creating directories one at a time" (now) + # instead of a real error). + # I'm tempted to just make it a fatal error to have '/' in a + # module name. But see comments at modules3-16. + if $remote; then :; else + mkdir 1; cd 1 + dotest modules3-12 "${testcvs} -q co path/in/modules" \ +"U first-dir/file1" + dotest modules3-13 "test -f path/in/modules/first-dir/file1" '' + cd ..; rm -r 1 + fi # end of tests skipped for remote + + # Now here is where it used to get seriously bogus. + mkdir 1; cd 1 + dotest modules3-14 \ +"${testcvs} -q rtag tag1 path/in/modules" '' + # CVS used to create this even though rtag should *never* affect + # the directory current when it is called! + dotest_fail modules3-15 "test -d path/in/modules" '' + # Just for trivia's sake, rdiff was not similarly vulnerable + # because it passed 0 for run_module_prog to do_module. + cd ..; rm -r 1 + + # Some people seem to want this to work. I still suspect there + # are dark corners in slashes in module names. This probably wants + # more thought before we start hacking on CVS (one way or the other) + # or documenting this. + mkdir 2; cd 2 + dotest modules3-16 "${testcvs} -q co another/path/test" \ +"U another/path/test/file1" + dotest modules3-17 "cat another/path/test/file1" 'file1' + + dokeep + cd ..; rm -r 2 + modify_repo rm -rf $CVSROOT_DIRNAME/first-dir \ + $CVSROOT_DIRNAME/second-dir + ;; + + + + modules4) + # Some tests using the modules file with aliases that + # exclude particular directories. + + mkdir 1; cd 1 + + dotest modules4-1 "${testcvs} -q co -l ." '' + mkdir first-dir + dotest modules4-2 "${testcvs} add first-dir" \ +"Directory ${CVSROOT_DIRNAME}/first-dir added to the repository" + + cd first-dir + mkdir subdir subdir_long + dotest modules4-3 "${testcvs} add subdir subdir_long" \ +"Directory ${CVSROOT_DIRNAME}/first-dir/subdir added to the repository +Directory ${CVSROOT_DIRNAME}/first-dir/subdir_long added to the repository" + + echo file1 > file1 + dotest modules4-4 "${testcvs} add file1" \ +"${SPROG}"' add: scheduling file `file1'\'' for addition +'"${SPROG}"' add: use .'"${SPROG}"' commit. to add this file permanently' + + echo file2 > subdir/file2 + dotest modules4-5 "${testcvs} add subdir/file2" \ +"${SPROG}"' add: scheduling file `subdir/file2'\'' for addition +'"${SPROG}"' add: use .'"${SPROG}"' commit. to add this file permanently' + + echo file3 > subdir_long/file3 + dotest modules4-6 "${testcvs} add subdir_long/file3" \ +"${SPROG}"' add: scheduling file `subdir_long/file3'\'' for addition +'"${SPROG}"' add: use .'"${SPROG}"' commit. to add this file permanently' + + dotest modules4-7 "${testcvs} -q ci -m add-it" \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +initial revision: 1\.1 +$CVSROOT_DIRNAME/first-dir/subdir/file2,v <-- subdir/file2 +initial revision: 1\.1 +$CVSROOT_DIRNAME/first-dir/subdir_long/file3,v <-- subdir_long/file3 +initial revision: 1\.1" + + cd .. + + dotest modules4-8 "${testcvs} -q update -d CVSROOT" \ +"U CVSROOT${DOTSTAR}" + cd CVSROOT + cat >modules <<EOF +all -a first-dir +some -a !first-dir/subdir first-dir +other -a !first-dir/subdir !first-dir/subdir_long first-dir +somewhat -a first-dir !first-dir/subdir +EOF + dotest modules4-9 "${testcvs} -q ci -m add-modules" \ +"$CVSROOT_DIRNAME/CVSROOT/modules,v <-- modules +new revision: 1\.[0-9]*; previous revision: 1\.[0-9]* +$SPROG commit: Rebuilding administrative file database" + cd .. + + cd .. + mkdir 2; cd 2 + + dotest modules4-10 "${testcvs} -q co all" \ +"U first-dir/file1 +U first-dir/subdir/file2 +U first-dir/subdir_long/file3" + rm -r first-dir + + dotest modules4-11 "${testcvs} -q co some" \ +"U first-dir/file1 +U first-dir/subdir_long/file3" + dotest_fail modules4-12 "test -d first-dir/subdir" '' + dotest modules4-13 "test -d first-dir/subdir_long" '' + rm -r first-dir + + if $remote; then + # But remote seems to do it the other way. + dotest modules4-14r-1 "${testcvs} -q co somewhat" \ +"U first-dir/file1 +U first-dir/subdir_long/file3" + dotest_fail modules4-14r-2 "test -d first-dir/subdir" '' + dotest modules4-14r-3 "test -d first-dir/subdir_long" '' + else + # This is strange behavior, in that the order of the + # "!first-dir/subdir" and "first-dir" matter, and it isn't + # clear that they should. I suspect it is long-standing + # strange behavior but I haven't verified that. + dotest modules4-14-1 "${testcvs} -q co somewhat" \ +"U first-dir/file1 +U first-dir/subdir/file2 +U first-dir/subdir_long/file3" + dotest modules4-14-2 "test -d first-dir/subdir" '' + dotest modules4-14-3 "test -d first-dir/subdir_long" '' + fi + rm -r first-dir + + dotest modules4-15 "${testcvs} -q co other" \ +"U first-dir/file1" + dotest_fail modules4-16 "test -d first-dir/subdir" '' + dotest_fail modules4-17 "test -d first-dir/subdir_long" '' + rm -r first-dir + + cd .. + rm -r 2 + + dotest modules4-18 "${testcvs} rtag tag some" \ +"${SPROG} rtag: Tagging first-dir +${SPROG} rtag: Ignoring first-dir/subdir +${SPROG} rtag: Tagging first-dir/subdir_long" + + cd 1/first-dir/subdir + dotest modules4-19 "${testcvs} log file2" " +RCS file: ${CVSROOT_DIRNAME}/first-dir/subdir/file2,v +Working file: file2 +head: 1\.1 +branch: +locks: strict +access list: +symbolic names: +keyword substitution: kv +total revisions: 1; selected revisions: 1 +description: +---------------------------- +revision 1\.1 +date: ${ISO8601DATE}; author: ${username}; state: Exp; commitid: ${commitid}; +add-it +=============================================================================" + + dokeep + cd ../../.. + rm -r 1 + modify_repo rm -rf $CVSROOT_DIRNAME/first-dir + ;; + + + + modules5) + # Test module programs + + modify_repo mkdir $CVSROOT_DIRNAME/first-dir + mkdir 1 + cd 1 + dotest modules5-1 "$testcvs -q co first-dir" + cd first-dir + mkdir subdir + dotest modules5-2 "${testcvs} add subdir" \ +"Directory ${CVSROOT_DIRNAME}/first-dir/subdir added to the repository" + cd subdir + mkdir ssdir + dotest modules5-3 "${testcvs} add ssdir" \ +"Directory ${CVSROOT_DIRNAME}/first-dir/subdir/ssdir added to the repository" + touch a b + dotest modules5-4 "${testcvs} add a b" \ +"${SPROG} add: scheduling file .a. for addition +${SPROG} add: scheduling file .b. for addition +${SPROG} add: use .${SPROG} commit. to add these files permanently" + + dotest modules5-5 "${testcvs} ci -m added" \ +"${CPROG} commit: Examining . +${CPROG} commit: Examining ssdir +${CVSROOT_DIRNAME}/first-dir/subdir/a,v <-- a +initial revision: 1\.1 +${CVSROOT_DIRNAME}/first-dir/subdir/b,v <-- b +initial revision: 1\.1" + + cd .. + dotest modules5-6 "${testcvs} -q co CVSROOT" \ +"U CVSROOT/checkoutlist +U CVSROOT/commitinfo +U CVSROOT/config +U CVSROOT/cvswrappers +U CVSROOT/loginfo +U CVSROOT/modules +U CVSROOT/notify +U CVSROOT/postadmin +U CVSROOT/postproxy +U CVSROOT/posttag +U CVSROOT/postwatch +U CVSROOT/preproxy +U CVSROOT/rcsinfo +U CVSROOT/taginfo +U CVSROOT/verifymsg" + + # FIXCVS: The sleep in the following script helps avoid out of + # order messages, but we really need to figure out how to fix + # cvs to prevent them in the first place. + for i in checkout export tag; do + cat >> ${CVSROOT_DIRNAME}/$i.sh <<EOF +#! $TESTSHELL +sleep 1 +echo "$i script invoked in \`pwd\`" +echo "args: \$@" +EOF + # Cygwin doesn't set premissions correctly over the Samba share. + if test -n "$remotehost"; then + $CVS_RSH $remotehost "chmod +x ${CVSROOT_DIRNAME}/$i.sh" + else + chmod +x ${CVSROOT_DIRNAME}/$i.sh + fi + done + + OPTS="-o${CVSROOT_DIRNAME}/checkout.sh -e ${CVSROOT_DIRNAME}/export.sh -t${CVSROOT_DIRNAME}/tag.sh" + cat >CVSROOT/modules <<EOF +realmodule ${OPTS} first-dir/subdir a +dirmodule ${OPTS} first-dir/subdir +namedmodule -d nameddir ${OPTS} first-dir/subdir +EOF + + dotest modules5-7 "$testcvs -Q ci -m 'add modules' CVSROOT/modules" + + cd .. + rm -rf first-dir + + # Test that real modules check out to realmodule/a, not subdir/a. + if $remote; then + # FIXCVS? + # Mac OSX 10.3 (Darwin ppc-osx1 5.5) fails here when $TMPDIR + # contains a symlink (it does not fail the local modules5-8). + # Since no other platforms are exhibiting the same problem, I + # suspect an issue with OSX and fork() or the like dereferencing + # the symlink, but it is possible it is something that could be + # fixed or worked around in CVS. + dotest modules5-8r "$testcvs co realmodule" \ +"U realmodule/a +${SPROG} checkout: Executing ..${CVSROOT_DIRNAME}/checkout\.sh. .realmodule.. +checkout script invoked in ${TMPDIR}/cvs-serv[0-9a-z]* +args: realmodule" + else + dotest modules5-8 "${testcvs} co realmodule" \ +"U realmodule/a +${SPROG} checkout: Executing ..${CVSROOT_DIRNAME}/checkout\.sh. .realmodule.. +checkout script invoked in ${TESTDIR}/1 +args: realmodule" + fi + dotest modules5-9 "test -d realmodule && test -f realmodule/a" "" + dotest_fail modules5-10 "test -f realmodule/b" "" + if $remote; then + dotest modules5-11 "${testcvs} -q co realmodule" \ +"checkout script invoked in ${TMPDIR}/cvs-serv[0-9a-z]* +args: realmodule" + dotest modules5-12 "${testcvs} -q update" '' + echo "change" >>realmodule/a + dotest modules5-13 "${testcvs} -q ci -m." \ +"$CVSROOT_DIRNAME/first-dir/subdir/a,v <-- realmodule/a +new revision: 1\.2; previous revision: 1\.1" + else + dotest modules5-11 "${testcvs} -q co realmodule" \ +"checkout script invoked in ${TESTDIR}/1 +args: realmodule" + dotest modules5-12 "${testcvs} -q update" '' + echo "change" >>realmodule/a + dotest modules5-13 "${testcvs} -q ci -m." \ +"$CVSROOT_DIRNAME/first-dir/subdir/a,v <-- realmodule/a +new revision: 1\.2; previous revision: 1\.1" + fi + dotest modules5-14 "echo yes | ${testcvs} release -d realmodule" \ +"You have \[0\] altered files in this repository\. +Are you sure you want to release (and delete) directory .realmodule.: " + dotest modules5-15 "${testcvs} -q rtag -Dnow MYTAG realmodule" \ +"tag script invoked in ${TESTDIR}/1 +args: realmodule MYTAG" \ +"tag script invoked in ${TMPDIR}/cvs-serv[0-9a-z]* +args: realmodule MYTAG" + if $remote; then + dotest modules5-16 "${testcvs} -q export -r MYTAG realmodule" \ +"U realmodule/a +export script invoked in ${TMPDIR}/cvs-serv[0-9a-z]* +args: realmodule" + else + dotest modules5-16 "${testcvs} -q export -r MYTAG realmodule" \ +"U realmodule/a +export script invoked in ${TESTDIR}/1 +args: realmodule" + fi + rm -r realmodule + + dotest_fail modules5-17 "${testcvs} co realmodule/a" \ +"${SPROG}"' checkout: module `realmodule/a'\'' is a request for a file in a module which is not a directory' \ +"${SPROG}"' server: module `realmodule/a'\'' is a request for a file in a module which is not a directory +'"${CPROG}"' \[checkout aborted\]: cannot expand modules' + + # Now test the ability to check out a single file from a directory + if $remote; then + dotest modules5-18 "${testcvs} co dirmodule/a" \ +"U dirmodule/a +${SPROG} checkout: Executing ..${CVSROOT_DIRNAME}/checkout\.sh. .dirmodule.. +checkout script invoked in ${TMPDIR}/cvs-serv[0-9a-z]* +args: dirmodule" + else + dotest modules5-18 "${testcvs} co dirmodule/a" \ +"U dirmodule/a +${SPROG} checkout: Executing ..${CVSROOT_DIRNAME}/checkout\.sh. .dirmodule.. +checkout script invoked in ${TESTDIR}/1 +args: dirmodule" + fi + dotest modules5-19 "test -d dirmodule && test -f dirmodule/a" "" + dotest_fail modules5-20 "test -f dirmodule/b" "" + dotest modules5-21 "echo yes | ${testcvs} release -d dirmodule" \ +"You have \[0\] altered files in this repository\. +Are you sure you want to release (and delete) directory .dirmodule.: " + + # Now test the ability to correctly reject a non-existent filename. + # For maximum studliness we would check that an error message is + # being output. + # We accept a zero exit status because it is what CVS does + # (Dec 95). Probably the exit status should be nonzero, + # however. + if $remote; then + dotest modules5-22 "${testcvs} co dirmodule/nonexist" \ +"${SPROG} checkout: warning: new-born \`dirmodule/nonexist' has disappeared +${SPROG} checkout: Executing ..${CVSROOT_DIRNAME}/checkout\.sh. .dirmodule.. +checkout script invoked in ${TMPDIR}/cvs-serv[0-9a-z]* +args: dirmodule" + else + dotest modules5-22 "${testcvs} co dirmodule/nonexist" \ +"${SPROG} checkout: warning: new-born \`dirmodule/nonexist' has disappeared +${SPROG} checkout: Executing ..${CVSROOT_DIRNAME}/checkout\.sh. .dirmodule.. +checkout script invoked in ${TESTDIR}/1 +args: dirmodule" + fi + # We tolerate the creation of the dirmodule directory, since that + # is what CVS does, not because we view that as preferable to not + # creating it. + dotest_fail modules5-23 "test -f dirmodule/a || test -f dirmodule/b" "" + rm -r dirmodule + + # Now test that a module using -d checks out to the specified + # directory. + if $remote; then + dotest modules5-24 "${testcvs} -q co namedmodule" \ +"U nameddir/a +U nameddir/b +checkout script invoked in ${TMPDIR}/cvs-serv[0-9a-z]* +args: nameddir" + else + dotest modules5-24 "${testcvs} -q co namedmodule" \ +"U nameddir/a +U nameddir/b +checkout script invoked in ${TESTDIR}/1 +args: nameddir" + fi + dotest modules5-25 "test -f nameddir/a && test -f nameddir/b" "" + echo add line >>nameddir/a + # This seems suspicious: when we checkout an existing directory, + # the checkout script gets executed in addition to the update + # script. Is that by design or accident? + if $remote; then + dotest modules5-26 "${testcvs} -q co namedmodule" \ +"M nameddir/a +checkout script invoked in ${TMPDIR}/cvs-serv[0-9a-z]* +args: nameddir" + else + dotest modules5-26 "${testcvs} -q co namedmodule" \ +"M nameddir/a +checkout script invoked in ${TESTDIR}/1 +args: nameddir" + fi + rm nameddir/a + + if $remote; then + dotest modules5-27 "${testcvs} -q co namedmodule" \ +"U nameddir/a +checkout script invoked in ${TMPDIR}/cvs-serv[0-9a-z]* +args: nameddir" + else + dotest modules5-27 "${testcvs} -q co namedmodule" \ +"U nameddir/a +checkout script invoked in ${TESTDIR}/1 +args: nameddir" + fi + dotest modules5-28 "echo yes | ${testcvs} release -d nameddir" \ +"You have \[0\] altered files in this repository\. +Are you sure you want to release (and delete) directory .nameddir.: " + + # Now try the same tests with -d on command line + # FIXCVS? The manual says the modules programs get the module name, + # but they really get the directory name. + if $remote; then + dotest modules5-29 "${testcvs} co -d mydir realmodule" \ +"U mydir/a +${SPROG} checkout: Executing ..${CVSROOT_DIRNAME}/checkout\.sh. .mydir.. +checkout script invoked in ${TMPDIR}/cvs-serv[0-9a-z]* +args: mydir" + else + dotest modules5-29 "${testcvs} co -d mydir realmodule" \ +"U mydir/a +${SPROG} checkout: Executing ..${CVSROOT_DIRNAME}/checkout\.sh. .mydir.. +checkout script invoked in ${TESTDIR}/1 +args: mydir" + fi + dotest modules5-30 "test -d mydir && test -f mydir/a" "" + dotest_fail modules5-31 "test -d realmodule || test -f mydir/b" "" + if $remote; then + dotest modules5-32 "${testcvs} -q co -d mydir realmodule" \ +"checkout script invoked in ${TMPDIR}/cvs-serv[0-9a-z]* +args: mydir" + dotest modules5-33 "${testcvs} -q update" '' + echo "change" >>mydir/a + dotest modules5-34 "${testcvs} -q ci -m." \ +"$CVSROOT_DIRNAME/first-dir/subdir/a,v <-- mydir/a +new revision: 1\.3; previous revision: 1\.2" + else + dotest modules5-32 "${testcvs} -q co -d mydir realmodule" \ +"checkout script invoked in ${TESTDIR}/1 +args: mydir" + dotest modules5-33 "${testcvs} -q update" '' + echo "change" >>mydir/a + dotest modules5-34 "${testcvs} -q ci -m." \ +"$CVSROOT_DIRNAME/first-dir/subdir/a,v <-- mydir/a +new revision: 1\.3; previous revision: 1\.2" + fi + dotest modules5-35 "echo yes | ${testcvs} release -d mydir" \ +"You have \[0\] altered files in this repository\. +Are you sure you want to release (and delete) directory .mydir.: " + if $remote; then + dotest modules5-36 "${testcvs} -q rtag -Dnow MYTAG2 realmodule" \ +"tag script invoked in ${TMPDIR}/cvs-serv[0-9a-z]* +args: realmodule MYTAG2" + dotest modules5-37 "${testcvs} -q export -r MYTAG2 -d mydir realmodule" \ +"U mydir/a +export script invoked in ${TMPDIR}/cvs-serv[0-9a-z]* +args: mydir" + else + dotest modules5-36 "${testcvs} -q rtag -Dnow MYTAG2 realmodule" \ +"tag script invoked in ${TESTDIR}/1 +args: realmodule MYTAG2" + dotest modules5-37 "${testcvs} -q export -r MYTAG2 -d mydir realmodule" \ +"U mydir/a +export script invoked in ${TESTDIR}/1 +args: mydir" + fi + rm -r mydir + + # Now test the ability to check out a single file from a directory + if $remote; then + dotest modules5-38 "${testcvs} co -d mydir dirmodule/a" \ +"U mydir/a +${SPROG} checkout: Executing ..${CVSROOT_DIRNAME}/checkout\.sh. .mydir.. +checkout script invoked in ${TMPDIR}/cvs-serv[0-9a-z]* +args: mydir" + else + dotest modules5-38 "${testcvs} co -d mydir dirmodule/a" \ +"U mydir/a +${SPROG} checkout: Executing ..${CVSROOT_DIRNAME}/checkout\.sh. .mydir.. +checkout script invoked in ${TESTDIR}/1 +args: mydir" + fi + dotest modules5-39 "test -d mydir && test -f mydir/a" "" + dotest_fail modules5-40 "test -d dirmodule || test -f mydir/b" "" + dotest modules5-41 "echo yes | ${testcvs} release -d mydir" \ +"You have \[0\] altered files in this repository\. +Are you sure you want to release (and delete) directory .mydir.: " + + # Now test the ability to correctly reject a non-existent filename. + # For maximum studliness we would check that an error message is + # being output. + # We accept a zero exit status because it is what CVS does + # (Dec 95). Probably the exit status should be nonzero, + # however. + if $remote; then + dotest modules5-42 "${testcvs} co -d mydir dirmodule/nonexist" \ +"${SPROG} checkout: warning: new-born \`mydir/nonexist' has disappeared +${SPROG} checkout: Executing ..${CVSROOT_DIRNAME}/checkout\.sh. .mydir.. +checkout script invoked in ${TMPDIR}/cvs-serv[0-9a-z]* +args: mydir" + else + dotest modules5-42 "${testcvs} co -d mydir dirmodule/nonexist" \ +"${SPROG} checkout: warning: new-born \`mydir/nonexist' has disappeared +${SPROG} checkout: Executing ..${CVSROOT_DIRNAME}/checkout\.sh. .mydir.. +checkout script invoked in ${TESTDIR}/1 +args: mydir" + fi + # We tolerate the creation of the mydir directory, since that + # is what CVS does, not because we view that as preferable to not + # creating it. + dotest_fail modules5-43 "test -f mydir/a || test -f mydir/b" "" + rm -r mydir + + if $remote; then + dotest modules5-44 "${testcvs} -q co -d mydir namedmodule" \ +"U mydir/a +U mydir/b +checkout script invoked in ${TMPDIR}/cvs-serv[0-9a-z]* +args: mydir" + else + dotest modules5-44 "${testcvs} -q co -d mydir namedmodule" \ +"U mydir/a +U mydir/b +checkout script invoked in ${TESTDIR}/1 +args: mydir" + fi + dotest modules5-45 "test -f mydir/a && test -f mydir/b" "" + dotest_fail modules5-46 "test -d namedir" + echo add line >>mydir/a + # This seems suspicious: when we checkout an existing directory, + # the checkout script gets executed in addition to the update + # script. Is that by design or accident? + if $remote; then + dotest modules5-47 "${testcvs} -q co -d mydir namedmodule" \ +"M mydir/a +checkout script invoked in ${TMPDIR}/cvs-serv[0-9a-z]* +args: mydir" + else + dotest modules5-47 "${testcvs} -q co -d mydir namedmodule" \ +"M mydir/a +checkout script invoked in ${TESTDIR}/1 +args: mydir" + fi + rm mydir/a + + if $remote; then + dotest modules5-48 "${testcvs} -q co -d mydir namedmodule" \ +"U mydir/a +checkout script invoked in ${TMPDIR}/cvs-serv[0-9a-z]* +args: mydir" + else + dotest modules5-48 "${testcvs} -q co -d mydir namedmodule" \ +"U mydir/a +checkout script invoked in ${TESTDIR}/1 +args: mydir" + fi + dotest modules5-49 "echo yes | ${testcvs} release -d mydir" \ +"You have \[0\] altered files in this repository\. +Are you sure you want to release (and delete) directory .mydir.: " + + dokeep + cd .. + rm -r 1 + modify_repo rm -rf $CVSROOT_DIRNAME/first-dir \ + $CVSROOT_DIRNAME/*.sh + ;; + + + + modules6) + # + # Test invalid module definitions + # + # See the header comment for the `modules' test for an index of + # the complete suite of modules tests. + # + + # + # There was a bug in CVS through 1.11.1p1 where a bad module name + # would cause the previous line to be parsed as the module + # definition. This test proves this doesn't happen anymore. + # + mkdir modules6 + cd modules6 + dotest module6-setup-1 "${testcvs} -Q co CVSROOT" "" + cd CVSROOT + echo "longmodulename who cares" >modules + echo "badname" >>modules + # This test almost isn't setup since it generates the error message + # we are looking for if `-Q' isn't specified, but I want to test the + # filename in the message later. + dotest modules6-setup-2 "$testcvs -Q ci -mbad-modules" + + # Here's where CVS would report not being able to find `lename' + cd .. + dotest_fail modules6-1 "${testcvs} -q co badname" \ +"${SPROG} checkout: warning: NULL value for key .badname. at line 2 of .${CVSROOT_DIRNAME}/CVSROOT/modules. +${SPROG} checkout: cannot find module .badname. - ignored" \ +"${SPROG} server: warning: NULL value for key .badname. at line 2 of .${CVSROOT_DIRNAME}/CVSROOT/modules. +${SPROG} server: cannot find module .badname. - ignored +${CPROG} \[checkout aborted\]: cannot expand modules" + + dokeep + restore_adm + cd .. + rm -r modules6 + ;; + + + + modules7) + # + # Test tag problems vs an empty CVSROOT/val-tags file + # + # See the header comment for the `modules' test for an index of + # the complete suite of modules tests. + # + mkdir modules7 + cd modules7 + dotest modules7-1 "$testcvs -Q co -d top ." + cd top + mkdir zero one + dotest modules7-2 "$testcvs -Q add zero one" + cd one + echo 'file1 contents' > file1 + dotest modules7-2 "$testcvs -Q add file1" + dotest modules7-3 "$testcvs -Q ci -mnew file1" + dotest modules7-4 "$testcvs -Q tag mytag file1" + cd ../CVSROOT + echo 'all -a zero one' > modules + dotest modules7-5 "$testcvs -Q ci -mall-module" + cd ../.. + mkdir myexport + cd myexport + + # This failed prior to CVS version 1.12.10. + dotest modules7-7 "$testcvs export -rmytag all" \ +"$SPROG export: Updating zero +$SPROG export: Updating one +U one/file1" + dotest modules7-8 'cat one/file1' 'file1 contents' + + dokeep + + # cleanup + restore_adm + cd ../.. + rm -fr modules7 + rm -rf $CVSROOT_DIRNAME/zero $CVSROOT_DIRNAME/one + ;; + + + + mkmodules) + # When a file listed in checkoutlist doesn't exist, cvs-1.10.4 + # would fail to remove the CVSROOT/.#[0-9]* temporary file it + # creates while mkmodules is in the process of trying to check + # out the missing file. + + mkdir 1; cd 1 + dotest mkmodules-temp-file-removal-1 "${testcvs} -Q co CVSROOT" '' + cd CVSROOT + echo no-such-file >> checkoutlist + dotest mkmodules-temp-file-removal-2 "$testcvs -Q ci -m. checkoutlist" + + dotest mkmodules-temp-file-removal-3 \ +"echo $CVSROOT_DIRNAME/CVSROOT/.#[0-9]*" \ +"$CVSROOT_DIRNAME/CVSROOT/\.#\[0-9\]\*" + + # Versions 1.11.6 & 1.12.1 and earlier of CVS printed most of the + # white space included before error messages in checkoutlist. + echo "no-such-file Failed to update no-such-file." >checkoutlist + dotest mkmodules-error-message-1 "$testcvs -Q ci -m. checkoutlist" \ +"$SPROG commit: Failed to update no-such-file\." + + # Versions 1.11.6 & 1.12.1 and earlier of CVS used the error string + # from the checkoutlist file as the format string passed to error()'s + # printf. Check that this is no longer the case by verifying that + # printf format patterns remain unchanged. + echo "no-such-file Failed to update %s %lx times because %s happened %d times." >checkoutlist + dotest mkmodules-error-message-2 "$testcvs -Q ci -m. checkoutlist" \ +"$SPROG commit: Failed to update %s %lx times because %s happened %d times\." + + dotest mkmodules-cleanup-1 \ +"$testcvs -Q up -pr1.1 checkoutlist >checkoutlist" + dotest mkmodules-cleanup-2 "$testcvs -Q ci -m. checkoutlist" + + dokeep + cd ../.. + rm -r 1 + ;; + + + + co-d) + # Some tests of various permutations of co-d when directories exist + # and checkouts lengthen. + # + # Interestingly enough, these same tests pass when the directory + # lengthening happens via the modules file. Go figure. + module=co-d + mkdir $module; cd $module + mkdir top; cd top + dotest co-d-init-1 "$testcvs -Q co -l ." + mkdir $module + dotest co-d-init-2 "$testcvs -Q add $module" + cd $module + echo content >file1 + echo different content >file2 + dotest co-d-init-3 "$testcvs -Q add file1 file2" + dotest co-d-init-4 "$testcvs -Q ci -madd-em" + cd ../.. + + mkdir 2; cd 2 + dotest co-d-1 "$testcvs -q co -d dir $module" \ +"U dir/file1 +U dir/file2" + dotest co-d-1.2 "cat dir/CVS/Repository" "$module" + + dotest co-d-2 "$testcvs -q co -d dir2/sdir $module" \ +"U dir2/sdir/file1 +U dir2/sdir/file2" + dotest co-d-2.2 "cat dir2/CVS/Repository" "." + dotest co-d-2.3 "cat dir2/sdir/CVS/Repository" "$module" + + dotest co-d-2.4 "$testcvs -q co -d dir2.4/sdir/sdir2 $module" \ +"U dir2.4/sdir/sdir2/file1 +U dir2.4/sdir/sdir2/file2" + dotest co-d-2.4.2 "cat dir2.4/CVS/Repository" "CVSROOT/Emptydir" + dotest co-d-2.4.3 "cat dir2.4/sdir/CVS/Repository" "." + dotest co-d-2.4.3 "cat dir2.4/sdir/sdir2/CVS/Repository" "$module" + + mkdir dir3 + dotest co-d-3 "$testcvs -q co -d dir3 $module" \ +"U dir3/file1 +U dir3/file2" + dotest co-d-3.2 "cat dir3/CVS/Repository" "$module" + + mkdir dir4 + dotest co-d-4 "$testcvs -q co -d dir4/sdir $module" \ +"U dir4/sdir/file1 +U dir4/sdir/file2" + + # CVS is only supposed to create administration directories in + # directories it also creates, and in the directory specified by + # the last portion of the path passed to -d regardless. This is + # + # FIXCVS: + # This is broken in client/server mode because the server does not + # know the client's directory structure and has to create + # everything. + if $remote; then + dotest co-d-4.2r "cat dir4/CVS/Repository" "." + else + dotest_fail co-d-4.2 "test -d dir4/CVS" + fi + + dotest co-d-4.3 "cat dir4/sdir/CVS/Repository" "$module" + + mkdir dir5 + mkdir dir5/sdir + dotest co-d-5 "$testcvs -q co -d dir5/sdir $module" \ +"U dir5/sdir/file1 +U dir5/sdir/file2" + # FIXCVS as for co-d-4.2r. + if $remote; then + dotest co-d-5.2 "cat dir5/CVS/Repository" "." + else + dotest_fail co-d-5.2 "test -d dir5/CVS" + fi + + dotest co-d-5.3 "cat dir5/sdir/CVS/Repository" "$module" + + # clean up + dokeep + cd ../.. + modify_repo rm -rf $CVSROOT_DIRNAME/$module + rm -r $module + ;; + + + + cvsadm) + # These test check the content of CVS' administrative + # files as they are checked out in various configurations. + # (As a side note, I'm not using the "-q" flag in any of + # this code, which should provide some extra checking for + # those messages which don't seem to be checked thoroughly + # anywhere else.) To do a thorough test, we need to make + # a bunch of modules in various configurations. + # + # <1mod> is a directory at the top level of cvsroot + # ``foo bar'' + # <2mod> is a directory at the second level of cvsroot + # ``foo bar/baz'' + # <1d1mod> is a directory at the top level which is + # checked out into another directory + # ``foo -d bar baz'' + # <1d2mod> is a directory at the second level which is + # checked out into another directory + # ``foo -d bar baz/quux'' + # <2d1mod> is a directory at the top level which is + # checked out into a directory that is two deep + # ``foo -d bar/baz quux'' + # <2d2mod> is a directory at the second level which is + # checked out into a directory that is two deep + # ``foo -d bar/baz quux'' + # + # The tests do each of these types separately and in twos. + # We also repeat each test -d flag for 1-deep and 2-deep + # directories. + # + # Each test should check the output for the Repository + # file, since that is the one which varies depending on + # the directory and how it was checked out. + # + # Yes, this is verbose, but at least it's very thorough. + + # convenience variables + REP=${CVSROOT} + + # First, set TopLevelAdmin=yes so we're sure to get + # top-level CVS directories. + mkdir 1; cd 1 + dotest cvsadm-setup-1 "${testcvs} -q co CVSROOT/config" \ +"U CVSROOT/config" + cd CVSROOT + echo "TopLevelAdmin=yes" >>config + dotest cvsadm-setup-2 "${testcvs} -q ci -m yes-top-level" \ +"$CVSROOT_DIRNAME/CVSROOT/config,v <-- config +new revision: 1\.[0-9]*; previous revision: 1\.[0-9]* +$SPROG commit: Rebuilding administrative file database" + cd ../.. + rm -r 1 + + # Second, check out the modules file and edit it. + mkdir 1; cd 1 + dotest cvsadm-1 "${testcvs} co CVSROOT/modules" \ +"U CVSROOT/modules" + + # Test CVS/Root once. Since there is only one part of + # the code which writes CVS/Root files (Create_Admin), + # there is no point in testing this every time. + dotest cvsadm-1a "cat CVS/Root" ${REP} + dotest cvsadm-1b "cat CVS/Repository" "\." + dotest cvsadm-1c "cat CVSROOT/CVS/Root" ${REP} + dotest cvsadm-1d "cat CVSROOT/CVS/Repository" "CVSROOT" + # All of the defined module names begin with a number. + # All of the top-level directory names begin with "dir". + # All of the subdirectory names begin with "sub". + # All of the top-level modules begin with "mod". + echo "# Module defs for cvsadm tests" > CVSROOT/modules + echo "1mod mod1" >> CVSROOT/modules + echo "1mod-2 mod1-2" >> CVSROOT/modules + echo "2mod mod2/sub2" >> CVSROOT/modules + echo "2mod-2 mod2-2/sub2-2" >> CVSROOT/modules + echo "1d1mod -d dir1d1 mod1" >> CVSROOT/modules + echo "1d1mod-2 -d dir1d1-2 mod1-2" >> CVSROOT/modules + echo "1d2mod -d dir1d2 mod2/sub2" >> CVSROOT/modules + echo "1d2mod-2 -d dir1d2-2 mod2-2/sub2-2" >> CVSROOT/modules + echo "2d1mod -d dir2d1/sub2d1 mod1" >> CVSROOT/modules + echo "2d1mod-2 -d dir2d1-2/sub2d1-2 mod1-2" >> CVSROOT/modules + echo "2d2mod -d dir2d2/sub2d2 mod2/sub2" >> CVSROOT/modules + echo "2d2mod-2 -d dir2d2-2/sub2d2-2 mod2-2/sub2-2" >> CVSROOT/modules + dotest cvsadm-1e "${testcvs} ci -m add-modules" \ +"${CPROG} commit: Examining . +${CPROG} commit: Examining CVSROOT +${CVSROOT_DIRNAME}/CVSROOT/modules,v <-- CVSROOT/modules +new revision: 1\.[0-9]*; previous revision: 1\.[0-9]* +${SPROG} commit: Rebuilding administrative file database" \ +"${CPROG} commit: Examining . +${CPROG} commit: Examining CVSROOT" + rm -rf CVS CVSROOT; + + # Create the various modules + dotest cvsadm-2 "${testcvs} -q co -l ." '' + mkdir mod1 + mkdir mod1-2 + mkdir mod2 + mkdir mod2/sub2 + mkdir mod2-2 + mkdir mod2-2/sub2-2 + dotest cvsadm-2a "${testcvs} add mod1 mod1-2 mod2 mod2/sub2 mod2-2 mod2-2/sub2-2" \ +"Directory ${CVSROOT_DIRNAME}/mod1 added to the repository +Directory ${CVSROOT_DIRNAME}/mod1-2 added to the repository +Directory ${CVSROOT_DIRNAME}/mod2 added to the repository +Directory ${CVSROOT_DIRNAME}/mod2/sub2 added to the repository +Directory ${CVSROOT_DIRNAME}/mod2-2 added to the repository +Directory ${CVSROOT_DIRNAME}/mod2-2/sub2-2 added to the repository" + + # Populate the directories for the halibut + echo "file1" > mod1/file1 + echo "file1-2" > mod1-2/file1-2 + echo "file2" > mod2/sub2/file2 + echo "file2-2" > mod2-2/sub2-2/file2-2 + dotest cvsadm-2aa "${testcvs} add mod1/file1 mod1-2/file1-2 mod2/sub2/file2 mod2-2/sub2-2/file2-2" \ +"${SPROG} add: scheduling file .mod1/file1. for addition +${SPROG} add: scheduling file .mod1-2/file1-2. for addition +${SPROG} add: scheduling file .mod2/sub2/file2. for addition +${SPROG} add: scheduling file .mod2-2/sub2-2/file2-2. for addition +${SPROG} add: use \`${SPROG} commit' to add these files permanently" + + dotest cvsadm-2b "${testcvs} ci -m yup mod1 mod1-2 mod2 mod2-2" \ +"${CPROG} commit: Examining mod1 +${CPROG} commit: Examining mod1-2 +${CPROG} commit: Examining mod2 +${CPROG} commit: Examining mod2/sub2 +${CPROG} commit: Examining mod2-2 +${CPROG} commit: Examining mod2-2/sub2-2 +${CVSROOT_DIRNAME}/mod1/file1,v <-- mod1/file1 +initial revision: 1.1 +${CVSROOT_DIRNAME}/mod1-2/file1-2,v <-- mod1-2/file1-2 +initial revision: 1.1 +${CVSROOT_DIRNAME}/mod2/sub2/file2,v <-- mod2/sub2/file2 +initial revision: 1.1 +${CVSROOT_DIRNAME}/mod2-2/sub2-2/file2-2,v <-- mod2-2/sub2-2/file2-2 +initial revision: 1.1" + # Finished creating the modules -- clean up. + rm -rf CVS mod1 mod1-2 mod2 mod2-2 + # Done. + + ################################################## + ## Start the dizzying array of possibilities. + ## Begin with each module type separately. + ################################################## + + # Pattern -- after each checkout, first check the top-level + # CVS directory. Then, check the directories in numerical + # order. + + dotest cvsadm-3 "${testcvs} co 1mod" \ +"${SPROG} checkout: Updating 1mod +U 1mod/file1" + dotest cvsadm-3b "cat CVS/Repository" "\." + dotest cvsadm-3d "cat 1mod/CVS/Repository" "mod1" + rm -rf CVS 1mod + + dotest cvsadm-4 "${testcvs} co 2mod" \ +"${SPROG} checkout: Updating 2mod +U 2mod/file2" + dotest cvsadm-4b "cat CVS/Repository" "\." + dotest cvsadm-4d "cat 2mod/CVS/Repository" "mod2/sub2" + rm -rf CVS 2mod + + dotest cvsadm-5 "${testcvs} co 1d1mod" \ +"${SPROG} checkout: Updating dir1d1 +U dir1d1/file1" + dotest cvsadm-5b "cat CVS/Repository" "\." + dotest cvsadm-5d "cat dir1d1/CVS/Repository" "mod1" + rm -rf CVS dir1d1 + + dotest cvsadm-6 "${testcvs} co 1d2mod" \ +"${SPROG} checkout: Updating dir1d2 +U dir1d2/file2" + dotest cvsadm-6b "cat CVS/Repository" "\." + dotest cvsadm-6d "cat dir1d2/CVS/Repository" "mod2/sub2" + rm -rf CVS dir1d2 + + dotest cvsadm-7 "${testcvs} co 2d1mod" \ +"${SPROG} checkout: Updating dir2d1/sub2d1 +U dir2d1/sub2d1/file1" + dotest cvsadm-7b "cat CVS/Repository" "\." + dotest cvsadm-7d "cat dir2d1/CVS/Repository" "\." + dotest cvsadm-7f "cat dir2d1/sub2d1/CVS/Repository" "mod1" + rm -rf CVS dir2d1 + + dotest cvsadm-8 "${testcvs} co 2d2mod" \ +"${SPROG} checkout: Updating dir2d2/sub2d2 +U dir2d2/sub2d2/file2" + dotest cvsadm-8b "cat CVS/Repository" "\." + dotest cvsadm-8d "cat dir2d2/CVS/Repository" "mod2" + dotest cvsadm-8f "cat dir2d2/sub2d2/CVS/Repository" "mod2/sub2" + rm -rf CVS dir2d2 + + ################################################## + ## You are in a shell script of twisted little + ## module combination statements, all alike. + ################################################## + + ### 1mod + + dotest cvsadm-9 "${testcvs} co 1mod 1mod-2" \ +"${SPROG} checkout: Updating 1mod +U 1mod/file1 +${SPROG} checkout: Updating 1mod-2 +U 1mod-2/file1-2" + # the usual for the top level + dotest cvsadm-9b "cat CVS/Repository" "\." + # the usual for 1mod + dotest cvsadm-9d "cat 1mod/CVS/Repository" "mod1" + # the usual for 1mod copy + dotest cvsadm-9f "cat 1mod-2/CVS/Repository" "mod1-2" + rm -rf CVS 1mod 1mod-2 + + # 1mod 2mod redmod bluemod + dotest cvsadm-10 "${testcvs} co 1mod 2mod" \ +"${SPROG} checkout: Updating 1mod +U 1mod/file1 +${SPROG} checkout: Updating 2mod +U 2mod/file2" + # the usual for the top level + dotest cvsadm-10b "cat CVS/Repository" "\." + # the usual for 1mod + dotest cvsadm-10d "cat 1mod/CVS/Repository" "mod1" + # the usual for 2dmod + dotest cvsadm-10f "cat 2mod/CVS/Repository" "mod2/sub2" + rm -rf CVS 1mod 2mod + + dotest cvsadm-11 "${testcvs} co 1mod 1d1mod" \ +"${SPROG} checkout: Updating 1mod +U 1mod/file1 +${SPROG} checkout: Updating dir1d1 +U dir1d1/file1" + # the usual for the top level + dotest cvsadm-11b "cat CVS/Repository" "\." + # the usual for 1mod + dotest cvsadm-11d "cat 1mod/CVS/Repository" "mod1" + # the usual for 1d1mod + dotest cvsadm-11f "cat dir1d1/CVS/Repository" "mod1" + rm -rf CVS 1mod dir1d1 + + dotest cvsadm-12 "${testcvs} co 1mod 1d2mod" \ +"${SPROG} checkout: Updating 1mod +U 1mod/file1 +${SPROG} checkout: Updating dir1d2 +U dir1d2/file2" + # the usual for the top level + dotest cvsadm-12b "cat CVS/Repository" "\." + # the usual for 1mod + dotest cvsadm-12d "cat 1mod/CVS/Repository" "mod1" + # the usual for 1d2mod + dotest cvsadm-12f "cat dir1d2/CVS/Repository" "mod2/sub2" + rm -rf CVS 1mod dir1d2 + + dotest cvsadm-13 "${testcvs} co 1mod 2d1mod" \ +"${SPROG} checkout: Updating 1mod +U 1mod/file1 +${SPROG} checkout: Updating dir2d1/sub2d1 +U dir2d1/sub2d1/file1" + # the usual for the top level + dotest cvsadm-13b "cat CVS/Repository" "\." + # the usual for 1mod + dotest cvsadm-13d "cat 1mod/CVS/Repository" "mod1" + # the usual for 2d1mod + dotest cvsadm-13f "cat dir2d1/CVS/Repository" "\." + dotest cvsadm-13h "cat dir2d1/sub2d1/CVS/Repository" "mod1" + rm -rf CVS 1mod dir2d1 + + dotest cvsadm-14 "${testcvs} co 1mod 2d2mod" \ +"${SPROG} checkout: Updating 1mod +U 1mod/file1 +${SPROG} checkout: Updating dir2d2/sub2d2 +U dir2d2/sub2d2/file2" + # the usual for the top level + dotest cvsadm-14b "cat CVS/Repository" "\." + # the usual for 1mod + dotest cvsadm-14d "cat 1mod/CVS/Repository" "mod1" + # the usual for 2d2mod + dotest cvsadm-14f "cat dir2d2/CVS/Repository" "mod2" + dotest cvsadm-14h "cat dir2d2/sub2d2/CVS/Repository" "mod2/sub2" + rm -rf CVS 1mod dir2d2 + + + ### 2mod + + dotest cvsadm-15 "${testcvs} co 2mod 2mod-2" \ +"${SPROG} checkout: Updating 2mod +U 2mod/file2 +${SPROG} checkout: Updating 2mod-2 +U 2mod-2/file2-2" + # the usual for the top level + dotest cvsadm-15b "cat CVS/Repository" "\." + # the usual for 2mod + dotest cvsadm-15d "cat 2mod/CVS/Repository" "mod2/sub2" + # the usual for 2mod copy + dotest cvsadm-15f "cat 2mod-2/CVS/Repository" "mod2-2/sub2-2" + rm -rf CVS 2mod 2mod-2 + + + dotest cvsadm-16 "${testcvs} co 2mod 1d1mod" \ +"${SPROG} checkout: Updating 2mod +U 2mod/file2 +${SPROG} checkout: Updating dir1d1 +U dir1d1/file1" + # the usual for the top level + dotest cvsadm-16b "cat CVS/Repository" "\." + # the usual for 2mod + dotest cvsadm-16d "cat 2mod/CVS/Repository" "mod2/sub2" + # the usual for 1d1mod + dotest cvsadm-16f "cat dir1d1/CVS/Repository" "mod1" + rm -rf CVS 2mod dir1d1 + + dotest cvsadm-17 "${testcvs} co 2mod 1d2mod" \ +"${SPROG} checkout: Updating 2mod +U 2mod/file2 +${SPROG} checkout: Updating dir1d2 +U dir1d2/file2" + # the usual for the top level + dotest cvsadm-17b "cat CVS/Repository" "\." + # the usual for 2mod + dotest cvsadm-17d "cat 2mod/CVS/Repository" "mod2/sub2" + # the usual for 1d2mod + dotest cvsadm-17f "cat dir1d2/CVS/Repository" "mod2/sub2" + rm -rf CVS 2mod dir1d2 + + dotest cvsadm-18 "${testcvs} co 2mod 2d1mod" \ +"${SPROG} checkout: Updating 2mod +U 2mod/file2 +${SPROG} checkout: Updating dir2d1/sub2d1 +U dir2d1/sub2d1/file1" + # the usual for the top level + dotest cvsadm-18b "cat CVS/Repository" "\." + # the usual for 2mod + dotest cvsadm-18d "cat 2mod/CVS/Repository" "mod2/sub2" + # the usual for 2d1mod + dotest cvsadm-18f "cat dir2d1/CVS/Repository" "\." + dotest cvsadm-18h "cat dir2d1/sub2d1/CVS/Repository" "mod1" + rm -rf CVS 2mod dir2d1 + + dotest cvsadm-19 "${testcvs} co 2mod 2d2mod" \ +"${SPROG} checkout: Updating 2mod +U 2mod/file2 +${SPROG} checkout: Updating dir2d2/sub2d2 +U dir2d2/sub2d2/file2" + # the usual for the top level + dotest cvsadm-19b "cat CVS/Repository" "\." + # the usual for 2mod + dotest cvsadm-19d "cat 2mod/CVS/Repository" "mod2/sub2" + # the usual for 2d2mod + dotest cvsadm-19f "cat dir2d2/CVS/Repository" "mod2" + dotest cvsadm-19h "cat dir2d2/sub2d2/CVS/Repository" "mod2/sub2" + rm -rf CVS 2mod dir2d2 + + + ### 1d1mod + + dotest cvsadm-20 "${testcvs} co 1d1mod 1d1mod-2" \ +"${SPROG} checkout: Updating dir1d1 +U dir1d1/file1 +${SPROG} checkout: Updating dir1d1-2 +U dir1d1-2/file1-2" + # the usual for the top level + dotest cvsadm-20b "cat CVS/Repository" "\." + # the usual for 1d1mod + dotest cvsadm-20d "cat dir1d1/CVS/Repository" "mod1" + # the usual for 1d1mod copy + dotest cvsadm-20f "cat dir1d1-2/CVS/Repository" "mod1-2" + rm -rf CVS dir1d1 dir1d1-2 + + dotest cvsadm-21 "${testcvs} co 1d1mod 1d2mod" \ +"${SPROG} checkout: Updating dir1d1 +U dir1d1/file1 +${SPROG} checkout: Updating dir1d2 +U dir1d2/file2" + # the usual for the top level + dotest cvsadm-21b "cat CVS/Repository" "\." + # the usual for 1d1mod + dotest cvsadm-21d "cat dir1d1/CVS/Repository" "mod1" + # the usual for 1d2mod + dotest cvsadm-21f "cat dir1d2/CVS/Repository" "mod2/sub2" + rm -rf CVS dir1d1 dir1d2 + + dotest cvsadm-22 "${testcvs} co 1d1mod 2d1mod" \ +"${SPROG} checkout: Updating dir1d1 +U dir1d1/file1 +${SPROG} checkout: Updating dir2d1/sub2d1 +U dir2d1/sub2d1/file1" + # the usual for the top level + dotest cvsadm-22b "cat CVS/Repository" "\." + # the usual for 1d1mod + dotest cvsadm-22d "cat dir1d1/CVS/Repository" "mod1" + # the usual for 2d1mod + dotest cvsadm-22f "cat dir2d1/CVS/Repository" "\." + dotest cvsadm-22h "cat dir2d1/sub2d1/CVS/Repository" "mod1" + rm -rf CVS dir1d1 dir2d1 + + dotest cvsadm-23 "${testcvs} co 1d1mod 2d2mod" \ +"${SPROG} checkout: Updating dir1d1 +U dir1d1/file1 +${SPROG} checkout: Updating dir2d2/sub2d2 +U dir2d2/sub2d2/file2" + # the usual for the top level + dotest cvsadm-23b "cat CVS/Repository" "\." + # the usual for 1d1mod + dotest cvsadm-23d "cat dir1d1/CVS/Repository" "mod1" + # the usual for 2d2mod + dotest cvsadm-23f "cat dir2d2/CVS/Repository" "mod2" + dotest cvsadm-23h "cat dir2d2/sub2d2/CVS/Repository" "mod2/sub2" + rm -rf CVS dir1d1 dir2d2 + + + ### 1d2mod + + dotest cvsadm-24 "${testcvs} co 1d2mod 1d2mod-2" \ +"${SPROG} checkout: Updating dir1d2 +U dir1d2/file2 +${SPROG} checkout: Updating dir1d2-2 +U dir1d2-2/file2-2" + # the usual for the top level + dotest cvsadm-24b "cat CVS/Repository" "\." + # the usual for 1d2mod + dotest cvsadm-24d "cat dir1d2/CVS/Repository" "mod2/sub2" + # the usual for 1d2mod copy + dotest cvsadm-24f "cat dir1d2-2/CVS/Repository" "mod2-2/sub2-2" + rm -rf CVS dir1d2 dir1d2-2 + + dotest cvsadm-25 "${testcvs} co 1d2mod 2d1mod" \ +"${SPROG} checkout: Updating dir1d2 +U dir1d2/file2 +${SPROG} checkout: Updating dir2d1/sub2d1 +U dir2d1/sub2d1/file1" + # the usual for the top level + dotest cvsadm-25b "cat CVS/Repository" "\." + # the usual for 1d2mod + dotest cvsadm-25d "cat dir1d2/CVS/Repository" "mod2/sub2" + # the usual for 2d1mod + dotest cvsadm-25f "cat dir2d1/CVS/Repository" "\." + dotest cvsadm-25h "cat dir2d1/sub2d1/CVS/Repository" "mod1" + rm -rf CVS dir1d2 dir2d1 + + dotest cvsadm-26 "${testcvs} co 1d2mod 2d2mod" \ +"${SPROG} checkout: Updating dir1d2 +U dir1d2/file2 +${SPROG} checkout: Updating dir2d2/sub2d2 +U dir2d2/sub2d2/file2" + # the usual for the top level + dotest cvsadm-26b "cat CVS/Repository" "\." + # the usual for 1d2mod + dotest cvsadm-26d "cat dir1d2/CVS/Repository" "mod2/sub2" + # the usual for 2d2mod + dotest cvsadm-26f "cat dir2d2/CVS/Repository" "mod2" + dotest cvsadm-26h "cat dir2d2/sub2d2/CVS/Repository" "mod2/sub2" + rm -rf CVS dir1d2 dir2d2 + + + # 2d1mod + + dotest cvsadm-27 "${testcvs} co 2d1mod 2d1mod-2" \ +"${SPROG} checkout: Updating dir2d1/sub2d1 +U dir2d1/sub2d1/file1 +${SPROG} checkout: Updating dir2d1-2/sub2d1-2 +U dir2d1-2/sub2d1-2/file1-2" + # the usual for the top level + dotest cvsadm-27b "cat CVS/Repository" "\." + # the usual for 2d1mod + dotest cvsadm-27d "cat dir2d1/CVS/Repository" "\." + dotest cvsadm-27f "cat dir2d1/sub2d1/CVS/Repository" "mod1" + # the usual for 2d1mod + dotest cvsadm-27h "cat dir2d1-2/CVS/Repository" "\." + dotest cvsadm-27j "cat dir2d1-2/sub2d1-2/CVS/Repository" "mod1-2" + rm -rf CVS dir2d1 dir2d1-2 + + dotest cvsadm-28 "${testcvs} co 2d1mod 2d2mod" \ +"${SPROG} checkout: Updating dir2d1/sub2d1 +U dir2d1/sub2d1/file1 +${SPROG} checkout: Updating dir2d2/sub2d2 +U dir2d2/sub2d2/file2" + # the usual for the top level + dotest cvsadm-28b "cat CVS/Repository" "\." + # the usual for 2d1mod + dotest cvsadm-28d "cat dir2d1/CVS/Repository" "\." + dotest cvsadm-28f "cat dir2d1/sub2d1/CVS/Repository" "mod1" + # the usual for 2d2mod + dotest cvsadm-28h "cat dir2d2/CVS/Repository" "mod2" + dotest cvsadm-28j "cat dir2d2/sub2d2/CVS/Repository" "mod2/sub2" + rm -rf CVS dir2d1 dir2d2 + + + # 2d2mod + + dotest cvsadm-29 "${testcvs} co 2d2mod 2d2mod-2" \ +"${SPROG} checkout: Updating dir2d2/sub2d2 +U dir2d2/sub2d2/file2 +${SPROG} checkout: Updating dir2d2-2/sub2d2-2 +U dir2d2-2/sub2d2-2/file2-2" + # the usual for the top level + dotest cvsadm-29b "cat CVS/Repository" "\." + # the usual for 2d2mod + dotest cvsadm-29d "cat dir2d2/CVS/Repository" "mod2" + dotest cvsadm-29f "cat dir2d2/sub2d2/CVS/Repository" "mod2/sub2" + # the usual for 2d2mod + dotest cvsadm-29h "cat dir2d2-2/CVS/Repository" "mod2-2" + dotest cvsadm-29j "cat dir2d2-2/sub2d2-2/CVS/Repository" \ +"mod2-2/sub2-2" + rm -rf CVS dir2d2 dir2d2-2 + + ################################################## + ## And now, all of that again using the "-d" flag + ## on the command line. + ################################################## + + dotest cvsadm-1d3 "${testcvs} co -d dir 1mod" \ +"${SPROG} checkout: Updating dir +U dir/file1" + dotest cvsadm-1d3b "cat CVS/Repository" "\." + dotest cvsadm-1d3d "cat dir/CVS/Repository" "mod1" + rm -rf CVS dir + + dotest cvsadm-1d4 "${testcvs} co -d dir 2mod" \ +"${SPROG} checkout: Updating dir +U dir/file2" + dotest cvsadm-1d4b "cat CVS/Repository" "\." + dotest cvsadm-1d4d "cat dir/CVS/Repository" "mod2/sub2" + rm -rf CVS dir + + dotest cvsadm-1d5 "${testcvs} co -d dir 1d1mod" \ +"${SPROG} checkout: Updating dir +U dir/file1" + dotest cvsadm-1d5b "cat CVS/Repository" "\." + dotest cvsadm-1d5d "cat dir/CVS/Repository" "mod1" + rm -rf CVS dir + + dotest cvsadm-1d6 "${testcvs} co -d dir 1d2mod" \ +"${SPROG} checkout: Updating dir +U dir/file2" + dotest cvsadm-1d6b "cat CVS/Repository" "\." + dotest cvsadm-1d6d "cat dir/CVS/Repository" "mod2/sub2" + rm -rf CVS dir + + dotest cvsadm-1d7 "${testcvs} co -d dir 2d1mod" \ +"${SPROG} checkout: Updating dir +U dir/file1" + dotest cvsadm-1d7b "cat CVS/Repository" "\." + dotest cvsadm-1d7d "cat dir/CVS/Repository" "mod1" + rm -rf CVS dir + + dotest cvsadm-1d8 "${testcvs} co -d dir 2d2mod" \ +"${SPROG} checkout: Updating dir +U dir/file2" + dotest cvsadm-1d8b "cat CVS/Repository" "\." + dotest cvsadm-1d8d "cat dir/CVS/Repository" "mod2/sub2" + rm -rf CVS dir + + ################################################## + ## Los Combonaciones + ################################################## + + ### 1mod + + dotest cvsadm-1d9 "${testcvs} co -d dir 1mod 1mod-2" \ +"${SPROG} checkout: Updating dir/1mod +U dir/1mod/file1 +${SPROG} checkout: Updating dir/1mod-2 +U dir/1mod-2/file1-2" + # the usual for the top level + dotest cvsadm-1d9b "cat CVS/Repository" "\." + # the usual for the dir level + dotest cvsadm-1d9d "cat dir/CVS/Repository" "\." + # the usual for 1mod + dotest cvsadm-1d9f "cat dir/1mod/CVS/Repository" "mod1" + # the usual for 1mod copy + dotest cvsadm-1d9h "cat dir/1mod-2/CVS/Repository" "mod1-2" + rm -rf CVS dir + + # 1mod 2mod redmod bluemod + dotest cvsadm-1d10 "${testcvs} co -d dir 1mod 2mod" \ +"${SPROG} checkout: Updating dir/1mod +U dir/1mod/file1 +${SPROG} checkout: Updating dir/2mod +U dir/2mod/file2" + dotest cvsadm-1d10b "cat CVS/Repository" "\." + # the usual for the dir level + dotest cvsadm-1d10d "cat dir/CVS/Repository" "\." + # the usual for 1mod + dotest cvsadm-1d10f "cat dir/1mod/CVS/Repository" "mod1" + # the usual for 2dmod + dotest cvsadm-1d10h "cat dir/2mod/CVS/Repository" "mod2/sub2" + rm -rf CVS dir + + dotest cvsadm-1d11 "${testcvs} co -d dir 1mod 1d1mod" \ +"${SPROG} checkout: Updating dir/1mod +U dir/1mod/file1 +${SPROG} checkout: Updating dir/dir1d1 +U dir/dir1d1/file1" + dotest cvsadm-1d11b "cat CVS/Repository" "\." + # the usual for the dir level + dotest cvsadm-1d11d "cat dir/CVS/Repository" "\." + # the usual for 1mod + dotest cvsadm-1d11f "cat dir/1mod/CVS/Repository" "mod1" + # the usual for 1d1mod + dotest cvsadm-1d11h "cat dir/dir1d1/CVS/Repository" "mod1" + rm -rf CVS dir + + dotest cvsadm-1d12 "${testcvs} co -d dir 1mod 1d2mod" \ +"${SPROG} checkout: Updating dir/1mod +U dir/1mod/file1 +${SPROG} checkout: Updating dir/dir1d2 +U dir/dir1d2/file2" + dotest cvsadm-1d12b "cat CVS/Repository" "\." + # the usual for the dir level + dotest cvsadm-1d12d "cat dir/CVS/Repository" "\." + # the usual for 1mod + dotest cvsadm-1d12f "cat dir/1mod/CVS/Repository" "mod1" + # the usual for 1d2mod + dotest cvsadm-1d12h "cat dir/dir1d2/CVS/Repository" "mod2/sub2" + rm -rf CVS dir + + dotest cvsadm-1d13 "${testcvs} co -d dir 1mod 2d1mod" \ +"${SPROG} checkout: Updating dir/1mod +U dir/1mod/file1 +${SPROG} checkout: Updating dir/dir2d1/sub2d1 +U dir/dir2d1/sub2d1/file1" + dotest cvsadm-1d13b "cat CVS/Repository" "\." + # the usual for the dir level + dotest cvsadm-1d13d "cat dir/CVS/Repository" "\." + # the usual for 1mod + dotest cvsadm-1d13f "cat dir/1mod/CVS/Repository" "mod1" + # the usual for 2d1mod + dotest cvsadm-1d13h "cat dir/dir2d1/CVS/Repository" "\." + dotest cvsadm-1d13j "cat dir/dir2d1/sub2d1/CVS/Repository" "mod1" + rm -rf CVS dir + + dotest cvsadm-1d14 "${testcvs} co -d dir 1mod 2d2mod" \ +"${SPROG} checkout: Updating dir/1mod +U dir/1mod/file1 +${SPROG} checkout: Updating dir/dir2d2/sub2d2 +U dir/dir2d2/sub2d2/file2" + dotest cvsadm-1d14b "cat CVS/Repository" "\." + # the usual for the dir level + dotest cvsadm-1d14d "cat dir/CVS/Repository" "\." + # the usual for 1mod + dotest cvsadm-1d14f "cat dir/1mod/CVS/Repository" "mod1" + # the usual for 2d2mod + dotest cvsadm-1d14h "cat dir/dir2d2/CVS/Repository" "mod2" + dotest cvsadm-1d14j "cat dir/dir2d2/sub2d2/CVS/Repository" "mod2/sub2" + rm -rf CVS dir + + + ### 2mod + + dotest cvsadm-1d15 "${testcvs} co -d dir 2mod 2mod-2" \ +"${SPROG} checkout: Updating dir/2mod +U dir/2mod/file2 +${SPROG} checkout: Updating dir/2mod-2 +U dir/2mod-2/file2-2" + dotest cvsadm-1d15b "cat CVS/Repository" "\." + # the usual for the dir level + dotest cvsadm-1d15d "cat dir/CVS/Repository" "mod2" + # the usual for 2mod + dotest cvsadm-1d15f "cat dir/2mod/CVS/Repository" "mod2/sub2" + # the usual for 2mod copy + dotest cvsadm-1d15h "cat dir/2mod-2/CVS/Repository" "mod2-2/sub2-2" + rm -rf CVS dir + + dotest cvsadm-1d16 "${testcvs} co -d dir 2mod 1d1mod" \ +"${SPROG} checkout: Updating dir/2mod +U dir/2mod/file2 +${SPROG} checkout: Updating dir/dir1d1 +U dir/dir1d1/file1" + dotest cvsadm-1d16b "cat CVS/Repository" "\." + # the usual for the dir level + dotest cvsadm-1d16d "cat dir/CVS/Repository" "mod2" + # the usual for 2mod + dotest cvsadm-1d16f "cat dir/2mod/CVS/Repository" "mod2/sub2" + # the usual for 1d1mod + dotest cvsadm-1d16h "cat dir/dir1d1/CVS/Repository" "mod1" + rm -rf CVS dir + + dotest cvsadm-1d17 "${testcvs} co -d dir 2mod 1d2mod" \ +"${SPROG} checkout: Updating dir/2mod +U dir/2mod/file2 +${SPROG} checkout: Updating dir/dir1d2 +U dir/dir1d2/file2" + dotest cvsadm-1d17b "cat CVS/Repository" "\." + # the usual for the dir level + dotest cvsadm-1d17d "cat dir/CVS/Repository" "mod2" + # the usual for 2mod + dotest cvsadm-1d17f "cat dir/2mod/CVS/Repository" "mod2/sub2" + # the usual for 1d2mod + dotest cvsadm-1d17h "cat dir/dir1d2/CVS/Repository" "mod2/sub2" + rm -rf CVS dir + + dotest cvsadm-1d18 "${testcvs} co -d dir 2mod 2d1mod" \ +"${SPROG} checkout: Updating dir/2mod +U dir/2mod/file2 +${SPROG} checkout: Updating dir/dir2d1/sub2d1 +U dir/dir2d1/sub2d1/file1" + dotest cvsadm-1d18b "cat CVS/Repository" "\." + # the usual for the dir level + dotest cvsadm-1d18d "cat dir/CVS/Repository" "mod2" + # the usual for 2mod + dotest cvsadm-1d18f "cat dir/2mod/CVS/Repository" "mod2/sub2" + # the usual for 2d1mod + dotest cvsadm-1d18h "cat dir/dir2d1/CVS/Repository" "\." + dotest cvsadm-1d18j "cat dir/dir2d1/sub2d1/CVS/Repository" "mod1" + rm -rf CVS dir + + dotest cvsadm-1d19 "${testcvs} co -d dir 2mod 2d2mod" \ +"${SPROG} checkout: Updating dir/2mod +U dir/2mod/file2 +${SPROG} checkout: Updating dir/dir2d2/sub2d2 +U dir/dir2d2/sub2d2/file2" + dotest cvsadm-1d19b "cat CVS/Repository" "\." + # the usual for the dir level + dotest cvsadm-1d19d "cat dir/CVS/Repository" "mod2" + # the usual for 2mod + dotest cvsadm-1d19f "cat dir/2mod/CVS/Repository" "mod2/sub2" + # the usual for 2d2mod + dotest cvsadm-1d19h "cat dir/dir2d2/CVS/Repository" "mod2" + dotest cvsadm-1d19j "cat dir/dir2d2/sub2d2/CVS/Repository" "mod2/sub2" + rm -rf CVS dir + + + ### 1d1mod + + dotest cvsadm-1d20 "${testcvs} co -d dir 1d1mod 1d1mod-2" \ +"${SPROG} checkout: Updating dir/dir1d1 +U dir/dir1d1/file1 +${SPROG} checkout: Updating dir/dir1d1-2 +U dir/dir1d1-2/file1-2" + dotest cvsadm-1d20b "cat CVS/Repository" "\." + # the usual for the dir level + dotest cvsadm-1d20d "cat dir/CVS/Repository" "\." + # the usual for 1d1mod + dotest cvsadm-1d20f "cat dir/dir1d1/CVS/Repository" "mod1" + # the usual for 1d1mod copy + dotest cvsadm-1d20h "cat dir/dir1d1-2/CVS/Repository" "mod1-2" + rm -rf CVS dir + + dotest cvsadm-1d21 "${testcvs} co -d dir 1d1mod 1d2mod" \ +"${SPROG} checkout: Updating dir/dir1d1 +U dir/dir1d1/file1 +${SPROG} checkout: Updating dir/dir1d2 +U dir/dir1d2/file2" + dotest cvsadm-1d21b "cat CVS/Repository" "\." + # the usual for the dir level + dotest cvsadm-1d21d "cat dir/CVS/Repository" "\." + # the usual for 1d1mod + dotest cvsadm-1d21f "cat dir/dir1d1/CVS/Repository" "mod1" + # the usual for 1d2mod + dotest cvsadm-1d21h "cat dir/dir1d2/CVS/Repository" "mod2/sub2" + rm -rf CVS dir + + dotest cvsadm-1d22 "${testcvs} co -d dir 1d1mod 2d1mod" \ +"${SPROG} checkout: Updating dir/dir1d1 +U dir/dir1d1/file1 +${SPROG} checkout: Updating dir/dir2d1/sub2d1 +U dir/dir2d1/sub2d1/file1" + dotest cvsadm-1d22b "cat CVS/Repository" "\." + # the usual for the dir level + dotest cvsadm-1d22d "cat dir/CVS/Repository" "\." + # the usual for 1d1mod + dotest cvsadm-1d22f "cat dir/dir1d1/CVS/Repository" "mod1" + # the usual for 2d1mod + dotest cvsadm-1d22h "cat dir/dir2d1/CVS/Repository" "\." + dotest cvsadm-1d22j "cat dir/dir2d1/sub2d1/CVS/Repository" "mod1" + rm -rf CVS dir + + dotest cvsadm-1d23 "${testcvs} co -d dir 1d1mod 2d2mod" \ +"${SPROG} checkout: Updating dir/dir1d1 +U dir/dir1d1/file1 +${SPROG} checkout: Updating dir/dir2d2/sub2d2 +U dir/dir2d2/sub2d2/file2" + dotest cvsadm-1d23b "cat CVS/Repository" "\." + # the usual for the dir level + dotest cvsadm-1d23d "cat dir/CVS/Repository" "\." + # the usual for 1d1mod + dotest cvsadm-1d23f "cat dir/dir1d1/CVS/Repository" "mod1" + # the usual for 2d2mod + dotest cvsadm-1d23h "cat dir/dir2d2/CVS/Repository" "mod2" + dotest cvsadm-1d23j "cat dir/dir2d2/sub2d2/CVS/Repository" "mod2/sub2" + rm -rf CVS dir + + + ### 1d2mod + + dotest cvsadm-1d24 "${testcvs} co -d dir 1d2mod 1d2mod-2" \ +"${SPROG} checkout: Updating dir/dir1d2 +U dir/dir1d2/file2 +${SPROG} checkout: Updating dir/dir1d2-2 +U dir/dir1d2-2/file2-2" + dotest cvsadm-1d24b "cat CVS/Repository" "\." + # the usual for the dir level + dotest cvsadm-1d24d "cat dir/CVS/Repository" "mod2" + # the usual for 1d2mod + dotest cvsadm-1d24f "cat dir/dir1d2/CVS/Repository" "mod2/sub2" + # the usual for 1d2mod copy + dotest cvsadm-1d24h "cat dir/dir1d2-2/CVS/Repository" "mod2-2/sub2-2" + rm -rf CVS dir + + dotest cvsadm-1d25 "${testcvs} co -d dir 1d2mod 2d1mod" \ +"${SPROG} checkout: Updating dir/dir1d2 +U dir/dir1d2/file2 +${SPROG} checkout: Updating dir/dir2d1/sub2d1 +U dir/dir2d1/sub2d1/file1" + dotest cvsadm-1d25b "cat CVS/Repository" "\." + # the usual for the dir level + dotest cvsadm-1d25d "cat dir/CVS/Repository" "mod2" + # the usual for 1d2mod + dotest cvsadm-1d25f "cat dir/dir1d2/CVS/Repository" "mod2/sub2" + # the usual for 2d1mod + dotest cvsadm-1d25h "cat dir/dir2d1/CVS/Repository" "\." + dotest cvsadm-1d25j "cat dir/dir2d1/sub2d1/CVS/Repository" "mod1" + rm -rf CVS dir + + dotest cvsadm-1d26 "${testcvs} co -d dir 1d2mod 2d2mod" \ +"${SPROG} checkout: Updating dir/dir1d2 +U dir/dir1d2/file2 +${SPROG} checkout: Updating dir/dir2d2/sub2d2 +U dir/dir2d2/sub2d2/file2" + dotest cvsadm-1d26b "cat CVS/Repository" "\." + # the usual for the dir level + dotest cvsadm-1d26d "cat dir/CVS/Repository" "mod2" + # the usual for 1d2mod + dotest cvsadm-1d26f "cat dir/dir1d2/CVS/Repository" "mod2/sub2" + # the usual for 2d2mod + dotest cvsadm-1d26h "cat dir/dir2d2/CVS/Repository" "mod2" + dotest cvsadm-1d26j "cat dir/dir2d2/sub2d2/CVS/Repository" "mod2/sub2" + rm -rf CVS dir + + + # 2d1mod + + dotest cvsadm-1d27 "${testcvs} co -d dir 2d1mod 2d1mod-2" \ +"${SPROG} checkout: Updating dir/dir2d1/sub2d1 +U dir/dir2d1/sub2d1/file1 +${SPROG} checkout: Updating dir/dir2d1-2/sub2d1-2 +U dir/dir2d1-2/sub2d1-2/file1-2" + dotest cvsadm-1d27b "cat CVS/Repository" "\." + # the usual for the dir level + dotest cvsadm-1d27d "cat dir/CVS/Repository" "CVSROOT/Emptydir" + # the usual for 2d1mod + dotest cvsadm-1d27f "cat dir/dir2d1/CVS/Repository" "\." + dotest cvsadm-1d27h "cat dir/dir2d1/sub2d1/CVS/Repository" "mod1" + # the usual for 2d1mod + dotest cvsadm-1d27j "cat dir/dir2d1-2/CVS/Repository" "\." + dotest cvsadm-1d27l "cat dir/dir2d1-2/sub2d1-2/CVS/Repository" \ +"mod1-2" + rm -rf CVS dir + + dotest cvsadm-1d28 "${testcvs} co -d dir 2d1mod 2d2mod" \ +"${SPROG} checkout: Updating dir/dir2d1/sub2d1 +U dir/dir2d1/sub2d1/file1 +${SPROG} checkout: Updating dir/dir2d2/sub2d2 +U dir/dir2d2/sub2d2/file2" + dotest cvsadm-1d28b "cat CVS/Repository" "\." + # the usual for the dir level + dotest cvsadm-1d28d "cat dir/CVS/Repository" "CVSROOT/Emptydir" + # the usual for 2d1mod + dotest cvsadm-1d28f "cat dir/dir2d1/CVS/Repository" "\." + dotest cvsadm-1d28h "cat dir/dir2d1/sub2d1/CVS/Repository" "mod1" + # the usual for 2d2mod + dotest cvsadm-1d28j "cat dir/dir2d2/CVS/Repository" "mod2" + dotest cvsadm-1d28l "cat dir/dir2d2/sub2d2/CVS/Repository" "mod2/sub2" + rm -rf CVS dir + + + # 2d2mod + + dotest cvsadm-1d29 "${testcvs} co -d dir 2d2mod 2d2mod-2" \ +"${SPROG} checkout: Updating dir/dir2d2/sub2d2 +U dir/dir2d2/sub2d2/file2 +${SPROG} checkout: Updating dir/dir2d2-2/sub2d2-2 +U dir/dir2d2-2/sub2d2-2/file2-2" + dotest cvsadm-1d29b "cat CVS/Repository" "\." + # the usual for the dir level + dotest cvsadm-1d29d "cat dir/CVS/Repository" "\." + # the usual for 2d2mod + dotest cvsadm-1d29f "cat dir/dir2d2/CVS/Repository" "mod2" + dotest cvsadm-1d29h "cat dir/dir2d2/sub2d2/CVS/Repository" "mod2/sub2" + # the usual for 2d2mod + dotest cvsadm-1d29j "cat dir/dir2d2-2/CVS/Repository" "mod2-2" + dotest cvsadm-1d29l "cat dir/dir2d2-2/sub2d2-2/CVS/Repository" \ +"mod2-2/sub2-2" + rm -rf CVS dir + + ################################################## + ## And now, some of that again using the "-d" flag + ## on the command line, but use a longer path. + ################################################## + + dotest cvsadm-2d3-1 "$testcvs co -d dir/dir2 1mod" \ +"$SPROG checkout: Updating dir/dir2 +U dir/dir2/file1" + + # Remote couldn't handle this, even with the "mkdir dir", before + # CVS 1.11.14. + dotest cvsadm-2d3b "cat CVS/Repository" "\." + dotest cvsadm-2d3d "cat dir/CVS/Repository" "." + dotest cvsadm-2d3f "cat dir/dir2/CVS/Repository" "mod1" + rm -rf CVS dir + + mkdir dir + dotest cvsadm-2d4 "$testcvs co -d dir/dir2 2mod" \ +"$SPROG checkout: Updating dir/dir2 +U dir/dir2/file2" + dotest cvsadm-2d4b "cat CVS/Repository" "\." + dotest cvsadm-2d4f "cat dir/dir2/CVS/Repository" "mod2/sub2" + rm -rf CVS dir + + mkdir dir + dotest cvsadm-2d5 "$testcvs co -d dir/dir2 1d1mod" \ +"$SPROG checkout: Updating dir/dir2 +U dir/dir2/file1" + dotest cvsadm-2d5b "cat CVS/Repository" "\." + dotest cvsadm-2d5f "cat dir/dir2/CVS/Repository" "mod1" + rm -rf CVS dir + + mkdir dir + dotest cvsadm-2d6 "$testcvs co -d dir/dir2 1d2mod" \ +"$SPROG checkout: Updating dir/dir2 +U dir/dir2/file2" + dotest cvsadm-2d6b "cat CVS/Repository" "\." + dotest cvsadm-2d6f "cat dir/dir2/CVS/Repository" "mod2/sub2" + rm -rf CVS dir + + mkdir dir + dotest cvsadm-2d7 "$testcvs co -d dir/dir2 2d1mod" \ +"$SPROG checkout: Updating dir/dir2 +U dir/dir2/file1" + dotest cvsadm-2d7b "cat CVS/Repository" "\." + dotest cvsadm-2d7f "cat dir/dir2/CVS/Repository" "mod1" + rm -rf CVS dir + + mkdir dir + dotest cvsadm-2d8 "$testcvs co -d dir/dir2 2d2mod" \ +"$SPROG checkout: Updating dir/dir2 +U dir/dir2/file2" + dotest cvsadm-2d8b "cat CVS/Repository" "\." + dotest cvsadm-2d8f "cat dir/dir2/CVS/Repository" "mod2/sub2" + rm -rf CVS dir + + ################################################## + ## And now, a few of those tests revisited to + ## test the behavior of the -N flag. + ################################################## + + dotest cvsadm-N3 "$testcvs co -N 1mod" \ +"$SPROG checkout: Updating 1mod +U 1mod/file1" + dotest cvsadm-N3b "cat CVS/Repository" "\." + dotest cvsadm-N3d "cat 1mod/CVS/Repository" "mod1" + rm -rf CVS 1mod + + dotest cvsadm-N4 "$testcvs co -N 2mod" \ +"$SPROG checkout: Updating 2mod +U 2mod/file2" + dotest cvsadm-N4b "cat CVS/Repository" "\." + dotest cvsadm-N4d "cat 2mod/CVS/Repository" "mod2/sub2" + rm -rf CVS 2mod + + dotest cvsadm-N5 "$testcvs co -N 1d1mod" \ +"$SPROG checkout: Updating dir1d1 +U dir1d1/file1" + dotest cvsadm-N5b "cat CVS/Repository" "\." + dotest cvsadm-N5d "cat dir1d1/CVS/Repository" "mod1" + rm -rf CVS dir1d1 + + dotest cvsadm-N6 "$testcvs co -N 1d2mod" \ +"$SPROG checkout: Updating dir1d2 +U dir1d2/file2" + dotest cvsadm-N6b "cat CVS/Repository" "\." + dotest cvsadm-N6d "cat dir1d2/CVS/Repository" "mod2/sub2" + rm -rf CVS dir1d2 + + dotest cvsadm-N7 "$testcvs co -N 2d1mod" \ +"$SPROG checkout: Updating dir2d1/sub2d1 +U dir2d1/sub2d1/file1" + dotest cvsadm-N7b "cat CVS/Repository" "\." + dotest cvsadm-N7d "cat dir2d1/CVS/Repository" "\." + dotest cvsadm-N7f "cat dir2d1/sub2d1/CVS/Repository" "mod1" + rm -rf CVS dir2d1 + + dotest cvsadm-N8 "$testcvs co -N 2d2mod" \ +"$SPROG checkout: Updating dir2d2/sub2d2 +U dir2d2/sub2d2/file2" + dotest cvsadm-N8b "cat CVS/Repository" "\." + dotest cvsadm-N8d "cat dir2d2/CVS/Repository" "mod2" + dotest cvsadm-N8f "cat dir2d2/sub2d2/CVS/Repository" "mod2/sub2" + rm -rf CVS dir2d2 + + ## the ones in one-deep directories + + dotest cvsadm-N1d3 "$testcvs co -N -d dir 1mod" \ +"$SPROG checkout: Updating dir/1mod +U dir/1mod/file1" + dotest cvsadm-N1d3b "cat CVS/Repository" "\." + dotest cvsadm-N1d3d "cat dir/CVS/Repository" "\." + dotest cvsadm-N1d3f "cat dir/1mod/CVS/Repository" "mod1" + rm -rf CVS dir + + dotest cvsadm-N1d4 "$testcvs co -N -d dir 2mod" \ +"$SPROG checkout: Updating dir/2mod +U dir/2mod/file2" + dotest cvsadm-N1d4b "cat CVS/Repository" "\." + dotest cvsadm-N1d4d "cat dir/CVS/Repository" "mod2" + dotest cvsadm-N1d4f "cat dir/2mod/CVS/Repository" "mod2/sub2" + rm -rf CVS dir + + dotest cvsadm-N1d5 "$testcvs co -N -d dir 1d1mod" \ +"$SPROG checkout: Updating dir/dir1d1 +U dir/dir1d1/file1" + dotest cvsadm-N1d5b "cat CVS/Repository" "\." + dotest cvsadm-N1d5d "cat dir/CVS/Repository" "\." + dotest cvsadm-N1d5d "cat dir/dir1d1/CVS/Repository" "mod1" + rm -rf CVS dir + + dotest cvsadm-N1d6 "$testcvs co -N -d dir 1d2mod" \ +"$SPROG checkout: Updating dir/dir1d2 +U dir/dir1d2/file2" + dotest cvsadm-N1d6b "cat CVS/Repository" "\." + dotest cvsadm-N1d6d "cat dir/CVS/Repository" "mod2" + dotest cvsadm-N1d6f "cat dir/dir1d2/CVS/Repository" "mod2/sub2" + rm -rf CVS dir + + dotest cvsadm-N1d7 "$testcvs co -N -d dir 2d1mod" \ +"$SPROG checkout: Updating dir/dir2d1/sub2d1 +U dir/dir2d1/sub2d1/file1" + dotest cvsadm-N1d7b "cat CVS/Repository" "\." + dotest cvsadm-N1d7d "cat dir/CVS/Repository" "CVSROOT/Emptydir" + dotest cvsadm-N1d7f "cat dir/dir2d1/CVS/Repository" "\." + dotest cvsadm-N1d7h "cat dir/dir2d1/sub2d1/CVS/Repository" "mod1" + rm -rf CVS dir + + dotest cvsadm-N1d8 "$testcvs co -N -d dir 2d2mod" \ +"$SPROG checkout: Updating dir/dir2d2/sub2d2 +U dir/dir2d2/sub2d2/file2" + dotest cvsadm-N1d8b "cat CVS/Repository" "\." + dotest cvsadm-N1d8d "cat dir/CVS/Repository" "\." + dotest cvsadm-N1d8d "cat dir/dir2d2/CVS/Repository" "mod2" + dotest cvsadm-N1d8d "cat dir/dir2d2/sub2d2/CVS/Repository" \ +"mod2/sub2" + rm -rf CVS dir + + ## the ones in two-deep directories + + mkdir dir + dotest cvsadm-N2d3 "$testcvs co -N -d dir/dir2 1mod" \ +"$SPROG checkout: Updating dir/dir2/1mod +U dir/dir2/1mod/file1" + dotest cvsadm-N2d3b "cat CVS/Repository" "\." + dotest cvsadm-N2d3f "cat dir/dir2/CVS/Repository" "\." + dotest cvsadm-N2d3h "cat dir/dir2/1mod/CVS/Repository" "mod1" + rm -rf CVS dir + + mkdir dir + dotest cvsadm-N2d4 "$testcvs co -N -d dir/dir2 2mod" \ +"$SPROG checkout: Updating dir/dir2/2mod +U dir/dir2/2mod/file2" + dotest cvsadm-N2d4b "cat CVS/Repository" "\." + dotest cvsadm-N2d4f "cat dir/dir2/CVS/Repository" "mod2" + dotest cvsadm-N2d4h "cat dir/dir2/2mod/CVS/Repository" "mod2/sub2" + rm -rf CVS dir + + mkdir dir + dotest cvsadm-N2d5 "$testcvs co -N -d dir/dir2 1d1mod" \ +"$SPROG checkout: Updating dir/dir2/dir1d1 +U dir/dir2/dir1d1/file1" + dotest cvsadm-N2d5b "cat CVS/Repository" "\." + dotest cvsadm-N2d5f "cat dir/dir2/CVS/Repository" "\." + dotest cvsadm-N2d5h "cat dir/dir2/dir1d1/CVS/Repository" "mod1" + rm -rf CVS dir + + mkdir dir + dotest cvsadm-N2d6 "$testcvs co -N -d dir/dir2 1d2mod" \ +"$SPROG checkout: Updating dir/dir2/dir1d2 +U dir/dir2/dir1d2/file2" + dotest cvsadm-N2d6b "cat CVS/Repository" "\." + dotest cvsadm-N2d6f "cat dir/dir2/CVS/Repository" "mod2" + dotest cvsadm-N2d6h "cat dir/dir2/dir1d2/CVS/Repository" "mod2/sub2" + rm -rf CVS dir + + mkdir dir + dotest cvsadm-N2d7 "$testcvs co -N -d dir/dir2 2d1mod" \ +"$SPROG checkout: Updating dir/dir2/dir2d1/sub2d1 +U dir/dir2/dir2d1/sub2d1/file1" + dotest cvsadm-N2d7b "cat CVS/Repository" "\." + dotest cvsadm-N2d7f "cat dir/dir2/CVS/Repository" "CVSROOT/Emptydir" + dotest cvsadm-N2d7g "cat dir/dir2/dir2d1/CVS/Repository" "\." + dotest cvsadm-N2d7h "cat dir/dir2/dir2d1/sub2d1/CVS/Repository" \ +"mod1" + rm -rf CVS dir + + mkdir dir + dotest cvsadm-N2d8 "$testcvs co -N -d dir/dir2 2d2mod" \ +"$SPROG checkout: Updating dir/dir2/dir2d2/sub2d2 +U dir/dir2/dir2d2/sub2d2/file2" + dotest cvsadm-N2d8b "cat CVS/Repository" "\." + dotest cvsadm-N2d8f "cat dir/dir2/CVS/Repository" "\." + dotest cvsadm-N2d8h "cat dir/dir2/dir2d2/CVS/Repository" "mod2" + dotest cvsadm-N2d8j "cat dir/dir2/dir2d2/sub2d2/CVS/Repository" \ +"mod2/sub2" + rm -rf CVS dir + # End of test that didn't work for remote prior to CVS 1.11.14. + + ################################################## + ## That's enough of that, thank you very much. + ################################################## + + dokeep + restore_adm + + # remove our junk + cd .. + rm -r 1 + modify_repo rm -rf $CVSROOT_DIRNAME/1mod $CVSROOT_DIRNAME/1mod-2 \ + $CVSROOT_DIRNAME/2mod $CVSROOT_DIRNAME/2mod-2 \ + $CVSROOT_DIRNAME/mod1 $CVSROOT_DIRNAME/mod1-2 \ + $CVSROOT_DIRNAME/mod2 $CVSROOT_DIRNAME/mod2-2 + ;; + + + + emptydir) + # Various tests of the Emptydir (CVSNULLREPOS) code. See also: + # cvsadm: tests of Emptydir in various module definitions + # basicb: Test that "Emptydir" is non-special in ordinary contexts + + mkdir 1; cd 1 + dotest emptydir-1 "${testcvs} co CVSROOT/modules" \ +"U CVSROOT/modules" + echo "# Module defs for emptydir tests" > CVSROOT/modules + echo "2d1mod -d dir2d1/sub/sub2d1 mod1" >> CVSROOT/modules + echo "2d1moda -d dir2d1/suba moda/modasub" >> CVSROOT/modules + echo "2d1modb -d dir2d1/suba mod1" >> CVSROOT/modules + echo "comb -a 2d1modb 2d1moda" >> CVSROOT/modules + + dotest emptydir-2 "${testcvs} ci -m add-modules" \ +"${CPROG} commit: Examining CVSROOT +${CVSROOT_DIRNAME}/CVSROOT/modules,v <-- CVSROOT/modules +new revision: 1\.[0-9]*; previous revision: 1\.[0-9]* +${SPROG} commit: Rebuilding administrative file database" \ +"${CPROG} commit: Examining CVSROOT" + rm -rf CVS CVSROOT + + modify_repo mkdir $CVSROOT_DIRNAME/mod1 $CVSROOT_DIRNAME/moda + # Populate. Not sure we really need to do this. + dotest emptydir-3 "$testcvs -q co -l ." + dotest emptydir-3a "${testcvs} co mod1 moda" \ +"${SPROG} checkout: Updating mod1 +${SPROG} checkout: Updating moda" + echo "file1" > mod1/file1 + mkdir moda/modasub + dotest emptydir-3b "${testcvs} add moda/modasub" \ +"Directory ${CVSROOT_DIRNAME}/moda/modasub added to the repository" + echo "filea" > moda/modasub/filea + dotest emptydir-4 "${testcvs} add mod1/file1 moda/modasub/filea" \ +"${SPROG} add: scheduling file .mod1/file1. for addition +${SPROG} add: scheduling file .moda/modasub/filea. for addition +${SPROG} add: use \`${SPROG} commit' to add these files permanently" + dotest emptydir-5 "${testcvs} -q ci -m yup" \ +"$CVSROOT_DIRNAME/mod1/file1,v <-- mod1/file1 +initial revision: 1\.1 +${CVSROOT_DIRNAME}/moda/modasub/filea,v <-- moda/modasub/filea +initial revision: 1\.1" + rm -rf mod1 moda CVS + # End Populate. + + dotest emptydir-6 "${testcvs} co 2d1mod" \ +"${SPROG} checkout: Updating dir2d1/sub/sub2d1 +U dir2d1/sub/sub2d1/file1" + cd dir2d1 + touch emptyfile + # It doesn't make any sense to add a file (or do much of anything + # else) in Emptydir; Emptydir is a placeholder indicating that + # the working directory doesn't correspond to anything in + # the repository. + dotest_fail emptydir-7 "${testcvs} add emptyfile" \ +"${SPROG} \[add aborted]: cannot add to \`${CVSROOT_DIRNAME}/CVSROOT/Emptydir'" + mkdir emptydir + dotest_fail emptydir-8 "${testcvs} add emptydir" \ +"${CPROG} \[add aborted]: cannot add to \`${CVSROOT_DIRNAME}/CVSROOT/Emptydir'" + cd .. + rm -rf CVS dir2d1 + + # OK, while we have an Emptydir around, test a few obscure + # things about it. + mkdir edir; cd edir + dotest emptydir-9 "${testcvs} -q co -l CVSROOT" \ +"U CVSROOT${DOTSTAR}" + cd CVSROOT + dotest_fail emptydir-10 "test -d Emptydir" '' + # This tests the code in find_dirs which skips Emptydir. + dotest emptydir-11 "${testcvs} -q -n update -d -P" '' + cd ../.. + rm -r edir + cd .. + + # Now start playing with moda. + mkdir 2; cd 2 + dotest emptydir-12 "${testcvs} -q co 2d1moda" \ +"U dir2d1/suba/filea" + # OK, this is the crux of the matter. This used to show "Emptydir", + # but everyone seemed to think it should show "moda". This + # usually works better, but not always as shown by the following + # test. + dotest emptydir-13 "cat dir2d1/CVS/Repository" "moda" + dotest_fail emptydir-14 "${testcvs} co comb" \ +"${SPROG} checkout: existing repository ${CVSROOT_DIRNAME}/moda/modasub does not match ${CVSROOT_DIRNAME}/mod1 +${SPROG} checkout: ignoring module 2d1modb +${SPROG} checkout: Updating dir2d1/suba" + dotest emptydir-15 "cat dir2d1/CVS/Repository" "moda" + cd .. + + # Test the effect of a non-cvs directory already existing with the + # same name as one in the modules file. + mkdir 3; cd 3 + mkdir dir2d1 + dotest emptydir-16 "${testcvs} co 2d1mod" \ +"${SPROG} checkout: Updating dir2d1/sub/sub2d1 +U dir2d1/sub/sub2d1/file1" + + if $remote; then + dotest emptydir-17 "cat dir2d1/CVS/Repository" "CVSROOT/Emptydir" + else + dotest_fail emptydir-17 "test -d dir2d1/CVS" + fi + + dokeep + cd .. + rm -r 1 2 3 + modify_repo rm -rf $CVSROOT_DIRNAME/mod1 $CVSROOT_DIRNAME/moda + # I guess for the moment the convention is going to be + # that we don't need to remove $CVSROOT_DIRNAME/CVSROOT/Emptydir + ;; + + + + abspath) + + # These tests test the thituations thin thwitch thoo theck + # things thout twith thabsolute thaths. Threally. + + # + # CHECKOUTS + # + + # Create a few modules to use + modify_repo mkdir $CVSROOT_DIRNAME/mod1 $CVSROOT_DIRNAME/mod2 + dotest abspath-1a "${testcvs} co mod1 mod2" \ +"${SPROG} checkout: Updating mod1 +${SPROG} checkout: Updating mod2" + + # Populate the module + echo "file1" > mod1/file1 + echo "file2" > mod2/file2 + cd mod1 + dotest abspath-1ba "${testcvs} add file1" \ +"${SPROG} add: scheduling file .file1. for addition +${SPROG} add: use \`${SPROG} commit' to add this file permanently" + cd .. + cd mod2 + dotest abspath-1bb "${testcvs} add file2" \ +"${SPROG} add: scheduling file .file2. for addition +${SPROG} add: use \`${SPROG} commit' to add this file permanently" + cd .. + + dotest abspath-1c "${testcvs} ci -m yup mod1 mod2" \ +"${CPROG} commit: Examining mod1 +${CPROG} commit: Examining mod2 +${CVSROOT_DIRNAME}/mod1/file1,v <-- mod1/file1 +initial revision: 1.1 +${CVSROOT_DIRNAME}/mod2/file2,v <-- mod2/file2 +initial revision: 1.1" + # Finished creating the module -- clean up. + rm -rf CVS mod1 mod2 + # Done. + + # Try checking out the module in a local directory + if $remote; then + dotest_fail abspath-2a "${testcvs} co -d ${TESTDIR}/1 mod1" \ +"${SPROG} \[checkout aborted\]: absolute pathnames invalid for server (specified .${TESTDIR}/1.)" + dotest abspath-2a-try2 "${testcvs} co -d 1 mod1" \ +"${SPROG} checkout: Updating 1 +U 1/file1" + else + dotest abspath-2a "${testcvs} co -d ${TESTDIR}/1 mod1" \ +"${SPROG} checkout: Updating ${TESTDIR}/1 +U ${TESTDIR}/1/file1" + fi # remote workaround + + dotest abspath-2b "cat ${TESTDIR}/1/CVS/Repository" "mod1" + + # Done. Clean up. + rm -r $TESTDIR/1 + + + # Now try in a subdirectory. We're not covering any more + # code here, but we might catch a future error if someone + # changes the checkout code. + + # Since CVS 1.11.14, CVS will create leading directories specified + # via co -d. + # I am unsure that this wasn't the behavior prior to CVS 1.9, but the + # comment that used to be here leads me to believe it was not. + if $remote; then :; else + dotest abspath-3.1 "$testcvs -q co -d $TESTDIR/1/2 mod1" \ +"U $TESTDIR/1/2/file1" + rm -r $TESTDIR/1 + fi + dotest abspath-3.2 "$testcvs -q co -d 1/2 mod1" \ +"U 1/2/file1" + rm -r 1 + + # We don't to mess with an existing directory just to traverse it, + # for example by creating a CVS directory, but currently we can't + # avoid this in client/server mode. + mkdir 1 + if $remote; then + dotest abspath-3ar "$testcvs co -d 1/2 mod1" \ +"$SPROG checkout: Updating 1/2 +U 1/2/file1" + dotest abspath-3br "cat 1/CVS/Repository" . + else + dotest abspath-3a "$testcvs co -d $TESTDIR/1/2 mod1" \ +"$SPROG checkout: Updating $TESTDIR/1/2 +U $TESTDIR/1/2/file1" + dotest_fail abspath-3b "test -d ${TESTDIR}/1/CVS" + fi + + dotest abspath-3c "cat ${TESTDIR}/1/2/CVS/Repository" mod1 + + + # Done. Clean up. + rm -rf ${TESTDIR}/1 + + + # Now try someplace where we don't have permission. + mkdir ${TESTDIR}/barf + chmod -w ${TESTDIR}/barf + dotest_fail abspath-4r "${testcvs} co -d ${TESTDIR}/barf/sub mod1" \ +"${SPROG} \[checkout aborted\]: cannot make directory sub: Permission denied" \ +"${SPROG} \[checkout aborted\]: absolute pathnames invalid for server (specified .${TESTDIR}/barf/sub.)" + chmod +w ${TESTDIR}/barf + rmdir ${TESTDIR}/barf + # Done. Nothing to clean up. + + + # Try checking out two modules into the same directory. + if $remote; then + dotest abspath-5ar "${testcvs} co -d 1 mod1 mod2" \ +"${SPROG} checkout: Updating 1/mod1 +U 1/mod1/file1 +${SPROG} checkout: Updating 1/mod2 +U 1/mod2/file2" + else + dotest abspath-5a "${testcvs} co -d ${TESTDIR}/1 mod1 mod2" \ +"${SPROG} checkout: Updating ${TESTDIR}/1/mod1 +U ${TESTDIR}/1/mod1/file1 +${SPROG} checkout: Updating ${TESTDIR}/1/mod2 +U ${TESTDIR}/1/mod2/file2" + fi # end remote workaround + dotest abspath-5b "cat ${TESTDIR}/1/CVS/Repository" "\." + dotest abspath-5c "cat ${TESTDIR}/1/mod1/CVS/Repository" "mod1" + dotest abspath-5d "cat ${TESTDIR}/1/mod2/CVS/Repository" "mod2" + # Done. Clean up. + rm -rf $TESTDIR/1 + + + # Try checking out the top-level module. + if $remote; then + dotest abspath-6ar "$testcvs co -d 1 ." \ +"$SPROG checkout: Updating 1 +$SPROG checkout: Updating 1/CVSROOT +$DOTSTAR +$SPROG checkout: Updating 1/mod1 +U 1/mod1/file1 +$SPROG checkout: Updating 1/mod2 +U 1/mod2/file2" + else + dotest abspath-6a "${testcvs} co -d ${TESTDIR}/1 ." \ +"${SPROG} checkout: Updating ${TESTDIR}/1 +${SPROG} checkout: Updating ${TESTDIR}/1/CVSROOT +${DOTSTAR} +${SPROG} checkout: Updating ${TESTDIR}/1/mod1 +U ${TESTDIR}/1/mod1/file1 +${SPROG} checkout: Updating ${TESTDIR}/1/mod2 +U ${TESTDIR}/1/mod2/file2" + fi # end of remote workaround + dotest abspath-6b "cat ${TESTDIR}/1/CVS/Repository" "\." + dotest abspath-6c "cat ${TESTDIR}/1/CVSROOT/CVS/Repository" "CVSROOT" + dotest abspath-6c "cat ${TESTDIR}/1/mod1/CVS/Repository" "mod1" + dotest abspath-6d "cat ${TESTDIR}/1/mod2/CVS/Repository" "mod2" + # Done. Clean up. + rm -rf ${TESTDIR}/1 + + # Test that an absolute pathname to some other directory + # doesn't mess with the current working directory. + mkdir 1 + cd 1 + if $remote; then + dotest_fail abspath-7ar "${testcvs} -q co -d ../2 mod2" \ +"${SPROG} checkout: protocol error: .\.\./2. contains more leading \.\. +${SPROG} \[checkout aborted\]: than the 0 which Max-dotdot specified" + cd .. + dotest abspath-7a-try2r "${testcvs} -q co -d 2 mod2" \ +"U 2/file2" + cd 1 + else + dotest abspath-7a "${testcvs} -q co -d ${TESTDIR}/2 mod2" \ +"U ${TESTDIR}/2/file2" + fi # remote workaround + dotest abspath-7b "ls" "" + dotest abspath-7c "${testcvs} -q co mod1" \ +"U mod1/file1" + cd mod1 + if $remote; then + cd ../.. + dotest abspath-7dr "${testcvs} -q co -d 3 mod2" \ +"U 3/file2" + cd 1/mod1 + else + dotest abspath-7d "${testcvs} -q co -d ${TESTDIR}/3 mod2" \ +"U ${TESTDIR}/3/file2" + fi # remote workaround + dotest abspath-7e "${testcvs} -q update -d" + + # + # FIXME: do other functions here (e.g. update /tmp/foo) + # + + # Finished with all tests. Cleanup. + dokeep + cd ../.. + rm -r 1 2 3 + modify_repo rm -rf $CVSROOT_DIRNAME/mod1 $CVSROOT_DIRNAME/mod2 + ;; + + + + abspath2) + # More absolute path checks. The following used to attempt to create + # directories in /: + # + # $ cvs -d:fork:/cvsroot co /foo + # cvs checkout: warning: cannot make directory CVS in /: Permission denied + # cvs [checkout aborted]: cannot make directory /foo: Permission denied + # $ + # + # The -z9 in this test also checks for an old server bug where the + # server would block indefinitely attempting to read an EOF from the + # client in the compression buffer shutdown routine. + dotest_fail abspath2-1 "$testcvs -z9 co /foo" \ +"$CPROG \[checkout aborted\]: Absolute module reference invalid: \`/foo'" \ +"$SPROG \[server aborted\]: Absolute module reference invalid: \`/foo' +$CPROG \[checkout aborted\]: end of file from server (consult above messages if any)" + ;; + + + + toplevel) + # test the feature that cvs creates a CVS subdir also for + # the toplevel directory + + # First set the TopLevelAdmin setting. + mkdir 1; cd 1 + dotest toplevel-1a "${testcvs} -q co CVSROOT/config" \ +"U CVSROOT/config" + cd CVSROOT + echo "TopLevelAdmin=yes" >>config + dotest toplevel-1b "${testcvs} -q ci -m yes-top-level" \ +"$CVSROOT_DIRNAME/CVSROOT/config,v <-- config +new revision: 1\.[0-9]*; previous revision: 1\.[0-9]* +$SPROG commit: Rebuilding administrative file database" + cd ../.. + rm -r 1 + + mkdir 1; cd 1 + dotest toplevel-1 "${testcvs} -q co -l ." '' + mkdir top-dir second-dir + dotest toplevel-2 "${testcvs} add top-dir second-dir" \ +"Directory ${CVSROOT_DIRNAME}/top-dir added to the repository +Directory ${CVSROOT_DIRNAME}/second-dir added to the repository" + cd top-dir + + touch file1 + dotest toplevel-3 "${testcvs} add file1" \ +"${SPROG} add: scheduling file .file1. for addition +${SPROG} add: use .${SPROG} commit. to add this file permanently" + dotest toplevel-4 "${testcvs} -q ci -m add" \ +"$CVSROOT_DIRNAME/top-dir/file1,v <-- file1 +initial revision: 1\.1" + cd .. + + cd second-dir + touch file2 + dotest toplevel-3s "${testcvs} add file2" \ +"${SPROG} add: scheduling file .file2. for addition +${SPROG} add: use .${SPROG} commit. to add this file permanently" + dotest toplevel-4s "${testcvs} -q ci -m add" \ +"$CVSROOT_DIRNAME/second-dir/file2,v <-- file2 +initial revision: 1\.1" + + cd ../.. + rm -r 1; mkdir 1; cd 1 + dotest toplevel-5 "${testcvs} co top-dir" \ +"${SPROG} checkout: Updating top-dir +U top-dir/file1" + + dotest toplevel-6 "${testcvs} update top-dir" \ +"${SPROG} update: Updating top-dir" + dotest toplevel-7 "${testcvs} update" \ +"${SPROG} update: Updating \. +${SPROG} update: Updating top-dir" + + dotest toplevel-8 "${testcvs} update -d top-dir" \ +"${SPROG} update: Updating top-dir" + # There is some sentiment that + # "${SPROG} update: Updating \. + # ${SPROG} update: Updating top-dir" + # is correct but it isn't clear why that would be correct instead + # of the remote CVS behavior (which also updates CVSROOT). + # + # The DOTSTAR matches of a bunch of lines like + # "U CVSROOT/checkoutlist". Trying to match them more precisely + # seemed to cause trouble. For example CVSROOT/cvsignore will + # be present or absent depending on whether we ran the "ignore" + # test or not. + dotest toplevel-9 "${testcvs} update -d" \ +"${SPROG} update: Updating \. +${SPROG} update: Updating CVSROOT +${DOTSTAR} +${SPROG} update: Updating top-dir" + + cd .. + rm -r 1; mkdir 1; cd 1 + dotest toplevel-10 "${testcvs} co top-dir" \ +"${SPROG} checkout: Updating top-dir +U top-dir/file1" + + # This tests more or less the same thing, in a particularly + # "real life" example. + dotest toplevel-11 "${testcvs} -q update -d second-dir" \ +"U second-dir/file2" + + # Now remove the CVS directory (people may do this manually, + # especially if they formed their habits with CVS + # 1.9 and older, which didn't create it. Or perhaps the working + # directory itself was created with 1.9 or older). + rm -r CVS + # Now set the permissions so we can't recreate it. + if test -n "$remotehost"; then + # Cygwin again. + $CVS_RSH $remotehost "chmod -w $TESTDIR/1" + else + chmod -w ../1 + fi + # Now see whether CVS has trouble because it can't create CVS. + # First string is for local, second is for remote. + dotest toplevel-12 "${testcvs} co top-dir" \ +"${SPROG} checkout: warning: cannot make directory CVS in \.: Permission denied +${SPROG} checkout: Updating top-dir" \ +"${CPROG} checkout: warning: cannot make directory CVS in \.: Permission denied +${CPROG} checkout: in directory \.: +${CPROG} checkout: cannot open CVS/Entries for reading: No such file or directory +${SPROG} checkout: Updating top-dir" + + chmod +w ../1 + + dokeep + restore_adm + cd .. + rm -r 1 + modify_repo rm -rf $CVSROOT_DIRNAME/top-dir \ + $CVSROOT_DIRNAME/second-dir + ;; + + + + toplevel2) + # Similar to toplevel, but test the case where TopLevelAdmin=no. + + # First set the TopLevelAdmin setting. + mkdir 1; cd 1 + dotest toplevel2-1a "${testcvs} -q co CVSROOT/config" \ +"U CVSROOT/config" + cd CVSROOT + echo "TopLevelAdmin=no" >>config + dotest toplevel2-1b "$testcvs -q ci -m no-top-level" \ +"$CVSROOT_DIRNAME/CVSROOT/config,v <-- config +new revision: 1\.[0-9]*; previous revision: 1\.[0-9]* +$SPROG commit: Rebuilding administrative file database" + cd ../.. + rm -r 1 + + # Now set up some directories and subdirectories + mkdir 1; cd 1 + dotest toplevel2-1 "${testcvs} -q co -l ." '' + mkdir top-dir second-dir + dotest toplevel2-2 "${testcvs} add top-dir second-dir" \ +"Directory ${CVSROOT_DIRNAME}/top-dir added to the repository +Directory ${CVSROOT_DIRNAME}/second-dir added to the repository" + cd top-dir + + touch file1 + dotest toplevel2-3 "${testcvs} add file1" \ +"${SPROG} add: scheduling file .file1. for addition +${SPROG} add: use .${SPROG} commit. to add this file permanently" + dotest toplevel2-4 "${testcvs} -q ci -m add" \ +"$CVSROOT_DIRNAME/top-dir/file1,v <-- file1 +initial revision: 1\.1" + cd .. + + cd second-dir + touch file2 + dotest toplevel2-3s "${testcvs} add file2" \ +"${SPROG} add: scheduling file .file2. for addition +${SPROG} add: use .${SPROG} commit. to add this file permanently" + dotest toplevel2-4s "${testcvs} -q ci -m add" \ +"$CVSROOT_DIRNAME/second-dir/file2,v <-- file2 +initial revision: 1\.1" + + cd ../.. + rm -r 1; mkdir 1; cd 1 + dotest toplevel2-5 "${testcvs} co top-dir" \ +"${SPROG} checkout: Updating top-dir +U top-dir/file1" + + dotest toplevel2-6 "${testcvs} update top-dir" \ +"${SPROG} update: Updating top-dir" + dotest toplevel2-7 "${testcvs} update" \ +"${SPROG} update: Updating top-dir" + + dotest toplevel2-8 "${testcvs} update -d top-dir" \ +"${SPROG} update: Updating top-dir" + # Contrast this with toplevel-9, which has TopLevelAdmin=yes. + dotest toplevel2-9 "${testcvs} update -d" \ +"${SPROG} update: Updating top-dir" + + cd .. + rm -r 1; mkdir 1; cd 1 + dotest toplevel2-10 "${testcvs} co top-dir" \ +"${SPROG} checkout: Updating top-dir +U top-dir/file1" + # This tests more or less the same thing, in a particularly + # "real life" example. With TopLevelAdmin=yes, this command + # would give us second-dir and CVSROOT directories too. + dotest toplevel2-11 "${testcvs} -q update -d" "" + + dokeep + cd .. + restore_adm + rm -r 1 + modify_repo rm -rf $CVSROOT_DIRNAME/top-dir \ + $CVSROOT_DIRNAME/second-dir + ;; + + + + rstar-toplevel) + # This test used to confirm a bug that existed in the r* commands + # run against the top-level project prior to CVS 1.11.18 & 1.12.10. + # + # The assertion failure was something like: + # do_recursion: Assertion \`strstr (repository, \"/\./\") == ((void \*)0)' failed\..*" + dotest rstar-toplevel-1 "$testcvs -q rlog ." \ +" +RCS file: $CVSROOT_DIRNAME/CVSROOT$DOTSTAR" + + dokeep + ;; + + + + trailingslashes) + # Some tests of CVS's reactions to path specifications containing + # trailing slashes. + mkdir trailingslashes; cd trailingslashes + dotest trailingslashes-init-1 "$testcvs -Q co -ldt ." + dotest trailingslashes-init-2 "$testcvs -Q co -dt2 ." + cd t + echo "Ahh'll be baaack." >topfile + dotest trailingslashes-init-3 "$testcvs -Q add topfile" + dotest trailingslashes-init-4 "$testcvs -Q ci -mto-top" + + # First, demonstrate the usual case. + cd ../t2 + dotest trailingslashes-1 "$testcvs -q up CVSROOT" + dotest_fail trailingslashes-1a "test -f topfile" + + # FIXCVS: + # Now the one that fails in remote mode. + # This highlights one of the failure cases mentioned in TODO item + # #205. + if $remote; then + dotest trailingslashes-2 "$testcvs -q up CVSROOT/" \ +"U topfile" + dotest trailingslashes-2a "test -f topfile" + else + dotest trailingslashes-2 "$testcvs -q up CVSROOT/" + dotest_fail trailingslashes-2a "test -f topfile" + fi + + dokeep + cd ../.. + rm -rf trailingslashes + modify_repo rm -rf $CVSROOT_DIRNAME/topfile,v + ;; + + + + checkout_repository) + dotest_fail checkout_repository-1 \ +"${testcvs} co -d ${CVSROOT_DIRNAME} CVSROOT" \ +"${CPROG} \[checkout aborted\]: Cannot check out files into the repository itself" \ +"${SPROG} \[checkout aborted\]: absolute pathnames invalid for server (specified \`${CVSROOT_DIRNAME}')" + + # The behavior of the client/server test below should be correct. + # The CVS client currently has no way of knowing that the client and + # server are the same machine and thus skips the $CVSROOT checks. + # I think checking for this case in CVS would be bloat since this + # should be a fairly rare occurance. + cd ${CVSROOT_DIRNAME} + dotest_fail checkout_repository-2 "${testcvs} co CVSROOT" \ +"${CPROG} \[checkout aborted\]: Cannot check out files into the repository itself" \ +"${SPROG} checkout: Updating CVSROOT +${CPROG} checkout: move away \`CVSROOT/checkoutlist'; it is in the way +C CVSROOT/checkoutlist +${CPROG} checkout: move away \`CVSROOT/commitinfo'; it is in the way +C CVSROOT/commitinfo +${CPROG} checkout: move away \`CVSROOT/config'; it is in the way +C CVSROOT/config +${CPROG} checkout: move away \`CVSROOT/cvswrappers'; it is in the way +C CVSROOT/cvswrappers +${CPROG} checkout: move away \`CVSROOT/loginfo'; it is in the way +C CVSROOT/loginfo +${CPROG} checkout: move away \`CVSROOT/modules'; it is in the way +C CVSROOT/modules +${CPROG} checkout: move away \`CVSROOT/notify'; it is in the way +C CVSROOT/notify +${CPROG} checkout: move away \`CVSROOT/postadmin'; it is in the way +C CVSROOT/postadmin +${CPROG} checkout: move away \`CVSROOT/postproxy'; it is in the way +C CVSROOT/postproxy +${CPROG} checkout: move away \`CVSROOT/posttag'; it is in the way +C CVSROOT/posttag +${CPROG} checkout: move away \`CVSROOT/postwatch'; it is in the way +C CVSROOT/postwatch +${CPROG} checkout: move away \`CVSROOT/preproxy'; it is in the way +C CVSROOT/preproxy +${CPROG} checkout: move away \`CVSROOT/rcsinfo'; it is in the way +C CVSROOT/rcsinfo +${CPROG} checkout: move away \`CVSROOT/taginfo'; it is in the way +C CVSROOT/taginfo +${CPROG} checkout: move away \`CVSROOT/verifymsg'; it is in the way +C CVSROOT/verifymsg" + + dotest checkout_repository-3 \ +"${testcvs} co -p CVSROOT/modules >/dev/null" \ +"=================================================================== +Checking out CVSROOT/modules +RCS: ${CVSROOT_DIRNAME}/CVSROOT/modules,v +VERS: 1\.[0-9]* +\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*" + + dokeep + cd $TESTDIR + ;; + + + + mflag) + for message in '' ' ' ' + ' ' test' ; do + # Set up + mkdir a-dir; cd a-dir + # Test handling of -m during import + echo testa >>test + if ${testcvs} import -m "$message" a-dir A A1 >>${LOGFILE} 2>&1;then + pass 156 + else + fail 156 + fi + # Must import twice since the first time uses inline code that + # avoids RCS call. + echo testb >>test + if ${testcvs} import -m "$message" a-dir A A2 >>${LOGFILE} 2>&1;then + pass 157 + else + fail 157 + fi + # Test handling of -m during ci + cd ..; rm -r a-dir + if ${testcvs} co a-dir >>${LOGFILE} 2>&1; then + pass 158 + else + fail 158 + fi + cd a-dir + echo testc >>test + if ${testcvs} ci -m "$message" >>${LOGFILE} 2>&1; then + pass 159 + else + fail 159 + fi + # Test handling of -m during rm/ci + rm test; + if ${testcvs} rm test >>${LOGFILE} 2>&1; then + pass 160 + else + fail 160 + fi + if ${testcvs} ci -m "$message" >>${LOGFILE} 2>&1; then + pass 161 + else + fail 161 + fi + + dokeep + # Clean up + cd .. + rm -r a-dir + modify_repo rm -rf $CVSROOT_DIRNAME/a-dir + done + ;; + + + + editor) + # More tests of log messages, in this case the ability to + # run an external editor. + # TODO: + # * also test $EDITOR, $CVSEDITOR, &c. + # * test what happens if up-to-date check fails. + + # Our "editor" puts "x" at the start of each line, so we + # can see the "CVS:" lines. + cat >${TESTDIR}/editme <<EOF +#!${TESTSHELL} +sleep 1 +sed <\$1 -e 's/^/x/' >${TESTDIR}/edit.new +mv ${TESTDIR}/edit.new \$1 +exit 0 +EOF + chmod +x ${TESTDIR}/editme + + mkdir 1; cd 1 + dotest editor-1 "${testcvs} -q co -l ." '' + mkdir first-dir + dotest editor-2 "${testcvs} add first-dir" \ +"Directory ${CVSROOT_DIRNAME}/first-dir added to the repository" + cd first-dir + touch file1 file2 + dotest editor-3 "${testcvs} add file1 file2" \ +"${SPROG} add: scheduling file .file1. for addition +${SPROG} add: scheduling file .file2. for addition +${SPROG} add: use .${SPROG} commit. to add these files permanently" + dotest editor-4 "${testcvs} -e ${TESTDIR}/editme -q ci" \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +initial revision: 1\.1 +$CVSROOT_DIRNAME/first-dir/file2,v <-- file2 +initial revision: 1\.1" + dotest editor-5 "${testcvs} -q tag -b br" "T file1 +T file2" + dotest editor-6 "${testcvs} -q update -r br" '' + echo modify >>file1 + dotest editor-7 "${testcvs} -e ${TESTDIR}/editme -q ci" \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +new revision: 1\.1\.2\.1; previous revision: 1\.1" + # OK, now we want to make sure "ci -r" puts in the branch + # where appropriate. Note that we can check in on the branch + # without being on the branch, because there is not a revision + # already on the branch. If there were a revision on the branch, + # CVS would correctly give an up-to-date check failed. + dotest editor-8 "${testcvs} -q update -A" "U file1" + echo add a line >>file2 + dotest editor-9 "${testcvs} -q -e ${TESTDIR}/editme ci -rbr file2" \ +"$CVSROOT_DIRNAME/first-dir/file2,v <-- file2 +new revision: 1\.1\.2\.1; previous revision: 1\.1" + + dotest editor-log-file1 "${testcvs} log -N file1" " +RCS file: ${CVSROOT_DIRNAME}/first-dir/file1,v +Working file: file1 +head: 1\.1 +branch: +locks: strict +access list: +keyword substitution: kv +total revisions: 2; selected revisions: 2 +description: +---------------------------- +revision 1\.1 +date: ${ISO8601DATE}; author: ${username}; state: Exp; commitid: ${commitid}; +branches: 1\.1\.2; +xCVS: ---------------------------------------------------------------------- +xCVS: Enter Log. Lines beginning with .CVS:. are removed automatically +xCVS: +xCVS: Committing in . +xCVS: +xCVS: Added Files: +xCVS: file1 file2 +xCVS: ---------------------------------------------------------------------- +---------------------------- +revision 1\.1\.2\.1 +date: ${ISO8601DATE}; author: ${username}; state: Exp; lines: ${PLUS}1 -0; commitid: ${commitid}; +xCVS: ---------------------------------------------------------------------- +xCVS: Enter Log. Lines beginning with .CVS:. are removed automatically +xCVS: +xCVS: Committing in . +xCVS: +xCVS: Modified Files: +xCVS: Tag: br +xCVS: file1 +xCVS: ---------------------------------------------------------------------- +=============================================================================" + + # The only difference between the two expect strings is the + # presence or absence of "Committing in ." for 1.1.2.1. + dotest editor-log-file2 "${testcvs} log -N file2" " +RCS file: ${CVSROOT_DIRNAME}/first-dir/file2,v +Working file: file2 +head: 1\.1 +branch: +locks: strict +access list: +keyword substitution: kv +total revisions: 2; selected revisions: 2 +description: +---------------------------- +revision 1\.1 +date: ${ISO8601DATE}; author: ${username}; state: Exp; commitid: ${commitid}; +branches: 1\.1\.2; +xCVS: ---------------------------------------------------------------------- +xCVS: Enter Log. Lines beginning with .CVS:. are removed automatically +xCVS: +xCVS: Committing in . +xCVS: +xCVS: Added Files: +xCVS: file1 file2 +xCVS: ---------------------------------------------------------------------- +---------------------------- +revision 1\.1\.2\.1 +date: ${ISO8601DATE}; author: ${username}; state: Exp; lines: ${PLUS}1 -0; commitid: ${commitid}; +xCVS: ---------------------------------------------------------------------- +xCVS: Enter Log. Lines beginning with .CVS:. are removed automatically +xCVS: +xCVS: Modified Files: +xCVS: Tag: br +xCVS: file2 +xCVS: ---------------------------------------------------------------------- +=============================================================================" " +RCS file: ${CVSROOT_DIRNAME}/first-dir/file2,v +Working file: file2 +head: 1\.1 +branch: +locks: strict +access list: +keyword substitution: kv +total revisions: 2; selected revisions: 2 +description: +---------------------------- +revision 1\.1 +date: ${ISO8601DATE}; author: ${username}; state: Exp; commitid: ${commitid}; +branches: 1\.1\.2; +xCVS: ---------------------------------------------------------------------- +xCVS: Enter Log. Lines beginning with .CVS:. are removed automatically +xCVS: +xCVS: Committing in . +xCVS: +xCVS: Added Files: +xCVS: file1 file2 +xCVS: ---------------------------------------------------------------------- +---------------------------- +revision 1\.1\.2\.1 +date: ${ISO8601DATE}; author: ${username}; state: Exp; lines: ${PLUS}1 -0; commitid: ${commitid}; +xCVS: ---------------------------------------------------------------------- +xCVS: Enter Log. Lines beginning with .CVS:. are removed automatically +xCVS: +xCVS: Committing in . +xCVS: +xCVS: Modified Files: +xCVS: Tag: br +xCVS: file2 +xCVS: ---------------------------------------------------------------------- +=============================================================================" + + # Test CVS's response to an unchanged log message + cat >${TESTDIR}/editme <<EOF +#!${TESTSHELL} +sleep 1 +exit 0 +EOF + chmod +x ${TESTDIR}/editme + dotest_fail editor-emptylog-1 "echo a |${testcvs} -e ${TESTDIR}/editme ci -f file1" \ +" +Log message unchanged or not specified +a)bort, c)ontinue, e)dit, !)reuse this message unchanged for remaining dirs +Action: (continue) ${CPROG} \[commit aborted\]: aborted by user" + + # Test CVS's response to an empty log message + cat >${TESTDIR}/editme <<EOF +#!${TESTSHELL} +sleep 1 +cat /dev/null >\$1 +exit 0 +EOF + chmod +x ${TESTDIR}/editme + dotest_fail editor-emptylog-1a "echo a |${testcvs} -e ${TESTDIR}/editme ci -f file1" \ +" +Log message unchanged or not specified +a)bort, c)ontinue, e)dit, !)reuse this message unchanged for remaining dirs +Action: (continue) ${CPROG} \[commit aborted\]: aborted by user" + + # Test CVS's response to a log message with one blank line + cat >${TESTDIR}/editme <<EOF +#!${TESTSHELL} +sleep 1 +echo >\$1 +exit 0 +EOF + chmod +x ${TESTDIR}/editme + dotest_fail editor-emptylog-1b "echo a |${testcvs} -e ${TESTDIR}/editme ci -f file1" \ +" +Log message unchanged or not specified +a)bort, c)ontinue, e)dit, !)reuse this message unchanged for remaining dirs +Action: (continue) ${CPROG} \[commit aborted\]: aborted by user" + + # Test CVS's response to a log message with only comments + cat >${TESTDIR}/editme <<EOF +#!${TESTSHELL} +sleep 1 +cat \$1 >${TESTDIR}/edit.new +mv ${TESTDIR}/edit.new \$1 +exit 0 +EOF + chmod +x ${TESTDIR}/editme + dotest_fail editor-emptylog-1c "echo a |${testcvs} -e ${TESTDIR}/editme ci -f file1" \ +" +Log message unchanged or not specified +a)bort, c)ontinue, e)dit, !)reuse this message unchanged for remaining dirs +Action: (continue) ${CPROG} \[commit aborted\]: aborted by user" + + # Test CVS's response to a log message that is zero bytes + # in length. This caused core dumps in cvs 1.11.5 on Solaris + # hosts. + cd .. + dotest editor-emptylog-continue-1 "${testcvs} -q co CVSROOT/loginfo" \ +"U CVSROOT/loginfo" + + cd CVSROOT + cat <<\EOF >>loginfo +DEFAULT (echo Start-Log;cat;echo End-Log) >> $CVSROOT/CVSROOT/commitlog +EOF + dotest editor-emptylog-continue-2 "$testcvs -Q ci -mloggem" + + cd ../first-dir + cat >${TESTDIR}/editme <<EOF +#!${TESTSHELL} +sleep 1 +cp /dev/null \$1 +exit 1 +EOF + chmod +x ${TESTDIR}/editme + dotest editor-emptylog-continue-3 "echo c |${testcvs} -e ${TESTDIR}/editme ci -f file1" \ +"${CPROG} commit: warning: editor session failed + +Log message unchanged or not specified +a)bort, c)ontinue, e)dit, !)reuse this message unchanged for remaining dirs +Action: (continue) ${CVSROOT_DIRNAME}/first-dir/file1,v <-- file1 +new revision: 1\.2; previous revision: 1\.1" + # The loginfo Log message should be an empty line and not "(null)" + # which is what some fprintf() implementations do with "%s" + # format and a NULL pointer... + if $remote; then + dotest editor-emptylog-continue-4r \ +"cat $CVSROOT_DIRNAME/CVSROOT/commitlog" \ +"Start-Log +Update of $CVSROOT_DIRNAME/CVSROOT +In directory $hostname:$TMPDIR/cvs-serv[0-9a-z]* + +Modified Files: + loginfo +Log Message: +loggem +End-Log +Start-Log +Update of $CVSROOT_DIRNAME/first-dir +In directory $hostname:$TMPDIR/cvs-serv[0-9a-z]* + +Modified Files: + file1 +Log Message: + +End-Log" + else + dotest editor-emptylog-continue-4 \ +"cat $CVSROOT_DIRNAME/CVSROOT/commitlog" \ +"Start-Log +Update of $CVSROOT_DIRNAME/CVSROOT +In directory $hostname:$TESTDIR/1/CVSROOT + +Modified Files: + loginfo +Log Message: +loggem +End-Log +Start-Log +Update of $CVSROOT_DIRNAME/first-dir +In directory $hostname:$TESTDIR/1/first-dir + +Modified Files: + file1 +Log Message: + +End-Log" + fi + # There should have an empty log message at this point + dotest editor-emptylog-continue-5 "${testcvs} log -N -r1.2 file1" \ +" +RCS file: ${CVSROOT_DIRNAME}/first-dir/file1,v +Working file: file1 +head: 1\.2 +branch: +locks: strict +access list: +keyword substitution: kv +total revisions: 3; selected revisions: 1 +description: +---------------------------- +revision 1\.2 +date: ${ISO8601DATE}; author: ${username}; state: Exp; lines: +0 -0; commitid: ${commitid}; +\*\*\* empty log message \*\*\* +=============================================================================" + + # clean up + dokeep + # restore the default loginfo script + restore_adm + cd ../.. + rm -r 1 + rm $TESTDIR/editme + modify_repo rm -rf $CVSROOT_DIRNAME/first-dir + ;; + + + + env) + # Test to see if the CVS_PID environment variable is being set + mkdir ${TESTDIR}/env + cd ${TESTDIR}/env + dotest env-1 "${testcvs} -Q co . >>${LOGFILE}" '' + + cat > ${TESTDIR}/env/test-cvs-pid <<EOF +#!${TESTSHELL} +if test "x\$CVS_PID" != "x"; then + # In local mode, there is no directory with the pid in it for use. + # In remote mode the CVS_PID will be the parent process of the + # cvs process that runs the commitinfo script. + if test "x$remote" = "x:" ; then + ppid=\`pwd | sed -e 's,.*/cvs-serv,,'\` + else + # This assumes that the -l switch puts PPID in the banner and does + # not run the elements together such that whitespace surrounds the + # pid and ppid in the output. This could be made slightly simpler + # if all hosts had a 'ps' command that supported the -p switch, + # but Solaris 7 /usr/ucb/ps does not and that may be the one we use. + # It is because this is so messy that the CVS_PID feature exists. + pid=\$\$ + pidcmd="ps -o pid,ppid -p \$pid || ps -el || ps -al" + if echo \$pidcmd | sh >pid.stdout 2> pid.stderr; then + ppid=\`cat pid.stdout |\\ + awk '/PPID/ { for (i=1; i <= NF; i++) { + if (\$i == "PPID") ppidx = i; + if (\$i == "PID") pidx = i; + } + next; + } + { print \$pidx " " \$ppidx }' |\\ + grep "^\$pid " |\\ + awk '{ print \$NF }'\` + else + ppid=unkown + fi + fi + if test "x\$ppid" = "x\${CVS_PID}"; then + # The PID looks okay to me + # Clean up any temporary files + rm -f pid.stdout pid.stderr + exit 0 + else + echo The environment variable CVS_PID is not properly set. + echo It should have been set to \'\$ppid\' but instead was \'\$CVS_PID\' + echo It is possible that this test is broken for your host. + echo Current pid: \$pid + [ -n "\$pidcmd" ] && echo "Command: \$pidcmd" + [ -s pid.stdout ] && echo Standard Out: && cat pid.stdout + [ -s pid.stderr ] && echo Standard Error: && cat pid.stderr + exit 1 + fi +else + echo The environment variable CVS_PID is not set. + exit 1 +fi +EOF + if test -n "$remotehost"; then + $CVS_RSH $remotehost "chmod +x ${TESTDIR}/env/test-cvs-pid" + else + chmod +x ${TESTDIR}/env/test-cvs-pid + fi + cd CVSROOT + echo "^env ${TESTDIR}/env/test-cvs-pid %r/%p %s" >>commitinfo + dotest env-2 "${testcvs} -q ci -m test-pid commitinfo" \ +"${CVSROOT_DIRNAME}/CVSROOT/commitinfo,v <-- commitinfo +new revision: 1\.2; previous revision: 1\.1 +${SPROG} commit: Rebuilding administrative file database" + cd .. + mkdir env + dotest env-3 "${testcvs} -q add env" \ +"Directory ${CVSROOT_DIRNAME}/env added to the repository" + cd env + echo testing >file1 + dotest env-4 "${testcvs} add file1" \ +"${SPROG} add: scheduling file .file1. for addition +${SPROG} add: use .${SPROG} commit. to add this file permanently" + dotest env-5 "${testcvs} -q commit -m test-pid" \ +"${CVSROOT_DIRNAME}/env/file1,v <-- file1 +initial revision: 1\.1" + + dokeep + # undo commitinfo changes + restore_adm + cd ../.. + rm -fr $TESTDIR/env + modify_repo rm -rf $CVSROOT_DIRNAME/env + ;; + + + + errmsg1) + modify_repo mkdir $CVSROOT_DIRNAME/1dir + mkdir 1 + cd 1 + dotest errmsg1-init-1 "$testcvs -Q co 1dir" + cd 1dir + touch foo + dotest errmsg-init-2 "$testcvs -Q add foo" + if ${testcvs} ci -m added >>${LOGFILE} 2>&1; then + pass 164 + else + fail 164 + fi + cd ../.. + mkdir 2 + cd 2 + if ${testcvs} -q co 1dir >>${LOGFILE}; then + pass 165 + else + fail 165 + fi + chmod a-w 1dir + cd ../1/1dir + rm foo; + if ${testcvs} rm foo >>${LOGFILE} 2>&1; then + pass 166 + else + fail 166 + fi + if ${testcvs} ci -m removed >>${LOGFILE} 2>&1; then + pass 167 + else + fail 167 + fi + + cd ../../2/1dir + # The second case in the local and remote versions of errmsg1-168 + # below happens on Cygwin under Windows, where write privileges + # aren't enforced properly. + if $remote; then + dotest errmsg1-168r "${testcvs} -q update" \ +"${SPROG} update: \`foo' is no longer in the repository +$CPROG update: unable to remove \./foo: Permission denied" \ +"${SPROG} update: \`foo' is no longer in the repository" + else + dotest errmsg1-168 "${testcvs} -q update" \ +"${SPROG} update: \`foo' is no longer in the repository +${SPROG} update: unable to remove foo: Permission denied" \ +"${SPROG} update: \`foo' is no longer in the repository" + fi + + dokeep + cd .. + chmod u+w 1dir + cd .. + rm -r 1 2 + modify_repo rm -rf $CVSROOT_DIRNAME/1dir + ;; + + + + errmsg2) + # More tests of various miscellaneous error handling, + # and cvs add behavior in general. + # See also test basicb-4a, concerning "cvs ci CVS". + # Too many tests to mention test the simple cases of + # adding files and directories. + # Test basicb-2a10 tests cvs -n add. + + # First the usual setup; create a directory first-dir. + mkdir 1; cd 1 + dotest errmsg2-1 "$testcvs -q co -l ." + mkdir first-dir + dotest errmsg2-2 "${testcvs} add first-dir" \ +"Directory ${CVSROOT_DIRNAME}/first-dir added to the repository" + cd first-dir + dotest_fail errmsg2-3 "${testcvs} add CVS" \ +"${CPROG} add: cannot add special file .CVS.; skipping" + touch file1 + # For the most part add returns a failure exitstatus if + # there are any errors, even if the remaining files are + # processed without incident. The "cannot add + # special file" message fits this pattern, at + # least currently. + dotest_fail errmsg2-4 "${testcvs} add CVS file1" \ +"${CPROG} add: cannot add special file .CVS.; skipping +${SPROG} add: scheduling file .file1. for addition +${SPROG} add: use .${SPROG} commit. to add this file permanently" + # I'm not sure these tests completely convey the various strange + # behaviors that CVS had before it specially checked for "." and + # "..". Suffice it to say that these are unlikely to work right + # without a special case. + dotest_fail errmsg2-5 "${testcvs} add ." \ +"${CPROG} add: cannot add special file .\..; skipping" + dotest_fail errmsg2-6 "${testcvs} add .." \ +"${CPROG} add: cannot add special file .\.\..; skipping" + # Make sure that none of the error messages left droppings + # which interfere with normal operation. + dotest errmsg2-7 "${testcvs} -q ci -m add-file1" \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +initial revision: 1\.1" + mkdir sdir + cd .. + dotest errmsg2-8 "${testcvs} add first-dir/sdir" \ +"Directory ${CVSROOT_DIRNAME}/first-dir/sdir added to the repository" + # while we're here... check commit with no CVS directory + dotest_fail errmsg2-8a "${testcvs} -q ci first-dir nonexistant" \ +"${CPROG} commit: nothing known about .nonexistant' +${CPROG} \[commit aborted\]: correct above errors first!" + dotest_fail errmsg2-8b "$testcvs -q ci nonexistant first-dir" \ +"$CPROG commit: nothing known about .nonexistant' +$CPROG \[commit aborted\]: correct above errors first!" + dotest errmsg2-8c "$testcvs -q ci first-dir" + + cd first-dir + + touch file10 + mkdir sdir10 + dotest errmsg2-10 "${testcvs} add file10 sdir10" \ +"${SPROG} add: scheduling file .file10. for addition +Directory ${CVSROOT_DIRNAME}/first-dir/sdir10 added to the repository +${SPROG} add: use .${SPROG} commit. to add this file permanently" + dotest errmsg2-11 "${testcvs} -q ci -m add-file10" \ +"$CVSROOT_DIRNAME/first-dir/file10,v <-- file10 +initial revision: 1\.1" + # Try to see that there are no droppings left by + # any of the previous tests. + dotest errmsg2-12 "${testcvs} -q update" "" + + # Now test adding files with '/' in the name, both one level + # down and more than one level down. + cd .. + mkdir first-dir/sdir10/ssdir + dotest errmsg2-13 "${testcvs} add first-dir/sdir10/ssdir" \ +"Directory ${CVSROOT_DIRNAME}/first-dir/sdir10/ssdir added to the repository" + + touch first-dir/sdir10/ssdir/ssfile + dotest errmsg2-14 \ + "${testcvs} add first-dir/sdir10/ssdir/ssfile" \ +"${SPROG} add: scheduling file .first-dir/sdir10/ssdir/ssfile. for addition +${SPROG} add: use .${SPROG} commit. to add this file permanently" + touch first-dir/file15 + dotest errmsg2-15 "${testcvs} add first-dir/file15" \ +"${SPROG} add: scheduling file .first-dir/file15. for addition +${SPROG} add: use .${SPROG} commit. to add this file permanently" + + # Now the case where we try to give it a directory which is not + # under CVS control. + mkdir bogus-dir + touch bogus-dir/file16 + # FIXCVS: The first message, from local CVS, is nice. The second one + # is not nice; would be good to fix remote CVS to give a clearer + # message (e.g. the one from local CVS). But at least it is an + # error message. + dotest_fail errmsg2-16 "${testcvs} add bogus-dir/file16" \ +"${SPROG} add: in directory \`bogus-dir': +${SPROG} \[add aborted\]: there is no version here; do .${SPROG} checkout. first" \ +"${CPROG} add: cannot open CVS/Entries for reading: No such file or directory +${CPROG} \[add aborted\]: no repository" + rm -r bogus-dir + + # One error condition we don't test for is trying to add a file + # or directory which already is there. + + dotest errmsg2-17 "${testcvs} -q ci -m checkin" \ +"$CVSROOT_DIRNAME/first-dir/file15,v <-- first-dir/file15 +initial revision: 1\.1 +$CVSROOT_DIRNAME/first-dir/sdir10/ssdir/ssfile,v <-- first-dir/sdir10/ssdir/ssfile +initial revision: 1\.1" + dotest errmsg2-18 "${testcvs} -Q tag test" '' + + # trying to import the repository + + if $remote; then :; else + cd ${CVSROOT_DIRNAME} + dotest_fail errmsg2-20 "${testcvs} import -mtest . A B" \ +"${SPROG} \[import aborted\]: attempt to import the repository" + dotest_fail errmsg2-21 "${testcvs} import -mtest first-dir A B" \ +"${SPROG} \[import aborted\]: attempt to import the repository" + fi + + dokeep + cd .. + rm -r 1 + modify_repo rm -rf $CVSROOT_DIRNAME/first-dir + ;; + + + + errmsg3) + # Test the *PANIC* message caused by missing administration files + mkdir errmsg3 + cd errmsg3 + mkdir CVS + dotest_fail errmsg3-1 "${testcvs} -q up" \ +"${CPROG} update: in directory \`.': +${CPROG} update: CVS directory found without administrative files\. +${CPROG} update: Use CVS to create the CVS directory, or rename the +${CPROG} update: directory if it is intended to store something +${CPROG} update: besides CVS administrative files\. +${CPROG} \[update aborted\]: \*PANIC\* administration files missing!" + + dokeep + cd .. + rm -r errmsg3 + ;; + + + + close-stdout) + # Ensure that cvs update -p FILE > /dev/full fails + # Perform this test IFF /dev/full is a writable character device. + if test -w /dev/full && test -c /dev/full; then + mkdir close-stdout + cd close-stdout + echo a > file + dotest close-stdout-1 "$testcvs -Q import -m. closeout X Y" '' + dotest close-stdout-2 "$testcvs -Q co closeout" '' + # Match either a bare `write error' or + # `write error: No space left on device', + # since closeout.c can produce both. + dotest_fail close-stdout-3 \ + "${testcvs} -Q update -p closeout/file > /dev/full" \ + "${CPROG} \[update aborted\]: write error.*" + + dokeep + cd .. + rm -r close-stdout + modify_repo rm -rf $CVSROOT_DIRNAME/closeout + else + skip close-stdout '/dev/full is not available' + fi + ;; + + + + debug-log-nonfatal) + # Once upon a time, failure to create the debug log could be fatal. + if $remote; then :; else + remoteonly debug-log-nonfatal + continue + fi + + mkdir $TESTDIR/unwritable + chmod a-w $TESTDIR/unwritable + if test -n "$CVS_CLIENT_LOG"; then + save_CVS_CLIENT_LOG=$CVS_CLIENT_LOG + fi + CVS_CLIENT_LOG=$TESTDIR/unwritable/cvsclientlog + export CVS_CLIENT_LOG + + dotest debug-log-nonfatal-1 \ +"$testcvs -Q co -p CVSROOT/config >/dev/null" \ +"$CPROG checkout: opening to-server logfile $TESTDIR/unwritable/cvsclientlog.in: Permission denied +$CPROG checkout: opening from-server logfile $TESTDIR/unwritable/cvsclientlog.out: Permission denied" + + dokeep + rm -rf $TESTDIR/unwritable + unset CVS_CLIENT_LOG + if test -n "$save_CVS_CLIENT_LOG"; then + CVS_CLIENT_LOG=$save_CVS_CLIENT_LOG + fi + ;; + + + + adderrmsg) + # Test some of the error messages the 'add' command can return and + # their reactions to '-q'. + + # First the usual setup; create a directory first-dir. + mkdir 1; cd 1 + dotest adderrmsg-init1 "${testcvs} -q co -l ." '' + mkdir adderrmsg-dir + dotest adderrmsg-init2 "${testcvs} add adderrmsg-dir" \ +"Directory ${CVSROOT_DIRNAME}/adderrmsg-dir added to the repository" + cd adderrmsg-dir + + # try to add the admin dir + dotest_fail adderrmsg-1 "${testcvs} add CVS" \ +"${CPROG} add: cannot add special file .CVS.; skipping" + # might not want to see this message when you 'cvs add *' + dotest_fail adderrmsg-2 "${testcvs} -q add CVS" "" + + # to test some other messages + touch file1 + dotest adderrmsg-3 "${testcvs} add file1" \ +"${SPROG} add: scheduling file .file1. for addition +${SPROG} add: use .${SPROG} commit. to add this file permanently" + + # add it twice + dotest_fail adderrmsg-4 "${testcvs} add file1" \ +"${SPROG} add: \`file1' has already been entered" + dotest_fail adderrmsg-5 "${testcvs} -q add file1" "" + + dotest adderrmsg-6 "${testcvs} -q ci -madd" \ +"$CVSROOT_DIRNAME/adderrmsg-dir/file1,v <-- file1 +initial revision: 1\.1" + + # file in Entries & repository + dotest_fail adderrmsg-7 "${testcvs} add file1" \ +"${SPROG} add: \`file1' already exists, with version number 1\.1" + dotest_fail adderrmsg-8 "${testcvs} -q add file1" "" + + # clean up + dokeep + cd ../.. + rm -r 1 + modify_repo rm -rf $CVSROOT_DIRNAME/adderrmsg-dir + ;; + + + + opterrmsg) + # Test some option parsing error messages + + # No init is necessary since these error messages are printed b4 + # CVS looks for a sandbox or repository + + # -z used to accept non-numeric arguments. This bit someone who + # attempted `cvs -z -n up' when the -n was read as the argument to + # -z. + dotest_fail opterrmsg-1 "${testcvs} -z -n up" \ +"${CPROG}: gzip compression level must be between 0 and 9" + + # Some general -z checks + dotest_fail opterrmsg-2 "${testcvs} -z -1 up" \ +"${CPROG}: gzip compression level must be between 0 and 9" + dotest_fail opterrmsg-3 "${testcvs} -z10 up" \ +"${CPROG}: gzip compression level must be between 0 and 9" + ;; + + + + devcom) + modify_repo mkdir $CVSROOT_DIRNAME/first-dir + mkdir 1 + cd 1 + dotest devcom-1 "$testcvs -q co first-dir" + + cd first-dir + echo abb >abb + dotest devcom-2 "$testcvs add abb" \ +"$SPROG add: scheduling file \`abb' for addition +$SPROG add: use \`$SPROG commit' to add this file permanently" + + dotest devcom-3 "$testcvs -q ci -m added" \ +"$CVSROOT_DIRNAME/first-dir/abb,v <-- abb +initial revision: 1\.1" + + dotest_fail devcom-4 "$testcvs watch" "Usage$DOTSTAR" + + dotest devcom-5 "$testcvs watch on" + + echo abc >abc + dotest devcom-6 "$testcvs add abc" \ +"$SPROG add: scheduling file \`abc' for addition +$SPROG add: use \`$SPROG commit' to add this file permanently" + + dotest devcom-7 "$testcvs -q ci -m added" \ +"$CVSROOT_DIRNAME/first-dir/abc,v <-- abc +initial revision: 1\.1" + + cd ../.. + mkdir 2 + cd 2 + + dotest devcom-8 "$testcvs -q co first-dir" \ +"U first-dir/abb +U first-dir/abc" + + cd first-dir + dotest_fail devcom-9 "test -w abb" + dotest_fail devcom-9b "test -w abc" + + dotest devcom-10 "$testcvs editors" + dotest devcom-11 "$testcvs edit abb" + + # Here we test for the traditional ISO C ctime() date format. + # We assume the C locale; I guess that works provided we set + # LC_ALL at the start of this script but whether these + # strings should vary based on locale does not strike me as + # self-evident. + dotest devcom-12 "$testcvs editors" \ +"abb ${username} [SMTWF][uoehra][neduit] [JFAMSOND][aepuco][nbrylgptvc] [0-9 ][0-9] [0-9:]* [0-9][0-9][0-9][0-9] -0000 [-a-zA-Z_.0-9]* ${TESTDIR}/2/first-dir" + + echo aaaa >>abb + dotest devcom-13 "$testcvs ci -m modify abb" \ +"${CVSROOT_DIRNAME}/first-dir/abb,v <-- abb +new revision: 1\.2; previous revision: 1\.1" + + # Unedit of a file not being edited should be a noop. + dotest devcom-14 "$testcvs unedit abb" '' + + dotest devcom-15 "$testcvs editors" "" + + dotest_fail devcom-16 "test -w abb" + + dotest devcom-17 "$testcvs edit abc" + + # Unedit of an unmodified file. + dotest devcom-18 "$testcvs unedit abc" + dotest devcom-19 "$testcvs edit abc" + + echo changedabc >abc + # Try to unedit a modified file; cvs should ask for confirmation + dotest devcom-20 "echo no | $testcvs unedit abc" \ +"abc has been modified; revert changes? " + + dotest devcom-21 "echo changedabc | cmp - abc" + + # OK, now confirm the unedit + dotest devcom-22 "echo yes |$testcvs unedit abc" \ +"abc has been modified; revert changes? " + + dotest devcom-23 "echo abc |cmp - abc" + + dotest devcom-24 "$testcvs watchers" '' + + # FIXME: This probably should be an error message instead + # of silently succeeding and printing nothing. + dotest devcom-a-nonexist "$testcvs watchers nonexist" '' + + dotest devcom-a1 "$testcvs watch add" '' + dotest devcom-a2 "$testcvs watchers" \ +"abb $username edit unedit commit +abc $username edit unedit commit" + dotest devcom-a3 "$testcvs watch remove -a unedit abb" '' + dotest devcom-a4 "$testcvs watchers abb" \ +"abb $username edit commit" + + # Check tagging and checking out while we have a CVS + # directory in the repository. + dotest devcom-t0 "${testcvs} -q tag tag" \ +'T abb +T abc' + cd ../.. + mkdir 3 + cd 3 + + # Test commented out because the bug it tests for is not fixed + # The error is: + # cvs watchers: cannot open CVS/Entries for reading: No such file or directory + # cvs: ../../work/ccvs/src/fileattr.c:75: fileattr_read: Assertion `fileattr_stored_repos != ((void *)0)' failed. +: dotest devcom-t-nonexist "${testcvs} watchers nonexist" fixme + + dotest devcom-t1 "${testcvs} -q co -rtag first-dir/abb" \ +'U first-dir/abb' + cd .. + # Since first-dir/abb is readonly, use -f. + rm -rf 3 + + # Test checking out the directory rather than the file. + mkdir 3 + cd 3 + dotest devcom-t2 "${testcvs} -q co -rtag first-dir" \ +'U first-dir/abb +U first-dir/abc' + cd .. + # Since the files are readonly, use -f. + rm -rf 3 + + # Now do it again, after removing the val-tags file created + # by devcom-t1 to force CVS to search the repository + # containing CVS directories. + rm ${CVSROOT_DIRNAME}/CVSROOT/val-tags + mkdir 3 + cd 3 + dotest devcom-t3 "${testcvs} -q co -rtag first-dir" \ +'U first-dir/abb +U first-dir/abc' + cd .. + # Since the files are readonly, use -f. + rm -rf 3 + + # Now remove all the file attributes + cd 2/first-dir + dotest devcom-b0 "${testcvs} watch off" '' + dotest devcom-b1 "${testcvs} watch remove" '' + # Test that CVS 1.6 and earlier can handle the repository. + dotest_fail devcom-b2 "test -d ${CVSROOT_DIRNAME}/first-dir/CVS" + + # Now test watching just some, not all, files. + dotest devcom-some0 "${testcvs} watch on abc" '' + cd ../.. + mkdir 3 + cd 3 + dotest devcom-some1 "${testcvs} -q co first-dir" 'U first-dir/abb +U first-dir/abc' + dotest devcom-some2 "test -w first-dir/abb" '' + dotest_fail devcom-some3 "test -w first-dir/abc" '' + + dokeep + cd .. + # Use -f because of the readonly files. + rm -rf 1 2 3 + modify_repo rm -rf $CVSROOT_DIRNAME/first-dir + ;; + + + + devcom2) + # More watch tests, most notably setting watches on + # files in various different states. + modify_repo mkdir $CVSROOT_DIRNAME/first-dir + mkdir 1 + cd 1 + dotest devcom2-1 "${testcvs} -q co first-dir" '' + cd first-dir + + # This should probably be an error; setting a watch on a totally + # unknown file is more likely to be a typo than intentional. + # But that isn't the currently implemented behavior. + dotest devcom2-2 "${testcvs} watch on w1" '' + + touch w1 w2 w3 nw1 + dotest devcom2-3 "${testcvs} add w1 w2 w3 nw1" "${DOTSTAR}" + # Letting the user set the watch here probably can be considered + # a feature--although it leads to a few potentially strange + # consequences like one user can set the watch and another actually + # adds the file. + dotest devcom2-4 "${testcvs} watch on w2" '' + dotest devcom2-5 "${testcvs} -Q ci -m add-them" + + # Note that this test differs in a subtle way from devcom-some0; + # in devcom-some0 the watch is creating a new fileattr file, and + # here we are modifying an existing one. + dotest devcom2-6 "${testcvs} watch on w3" '' + + # Now test that all the watches got set on the correct files + # FIXME: CVS should have a way to report whether watches are + # set, I think. The "check it out and see if it read-only" is + # sort of OK, but is complicated by CVSREAD and doesn't help + # if the file is added and not yet committed or some such. + # Probably "cvs status" should report "watch: on" if watch is on + # (and nothing if watch is off, so existing behavior is preserved). + cd ../.. + mkdir 2 + cd 2 + dotest devcom2-7 "${testcvs} -q co first-dir" 'U first-dir/nw1 +U first-dir/w1 +U first-dir/w2 +U first-dir/w3' + dotest devcom2-8 "test -w first-dir/nw1" '' + dotest_fail devcom2-9 "test -w first-dir/w1" '' + dotest_fail devcom2-10 "test -w first-dir/w2" '' + dotest_fail devcom2-11 "test -w first-dir/w3" '' + + cd first-dir + # OK, now we want to try files in various states with cvs edit. + dotest_fail devcom2-12 "$testcvs edit w4" \ +"${CPROG} edit: no such file w4; ignored" + # Try the same thing with a per-directory watch set. + dotest devcom2-13 "${testcvs} watch on" '' + dotest_fail devcom2-14 "$testcvs edit w5" \ +"${CPROG} edit: no such file w5; ignored" + dotest devcom2-15 "${testcvs} editors" '' + dotest devcom2-16 "${testcvs} editors w4" '' + # Make sure there are no droppings lying around + dotest devcom2-17 "cat ${CVSROOT_DIRNAME}/first-dir/CVS/fileattr" \ +"Fw1 _watched= +Fw2 _watched= +Fw3 _watched= +Fnw1 _watched= +D _watched=" + cd .. + + # Do a little error testing + dotest devcom2-18 "${testcvs} -q co -d first+dir first-dir" \ +"U first${PLUS}dir/nw1 +U first${PLUS}dir/w1 +U first${PLUS}dir/w2 +U first${PLUS}dir/w3" + cd first+dir + dotest_fail devcom2-19 "${testcvs} edit" \ +"${CPROG} \[edit aborted\]: current directory (${TESTDIR}/2/first${PLUS}dir) contains an invalid character (${PLUS},>;=\\\\t\\\\n)" + + # Make sure there are no droppings lying around + dotest devcom2-20 "cat ${CVSROOT_DIRNAME}/first-dir/CVS/fileattr" \ +"Fw1 _watched= +Fw2 _watched= +Fw3 _watched= +Fnw1 _watched= +D _watched=" + + dokeep + cd ../.. + # Use -f because of the readonly files. + rm -rf 1 2 + modify_repo rm -rf $CVSROOT_DIRNAME/first-dir + ;; + + + + devcom3) + # More watch tests, most notably handling of features designed + # for future expansion. + modify_repo mkdir $CVSROOT_DIRNAME/first-dir + mkdir 1 + cd 1 + + # Set up logging via the postwatch script hook. See the `info' test + # for a list of tests where other script hooks are tested. + dotest devcom3-init-1 "$testcvs -Q co CVSROOT" + cd CVSROOT + echo "ALL $TESTDIR/1/loggit %r %p %c" >>postwatch + dotest devcom3-init-2 "$testcvs -Q ci -mlog-watch" + cd .. # 1 + + cat >loggit <<EOF +#!$TESTSHELL +echo \${1+"\$@"} >>$TESTDIR/1/watch-log +EOF + # #^@&!^@ Cygwin. + if test -n "$remotehost"; then + $CVS_RSH $remotehost "chmod +x $TESTDIR/1/loggit" + else + chmod +x loggit + fi + + + + dotest devcom3-1 "$testcvs -q co first-dir" + cd first-dir + + touch w1 w2 + dotest devcom3-2 "${testcvs} add w1 w2" "${DOTSTAR}" + dotest devcom3-3 "${testcvs} watch on w1 w2" '' + dotest devcom3-4 "${testcvs} -Q ci -m add-them" + + # OK, since we are about to delve into CVS's internals, make + # sure that we seem to be correct about how they work. + dotest devcom3-5 "cat ${CVSROOT_DIRNAME}/first-dir/CVS/fileattr" \ +"Fw1 _watched= +Fw2 _watched=" + # Now write a few more lines, just as if we were a newer version + # of CVS implementing some new feature. + cat <<'EOF' >>${CVSROOT_DIRNAME}/first-dir/CVS/fileattr +Enew line here +G@#$^!@#=& +EOF + # Now get CVS to write to the fileattr file.... + dotest devcom3-6 "${testcvs} watch off w1" '' + # ...and make sure that it hasn't clobbered our new lines. + # Note that writing these lines in another order would be OK + # too. + dotest devcom3-7 "cat ${CVSROOT_DIRNAME}/first-dir/CVS/fileattr" \ +"Fw2 _watched= +G@#..!@#=& +Enew line here" + + # See what CVS does when a file name is duplicated. The + # behavior of all versions of CVS since file attributes were + # implemented is that it nukes the duplications. This seems + # reasonable enough, although it means it isn't clear how + # useful duplicates would be for purposes of future + # expansion. But in the interests of keeping behaviors + # predictable, might as well test for it, I guess. + echo 'Fw2 duplicate=' >>${CVSROOT_DIRNAME}/first-dir/CVS/fileattr + dotest devcom3-8 "${testcvs} watch on w1" '' + dotest devcom3-9 "cat ${CVSROOT_DIRNAME}/first-dir/CVS/fileattr" \ +"Fw2 _watched= +Fw1 _watched= +Enew line here +G@#..!@#=&" + + # Now test disconnected "cvs edit" and the format of the + # CVS/Notify file. + if $remote; then + CVS_SERVER_save=$CVS_SERVER + CVS_SERVER=$TESTDIR/cvs-none; export CVS_SERVER + + # The ${DOTSTAR} below matches the exact CVS server error message, + # which in :fork: mode is: + # "$SPROG \[edit aborted\]: cannot exec $TESTDIR/cvs-none: ${DOTSTAR}", + # but which is: + # "bash2: line 1: $TESTDIR/cvs-none: No such file or directory" + # when testing across an :ext:/ssh link to my Linux 2.4 box. + # + # I can't even test for the second part of the error message, + # from the client, which varies more consistently, usually either + # "end of file from server" (if the process doing the exec exits + # before the parent gets around to sending data to it) or + # "received broken pipe signal" (if it is the other way around), + # since HP-UX fails to output it. + dotest_fail devcom3-9ar "$testcvs edit w1 2>/dev/null" + dotest devcom3-9br "test -w w1" + dotest devcom3-9cr "cat CVS/Notify" \ +"Ew1 [SMTWF][uoehra][neduit] [JFAMSOND][aepuco][nbrylgptvc] [0-9 ][0-9] [0-9:]* [0-9][0-9][0-9][0-9] -0000 [-a-zA-Z_.0-9]* ${TESTDIR}/1/first-dir EUC" + CVS_SERVER=${CVS_SERVER_save}; export CVS_SERVER + if $proxy; then + dotest_fail devcom3-9dp "$testcvs -q update" \ +"This CVS server does not support disconnected \`cvs edit'\. For now, remove all \`CVS/Notify' files in your workspace and try your command again\." + dotest devcom3-9ep "test -f CVS/Notify" + rm CVS/Notify + dotest devcom3-9hp "$testcvs watchers w1" + else + dotest devcom3-9dr "$testcvs -q update" + dotest_fail devcom3-9er "test -f CVS/Notify" + dotest devcom3-9fr "$testcvs watchers w1" \ +"w1 $username tedit tunedit tcommit" + fi + dotest devcom3-9gr "$testcvs unedit w1" + dotest devcom3-9hr "$testcvs watchers w1" + fi + + cd ../.. + # OK, now change the tab to a space, and see that CVS gives + # a reasonable error (this is database corruption but CVS should + # not lose its mind). + sed -e 's/Fw2 /Fw2 /' <$CVSROOT_DIRNAME/first-dir/CVS/fileattr \ + >$CVSROOT_DIRNAME/first-dir/CVS/fileattr.new + modify_repo mv $CVSROOT_DIRNAME/first-dir/CVS/fileattr.new \ + $CVSROOT_DIRNAME/first-dir/CVS/fileattr + mkdir 2; cd 2 + dotest_fail devcom3-10 "${testcvs} -Q co ." \ +"${SPROG} \[checkout aborted\]: file attribute database corruption: tab missing in ${CVSROOT_DIRNAME}/first-dir/CVS/fileattr" + + notifyworks=false + if $remote; then + if $proxy; then :; else + notifyworks=: + fi + fi + if $notifyworks; then + dotest devcom3-postwatch-examine-1r "cat $TESTDIR/1/watch-log" \ +"$CVSROOT_DIRNAME first-dir watch +$CVSROOT_DIRNAME first-dir watch +$CVSROOT_DIRNAME first-dir watch +$CVSROOT_DIRNAME first-dir update +$CVSROOT_DIRNAME first-dir server" + else + dotest devcom3-postwatch-examine-1 "cat $TESTDIR/1/watch-log" \ +"$CVSROOT_DIRNAME first-dir watch +$CVSROOT_DIRNAME first-dir watch +$CVSROOT_DIRNAME first-dir watch" + fi + + dokeep + restore_adm + cd .. + # Use -f because of the readonly files. + rm -rf 1 2 + modify_repo rm -rf $CVSROOT_DIRNAME/first-dir + ;; + + + + watch4) + # More watch tests, including adding directories. + mkdir 1; cd 1 + dotest watch4-0a "${testcvs} -q co -l ." '' + mkdir first-dir + dotest watch4-0b "${testcvs} add first-dir" \ +"Directory ${CVSROOT_DIRNAME}/first-dir added to the repository" + + cd first-dir + dotest watch4-1 "${testcvs} watch on" '' + # This is just like the 173 test + touch file1 + dotest watch4-2 "$testcvs add file1" \ +"$SPROG add: scheduling file .file1. for addition +$SPROG add: use .$SPROG commit. to add this file permanently" + dotest watch4-3 "$testcvs -q ci -m add" \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +initial revision: 1\.1" + # Now test the analogous behavior for directories. + mkdir subdir + dotest watch4-4 "${testcvs} add subdir" \ +"Directory ${CVSROOT_DIRNAME}/first-dir/subdir added to the repository" + cd subdir + touch sfile + dotest watch4-5 "${testcvs} add sfile" \ +"${SPROG} add: scheduling file .sfile. for addition +${SPROG} add: use .${SPROG} commit. to add this file permanently" + dotest watch4-6 "${testcvs} -q ci -m add" \ +"$CVSROOT_DIRNAME/first-dir/subdir/sfile,v <-- sfile +initial revision: 1\.1" + cd ../../.. + mkdir 2; cd 2 + dotest watch4-7 "${testcvs} -q co first-dir" "U first-dir/file1 +U first-dir/subdir/sfile" + dotest_fail watch4-8 "test -w first-dir/file1" '' + dotest_fail watch4-9 "test -w first-dir/subdir/sfile" '' + cd first-dir + dotest watch4-10 "${testcvs} edit file1" '' + echo 'edited in 2' >file1 + cd ../.. + + cd 1/first-dir + + # NOTE: I'm leaving in '' as acceptable + # to maintain partial compatibility with CVS versions + # prior to the edit check patch. + editorsLineRE="file1 $username [SMTWF][uoehra][neduit] [JFAMSOND][aepuco][nbrylgptvc] [0-9 ][0-9] [0-9:]* [0-9][0-9][0-9][0-9] -0000 $hostname $TESTDIR/2/first-dir" + dotest watch4-11 "$testcvs edit file1" "$editorsLineRE" + + echo 'edited in 1' >file1 + dotest watch4-12 "${testcvs} -q ci -m edit-in-1" \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +new revision: 1\.2; previous revision: 1\.1" + cd ../.. + cd 2/first-dir + dotest watch4-13 "${testcvs} -q update" \ +"RCS file: ${CVSROOT_DIRNAME}/first-dir/file1,v +retrieving revision 1\.1 +retrieving revision 1\.2 +Merging differences between 1\.1 and 1\.2 into file1 +rcsmerge: warning: conflicts during merge +${SPROG} update: conflicts found in file1 +C file1" + if (echo yes | ${testcvs} unedit file1) >>${LOGFILE}; then + pass watch4-14 + else + fail watch4-15 + fi + # This could plausibly be defined to either go back to the revision + # which was cvs edit'd (the status quo), or back to revision 1.2 + # (that is, the merge could update CVS/Base/file1). We pick the + # former because it is easier to implement, not because we have + # thought much about which is better. + dotest watch4-16 "cat file1" '' + # Make sure CVS really thinks we are at 1.1. + dotest watch4-17 "${testcvs} -q update" "U file1" + dotest watch4-18 "cat file1" "edited in 1" + cd ../.. + + # As a sanity check, make sure we are in the right place. + dotest watch4-cleanup-1 "test -d 1" + dotest watch4-cleanup-1 "test -d 2" + + dokeep + # Specify -f because of the readonly files. + rm -rf 1 2 + modify_repo rm -rf $CVSROOT_DIRNAME/first-dir + ;; + + + + watch5) + # This test was designed to catch a problem in server + # mode where an 'cvs edit'd file disappeared from the + # CVS/Base directory when 'cvs status' or 'cvs update' + # was called on the file after the file was touched. + # + # This test is still here to prevent the bug from + # being reintroduced. + # + # The rationale for having CVS/Base stay around is that + # CVS/Base should be there if "cvs edit" has been run (this + # may be helpful as a "cvs editors" analogue, it is + # client-side and based on working directory not username; + # but more importantly, it isn't clear why a "cvs status" + # would act like an unedit, and even if it does, it would + # need to make the file read-only again). + + mkdir watch5; cd watch5 + dotest watch5-0a "${testcvs} -q co -l ." '' + mkdir first-dir + dotest watch5-0b "${testcvs} add first-dir" \ +"Directory ${CVSROOT_DIRNAME}/first-dir added to the repository" + + cd first-dir + dotest watch5-1 "${testcvs} watch on" '' + # This is just like the 173 test + touch file1 + dotest watch5-2 "${testcvs} add file1" \ +"${SPROG} add: scheduling file .file1. for addition +${SPROG} add: use .${SPROG} commit. to add this file permanently" + dotest watch5-3 "${testcvs} -q ci -m add" \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +initial revision: 1\.1" + dotest watch5-4 "${testcvs} edit file1" '' + dotest watch5-5 "test -f CVS/Base/file1" '' + if ${testcvs} status file1 >>${LOGFILE} 2>&1; then + pass watch5-6 + else + fail watch5-6 + fi + dotest watch5-7 "test -f CVS/Base/file1" '' + + # Here's where the file used to dissappear + touch file1 + if ${testcvs} status file1 >>${LOGFILE} 2>&1; then + pass watch5-8 + else + fail watch5-8 + fi + dotest watch5-10 "test -f CVS/Base/file1" '' + + # Make sure update won't remove the file either + touch file1 + dotest watch5-11 "${testcvs} -q up" '' + dotest watch5-12 "test -f CVS/Base/file1" '' + + dokeep + cd ../.. + rm -r watch5 + modify_repo rm -rf $CVSROOT_DIRNAME/first-dir + ;; + + + + watch6-0) + + # Make sure that default attributes are being set properly. + # Specifying a directory has, it seems, never worked, + # and 1.12.10 broke it completely. + mkdir watch6-0; cd watch6-0 + + dotest watch6-0-setup-1 "$testcvs -Q co -ldtop ." + cd top + mkdir watch6-0 + dotest watch6-0-setup-2 "$testcvs -Q add watch6-0" + cd watch6-0 + dotest watch6-0-1 "$testcvs watch add" + dotest watch6-0-2 "grep -qE '^D' $CVSROOT_DIRNAME/watch6-0/CVS/fileattr" + dotest watch6-0-3 "$testcvs watch remove" + dotest_fail watch6-0-4 "grep -qE '^D' $CVSROOT_DIRNAME/watch6-0/CVS/fileattr 2>/dev/null" + + dotest watch6-0-5 "$testcvs watch add ." + dotest watch6-0-6 "grep -qE '^D' $CVSROOT_DIRNAME/watch6-0/CVS/fileattr" + dotest watch6-0-7 "$testcvs watch remove ." + dotest_fail watch6-0-8 "grep -qE '^D' $CVSROOT_DIRNAME/watch6-0/CVS/fileattr 2>/dev/null" + + # OK, basic add/remove work. Now, make sure it works with named directories + mkdir dir1 + mkdir dir2 + mkdir dir3 + echo afile>afile + $testcvs -Q add afile dir1 dir2 dir3 + $testcvs -Q ci -m "Adding test files" + + # Current directory should not be watched, but there should be a watch on the file, + # and on dir1 & dir2, but not on dir3. + dotest watch6-0-9 "$testcvs -Q watch add afile dir1 dir2" + dotest_fail watch6-0-10 "grep -qE '^D' $CVSROOT_DIRNAME/watch6-0/CVS/fileattr 2>/dev/null" + dotest watch6-0-11 "grep -qE '^Fafile' $CVSROOT_DIRNAME/watch6-0/CVS/fileattr" + dotest watch6-0-12 "grep -qE '^D' $CVSROOT_DIRNAME/watch6-0/dir1/CVS/fileattr" + dotest watch6-0-13 "grep -qE '^D' $CVSROOT_DIRNAME/watch6-0/dir2/CVS/fileattr" + dotest_fail watch6-0-12 "grep -qE '^D' $CVSROOT_DIRNAME/watch6-0/dir3/CVS/fileattr 2>/dev/null" + + dokeep + cd ../../.. + rm -rf watch6-0 + modify_repo rm -rf $CVSROOT_DIRNAME/watch6-0 + ;; + + + + watch6) + # Check that `cvs watch on' does not reset the fileattr file. + mkdir watch6; cd watch6 + + dotest watch6-setup-1 "$testcvs -Q co -ldtop ." + cd top + mkdir watch6 + dotest watch6-setup-2 "$testcvs -Q add watch6" + + # I don't recall why I had these next 3 lines. + cd .. + dotest watch6-setup-3 "$testcvs -Q co watch6" + cd watch6 + + mkdir subdir + dotest watch6-setup-4 "$testcvs -Q add subdir" + cd subdir + + # START watch add/remove sequence + dotest watch6-1 "$testcvs -Q watch add" + dotest watch6-2 \ +"grep '_watchers' $CVSROOT_DIRNAME/watch6/subdir/CVS/fileattr >/dev/null" + + dotest watch6-3 "$testcvs watch on" + dotest watch6-4 \ +"grep '_watchers' $CVSROOT_DIRNAME/watch6/subdir/CVS/fileattr >/dev/null" + dotest watch6-5 \ +"grep '_watched' $CVSROOT_DIRNAME/watch6/subdir/CVS/fileattr >/dev/null" + + dotest watch6-6 "$testcvs watch off" + dotest watch6-7 \ +"grep '_watchers' $CVSROOT_DIRNAME/watch6/subdir/CVS/fileattr >/dev/null" + dotest_fail watch6-8 \ +"grep '_watched' $CVSROOT_DIRNAME/watch6/subdir/CVS/fileattr >/dev/null" + + dotest watch6-9 "$testcvs watch remove" + dotest_fail watch6-10 \ +"test -d $CVSROOT_DIRNAME/test-directory/subdir/CVS" + dotest_fail watch6-11 \ +"test -f $CVSROOT_DIRNAME/test-directory/subdir/CVS/fileattr" + # END watch add/remove sequence + + echo Hi there >afile + dotest watch6-12 "$testcvs -Q add afile" + dotest watch6-13 "$testcvs ci -m 'A file' afile" \ +"$CVSROOT_DIRNAME/watch6/subdir/afile,v <-- afile +initial revision: 1.1" + + # START watch add/remove sequence + dotest watch6-14 "$testcvs -Q watch add" + dotest watch6-15 \ +"grep '_watchers' $CVSROOT_DIRNAME/watch6/subdir/CVS/fileattr >/dev/null" + + dotest watch6-16 "$testcvs watch on" + dotest watch6-17 \ +"grep '_watchers' $CVSROOT_DIRNAME/watch6/subdir/CVS/fileattr >/dev/null" + dotest watch6-18 \ +"grep '_watched' $CVSROOT_DIRNAME/watch6/subdir/CVS/fileattr >/dev/null" + + dotest watch6-19 "$testcvs watch off" + dotest watch6-20 \ +"grep '_watchers' $CVSROOT_DIRNAME/watch6/subdir/CVS/fileattr >/dev/null" + dotest_fail watch6-21 \ +"grep '_watched' $CVSROOT_DIRNAME/watch6/subdir/CVS/fileattr >/dev/null" + + dotest watch6-22 "$testcvs watch remove" + dotest_fail watch6-23 \ +"test -d $CVSROOT_DIRNAME/test-directory/subdir/CVS" + dotest_fail watch6-24 \ +"test -f $CVSROOT_DIRNAME/test-directory/subdir/CVS/fileattr" + # END watch add/remove sequence + + if $keep; then + echo Keeping $TESTDIR and exiting due to --keep + exit 0 + fi + cd ../../.. + rm -r watch6 + modify_repo rm -rf $CVSROOT_DIRNAME/watch6 + ;; + + + + edit-check) + # This tests the edit -c/-f and related features. + + mkdir edit-check; cd edit-check + dotest edit-check-0a "$testcvs -q co -l ." + mkdir first-dir + dotest edit-check-0b "$testcvs add first-dir" \ +"Directory $CVSROOT_DIRNAME/first-dir added to the repository" + + cd first-dir + dotest edit-check-1 "$testcvs watch on" + + echo foo > file1 + dotest edit-check-2a "$testcvs add -minitial file1" \ +"$SPROG [a-z]*: scheduling file .file1. for addition +$SPROG [a-z]*: use .$SPROG commit. to add this file permanently" + + dotest edit-check-2b "$testcvs commit -m 'c1' file1" \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +initial revision: 1\.1" + + editorsLineRE="file1 $username [SMTWF][uoehra][neduit] [JFAMSOND][aepuco][nbrylgptvc] [0-9 ][0-9] [0-9:]* [0-9][0-9][0-9][0-9] -0000 $hostname $TESTDIR/edit-check/first-dir" + + R_editorsLineRE="first-dir/file1 $username [SMTWF][uoehra][neduit] [JFAMSOND][aepuco][nbrylgptvc] [0-9 ][0-9] [0-9:]* [0-9][0-9][0-9][0-9] -0000 $hostname $TESTDIR/edit-check" + F3_editorsLineRE="second-dir/file3 $username [SMTWF][uoehra][neduit] [JFAMSOND][aepuco][nbrylgptvc] [0-9 ][0-9] [0-9:]* [0-9][0-9][0-9][0-9] -0000 $hostname $TESTDIR/edit-check/first-dir" + + A_editorsLineRE="file1 [-a-zA-Z0-9_]* [SMTWF][uoehra][neduit] [JFAMSOND][aepuco][nbrylgptvc] [0-9 ][0-9] [0-9:]* [0-9][0-9][0-9][0-9] -0000 $hostname $TESTDIR[0-9]*/edit-check/first-dir" + + AF_editorsLineRE="file[12] [-a-zA-Z0-9_]* [SMTWF][uoehra][neduit] [JFAMSOND][aepuco][nbrylgptvc] [0-9 ][0-9] [0-9:]* [0-9][0-9][0-9][0-9] -0000 $hostname $TESTDIR/edit-check/first-dir" + + NF_editorsLineRE=" [-a-zA-Z0-9_]* [SMTWF][uoehra][neduit] [JFAMSOND][aepuco][nbrylgptvc] [0-9 ][0-9] [0-9:]* [0-9][0-9][0-9][0-9] -0000 $hostname $TESTDIR/edit-check/first-dir" + + dotest edit-check-3 "$testcvs edit file1" + dotest edit-check-4 "$testcvs edit file1" "$editorsLineRE" + + dotest_fail edit-check-5a "$testcvs edit -c file1" \ +"$editorsLineRE +$SPROG edit: Skipping file \`file1' due to existing editors\." + + dotest edit-check-5b "$testcvs editors" "$editorsLineRE" + + dotest edit-check-6a "$testcvs edit -c -f file1" "$editorsLineRE" + dotest edit-check-6b "$testcvs editors" "$editorsLineRE" + + dotest edit-check-7a "cat file1" "foo" + echo "bar" > file1 + dotest_fail edit-check-7b "$testcvs edit -c file1" \ +"$editorsLineRE +$SPROG edit: Skipping file \`file1' due to existing editors\." + dotest edit-check-7c "cat file1" "bar" + + # edit-check-8a has issues. It copies the current (modified) + # version of the file into CVS/Base, so that edit-check-9a and + # edit-check-9b don't get the expected results. + # Maybe unedit is *supposed* to return it to the state + # it was in before the edit (even if it was modified), + # but while that has a certain symetry, it doesn't seem + # to pass the intuitive-usability test. + # This aspect of the general problem could + # be fixed by not overwriting pre-existing Base versions, + # but it still wouldn't fix it if the user manually + # modified the file before doing the first edit. + # Because of the possibility that this is working as + # intended, I'm just commenting out the test, not fixing + # the issue. + #dotest edit-check-8a "${testcvs} edit -c -f file1" \ + # "${editorsLineRE}" + dotest edit-check-8b "$testcvs editors" "$editorsLineRE" + + dotest edit-check-9a "echo yes | $testcvs unedit file1" \ +"file1 has been modified; revert changes? " + dotest edit-check-9b "$testcvs editors" + dotest edit-check-9c "cat file1" "foo" + + dotest edit-check-10 "$testcvs edit -c file1" + dotest_fail edit-check-11 "$testcvs edit -c file1" \ +"$editorsLineRE +$SPROG edit: Skipping file \`file1' due to existing editors\." + + echo "morefoo" > file1 + dotest edit-check-12a "$testcvs commit -m 'c2' -c file1" \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +new revision: 1\.2; previous revision: 1\.1" + dotest edit-check-12b "$testcvs editors file1" + + chmod u+w file1 + echo "morebar" > file1 + dotest_fail edit-check-13a "$testcvs commit -m 'c3' -c file1" \ +"$SPROG [a-z]*: Valid edit does not exist for file1 +$SPROG \[[a-z]* aborted\]: correct above errors first!" + dotest edit-check-13b "$testcvs editors file1" + + dotest edit-check-14a "$testcvs commit -m 'c4' -c -f file1" \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +new revision: 1\.3; previous revision: 1\.2" + dotest edit-check-14b "$testcvs editors file1" + + dotest edit-check-15 "$testcvs edit -c file1" + cd .. + + dotest edit-check-16a "echo yes | $testcvs release -d first-dir" \ +"You have \[0\] altered files in this repository. +Are you sure you want to release (and delete) directory \`first-dir': " + dotest edit-check-16b "$testcvs -q update -d first-dir" \ + "U first-dir/file1" + cd first-dir + dotest edit-check-16c "$testcvs editors file1" + + cd .. + dotest edit-check-17a "$testcvs edit -c" + dotest_fail edit-check-17b "$testcvs edit -c" \ +"$R_editorsLineRE +$SPROG edit: Skipping file \`first-dir/file1' due to existing editors\." + dotest edit-check-17c "$testcvs edit -c -f" "$R_editorsLineRE" + + echo "more changes" > first-dir/file1 + dotest edit-check-18a "$testcvs -q commit -m 'c5' -c" \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- first-dir/file1 +new revision: 1\.4; previous revision: 1\.3" + dotest edit-check-18b "$testcvs editors" + + cd first-dir + + # Manually fake another editor: + + # Try to gaurantee a seperate name for an "other" user editting + # the file. + otherUser="dummyUser" + if [ x"$USER" = x"$otherUser" ] ; then + otherUser="dummyUser2" + fi + if [ x"$LOGNAME" = x"$otherUser" ] ; then + otherUser="dummyUser3" + fi + tabChar=' ' + + backupFileattrName="$CVSROOT_DIRNAME/first-dir/CVS/bak.fileattr.$$" + mv $CVSROOT_DIRNAME/first-dir/CVS/fileattr $backupFileattrName + + otherDir="`pwd | sed 's%/edit-check/%2/edit-check/%'`" + echo \ +"Ffile1${tabChar}_watched=;_editors=$otherUser>Sat Oct 6 04:25:00 2001 -0000+`hostname`+$otherDir;_watchers=$otherUser>tedit+tunedit+tcommit +D${tabChar}_watched=" > $CVSROOT_DIRNAME/first-dir/CVS/fileattr + + editFileattrName="$CVSROOT_DIRNAME/first-dir/CVS/edit.fileattr.$$" + cp $CVSROOT_DIRNAME/first-dir/CVS/fileattr $editFileattrName + + O_editorsLineRE="file1 $otherUser [SMTWF][uoehra][neduit] [JFAMSOND][aepuco][nbrylgptvc] [0-9 ][0-9] [0-9:]* [0-9][0-9][0-9][0-9] -0000 $hostname $TESTDIR[0-9]/edit-check/first-dir" + + dotest edit-check-19a "$testcvs edit file1" "$O_editorsLineRE" + dotest edit-check-19b "$testcvs editors" \ +"$A_editorsLineRE +$NF_editorsLineRE" + + dotest edit-check-20a "$testcvs unedit file1" + dotest edit-check-20b "$testcvs editors" "$O_editorsLineRE" + + dotest_fail edit-check-21a "$testcvs edit -c file1" \ +"$O_editorsLineRE +$SPROG edit: Skipping file \`file1' due to existing editors\." + dotest edit-check-21b "$testcvs editors" "$O_editorsLineRE" + + dotest edit-check-22a "$testcvs edit -c -f file1" "$O_editorsLineRE" + dotest edit-check-22b "$testcvs editors" \ +"$A_editorsLineRE +$NF_editorsLineRE" + + echo "Yet another change" >file1 + + dotest_fail edit-check-23a "$testcvs edit -c" \ +"$A_editorsLineRE +$NF_editorsLineRE +$SPROG edit: Skipping file \`file1' due to existing editors\." + + dotest edit-check-23b "$testcvs editors" \ +"$A_editorsLineRE +$NF_editorsLineRE" + + dotest edit-check-24a "echo y | $testcvs unedit" \ + "file1 has been modified; revert changes? " + dotest edit-check-24b "$testcvs editors" "$O_editorsLineRE" + dotest edit-check-24c "cat file1" "more changes" + + dotest edit-check-25a "$testcvs unedit" + dotest edit-check-25b "$testcvs editors" "$O_editorsLineRE" + dotest_fail edit-check-25c "test -w file1" + + dotest edit-check-26a "$testcvs edit file1" "$O_editorsLineRE" + dotest edit-check-26b "$testcvs editors file1" \ +"$A_editorsLineRE +$NF_editorsLineRE" + dotest edit-check-26c "test -w file1" + + echo "Yet more changes" >file1 + dotest edit-check-27a "$testcvs -q commit -mmsg -c file1" \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +new revision: 1\.5; previous revision: 1\.4" + dotest edit-check-27b "$testcvs editors" "$O_editorsLineRE" + + chmod u+w file1 + echo "unofficial change" >file1 + + dotest_fail edit-check-28a "$testcvs -q commit -mmsg -c" \ +"$SPROG commit: Valid edit does not exist for file1 +$SPROG \[commit aborted\]: correct above errors first!" + dotest edit-check-28b "$testcvs editors" "$O_editorsLineRE" + + dotest edit-check-29a "$testcvs -q commit -mmsg -c -f" \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +new revision: 1\.6; previous revision: 1\.5" + dotest edit-check-29b "$testcvs editors" "$O_editorsLineRE" + dotest edit-check-29c "cat file1" "unofficial change" + + modify_repo cp "$backupFileattrName" \ + $CVSROOT_DIRNAME/first-dir/CVS/fileattr + dotest edit-check-30 "$testcvs editors" + + # Make sure earlier unreported editors are reported properly + # with the edit-check code running. + if $remote; then + CVS_SERVER_SAVED=$CVS_SERVER + CVS_SERVER=$TESTDIR/cvs-none; export CVS_SERVER + + # The $DOTSTAR matches the exact exec error message + # (which varies) and either "end of file from server" + # (if the process doing the exec exits before the parent + # gets around to sending data to it) or "broken pipe" (if it + # is the other way around). + dotest_fail edit-check-31ar "$testcvs edit file1" \ +"$SPROG \[edit aborted\]: cannot exec $TESTDIR/cvs-none: $DOTSTAR" + dotest edit-check-31br "test -w file1" + dotest edit-check-31cr "cat CVS/Notify" \ +"Efile1 [SMTWF][uoehra][neduit] [JFAMSOND][aepuco][nbrylgptvc] [0-9 ][0-9] [0-9:]* [0-9][0-9][0-9][0-9] -0000 [-a-zA-Z_.0-9]* $TESTDIR/edit-check/first-dir EUC" + CVS_SERVER=$CVS_SERVER_SAVED; export CVS_SERVER + + dotest_fail edit-check-31dr "$testcvs edit -c file1" \ +"$editorsLineRE +$SPROG edit: Skipping file \`file1' due to existing editors\." + dotest edit-check-31er "$testcvs editors file1" "$editorsLineRE" + dotest edit-check-31fr "$testcvs unedit file1" + fi + + # Make sure it isn't confused by handling multiple files at + # the same time: + echo file2Data >file2 + + dotest edit-check-32a "$testcvs add file2" \ +"$SPROG [a-z]*: scheduling file .file2. for addition +$SPROG [a-z]*: use .$SPROG commit. to add this file permanently" + + dotest edit-check-32b "$testcvs commit -m 'c1' file2" \ +"$CVSROOT_DIRNAME/first-dir/file2,v <-- file2 +initial revision: 1\.1" + + mkdir second-dir + dotest edit-check-32c "$testcvs add second-dir" \ +"Directory $CVSROOT_DIRNAME/first-dir/second-dir added to the repository" + cd second-dir + echo ThirdFile >file3 + + dotest edit-check-32d "$testcvs add file3" \ +"$SPROG [a-z]*: scheduling file .file3. for addition +$SPROG [a-z]*: use .$SPROG commit. to add this file permanently" + + dotest edit-check-32f "$testcvs commit -m 'c1' file3" \ +"$CVSROOT_DIRNAME/first-dir/second-dir/file3,v <-- file3 +initial revision: 1\.1" + dotest_fail edit-check-32g "test -w file3" + + cd .. + + dotest edit-check-33a "$testcvs edit -c" + + dotest edit-check-33b "$testcvs editors" \ +"$AF_editorsLineRE +$AF_editorsLineRE +$F3_editorsLineRE" + dotest edit-check-33c "test -w second-dir/file3" + + dotest_fail edit-check-34a "$testcvs edit -c file1 file2" \ +"$AF_editorsLineRE +$SPROG edit: Skipping file \`file1' due to existing editors\. +$AF_editorsLineRE +$SPROG edit: Skipping file \`file2' due to existing editors\." + + dotest edit-check-34b "$testcvs editors file1 file2" \ +"$editorsLineRE +$AF_editorsLineRE" + + dotest edit-check-35a "$testcvs unedit file1" + dotest edit-check-35b "$testcvs editors" \ +"$AF_editorsLineRE +$F3_editorsLineRE" + dotest edit-check-35c "test -w second-dir/file3" + + dotest edit-check-36a "$testcvs unedit" + dotest edit-check-36b "$testcvs editors" + dotest_fail edit-check-36c "test -w second-dir/file3" + + dokeep + cd ../.. + rm -rf edit-check + rm -rf $CVSROOT_DIRNAME/first-dir + ;; + + + + unedit-without-baserev) + mkdir 1; cd 1 + module=x + + file=m + echo foo > $file + dotest unedit-without-baserev-1 \ + "$testcvs -Q import -m . $module X Y" '' + dotest unedit-without-baserev-2 "$testcvs -Q co $module" '' + cd $module + + dotest unedit-without-baserev-3 "$testcvs -Q edit $file" '' + + echo add a line >> $file + rm -f CVS/Baserev + + # This will fail on most systems. + dotest unedit-without-baserev-4 "echo yes |${testcvs} -Q unedit $file" \ +"m has been modified; revert changes${QUESTION} ${CPROG} unedit: m not mentioned in CVS/Baserev +${CPROG} unedit: run update to complete the unedit" + + # SunOS4.1.4 systems make it this far, but with a corrupted + # CVS/Entries file. Demonstrate the corruption! + dotest unedit-without-baserev-5 "cat CVS/Entries" \ + "/$file/1\.1\.1\.1/${DOTSTAR}" + + dotest unedit-without-baserev-6 "${testcvs} -q update" \ +"$SPROG update: warning: \`m' was lost +U m" + + # OK, those were the easy cases. Now tackle the hard one + # (the reason that CVS/Baserev was invented rather than just + # getting the revision from CVS/Entries). This is very + # similar to watch4-10 through watch4-18 but with Baserev + # missing. + cd ../.. + mkdir 2; cd 2 + dotest unedit-without-baserev-7 "${testcvs} -Q co x" '' + cd x + + dotest unedit-without-baserev-10 "${testcvs} edit m" '' + echo 'edited in 2' >m + cd ../.. + + cd 1/x + + editorsLineRE="m $username [SMTWF][uoehra][neduit] [JFAMSOND][aepuco][nbrylgptvc] [0-9 ][0-9] [0-9:]* [0-9][0-9][0-9][0-9] -0000 $hostname $TESTDIR/2/x" + dotest unedit-without-baserev-11 "$testcvs edit m" "$editorsLineRE" + + echo 'edited in 1' >m + dotest unedit-without-baserev-12 "${testcvs} -q ci -m edit-in-1" \ +"$CVSROOT_DIRNAME/x/m,v <-- m +new revision: 1\.2; previous revision: 1\.1" + cd ../.. + cd 2/x + dotest unedit-without-baserev-13 "${testcvs} -q update" \ +"RCS file: ${CVSROOT_DIRNAME}/x/m,v +retrieving revision 1\.1\.1\.1 +retrieving revision 1\.2 +Merging differences between 1\.1\.1\.1 and 1\.2 into m +rcsmerge: warning: conflicts during merge +${SPROG} update: conflicts found in m +C m" + rm CVS/Baserev + dotest unedit-without-baserev-14 "echo yes |${testcvs} unedit m" \ +"m has been modified; revert changes${QUESTION} ${CPROG} unedit: m not mentioned in CVS/Baserev +${CPROG} unedit: run update to complete the unedit" + dotest unedit-without-baserev-15 "${testcvs} -q update" \ +"$SPROG update: warning: \`m' was lost +U m" + # The following tests are kind of degenerate compared with + # watch4-16 through watch4-18 but might as well make sure that + # nothing seriously wrong has happened to the working directory. + dotest unedit-without-baserev-16 "cat m" 'edited in 1' + # Make sure CVS really thinks we are at 1.2. + dotest unedit-without-baserev-17 "${testcvs} -q update" "" + dotest unedit-without-baserev-18 "cat m" "edited in 1" + + dokeep + cd ../.. + rm -rf 1 + rm -r 2 + modify_repo rm -rf $CVSROOT_DIRNAME/$module + ;; + + + + ignore) + # On Windows, we can't check out CVSROOT, because the case + # insensitivity means that this conflicts with cvsroot. + mkdir ignore + cd ignore + + dotest ignore-1 "${testcvs} -q co CVSROOT" "U CVSROOT/${DOTSTAR}" + cd CVSROOT + echo rootig.c >cvsignore + dotest ignore-2 "${testcvs} add cvsignore" "${SPROG}"' add: scheduling file `cvsignore'"'"' for addition +'"${SPROG}"' add: use .'"${SPROG}"' commit. to add this file permanently' + + dotest ignore-3 " ${testcvs} ci -m added" \ +"${CPROG} commit: Examining \. +${CVSROOT_DIRNAME}/CVSROOT/cvsignore,v <-- cvsignore +initial revision: 1\.1 +${SPROG} commit: Rebuilding administrative file database" + + cd .. + if echo "yes" | ${testcvs} release -d CVSROOT >>${LOGFILE} ; then + pass ignore-4 + else + fail ignore-4 + fi + + # CVS looks at the home dir from getpwuid, not HOME (is that correct + # behavior?), so this is hard to test and we won't try. + # echo foobar.c >${HOME}/.cvsignore + CVSIGNORE=envig.c; export CVSIGNORE + mkdir dir-to-import + cd dir-to-import + touch foobar.c bar.c rootig.c defig.o envig.c optig.c + # We use sort because we can't predict the order in which + # the files will be listed. + dotest_sort ignore-5 "${testcvs} import -m m -I optig.c ignore/first-dir tag1 tag2" \ +' + +I ignore/first-dir/defig.o +I ignore/first-dir/envig.c +I ignore/first-dir/optig.c +I ignore/first-dir/rootig.c +N ignore/first-dir/bar.c +N ignore/first-dir/foobar.c +No conflicts created by this import' + dotest_sort ignore-6 "${testcvs} import -m m -I ! ignore/second-dir tag3 tag4" \ +' + +N ignore/second-dir/bar.c +N ignore/second-dir/defig.o +N ignore/second-dir/envig.c +N ignore/second-dir/foobar.c +N ignore/second-dir/optig.c +N ignore/second-dir/rootig.c +No conflicts created by this import' + cd .. + rm -r dir-to-import + + mkdir 1 + cd 1 + dotest ignore-7 "${testcvs} -q co -dsecond-dir ignore/second-dir" \ +'U second-dir/bar.c +U second-dir/defig.o +U second-dir/envig.c +U second-dir/foobar.c +U second-dir/optig.c +U second-dir/rootig.c' + dotest ignore-8 "${testcvs} -q co -dfirst-dir ignore/first-dir" 'U first-dir/bar.c +U first-dir/foobar.c' + cd first-dir + touch rootig.c defig.o envig.c optig.c notig.c + dotest ignore-9 "${testcvs} -q update -I optig.c" "${QUESTION} notig.c" + # The fact that CVS requires us to specify -I CVS here strikes me + # as a bug. + dotest_sort ignore-10 "${testcvs} -q update -I ! -I CVS" \ +"${QUESTION} defig.o +${QUESTION} envig.c +${QUESTION} notig.c +${QUESTION} optig.c +${QUESTION} rootig.c" + + # Now test that commands other than update also print "? notig.c" + # where appropriate. Only test this for remote, because local + # CVS only prints it on update. + rm optig.c + if $remote; then + dotest ignore-11r "$testcvs -q diff" "$QUESTION notig.c" + + # Force the server to be contacted. Ugh. Having CVS + # contact the server for the sole purpose of checking + # the CVSROOT/cvsignore file does not seem like such a + # good idea, so I imagine this will continue to be + # necessary. Oh well, at least we test CVS's ablity to + # handle a file with a modified timestamp but unmodified + # contents. + touch bar.c + + dotest ignore-11ar "$testcvs -q ci -m commit-it" \ +"$QUESTION notig.c" + fi + + # now test .cvsignore files + cd .. + echo notig.c >first-dir/.cvsignore + echo foobar.c >second-dir/.cvsignore + touch first-dir/notig.c second-dir/notig.c second-dir/foobar.c + dotest_sort ignore-12 "${testcvs} -qn update" \ +"${QUESTION} first-dir/.cvsignore +${QUESTION} second-dir/.cvsignore +${QUESTION} second-dir/notig.c" + dotest_sort ignore-13 "${testcvs} -qn update -I! -I CVS" \ +"${QUESTION} first-dir/.cvsignore +${QUESTION} first-dir/defig.o +${QUESTION} first-dir/envig.c +${QUESTION} first-dir/rootig.c +${QUESTION} second-dir/.cvsignore +${QUESTION} second-dir/notig.c" + + echo yes | dotest ignore-14 "${testcvs} release -d first-dir" \ +"${QUESTION} \.cvsignore +You have \[0\] altered files in this repository. +Are you sure you want to release (and delete) directory .first-dir': " + + echo add a line >>second-dir/foobar.c + rm second-dir/notig.c second-dir/.cvsignore + echo yes | dotest ignore-15 "${testcvs} release -d second-dir" \ +"M foobar.c +You have \[1\] altered files in this repository. +Are you sure you want to release (and delete) directory .second-dir': " + + dokeep + cd ../.. + rm -r ignore + modify_repo rm -rf $CVSROOT_DIRNAME/ignore + ;; + + + + ignore-on-branch) + # Test that CVS _doesn't_ ignore files on branches because they were + # added to the trunk. + mkdir ignore-on-branch; cd ignore-on-branch + modify_repo mkdir $CVSROOT_DIRNAME/ignore-on-branch + + # create file1 & file2 on trunk + dotest ignore-on-branch-setup-1 "$testcvs -q co -dsetup ignore-on-branch" '' + cd setup + echo file1 >file1 + dotest ignore-on-branch-setup-2 "$testcvs -q add file1" \ +"${SPROG} add: use .${SPROG} commit. to add this file permanently" + dotest ignore-on-branch-setup-3 "$testcvs -q ci -mfile1 file1" \ +"$CVSROOT_DIRNAME/ignore-on-branch/file1,v <-- file1 +initial revision: 1\.1" + dotest ignore-on-branch-setup-4 "$testcvs -q tag -b branch" 'T file1' + echo file2 >file2 + dotest ignore-on-branch-setup-5 "$testcvs -q add file2" \ +"${SPROG} add: use .${SPROG} commit. to add this file permanently" + dotest ignore-on-branch-setup-6 "$testcvs -q ci -mtrunk file2" \ +"$CVSROOT_DIRNAME/ignore-on-branch/file2,v <-- file2 +initial revision: 1\.1" + + cd .. + + # Check out branch. + # + # - This was the original failure case - file2 would not be flagged + # with a '?' + dotest ignore-on-branch-1 "$testcvs -q co -rbranch ignore-on-branch" \ +'U ignore-on-branch/file1' + cd ignore-on-branch + echo file2 on branch >file2 + dotest ignore-on-branch-2 "$testcvs -nq update" '? file2' + + # Now set up for a join. One of the original fixes for this would + # print out a 'U' and a '?' during a join which added a file. + if $remote; then + dotest ignore-on-branch-3 "$testcvs -q tag -b branch2" \ +'? file2 +T file1' + else + dotest ignore-on-branch-3 "$testcvs -q tag -b branch2" 'T file1' + fi + dotest ignore-on-branch-4 "$testcvs -q add file2" \ +"${SPROG} add: use .${SPROG} commit. to add this file permanently" + dotest ignore-on-branch-5 "$testcvs -q ci -mbranch file2" \ +"$CVSROOT_DIRNAME/ignore-on-branch/file2,v <-- file2 +new revision: 1\.1\.2\.2; previous revision: 1\.1\.2\.1" + dotest ignore-on-branch-6 "$testcvs -q up -rbranch2" \ +"${SPROG} update: \`file2' is no longer in the repository" + dotest ignore-on-branch-7 "$testcvs -q up -jbranch" 'U file2' + + dokeep + cd ../.. + rm -r ignore-on-branch + modify_repo rm -rf $CVSROOT_DIRNAME/ignore-on-branch + ;; + + + + binfiles) + # Test cvs's ability to handle binary files. + # List of binary file tests: + # * conflicts, "cvs admin": binfiles + # * branching and joining: binfiles2 + # * adding and removing files: binfiles3 + # * -k wrappers: binwrap, binwrap2, binwrap3 + # * "cvs import" and wrappers: binwrap, binwrap2, binwrap3 + # * -k option to "cvs import": none yet, as far as I know. + modify_repo mkdir $CVSROOT_DIRNAME/first-dir + mkdir 1; cd 1 + dotest binfiles-1 "${testcvs} -q co first-dir" '' + ${AWK} 'BEGIN { printf "%c%c%c@%c%c", 2, 10, 137, 13, 10 }' \ + </dev/null | ${TR} '@' '\000' >binfile.dat + cat binfile.dat binfile.dat >binfile2.dat + cd first-dir + cp ../binfile.dat binfile + dotest binfiles-2 "${testcvs} add -kb binfile" \ +"${SPROG}"' add: scheduling file `binfile'\'' for addition +'"${SPROG}"' add: use .'"${SPROG}"' commit. to add this file permanently' + dotest binfiles-3 "${testcvs} -q ci -m add-it" \ +"$CVSROOT_DIRNAME/first-dir/binfile,v <-- binfile +initial revision: 1\.1" + cd ../.. + mkdir 2; cd 2 + dotest binfiles-4 "${testcvs} -q co first-dir" 'U first-dir/binfile' + cd first-dir + dotest binfiles-5 "cmp ../../1/binfile.dat binfile" '' + # Testing that sticky options is -kb is the closest thing we have + # to testing that binary files work right on non-unix machines + # (until there is automated testing for such machines, of course). + dotest binfiles-5.5 "${testcvs} status binfile" \ +"=================================================================== +File: binfile Status: Up-to-date + + Working revision: 1\.1.* + Repository revision: 1\.1 ${CVSROOT_DIRNAME}/first-dir/binfile,v + Commit Identifier: ${commitid} + Sticky Tag: (none) + Sticky Date: (none) + Sticky Options: -kb" + + # Test that "-kk" does not override "-kb" + cd ../.. + mkdir 2a; cd 2a + dotest binfiles-4 "${testcvs} -q co -kk first-dir" 'U first-dir/binfile' + cd first-dir + # Testing that sticky options is -kb is the closest thing we have + # to testing that binary files work right on non-unix machines + # (until there is automated testing for such machines, of course). + dotest binfiles-5.5 "${testcvs} status binfile" \ +"=================================================================== +File: binfile Status: Up-to-date + + Working revision: 1\.1.* + Repository revision: 1\.1 ${CVSROOT_DIRNAME}/first-dir/binfile,v + Commit Identifier: ${commitid} + Sticky Tag: (none) + Sticky Date: (none) + Sticky Options: -kb" + + # Test whether the default options from the RCS file are + # also used when operating on files instead of whole + # directories + cd ../.. + rm -r 2a + mkdir 3; cd 3 + dotest binfiles-5.5b0 "${testcvs} -q co first-dir/binfile" \ +'U first-dir/binfile' + cd first-dir + dotest binfiles-5.5b1 "${testcvs} status binfile" \ +"=================================================================== +File: binfile Status: Up-to-date + + Working revision: 1\.1.* + Repository revision: 1\.1 ${CVSROOT_DIRNAME}/first-dir/binfile,v + Commit Identifier: ${commitid} + Sticky Tag: (none) + Sticky Date: (none) + Sticky Options: -kb" + cd ../.. + rm -r 3 + # test that "-kk" does not override "-kb" + mkdir 3; cd 3 + dotest binfiles-5.5b0 "${testcvs} -q co -kk first-dir/binfile" \ +'U first-dir/binfile' + cd first-dir + dotest binfiles-5.5b1 "${testcvs} status binfile" \ +"=================================================================== +File: binfile Status: Up-to-date + + Working revision: 1\.1.* + Repository revision: 1\.1 ${CVSROOT_DIRNAME}/first-dir/binfile,v + Commit Identifier: ${commitid} + Sticky Tag: (none) + Sticky Date: (none) + Sticky Options: -kb" + cd ../.. + rm -r 3 + cd 2/first-dir + + cp ../../1/binfile2.dat binfile + dotest binfiles-6 "${testcvs} -q ci -m modify-it" \ +"$CVSROOT_DIRNAME/first-dir/binfile,v <-- binfile +new revision: 1\.2; previous revision: 1\.1" + cd ../../1/first-dir + dotest binfiles-7 "${testcvs} -q update" '[UP] binfile' + dotest binfiles-8 "cmp ../binfile2.dat binfile" '' + + # Now test handling of conflicts with binary files. + cp ../binfile.dat binfile + dotest binfiles-con0 "${testcvs} -q ci -m modify-it" \ +"$CVSROOT_DIRNAME/first-dir/binfile,v <-- binfile +new revision: 1\.3; previous revision: 1\.2" + cd ../../2/first-dir + echo 'edits in dir 2' >binfile + dotest binfiles-con1 "${testcvs} -q update" \ +"$SPROG update: nonmergeable file needs merge +$SPROG update: revision 1\.3 from repository is now in binfile +$SPROG update: file from working directory is now in \.#binfile\.1\.2 +C binfile" + + dotest_fail binfiles-con1b "$testcvs -q up" "C binfile" + + dotest binfiles-con2 "cmp binfile ../../1/binfile.dat" '' + dotest binfiles-con3 "cat .#binfile.1.2" 'edits in dir 2' + + cp ../../1/binfile2.dat binfile + dotest binfiles-con4 "$testcvs -q ci -m resolve-it" \ +"$CVSROOT_DIRNAME/first-dir/binfile,v <-- binfile +new revision: 1\.4; previous revision: 1\.3" + cd ../../1/first-dir + dotest binfiles-con5 "${testcvs} -q update" '[UP] binfile' + + dotest binfiles-9 "${testcvs} -q update -A" '' + # "-kk" no longer does anything with "-kb" + dotest binfiles-10 "${testcvs} -q update -kk" '' + dotest binfiles-11 "${testcvs} -q update" '' + # "-kk" no longer does anything with "-kb" + dotest binfiles-12 "${testcvs} -q update -A" '' + dotest binfiles-13 "${testcvs} -q update -A" '' + + cd ../.. + + mkdir 3 + cd 3 + dotest binfiles-13a0 "${testcvs} -q co -r HEAD first-dir" \ +'U first-dir/binfile' + cd first-dir + dotest binfiles-13a1 "${testcvs} status binfile" \ +"=================================================================== +File: binfile Status: Up-to-date + + Working revision: 1\.4.* + Repository revision: 1\.4 ${CVSROOT_DIRNAME}/first-dir/binfile,v + Commit Identifier: ${commitid} + Sticky Tag: HEAD (revision: 1\.4) + Sticky Date: (none) + Sticky Options: -kb" + cd ../.. + rm -r 3 + + cd 2/first-dir + echo 'this file is $''RCSfile$' >binfile + dotest binfiles-14a "${testcvs} -q ci -m modify-it" \ +"$CVSROOT_DIRNAME/first-dir/binfile,v <-- binfile +new revision: 1\.5; previous revision: 1\.4" + dotest binfiles-14b "cat binfile" 'this file is $''RCSfile$' + # See binfiles-5.5 for discussion of -kb. + dotest binfiles-14c "${testcvs} status binfile" \ +"=================================================================== +File: binfile Status: Up-to-date + + Working revision: 1\.5.* + Repository revision: 1\.5 ${CVSROOT_DIRNAME}/first-dir/binfile,v + Commit Identifier: ${commitid} + Sticky Tag: (none) + Sticky Date: (none) + Sticky Options: -kb" + dotest binfiles-14d "${testcvs} admin -kv binfile" \ +"RCS file: ${CVSROOT_DIRNAME}/first-dir/binfile,v +done" + # cvs admin doesn't change the checked-out file or its sticky + # kopts. There probably should be a way which does (but + # what if the file is modified? And do we try to version + # control the kopt setting?) + dotest binfiles-14e "cat binfile" 'this file is $''RCSfile$' + dotest binfiles-14f "${testcvs} status binfile" \ +"=================================================================== +File: binfile Status: Up-to-date + + Working revision: 1\.5.* + Repository revision: 1\.5 ${CVSROOT_DIRNAME}/first-dir/binfile,v + Commit Identifier: ${commitid} + Sticky Tag: (none) + Sticky Date: (none) + Sticky Options: -kb" + dotest binfiles-14g "${testcvs} -q update -A" '[UP] binfile' + dotest binfiles-14h "cat binfile" 'this file is binfile,v' + dotest binfiles-14i "${testcvs} status binfile" \ +"=================================================================== +File: binfile Status: Up-to-date + + Working revision: 1\.5.* + Repository revision: 1\.5 ${CVSROOT_DIRNAME}/first-dir/binfile,v + Commit Identifier: ${commitid} + Sticky Tag: (none) + Sticky Date: (none) + Sticky Options: -kv" + + # Do sticky options work when used with 'cvs update'? + echo "Not a binary file." > nibfile + dotest binfiles-sticky1 "${testcvs} -q add nibfile" \ +"${SPROG} add: use .${SPROG} commit. to add this file permanently" + dotest binfiles-sticky2 "${testcvs} -q ci -m add-it nibfile" \ +"$CVSROOT_DIRNAME/first-dir/nibfile,v <-- nibfile +initial revision: 1\.1" + dotest binfiles-sticky3 "${testcvs} -q update -kb nibfile" \ + '[UP] nibfile' + dotest binfiles-sticky4 "${testcvs} -q status nibfile" \ +"=================================================================== +File: nibfile Status: Up-to-date + + Working revision: 1\.1.* + Repository revision: 1\.1 ${CVSROOT_DIRNAME}/first-dir/nibfile,v + Commit Identifier: ${commitid} + Sticky Tag: (none) + Sticky Date: (none) + Sticky Options: -kb" + + # Now test that -A can clear the sticky option. + dotest binfiles-sticky5 "${testcvs} -q update -A nibfile" \ +"[UP] nibfile" + dotest binfiles-sticky6 "${testcvs} -q status nibfile" \ +"=================================================================== +File: nibfile Status: Up-to-date + + Working revision: 1\.1.* + Repository revision: 1\.1 ${CVSROOT_DIRNAME}/first-dir/nibfile,v + Commit Identifier: ${commitid} + Sticky Tag: (none) + Sticky Date: (none) + Sticky Options: (none)" + dotest binfiles-15 "${testcvs} -q admin -kb nibfile" \ +"RCS file: ${CVSROOT_DIRNAME}/first-dir/nibfile,v +done" + dotest binfiles-16 "${testcvs} -q update nibfile" "[UP] nibfile" + dotest binfiles-17 "${testcvs} -q status nibfile" \ +"=================================================================== +File: nibfile Status: Up-to-date + + Working revision: 1\.1.* + Repository revision: 1\.1 ${CVSROOT_DIRNAME}/first-dir/nibfile,v + Commit Identifier: ${commitid} + Sticky Tag: (none) + Sticky Date: (none) + Sticky Options: -kb" + + dotest binfiles-o1 "${testcvs} admin -o1.3:: binfile" \ +"RCS file: ${CVSROOT_DIRNAME}/first-dir/binfile,v +deleting revision 1\.5 +deleting revision 1\.4 +done" + dotest binfiles-o2 "${testcvs} admin -o::1.3 binfile" \ +"RCS file: ${CVSROOT_DIRNAME}/first-dir/binfile,v +deleting revision 1\.2 +deleting revision 1\.1 +done" + dotest binfiles-o3 "${testcvs} -q log -h -N binfile" " +RCS file: ${CVSROOT_DIRNAME}/first-dir/binfile,v +Working file: binfile +head: 1\.3 +branch: +locks: strict +access list: +keyword substitution: v +total revisions: 1 +=============================================================================" + + # Check that the contents were right. This isn't the hard case + # (in which RCS_delete_revs does a diff), but might as well. + dotest binfiles-o4 "${testcvs} -q update binfile" "U binfile" + dotest binfiles-o5 "cmp binfile ../../1/binfile.dat" "" + + dokeep + cd ../.. + modify_repo rm -rf $CVSROOT_DIRNAME/first-dir + rm -r 1 2 + ;; + + + + binfiles2) + # Test cvs's ability to handle binary files, particularly branching + # and joining. The key thing we are worrying about is that CVS + # doesn't print "cannot merge binary files" or some such, in + # situations where no merging is required. + # See also "join" which does this with non-binary files. + # + # Cases (we are merging from the branch to the trunk): + # binfile.dat) File added on branch, not on trunk. + # File should be marked for addition. + # brmod) File modified on branch, not on trunk. + # File should be copied over to trunk (no merging is needed). + # brmod-trmod) File modified on branch, also on trunk. + # This is a conflict. Present the user with both files and + # let them figure it out. + # brmod-wdmod) File modified on branch, not modified in the trunk + # repository, but modified in the (trunk) working directory. + # This is also a conflict. + + modify_repo mkdir ${CVSROOT_DIRNAME}/first-dir + mkdir 1; cd 1 + dotest binfiles2-1 "${testcvs} -q co first-dir" '' + cd first-dir + + # The most important thing here is that binfile, binfile2, &c + # each be distinct from each other. We also make sure to include + # a few likely end-of-line patterns to make sure nothing is + # being munged as if in text mode. + ${AWK} 'BEGIN { printf "%c%c%c@%c%c", 2, 10, 137, 13, 10 }' \ + </dev/null | ${TR} '@' '\000' >../binfile + # Use binfl2 rather than binfile2 because of a problem with Cygwin + # and Samba. that causes cat to report that the input and output file + # are the same when outputting to binfile3. Why? I don't know, but + # it is consistently reproducible. + cat ../binfile ../binfile >../binfl2 + cat ../binfl2 ../binfile >../binfile3 + + # FIXCVS: unless a branch has at least one file on it, + # tag_check_valid won't know it exists. So if brmod didn't + # exist, we would have to invent it. + cp ../binfile brmod + cp ../binfile brmod-trmod + cp ../binfile brmod-wdmod + dotest binfiles2-1a \ +"${testcvs} add -kb brmod brmod-trmod brmod-wdmod" \ +"${SPROG} add: scheduling file .brmod. for addition +${SPROG} add: scheduling file .brmod-trmod. for addition +${SPROG} add: scheduling file .brmod-wdmod. for addition +${SPROG} add: use .${SPROG} commit. to add these files permanently" + dotest binfiles2-1b "${testcvs} -q ci -m add" \ +"$CVSROOT_DIRNAME/first-dir/brmod,v <-- brmod +initial revision: 1\.1 +$CVSROOT_DIRNAME/first-dir/brmod-trmod,v <-- brmod-trmod +initial revision: 1\.1 +$CVSROOT_DIRNAME/first-dir/brmod-wdmod,v <-- brmod-wdmod +initial revision: 1\.1" + dotest binfiles2-2 "${testcvs} -q tag -b br" 'T brmod +T brmod-trmod +T brmod-wdmod' + dotest binfiles2-3 "${testcvs} -q update -r br" '' + cp ../binfile binfile.dat + dotest binfiles2-4 "${testcvs} add -kb binfile.dat" \ +"${SPROG} add: scheduling file .binfile\.dat. for addition on branch .br. +${SPROG} add: use .${SPROG} commit. to add this file permanently" + cp ../binfl2 brmod + cp ../binfl2 brmod-trmod + cp ../binfl2 brmod-wdmod + dotest binfiles2-5 "${testcvs} -q ci -m br-changes" \ +"$CVSROOT_DIRNAME/first-dir/Attic/binfile\.dat,v <-- binfile\.dat +new revision: 1\.1\.2\.1; previous revision: 1\.1 +$CVSROOT_DIRNAME/first-dir/brmod,v <-- brmod +new revision: 1\.1\.2\.1; previous revision: 1\.1 +$CVSROOT_DIRNAME/first-dir/brmod-trmod,v <-- brmod-trmod +new revision: 1\.1\.2\.1; previous revision: 1\.1 +$CVSROOT_DIRNAME/first-dir/brmod-wdmod,v <-- brmod-wdmod +new revision: 1\.1\.2\.1; previous revision: 1\.1" + dotest binfiles2-6 "${testcvs} -q update -A" \ +"${SPROG} update: \`binfile\.dat' is no longer in the repository +[UP] brmod +[UP] brmod-trmod +[UP] brmod-wdmod" + dotest_fail binfiles2-7 "test -f binfile.dat" '' + dotest binfiles2-7-brmod "cmp ../binfile brmod" + cp ../binfile3 brmod-trmod + dotest binfiles2-7a "${testcvs} -q ci -m tr-modify" \ +"$CVSROOT_DIRNAME/first-dir/brmod-trmod,v <-- brmod-trmod +new revision: 1\.2; previous revision: 1\.1" + cp ../binfile3 brmod-wdmod + + dotest binfiles2-8 "${testcvs} -q update -j br" \ +"U binfile\.dat +U brmod +${SPROG} update: nonmergeable file needs merge +${SPROG} update: revision 1.1.2.1 from repository is now in brmod-trmod +${SPROG} update: file from working directory is now in .#brmod-trmod.1.2 +C brmod-trmod +M brmod-wdmod +${SPROG} update: nonmergeable file needs merge +${SPROG} update: revision 1.1.2.1 from repository is now in brmod-wdmod +${SPROG} update: file from working directory is now in .#brmod-wdmod.1.1 +C brmod-wdmod" + + dotest binfiles2-9 "cmp ../binfile binfile.dat" + dotest binfiles2-9-brmod "cmp ../binfl2 brmod" + dotest binfiles2-9-brmod-trmod "cmp ../binfl2 brmod-trmod" + dotest binfiles2-9-brmod-trmod "cmp ../binfl2 brmod-wdmod" + dotest binfiles2-9a-brmod-trmod "cmp ../binfile3 .#brmod-trmod.1.2" + dotest binfiles2-9a-brmod-wdmod "cmp ../binfile3 .#brmod-wdmod.1.1" + + # Test that everything was properly scheduled. + dotest binfiles2-10 "${testcvs} -q ci -m checkin" \ +"$CVSROOT_DIRNAME/first-dir/binfile\.dat,v <-- binfile\.dat +new revision: 1\.2; previous revision: 1\.1 +$CVSROOT_DIRNAME/first-dir/brmod,v <-- brmod +new revision: 1\.2; previous revision: 1\.1 +$CVSROOT_DIRNAME/first-dir/brmod-trmod,v <-- brmod-trmod +new revision: 1\.3; previous revision: 1\.2 +$CVSROOT_DIRNAME/first-dir/brmod-wdmod,v <-- brmod-wdmod +new revision: 1\.2; previous revision: 1\.1" + + dotest_fail binfiles2-o1 "${testcvs} -q admin -o :1.2 brmod-trmod" \ +"RCS file: ${CVSROOT_DIRNAME}/first-dir/brmod-trmod,v +deleting revision 1\.2 +${SPROG} admin: ${CVSROOT_DIRNAME}/first-dir/brmod-trmod,v: can't remove branch point 1\.1 +${SPROG} admin: RCS file for .brmod-trmod. not modified\." + dotest binfiles2-o2 "${testcvs} -q admin -o 1.1.2.1: brmod-trmod" \ +"RCS file: ${CVSROOT_DIRNAME}/first-dir/brmod-trmod,v +deleting revision 1\.1\.2\.1 +done" + dotest binfiles2-o3 "${testcvs} -q admin -o :1.2 brmod-trmod" \ +"RCS file: ${CVSROOT_DIRNAME}/first-dir/brmod-trmod,v +deleting revision 1\.2 +deleting revision 1\.1 +done" + dotest binfiles2-o4 "${testcvs} -q log -N brmod-trmod" " +RCS file: ${CVSROOT_DIRNAME}/first-dir/brmod-trmod,v +Working file: brmod-trmod +head: 1\.3 +branch: +locks: strict +access list: +keyword substitution: b +total revisions: 1; selected revisions: 1 +description: +---------------------------- +revision 1\.3 +date: ${ISO8601DATE}; author: ${username}; state: Exp; commitid: ${commitid}; +checkin +=============================================================================" + + dokeep + cd ../.. + modify_repo rm -rf $CVSROOT_DIRNAME/first-dir + rm -r 1 + ;; + + + + binfiles3) + # More binary file tests, especially removing, adding, &c. + # See "binfiles" for a list of binary file tests. + modify_repo mkdir $CVSROOT_DIRNAME/first-dir + mkdir 1; cd 1 + dotest binfiles3-1 "${testcvs} -q co first-dir" '' + ${AWK} 'BEGIN { printf "%c%c%c@%c%c", 2, 10, 137, 13, 10 }' \ + </dev/null | ${TR} '@' '\000' >binfile.dat + cd first-dir + echo hello >file1 + dotest binfiles3-2 "${testcvs} add file1" \ +"${SPROG} add: scheduling file .file1. for addition +${SPROG} add: use .${SPROG} commit. to add this file permanently" + dotest binfiles3-3 "${testcvs} -q ci -m add-it" \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +initial revision: 1\.1" + rm file1 + dotest binfiles3-4 "${testcvs} rm file1" \ +"${SPROG} remove: scheduling .file1. for removal +${SPROG} remove: use .${SPROG} commit. to remove this file permanently" + dotest binfiles3-5 "${testcvs} -q ci -m remove-it" \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +new revision: delete; previous revision: 1\.1" + cp ../binfile.dat file1 + dotest binfiles3-6 "${testcvs} add -kb file1" \ +"$SPROG add: Re-adding file .file1. after dead revision 1\.2\. +${SPROG} add: use .${SPROG} commit. to add this file permanently" + # The idea behind this test is to make sure that the file + # gets opened in binary mode to send to "cvs ci". + dotest binfiles3-6a "cat CVS/Entries" \ +"/file1/0/[A-Za-z0-9 :]*/-kb/ +D" + # TODO: This just tests the case where the old keyword + # expansion mode is the default (RCS_getexpand == NULL + # in checkaddfile()); should also test the case in which + # we are changing it from one non-default value to another. + dotest binfiles3-7 "$testcvs -q ci -m readd-it" \ +"$SPROG commit: changing keyword expansion mode to -kb +$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +new revision: 1\.3; previous revision: 1\.2" + dotest binfiles3-8 "${testcvs} -q log -h -N file1" " +RCS file: ${CVSROOT_DIRNAME}/first-dir/file1,v +Working file: file1 +head: 1\.3 +branch: +locks: strict +access list: +keyword substitution: b +total revisions: 3 +=============================================================================" + + # OK, now test admin -o on a binary file. See "admin" + # test for a more complete list of admin -o tests. + cp ${TESTDIR}/1/binfile.dat ${TESTDIR}/1/binfile4.dat + echo '%%$$##@@!!jjiiuull' | ${TR} j '\000' >>${TESTDIR}/1/binfile4.dat + cp ${TESTDIR}/1/binfile4.dat ${TESTDIR}/1/binfile5.dat + echo 'aawwee%$$##@@!!jjil' | ${TR} w '\000' >>${TESTDIR}/1/binfile5.dat + + cp ../binfile4.dat file1 + dotest binfiles3-9 "${testcvs} -q ci -m change" \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +new revision: 1\.4; previous revision: 1\.3" + cp ../binfile5.dat file1 + dotest binfiles3-10 "${testcvs} -q ci -m change" \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +new revision: 1\.5; previous revision: 1\.4" + dotest binfiles3-11 "${testcvs} admin -o 1.3::1.5 file1" \ +"RCS file: ${CVSROOT_DIRNAME}/first-dir/file1,v +deleting revision 1\.4 +done" + dotest binfiles3-12 "${testcvs} -q update -r 1.3 file1" "U file1" + dotest binfiles3-13 "cmp file1 ${TESTDIR}/1/binfile.dat" "" + + dokeep + cd ../.. + rm -r 1 + modify_repo rm -rf $CVSROOT_DIRNAME/first-dir + ;; + + + + mcopy) + # See comment at "mwrap" test for list of other wrappers tests. + # Test cvs's ability to handle nonmergeable files specified with + # -m 'COPY' in wrappers. Similar to the binfiles2 test, + # which tests the same thing for binary files + # (which are non-mergeable in the same sense). + # + # Cases (we are merging from the branch to the trunk): + # brmod) File modified on branch, not on trunk. + # File should be copied over to trunk (no merging is needed). + # brmod-trmod) File modified on branch, also on trunk. + # This is a conflict. Present the user with both files and + # let them figure it out. + # brmod-wdmod) File modified on branch, not modified in the trunk + # repository, but modified in the (trunk) working directory. + # This is also a conflict. + + # For the moment, remote CVS can't pass wrappers from CVSWRAPPERS + # (see wrap_send). So skip these tests for remote. + if $remote; then :; else + + mkdir ${CVSROOT_DIRNAME}/first-dir + mkdir 1; cd 1 + dotest mcopy-1 "${testcvs} -q co first-dir" '' + cd first-dir + + # FIXCVS: unless a branch has at least one file on it, + # tag_check_valid won't know it exists. So if brmod didn't + # exist, we would have to invent it. + echo 'brmod initial contents' >brmod + echo 'brmod-trmod initial contents' >brmod-trmod + echo 'brmod-wdmod initial contents' >brmod-wdmod + echo "* -m 'COPY'" >.cvswrappers + dotest mcopy-1a \ +"${testcvs} add .cvswrappers brmod brmod-trmod brmod-wdmod" \ +"${SPROG} add: scheduling file .\.cvswrappers. for addition +${SPROG} add: scheduling file .brmod. for addition +${SPROG} add: scheduling file .brmod-trmod. for addition +${SPROG} add: scheduling file .brmod-wdmod. for addition +${SPROG} add: use .${SPROG} commit. to add these files permanently" + dotest mcopy-1b "${testcvs} -q ci -m add" \ +"$CVSROOT_DIRNAME/first-dir/\.cvswrappers,v <-- \.cvswrappers +initial revision: 1\.1 +$CVSROOT_DIRNAME/first-dir/brmod,v <-- brmod +initial revision: 1\.1 +$CVSROOT_DIRNAME/first-dir/brmod-trmod,v <-- brmod-trmod +initial revision: 1\.1 +$CVSROOT_DIRNAME/first-dir/brmod-wdmod,v <-- brmod-wdmod +initial revision: 1\.1" + + # NOTE: .cvswrappers files are broken (see comment in + # src/wrapper.c). So doing everything via the environment + # variable is a workaround. Better would be to test them + # both. + CVSWRAPPERS="* -m 'COPY'" + export CVSWRAPPERS + dotest mcopy-2 "${testcvs} -q tag -b br" 'T \.cvswrappers +T brmod +T brmod-trmod +T brmod-wdmod' + dotest mcopy-3 "${testcvs} -q update -r br" '' + echo 'modify brmod on br' >brmod + echo 'modify brmod-trmod on br' >brmod-trmod + echo 'modify brmod-wdmod on br' >brmod-wdmod + dotest mcopy-5 "${testcvs} -q ci -m br-changes" \ +"$CVSROOT_DIRNAME/first-dir/brmod,v <-- brmod +new revision: 1\.1\.2\.1; previous revision: 1\.1 +$CVSROOT_DIRNAME/first-dir/brmod-trmod,v <-- brmod-trmod +new revision: 1\.1\.2\.1; previous revision: 1\.1 +$CVSROOT_DIRNAME/first-dir/brmod-wdmod,v <-- brmod-wdmod +new revision: 1\.1\.2\.1; previous revision: 1\.1" + dotest mcopy-6 "${testcvs} -q update -A" \ +"[UP] brmod +[UP] brmod-trmod +[UP] brmod-wdmod" + dotest mcopy-7 "cat brmod brmod-trmod brmod-wdmod" \ +"brmod initial contents +brmod-trmod initial contents +brmod-wdmod initial contents" + + echo 'modify brmod-trmod again on trunk' >brmod-trmod + dotest mcopy-7a "${testcvs} -q ci -m tr-modify" \ +"$CVSROOT_DIRNAME/first-dir/brmod-trmod,v <-- brmod-trmod +new revision: 1\.2; previous revision: 1\.1" + echo 'modify brmod-wdmod in working dir' >brmod-wdmod + + dotest mcopy-8 "${testcvs} -q update -j br" \ +"U brmod +${SPROG} update: nonmergeable file needs merge +${SPROG} update: revision 1.1.2.1 from repository is now in brmod-trmod +${SPROG} update: file from working directory is now in .#brmod-trmod.1.2 +C brmod-trmod +M brmod-wdmod +${SPROG} update: nonmergeable file needs merge +${SPROG} update: revision 1.1.2.1 from repository is now in brmod-wdmod +${SPROG} update: file from working directory is now in .#brmod-wdmod.1.1 +C brmod-wdmod" + + dotest mcopy-9 "cat brmod brmod-trmod brmod-wdmod" \ +"modify brmod on br +modify brmod-trmod on br +modify brmod-wdmod on br" + dotest mcopy-9a "cat .#brmod-trmod.1.2 .#brmod-wdmod.1.1" \ +"modify brmod-trmod again on trunk +modify brmod-wdmod in working dir" + + # Test that everything was properly scheduled. + dotest mcopy-10 "${testcvs} -q ci -m checkin" \ +"$CVSROOT_DIRNAME/first-dir/brmod,v <-- brmod +new revision: 1\.2; previous revision: 1\.1 +$CVSROOT_DIRNAME/first-dir/brmod-trmod,v <-- brmod-trmod +new revision: 1\.3; previous revision: 1\.2 +$CVSROOT_DIRNAME/first-dir/brmod-wdmod,v <-- brmod-wdmod +new revision: 1\.2; previous revision: 1\.1" + + dokeep + cd ../.. + modify_repo rm -rf $CVSROOT_DIRNAME/first-dir + rm -r 1 + unset CVSWRAPPERS + fi # end of tests to be skipped for remote + ;; + + + + binwrap) + # Test the ability to specify binary-ness based on file name. + # See "mwrap" for a list of other wrappers tests. + + mkdir dir-to-import + cd dir-to-import + touch foo.c foo.exe + + # While we're here, test for rejection of duplicate tag names. + dotest_fail binwrap-0 \ + "${testcvs} import -m msg -I ! first-dir dup dup" \ +"${CPROG} \[import aborted\]: tag .dup. was specified more than once" + + if ${testcvs} import -m message -I ! -W "*.exe -k 'b'" \ + first-dir tag1 tag2 >>${LOGFILE}; then + pass binwrap-1 + else + fail binwrap-1 + fi + cd .. + rm -r dir-to-import + dotest binwrap-2 "${testcvs} -q co first-dir" 'U first-dir/foo.c +U first-dir/foo.exe' + dotest binwrap-3 "${testcvs} -q status first-dir" \ +"=================================================================== +File: foo\.c Status: Up-to-date + + Working revision: 1\.1\.1\.1.* + Repository revision: 1\.1\.1\.1 ${CVSROOT_DIRNAME}/first-dir/foo\.c,v + Commit Identifier: ${commitid} + Sticky Tag: (none) + Sticky Date: (none) + Sticky Options: (none) + +=================================================================== +File: foo\.exe Status: Up-to-date + + Working revision: 1\.1\.1\.1.* + Repository revision: 1\.1\.1\.1 ${CVSROOT_DIRNAME}/first-dir/foo\.exe,v + Commit Identifier: ${commitid} + Sticky Tag: (none) + Sticky Date: (none) + Sticky Options: -kb" + + dokeep + rm -r first-dir + modify_repo rm -rf $CVSROOT_DIRNAME/first-dir + ;; + + + + binwrap2) + # Test the ability to specify binary-ness based on file name. + # See "mwrap" for a list of other wrappers tests. + + mkdir dir-to-import + cd dir-to-import + touch foo.c foo.exe + + # Specify that all files are binary except *.c. + # The order seems to matter, with the earlier rules taking + # precedence. I'm not sure whether that is good or not, + # but it is the current behavior. + if ${testcvs} import -m message -I ! \ + -W "*.c -k 'o'" -W "* -k 'b'" \ + first-dir tag1 tag2 >>${LOGFILE}; then + pass binwrap2-1 + else + fail binwrap2-1 + fi + cd .. + rm -r dir-to-import + dotest binwrap2-2 "${testcvs} -q co first-dir" 'U first-dir/foo.c +U first-dir/foo.exe' + dotest binwrap2-3 "${testcvs} -q status first-dir" \ +"=================================================================== +File: foo\.c Status: Up-to-date + + Working revision: 1\.1\.1\.1.* + Repository revision: 1\.1\.1\.1 ${CVSROOT_DIRNAME}/first-dir/foo\.c,v + Commit Identifier: ${commitid} + Sticky Tag: (none) + Sticky Date: (none) + Sticky Options: -ko + +=================================================================== +File: foo\.exe Status: Up-to-date + + Working revision: 1\.1\.1\.1.* + Repository revision: 1\.1\.1\.1 ${CVSROOT_DIRNAME}/first-dir/foo\.exe,v + Commit Identifier: ${commitid} + Sticky Tag: (none) + Sticky Date: (none) + Sticky Options: -kb" + + dokeep + rm -r first-dir + modify_repo rm -rf $CVSROOT_DIRNAME/first-dir + ;; + + + + binwrap3) + # Test communication of file-specified -k wrappers between + # client and server, in `import': + # + # 1. Set up a directory tree, populate it with files. + # 2. Give each directory a different .cvswrappers file. + # 3. Give the server its own .cvswrappers file. + # 4. Import the whole tree, see if the right files got set + # to binary. + # + # The tree has a top ("0th") level, and two subdirs, sub1/ + # and sub2/; sub2/ contains directory subsub/. Every + # directory has a .cvswrappers file as well as regular + # files. + # + # In the file names, "foo-b.*" should end up binary, and + # "foo-t.*" should end up text. Don't worry about the two + # letter extensions; they're just there to help me keep + # things straight. + # + # Here's the directory tree: + # + # ./ + # .cvswrappers + # foo-b.c0 + # foo-b.sb + # foo-t.c1 + # foo-t.st + # + # sub1/ sub2/ + # .cvswrappers .cvswrappers + # foo-b.c1 foo-b.sb + # foo-b.sb foo-b.st + # foo-t.c0 foo-t.c0 + # foo-t.st foo-t.c1 + # foo-t.c2 + # foo-t.c3 + # + # subsub/ + # .cvswrappers + # foo-b.c3 + # foo-b.sb + # foo-t.c0 + # foo-t.c1 + # foo-t.c2 + # foo-t.st + + binwrap3_line1="This is a test file " + binwrap3_line2="containing little of use " + binwrap3_line3="except this non-haiku" + + binwrap3_text="${binwrap3_line1}${binwrap3_line2}${binwrap3_line3}" + + cd ${TESTDIR} + + # On Windows, we can't check out CVSROOT, because the case + # insensitivity means that this conflicts with cvsroot. + mkdir wnt + cd wnt + + mkdir binwrap3 # the 0th dir + mkdir binwrap3/sub1 + mkdir binwrap3/sub2 + mkdir binwrap3/sub2/subsub + + echo "bar*" > binwrap3/.cvswrappers + echo "*.c0 -k 'b'" >> binwrap3/.cvswrappers + echo "whatever -k 'b'" >> binwrap3/.cvswrappers + echo ${binwrap3_text} > binwrap3/foo-b.c0 + echo ${binwrap3_text} > binwrap3/bar-t.c0 + echo ${binwrap3_text} > binwrap3/foo-b.sb + echo ${binwrap3_text} > binwrap3/foo-t.sb + echo ${binwrap3_text} > binwrap3/foo-t.c1 + echo ${binwrap3_text} > binwrap3/foo-t.st + + echo "bar* -k 'kv'" > binwrap3/sub1/.cvswrappers + echo "*.c1 -k 'b'" >> binwrap3/sub1/.cvswrappers + echo "whatever -k 'b'" >> binwrap3/sub1/.cvswrappers + echo ${binwrap3_text} > binwrap3/sub1/foo-b.c1 + echo ${binwrap3_text} > binwrap3/sub1/bar-t.c1 + echo ${binwrap3_text} > binwrap3/sub1/foo-b.sb + echo ${binwrap3_text} > binwrap3/sub1/foo-t.sb + echo ${binwrap3_text} > binwrap3/sub1/foo-t.c0 + echo ${binwrap3_text} > binwrap3/sub1/foo-t.st + + echo "bar*" > binwrap3/sub2/.cvswrappers + echo "*.st -k 'b'" >> binwrap3/sub2/.cvswrappers + echo ${binwrap3_text} > binwrap3/sub2/foo-b.sb + echo ${binwrap3_text} > binwrap3/sub2/foo-t.sb + echo ${binwrap3_text} > binwrap3/sub2/foo-b.st + echo ${binwrap3_text} > binwrap3/sub2/bar-t.st + echo ${binwrap3_text} > binwrap3/sub2/foo-t.c0 + echo ${binwrap3_text} > binwrap3/sub2/foo-t.c1 + echo ${binwrap3_text} > binwrap3/sub2/foo-t.c2 + echo ${binwrap3_text} > binwrap3/sub2/foo-t.c3 + + echo "bar* -k 'kv'" > binwrap3/sub2/subsub/.cvswrappers + echo "*.c3 -k 'b'" >> binwrap3/sub2/subsub/.cvswrappers + echo "foo -k 'b'" >> binwrap3/sub2/subsub/.cvswrappers + echo "c0* -k 'b'" >> binwrap3/sub2/subsub/.cvswrappers + echo ${binwrap3_text} > binwrap3/sub2/subsub/foo-b.c3 + echo ${binwrap3_text} > binwrap3/sub2/subsub/bar-t.c3 + echo ${binwrap3_text} > binwrap3/sub2/subsub/foo-b.sb + echo ${binwrap3_text} > binwrap3/sub2/subsub/foo-t.sb + echo ${binwrap3_text} > binwrap3/sub2/subsub/foo-t.c0 + echo ${binwrap3_text} > binwrap3/sub2/subsub/foo-t.c1 + echo ${binwrap3_text} > binwrap3/sub2/subsub/foo-t.c2 + echo ${binwrap3_text} > binwrap3/sub2/subsub/foo-t.st + + # Now set up CVSROOT/cvswrappers, the easy way: + dotest binwrap3-1 "${testcvs} -q co CVSROOT" "[UP] CVSROOT${DOTSTAR}" + cd CVSROOT + # This destroys anything currently in cvswrappers, but + # presumably other tests will take care of it themselves if + # they use cvswrappers: + echo "foo-t.sb" > cvswrappers + echo "foo*.sb -k 'b'" >> cvswrappers + dotest binwrap3-2 "${testcvs} -q ci -m cvswrappers-mod" \ +"$CVSROOT_DIRNAME/CVSROOT/cvswrappers,v <-- cvswrappers +new revision: 1\.[0-9]*; previous revision: 1\.[0-9]* +$SPROG commit: Rebuilding administrative file database" + cd .. + + # Avoid environmental interference + CVSWRAPPERS_save=${CVSWRAPPERS} + unset CVSWRAPPERS + + # Do the import + cd binwrap3 + # Not importing .cvswrappers tests whether the client is really + # letting the server know "honestly" whether the file is binary, + # rather than just letting the server see the .cvswrappers file. + dotest binwrap3-2a \ +"${testcvs} import -m . -I .cvswrappers binwrap3 tag1 tag2" \ +"[NI] ${DOTSTAR}" + + # OK, now test "cvs add". + cd .. + rm -r binwrap3 + dotest binwrap3-2b "${testcvs} co binwrap3" "${DOTSTAR}" + cd binwrap3 + cd sub2 + echo "*.newbin -k 'b'" > .cvswrappers + echo .cvswrappers >.cvsignore + echo .cvsignore >>.cvsignore + touch file1.newbin file1.txt + dotest binwrap3-2c "${testcvs} add file1.newbin file1.txt" \ +"${SPROG} add: scheduling file .file1\.newbin. for addition +${SPROG} add: scheduling file .file1\.txt. for addition +${SPROG} add: use .${SPROG} commit. to add these files permanently" + dotest binwrap3-2d "${testcvs} -q ci -m add" \ +"$CVSROOT_DIRNAME/binwrap3/sub2/file1\.newbin,v <-- file1\.newbin +initial revision: 1\.1 +$CVSROOT_DIRNAME/binwrap3/sub2/file1\.txt,v <-- file1\.txt +initial revision: 1\.1" + cd .. + + # Now check out the module and see which files are binary. + cd .. + rm -r binwrap3 + dotest binwrap3-3 "${testcvs} co binwrap3" "${DOTSTAR}" + cd binwrap3 + + # Running "cvs status" and matching output is too + # error-prone, too likely to falsely fail. Instead, we'll + # just grep the Entries lines: + + dotest binwrap3-top1 "grep foo-b.c0 ./CVS/Entries" \ + "/foo-b.c0/1.1.1.1/[A-Za-z0-9 :]*/-kb/" + + dotest binwrap3-top2 "grep foo-b.sb ./CVS/Entries" \ + "/foo-b.sb/1.1.1.1/[A-Za-z0-9 :]*/-kb/" + + dotest binwrap3-top3 "grep foo-t.c1 ./CVS/Entries" \ + "/foo-t.c1/1.1.1.1/[A-Za-z0-9 :]*//" + + dotest binwrap3-top4 "grep foo-t.st ./CVS/Entries" \ + "/foo-t.st/1.1.1.1/[A-Za-z0-9 :]*//" + + dotest binwrap3-top5 "grep foo-t.sb ./CVS/Entries" \ + "/foo-t.sb/1.1.1.1/[A-Za-z0-9 :]*//" + + dotest binwrap3-top6 "grep bar-t.c0 ./CVS/Entries" \ + "/bar-t.c0/1.1.1.1/[A-Za-z0-9 :]*//" + + dotest binwrap3-sub1-1 "grep foo-b.c1 sub1/CVS/Entries" \ + "/foo-b.c1/1.1.1.1/[A-Za-z0-9 :]*/-kb/" + + dotest binwrap3-sub1-2 "grep foo-b.sb sub1/CVS/Entries" \ + "/foo-b.sb/1.1.1.1/[A-Za-z0-9 :]*/-kb/" + + dotest binwrap3-sub1-3 "grep foo-t.c0 sub1/CVS/Entries" \ + "/foo-t.c0/1.1.1.1/[A-Za-z0-9 :]*//" + + dotest binwrap3-sub1-4 "grep foo-t.st sub1/CVS/Entries" \ + "/foo-t.st/1.1.1.1/[A-Za-z0-9 :]*//" + + dotest binwrap3-sub1-5 "grep foo-t.sb sub1/CVS/Entries" \ + "/foo-t.sb/1.1.1.1/[A-Za-z0-9 :]*//" + + dotest binwrap3-sub1-6 "grep bar-t.c1 sub1/CVS/Entries" \ + "/bar-t.c1/1.1.1.1/[A-Za-z0-9 :]*//" + + dotest binwrap3-sub2-1 "grep foo-b.sb sub2/CVS/Entries" \ + "/foo-b.sb/1.1.1.1/[A-Za-z0-9 :]*/-kb/" + + dotest binwrap3-sub2-2 "grep foo-b.st sub2/CVS/Entries" \ + "/foo-b.st/1.1.1.1/[A-Za-z0-9 :]*/-kb/" + + dotest binwrap3-sub2-3 "grep foo-t.c0 sub2/CVS/Entries" \ + "/foo-t.c0/1.1.1.1/[A-Za-z0-9 :]*//" + + dotest binwrap3-sub2-4 "grep foo-t.c1 sub2/CVS/Entries" \ + "/foo-t.c1/1.1.1.1/[A-Za-z0-9 :]*//" + + dotest binwrap3-sub2-5 "grep foo-t.c2 sub2/CVS/Entries" \ + "/foo-t.c2/1.1.1.1/[A-Za-z0-9 :]*//" + + dotest binwrap3-sub2-6 "grep foo-t.c3 sub2/CVS/Entries" \ + "/foo-t.c3/1.1.1.1/[A-Za-z0-9 :]*//" + + dotest binwrap3-sub2-7 "grep foo-t.sb sub2/CVS/Entries" \ + "/foo-t.sb/1.1.1.1/[A-Za-z0-9 :]*//" + + dotest binwrap3-sub2-8 "grep bar-t.st sub2/CVS/Entries" \ + "/bar-t.st/1.1.1.1/[A-Za-z0-9 :]*//" + + dotest binwrap3-subsub1 "grep foo-b.c3 sub2/subsub/CVS/Entries" \ + "/foo-b.c3/1.1.1.1/[A-Za-z0-9 :]*/-kb/" + + dotest binwrap3-subsub2 "grep foo-b.sb sub2/subsub/CVS/Entries" \ + "/foo-b.sb/1.1.1.1/[A-Za-z0-9 :]*/-kb/" + + dotest binwrap3-subsub3 "grep foo-t.c0 sub2/subsub/CVS/Entries" \ + "/foo-t.c0/1.1.1.1/[A-Za-z0-9 :]*//" + + dotest binwrap3-subsub4 "grep foo-t.c1 sub2/subsub/CVS/Entries" \ + "/foo-t.c1/1.1.1.1/[A-Za-z0-9 :]*//" + + dotest binwrap3-subsub5 "grep foo-t.c2 sub2/subsub/CVS/Entries" \ + "/foo-t.c2/1.1.1.1/[A-Za-z0-9 :]*//" + + dotest binwrap3-subsub6 "grep foo-t.st sub2/subsub/CVS/Entries" \ + "/foo-t.st/1.1.1.1/[A-Za-z0-9 :]*//" + + dotest binwrap3-subsub7 "grep foo-t.sb sub2/subsub/CVS/Entries" \ + "/foo-t.sb/1.1.1.1/[A-Za-z0-9 :]*//" + + dotest binwrap3-subsub8 "grep bar-t.c3 sub2/subsub/CVS/Entries" \ + "/bar-t.c3/1.1.1.1/[A-Za-z0-9 :]*//" + + dotest binwrap3-sub2-add1 "grep file1.newbin sub2/CVS/Entries" \ + "/file1.newbin/1.1/[A-Za-z0-9 :]*/-kb/" + dotest binwrap3-sub2-add2 "grep file1.txt sub2/CVS/Entries" \ + "/file1.txt/1.1/[A-Za-z0-9 :]*//" + + # Restore and clean up + dokeep + cd .. + rm -r binwrap3 CVSROOT + cd .. + rm -r wnt + modify_repo rm -rf $CVSROOT_DIRNAME/binwrap3 + CVSWRAPPERS=${CVSWRAPPERS_save} + ;; + + + + mwrap) + # Tests of various wrappers features: + # -m 'COPY' and cvs update: mwrap + # -m 'COPY' and joining: mcopy + # -k: binwrap, binwrap2 + # -t/-f: hasn't been written yet. + # + # Tests of different ways of specifying wrappers: + # CVSROOT/cvswrappers: mwrap + # -W: binwrap, binwrap2 + # .cvswrappers in working directory, local: mcopy + # CVSROOT/cvswrappers, .cvswrappers remote: binwrap3 + # CVSWRAPPERS environment variable: mcopy + + # This test is similar to binfiles-con1; -m 'COPY' specifies + # non-mergeableness the same way that -kb does. + + # On Windows, we can't check out CVSROOT, because the case + # insensitivity means that this conflicts with cvsroot. + mkdir wnt + cd wnt + + dotest mwrap-c1 "${testcvs} -q co CVSROOT" "[UP] CVSROOT${DOTSTAR}" + cd CVSROOT + echo "* -m 'COPY'" >>cvswrappers + dotest mwrap-c2 "${testcvs} -q ci -m wrapper-mod" \ +"$CVSROOT_DIRNAME/CVSROOT/cvswrappers,v <-- cvswrappers +new revision: 1\.[0-9]*; previous revision: 1\.[0-9]* +$SPROG commit: Rebuilding administrative file database" + cd .. + mkdir m1; cd m1 + dotest mwrap-1 "${testcvs} -q co -l ." '' + mkdir first-dir + dotest mwrap-2 "${testcvs} add first-dir" \ +"Directory ${CVSROOT_DIRNAME}/first-dir added to the repository" + cd first-dir + touch aa + dotest mwrap-3 "${testcvs} add aa" \ +"${SPROG} add: scheduling file .aa. for addition +${SPROG} add: use .${SPROG} commit. to add this file permanently" + dotest mwrap-4 "${testcvs} -q ci -m add" \ +"$CVSROOT_DIRNAME/first-dir/aa,v <-- aa +initial revision: 1\.1" + cd ../.. + mkdir m2; cd m2 + dotest mwrap-5 "${testcvs} -q co first-dir" "U first-dir/aa" + cd first-dir + echo "changed in m2" >aa + dotest mwrap-6 "${testcvs} -q ci -m m2-mod" \ +"$CVSROOT_DIRNAME/first-dir/aa,v <-- aa +new revision: 1\.2; previous revision: 1\.1" + cd ../.. + cd m1/first-dir + echo "changed in m1" >aa + dotest mwrap-7 "$testcvs -nq update" \ +"$SPROG update: nonmergeable file needs merge +$SPROG update: revision 1\.2 from repository is now in aa +$SPROG update: file from working directory is now in \.#aa\.1\.1 +C aa" + dotest mwrap-8 "$testcvs -q update" \ +"$SPROG update: nonmergeable file needs merge +$SPROG update: revision 1\.2 from repository is now in aa +$SPROG update: file from working directory is now in \.#aa\.1\.1 +C aa" + dotest mwrap-9 "cat aa" "changed in m2" + dotest mwrap-10 "cat .#aa.1.1" "changed in m1" + + dokeep + restore_adm + cd ../.. + rm -r CVSROOT + rm -r m1 m2 + cd .. + rm -r wnt + modify_repo rm -rf $CVSROOT_DIRNAME/first-dir + ;; + + + + info) + # Administrative file tests. + # Here is a list of where each administrative file is tested: + # loginfo: info + # modules: modules, modules2, modules3 + # cvsignore: ignore + # verifymsg: info + # cvswrappers: mwrap + # taginfo: taginfo + # posttag: posttag + # postadmin: admin + # postwatch: devcom3 + # config: config + # config2: MinCompressionLevel and MaxCompressionLevel in config + + # On Windows, we can't check out CVSROOT, because the case + # insensitivity means that this conflicts with cvsroot. + mkdir wnt + cd wnt + + dotest info-1 "$testcvs -q co CVSROOT" "[UP] CVSROOT${DOTSTAR}" + cd CVSROOT + dotest info-2 "$testcvs -Q tag info-start" + sed -e's/%p/ALL/' <loginfo >tmploginfo + mv tmploginfo loginfo + echo "ALL sh -c \"echo x\${=MYENV}\${=OTHER}y\${=ZEE}=\$USER=\$COMMITID=\$SESSIONID=\$CVSROOT= >>$TESTDIR/testlog; cat >/dev/null\"" >> loginfo + # The following cases test the format string substitution + echo "ALL echo %{} >>$TESTDIR/testlog2; cat >/dev/null" >> loginfo + echo "ALL echo %x >>$TESTDIR/testlog2; cat >/dev/null" >> loginfo + echo "ALL echo % >>$TESTDIR/testlog2; cat >/dev/null" >> loginfo + echo "ALL echo %{sxVv} >>$TESTDIR/testlog2; cat >/dev/null" >> loginfo + echo "ALL echo %{v} >>$TESTDIR/testlog2; cat >/dev/null" >> loginfo + echo "ALL echo %s %s >>$TESTDIR/testlog2; cat >/dev/null" >> loginfo + echo "ALL echo %{V}AX >>$TESTDIR/testlog2; cat >/dev/null" >> loginfo + echo "first-dir echo %sux >>$TESTDIR/testlog2; cat >/dev/null" \ + >> loginfo + sed -e's/^UseNewInfoFmtStrings=yes$/#&/' <config >tmpconfig + mv tmpconfig config + + # Might be nice to move this to crerepos tests; it should + # work to create a loginfo file if you didn't create one + # with "cvs init". + : dotest info-2 "$testcvs add loginfo" \ +"$SPROG add: scheduling file \`loginfo' for addition +$SPROG add: use \`$SPROG commit' to add this file permanently" + + dotest_fail info-3 "$testcvs -q ci -m new-loginfo" \ +"$TESTDIR/cvsroot/CVSROOT/config,v <-- config +new revision: 1\.[0-9]*; previous revision: 1\.[0-9]* +$CVSROOT_DIRNAME/CVSROOT/loginfo,v <-- loginfo +new revision: 1\.[0-9]*; previous revision: 1\.[0-9]* +$SPROG commit: Rebuilding administrative file database +$SPROG commit: loginfo:[0-9]*: no such user variable \${=MYENV} +$SPROG \[commit aborted\]: Unknown format character in info file (''). +Info files are the hook files, verifymsg, taginfo, commitinfo, etc\." + cd .. + + modify_repo mkdir $CVSROOT_DIRNAME/first-dir + dotest info-5 "$testcvs -q co first-dir" '' + cd first-dir + touch file1 + dotest info-6 "$testcvs add file1" \ +"$SPROG add: scheduling file \`file1' for addition +$SPROG add: use \`$SPROG commit' to add this file permanently" + echo "cvs -s OTHER=not-this -s MYENV=env-" >>$HOME/.cvsrc + dotest info-6b "$testcvs -q -s OTHER=value ci -m add-it" \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +initial revision: 1\.1 +$SPROG commit: loginfo:[0-9]*: no such user variable \${=ZEE} +$SPROG commit: warning: Set to use deprecated info format strings\. Establish +compatibility with the new info file format strings (add a temporary .1. in +all info files after each .%. which doesn.t represent a literal percent) +and set UseNewInfoFmtStrings=yes in CVSROOT/config\. After that, convert +individual command lines and scripts to handle the new format at your +leisure\." \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +initial revision: 1\.1 +$SPROG commit: warning: Set to use deprecated info format strings\. Establish +compatibility with the new info file format strings (add a temporary .1. in +all info files after each .%. which doesn.t represent a literal percent) +and set UseNewInfoFmtStrings=yes in CVSROOT/config\. After that, convert +individual command lines and scripts to handle the new format at your +leisure\. +$SPROG commit: loginfo:[0-9]*: no such user variable \${=ZEE}" + echo line0 >>file1 + dotest info-6c "$testcvs -q -sOTHER=foo ci -m mod-it" \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +new revision: 1\.2; previous revision: 1\.1 +$SPROG commit: loginfo:[0-9]*: no such user variable \${=ZEE} +$SPROG commit: warning: Set to use deprecated info format strings\. Establish +compatibility with the new info file format strings (add a temporary .1. in +all info files after each .%. which doesn.t represent a literal percent) +and set UseNewInfoFmtStrings=yes in CVSROOT/config\. After that, convert +individual command lines and scripts to handle the new format at your +leisure\." \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +new revision: 1\.2; previous revision: 1\.1 +$SPROG commit: warning: Set to use deprecated info format strings\. Establish +compatibility with the new info file format strings (add a temporary .1. in +all info files after each .%. which doesn.t represent a literal percent) +and set UseNewInfoFmtStrings=yes in CVSROOT/config\. After that, convert +individual command lines and scripts to handle the new format at your +leisure\. +$SPROG commit: loginfo:[0-9]*: no such user variable \${=ZEE}" + echo line1 >>file1 + dotest info-7 "${testcvs} -q -s OTHER=value -s ZEE=z ci -m mod-it" \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +new revision: 1\.3; previous revision: 1\.2 +$SPROG commit: warning: Set to use deprecated info format strings\. Establish +compatibility with the new info file format strings (add a temporary .1. in +all info files after each .%. which doesn.t represent a literal percent) +and set UseNewInfoFmtStrings=yes in CVSROOT/config\. After that, convert +individual command lines and scripts to handle the new format at your +leisure\." + + cd .. + dotest info-9 "cat $TESTDIR/testlog" \ +"xenv-valueyz=${username}=${commitid}=${commitid}=${CVSROOT_DIRNAME}=" + dotest info-10 "cat $TESTDIR/testlog2" \ +'first-dir +first-dir +first-dir +first-dir file1,,NONE,1.1 +first-dir 1.1 +first-dir file1 %s +first-dir NONEAX +first-dir file1ux +first-dir +first-dir +first-dir +first-dir file1,,1.1,1.2 +first-dir 1.2 +first-dir file1 %s +first-dir 1.1AX +first-dir file1ux +first-dir +first-dir +first-dir +first-dir file1,,1.2,1.3 +first-dir 1.3 +first-dir file1 %s +first-dir 1.2AX +first-dir file1ux' + + # and make sure adding a '1' in the format strings really does ensure + # ensure backwards compatibility. + # + # these tests are identical to the above except for the loginfo setup + # and the project name + cd CVSROOT + dotest info-setup-intfmt-1 "$testcvs -q up -prinfo-start config >config" + dotest info-setup-intfmt-2 "$testcvs -q up -prinfo-start loginfo >loginfo" + sed -e's/%p/ALL/' <loginfo >tmploginfo + mv tmploginfo loginfo + echo "ALL sh -c \"echo x\${=MYENV}\${=OTHER}y\${=ZEE}=\$USER=\$CVSROOT= >>$TESTDIR/testlog; cat >/dev/null\"" >> loginfo + # The following cases test the format string substitution + echo "ALL echo %1{} >>$TESTDIR/testlog2; cat >/dev/null" >> loginfo + echo "ALL echo %1x >>$TESTDIR/testlog2; cat >/dev/null" >> loginfo + echo "ALL echo %1 >>$TESTDIR/testlog2; cat >/dev/null" >> loginfo + echo "ALL echo %1{sxVv} >>$TESTDIR/testlog2; cat >/dev/null" >> loginfo + echo "ALL echo %1{v} >>$TESTDIR/testlog2; cat >/dev/null" >> loginfo + echo "ALL echo %1s %%s >>$TESTDIR/testlog2; cat >/dev/null" >> loginfo + echo "ALL echo %1{V}AX >>$TESTDIR/testlog2; cat >/dev/null" >> loginfo + echo "third-dir echo %1sux >>$TESTDIR/testlog2; cat >/dev/null" \ + >> loginfo + + dotest info-setup-intfmt-2 "${testcvs} -q -s ZEE=garbage ci -m nuke-admin-for-info-intfmt" \ +"$TESTDIR/cvsroot/CVSROOT/config,v <-- config +new revision: 1\.[0-9]*; previous revision: 1\.[0-9]* +$TESTDIR/cvsroot/CVSROOT/loginfo,v <-- loginfo +new revision: 1\.[0-9]*; previous revision: 1\.[0-9]* +$SPROG commit: Rebuilding administrative file database +$SPROG commit: warning: Set to use deprecated info format strings\. Establish +compatibility with the new info file format strings (add a temporary .1. in +all info files after each .%. which doesn.t represent a literal percent) +and set UseNewInfoFmtStrings=yes in CVSROOT/config\. After that, convert +individual command lines and scripts to handle the new format at your +leisure\." + cd .. + + # delete the logs now so the results look more like the last tests + # (they won't include the config file update) + rm ${TESTDIR}/testlog ${TESTDIR}/testlog2 + + modify_repo mkdir $CVSROOT_DIRNAME/third-dir + dotest info-intfmt-5 "${testcvs} -q co third-dir" '' + cd third-dir + touch file1 + dotest info-intfmt-6 "${testcvs} add file1" \ +"${SPROG}"' add: scheduling file `file1'\'' for addition +'"${SPROG}"' add: use .'"${SPROG}"' commit. to add this file permanently' + echo "cvs -s OTHER=not-this -s MYENV=env-" >>$HOME/.cvsrc + dotest info-intfmt-6b "${testcvs} -q -s OTHER=value ci -m add-it" \ +"${TESTDIR}/cvsroot/third-dir/file1,v <-- file1 +initial revision: 1\.1 +${SPROG} commit: loginfo:[0-9]*: no such user variable \${=ZEE} +${SPROG} commit: Using deprecated info format strings\. Convert your scripts to use +the new argument format and remove '1's from your info file format strings\. +${SPROG} commit: Using deprecated info format strings\. Convert your scripts to use +the new argument format and remove '1's from your info file format strings\. +${SPROG} commit: Using deprecated info format strings\. Convert your scripts to use +the new argument format and remove '1's from your info file format strings\. +${SPROG} commit: Using deprecated info format strings\. Convert your scripts to use +the new argument format and remove '1's from your info file format strings\. +${SPROG} commit: Using deprecated info format strings\. Convert your scripts to use +the new argument format and remove '1's from your info file format strings\. +${SPROG} commit: Using deprecated info format strings\. Convert your scripts to use +the new argument format and remove '1's from your info file format strings\. +${SPROG} commit: Using deprecated info format strings\. Convert your scripts to use +the new argument format and remove '1's from your info file format strings\. +${SPROG} commit: Using deprecated info format strings\. Convert your scripts to use +the new argument format and remove '1's from your info file format strings\." + echo line0 >>file1 + dotest info-intfmt-6c "${testcvs} -q -sOTHER=foo ci -m mod-it" \ +"${TESTDIR}/cvsroot/third-dir/file1,v <-- file1 +new revision: 1\.2; previous revision: 1\.1 +${SPROG} commit: loginfo:[0-9]*: no such user variable \${=ZEE} +${SPROG} commit: Using deprecated info format strings\. Convert your scripts to use +the new argument format and remove '1's from your info file format strings\. +${SPROG} commit: Using deprecated info format strings\. Convert your scripts to use +the new argument format and remove '1's from your info file format strings\. +${SPROG} commit: Using deprecated info format strings\. Convert your scripts to use +the new argument format and remove '1's from your info file format strings\. +${SPROG} commit: Using deprecated info format strings\. Convert your scripts to use +the new argument format and remove '1's from your info file format strings\. +${SPROG} commit: Using deprecated info format strings\. Convert your scripts to use +the new argument format and remove '1's from your info file format strings\. +${SPROG} commit: Using deprecated info format strings\. Convert your scripts to use +the new argument format and remove '1's from your info file format strings\. +${SPROG} commit: Using deprecated info format strings\. Convert your scripts to use +the new argument format and remove '1's from your info file format strings\. +${SPROG} commit: Using deprecated info format strings\. Convert your scripts to use +the new argument format and remove '1's from your info file format strings\." + echo line1 >>file1 + dotest info-intfmt-7 "${testcvs} -q -s OTHER=value -s ZEE=z ci -m mod-it" \ +"${TESTDIR}/cvsroot/third-dir/file1,v <-- file1 +new revision: 1\.3; previous revision: 1\.2 +${SPROG} commit: Using deprecated info format strings\. Convert your scripts to use +the new argument format and remove '1's from your info file format strings\. +${SPROG} commit: Using deprecated info format strings\. Convert your scripts to use +the new argument format and remove '1's from your info file format strings\. +${SPROG} commit: Using deprecated info format strings\. Convert your scripts to use +the new argument format and remove '1's from your info file format strings\. +${SPROG} commit: Using deprecated info format strings\. Convert your scripts to use +the new argument format and remove '1's from your info file format strings\. +${SPROG} commit: Using deprecated info format strings\. Convert your scripts to use +the new argument format and remove '1's from your info file format strings\. +${SPROG} commit: Using deprecated info format strings\. Convert your scripts to use +the new argument format and remove '1's from your info file format strings\. +${SPROG} commit: Using deprecated info format strings\. Convert your scripts to use +the new argument format and remove '1's from your info file format strings\. +${SPROG} commit: Using deprecated info format strings\. Convert your scripts to use +the new argument format and remove '1's from your info file format strings\." + + cd .. + dotest info-intfmt-9 "cat $TESTDIR/testlog" "xenv-valueyz=${username}=${TESTDIR}/cvsroot=" + dotest info-intfmt-10 "cat $TESTDIR/testlog2" \ +'third-dir +third-dir +third-dir +third-dir file1,,NONE,1.1 +third-dir 1.1 +third-dir file1 %s +third-dir NONEAX +third-dir file1ux +third-dir +third-dir +third-dir +third-dir file1,,1.1,1.2 +third-dir 1.2 +third-dir file1 %s +third-dir 1.1AX +third-dir file1ux +third-dir +third-dir +third-dir +third-dir file1,,1.2,1.3 +third-dir 1.3 +third-dir file1 %s +third-dir 1.2AX +third-dir file1ux' + + rm ${TESTDIR}/testlog ${TESTDIR}/testlog2 + + # test the new format strings too + cd CVSROOT + dotest info-setup-newfmt-1 "$testcvs -q up -prinfo-start loginfo >loginfo" + echo "ALL sh -c \"echo x\${=MYENV}\${=OTHER}y\${=ZEE}=\$USER=\$CVSROOT= >>$TESTDIR/testlog; cat >/dev/null\" %{sVv}" >> loginfo + # The following cases test the format string substitution + echo "ALL echo %p \"%{sTVv}\" >>$TESTDIR/testlog2; cat >/dev/null" >> loginfo + echo "ALL echo %{v} >>$TESTDIR/testlog2; cat >/dev/null" >> loginfo + echo "ALL echo %s >>$TESTDIR/testlog2; cat >/dev/null" >> loginfo + echo "ALL echo %{V}AX >>$TESTDIR/testlog2; cat >/dev/null" >> loginfo + echo "second-dir echo %sux >>$TESTDIR/testlog2; cat >/dev/null" >> loginfo + dotest info-setup-newfmt-2 "$testcvs -q -s ZEE=garbage ci -m nuke-admin-for-info-newfmt" \ +"${CVSROOT_DIRNAME}/CVSROOT/loginfo,v <-- loginfo +new revision: 1\.[0-9]*; previous revision: 1\.[0-9]* +${SPROG} commit: Rebuilding administrative file database" + cd .. + + # delete the logs now so the results look more like the last tests + # (they won't include the config file update) + rm ${TESTDIR}/testlog ${TESTDIR}/testlog2 + + modify_repo mkdir $CVSROOT_DIRNAME/fourth-dir + dotest info-newfmt-1 "${testcvs} -q co fourth-dir" '' + cd fourth-dir + touch file1 + dotest info-newfmt-2 "${testcvs} add file1" \ +"${SPROG}"' add: scheduling file `file1'\'' for addition +'"${SPROG}"' add: use .'"${SPROG}"' commit. to add this file permanently' + echo "cvs -s OTHER=not-this -s MYENV=env-" >>$HOME/.cvsrc + dotest info-newfmt-3 "$testcvs -q -s OTHER=value ci -m add-it" \ +"$TESTDIR/cvsroot/fourth-dir/file1,v <-- file1 +initial revision: 1\.1 +$SPROG commit: loginfo:[0-9]*: no such user variable \${=ZEE}" + echo line0 >>file1 + dotest info-newfmt-4 "$testcvs -q -sOTHER=foo ci -m mod-it" \ +"$TESTDIR/cvsroot/fourth-dir/file1,v <-- file1 +new revision: 1\.2; previous revision: 1\.1 +$SPROG commit: loginfo:[0-9]*: no such user variable \${=ZEE}" + echo line1 >>file1 + dotest info-newfmt-5 "${testcvs} -q -s OTHER=value -s ZEE=z ci -m mod-it" \ +"${TESTDIR}/cvsroot/fourth-dir/file1,v <-- file1 +new revision: 1\.3; previous revision: 1\.2" + + cd .. + dotest info-newfmt-6 "cat $TESTDIR/testlog" \ +"xenv-valueyz=${username}=${TESTDIR}/cvsroot=" + dotest info-newfmt-7 "cat $TESTDIR/testlog2" \ +'fourth-dir file1 NONE 1\.1 +1\.1 +file1 +NONEAX +fourth-dir file1 1\.1 1\.2 +1\.2 +file1 +1\.1AX +fourth-dir file1 1\.2 1\.3 +1\.3 +file1 +1\.2AX' + + # clean up after newfmt tests + cd CVSROOT + dotest info-cleanup-newfmt-1 "$testcvs -q up -prinfo-start loginfo >loginfo" + dotest info-cleanup-newfmt-2 "$testcvs -q ci -m nuke-loginfo" \ +"$CVSROOT_DIRNAME/CVSROOT/loginfo,v <-- loginfo +new revision: 1\.[0-9]*; previous revision: 1\.[0-9]* +$SPROG commit: Rebuilding administrative file database" + + # clean up the logs + rm ${TESTDIR}/testlog ${TESTDIR}/testlog2 + + # Now test verifymsg + cat >${TESTDIR}/vscript <<EOF +#!${TESTSHELL} +echo vscript "\$@" +if sed 1q < \$1 | grep '^BugId:[ ]*[0-9][0-9]*$' > /dev/null; then + exit 0 +elif sed 1q < \$1 | grep '^BugId:[ ]*new$' > /dev/null; then + echo A new bugid was found. >> \$1 + exit 0 +else + echo "No BugId found." + sleep 1 + exit 1 +fi +EOF + cat >${TESTDIR}/vscript2 <<EOF +#!${TESTSHELL} +echo vscript2 "\$@" +if test -f CVS/Repository; then + repo=\`cat CVS/Repository\` +else + repo=\`pwd\` +fi +echo \$repo +if echo "\$repo" |grep yet-another/ >/dev/null 2>&1; then + exit 1 +else + exit 0 +fi +EOF + # Grumble, grumble, mumble, search for "Cygwin". + if test -n "$remotehost"; then + $CVS_RSH $remotehost "chmod +x ${TESTDIR}/vscript*" + else + chmod +x ${TESTDIR}/vscript* + fi + echo "^first-dir/yet-another\\(/\\|\$\\) ${TESTDIR}/vscript2 %l %{sV}" >verifymsg + echo "^first-dir\\(/\\|\$\\) ${TESTDIR}/vscript %l %{sV}" >>verifymsg + echo "^missing-script\$ ${TESTDIR}/bogus %l" >>verifymsg + echo "^missing-var\$ ${TESTDIR}/vscript %l \${=Bogus}" >>verifymsg + # first test the directory independant verifymsg + dotest info-v1 "${testcvs} -q ci -m add-verification" \ +"$CVSROOT_DIRNAME/CVSROOT/verifymsg,v <-- verifymsg +new revision: 1\.[0-9]*; previous revision: 1\.[0-9]* +$SPROG commit: Rebuilding administrative file database" + + cd ../first-dir + echo line2 >>file1 + dotest_fail info-v2 "${testcvs} -q ci -m bogus" \ +"vscript $tempname file1 1\.3 +No BugId found\. +${SPROG} \[commit aborted\]: Message verification failed" + + cat >${TESTDIR}/comment.tmp <<EOF +BugId: 42 +and many more lines after it +EOF + dotest info-v3 "${testcvs} -q ci -F ${TESTDIR}/comment.tmp" \ +"vscript $tempname file1 1\.3 +$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +new revision: 1\.4; previous revision: 1\.3" + rm ${TESTDIR}/comment.tmp + + cd .. + mkdir another-dir + cd another-dir + touch file2 + dotest_fail info-v4 \ + "${testcvs} import -m bogus first-dir/another x y" \ +"vscript $tempname - Imported sources NONE +No BugId found\. +${SPROG} \[import aborted\]: Message verification failed" + + # now verify that directory dependent verifymsgs work + dotest info-v5 \ + "${testcvs} import -m bogus first-dir/yet-another x y" \ +"vscript2 $tempname - Imported sources NONE +$TESTDIR/wnt/another-dir +N first-dir/yet-another/file2 + +No conflicts created by this import" \ +"vscript2 $tempname - Imported sources NONE +$CVSROOT_DIRNAME/first-dir/yet-another +N first-dir/yet-another/file2 + +No conflicts created by this import" + + # FIXCVS + # + # note that in the local case the error message is the same as + # info-v5 + # + # This means that the verifymsg scripts cannot reliably and + # consistantly obtain information on which directory is being + # committed to. Thus it is currently useless for them to be + # running in every dir. They should either be run once or + # directory information should be passed. + if $remote; then + dotest_fail info-v6r \ + "${testcvs} import -m bogus first-dir/yet-another/and-another x y" \ +"vscript2 $tempname - Imported sources NONE +$CVSROOT_DIRNAME/first-dir/yet-another/and-another +$SPROG \[import aborted\]: Message verification failed" + else + dotest info-v6 \ + "${testcvs} import -m bogus first-dir/yet-another/and-another x y" \ +"vscript2 $tempname - Imported sources NONE +$TESTDIR/wnt/another-dir +N first-dir/yet-another/and-another/file2 + +No conflicts created by this import" + fi + + # check that errors invoking the script cause verification failure + # + # The second text below occurs on Cygwin, where I assume execvp + # does not return to let CVS print the error message when its + # argument does not exist. + dotest_fail info-v7 "${testcvs} import -m bogus missing-script x y" \ +"${SPROG} import: cannot exec ${TESTDIR}/bogus: No such file or directory +${SPROG} \[import aborted\]: Message verification failed" \ +"${SPROG} \[import aborted\]: Message verification failed" + + dotest_fail info-v8 "${testcvs} import -m bogus missing-var x y" \ +"${SPROG} import: verifymsg:4: no such user variable \${=Bogus} +${SPROG} \[import aborted\]: Message verification failed" + + rm file2 + cd .. + rmdir another-dir + + cd CVSROOT + echo "RereadLogAfterVerify=always" >>config + dotest info-rereadlog-1 "${testcvs} -q ci -m add-RereadLogAfterVerify=always" \ +"$CVSROOT_DIRNAME/CVSROOT/config,v <-- config +new revision: 1\.[0-9]*; previous revision: 1\.[0-9]* +$SPROG commit: Rebuilding administrative file database" + cd ../first-dir + echo line3 >>file1 + cat >${TESTDIR}/comment.tmp <<EOF +BugId: new +See what happens next. +EOF + dotest info-reread-2 "${testcvs} -q ci -F ${TESTDIR}/comment.tmp" \ +"vscript $tempname file1 1\.4 +$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +new revision: 1\.5; previous revision: 1\.4" + dotest info-reread-3 "${testcvs} -q log -N -r1.5 file1" " +.* +BugId: new +See what happens next. +A new bugid was found. +=============================================================================" + + cd ../CVSROOT + grep -v "RereadLogAfterVerify" config > config.new + mv config.new config + echo "RereadLogAfterVerify=stat" >>config + dotest info-reread-4 \ +"$testcvs -q ci -m add-RereadLogAfterVerify=stat" \ +"$CVSROOT_DIRNAME/CVSROOT/config,v <-- config +new revision: 1\.[0-9]*; previous revision: 1\.[0-9]* +$SPROG commit: Rebuilding administrative file database" + cd ../first-dir + echo line4 >>file1 + cat >${TESTDIR}/comment.tmp <<EOF +BugId: new +See what happens next with stat. +EOF + dotest info-reread-5 "${testcvs} -q ci -F ${TESTDIR}/comment.tmp" \ +"vscript $tempname file1 1\.5 +$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +new revision: 1\.6; previous revision: 1\.5" + dotest info-reread-6 "${testcvs} -q log -N -r1.6 file1" " +.* +BugId: new +See what happens next with stat. +A new bugid was found. +=============================================================================" + + cd ../CVSROOT + grep -v "RereadLogAfterVerify" config > config.new + mv config.new config + echo "RereadLogAfterVerify=never" >>config + dotest info-reread-7 \ +"$testcvs -q ci -m add-RereadLogAfterVerify=never" \ +"$CVSROOT_DIRNAME/CVSROOT/config,v <-- config +new revision: 1\.[0-9]*; previous revision: 1\.[0-9]* +$SPROG commit: Rebuilding administrative file database" + cd ../first-dir + echo line5 >>file1 + cat >${TESTDIR}/comment.tmp <<EOF +BugId: new +See what happens next. +EOF + dotest info-reread-8 "${testcvs} -q ci -F ${TESTDIR}/comment.tmp" \ +"vscript $tempname file1 1\.6 +$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +new revision: 1\.7; previous revision: 1\.6" + dotest info-reread-6 "${testcvs} -q log -N -r1.7 file1" " +.* +BugId: new +See what happens next. +=============================================================================" + + cd ../CVSROOT + dotest info-reread-cleanup-1 "$testcvs -q up -prinfo-start config >config" + # Append the NULL format string until we remove the deprecation + # warning for lack of format strings. + echo 'DEFAULT false %n' >verifymsg + echo 'DEFAULT true %n' >>verifymsg + dotest info-multdef "${testcvs} -q ci -m multdef" \ +"$CVSROOT_DIRNAME/CVSROOT/config,v <-- config +new revision: 1\.[0-9]*; previous revision: 1\.[0-9]* +$CVSROOT_DIRNAME/CVSROOT/verifymsg,v <-- verifymsg +new revision: 1\.[0-9]*; previous revision: 1\.[0-9]* +$SPROG commit: Rebuilding administrative file database" + + cd ../CVSROOT + dotest info-reread--cleanup-1 \ +"$testcvs -q up -prinfo-start verifymsg >verifymsg" + dotest info-cleanup-verifymsg "$testcvs -q ci -m nuke-verifymsg" \ +"$SPROG commit: Multiple .DEFAULT. lines (1 and 2) in verifymsg file +$CVSROOT_DIRNAME/CVSROOT/verifymsg,v <-- verifymsg +new revision: 1\.[0-9]*; previous revision: 1\.[0-9]* +$SPROG commit: Rebuilding administrative file database" + + dokeep + rm ${TESTDIR}/vscript* + cd .. + + dotest info-cleanup-0 "$testcvs -n release -d CVSROOT" \ +"You have \[0\] altered files in this repository\." + + dotest info-cleanup-1 \ +"echo yes |${testcvs} -q release -d CVSROOT >/dev/null" + dotest info-cleanup-2 \ +"echo yes |${testcvs} -q release -d first-dir >/dev/null" + dotest info-cleanup-3 \ +"echo yes |${testcvs} -q release -d third-dir >/dev/null" + dotest info-cleanup-4 \ +"echo yes |${testcvs} -q release -d fourth-dir >/dev/null" + + dokeep + cd .. + rm -r wnt + rm $HOME/.cvsrc + modify_repo rm -rf $CVSROOT_DIRNAME/first-dir \ + $CVSROOT_DIRNAME/third-dir \ + $CVSROOT_DIRNAME/fourth-dir + ;; + + + + taginfo) + # Tests of the CVSROOT/taginfo file. See the comment at the + # "info" tests for a full list of administrative file tests. + + # all the oldfmt stuff can come out once we finish deprecating + # the old info file command line format stuff. + # + # grep the code for SUPPORT_OLD_INFO_FMT_STRINGS and see the stuff + # in configure.in about oldinfoformatsupport + + mkdir 1; cd 1 + dotest taginfo-init-1 "$testcvs -q co CVSROOT" "U CVSROOT/$DOTSTAR" + cd CVSROOT + dotest taginfo-init-2 "$testcvs -Q tag taginfo-start" + cat >$TESTDIR/1/loggit <<EOF +#!$TESTSHELL +if test "\$1" = rejectme; then + exit 1 +else + echo "\$@" >>$TESTDIR/1/taglog + exit 0 +fi +EOF + # #^@&!^@ Cygwin. + if test -n "$remotehost"; then + $CVS_RSH $remotehost "chmod +x ${TESTDIR}/1/loggit" + else + chmod +x ${TESTDIR}/1/loggit + fi + echo "ALL ${TESTDIR}/1/loggit" >>taginfo + sed -e's/^UseNewInfoFmtStrings=yes$/#&/' <config >tmpconfig + mv tmpconfig config + sed -e's/%p/ALL/' <loginfo >tmploginfo + mv tmploginfo loginfo + dotest taginfo-2 "${testcvs} -q ci -m check-in-taginfo" \ +"$TESTDIR/cvsroot/CVSROOT/config,v <-- config +new revision: 1\.[0-9]*; previous revision: 1\.[0-9]* +$CVSROOT_DIRNAME/CVSROOT/loginfo,v <-- loginfo +new revision: 1\.[0-9]*; previous revision: 1\.[0-9]* +$CVSROOT_DIRNAME/CVSROOT/taginfo,v <-- taginfo +new revision: 1\.[0-9]*; previous revision: 1\.[0-9]* +$SPROG commit: Rebuilding administrative file database" + cd .. + + # taginfo-3 used to rely on the top-level CVS directory + # being created to add "first-dir" to the repository. Since + # that won't happen anymore, we create the directory in the + # repository. + modify_repo mkdir $CVSROOT_DIRNAME/first-dir + dotest taginfo-3 "$testcvs -q co first-dir" + + cd first-dir + echo first >file1 + dotest taginfo-4 "${testcvs} add file1" \ +"${SPROG} add: scheduling file .file1. for addition +${SPROG} add: use .${SPROG} commit. to add this file permanently" + dotest taginfo-5 "${testcvs} -q ci -m add-it" \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +initial revision: 1\.1" \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +initial revision: 1\.1 +$SPROG commit: warning: Set to use deprecated info format strings\. Establish +compatibility with the new info file format strings (add a temporary '1' in +all info files after each '%' which doesn't represent a literal percent) +and set UseNewInfoFmtStrings=yes in CVSROOT/config\. After that, convert +individual command lines and scripts to handle the new format at your +leisure\." + dotest taginfo-6 "${testcvs} -q tag tag1" \ +"${SPROG} tag: warning: taginfo line contains no format strings: + \"${TESTDIR}/1/loggit\" +Filling in old defaults ('%t %o %p %{sv}'), but please be aware that this +usage is deprecated\. +T file1" + dotest taginfo-7 "${testcvs} -q tag -b br" \ +"${SPROG} tag: warning: taginfo line contains no format strings: + \"${TESTDIR}/1/loggit\" +Filling in old defaults ('%t %o %p %{sv}'), but please be aware that this +usage is deprecated\. +T file1" + dotest taginfo-8 "$testcvs -q update -r br" + echo add text on branch >>file1 + dotest taginfo-9 "${testcvs} -q ci -m modify-on-br" \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +new revision: 1\.1\.2\.1; previous revision: 1\.1" \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +new revision: 1\.1\.2\.1; previous revision: 1\.1 +$SPROG commit: warning: Set to use deprecated info format strings\. Establish +compatibility with the new info file format strings (add a temporary '1' in +all info files after each '%' which doesn't represent a literal percent) +and set UseNewInfoFmtStrings=yes in CVSROOT/config\. After that, convert +individual command lines and scripts to handle the new format at your +leisure\." + dotest taginfo-10 "${testcvs} -q tag -F -c brtag" \ +"${SPROG} tag: warning: taginfo line contains no format strings: + \"${TESTDIR}/1/loggit\" +Filling in old defaults ('%t %o %p %{sv}'), but please be aware that this +usage is deprecated\. +T file1" + + dotest_fail taginfo-11 "${testcvs} -q tag rejectme" \ +"${SPROG} tag: warning: taginfo line contains no format strings: + \"${TESTDIR}/1/loggit\" +Filling in old defaults ('%t %o %p %{sv}'), but please be aware that this +usage is deprecated\. +${SPROG} tag: Pre-tag check failed +${SPROG} \[tag aborted\]: correct the above errors first!" + + # When we are using taginfo to allow/disallow, it would be + # convenient to be able to use "cvs -n tag" to test whether + # the allow/disallow functionality is working as expected. + dotest taginfo-12 "${testcvs} -nq tag rejectme" \ +"${SPROG} tag: warning: taginfo line contains no format strings: + \"${TESTDIR}/1/loggit\" +Filling in old defaults ('%t %o %p %{sv}'), but please be aware that this +usage is deprecated\. +T file1" + + # But when taginfo is used for logging, it is a pain for -n + # to call taginfo, since taginfo doesn't know whether -n was + # specified or not. + dotest taginfo-13 "${testcvs} -nq tag would-be-tag" \ +"${SPROG} tag: warning: taginfo line contains no format strings: + \"${TESTDIR}/1/loggit\" +Filling in old defaults ('%t %o %p %{sv}'), but please be aware that this +usage is deprecated\. +T file1" + + # Deleting: the cases are basically either the tag existed, + # or it didn't exist. + dotest taginfo-14 "${testcvs} -q tag -d tag1" \ +"${SPROG} tag: warning: taginfo line contains no format strings: + \"${TESTDIR}/1/loggit\" +Filling in old defaults ('%t %o %p %{sv}'), but please be aware that this +usage is deprecated\. +D file1" + dotest taginfo-15 "${testcvs} -q tag -d tag1" \ +"${SPROG} tag: warning: taginfo line contains no format strings: + \"${TESTDIR}/1/loggit\" +Filling in old defaults ('%t %o %p %{sv}'), but please be aware that this +usage is deprecated\." + + # Likewise with rtag. + dotest taginfo-16 "${testcvs} -q rtag tag1 first-dir" \ +"${SPROG} rtag: warning: taginfo line contains no format strings: + \"${TESTDIR}/1/loggit\" +Filling in old defaults ('%t %o %p %{sv}'), but please be aware that this +usage is deprecated\." + dotest taginfo-17 "${testcvs} -q rtag -d tag1 first-dir" \ +"${SPROG} rtag: warning: taginfo line contains no format strings: + \"${TESTDIR}/1/loggit\" +Filling in old defaults ('%t %o %p %{sv}'), but please be aware that this +usage is deprecated\." + dotest taginfo-18 "${testcvs} -q rtag -d tag1 first-dir" \ +"${SPROG} rtag: warning: taginfo line contains no format strings: + \"${TESTDIR}/1/loggit\" +Filling in old defaults ('%t %o %p %{sv}'), but please be aware that this +usage is deprecated\." + + # The "br" example should be passing 1.1.2 or 1.1.0.2. + # But it turns out that is very hard to implement, since + # check_fileproc doesn't know what branch number it will + # get. Probably the whole thing should be re-architected + # so that taginfo only allows/denies tagging, and a new + # hook, which is done from tag_fileproc, does logging. + # That would solve this, some more subtle races, and also + # the fact that it is nice for users to run "-n tag foo" to + # see whether a tag would be allowed. Failing that, + # I suppose passing "1.1.branch" or "branch" for "br" + # would be an improvement. + dotest taginfo-examine-1 "cat ${TESTDIR}/1/taglog" \ +"tag1 add first-dir file1 1\.1 +br add first-dir file1 1\.1 +brtag mov first-dir file1 1\.1\.2\.1 +tag1 del first-dir file1 1\.1 +tag1 del first-dir +tag1 add first-dir file1 1\.1 +tag1 del first-dir file1 1\.1 +tag1 del first-dir" + + # now that we've tested the default operation, try a new + # style fmt string. + rm $TESTDIR/1/taglog + cd .. + cd CVSROOT + dotest taginfo-newfmt-init-1 \ +"$testcvs -q up -prtaginfo-start taginfo >taginfo" + echo "ALL $TESTDIR/1/loggit %r %t %o %b %p %{sTVv}" >>taginfo + dotest taginfo-newfmt-init-2 "$testcvs -q ci -m check-in-taginfo" \ +"$TESTDIR/cvsroot/CVSROOT/taginfo,v <-- taginfo +new revision: 1\.[0-9]*; previous revision: 1\.[0-9]* +$SPROG commit: Rebuilding administrative file database" \ +"$TESTDIR/cvsroot/CVSROOT/taginfo,v <-- taginfo +new revision: 1\.[0-9]*; previous revision: 1\.[0-9]* +$SPROG commit: Rebuilding administrative file database +$SPROG commit: warning: Set to use deprecated info format strings\. Establish +compatibility with the new info file format strings (add a temporary '1' in +all info files after each '%' which doesn't represent a literal percent) +and set UseNewInfoFmtStrings=yes in CVSROOT/config\. After that, convert +individual command lines and scripts to handle the new format at your +leisure\." + + cat >${TESTDIR}/1/loggit <<EOF +#!${TESTSHELL} +if test "\$1" = rejectme; then + exit 1 +else + while test "\$#" -gt 0; do + echo "\$1" >>${TESTDIR}/1/taglog + shift + done + exit 0 +fi +EOF + + cd .. + cd first-dir + dotest taginfo-newfmt-2 "${testcvs} -q update -A" "[UP] file1" + echo "bull pucky" >'file 2' + dotest taginfo-newfmt-2b "${testcvs} add 'file 2'" \ +"${SPROG} add: scheduling file .file 2. for addition +${SPROG} add: use .${SPROG} commit. to add this file permanently" + dotest taginfo-newfmt-2c "$testcvs -q ci -m add-it" \ +"$TESTDIR/cvsroot/first-dir/file 2,v <-- file 2 +initial revision: 1\.1" \ +"$TESTDIR/cvsroot/first-dir/file 2,v <-- file 2 +initial revision: 1\.1 +$SPROG commit: warning: Set to use deprecated info format strings\. Establish +compatibility with the new info file format strings (add a temporary '1' in +all info files after each '%' which doesn't represent a literal percent) +and set UseNewInfoFmtStrings=yes in CVSROOT/config\. After that, convert +individual command lines and scripts to handle the new format at your +leisure\." + + dotest taginfo-newfmt-3 "${testcvs} -q tag tag1" \ +"T file 2 +T file1" + dotest taginfo-newfmt-4 "${testcvs} -q tag tag3" \ +"T file 2 +T file1" + dotest taginfo-newfmt-5 "$testcvs -q tag -rtag1 tag4" \ +"T file 2 +T file1" + + dotest taginfo-newfmt-examine-1 "cat ${TESTDIR}/1/taglog" \ +"$TESTDIR/cvsroot +tag1 +add +N +first-dir +file 2 + +NONE +1\.1 +file1 + +NONE +1\.1 +$TESTDIR/cvsroot +tag3 +add +N +first-dir +file 2 + +NONE +1\.1 +file1 + +NONE +1\.1 +$TESTDIR/cvsroot +tag4 +add +N +first-dir +file 2 +tag1 +NONE +1\.1 +file1 +tag1 +NONE +1\.1" + + # now update to use the new format strings (really, disable support + # of the old format) and run the whole gamut of tests again. + rm ${TESTDIR}/1/taglog + cd .. + cd CVSROOT + cat >${TESTDIR}/1/loggit <<EOF +#!${TESTSHELL} +if test "\$1" = rejectme; then + exit 1 +else + echo "\$@" >>${TESTDIR}/1/taglog + exit 0 +fi +EOF + dotest taginfo-newfmt-init-7 \ +"$testcvs -q up -prtaginfo-start taginfo >taginfo" + echo "ALL ${TESTDIR}/1/loggit %{t} %b %{o} %p %{sTVv}" >>taginfo + echo "UseNewInfoFmtStrings=yes" >>config + dotest taginfo-newfmt-7 "$testcvs -q ci -m check-in-taginfo" \ +"$TESTDIR/cvsroot/CVSROOT/config,v <-- config +new revision: 1\.[0-9]*; previous revision: 1\.[0-9]* +$TESTDIR/cvsroot/CVSROOT/taginfo,v <-- taginfo +new revision: 1\.[0-9]*; previous revision: 1\.[0-9]* +$SPROG commit: Rebuilding administrative file database" \ +"$TESTDIR/cvsroot/CVSROOT/config,v <-- config +new revision: 1\.[0-9]*; previous revision: 1\.[0-9]* +$TESTDIR/cvsroot/CVSROOT/taginfo,v <-- taginfo +new revision: 1\.[0-9]*; previous revision: 1\.[0-9]* +$SPROG commit: Rebuilding administrative file database +$SPROG commit: warning: Set to use deprecated info format strings\. Establish +compatibility with the new info file format strings (add a temporary '1' in +all info files after each '%' which doesn't represent a literal percent) +and set UseNewInfoFmtStrings=yes in CVSROOT/config\. After that, convert +individual command lines and scripts to handle the new format at your +leisure\." + + cd ../first-dir + dotest taginfo-newfmt-8 "${testcvs} -q tag tag1" "" + mkdir sdir + dotest taginfo-newfmt-8b "${testcvs} -q add sdir" \ +"Directory ${TESTDIR}/cvsroot/first-dir/sdir added to the repository" + touch sdir/file3 + dotest taginfo-newfmt-8c "${testcvs} -q add sdir/file3" \ +"${SPROG} add: use .${SPROG} commit. to add this file permanently" + dotest taginfo-newfmt-8d "${testcvs} -q ci -m added-sdir" \ +"${TESTDIR}/cvsroot/first-dir/sdir/file3,v <-- sdir/file3 +initial revision: 1\.1" + dotest taginfo-newfmt-9 "${testcvs} -q tag -b br" \ +"T file 2 +W file1 : br already exists on branch 1\.1\.2\.1 : NOT MOVING tag to branch 1\.1\.0\.4 +T sdir/file3" + dotest taginfo-newfmt-10 "${testcvs} -q update -r br" "[UP] file1" + echo add more text on branch >>file1 + dotest taginfo-newfmt-11 "${testcvs} -q ci -m modify-on-br" \ +"${TESTDIR}/cvsroot/first-dir/file1,v <-- file1 +new revision: 1\.1\.2\.2; previous revision: 1\.1\.2\.1" + dotest taginfo-newfmt-12 "${testcvs} -q tag -F -c brtag" \ +"T file 2 +T file1 +T sdir/file3" + + # we are being called once for each directory. I'm not sure + # I like this, but I'm also not sure how hard it would be to change, + # It seems like it would be more trouble than it is really worth + # to let a partial tag go through... + dotest_fail taginfo-newfmt-13 "${testcvs} -q tag rejectme" \ +"${SPROG} tag: Pre-tag check failed +${SPROG} tag: Pre-tag check failed +${SPROG} \[tag aborted\]: correct the above errors first!" + + # When we are using taginfo to allow/disallow, it would be + # convenient to be able to use "cvs -n tag" to test whether + # the allow/disallow functionality is working as expected. + # see the comment before taginfo-newfmt-15 for notes on + # pretag and posttag proc + dotest taginfo-newfmt-14 "${testcvs} -nq tag rejectme" \ +"T file 2 +T file1 +T sdir/file3" + + # But when taginfo is used for logging, it is a pain for -n + # to call taginfo, since taginfo doesn't know whether -n was + # specified or not. (this could be fixed pretty easily now + # with a new fmt string. i suppose it would be better to + # have a pretag proc and a posttag proc, though.) + dotest taginfo-newfmt-15 "${testcvs} -nq tag would-be-tag" \ +"T file 2 +T file1 +T sdir/file3" + + # Deleting: the cases are basically either the tag existed, + # or it didn't exist. + dotest taginfo-newfmt-16 "${testcvs} -q tag -d tag1" \ +"D file 2 +D file1" + dotest taginfo-newfmt-17 "${testcvs} -q tag -d tag1" "" + + # Likewise with rtag. + dotest taginfo-newfmt-18 "${testcvs} -q rtag tag1 first-dir" "" + dotest taginfo-newfmt-19 "${testcvs} -q rtag -d tag1 first-dir" "" + dotest taginfo-newfmt-20 "${testcvs} -q rtag -d tag1 first-dir" "" + + # The "br" example should be passing 1.1.2 or 1.1.0.2. + # But it turns out that is very hard to implement, since + # check_fileproc doesn't know what branch number it will + # get. Probably the whole thing should be re-architected + # so that taginfo only allows/denies tagging, and a new + # hook, which is done from tag_fileproc, does logging. + # That would solve this, some more subtle races, and also + # the fact that it is nice for users to run "-n tag foo" to + # see whether a tag would be allowed. Failing that, + # I suppose passing "1.1.branch" or "branch" for "br" + # would be an improvement. + dotest taginfo-newfmt-examine-2 "cat ${TESTDIR}/1/taglog" \ +"tag1 N add first-dir +br T add first-dir file 2 NONE 1\.1 +br T add first-dir/sdir file3 NONE 1\.1 +brtag N mov first-dir file 2 br NONE 1\.1 file1 br 1\.1\.2\.1 1\.1\.2\.2 +brtag N mov first-dir/sdir file3 br NONE 1\.1 +tag1 ? del first-dir file 2 br 1\.1 1\.1 file1 br 1\.1 1\.1 +tag1 ? del first-dir/sdir +tag1 ? del first-dir +tag1 ? del first-dir/sdir +tag1 N add first-dir file 2 NONE 1\.1 file1 NONE 1\.1 +tag1 N add first-dir/sdir file3 NONE 1\.1 +tag1 ? del first-dir file 2 1\.1 1\.1 file1 1\.1 1\.1 +tag1 ? del first-dir/sdir file3 1\.1 1\.1 +tag1 ? del first-dir +tag1 ? del first-dir/sdir" + + dokeep + restore_adm + cd ../.. + rm -r 1 + modify_repo rm -rf $CVSROOT_DIRNAME/first-dir + ;; + + + + posttag) + # Tests of the CVSROOT/taginfo file. See the comment at the + # "info" tests for a full list of administrative file tests. + + mkdir 1; cd 1 + + dotest posttag-init-1 "$testcvs -q co CVSROOT" "U CVSROOT/$DOTSTAR" + + # now that we've tested the default operation, try a new + # style fmt string. + cd CVSROOT + echo "ALL $TESTDIR/1/loggit %r %t %o %b %p %{sVv}" >posttag + dotest posttag-init-2 "$testcvs -q ci -m check-in-taginfo" \ +"$TESTDIR/cvsroot/CVSROOT/posttag,v <-- posttag +new revision: 1\.[0-9]*; previous revision: 1\.[0-9]* +$SPROG commit: Rebuilding administrative file database" + cd .. + + cat >$TESTDIR/1/loggit <<EOF +#!$TESTSHELL +if test "\$1" = rejectme; then + error=: +else + error=false +fi + +while [ -n "\$1" ]; do + echo "\$1" >>$TESTDIR/1/taglog + shift +done + +if \$error; then + exit 1 +fi +exit 0 +EOF + # #^@&!^@ Cygwin. + if test -n "$remotehost"; then + $CVS_RSH $remotehost "chmod +x $TESTDIR/1/loggit" + else + chmod +x $TESTDIR/1/loggit + fi + + modify_repo mkdir $CVSROOT_DIRNAME/first-dir + dotest posttag-init-3 "$testcvs -q co first-dir" + + cd first-dir + echo first >file1 + echo "bull pucky" >'file 2' + dotest posttag-init-4 "$testcvs add file1 'file 2'" \ +"$SPROG add: scheduling file \`file1' for addition +$SPROG add: scheduling file \`file 2' for addition +$SPROG add: use \`$SPROG commit' to add these files permanently" + dotest posttag-init-5 "$testcvs -q ci -m add-it" \ +"$CVSROOT_DIRNAME/first-dir/file 2,v <-- file 2 +initial revision: 1\.1 +$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +initial revision: 1\.1" + + dotest posttag-1 "$testcvs -q tag tag1" \ +"T file 2 +T file1" + dotest posttag-2 "$testcvs -q tag tag3" \ +"T file 2 +T file1" + + dotest posttag-3 "$testcvs -q tag rejectme" \ +"T file 2 +T file1" + + dotest posttag-4 "$testcvs -q tag -d rejectme" \ +"D file 2 +D file1" + + dotest posttag-examine-1 "cat $TESTDIR/1/taglog" \ +"$TESTDIR/cvsroot +tag1 +add +N +first-dir +file 2 +NONE +1\.1 +file1 +NONE +1\.1 +$TESTDIR/cvsroot +tag3 +add +N +first-dir +file 2 +NONE +1\.1 +file1 +NONE +1\.1 +$TESTDIR/cvsroot +rejectme +add +N +first-dir +file 2 +NONE +1.1 +file1 +NONE +1.1 +$TESTDIR/cvsroot +rejectme +del +? +first-dir +file 2 +1.1 +1.1 +file1 +1.1 +1.1" + + dokeep + cd ../.. + restore_adm + rm -r 1 + modify_repo rm -rf $CVSROOT_DIRNAME/first-dir + ;; + + + + config) + # Tests of the CVSROOT/config file. See the comment at the + # "info" tests for a full list of administrative file tests. + + # See note in keywordexpand about config errors from a proxied + # primary. + if $noredirect; then + notnoredirect config + continue + fi + + # On Windows, we can't check out CVSROOT, because the case + # insensitivity means that this conflicts with cvsroot. + mkdir wnt + cd wnt + + dotest config-init-1 "$testcvs -q co CVSROOT" "U CVSROOT/$DOTSTAR" + cd CVSROOT + dotest config-init-2 "$testcvs -Q tag config-start" + echo 'bogus line' >>config + dotest config-3 "$testcvs -q ci -m change-to-bogus-line" \ +"$CVSROOT_DIRNAME/CVSROOT/config,v <-- config +new revision: 1\.[0-9]*; previous revision: 1\.[0-9]* +$SPROG commit: Rebuilding administrative file database" + dotest config-3a "$testcvs -Q update -jHEAD -jconfig-start" \ +"$SPROG [a-z]*: $SECONDARY_CVSROOT_DIRNAME/CVSROOT/config \[[1-9][0-9]*\]: syntax error: missing \`=' between keyword and value +RCS file: $CVSROOT_DIRNAME/CVSROOT/config,v +retrieving revision 1.[0-9]* +retrieving revision 1.[0-9]* +Merging differences between 1.[0-9]* and 1.[0-9]* into config" + echo 'BogusOption=yes' >>config + if $proxy; then + dotest config-4p "$testcvs -q ci -m change-to-bogus-opt" \ +"$SPROG [a-z]*: $SECONDARY_CVSROOT_DIRNAME/CVSROOT/config \[99\]: syntax error: missing \`=' between keyword and value +$SPROG [a-z]*: $CVSROOT_DIRNAME/CVSROOT/config \[99\]: syntax error: missing \`=' between keyword and value +$CVSROOT_DIRNAME/CVSROOT/config,v <-- config +new revision: 1\.[0-9]*; previous revision: 1\.[0-9]* +$SPROG commit: Rebuilding administrative file database" + else + dotest config-4 "$testcvs -q ci -m change-to-bogus-opt" \ +"$SPROG [a-z]*: $SECONDARY_CVSROOT_DIRNAME/CVSROOT/config \[[1-9][0-9]*\]: syntax error: missing \`=' between keyword and value +$CVSROOT_DIRNAME/CVSROOT/config,v <-- config +new revision: 1\.[0-9]*; previous revision: 1\.[0-9]* +$SPROG commit: Rebuilding administrative file database" + fi + + if $proxy; then + : # FIXME: don't try in proxy mode + else + # Now test the HistoryLogPath and HistorySearchPath options. + mkdir $TESTDIR/historylogs + echo >config \ + 'HistoryLogPath=$CVSROOT/../historylogs/%Y-%m-%d-%H-%M-%S' + echo 'HistorySearchPath=$CVSROOT/../historylogs/*' >>config + + # The warning is left over from the previous test. + dotest config-5 "$testcvs -q ci -m set-HistoryLogPath" \ +"$SPROG [a-z]*: $CVSROOT_DIRNAME/CVSROOT/config \[98\]: unrecognized keyword \`BogusOption' +$CVSROOT_DIRNAME/CVSROOT/config,v <-- config +new revision: 1\.[0-9]*; previous revision: 1\.[0-9]* +$SPROG commit: Rebuilding administrative file database" + + echo '# noop' >> config + dotest config-6 "$testcvs -q ci -mlog-commit" \ +"$CVSROOT_DIRNAME/CVSROOT/config,v <-- config +new revision: 1\.[0-9]*; previous revision: 1\.[0-9]* +$SPROG commit: Rebuilding administrative file database" + + sleep 1 + echo '# noop' >> config + dotest config-7 "$testcvs -q ci -mlog-commit" \ +"$CVSROOT_DIRNAME/CVSROOT/config,v <-- config +new revision: 1\.[0-9]*; previous revision: 1\.[0-9]* +$SPROG commit: Rebuilding administrative file database" + + # The log entry was intentionally split across multiple files. + dotest config-8 "ls -l $TESTDIR/historylogs/*" \ +"-rw-rw-r--.*$TESTDIR/historylogs/2[0-9][0-9][0-9]-[01][0-9]-[0-3][0-9]-[0-2][0-9]-[0-5][0-9]-[0-5][0-9] +-rw-rw-r--.*$TESTDIR/historylogs/2[0-9][0-9][0-9]-[01][0-9]-[0-3][0-9]-[0-2][0-9]-[0-5][0-9]-[0-5][0-9]" + + # Should still see both commits. + if $remote; then + dotest config-9r "$testcvs history -ea" \ +"M [0-9-]* [0-9:]* ${PLUS}0000 $username 1\.[0-9]* config CVSROOT == <remote> +M [0-9-]* [0-9:]* ${PLUS}0000 $username 1\.[0-9]* config CVSROOT == <remote>" + else + dotest config-9 "$testcvs history -ea" \ +"M [0-9-]* [0-9:]* ${PLUS}0000 $username 1\.[0-9]* config CVSROOT == $TESTDIR/wnt/CVSROOT +M [0-9-]* [0-9:]* ${PLUS}0000 $username 1\.[0-9]* config CVSROOT == $TESTDIR/wnt/CVSROOT" + fi + + # Remove this now to see what kind of error messages we get. + rm -r $TESTDIR/historylogs + fi + + dokeep + restore_adm + cd ../.. + rm -r wnt + ;; + + + + config2) + # Tests of the CVSROOT/config file. See the comment at the + # "info" tests for a full list of administrative file tests. + + # No point in testing compression effects in local mode. + if $remote; then :; else + remoteonly config2 + continue + fi + + # On Windows, we can't check out CVSROOT, because the case + # insensitivity means that this conflicts with cvsroot. + mkdir wnt + cd wnt + + # Set MinCompressionLevel and MaxCompressionLevel in config. + dotest config2-init-1 "$testcvs -q co CVSROOT" "U CVSROOT/$DOTSTAR" + dotest config2-init-1b "$testcvs -Q tag initial" + cd CVSROOT + cat << EOF >> config +MinCompressionLevel=5 +MaxCompressionLevel=6 +EOF + dotest config2-init-2 \ +"$testcvs -q ci -m set-compression-constraints" \ +"$CVSROOT_DIRNAME/CVSROOT/config,v <-- config +new revision: 1\.[0-9]*; previous revision: 1\.[0-9]* +$SPROG commit: Rebuilding administrative file database" + + # Verify that the server reports forcing compression to an allowed + # level. + + # Too high. + dotest config2-1 "$testcvs -z9 update" \ +"$SPROG server: Forcing compression level 6 (allowed: 5 <= z <= 6)\. +$SPROG update: Updating \." + # Too low. + dotest config2-2 "$testcvs -z1 update" \ +"$SPROG server: Forcing compression level 5 (allowed: 5 <= z <= 6)\. +$SPROG update: Updating \." + # From zero. + dotest config2-3 "$testcvs update" \ +"$SPROG server: Forcing compression level 5 (allowed: 5 <= z <= 6)\. +$SPROG update: Updating \." + # Just right. + dotest config2-3 "$testcvs -z5 update" \ +"$SPROG update: Updating \." + + # Check that compression may be forced to 0. + dotest config2-init-2b "$testcvs -z5 up -jHEAD -jinitial" "$DOTSTAR" + cat << EOF >> config +MaxCompressionLevel=0 +EOF + dotest config2-init-3 "$testcvs -qz5 ci -m no-compression" \ +"$CVSROOT_DIRNAME/CVSROOT/config,v <-- config +new revision: 1\.[0-9]*; previous revision: 1\.[0-9]* +$SPROG commit: Rebuilding administrative file database" + + # Too high. + dotest config2-5 "$testcvs -z9 update" \ +"$SPROG server: Forcing compression level 0 (allowed: 0 <= z <= 0)\. +$SPROG update: Updating \." + # Just right. + dotest config2-6 "$testcvs update" \ +"$SPROG update: Updating \." + + # And verify effect without restrictions. + dotest config2-init-3b "$testcvs up -jHEAD -jinitial" "$DOTSTAR" + dotest config2-init-4 "$testcvs -q ci -m change-to-comment" \ +"$CVSROOT_DIRNAME/CVSROOT/config,v <-- config +new revision: 1\.[0-9]*; previous revision: 1\.[0-9]* +$SPROG commit: Rebuilding administrative file database" + dotest config2-7 "$testcvs update" \ +"$SPROG update: Updating \." + + dokeep + restore_adm + cd ../.. + rm -r wnt + ;; + + config3) + # Verify comments, white space, & [rootspecs] in CVSROOT/config + # + # `cvs server' `-c' option tested in `server' test + modify_repo mkdir $CVSROOT_DIRNAME/config3 + mkdir config3 + cd config3 + + dotest config3-init-1 "$testcvs -q co CVSROOT" "U CVSROOT/$DOTSTAR" + cd CVSROOT + + # I break the usual sanity.sh indentation standard for here-docs + # mostly to test that leading white-space is now ignored. + dotest config3-init-1b "$testcvs -Q tag initial-config" + + cat <<EOF >>config + # Ignore a comment with leading spaces. + GLOBAL-BAD-OPTION=WWW + + [/ignore/this/root] + [/and/this/one] + IGNORED-BAD-OPTION=YYY +EOF + dotest config3-init-2 \ +"$testcvs -q ci -m test-root-specs" \ +"$CVSROOT_DIRNAME/CVSROOT/config,v <-- config +new revision: 1\.[0-9]*; previous revision: 1\.[0-9]* +$SPROG commit: Rebuilding administrative file database" + + cd .. + dotest config3-1 "$testcvs co config3" \ +"$SPROG [a-z]*: $SECONDARY_CVSROOT_DIRNAME/CVSROOT/config \[[0-9]*\]: unrecognized keyword \`GLOBAL-BAD-OPTION' +$SPROG checkout: Updating config3" + + cd CVSROOT + dotest config3-init-2a "$testcvs -Q up -jHEAD -jinitial-config" \ +"$DOTSTAR +Merging differences between 1\.[0-9]* and 1\.[0-9]* into config" + + cat <<EOF >>config + # Ignore a comment with leading spaces. + + [/ignore/this/root] + [/and/this/one] + IGNORED-BAD-OPTION=YYY + # Ignore a comment with leading spaces. + + [/some/other/root] + + # Comments and blank lines do not affect fall-through behavior. + + [$CVSROOT_DIRNAME] + [$SECONDARY_CVSROOT_DIRNAME] + + # Comments and blank lines do not affect fall-through behavior. + + [/yet/another/root] + # Ignore a comment with leading spaces. + PROCESS-BAD-OPTION=XXX +EOF + dotest config3-init-3 \ +"$testcvs -q ci -m test-root-specs" \ +"$SPROG [a-z]*: $CVSROOT_DIRNAME/CVSROOT/config \[[0-9]*\]: unrecognized keyword \`GLOBAL-BAD-OPTION' +$CVSROOT_DIRNAME/CVSROOT/config,v <-- config +new revision: 1\.[0-9]*; previous revision: 1\.[0-9]* +$SPROG commit: Rebuilding administrative file database" \ +"$SPROG [a-z]*: $SECONDARY_CVSROOT_DIRNAME/CVSROOT/config \[[0-9]*\]: unrecognized keyword \`GLOBAL-BAD-OPTION' +$SPROG [a-z]*: $CVSROOT_DIRNAME/CVSROOT/config \[[0-9]*\]: unrecognized keyword \`GLOBAL-BAD-OPTION' +$CVSROOT_DIRNAME/CVSROOT/config,v <-- config +new revision: 1\.[0-9]*; previous revision: 1\.[0-9]* +$SPROG commit: Rebuilding administrative file database" + + cd .. + dotest config3-2 "$testcvs co config3" \ +"$SPROG [a-z]*: $SECONDARY_CVSROOT_DIRNAME/CVSROOT/config \[[0-9]*\]: unrecognized keyword \`PROCESS-BAD-OPTION' +$SPROG checkout: Updating config3" + + # The next few tests make sure both global options and root + # specific options are processed by setting the history log and + # search paths in different locations and then verifying that + # both registered. It also verifies that a key for a different + # root is ignored. + cd CVSROOT + dotest config3-init-3a "$testcvs -Q up -jHEAD -jinitial-config" \ +"$DOTSTAR +Merging differences between 1\.[0-9]* and 1\.[0-9]* into config" + + cat <<EOF >>config + HistoryLogPath=$TESTDIR/historylog + + [/ignore/this/root] + [/and/this/one] + IGNORED-BAD-OPTION=YYY + + [/some/other/root] + [$CVSROOT_DIRNAME] + [$SECONDARY_CVSROOT_DIRNAME] + [/yet/another/root] + HistorySearchPath=$TESTDIR/historylog + + [/ignore/another/root] + [/and/this/one/too] + ANOTHER-IGNORED-BAD-OPTION=ZZZ + + [$CVSROOT_DIRNAME] + [$SECONDARY_CVSROOT_DIRNAME] + LogHistory=TMAR +EOF + dotest config3-init-4 \ +"$testcvs -q ci -m test-root-specs" \ +"$SPROG [a-z]*: $CVSROOT_DIRNAME/CVSROOT/config \[[0-9]*\]: unrecognized keyword \`PROCESS-BAD-OPTION' +$CVSROOT_DIRNAME/CVSROOT/config,v <-- config +new revision: 1\.[0-9]*; previous revision: 1\.[0-9]* +$SPROG commit: Rebuilding administrative file database" \ +"$SPROG [a-z]*: $SECONDARY_CVSROOT_DIRNAME/CVSROOT/config \[[0-9]*\]: unrecognized keyword \`PROCESS-BAD-OPTION' +$SPROG [a-z]*: $CVSROOT_DIRNAME/CVSROOT/config \[[0-9]*\]: unrecognized keyword \`PROCESS-BAD-OPTION' +$CVSROOT_DIRNAME/CVSROOT/config,v <-- config +new revision: 1\.[0-9]*; previous revision: 1\.[0-9]* +$SPROG commit: Rebuilding administrative file database" + + cd .. + dotest config3-3 "$testcvs co -d config3-2 config3" \ +"$SPROG checkout: Updating config3-2" + + cd config3-2 + touch newfile + dotest config3-4 "$testcvs -Q add newfile" + dotest config3-5 "$testcvs -q ci -madd-file" \ +"$CVSROOT_DIRNAME/config3/newfile,v <-- newfile +initial revision: 1\.1" + + dotest config3-6 "$testcvs rtag testtag config3" \ +"$SPROG rtag: Tagging config3" + + cd .. + dotest config3-7 "$testcvs history -ea" \ +"A [0-9-]* [0-9:]* ${PLUS}0000 $username 1\.1 newfile config3 == [-_/a-zA-Z0-9<>]* +T [0-9-]* [0-9:]* ${PLUS}0000 $username config3 \[testtag:A\]" + + dokeep + restore_adm + cd .. + rm -r config3 + modify_repo rm -rf $CVSROOT_DIRNAME/config3 + ;; + + + + config4) + # TmpDir + mkdir config4 + cd config4 + + dotest config4-init-1 "$testcvs -q co CVSROOT" "U CVSROOT/$DOTSTAR" + cd CVSROOT + mkdir $TESTDIR/config4/tmp + echo "TmpDir=$TESTDIR/config4/tmp" >>config + echo "DEFAULT $TESTDIR/config4/verify %l" >>verifymsg + dotest config4-init-2 "$testcvs -q ci -m change-tmpdir" \ +"$CVSROOT_DIRNAME/CVSROOT/config,v <-- config +new revision: 1\.[0-9]*; previous revision: 1\.[0-9]* +$CVSROOT_DIRNAME/CVSROOT/verifymsg,v <-- verifymsg +new revision: 1\.[0-9]*; previous revision: 1\.[0-9]* +$SPROG commit: Rebuilding administrative file database" + + cat >$TESTDIR/config4/verify <<EOF +#! /bin/sh +echo \$1 +exit 0 +EOF + chmod a+x $TESTDIR/config4/verify + dotest config4-1 \ +"$testcvs -q ci -fmtest-tmpdir config" \ +"$TESTDIR/config4/tmp/$tempfile +$CVSROOT_DIRNAME/CVSROOT/config,v <-- config +new revision: 1\.[0-9]*; previous revision: 1\.[0-9]* +$SPROG commit: Rebuilding administrative file database" + + dokeep + restore_adm + cd ../.. + rm -r config4 + modify_repo rm -rf $CVSROOT_DIRNAME/config4 + ;; + + + + serverpatch) + # Test remote CVS handling of unpatchable files. This isn't + # much of a test for local CVS. + # We test this with some keyword expansion games, but the situation + # also arises if the user modifies the file while CVS is running. + modify_repo mkdir $CVSROOT_DIRNAME/first-dir + mkdir 1 + cd 1 + dotest serverpatch-1 "$testcvs -q co first-dir" + + cd first-dir + + # Add a file with an RCS keyword. + echo '$''Name$' > file1 + echo '1' >> file1 + dotest serverpatch-2 "$testcvs add file1" \ +"$SPROG add: scheduling file \`file1' for addition +$SPROG add: use \`$SPROG commit' to add this file permanently" + + dotest serverpatch-3 "${testcvs} -q commit -m add" \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +initial revision: 1\.1" + + # Tag the file. + dotest serverpatch-4 "${testcvs} -q tag tag file1" 'T file1' + + # Check out a tagged copy of the file. + cd ../.. + mkdir 2 + cd 2 + dotest serverpatch-5 "${testcvs} -q co -r tag first-dir" \ +'U first-dir/file1' + + # Remove the tag. This will leave the tag string in the + # expansion of the Name keyword. + dotest serverpatch-6 "${testcvs} -q update -A first-dir" '' + + # Modify and check in the first copy. + cd ../1/first-dir + echo '2' >> file1 + dotest serverpatch-7 "${testcvs} -q ci -mx file1" \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +new revision: 1\.2; previous revision: 1\.1" + + # Now update the second copy. When using remote CVS, the + # patch will fail, forcing the file to be refetched. + cd ../../2/first-dir + dotest serverpatch-8 "${testcvs} -q update" \ +'U file1' \ +"P file1 +${CPROG} update: checksum failure after patch to \./file1; will refetch +${CPROG} client: refetching unpatchable files +$SPROG update: warning: \`file1' was lost +U file1" + + dokeep + cd ../.. + rm -r 1 2 + modify_repo rm -rf $CVSROOT_DIRNAME/first-dir + ;; + + + + log) + # Test selecting revisions with cvs log. + # See also log2 tests for more tests. + # See also branches-14.3 for logging with a branch off of a branch. + # See also multibranch-14 for logging with several branches off the + # same branchpoint. + # Tests of each option to cvs log: + # -h: admin-19a-log + # -N: log, log2, admin-19a-log + # -b, -r: log + # -d: logopt, rcs + # -s: logopt, rcs3 + # -R: logopt, rcs3 + # -w, -t: not tested yet (TODO) + + # Check in a file with a few revisions and branches. + modify_repo mkdir $CVSROOT_DIRNAME/first-dir + dotest log-1 "$testcvs -q co first-dir" + cd first-dir + echo 'first revision' > file1 + echo 'first revision' > file2 + dotest log-2 "${testcvs} add file1 file2" \ +"${SPROG} add: scheduling file .file1. for addition +${SPROG} add: scheduling file .file2. for addition +${SPROG} add: use .${SPROG} commit. to add these files permanently" + + # While we're at it, check multi-line comments, input from file, + # and trailing whitespace trimming + echo 'line 1 ' >${TESTDIR}/comment.tmp + echo ' ' >>${TESTDIR}/comment.tmp + echo 'line 2 ' >>${TESTDIR}/comment.tmp + echo ' ' >>${TESTDIR}/comment.tmp + echo ' ' >>${TESTDIR}/comment.tmp + dotest log-3 "${testcvs} -q commit -F ${TESTDIR}/comment.tmp" \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +initial revision: 1\.1 +$CVSROOT_DIRNAME/first-dir/file2,v <-- file2 +initial revision: 1\.1" + rm -f ${TESTDIR}/comment.tmp + + echo 'second revision' > file1 + echo 'second revision' > file2 + dotest log-4 "${testcvs} -q ci -m2 file1 file2" \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +new revision: 1\.2; previous revision: 1\.1 +$CVSROOT_DIRNAME/first-dir/file2,v <-- file2 +new revision: 1\.2; previous revision: 1\.1" + + dotest log-5 "${testcvs} -q tag -b branch file1" 'T file1' + dotest log-5a "${testcvs} -q tag tag1 file2" 'T file2' + + echo 'third revision' > file1 + echo 'third revision' > file2 + dotest log-6 "${testcvs} -q ci -m3 file1 file2" \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +new revision: 1\.3; previous revision: 1\.2 +$CVSROOT_DIRNAME/first-dir/file2,v <-- file2 +new revision: 1\.3; previous revision: 1\.2" + + dotest log-6a "${testcvs} -q tag tag2 file2" 'T file2' + + dotest log-7 "${testcvs} -q update -r branch" \ +"[UP] file1 +${SPROG} update: \`file2' is no longer in the repository" + + echo 'first branch revision' > file1 + dotest log-8 "${testcvs} -q ci -m1b file1" \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +new revision: 1\.2\.2\.1; previous revision: 1\.2" + + dotest log-9 "${testcvs} -q tag tag file1" 'T file1' + + echo 'second branch revision' > file1 + dotest log-10 "${testcvs} -q ci -m2b file1" \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +new revision: 1\.2\.2\.2; previous revision: 1\.2\.2\.1" + + # Set up a bunch of shell variables to make the later tests + # easier to describe.= + log_header1=" +RCS file: ${CVSROOT_DIRNAME}/first-dir/file1,v +Working file: file1 +head: 1\.3 +branch: +locks: strict +access list:" + rlog_header1=" +RCS file: ${CVSROOT_DIRNAME}/first-dir/file1,v +head: 1\.3 +branch: +locks: strict +access list:" + log_tags1='symbolic names: + tag: 1\.2\.2\.1 + branch: 1\.2\.0\.2' + log_keyword='keyword substitution: kv' + log_dash='---------------------------- +revision' + log_date="date: ${ISO8601DATE}; author: ${username}; state: Exp;" + log_lines=" lines: ${PLUS}1 -1;" + log_commitid=" commitid: ${commitid};" + log_rev1="${log_dash} 1\.1 +${log_date}${log_commitid} +line 1 + +line 2" + log_rev2="${log_dash} 1\.2 +${log_date}${log_lines}${log_commitid} +branches: 1\.2\.2; +2" + log_rev3="${log_dash} 1\.3 +${log_date}${log_lines}${log_commitid} +3" + log_rev1b="${log_dash} 1\.2\.2\.1 +${log_date}${log_lines}${log_commitid} +1b" + log_rev2b="${log_dash} 1\.2\.2\.2 +${log_date}${log_lines}${log_commitid} +2b" + log_trailer='=============================================================================' + + # Now, finally, test the log output. + + dotest log-11 "${testcvs} log file1" \ +"${log_header1} +${log_tags1} +${log_keyword} +total revisions: 5; selected revisions: 5 +description: +${log_rev3} +${log_rev2} +${log_rev1} +${log_rev2b} +${log_rev1b} +${log_trailer}" + + dotest log-12 "${testcvs} log -N file1" \ +"${log_header1} +${log_keyword} +total revisions: 5; selected revisions: 5 +description: +${log_rev3} +${log_rev2} +${log_rev1} +${log_rev2b} +${log_rev1b} +${log_trailer}" + + dotest log-13 "${testcvs} log -b file1" \ +"${log_header1} +${log_tags1} +${log_keyword} +total revisions: 5; selected revisions: 3 +description: +${log_rev3} +${log_rev2} +${log_rev1} +${log_trailer}" + + dotest log-14 "${testcvs} log -r file1" \ +"${log_header1} +${log_tags1} +${log_keyword} +total revisions: 5; selected revisions: 1 +description: +${log_rev3} +${log_trailer}" + + dotest log-14a "${testcvs} log -rHEAD file1" \ +"${log_header1} +${log_tags1} +${log_keyword} +total revisions: 5; selected revisions: 1 +description: +${log_rev3} +${log_trailer}" + + # The user might not realize that "-r" must not take a space. + # In the error message, HEAD is a file name, not a tag name (which + # might be confusing itself). + dotest_fail log-14b "${testcvs} log -r HEAD file1" \ +"${SPROG} log: nothing known about HEAD +${log_header1} +${log_tags1} +${log_keyword} +total revisions: 5; selected revisions: 1 +description: +${log_rev3} +${log_trailer}" + +# Check that unusual syntax works correctly. + + dotest log-14c "${testcvs} log -r: file1" \ +"${log_header1} +${log_tags1} +${log_keyword} +total revisions: 5; selected revisions: 1 +description: +${log_rev3} +${log_trailer}" + dotest log-14d "${testcvs} log -r, file1" \ +"${log_header1} +${log_tags1} +${log_keyword} +total revisions: 5; selected revisions: 1 +description: +${log_rev3} +${log_trailer}" + dotest log-14e "${testcvs} log -r. file1" \ +"${log_header1} +${log_tags1} +${log_keyword} +total revisions: 5; selected revisions: 1 +description: +${log_rev3} +${log_trailer}" + dotest log-14f "${testcvs} log -r:: file1" \ +"${log_header1} +${log_tags1} +${log_keyword} +total revisions: 5; selected revisions: 0 +description: +${log_trailer}" + + dotest log-15 "${testcvs} log -r1.2 file1" \ +"${log_header1} +${log_tags1} +${log_keyword} +total revisions: 5; selected revisions: 1 +description: +${log_rev2} +${log_trailer}" + + dotest log-16 "${testcvs} log -r1.2.2 file1" \ +"${log_header1} +${log_tags1} +${log_keyword} +total revisions: 5; selected revisions: 2 +description: +${log_rev2b} +${log_rev1b} +${log_trailer}" + + # This test would fail with the old invocation of rlog, but it + # works with the builtin log support. + dotest log-17 "${testcvs} log -rbranch file1" \ +"${log_header1} +${log_tags1} +${log_keyword} +total revisions: 5; selected revisions: 2 +description: +${log_rev2b} +${log_rev1b} +${log_trailer}" + + dotest log-18 "${testcvs} log -r1.2.2. file1" \ +"${log_header1} +${log_tags1} +${log_keyword} +total revisions: 5; selected revisions: 1 +description: +${log_rev2b} +${log_trailer}" + + # Multiple -r options are undocumented; see comments in + # cvs.texinfo about whether they should be deprecated. + dotest log-18a "${testcvs} log -r1.2.2.2 -r1.3:1.3 file1" \ +"${log_header1} +${log_tags1} +${log_keyword} +total revisions: 5; selected revisions: 2 +description: +${log_rev3} +${log_rev2b} +${log_trailer}" + + # This test would fail with the old invocation of rlog, but it + # works with the builtin log support. + dotest log-19 "${testcvs} log -rbranch. file1" \ +"${log_header1} +${log_tags1} +${log_keyword} +total revisions: 5; selected revisions: 1 +description: +${log_rev2b} +${log_trailer}" + + dotest log-20 "${testcvs} log -r1.2: file1" \ +"${log_header1} +${log_tags1} +${log_keyword} +total revisions: 5; selected revisions: 2 +description: +${log_rev3} +${log_rev2} +${log_trailer}" + + dotest log-20a "${testcvs} log -r1.2:: file1" \ +"${log_header1} +${log_tags1} +${log_keyword} +total revisions: 5; selected revisions: 1 +description: +${log_rev3} +${log_trailer}" + + dotest log-21 "${testcvs} log -r:1.2 file1" \ +"${log_header1} +${log_tags1} +${log_keyword} +total revisions: 5; selected revisions: 2 +description: +${log_rev2} +${log_rev1} +${log_trailer}" + + dotest log-21a "${testcvs} log -r::1.2 file1" \ +"${log_header1} +${log_tags1} +${log_keyword} +total revisions: 5; selected revisions: 2 +description: +${log_rev2} +${log_rev1} +${log_trailer}" + + dotest log-22 "${testcvs} log -r1.1:1.2 file1" \ +"${log_header1} +${log_tags1} +${log_keyword} +total revisions: 5; selected revisions: 2 +description: +${log_rev2} +${log_rev1} +${log_trailer}" + + dotest log-22a "${testcvs} log -r1.1::1.2 file1" \ +"${log_header1} +${log_tags1} +${log_keyword} +total revisions: 5; selected revisions: 1 +description: +${log_rev2} +${log_trailer}" + + dotest log-22b "${testcvs} log -r1.1::1.3 file1" \ +"${log_header1} +${log_tags1} +${log_keyword} +total revisions: 5; selected revisions: 2 +description: +${log_rev3} +${log_rev2} +${log_trailer}" + + dotest log-23 "${testcvs} log -rfoo:: file1" \ +"${SPROG} log: warning: no revision .foo. in .${CVSROOT_DIRNAME}/first-dir/file1,v. +${log_header1} +${log_tags1} +${log_keyword} +total revisions: 5; selected revisions: 0 +description: +${log_trailer}" + + dotest log-24 "${testcvs} log -rfoo::1.3 file1" \ +"${SPROG} log: warning: no revision .foo. in .${CVSROOT_DIRNAME}/first-dir/file1,v. +${log_header1} +${log_tags1} +${log_keyword} +total revisions: 5; selected revisions: 0 +description: +${log_trailer}" + + dotest log-25 "${testcvs} log -r::foo file1" \ +"${SPROG} log: warning: no revision .foo. in .${CVSROOT_DIRNAME}/first-dir/file1,v. +${log_header1} +${log_tags1} +${log_keyword} +total revisions: 5; selected revisions: 0 +description: +${log_trailer}" + + dotest log-26 "${testcvs} log -r1.1::foo file1" \ +"${SPROG} log: warning: no revision .foo. in .${CVSROOT_DIRNAME}/first-dir/file1,v. +${log_header1} +${log_tags1} +${log_keyword} +total revisions: 5; selected revisions: 0 +description: +${log_trailer}" + + # Test BASE pseudotag + dotest log-27 "${testcvs} log -rBASE file1" \ +"${log_header1} +${log_tags1} +${log_keyword} +total revisions: 5; selected revisions: 1 +description: +${log_rev2b} +${log_trailer}" + + dotest log-28 "${testcvs} -q up -r1.2 file1" "[UP] file1" + dotest log-29 "${testcvs} log -rBASE file1" \ +"${log_header1} +${log_tags1} +${log_keyword} +total revisions: 5; selected revisions: 1 +description: +${log_rev2} +${log_trailer}" + + dotest log-30 "${testcvs} -q up -rbranch file1" "[UP] file1" + + # Now the same tests but with rlog + + dotest log-r11 "${testcvs} rlog first-dir/file1" \ +"${rlog_header1} +${log_tags1} +${log_keyword} +total revisions: 5; selected revisions: 5 +description: +${log_rev3} +${log_rev2} +${log_rev1} +${log_rev2b} +${log_rev1b} +${log_trailer}" + + dotest log-r12 "${testcvs} rlog -N first-dir/file1" \ +"${rlog_header1} +${log_keyword} +total revisions: 5; selected revisions: 5 +description: +${log_rev3} +${log_rev2} +${log_rev1} +${log_rev2b} +${log_rev1b} +${log_trailer}" + + dotest log-r13 "${testcvs} rlog -b first-dir/file1" \ +"${rlog_header1} +${log_tags1} +${log_keyword} +total revisions: 5; selected revisions: 3 +description: +${log_rev3} +${log_rev2} +${log_rev1} +${log_trailer}" + + dotest log-r14 "${testcvs} rlog -r first-dir/file1" \ +"${rlog_header1} +${log_tags1} +${log_keyword} +total revisions: 5; selected revisions: 1 +description: +${log_rev3} +${log_trailer}" + + dotest log-r14a "${testcvs} rlog -rHEAD first-dir/file1" \ +"${rlog_header1} +${log_tags1} +${log_keyword} +total revisions: 5; selected revisions: 1 +description: +${log_rev3} +${log_trailer}" + + dotest_fail log-r14b "${testcvs} rlog -r HEAD first-dir/file1" \ +"${SPROG} rlog: cannot find module .HEAD. - ignored +${rlog_header1} +${log_tags1} +${log_keyword} +total revisions: 5; selected revisions: 1 +description: +${log_rev3} +${log_trailer}" + + dotest log-r14c "${testcvs} rlog -r: first-dir/file1" \ +"${rlog_header1} +${log_tags1} +${log_keyword} +total revisions: 5; selected revisions: 1 +description: +${log_rev3} +${log_trailer}" + dotest log-r14d "${testcvs} rlog -r, first-dir/file1" \ +"${rlog_header1} +${log_tags1} +${log_keyword} +total revisions: 5; selected revisions: 1 +description: +${log_rev3} +${log_trailer}" + dotest log-r14e "${testcvs} rlog -r. first-dir/file1" \ +"${rlog_header1} +${log_tags1} +${log_keyword} +total revisions: 5; selected revisions: 1 +description: +${log_rev3} +${log_trailer}" + dotest log-r14f "${testcvs} rlog -r:: first-dir/file1" \ +"${rlog_header1} +${log_tags1} +${log_keyword} +total revisions: 5; selected revisions: 0 +description: +${log_trailer}" + + dotest log-r15 "${testcvs} rlog -r1.2 first-dir/file1" \ +"${rlog_header1} +${log_tags1} +${log_keyword} +total revisions: 5; selected revisions: 1 +description: +${log_rev2} +${log_trailer}" + + dotest log-r16 "${testcvs} rlog -r1.2.2 first-dir/file1" \ +"${rlog_header1} +${log_tags1} +${log_keyword} +total revisions: 5; selected revisions: 2 +description: +${log_rev2b} +${log_rev1b} +${log_trailer}" + + dotest log-r17 "${testcvs} rlog -rbranch first-dir/file1" \ +"${rlog_header1} +${log_tags1} +${log_keyword} +total revisions: 5; selected revisions: 2 +description: +${log_rev2b} +${log_rev1b} +${log_trailer}" + + dotest log-r18 "${testcvs} rlog -r1.2.2. first-dir/file1" \ +"${rlog_header1} +${log_tags1} +${log_keyword} +total revisions: 5; selected revisions: 1 +description: +${log_rev2b} +${log_trailer}" + + dotest log-r18a "${testcvs} rlog -r1.2.2.2 -r1.3:1.3 first-dir/file1" \ +"${rlog_header1} +${log_tags1} +${log_keyword} +total revisions: 5; selected revisions: 2 +description: +${log_rev3} +${log_rev2b} +${log_trailer}" + + dotest log-r19 "${testcvs} rlog -rbranch. first-dir/file1" \ +"${rlog_header1} +${log_tags1} +${log_keyword} +total revisions: 5; selected revisions: 1 +description: +${log_rev2b} +${log_trailer}" + + dotest log-r20 "${testcvs} rlog -r1.2: first-dir/file1" \ +"${rlog_header1} +${log_tags1} +${log_keyword} +total revisions: 5; selected revisions: 2 +description: +${log_rev3} +${log_rev2} +${log_trailer}" + + dotest log-r20a "${testcvs} rlog -r1.2:: first-dir/file1" \ +"${rlog_header1} +${log_tags1} +${log_keyword} +total revisions: 5; selected revisions: 1 +description: +${log_rev3} +${log_trailer}" + + dotest log-r21 "${testcvs} rlog -r:1.2 first-dir/file1" \ +"${rlog_header1} +${log_tags1} +${log_keyword} +total revisions: 5; selected revisions: 2 +description: +${log_rev2} +${log_rev1} +${log_trailer}" + + dotest log-r21a "${testcvs} rlog -r::1.2 first-dir/file1" \ +"${rlog_header1} +${log_tags1} +${log_keyword} +total revisions: 5; selected revisions: 2 +description: +${log_rev2} +${log_rev1} +${log_trailer}" + + dotest log-r22 "${testcvs} rlog -r1.1:1.2 first-dir/file1" \ +"${rlog_header1} +${log_tags1} +${log_keyword} +total revisions: 5; selected revisions: 2 +description: +${log_rev2} +${log_rev1} +${log_trailer}" + + dotest log-r22a "${testcvs} rlog -r1.1::1.2 first-dir/file1" \ +"${rlog_header1} +${log_tags1} +${log_keyword} +total revisions: 5; selected revisions: 1 +description: +${log_rev2} +${log_trailer}" + + dotest log-r22b "${testcvs} rlog -r1.1::1.3 first-dir/file1" \ +"${rlog_header1} +${log_tags1} +${log_keyword} +total revisions: 5; selected revisions: 2 +description: +${log_rev3} +${log_rev2} +${log_trailer}" + + dotest log-r23 "${testcvs} rlog -rfoo:: first-dir/file1" \ +"${SPROG} rlog: warning: no revision .foo. in .${CVSROOT_DIRNAME}/first-dir/file1,v. +${rlog_header1} +${log_tags1} +${log_keyword} +total revisions: 5; selected revisions: 0 +description: +${log_trailer}" + + dotest log-r24 "${testcvs} rlog -rfoo::1.3 first-dir/file1" \ +"${SPROG} rlog: warning: no revision .foo. in .${CVSROOT_DIRNAME}/first-dir/file1,v. +${rlog_header1} +${log_tags1} +${log_keyword} +total revisions: 5; selected revisions: 0 +description: +${log_trailer}" + + dotest log-r25 "${testcvs} rlog -r::foo first-dir/file1" \ +"${SPROG} rlog: warning: no revision .foo. in .${CVSROOT_DIRNAME}/first-dir/file1,v. +${rlog_header1} +${log_tags1} +${log_keyword} +total revisions: 5; selected revisions: 0 +description: +${log_trailer}" + + dotest log-r26 "${testcvs} rlog -r1.1::foo first-dir/file1" \ +"${SPROG} rlog: warning: no revision .foo. in .${CVSROOT_DIRNAME}/first-dir/file1,v. +${rlog_header1} +${log_tags1} +${log_keyword} +total revisions: 5; selected revisions: 0 +description: +${log_trailer}" + + # Test BASE pseudotag + dotest log-r27 "${testcvs} rlog -rBASE first-dir/file1" \ +"${SPROG} rlog: warning: no revision .BASE. in .${CVSROOT_DIRNAME}/first-dir/file1,v. +${rlog_header1} +${log_tags1} +${log_keyword} +total revisions: 5; selected revisions: 0 +description: +${log_trailer}" + + dotest log-r28 "${testcvs} -q up -r1.2 file1" "[UP] file1" + dotest log-r29 "${testcvs} rlog -rBASE first-dir/file1" \ +"${SPROG} rlog: warning: no revision .BASE. in .${CVSROOT_DIRNAME}/first-dir/file1,v. +${rlog_header1} +${log_tags1} +${log_keyword} +total revisions: 5; selected revisions: 0 +description: +${log_trailer}" + + # Test when head is dead + + dotest log-d0 "${testcvs} -q up -A" \ +"[UP] file1 +U file2" + dotest log-d1 "${testcvs} -q rm -f file1" \ +"${SPROG} remove: use .${SPROG} commit. to remove this file permanently" + dotest log-d2 "${testcvs} -q ci -m4" \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +new revision: delete; previous revision: 1\.3" + + log_header1=" +RCS file: ${CVSROOT_DIRNAME}/first-dir/Attic/file1,v +Working file: file1 +head: 1\.4 +branch: +locks: strict +access list:" + rlog_header1=" +RCS file: ${CVSROOT_DIRNAME}/first-dir/Attic/file1,v +head: 1\.4 +branch: +locks: strict +access list:" + log_header2=" +RCS file: ${CVSROOT_DIRNAME}/first-dir/file2,v +Working file: file2 +head: 1\.3 +branch: +locks: strict +access list:" + rlog_header2=" +RCS file: ${CVSROOT_DIRNAME}/first-dir/file2,v +head: 1\.3 +branch: +locks: strict +access list:" + log_tags2='symbolic names: + tag2: 1\.3 + tag1: 1\.2' + log_rev4="${log_dash} 1\.4 +date: ${ISO8601DATE}; author: ${username}; state: dead; lines: ${PLUS}0 -0; commitid: ${commitid}; +4" + log_rev22="${log_dash} 1\.2 +${log_date}${log_lines}${log_commitid} +2" + + dotest log-d3 "${testcvs} log -rbranch file1" \ +"${log_header1} +${log_tags1} +${log_keyword} +total revisions: 6; selected revisions: 2 +description: +${log_rev2b} +${log_rev1b} +${log_trailer}" + dotest log-rd3 "${testcvs} rlog -rbranch first-dir/file1" \ +"${rlog_header1} +${log_tags1} +${log_keyword} +total revisions: 6; selected revisions: 2 +description: +${log_rev2b} +${log_rev1b} +${log_trailer}" + dotest log-d4 "${testcvs} -q log -rbranch" \ +"${log_header1} +${log_tags1} +${log_keyword} +total revisions: 6; selected revisions: 2 +description: +${log_rev2b} +${log_rev1b} +${log_trailer} +${SPROG} log: warning: no revision .branch. in .${CVSROOT_DIRNAME}/first-dir/file2,v. +${log_header2} +${log_tags2} +${log_keyword} +total revisions: 3; selected revisions: 0 +description: +${log_trailer}" + dotest log-d4a "${testcvs} -q log -t -rbranch" \ +"${log_header1} +${log_tags1} +${log_keyword} +total revisions: 6 +description: +${log_trailer} +${SPROG} log: warning: no revision .branch. in .${CVSROOT_DIRNAME}/first-dir/file2,v. +${log_header2} +${log_tags2} +${log_keyword} +total revisions: 3 +description: +${log_trailer}" + dotest log-d4b "${testcvs} -q log -tS -rbranch" \ +"${log_header1} +${log_tags1} +${log_keyword} +total revisions: 6; selected revisions: 2 +description: +${log_trailer} +${SPROG} log: warning: no revision .branch. in .${CVSROOT_DIRNAME}/first-dir/file2,v." + dotest log-d4c "${testcvs} -q log -h -rbranch" \ +"${log_header1} +${log_tags1} +${log_keyword} +total revisions: 6 +${log_trailer} +${SPROG} log: warning: no revision .branch. in .${CVSROOT_DIRNAME}/first-dir/file2,v. +${log_header2} +${log_tags2} +${log_keyword} +total revisions: 3 +${log_trailer}" + dotest log-d4d "${testcvs} -q log -hS -rbranch" \ +"${log_header1} +${log_tags1} +${log_keyword} +total revisions: 6; selected revisions: 2 +${log_trailer} +${SPROG} log: warning: no revision .branch. in .${CVSROOT_DIRNAME}/first-dir/file2,v." + dotest log-d4e "$testcvs -q log -R -rbranch" \ +"$CVSROOT_DIRNAME/first-dir/Attic/file1,v +$CVSROOT_DIRNAME/first-dir/file2,v" + dotest log-d4f "${testcvs} -q log -R -S -rbranch" \ +"${CVSROOT_DIRNAME}/first-dir/Attic/file1,v +${SPROG} log: warning: no revision .branch. in .${CVSROOT_DIRNAME}/first-dir/file2,v." + dotest log-rd4 "${testcvs} -q rlog -rbranch first-dir" \ +"${rlog_header1} +${log_tags1} +${log_keyword} +total revisions: 6; selected revisions: 2 +description: +${log_rev2b} +${log_rev1b} +${log_trailer} +${SPROG} rlog: warning: no revision .branch. in .${CVSROOT_DIRNAME}/first-dir/file2,v. +${rlog_header2} +${log_tags2} +${log_keyword} +total revisions: 3; selected revisions: 0 +description: +${log_trailer}" + dotest log-rd4a "${testcvs} -q rlog -t -rbranch first-dir" \ +"${rlog_header1} +${log_tags1} +${log_keyword} +total revisions: 6 +description: +${log_trailer} +${SPROG} rlog: warning: no revision .branch. in .${CVSROOT_DIRNAME}/first-dir/file2,v. +${rlog_header2} +${log_tags2} +${log_keyword} +total revisions: 3 +description: +${log_trailer}" + dotest log-rd4b "${testcvs} -q rlog -St -rbranch first-dir" \ +"${rlog_header1} +${log_tags1} +${log_keyword} +total revisions: 6; selected revisions: 2 +description: +${log_trailer} +${SPROG} rlog: warning: no revision .branch. in .${CVSROOT_DIRNAME}/first-dir/file2,v." + dotest log-rd4c "${testcvs} -q rlog -h -rbranch first-dir" \ +"${rlog_header1} +${log_tags1} +${log_keyword} +total revisions: 6 +${log_trailer} +${SPROG} rlog: warning: no revision .branch. in .${CVSROOT_DIRNAME}/first-dir/file2,v. +${rlog_header2} +${log_tags2} +${log_keyword} +total revisions: 3 +${log_trailer}" + dotest log-rd4d "${testcvs} -q rlog -Sh -rbranch first-dir" \ +"${rlog_header1} +${log_tags1} +${log_keyword} +total revisions: 6; selected revisions: 2 +${log_trailer} +${SPROG} rlog: warning: no revision .branch. in .${CVSROOT_DIRNAME}/first-dir/file2,v." + dotest log-rd4e "${testcvs} -q rlog -R -rbranch first-dir" \ +"${CVSROOT_DIRNAME}/first-dir/Attic/file1,v +${CVSROOT_DIRNAME}/first-dir/file2,v" + dotest log-rd4f "${testcvs} -q rlog -R -S -rbranch first-dir" \ +"${CVSROOT_DIRNAME}/first-dir/Attic/file1,v +${SPROG} rlog: warning: no revision .branch. in .${CVSROOT_DIRNAME}/first-dir/file2,v." + dotest log-d5 "${testcvs} log -r1.2.2.1:1.2.2.2 file1" \ +"${log_header1} +${log_tags1} +${log_keyword} +total revisions: 6; selected revisions: 2 +description: +${log_rev2b} +${log_rev1b} +${log_trailer}" + dotest log-rd5 "${testcvs} rlog -r1.2.2.1:1.2.2.2 first-dir/file1" \ +"${rlog_header1} +${log_tags1} +${log_keyword} +total revisions: 6; selected revisions: 2 +description: +${log_rev2b} +${log_rev1b} +${log_trailer}" + dotest log-d6 "${testcvs} -q log -r1.2.2.1:1.2.2.2" \ +"${log_header1} +${log_tags1} +${log_keyword} +total revisions: 6; selected revisions: 2 +description: +${log_rev2b} +${log_rev1b} +${log_trailer} +${log_header2} +${log_tags2} +${log_keyword} +total revisions: 3; selected revisions: 0 +description: +${log_trailer}" + dotest log-rd6 "${testcvs} -q rlog -r1.2.2.1:1.2.2.2 first-dir" \ +"${rlog_header1} +${log_tags1} +${log_keyword} +total revisions: 6; selected revisions: 2 +description: +${log_rev2b} +${log_rev1b} +${log_trailer} +${rlog_header2} +${log_tags2} +${log_keyword} +total revisions: 3; selected revisions: 0 +description: +${log_trailer}" + dotest log-d7 "${testcvs} log -r1.2:1.3 file1" \ +"${log_header1} +${log_tags1} +${log_keyword} +total revisions: 6; selected revisions: 2 +description: +${log_rev3} +${log_rev2} +${log_trailer}" + dotest log-rd7 "${testcvs} -q rlog -r1.2:1.3 first-dir/file1" \ +"${rlog_header1} +${log_tags1} +${log_keyword} +total revisions: 6; selected revisions: 2 +description: +${log_rev3} +${log_rev2} +${log_trailer}" + dotest log-d8 "${testcvs} -q log -rtag1:tag2" \ +"${SPROG} log: warning: no revision .tag1. in .${CVSROOT_DIRNAME}/first-dir/Attic/file1,v. +${SPROG} log: warning: no revision .tag2. in .${CVSROOT_DIRNAME}/first-dir/Attic/file1,v. +${log_header1} +${log_tags1} +${log_keyword} +total revisions: 6; selected revisions: 0 +description: +${log_trailer} +${log_header2} +${log_tags2} +${log_keyword} +total revisions: 3; selected revisions: 2 +description: +${log_rev3} +${log_rev22} +${log_trailer}" + dotest log-d8a "${testcvs} -q log -rtag1:tag2 -S" \ +"${SPROG} log: warning: no revision .tag1. in .${CVSROOT_DIRNAME}/first-dir/Attic/file1,v. +${SPROG} log: warning: no revision .tag2. in .${CVSROOT_DIRNAME}/first-dir/Attic/file1,v. +${log_header2} +${log_tags2} +${log_keyword} +total revisions: 3; selected revisions: 2 +description: +${log_rev3} +${log_rev22} +${log_trailer}" + dotest log-rd8 "${testcvs} -q rlog -rtag1:tag2 first-dir" \ +"${SPROG} rlog: warning: no revision .tag1. in .${CVSROOT_DIRNAME}/first-dir/Attic/file1,v. +${SPROG} rlog: warning: no revision .tag2. in .${CVSROOT_DIRNAME}/first-dir/Attic/file1,v. +${rlog_header1} +${log_tags1} +${log_keyword} +total revisions: 6; selected revisions: 0 +description: +${log_trailer} +${rlog_header2} +${log_tags2} +${log_keyword} +total revisions: 3; selected revisions: 2 +description: +${log_rev3} +${log_rev22} +${log_trailer}" + dotest log-rd8a "${testcvs} -q rlog -rtag1:tag2 -S first-dir" \ +"${SPROG} rlog: warning: no revision .tag1. in .${CVSROOT_DIRNAME}/first-dir/Attic/file1,v. +${SPROG} rlog: warning: no revision .tag2. in .${CVSROOT_DIRNAME}/first-dir/Attic/file1,v. +${rlog_header2} +${log_tags2} +${log_keyword} +total revisions: 3; selected revisions: 2 +description: +${log_rev3} +${log_rev22} +${log_trailer}" + + dotest log-d99 "${testcvs} -q up -rbranch" \ +"[UP] file1 +${SPROG} update: \`file2' is no longer in the repository" + + # Now test outdating revisions + + dotest log-o0 "${testcvs} admin -o 1.2.2.2:: file1" \ +"RCS file: ${CVSROOT_DIRNAME}/first-dir/Attic/file1,v +done" + dotest log-o1 "${testcvs} admin -o ::1.2.2.1 file1" \ +"RCS file: ${CVSROOT_DIRNAME}/first-dir/Attic/file1,v +done" + dotest log-o2 "${testcvs} admin -o 1.2.2.1:: file1" \ +"RCS file: ${CVSROOT_DIRNAME}/first-dir/Attic/file1,v +deleting revision 1\.2\.2\.2 +done" + dotest log-o3 "${testcvs} log file1" \ +"${log_header1} +${log_tags1} +${log_keyword} +total revisions: 5; selected revisions: 5 +description: +${log_rev4} +${log_rev3} +${log_rev2} +${log_rev1} +${log_rev1b} +${log_trailer}" + dotest log-ro3 "${testcvs} rlog first-dir/file1" \ +"${rlog_header1} +${log_tags1} +${log_keyword} +total revisions: 5; selected revisions: 5 +description: +${log_rev4} +${log_rev3} +${log_rev2} +${log_rev1} +${log_rev1b} +${log_trailer}" + dotest log-o4 "${testcvs} -q update -p -r 1.2.2.1 file1" \ +"first branch revision" + + dokeep + cd .. + rm -r first-dir + modify_repo rm -rf $CVSROOT_DIRNAME/first-dir + ;; + + + + log2) + # More "cvs log" tests, for example the file description. + + # Check in a file + modify_repo mkdir $CVSROOT_DIRNAME/first-dir + dotest log2-1 "$testcvs -q co first-dir" + cd first-dir + echo 'first revision' > file1 + dotest log2-2 "${testcvs} add -m file1-is-for-testing file1" \ +"${SPROG}"' add: scheduling file `file1'\'' for addition +'"${SPROG}"' add: use .'"${SPROG}"' commit. to add this file permanently' + dotest log2-3 "${testcvs} -q commit -m 1" \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +initial revision: 1\.1" + # Setting the file description with add -m doesn't yet work + # client/server, so skip log2-4 for remote. + if $remote; then :; else + + dotest log2-4 "${testcvs} log -N file1" " +RCS file: ${CVSROOT_DIRNAME}/first-dir/file1,v +Working file: file1 +head: 1\.1 +branch: +locks: strict +access list: +keyword substitution: kv +total revisions: 1; selected revisions: 1 +description: +file1-is-for-testing +---------------------------- +revision 1\.1 +date: ${ISO8601DATE}; author: ${username}; state: Exp; commitid: ${commitid}; +1 +=============================================================================" + + fi # end of tests skipped for remote + + dotest log2-5 "${testcvs} admin -t-change-description file1" \ +"RCS file: ${CVSROOT_DIRNAME}/first-dir/file1,v +done" + dotest log2-6 "${testcvs} log -N file1" " +RCS file: ${CVSROOT_DIRNAME}/first-dir/file1,v +Working file: file1 +head: 1\.1 +branch: +locks: strict +access list: +keyword substitution: kv +total revisions: 1; selected revisions: 1 +description: +change-description +---------------------------- +revision 1\.1 +date: ${ISO8601DATE}; author: ${username}; state: Exp; commitid: ${commitid}; +1 +=============================================================================" + + echo 'longer description' >${TESTDIR}/descrip + echo 'with two lines' >>${TESTDIR}/descrip + dotest log2-7 "${testcvs} admin -t${TESTDIR}/descrip file1" \ +"RCS file: ${CVSROOT_DIRNAME}/first-dir/file1,v +done" + dotest_fail log2-7a "${testcvs} admin -t${TESTDIR}/nonexist file1" \ +"${CPROG} \[admin aborted\]: can't stat ${TESTDIR}/nonexist: No such file or directory" + dotest log2-8 "${testcvs} log -N file1" " +RCS file: ${CVSROOT_DIRNAME}/first-dir/file1,v +Working file: file1 +head: 1\.1 +branch: +locks: strict +access list: +keyword substitution: kv +total revisions: 1; selected revisions: 1 +description: +longer description +with two lines +---------------------------- +revision 1\.1 +date: ${ISO8601DATE}; author: ${username}; state: Exp; commitid: ${commitid}; +1 +=============================================================================" + + # TODO: `cvs admin -t "my message" file1' is a request to + # read the message from stdin and to operate on two files. + # Should test that there is an error because "my message" + # doesn't exist. + + dotest log2-9 "echo change from stdin | ${testcvs} admin -t -q file1" "" + dotest log2-10 "${testcvs} log -N file1" " +RCS file: ${CVSROOT_DIRNAME}/first-dir/file1,v +Working file: file1 +head: 1\.1 +branch: +locks: strict +access list: +keyword substitution: kv +total revisions: 1; selected revisions: 1 +description: +change from stdin +---------------------------- +revision 1\.1 +date: ${ISO8601DATE}; author: ${username}; state: Exp; commitid: ${commitid}; +1 +=============================================================================" + + dokeep + cd .. + rm $TESTDIR/descrip + rm -r first-dir + modify_repo rm -rf $CVSROOT_DIRNAME/first-dir + ;; + + + + logopt) + # Some tests of log.c's option parsing and such things. + mkdir 1; cd 1 + dotest logopt-1 "$testcvs -q co -l ." '' + mkdir first-dir + dotest logopt-2 "$testcvs add first-dir" \ +"Directory $CVSROOT_DIRNAME/first-dir added to the repository" + cd first-dir + echo hi >file1 + dotest logopt-3 "${testcvs} add file1" \ +"${SPROG} add: scheduling file .file1. for addition +${SPROG} add: use .${SPROG} commit. to add this file permanently" + dotest logopt-4 "${testcvs} -q ci -m add file1" \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +initial revision: 1\.1" + cd .. + + dotest logopt-5 "${testcvs} log -R -d 2038-01-01" \ +"${SPROG} log: Logging \. +${SPROG} log: Logging first-dir +${CVSROOT_DIRNAME}/first-dir/file1,v" + dotest logopt-6 "${testcvs} log -d 2038-01-01 -R" \ +"${SPROG} log: Logging \. +${SPROG} log: Logging first-dir +${CVSROOT_DIRNAME}/first-dir/file1,v" + dotest logopt-6a "${testcvs} log -Rd 2038-01-01" \ +"${SPROG} log: Logging \. +${SPROG} log: Logging first-dir +${CVSROOT_DIRNAME}/first-dir/file1,v" + dotest logopt-7 "${testcvs} log -s Exp -R" \ +"${SPROG} log: Logging \. +${SPROG} log: Logging first-dir +${CVSROOT_DIRNAME}/first-dir/file1,v" + + dokeep + cd .. + rm -r 1 + modify_repo rm -rf $CVSROOT_DIRNAME/first-dir + ;; + + + + ann) + # Tests of "cvs annotate". See also: + # basica-10 A simple annotate test + # rcs Annotate and the year 2000 + # keywordlog Annotate and $Log. + mkdir 1; cd 1 + dotest ann-1 "$testcvs -q co -l ." + mkdir first-dir + dotest ann-2 "${testcvs} add first-dir" \ +"Directory ${CVSROOT_DIRNAME}/first-dir added to the repository" + cd first-dir + cat >file1 <<EOF +this +is +the +ancestral +file +EOF + dotest ann-3 "${testcvs} add file1" \ +"${SPROG} add: scheduling file .file1. for addition +${SPROG} add: use .${SPROG} commit. to add this file permanently" + dotest ann-4 "${testcvs} -q ci -m add file1" \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +initial revision: 1\.1" + cat >file1 <<EOF +this +is +a +file + +with +a +blank +line +EOF + dotest ann-5 "${testcvs} -q ci -m modify file1" \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +new revision: 1\.2; previous revision: 1\.1" + dotest ann-6 "${testcvs} -q tag -b br" "T file1" + cat >file1 <<EOF +this +is +a +trunk file + +with +a +blank +line +EOF + dotest ann-7 "${testcvs} -q ci -m modify file1" \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +new revision: 1\.3; previous revision: 1\.2" + dotest ann-8 "${testcvs} -q update -r br" "[UP] file1" + cat >file1 <<EOF +this +is +a +file + +with +a +blank +line +and some +branched content +EOF + dotest ann-9 "${testcvs} -q ci -m modify" \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +new revision: 1\.2\.2\.1; previous revision: 1\.2" + # Note that this annotates the trunk despite the presence + # of a sticky tag in the current directory. This is + # fairly bogus, but it is the longstanding behavior for + # whatever that is worth. + dotest ann-10 "${testcvs} ann" \ +" +Annotations for file1 +\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* +1\.1 ($username8 *[0-9a-zA-Z-]*): this +1\.1 ($username8 *[0-9a-zA-Z-]*): is +1\.2 ($username8 *[0-9a-zA-Z-]*): a +1\.3 ($username8 *[0-9a-zA-Z-]*): trunk file +1\.2 ($username8 *[0-9a-zA-Z-]*): +1\.2 ($username8 *[0-9a-zA-Z-]*): with +1\.2 ($username8 *[0-9a-zA-Z-]*): a +1\.2 ($username8 *[0-9a-zA-Z-]*): blank +1\.2 ($username8 *[0-9a-zA-Z-]*): line" + dotest ann-11 "${testcvs} ann -r br" \ +" +Annotations for file1 +\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* +1\.1 ($username8 *[0-9a-zA-Z-]*): this +1\.1 ($username8 *[0-9a-zA-Z-]*): is +1\.2 ($username8 *[0-9a-zA-Z-]*): a +1\.1 ($username8 *[0-9a-zA-Z-]*): file +1\.2 ($username8 *[0-9a-zA-Z-]*): +1\.2 ($username8 *[0-9a-zA-Z-]*): with +1\.2 ($username8 *[0-9a-zA-Z-]*): a +1\.2 ($username8 *[0-9a-zA-Z-]*): blank +1\.2 ($username8 *[0-9a-zA-Z-]*): line +1\.2\.2\.1 ($username8 *[0-9a-zA-Z-]*): and some +1\.2\.2\.1 ($username8 *[0-9a-zA-Z-]*): branched content" + # FIXCVS: shouldn't "-r 1.2.0.2" be the same as "-r br"? + dotest ann-12 "${testcvs} ann -r 1.2.0.2 file1" "" + dotest ann-13 "${testcvs} ann -r 1.2.2 file1" \ +" +Annotations for file1 +\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* +1\.1 ($username8 *[0-9a-zA-Z-]*): this +1\.1 ($username8 *[0-9a-zA-Z-]*): is +1\.2 ($username8 *[0-9a-zA-Z-]*): a +1\.1 ($username8 *[0-9a-zA-Z-]*): file +1\.2 ($username8 *[0-9a-zA-Z-]*): +1\.2 ($username8 *[0-9a-zA-Z-]*): with +1\.2 ($username8 *[0-9a-zA-Z-]*): a +1\.2 ($username8 *[0-9a-zA-Z-]*): blank +1\.2 ($username8 *[0-9a-zA-Z-]*): line +1\.2\.2\.1 ($username8 *[0-9a-zA-Z-]*): and some +1\.2\.2\.1 ($username8 *[0-9a-zA-Z-]*): branched content" + dotest_fail ann-14 "$testcvs ann -r bill-clintons-chastity file1" \ +"$SPROG \[annotate aborted\]: no such tag \`bill-clintons-chastity'" + + # Now get rid of the working directory and test rannotate + + cd ../.. + rm -r 1 + dotest ann-r10 "${testcvs} rann first-dir" \ +" +Annotations for first-dir/file1 +\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* +1\.1 ($username8 *[0-9a-zA-Z-]*): this +1\.1 ($username8 *[0-9a-zA-Z-]*): is +1\.2 ($username8 *[0-9a-zA-Z-]*): a +1\.3 ($username8 *[0-9a-zA-Z-]*): trunk file +1\.2 ($username8 *[0-9a-zA-Z-]*): +1\.2 ($username8 *[0-9a-zA-Z-]*): with +1\.2 ($username8 *[0-9a-zA-Z-]*): a +1\.2 ($username8 *[0-9a-zA-Z-]*): blank +1\.2 ($username8 *[0-9a-zA-Z-]*): line" + dotest ann-r11 "${testcvs} rann -r br first-dir" \ +" +Annotations for first-dir/file1 +\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* +1\.1 ($username8 *[0-9a-zA-Z-]*): this +1\.1 ($username8 *[0-9a-zA-Z-]*): is +1\.2 ($username8 *[0-9a-zA-Z-]*): a +1\.1 ($username8 *[0-9a-zA-Z-]*): file +1\.2 ($username8 *[0-9a-zA-Z-]*): +1\.2 ($username8 *[0-9a-zA-Z-]*): with +1\.2 ($username8 *[0-9a-zA-Z-]*): a +1\.2 ($username8 *[0-9a-zA-Z-]*): blank +1\.2 ($username8 *[0-9a-zA-Z-]*): line +1\.2\.2\.1 ($username8 *[0-9a-zA-Z-]*): and some +1\.2\.2\.1 ($username8 *[0-9a-zA-Z-]*): branched content" + dotest ann-r12 "${testcvs} rann -r 1.2.0.2 first-dir/file1" "" + dotest ann-r13 "${testcvs} rann -r 1.2.2 first-dir/file1" \ +" +Annotations for first-dir/file1 +\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* +1\.1 ($username8 *[0-9a-zA-Z-]*): this +1\.1 ($username8 *[0-9a-zA-Z-]*): is +1\.2 ($username8 *[0-9a-zA-Z-]*): a +1\.1 ($username8 *[0-9a-zA-Z-]*): file +1\.2 ($username8 *[0-9a-zA-Z-]*): +1\.2 ($username8 *[0-9a-zA-Z-]*): with +1\.2 ($username8 *[0-9a-zA-Z-]*): a +1\.2 ($username8 *[0-9a-zA-Z-]*): blank +1\.2 ($username8 *[0-9a-zA-Z-]*): line +1\.2\.2\.1 ($username8 *[0-9a-zA-Z-]*): and some +1\.2\.2\.1 ($username8 *[0-9a-zA-Z-]*): branched content" + dotest_fail ann-r14 "$testcvs rann -r bill-clintons-chastity first-dir/file1" \ +"$SPROG \[rannotate aborted\]: no such tag \`bill-clintons-chastity'" + + dokeep + modify_repo rm -rf $CVSROOT_DIRNAME/first-dir + ;; + + + + ann-id) + # Demonstrate that cvs-1.9.28.1 improperly expands rcs keywords in + # the output of `cvs annotate' -- it uses values from the previous + # delta. In this case, `1.1' instead of `1.2', even though it puts + # the proper version number on the prefix to each line of output. + mkdir 1; cd 1 + dotest ann-id-1 "$testcvs -q co -l ." + module=x + mkdir $module + dotest ann-id-2 "${testcvs} add $module" \ +"Directory ${CVSROOT_DIRNAME}/$module added to the repository" + cd $module + + file=m + echo '$Id''$' > $file + + dotest ann-id-3 "$testcvs add $file" \ +"$SPROG add: scheduling file .$file. for addition +$SPROG add: use .$SPROG commit. to add this file permanently" + dotest ann-id-4 "$testcvs -Q ci -m . $file" + + echo line2 >> $file + dotest ann-id-5 "$testcvs -Q ci -m . $file" + + # The version number after $file,v should be `1.2'. + # 1.9.28.1 puts `1.1' there. + dotest ann-id-6 "$testcvs -Q ann $file" \ +" +Annotations for $file +\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* +1.2 ($username8 *[0-9a-zA-Z-]*): "'\$'"Id: $file,v 1.1 [0-9/]* [0-9:]* $username Exp "'\$'" +1.2 ($username8 *[0-9a-zA-Z-]*): line2" + + dokeep + cd ../.. + rm -rf 1 + modify_repo rm -rf $CVSROOT_DIRNAME/$module + ;; + + + + crerepos) + # Various tests relating to creating repositories, operating + # on repositories created with old versions of CVS, etc. + + CVS_SERVER_save=$CVS_SERVER + + # Because this test is all about -d options and such, it + # at least to some extent needs to be different for remote vs. + # local. + if $remote; then + + # Use :ext: rather than :fork:. Most of the tests use :fork:, + # so we want to make sure that we test :ext: _somewhere_. + # Make sure 'rsh' works first. + require_rsh "$CVS_RSH" + if test $? -eq 77; then + skip crerepos "$skipreason" + continue + fi + + # Make sure server ignores real $HOME/.cvsrc: + cat >$TESTDIR/cvs-setHome <<EOF +#!$TESTSHELL +HOME=$HOME +export HOME +exec $CVS_SERVER "\$@" +EOF + chmod a+x $TESTDIR/cvs-setHome + + # Note that we set CVS_SERVER at the beginning. + CVS_SERVER=$TESTDIR/cvs-setHome; export CVS_SERVER + CREREPOS_ROOT=:ext:$host$TESTDIR/crerepos + else # local + CREREPOS_ROOT=$TESTDIR/crerepos + fi + + # First, if the repository doesn't exist at all... + dotest_fail crerepos-1 \ +"${testcvs} -d ${TESTDIR}/crerepos co cvs-sanity" \ +"${SPROG} \[checkout aborted\]: ${TESTDIR}/crerepos/CVSROOT: .*" + mkdir crerepos + + # The repository exists but CVSROOT doesn't. + dotest_fail crerepos-2 \ +"${testcvs} -d ${TESTDIR}/crerepos co cvs-sanity" \ +"${SPROG} \[checkout aborted\]: ${TESTDIR}/crerepos/CVSROOT: .*" + mkdir crerepos/CVSROOT + + # Checkout of nonexistent module + dotest_fail crerepos-3 \ +"${testcvs} -d ${TESTDIR}/crerepos co cvs-sanity" \ +"${SPROG} checkout: cannot find module .cvs-sanity. - ignored" + + # Now test that CVS works correctly without a modules file + # or any of that other stuff. In particular, it *must* + # function if administrative files added to CVS recently (since + # CVS 1.3) do not exist, because the repository might have + # been created with an old version of CVS. + mkdir 1; cd 1 + dotest crerepos-4 \ +"${testcvs} -q -d ${TESTDIR}/crerepos co CVSROOT" \ +'' + dotest crerepos-5 \ +"echo yes | $testcvs -d $TESTDIR/crerepos release -d CVSROOT" \ +"You have \[0\] altered files in this repository\. +Are you sure you want to release (and delete) directory \`CVSROOT': " + rm -rf CVS + cd .. + # The directory 1 should be empty + dotest crerepos-6 "rmdir 1" + + if $remote; then + # Test that CVS rejects a relative path in CVSROOT. + mkdir 1; cd 1 + # Note that having the client reject the pathname (as :fork: + # does), does _not_ test for the bugs we are trying to catch + # here. The point is that malicious clients might send all + # manner of things and the server better protect itself. + dotest_fail crerepos-6a-r \ +"${testcvs} -q -d :ext:`hostname`:../crerepos get ." \ +"${CPROG} checkout: CVSROOT may only specify a positive, non-zero, integer port (not .\.\..)\. +${CPROG} checkout: Perhaps you entered a relative pathname${QUESTION} +${CPROG} \[checkout aborted\]: Bad CVSROOT: .:ext:${hostname}:\.\./crerepos.\." + cd .. + rm -r 1 + + mkdir 1; cd 1 + dotest_fail crerepos-6b-r \ +"${testcvs} -d :ext:`hostname`:crerepos init" \ +"${CPROG} init: CVSROOT requires a path spec: +${CPROG} init: :(gserver|kserver|pserver):\[\[user\]\[:password\]@\]host\[:\[port\]\]/path +${CPROG} init: \[:(ext|server):\]\[\[user\]@\]host\[:\]/path +${CPROG} \[init aborted\]: Bad CVSROOT: .:ext:${hostname}:crerepos.\." + cd .. + rm -r 1 + else # local + # Test that CVS rejects a relative path in CVSROOT. + + mkdir 1; cd 1 + # Set CVS_RSH=false since ocassionally (e.g. when CVS_RSH=ssh on + # some systems) some rsh implementations will block because they + # can look up '..' and want to ask the user about the unknown host + # key or somesuch. Which error message we get depends on whether + # false finishes running before we try to talk to it or not. + dotest_fail crerepos-6a "CVS_RSH=false ${testcvs} -q -d ../crerepos get ." \ +"${SPROG} \[checkout aborted\]: end of file from server (consult above messages if any)" \ +"${SPROG} \[checkout aborted\]: received broken pipe signal" + cd .. + rm -r 1 + + mkdir 1; cd 1 + dotest_fail crerepos-6b "${testcvs} -d crerepos init" \ +"${SPROG} init: CVSROOT must be an absolute pathname (not .crerepos.) +${SPROG} init: when using local access method\. +${SPROG} \[init aborted\]: Bad CVSROOT: .crerepos.\." + cd .. + rm -r 1 + fi # end of tests to be skipped for remote + + # CVS should have created a history file. If the administrator + # doesn't need it and wants to save on disk space, they just + # delete it and set LogHistory = the empty string in config. + dotest crerepos-7 "test -f $TESTDIR/crerepos/CVSROOT/history" + + # Now test mixing repositories. This kind of thing tends to + # happen accidentally when people work with several repositories. + mkdir 1; cd 1 + dotest crerepos-8 "${testcvs} -q co -l ." '' + mkdir first-dir + dotest crerepos-9 "${testcvs} add first-dir" \ +"Directory ${CVSROOT_DIRNAME}/first-dir added to the repository" + cd first-dir + touch file1 + dotest crerepos-10 "${testcvs} add file1" \ +"${SPROG} add: scheduling file .file1. for addition +${SPROG} add: use .${SPROG} commit. to add this file permanently" + dotest crerepos-11 "${testcvs} -q ci -m add-it" \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +initial revision: 1\.1" + cd ../.. + rm -r 1 + + mkdir 1; cd 1 + dotest crerepos-12 "$testcvs -d $CREREPOS_ROOT -q co -l ." + mkdir crerepos-dir + dotest crerepos-13 "$testcvs add crerepos-dir" \ +"Directory $TESTDIR/crerepos/crerepos-dir added to the repository" + cd crerepos-dir + touch cfile + dotest crerepos-14 "${testcvs} add cfile" \ +"${SPROG} add: scheduling file .cfile. for addition +${SPROG} add: use .${SPROG} commit. to add this file permanently" + dotest crerepos-15 "${testcvs} -q ci -m add-it" \ +"$TESTDIR/crerepos/crerepos-dir/cfile,v <-- cfile +initial revision: 1\.1" + cd ../.. + rm -r 1 + + mkdir 1; cd 1 + dotest crerepos-16 "${testcvs} co first-dir" \ +"${SPROG} checkout: Updating first-dir +U first-dir/file1" + dotest crerepos-17 "${testcvs} -d ${CREREPOS_ROOT} co crerepos-dir" \ +"${SPROG} checkout: Updating crerepos-dir +U crerepos-dir/cfile" + dotest crerepos-18 "${testcvs} update" \ +"${SPROG} update: Updating first-dir +${SPROG} update: Updating crerepos-dir" + + cd .. + + CVS_SERVER=$CVS_SERVER_save; export CVS_SERVER + + if $keep; then + echo Keeping ${TESTDIR} and exiting due to --keep + exit 0 + fi + + dokeep + rm -f $TESTDIR/cvs-setHome + rm -r 1 + modify_repo rm -rf $CVSROOT_DIRNAME/first-dir + rm -rf $TESTDIR/crerepos + ;; + + + + rcs) + # Test ability to import an RCS file. Note that this format + # is fixed--files written by RCS5, and other software which + # implements this format, will be out there "forever" and + # CVS must always be able to import such files. + + # See tests admin-13, admin-25 and rcs-8a for exporting RCS files. + + # Save the timezone and set it to UTC for these tests to make the + # value more predicatable. + save_TZ=$TZ + TZ=UTC0; export TZ + + modify_repo mkdir $CVSROOT_DIRNAME/first-dir + + # Currently the way to import an RCS file is to copy it + # directly into the repository. + # + # This file was written by RCS 5.7, and then the dates were + # hacked so that we test year 2000 stuff. Note also that + # "author" names are just strings, as far as importing + # RCS files is concerned--they need not correspond to user + # IDs on any particular system. + # + # I also tried writing a file with the RCS supplied with + # HPUX A.09.05. According to "man rcsintro" this is + # "Revision Number: 3.0; Release Date: 83/05/11". There + # were a few minor differences like whitespace but at least + # in simple cases like this everything else seemed the same + # as the file written by RCS 5.7 (so I won't try to make it + # a separate test case). + + cat <<EOF >$TESTDIR/file1,v +head 1.3; +access; +symbols; +locks; strict; +comment @# @; + + +1.3 +date ${RAWRCSDATE2000A}; author kingdon; state Exp; +branches; +next 1.2; + +1.2 +date ${RAWRCSDATE1996A}; author kingdon; state Exp; +branches; +next 1.1; + +1.1 +date ${RAWRCSDATE1996B}; author kingdon; state Exp; +branches; +next ; + + +desc +@file1 is for testing CVS +@ + + +1.3 +log +@delete second line; modify twelfth line +@ +text +@This is the first line +This is the third line +This is the fourth line +This is the fifth line +This is the sixth line +This is the seventh line +This is the eighth line +This is the ninth line +This is the tenth line +This is the eleventh line +This is the twelfth line (and what a line it is) +This is the thirteenth line +@ + + +1.2 +log +@add more lines +@ +text +@a1 1 +This is the second line +d11 1 +a11 1 +This is the twelfth line +@ + + +1.1 +log +@add file1 +@ +text +@d2 12 +@ +EOF + modify_repo mv $TESTDIR/file1,v $CVSROOT_DIRNAME/first-dir/file1,v + + dotest rcs-1 "$testcvs -q co first-dir" 'U first-dir/file1' + cd first-dir + dotest rcs-2 "$testcvs -q log" " +RCS file: $CVSROOT_DIRNAME/first-dir/file1,v +Working file: file1 +head: 1\.3 +branch: +locks: strict +access list: +symbolic names: +keyword substitution: kv +total revisions: 3; selected revisions: 3 +description: +file1 is for testing CVS +---------------------------- +revision 1\.3 +date: ${ISO8601DATE2000A}; author: kingdon; state: Exp; lines: ${PLUS}1 -2; +delete second line; modify twelfth line +---------------------------- +revision 1\.2 +date: ${ISO8601DATE1996A}; author: kingdon; state: Exp; lines: ${PLUS}12 -0; +add more lines +---------------------------- +revision 1\.1 +date: ${ISO8601DATE1996B}; author: kingdon; state: Exp; +add file1 +=============================================================================" + + # Note that the dates here are chosen so that (a) we test + # at least one date after 2000, (b) we will notice if the + # month and day are getting mixed up with each other. + # TODO: also test that year isn't getting mixed up with month + # or day, for example 01-02-03. + + # ISO8601 format. There are many, many, other variations + # specified by ISO8601 which we should be testing too. + dotest rcs-3 "${testcvs} -q log -d '1996-12-11<'" " +RCS file: ${CVSROOT_DIRNAME}/first-dir/file1,v +Working file: file1 +head: 1\.3 +branch: +locks: strict +access list: +symbolic names: +keyword substitution: kv +total revisions: 3; selected revisions: 1 +description: +file1 is for testing CVS +---------------------------- +revision 1\.3 +date: ${ISO8601DATE2000A}; author: kingdon; state: Exp; lines: ${PLUS}1 -2; +delete second line; modify twelfth line +=============================================================================" + + # RFC822 format (as amended by RFC1123). + dotest rcs-4 "${testcvs} -q log -d '<3 Apr 2000 00:00'" \ +" +RCS file: ${CVSROOT_DIRNAME}/first-dir/file1,v +Working file: file1 +head: 1\.3 +branch: +locks: strict +access list: +symbolic names: +keyword substitution: kv +total revisions: 3; selected revisions: 2 +description: +file1 is for testing CVS +---------------------------- +revision 1\.2 +date: ${ISO8601DATE1996A}; author: kingdon; state: Exp; lines: ${PLUS}12 -0; +add more lines +---------------------------- +revision 1\.1 +date: ${ISO8601DATE1996B}; author: kingdon; state: Exp; +add file1 +=============================================================================" + + # Intended behavior for "cvs annotate" is that it displays the + # last two digits of the year. Make sure it does that rather + # than some bogosity like "100". + dotest rcs-4a "${testcvs} annotate file1" \ +" +Annotations for file1 +\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* +1\.1 (kingdon 24-Nov-96): This is the first line +1\.2 (kingdon 24-Nov-96): This is the third line +1\.2 (kingdon 24-Nov-96): This is the fourth line +1\.2 (kingdon 24-Nov-96): This is the fifth line +1\.2 (kingdon 24-Nov-96): This is the sixth line +1\.2 (kingdon 24-Nov-96): This is the seventh line +1\.2 (kingdon 24-Nov-96): This is the eighth line +1\.2 (kingdon 24-Nov-96): This is the ninth line +1\.2 (kingdon 24-Nov-96): This is the tenth line +1\.2 (kingdon 24-Nov-96): This is the eleventh line +1\.3 (kingdon 24-Nov-00): This is the twelfth line (and what a line it is) +1\.2 (kingdon 24-Nov-96): This is the thirteenth line" + + # Probably should split this test into two at this point (file1 + # above this line and file2 below), as the two share little + # data/setup. + + # OK, here is another one. This one was written by hand based on + # doc/RCSFILES and friends. One subtle point is that none of + # the lines end with newlines; that is a feature which we + # should be testing. + cat <<EOF >$TESTDIR/file2,v +head 1.5 ; + branch 1.2.6; +access ; +symbols branch:1.2.6; +locks; +testofanewphrase @without newphrase we'd have trouble extending @@ all@ ; +1.5 date 71.01.01.01.00.00; author joe; state bogus; branches; next 1.4; +1.4 date 71.01.01.00.00.05; author joe; state bogus; branches; next 1.3; +1.3 date 70.12.31.15.00.05; author joe; state bogus; branches; next 1.2; +1.2 date 70.12.31.12.15.05; author me; state bogus; branches 1.2.6.1; next 1.1; +1.1 date 70.12.31.11.00.05; author joe; state bogus; branches; next; newph; +1.2.6.1 date 71.01.01.08.00.05; author joe; state Exp; branches; next; +desc @@ +1.5 log @@ newphrase1; newphrase2 42; text @head revision@ +1.4 log @@ text @d1 1 +a1 1 +new year revision@ +1.3 log @@ text @d1 1 +a1 1 +old year revision@ +1.2 log @@ text @d1 1 +a1 1 +mid revision@ 1.1 + +log @@ text @d1 1 +a1 1 +start revision@ +1.2.6.1 log @@ text @d1 1 +a1 1 +branch revision@ +EOF + modify_repo mv $TESTDIR/file2,v $CVSROOT_DIRNAME/first-dir/file2,v + # ' Match the single quote in above here doc -- for font-lock mode. + + # First test the default branch. + dotest rcs-5 "${testcvs} -q update file2" "U file2" + dotest rcs-6 "cat file2" "branch revision" + + # Check in a revision on the branch to force CVS to + # interpret every revision in the file. + dotest rcs-6a "${testcvs} -q update -r branch file2" "" + echo "next branch revision" > file2 + dotest rcs-6b "${testcvs} -q ci -m mod file2" \ +"$CVSROOT_DIRNAME/first-dir/file2,v <-- file2 +new revision: 1\.2\.6\.2; previous revision: 1\.2\.6\.1" + + # Now get rid of the default branch, it will get in the way. + dotest rcs-7 "${testcvs} admin -b file2" \ +"RCS file: ${CVSROOT_DIRNAME}/first-dir/file2,v +done" + # But we do want to make sure that "cvs admin" leaves the newphrases + # in the file. + # The extra whitespace regexps are for the RCS library, which does + # not preserve whitespace in the dogmatic manner of RCS 5.7. -twp + dotest rcs-8 \ +"grep testofanewphrase ${CVSROOT_DIRNAME}/first-dir/file2,v" \ +"testofanewphrase[ ][ ]*@without newphrase we'd have trouble extending @@ all@[ ]*;" + # The easiest way to test for newphrases in deltas and deltatexts + # is to just look at the whole file, I guess. + dotest rcs-8a "cat ${CVSROOT_DIRNAME}/first-dir/file2,v" \ +"head 1\.5; +access; +symbols + branch:1.2.6; +locks; + +testofanewphrase @without newphrase we'd have trouble extending @@ all@; + +1\.5 +date 71\.01\.01\.01\.00\.00; author joe; state bogus; +branches; +next 1\.4; + +1\.4 +date 71\.01\.01\.00\.00\.05; author joe; state bogus; +branches; +next 1\.3; + +1\.3 +date 70\.12\.31\.15\.00\.05; author joe; state bogus; +branches; +next 1\.2; + +1\.2 +date 70\.12\.31\.12\.15\.05; author me; state bogus; +branches + 1\.2\.6\.1; +next 1\.1; + +1\.1 +date 70\.12\.31\.11\.00\.05; author joe; state bogus; +branches; +next ; +newph ; + +1\.2\.6\.1 +date 71\.01\.01\.08\.00\.05; author joe; state Exp; +branches; +next 1\.2\.6\.2; + +1\.2\.6\.2 +date [0-9.]*; author ${username}; state Exp; +branches; +next ; +commitid ${commitid}; + + +desc +@@ + + +1\.5 +log +@@ +newphrase1 ; +newphrase2 42; +text +@head revision@ + + +1\.4 +log +@@ +text +@d1 1 +a1 1 +new year revision@ + + +1\.3 +log +@@ +text +@d1 1 +a1 1 +old year revision@ + + +1\.2 +log +@@ +text +@d1 1 +a1 1 +mid revision@ + + +1\.1 +log +@@ +text +@d1 1 +a1 1 +start revision@ + + +1\.2\.6\.1 +log +@@ +text +@d1 1 +a1 1 +branch revision@ + + +1\.2\.6\.2 +log +@mod +@ +text +@d1 1 +a1 1 +next branch revision +@" + + dotest rcs-9 "${testcvs} -q update -p -D '1970-12-31 11:30 UT' file2" \ +"start revision" + + dotest rcs-10 "${testcvs} -q update -p -D '1970-12-31 12:30 UT' file2" \ +"mid revision" + + dotest rcs-11 "${testcvs} -q update -p -D '1971-01-01 00:30 UT' file2" \ +"new year revision" + + # Same test as rcs-10, but with am/pm. + dotest rcs-12 "${testcvs} -q update -p -D 'December 31, 1970 12:30pm UT' file2" \ +"mid revision" + + # Same test as rcs-11, but with am/pm. + dotest rcs-13 "${testcvs} -q update -p -D 'January 1, 1971 12:30am UT' file2" \ +"new year revision" + + # OK, now make sure cvs log doesn't have any trouble with the + # newphrases and such. + dotest rcs-14 "${testcvs} -q log file2" " +RCS file: ${CVSROOT_DIRNAME}/first-dir/file2,v +Working file: file2 +head: 1\.5 +branch: +locks: +access list: +symbolic names: + branch: 1\.2\.6 +keyword substitution: kv +total revisions: 7; selected revisions: 7 +description: +---------------------------- +revision 1\.5 +date: 1971-01-01 01:00:00 [+-]0000; author: joe; state: bogus; lines: ${PLUS}1 -1; +\*\*\* empty log message \*\*\* +---------------------------- +revision 1\.4 +date: 1971-01-01 00:00:05 [+-]0000; author: joe; state: bogus; lines: ${PLUS}1 -1; +\*\*\* empty log message \*\*\* +---------------------------- +revision 1\.3 +date: 1970-12-31 15:00:05 [+-]0000; author: joe; state: bogus; lines: ${PLUS}1 -1; +\*\*\* empty log message \*\*\* +---------------------------- +revision 1\.2 +date: 1970-12-31 12:15:05 [+-]0000; author: me; state: bogus; lines: ${PLUS}1 -1; +branches: 1\.2\.6; +\*\*\* empty log message \*\*\* +---------------------------- +revision 1\.1 +date: 1970-12-31 11:00:05 [+-]0000; author: joe; state: bogus; +\*\*\* empty log message \*\*\* +---------------------------- +revision 1\.2\.6\.2 +date: ${ISO8601DATE}; author: ${username}; state: Exp; lines: ${PLUS}1 -1; commitid: ${commitid}; +mod +---------------------------- +revision 1\.2\.6\.1 +date: 1971-01-01 08:00:05 [+-]0000; author: joe; state: Exp; lines: ${PLUS}1 -1; +\*\*\* empty log message \*\*\* +=============================================================================" + # Now test each date format for "cvs log -d". + # Earlier than 1971-01-01 + dotest rcs-15 "${testcvs} -q log -d '<1971-01-01 00:00 GMT' file2 \ + | grep revision" \ +"total revisions: 7; selected revisions: 3 +revision 1\.3 +revision 1\.2 +revision 1\.1" + # Later than 1971-01-01 + dotest rcs-16 "${testcvs} -q log -d '1971-01-01 00:00 GMT<' file2 \ + | grep revision" \ +"total revisions: 7; selected revisions: 4 +revision 1\.5 +revision 1\.4 +revision 1\.2\.6\.2 +revision 1\.2\.6\.1" + # Alternate syntaxes for later and earlier; multiple -d options + dotest rcs-17 "${testcvs} -q log -d '>1971-01-01 00:00 GMT' \ + -d '1970-12-31 12:15 GMT>' file2 | grep revision" \ +"total revisions: 7; selected revisions: 5 +revision 1\.5 +revision 1\.4 +revision 1\.1 +revision 1\.2\.6\.2 +revision 1\.2\.6\.1" + # Range, and single date + dotest rcs-18 "${testcvs} -q log -d '1970-12-31 11:30 GMT' \ + -d '1971-01-01 00:00:05 GMT<1971-01-01 01:00:01 GMT' \ + file2 | grep revision" \ +"total revisions: 7; selected revisions: 2 +revision 1\.5 +revision 1\.1" + # Alternate range syntax; equality + dotest rcs-19 "${testcvs} -q log \ + -d '1971-01-01 01:00:01 GMT>=1971-01-01 00:00:05 GMT' \ + file2 | grep revision" \ +"total revisions: 7; selected revisions: 2 +revision 1\.5 +revision 1\.4" + + dokeep + TZ=$save_TZ + cd .. + rm -r first-dir + modify_repo rm -rf $CVSROOT_DIRNAME/first-dir + ;; + + + + rcs2) + # More date tests. Might as well do this as a separate + # test from "rcs", so that we don't need to perturb the + # "written by RCS 5.7" RCS file. + modify_repo mkdir $CVSROOT_DIRNAME/first-dir + # Significance of various dates: + # * At least one Y2K standard refers to recognizing 9 Sep 1999 + # (as an example of a pre-2000 date, I guess). + # * At least one Y2K standard refers to recognizing 1 Jan 2001 + # (as an example of a post-2000 date, I guess). + # * Many Y2K standards refer to 2000 being a leap year. + cat <<EOF >$TESTDIR/file1,v +head 1.7; access; symbols; locks; strict; +1.7 date 2004.08.31.01.01.01; author sue; state; branches; next 1.6; +1.6 date 2004.02.29.01.01.01; author sue; state; branches; next 1.5; +1.5 date 2003.02.28.01.01.01; author sue; state; branches; next 1.4; +1.4 date 2001.01.01.01.01.01; author sue; state; branches; next 1.3; +1.3 date 2000.02.29.01.01.01; author sue; state; branches; next 1.2; +1.2 date 99.09.09.01.01.01; author sue; state; branches; next 1.1; +1.1 date 98.09.10.01.01.01; author sue; state; branches; next; +desc @a test file@ +1.7 log @@ text @head revision@ +1.6 log @@ text @d1 1 +a1 1 +2004 was a great year for leaping@ +1.5 log @@ text @d1 1 +a1 1 +2003 wasn't@ +1.4 log @@ text @d1 1 +a1 1 +two year hiatus@ +1.3 log @@ text @d1 1 +a1 1 +2000 is also a good year for leaping@ +1.2 log @@ text @d1 1 +a1 1 +Tonight we're going to party like it's a certain year@ +1.1 log @@ text @d1 1 +a1 1 +Need to start somewhere@ +EOF + modify_repo mv $TESTDIR/file1,v $CVSROOT_DIRNAME/first-dir/file1,v + # ' Match the 3rd single quote in the here doc -- for font-lock mode. + + dotest rcs2-1 "${testcvs} -q co first-dir" 'U first-dir/file1' + cd first-dir + + # 9 Sep 1999 + dotest rcs2-2 "${testcvs} -q update -p -D '1999-09-09 11:30 UT' file1" \ +"Tonight we're going to party like it's a certain year" + # 1 Jan 2001. + dotest rcs2-3 "${testcvs} -q update -p -D '2001-01-01 11:30 UT' file1" \ +"two year hiatus" + # 29 Feb 2000 + dotest rcs2-4 "${testcvs} -q update -p -D '2000-02-29 11:30 UT' file1" \ +"2000 is also a good year for leaping" + # 29 Feb 2003 is invalid + dotest_fail rcs2-5 "${testcvs} -q update -p -D '2003-02-29 11:30 UT' file1" \ +"$CPROG \[update aborted\]: Can't parse date/time: \`2003-02-29 11:30 UT'" + + dotest rcs2-6 "${testcvs} -q update -p -D 2007-01-07 file1" \ +"head revision" + # This assumes that the clock of the machine running the tests + # is set to at least the year 1998 or so. There don't seem + # to be a lot of ways to test the relative date code (short + # of something like LD_LIBRARY_PRELOAD'ing in our own + # getttimeofday, or hacking the CVS source with testing + # features, which always seems to be problematic since then + # someone feels like documenting them and things go downhill + # from there). + # + # These tests can be expected to fail 3 times every 400 years + # starting Feb. 29, 2096 (because 8 years from that date would + # be Feb. 29, 2100, which is an invalid date -- 2100 isn't a + # leap year because it's divisible by 100 but not by 400). + + dotest rcs2-7 "${testcvs} -q update -p -D '96 months' file1" \ +"head revision" + dotest rcs2-8 "${testcvs} -q update -p -D '8 years' file1" \ +"head revision" + + dokeep + cd .. + rm -r first-dir + modify_repo rm -rf $CVSROOT_DIRNAME/first-dir + ;; + + + + rcs3) + # More RCS file tests, in particular at least some of the + # error handling issues. + mkdir ${CVSROOT_DIRNAME}/first-dir + cat <<EOF >$TESTDIR/file1,v +head 1.1; access; symbols; locks; expand o; 1.1 date 2007.03.20.04.03.02 +; author jeremiah ;state ; branches; next;desc@@1.1log@@text@head@ +EOF + modify_repo mv $TESTDIR/file1,v $CVSROOT_DIRNAME/first-dir/file1,v + mkdir 1; cd 1 + # CVS requires whitespace between "desc" and its value. + # The rcsfile(5) manpage doesn't really seem to answer the + # question one way or the other (it has a grammar but almost + # nothing about lexical analysis). + dotest_fail rcs3-1 "${testcvs} -q co first-dir" \ +"${SPROG} \[checkout aborted\]: EOF while looking for value in RCS file ${CVSROOT_DIRNAME}/first-dir/file1,v" + cat <<EOF >$TESTDIR/file1,v +head 1.1; access; symbols; locks; expand o; 1.1 date 2007.03.20.04.03.02 +; author jeremiah ;state ; branches; next;desc @@1.1log@@text@head@ +EOF + modify_repo mv $TESTDIR/file1,v $CVSROOT_DIRNAME/first-dir/file1,v + # Whitespace issues, likewise. + dotest_fail rcs3-2 "${testcvs} -q co first-dir" \ +"${SPROG} \[checkout aborted\]: unexpected '.x6c' reading revision number in RCS file ${CVSROOT_DIRNAME}/first-dir/file1,v" + cat <<EOF >$TESTDIR/file1,v +head 1.1; access; symbols; locks; expand o; 1.1 date 2007.03.20.04.03.02 +; author jeremiah ;state ; branches; next;desc @@1.1 log@@text@head@ +EOF + modify_repo mv $TESTDIR/file1,v $CVSROOT_DIRNAME/first-dir/file1,v + # Charming array of different messages for similar + # whitespace issues (depending on where the whitespace is). + dotest_fail rcs3-3 "${testcvs} -q co first-dir" \ +"${SPROG} \[checkout aborted\]: EOF while looking for value in RCS file ${CVSROOT_DIRNAME}/first-dir/file1,v" + cat <<EOF >$TESTDIR/file1,v +head 1.1; access; symbols; locks; expand o; 1.1 date 2007.03.20.04.03.02 +; author jeremiah ;state ; branches; next;desc @@1.1 log @@text @head@ +EOF + modify_repo mv $TESTDIR/file1,v $CVSROOT_DIRNAME/first-dir/file1,v + dotest rcs3-4 "${testcvs} -q co first-dir" 'U first-dir/file1' + + # Ouch, didn't expect this one. FIXCVS. Or maybe just remove + # the feature, if this is a -s problem? + dotest_fail rcs3-5 "${testcvs} log -s nostate first-dir/file1" \ +"${DOTSTAR}ssertion.*failed${DOTSTAR}" "${DOTSTAR}failed assertion${DOTSTAR}" + cd first-dir + dotest_fail rcs3-5a "${testcvs} log -s nostate file1" \ +"${DOTSTAR}ssertion.*failed${DOTSTAR}" "${DOTSTAR}failed assertion${DOTSTAR}" + cd .. + + # See remote code above for rationale for cd. + cd first-dir + dotest rcs3-6 "${testcvs} log -R file1" \ +"${CVSROOT_DIRNAME}/first-dir/file1,v" + + # OK, now put an extraneous '\0' at the end. + mv $CVSROOT_DIRNAME/first-dir/file1,v $TESTDIR/file1,v + ${AWK} </dev/null 'BEGIN { printf "@%c", 10 }' | ${TR} '@' '\000' \ + >>$TESTDIR/file1,v + modify_repo mv $TESTDIR/file1,v $CVSROOT_DIRNAME/first-dir/file1,v + dotest_fail rcs3-7 "${testcvs} log -s nostate file1" \ +"${SPROG} \[log aborted\]: unexpected '.x0' reading revision number in RCS file ${CVSROOT_DIRNAME}/first-dir/file1,v" + + dokeep + cd ../.. + rm -r 1 + modify_repo rm -rf $CVSROOT_DIRNAME/first-dir + ;; + + + + rcs4) + # Fix a bug that shows up when checking out files by date with the + # "-D date" command line option. There is code in the original to + # handle a special case. If the date search finds revision 1.1 it + # is supposed to check whether revision 1.1.1.1 has the same date + # stamp, which would indicate that the file was originally brought + # in with "cvs import". In that case it is supposed to return the + # vendor branch version 1.1.1.1. + # + # However, there is a bug in the code. It actually compares + # the date of revision 1.1 for equality with the date given + # on the command line -- clearly wrong. This commit fixes + # the coding bug. + # + # There is an additional bug which is _not_ fixed yet. + # The date comparison should not be a strict + # equality test. It should allow a fudge factor of, say, 2-3 + # seconds. Old versions of CVS created the two revisions + # with two separate invocations of the RCS "ci" command. We + # have many old files in the tree in which the dates of + # revisions 1.1 and 1.1.1.1 differ by 1 second. + + # Need a predictable time zone. + save_TZ=$TZ + TZ=UTC0; export TZ + + mkdir rcs4 + cd rcs4 + + mkdir imp-dir + cd imp-dir + echo 'OpenMunger sources' >file1 + + # choose a time in the past to demonstrate the problem + touch -t 200012010123 file1 + + dotest_sort rcs4-1 \ +"${testcvs} import -d -m add rcs4-dir openmunger openmunger-1_0" \ +' + +N rcs4-dir/file1 +No conflicts created by this import' + echo 'OpenMunger sources release 1.1 extras' >>file1 + touch -t 200112011234 file1 + dotest_sort rcs4-2 \ +"${testcvs} import -d -m add rcs4-dir openmunger openmunger-1_1" \ +' + +No conflicts created by this import +U rcs4-dir/file1' + cd .. + # Next checkout the new module + dotest rcs4-3 \ +"${testcvs} -q co rcs4-dir" \ +'U rcs4-dir/file1' + cd rcs4-dir + echo 'local change' >> file1 + + # commit a local change + dotest rcs4-4 "${testcvs} -q commit -m hack file1" \ +"$CVSROOT_DIRNAME/rcs4-dir/file1,v <-- file1 +new revision: 1\.2; previous revision: 1\.1" + # now see if we get version 1.1 or 1.1.1.1 when we ask for + # a checkout by time... it really should be 1.1.1.1 as + # that was indeed the version that was visible at the target + # time. + dotest rcs4-5 \ +"${testcvs} -q update -D 'October 1, 2001 UTC' file1" \ +'[UP] file1' + dotest rcs4-6 \ +"${testcvs} -q status file1" \ +'=================================================================== +File: file1 Status: Up-to-date + + Working revision: 1\.1\.1\.1.* + Repository revision: 1\.1\.1\.1 '${CVSROOT_DIRNAME}'/rcs4-dir/file1,v + Commit Identifier: '${commitid}' + Sticky Tag: (none) + Sticky Date: 2001\.10\.01\.00\.00\.00 + Sticky Options: (none)' + + dokeep + TZ=$save_TZ + cd ../.. + rm -r rcs4 + modify_repo rm -rf $CVSROOT_DIRNAME/rcs4-dir + ;; + + + + rcs5) + # Some tests of the $Log keyword and log message without a trailing + # EOL. This used to look ugly and, in the worst case, could cause + # a seg fault due to a buffer overflow. + # + # Note that it should not be possible to create this situation via a + # CVS server (and any client), since the server itself inserts the + # trailing EOL onto log messages that are missing one. Still, we + # shouldn't segfault due to a corrupt RCS file and I think that a log + # message without the trailing EOL doesn't actually violate the RCS + # spec, though it doesn't appear to be possible to create such a log + # message using RCS 5.7. + + modify_repo mkdir $CVSROOT_DIRNAME/rcs5 + cat <<\EOF >$TESTDIR/file1,v +head 1.1; +access; +symbols; +locks; +expand kv; + +1.1 date 2007.03.20.04.03.02; author jeremiah; state Ext; branches; next; + +desc +@@ + +1.1 +log +@he always had very fine wine@ +text +@line1 +/* +EOF +echo ' * History: $''Log$' >>$TESTDIR/file1,v + cat <<\EOF >>$TESTDIR/file1,v + */ +line5 +@ +EOF + modify_repo mv $TESTDIR/file1,v $CVSROOT_DIRNAME/rcs5/file1,v + + mkdir rcs5 + cd rcs5 + dotest rcs5-1 "$testcvs -Q co rcs5" + dotest rcs5-2 "cat rcs5/file1" \ +"line1 +/\\* + \\* History: "'\$'"Log: file1,v "'\$'" + \\* History: Revision 1\.1 2007/03/20 04:03:02 jeremiah + \\* History: he always had very fine wine + \\* History: + \\*/ +line5" + + cd .. + rm -r rcs5 + modify_repo rm -rf $CVSROOT_DIRNAME/rcs5 + ;; + + + + lockfiles) + # Tests of CVS lock files. + # TODO-maybe: Add a test where we arrange for a loginfo + # script (or some such) to ensure that locks are in place + # so then we can see how they are behaving. + + if $proxy; then + # don't even try + continue + fi + + mkdir 1; cd 1 + mkdir sdir + mkdir sdir/ssdir + echo file >sdir/ssdir/file1 + dotest lockfiles-1 \ +"${testcvs} -Q import -m import-it first-dir bar baz" "" + cd .. + + mkdir 2; cd 2 + dotest lockfiles-2 "${testcvs} -q co first-dir" \ +"U first-dir/sdir/ssdir/file1" + dotest lockfiles-3 "${testcvs} -Q co CVSROOT" "" + cd CVSROOT + echo "LockDir=${TESTDIR}/locks" >>config + dotest lockfiles-4 "${testcvs} -q ci -m config-it" \ +"$CVSROOT_DIRNAME/CVSROOT/config,v <-- config +new revision: 1\.[0-9]*; previous revision: 1\.[0-9]* +$SPROG commit: Rebuilding administrative file database" + cd ../first-dir/sdir/ssdir + # The error message appears twice because Lock_Cleanup only + # stops recursing after the first attempt. + dotest_fail lockfiles-5 "${testcvs} -q update" \ +"${SPROG} \[update aborted\]: cannot stat ${TESTDIR}/locks: No such file or directory" + mkdir ${TESTDIR}/locks + # Grumble, mumble. Cygwin. + if test -n "$remotehost"; then + $CVS_RSH $remotehost "chmod u=rwx,g=r,o= ${TESTDIR}/locks" + else + chmod u=rwx,g=r,o= ${TESTDIR}/locks + fi + save_umask=`umask` + umask 0077 + CVSUMASK=0077; export CVSUMASK + dotest lockfiles-6 "${testcvs} -q update" "" + # TODO: should also be testing that CVS continues to honor the + # umask and CVSUMASK normally. In the case of the umask, CVS + # doesn't seem to use it for much (although it perhaps should). + dotest lockfiles-7 "ls ${TESTDIR}/locks/first-dir/sdir/ssdir" "" + + # The policy is that when CVS creates new lock directories, they + # inherit the permissions from the parent directory. CVSUMASK + # isn't right, because typically the reason for LockDir is to + # use a different set of permissions. + # + # Bah! Cygwin! + if test -n "$remotehost"; then + dotest lockfiles-7a "$CVS_RSH $remotehost 'ls -ld ${TESTDIR}/locks/first-dir'" \ +"drwxr-----.*first-dir" + dotest lockfiles-7b "$CVS_RSH $remotehost 'ls -ld ${TESTDIR}/locks/first-dir/sdir/ssdir'" \ +"drwxr-----.*first-dir/sdir/ssdir" + else + dotest lockfiles-7a "ls -ld ${TESTDIR}/locks/first-dir" \ +"drwxr-----.*first-dir" + dotest lockfiles-7b "ls -ld ${TESTDIR}/locks/first-dir/sdir/ssdir" \ +"drwxr-----.*first-dir/sdir/ssdir" + fi + + cd ../../.. + dotest lockfiles-8 "${testcvs} -q update" "" + dotest lockfiles-9 "${testcvs} -q co -l ." "" + + ### + ### There are race conditions in the following tests, but hopefully + ### the 5 seconds the first process waits to remove the lockdir and + ### the 30 seconds CVS waits betweens checks will be significant + ### enough to render the case moot. + ### + # Considers the following cases: + # + # Lock Present + # Operation Allowed (case #) + # + # Read Promotable Write + # _______ __________ ______ + # Read |Yes (1) Yes (2) No (3) + # Promotable Read |Yes (4) No (5) No (6) + # Write |No (7) No (8) No (9) + # + # Tests do not appear in same ordering as table: + # 1. Read when read locks are present... + # 2. Read when promotable locks are present... + # 3. Don't read when write locks present... + # 4. Read but don't write when read locks are present... (fail + # commit up-to-date check with promotable lock present). + # 5. Don't allow promotable read when promotable locks are present... + # (fail to perform commit up-to-date check with promotable lock + # present). + # 6. Don't allow promotable read when write locks are present... + # (fail to perform commit up-to-date check with promotable lock + # present). + # 7. Don't write when read locks are present... + # 8. Don't write when promotable locks are present... + # 9. Don't write when write locks are present... + + # 3. Don't read when write locks present... + mkdir "$TESTDIR/locks/first-dir/#cvs.lock" + (sleep 5; rmdir "$TESTDIR/locks/first-dir/#cvs.lock")& + dotest lockfiles-10 "$testcvs -q co -l first-dir" \ +"$SPROG checkout: \[[0-9:]*\] waiting for $username's lock in $CVSROOT_DIRNAME/first-dir +$SPROG checkout: \[[0-9:]*\] obtained lock in $CVSROOT_DIRNAME/first-dir" + + # 1. Read when read locks are present... + touch "$TESTDIR/locks/first-dir/#cvs.rfl.test.lock" + dotest lockfiles-11 "$testcvs -q co -l first-dir" + rm "$TESTDIR/locks/first-dir/#cvs.rfl.test.lock" + + # 2. Read when promotable locks are present... + cd .. + mkdir 3; cd 3 + touch "$TESTDIR/locks/first-dir/sdir/ssdir/#cvs.pfl.test.lock" + dotest lockfiles-12 "$testcvs -q co first-dir" \ +"U first-dir/sdir/ssdir/file1" + rm "$TESTDIR/locks/first-dir/sdir/ssdir/#cvs.pfl.test.lock" + + # 7. Don't write when read locks are present... + echo I always have trouble coming up with witty text for the test files >>first-dir/sdir/ssdir/file1 + touch "$TESTDIR/locks/first-dir/sdir/ssdir/#cvs.rfl.test.lock" + (sleep 5; rm "$TESTDIR/locks/first-dir/sdir/ssdir/#cvs.rfl.test.lock")& + dotest lockfiles-13 "$testcvs -q ci -mconflict first-dir" \ +"$SPROG commit: \[[0-9:]*\] waiting for $username's lock in $CVSROOT_DIRNAME/first-dir/sdir/ssdir +$SPROG commit: \[[0-9:]*\] obtained lock in $CVSROOT_DIRNAME/first-dir/sdir/ssdir +$CVSROOT_DIRNAME/first-dir/sdir/ssdir/file1,v <-- first-dir/sdir/ssdir/file1 +new revision: 1\.2; previous revision: 1\.1" + + # 4. Read but don't write when read locks are present... (fail + # commit up-to-date check with promotable lock present). + cd ../2 + echo something that would render readers all full of smiles >>first-dir/sdir/ssdir/file1 + touch "$TESTDIR/locks/first-dir/sdir/ssdir/#cvs.rfl.test.lock" + dotest_fail lockfiles-14 "$testcvs -q ci -mnot-up-to-date first-dir" \ +"$SPROG commit: Up-to-date check failed for \`first-dir/sdir/ssdir/file1' +$SPROG \[commit aborted\]: correct above errors first!" + rm "$TESTDIR/locks/first-dir/sdir/ssdir/#cvs.rfl.test.lock" + + # 5. Don't allow promotable read when promotable locks are present... + # (fail to perform commit up-to-date check with promotable lock + # present). + touch "$TESTDIR/locks/first-dir/sdir/ssdir/#cvs.pfl.test.lock" + (sleep 5; rm "$TESTDIR/locks/first-dir/sdir/ssdir/#cvs.pfl.test.lock")& + dotest_fail lockfiles-15 "$testcvs -q ci -mnot-up-to-date first-dir" \ +"$SPROG commit: \[[0-9:]*\] waiting for $username's lock in $CVSROOT_DIRNAME/first-dir/sdir/ssdir +$SPROG commit: \[[0-9:]*\] obtained lock in $CVSROOT_DIRNAME/first-dir/sdir/ssdir +$SPROG commit: Up-to-date check failed for \`first-dir/sdir/ssdir/file1' +$SPROG \[commit aborted\]: correct above errors first!" + + # 6. Don't allow promotable read when write locks are present... + # (fail to perform commit up-to-date check with promotable lock + # present). + mkdir "$TESTDIR/locks/first-dir/sdir/ssdir/#cvs.lock" + (sleep 5; rmdir "$TESTDIR/locks/first-dir/sdir/ssdir/#cvs.lock")& + dotest_fail lockfiles-16 "$testcvs -q ci -mnot-up-to-date first-dir" \ +"$SPROG commit: \[[0-9:]*\] waiting for $username's lock in $CVSROOT_DIRNAME/first-dir/sdir/ssdir +$SPROG commit: \[[0-9:]*\] obtained lock in $CVSROOT_DIRNAME/first-dir/sdir/ssdir +$SPROG commit: Up-to-date check failed for \`first-dir/sdir/ssdir/file1' +$SPROG \[commit aborted\]: correct above errors first!" + + # 8. Don't write when promotable locks are present... + dotest lockfiles-17 "$testcvs -Q up -C first-dir/sdir/ssdir" + echo the kinds of smiles that light faces for miles >>first-dir/sdir/ssdir/file1 + touch "$TESTDIR/locks/first-dir/sdir/ssdir/#cvs.pfl.test.lock" + (sleep 5; rm "$TESTDIR/locks/first-dir/sdir/ssdir/#cvs.pfl.test.lock")& + dotest lockfiles-18 "$testcvs -q ci -mnot-up-to-date first-dir" \ +"$SPROG commit: \[[0-9:]*\] waiting for $username's lock in $CVSROOT_DIRNAME/first-dir/sdir/ssdir +$SPROG commit: \[[0-9:]*\] obtained lock in $CVSROOT_DIRNAME/first-dir/sdir/ssdir +$CVSROOT_DIRNAME/first-dir/sdir/ssdir/file1,v <-- first-dir/sdir/ssdir/file1 +new revision: 1\.3; previous revision: 1\.2" + + # 9. Don't write when write locks are present... + echo yet this poem would probably only give longfellow bile >>first-dir/sdir/ssdir/file1 + mkdir "$TESTDIR/locks/first-dir/sdir/ssdir/#cvs.lock" + (sleep 5; rmdir "$TESTDIR/locks/first-dir/sdir/ssdir/#cvs.lock")& + dotest lockfiles-19 "$testcvs -q ci -mnot-up-to-date first-dir" \ +"$SPROG commit: \[[0-9:]*\] waiting for $username's lock in $CVSROOT_DIRNAME/first-dir/sdir/ssdir +$SPROG commit: \[[0-9:]*\] obtained lock in $CVSROOT_DIRNAME/first-dir/sdir/ssdir +$CVSROOT_DIRNAME/first-dir/sdir/ssdir/file1,v <-- first-dir/sdir/ssdir/file1 +new revision: 1\.4; previous revision: 1\.3" + + # 10. Don't write when history locks are present... + echo have you ever heard a poem quite so vile\? >>first-dir/sdir/ssdir/file1 + mkdir "$TESTDIR/locks/CVSROOT/#cvs.history.lock" + (sleep 5; rmdir "$TESTDIR/locks/CVSROOT/#cvs.history.lock")& + dotest lockfiles-20 "$testcvs -q ci -mnot-up-to-date first-dir" \ +"$CVSROOT_DIRNAME/first-dir/sdir/ssdir/file1,v <-- first-dir/sdir/ssdir/file1 +new revision: 1\.5; previous revision: 1\.4 +$SPROG commit: \[[0-9:]*\] waiting for $username's lock in $CVSROOT_DIRNAME/CVSROOT +$SPROG commit: \[[0-9:]*\] obtained lock in $CVSROOT_DIRNAME/CVSROOT" + + dotest lockfiles-21 "$testcvs -Q tag newtag first-dir" + + rm $CVSROOT_DIRNAME/CVSROOT/val-tags + mkdir "$TESTDIR/locks/CVSROOT/#cvs.val-tags.lock" + (sleep 5; rmdir "$TESTDIR/locks/CVSROOT/#cvs.val-tags.lock")& + dotest lockfiles-22 "$testcvs -q up -r newtag first-dir" \ +"$SPROG update: \[[0-9:]*\] waiting for $username's lock in $CVSROOT_DIRNAME/CVSROOT +$SPROG update: \[[0-9:]*\] obtained lock in $CVSROOT_DIRNAME/CVSROOT" + + cd CVSROOT + dotest lockfiles-cleanup-1 "$testcvs -q up -pr1.1 config >config" "" + dotest lockfiles-cleanup-2 "$testcvs -q ci -m config-it" \ +"$CVSROOT_DIRNAME/CVSROOT/config,v <-- config +new revision: 1\.[0-9]*; previous revision: 1\.[0-9]* +$SPROG commit: Rebuilding administrative file database" + + dokeep + cd ../.. + # Restore umask. + umask $save_umask + unset CVSUMASK + rm -r $TESTDIR/locks + rm -r 1 2 3 + modify_repo rm -rf $CVSROOT_DIRNAME/first-dir + ;; + + + + backuprecover) + # Tests to make sure we get the expected behavior + # when we recover a repository from an old backup + # + # Details: + # Backup will be older than some developer's workspaces + # This means the first attempt at an update will fail + # The workaround for this is to replace the CVS + # directories with those from a "new" checkout from + # the recovered repository. Due to this, multiple + # merges should cause conflicts (the same data + # will be merged more than once). + # A workspace updated before the date of the recovered + # copy will not need any extra attention + # + # Note that backuprecover-15 is probably a failure case + # If nobody else had a more recent update, the data would be lost + # permanently + # Granted, the developer should have been notified not to do this + # by now, but still... + # + mkdir backuprecover; cd backuprecover + mkdir 1; cd 1 + dotest backuprecover-1 "$testcvs -q co -l ." + mkdir first-dir + dotest backuprecover-2 "${testcvs} add first-dir" \ +"Directory ${CVSROOT_DIRNAME}/first-dir added to the repository" + cd first-dir + mkdir dir + dotest backuprecover-3 "${testcvs} add dir" \ +"Directory ${CVSROOT_DIRNAME}/first-dir/dir added to the repository" + touch file1 dir/file2 + dotest backuprecover-4 "${testcvs} -q add file1 dir/file2" \ +"${SPROG} add: use \`${SPROG} commit' to add these files permanently" + dotest backuprecover-5 "${testcvs} -q ci -mtest" \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +initial revision: 1\.1 +$CVSROOT_DIRNAME/first-dir/dir/file2,v <-- dir/file2 +initial revision: 1\.1" + echo "Line one" >>file1 + echo " is the place" >>file1 + echo " we like to begin" >>file1 + echo "Anything else" >>file1 + echo " looks like" >>file1 + echo " a sin" >>file1 + echo "File 2" >>dir/file2 + echo " is the place" >>dir/file2 + echo " the rest of it goes" >>dir/file2 + echo "Why I don't use" >>dir/file2 + echo " something like 'foo'" >>dir/file2 + echo " God only knows" >>dir/file2 + dotest backuprecover-6 "${testcvs} -q ci -mtest" \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +new revision: 1\.2; previous revision: 1\.1 +$CVSROOT_DIRNAME/first-dir/dir/file2,v <-- dir/file2 +new revision: 1\.2; previous revision: 1\.1" + + # Simulate the lazy developer + # (he did some work but didn't check it in...) + cd ../.. + mkdir 2; cd 2 + dotest backuprecover-7 "${testcvs} -Q co first-dir" '' + cd first-dir + sed -e "s/looks like/just looks like/" file1 >tmp; mv tmp file1 + sed -e "s/don't use/don't just use/" dir/file2 >tmp; mv tmp dir/file2 + + # developer 1 is on a roll + cd ../../1/first-dir + echo "I need some more words" >>file1 + echo " to fill up this space" >>file1 + echo " anything else would be a disgrace" >>file1 + echo "My rhymes cross many boundries" >>dir/file2 + echo " this time it's files" >>dir/file2 + echo " a word that fits here would be something like dials" >>dir/file2 + dotest backuprecover-8 "${testcvs} -q ci -mtest" \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +new revision: 1\.3; previous revision: 1\.2 +$CVSROOT_DIRNAME/first-dir/dir/file2,v <-- dir/file2 +new revision: 1\.3; previous revision: 1\.2" + + # Save a backup copy + cp -R $CVSROOT_DIRNAME/first-dir $TESTDIR/backup + + # Simulate developer 3 + cd ../.. + mkdir 3; cd 3 + dotest backuprecover-9a "${testcvs} -Q co first-dir" '' + cd first-dir + echo >>file1 + echo >>dir/file2 + echo "Developer 1 makes very lame rhymes" >>file1 + echo " I think he should quit and become a mime" >>file1 + echo "What the %*^# kind of rhyme crosses a boundry?" >>dir/file2 + echo " I think you should quit and get a job in the foundry" >>dir/file2 + dotest backuprecover-9b "${testcvs} -q ci -mtest" \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +new revision: 1\.4; previous revision: 1\.3 +$CVSROOT_DIRNAME/first-dir/dir/file2,v <-- dir/file2 +new revision: 1\.4; previous revision: 1\.3" + + # Developer 4 so we can simulate a conflict later... + cd ../.. + mkdir 4; cd 4 + dotest backuprecover-10 "${testcvs} -Q co first-dir" '' + cd first-dir + sed -e "s/quit and/be fired so he can/" dir/file2 >tmp; mv tmp dir/file2 + + # And back to developer 1 + cd ../../1/first-dir + dotest backuprecover-11 "${testcvs} -Q update" '' + echo >>file1 + echo >>dir/file2 + echo "Oh yeah, well rhyme this" >>file1 + echo " developer three" >>file1 + echo " you want opposition" >>file1 + echo " you found some in me!" >>file1 + echo "I'll give you mimes" >>dir/file2 + echo " and foundries galore!" >>dir/file2 + echo " your head will spin" >>dir/file2 + echo " once you find what's in store!" >>dir/file2 + dotest backuprecover-12 "${testcvs} -q ci -mtest" \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +new revision: 1\.5; previous revision: 1\.4 +$CVSROOT_DIRNAME/first-dir/dir/file2,v <-- dir/file2 +new revision: 1\.5; previous revision: 1\.4" + + # developer 3'll do a bit of work that never gets checked in + cd ../../3/first-dir + dotest backuprecover-13 "${testcvs} -Q update" '' + sed -e "s/very/some extremely/" file1 >tmp; mv tmp file1 + dotest backuprecover-14 "${testcvs} -q ci -mtest" \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +new revision: 1\.6; previous revision: 1\.5" + echo >>file1 + echo "Tee hee hee hee" >>file1 + echo >>dir/file2 + echo "Find what's in store?" >>dir/file2 + echo " Oh, I'm so sure!" >>dir/file2 + echo " You've got an ill, and I have the cure!" >>dir/file2 + + # Slag the original and restore it a few revisions back + modify_repo rm -rf $CVSROOT_DIRNAME/first-dir + modify_repo mv $TESTDIR/backup $CVSROOT_DIRNAME/first-dir + + # Have developer 1 try an update and lose some data + # + # Feel free to imagine the horrific scream of despair + cd ../../1/first-dir + dotest backuprecover-15 "${testcvs} update" \ +"${SPROG} update: Updating . +U file1 +${SPROG} update: Updating dir +U dir/file2" + + # Developer 3 tries the same thing (he has an office) + # but fails without losing data since all of his files have + # uncommitted changes + cd ../../3/first-dir + dotest_fail backuprecover-16 "${testcvs} update" \ +"${SPROG} update: Updating \. +${SPROG} \[update aborted\]: could not find desired version 1\.6 in ${CVSROOT_DIRNAME}/first-dir/file1,v" + + # create our workspace fixin' script + cd ../.. + echo \ +"#!$TESTSHELL + +# This script will copy the CVS database dirs from the checked out +# version of a newly recovered repository and replace the CVS +# database dirs in a workspace with later revisions than those in the +# recovered repository +cd repos-first-dir +DATADIRS=\`find . -name CVS -print\` +cd ../first-dir +find . -name CVS -print | xargs rm -rf +for file in \${DATADIRS}; do + cp -R ../repos-first-dir/\${file} \${file} +done" >fixit + + # We only need to fix the workspaces of developers 3 and 4 + # (1 lost all her data and 2 has an update date from + # before the date the backup was made) + cd 3 + dotest backuprecover-17 \ + "${testcvs} -Q co -d repos-first-dir first-dir" '' + cd ../4 + dotest backuprecover-18 \ + "${testcvs} -Q co -d repos-first-dir first-dir" '' + sh ../fixit + cd ../3; sh ../fixit + + # (re)commit developer 3's stuff + cd first-dir + dotest backuprecover-19 "${testcvs} -q ci -mrecover/merge" \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +new revision: 1\.4; previous revision: 1\.3 +$CVSROOT_DIRNAME/first-dir/dir/file2,v <-- dir/file2 +new revision: 1\.4; previous revision: 1\.3" + + # and we should get a conflict on developer 4's stuff + cd ../../4/first-dir + dotest backuprecover-20 "${testcvs} update" \ +"${SPROG} update: Updating \. +RCS file: ${CVSROOT_DIRNAME}/first-dir/file1,v +retrieving revision 1\.3 +retrieving revision 1\.4 +Merging differences between 1\.3 and 1\.4 into file1 +rcsmerge: warning: conflicts during merge +${SPROG} update: conflicts found in file1 +C file1 +${SPROG} update: Updating dir +RCS file: ${CVSROOT_DIRNAME}/first-dir/dir/file2,v +retrieving revision 1\.3 +retrieving revision 1\.4 +Merging differences between 1\.3 and 1\.4 into file2 +rcsmerge: warning: conflicts during merge +${SPROG} update: conflicts found in dir/file2 +C dir/file2" + sed -e \ +"/^<<<<<<</,/^=======/d +/^>>>>>>>/d" file1 >tmp; mv tmp file1 + sed -e \ +"/^<<<<<<</,/^=======/d +/^>>>>>>>/d +s/quit and/be fired so he can/" dir/file2 >tmp; mv tmp dir/file2 + dotest backuprecover-21 "${testcvs} -q ci -mrecover/merge" \ +"$CVSROOT_DIRNAME/first-dir/dir/file2,v <-- dir/file2 +new revision: 1\.5; previous revision: 1\.4" + + # go back and commit developer 2's stuff to prove it can still be done + cd ../../2/first-dir + dotest backuprecover-22 "${testcvs} -Q update" \ +"RCS file: ${CVSROOT_DIRNAME}/first-dir/file1,v +retrieving revision 1\.2 +retrieving revision 1\.4 +Merging differences between 1\.2 and 1\.4 into file1 +RCS file: ${CVSROOT_DIRNAME}/first-dir/dir/file2,v +retrieving revision 1\.2 +retrieving revision 1\.5 +Merging differences between 1\.2 and 1\.5 into file2" + dotest backuprecover-23 "${testcvs} -q ci -mtest" \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +new revision: 1\.5; previous revision: 1\.4 +$CVSROOT_DIRNAME/first-dir/dir/file2,v <-- dir/file2 +new revision: 1\.6; previous revision: 1\.5" + + # and restore the data to developer 1 + cd ../../1/first-dir + dotest backuprecover-24 "${testcvs} -Q update" '' + + dokeep + cd ../../.. + rm -r backuprecover + modify_repo rm -rf $CVSROOT_DIRNAME/first-dir + ;; + + + + sshstdio) + # CVS_RSH=ssh can have a problem with a non-blocking stdio + # in some cases. So, this test is all about testing :ext: + # with CVS_RSH=ssh. The problem is that not all machines + # will necessarily have ssh available, so be prepared to + # skip this test. + + if $proxy; then + notproxy sshstdio + continue + fi + + if $remote; then :; else + remoteonly sshstdio + continue + fi + + require_ssh + if test $? -eq 77; then + skip sshstdio "$skipreason" + continue + fi + + SSHSTDIO_ROOT=:ext:$host$CVSROOT_DIRNAME + + mkdir sshstdio; cd sshstdio + dotest sshstdio-1 "$testcvs -d $SSHSTDIO_ROOT -q co -l ." + mkdir first-dir + dotest sshstdio-2 "$testcvs add first-dir" \ + "Directory $CVSROOT_DIRNAME/first-dir added to the repository" + cd first-dir + a='aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' + c='aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaacaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' + # Generate 1024 lines of $a + cnt=0 + echo $a > aaa + while [ $cnt -lt 5 ] ; do + cnt=`expr $cnt + 1` ; + mv aaa aaa.old + cat aaa.old aaa.old aaa.old aaa.old > aaa + done + dotest sshstdio-3 "$testcvs -q add aaa" \ +"$SPROG add: use .$SPROG commit. to add this file permanently" + dotest sshstdio-4 "$testcvs -q ci -mcreate aaa" \ +"$CVSROOT_DIRNAME/first-dir/aaa,v <-- aaa +initial revision: 1\.1" + # replace lines 1, 512, 513, 1024 with $c + sed 510q < aaa > aaa.old + (echo $c; cat aaa.old; echo $c; \ + echo $c; cat aaa.old; echo $c) > aaa + dotest sshstdio-5 "$testcvs -q ci -mmodify-it aaa" \ +"$CVSROOT_DIRNAME/first-dir/aaa,v <-- aaa +new revision: 1\.2; previous revision: 1\.1" + cat > wrapper.sh <<EOF +#!$TESTSHELL +exec "\$@" 2>&1 < /dev/null | cat +EOF + chmod +x wrapper.sh + ./wrapper.sh \ + $testcvs -z5 -Q diff --side-by-side -W 500 -r 1.1 -r 1.2 \ + aaa > wrapper.dif + + $testcvs -z5 -Q diff --side-by-side -W 500 -r 1.1 -r 1.2 \ + aaa > good.dif + + dotest sshstdio-6 "cmp wrapper.dif good.dif" + + dokeep + cd ../.. + CVS_RSH=$save_CVS_RSH; export CVS_RSH + rm -r sshstdio + rm -rf $CVSROOT_DIRNAME/first-dir + ;; + + + + parseroot2) + # Test some :ext: roots for consistancy. + if $remote; then :; else + remoteonly parseroot2 + continue + fi + + require_rsh "$CVS_RSH" + if test $? -eq 77; then + skip parseroot2 "$skipreason" + continue + fi + + # Test checking out and subsequently updating with some different + # CVSROOTs. + + # A standard case, hostname:dirname. + mkdir parseroot2; cd parseroot2 + save_CVSROOT=$CVSROOT + CVSROOT=$host:$CVSROOT_DIRNAME + dotest parseroot2-1 "$testcvs -Q co CVSROOT" + cd CVSROOT + dotest parseroot2-2 "$testcvs -Q up" + cd .. + + # A degenerate remote case, just the server name and the directory + # name, with no :'s to help parsing. It can be mistaken for a + # relative directory name. + rm -r CVSROOT + CVSROOT=$host$CVSROOT_DIRNAME + dotest parseroot2-3 "$testcvs -Q co CVSROOT" + cd CVSROOT + dotest parseroot2-4 "$testcvs -Q up" + + dokeep + cd ../.. + CVSROOT=$save_CVSROOT + rm -r parseroot2 + ;; + + + + parseroot3) + # Test some :ext: roots for consistancy. + if $remote; then :; else + remoteonly parseroot3 + continue + fi + + require_rsh "$CVS_RSH" + if test $? -eq 77; then + skip parseroot3 "$skipreason" + continue + fi + + # Test checking out and subsequently updating with some different + # CVSROOTs. + + # A standard case, hostname:dirname. + mkdir parseroot3; cd parseroot3 + save_CVSROOT=$CVSROOT + save_CVS_RSH=$CVS_RSH + save_CVS_SERVER=$CVS_SERVER + unset CVS_RSH + unset CVS_SERVER + CVSROOT=":ext;CVS_RSH=$save_CVS_RSH;CVS_SERVER=$save_CVS_SERVER:$host:$CVSROOT_DIRNAME" + dotest parseroot3-1 "$testcvs -Q co CVSROOT" + cd CVSROOT + dotest parseroot3-2 "$testcvs -Q up" + cd .. + + # Initial checkout. + rm -r CVSROOT + CVSROOT=":ext;cvs_RSH=$save_CVS_RSH;CVS_Server=$save_CVS_SERVER:$host$CVSROOT_DIRNAME" + dotest parseroot3-3 "$testcvs -Q co CVSROOT" + cd CVSROOT + dotest parseroot3-4 "$testcvs -Q up" + cd .. + + # Checkout bogus values for Redirect + rm -r CVSROOT + CVSROOT=":ext;Redirect=bogus;CVS_RSH=$save_CVS_RSH;CVS_SERVER=$save_CVS_SERVER:$host$CVSROOT_DIRNAME" + dotest parseroot3-5 "$testcvs -Q co CVSROOT" \ +"$SPROG checkout: CVSROOT: unrecognized value \`bogus' for \`Redirect'" + cd CVSROOT + # FIXCVS: parse_cvsroot is called more often that is + # desirable. + dotest parseroot3-6 "$testcvs -Q up" \ +"$SPROG update: CVSROOT: unrecognized value \`bogus' for \`Redirect'" + cd .. + + # Checkout good values for Redirect + rm -r CVSROOT + CVSROOT=":EXT;Redirect=no;CVS_RSH=$save_CVS_RSH;CVS_SERVER=$save_CVS_SERVER:$host$CVSROOT_DIRNAME" + dotest parseroot3-7 "$testcvs -Q co CVSROOT" + cd CVSROOT + dotest parseroot3-8 "$testcvs -Q up" + cd .. + + dotest parseroot3-9 "$testcvs -Q co -ldtop ." + dotest parseroot3-10 "test -d top" + dotest parseroot3-11 "test -d top/CVS" + dotest parseroot3-10 "cat top/CVS/Root" "$CVSROOT" + + dokeep + cd .. + CVSROOT=$save_CVSROOT + CVS_RSH=$save_CVS_RSH + CVS_SERVER=$save_CVS_SERVER + export CVS_RSH CVS_SERVER + rm -r parseroot3 + ;; + + + + history) + # CVSROOT/history tests: + # history: various "cvs history" invocations + # basic2: Generating the CVSROOT/history file via CVS commands. + + # Put in some data for the history file (discarding what was + # there before). Note that this file format is fixed; the + # user may wish to analyze data from a previous version of + # CVS. If we phase out this format, it should be done + # slowly and carefully. + + if $proxy; then + # don't even try + continue + fi + + cat <<EOF >$CVSROOT_DIRNAME/CVSROOT/history +O3395c677|anonymous|<remote>/*0|ccvs||ccvs +O3396c677|anonymous|<remote>/src|ccvs||src +O3397c677|kingdon|<remote>/*0|ccvs||ccvs +M339cafae|nk|<remote>|ccvs/src|1.229|sanity.sh +M339cafff|anonymous|<remote>|ccvs/src|1.23|Makefile +M339dc339|kingdon|~/work/*0|ccvs/src|1.231|sanity.sh +W33a6eada|anonymous|<remote>*4|ccvs/emx||Makefile.in +C3b235f50|kingdon|<remote>|ccvs/emx|1.3|README +M3b23af50|kingdon|~/work/*0|ccvs/doc|1.281|cvs.texinfo +EOF + + dotest history-1 "${testcvs} history -e -a" \ +"O 1997-06-04 19:48 ${PLUS}0000 anonymous ccvs =ccvs= <remote>/\* +O 1997-06-05 14:00 ${PLUS}0000 anonymous ccvs =src= <remote>/\* +M 1997-06-10 01:38 ${PLUS}0000 anonymous 1\.23 Makefile ccvs/src == <remote> +W 1997-06-17 19:51 ${PLUS}0000 anonymous Makefile\.in ccvs/emx == <remote>/emx +O 1997-06-06 08:12 ${PLUS}0000 kingdon ccvs =ccvs= <remote>/\* +M 1997-06-10 21:12 ${PLUS}0000 kingdon 1\.231 sanity\.sh ccvs/src == ~/work/ccvs/src +C 2001-06-10 11:51 ${PLUS}0000 kingdon 1\.3 README ccvs/emx == <remote> +M 2001-06-10 17:33 ${PLUS}0000 kingdon 1\.281 cvs\.texinfo ccvs/doc == ~/work/ccvs/doc +M 1997-06-10 01:36 ${PLUS}0000 nk 1\.229 sanity\.sh ccvs/src == <remote>" + + dotest history-2 "${testcvs} history -e -a -D '10 Jun 1997 13:00 UT'" \ +"W 1997-06-17 19:51 ${PLUS}0000 anonymous Makefile\.in ccvs/emx == <remote>/emx +M 1997-06-10 21:12 ${PLUS}0000 kingdon 1\.231 sanity\.sh ccvs/src == ~/work/ccvs/src +C 2001-06-10 11:51 ${PLUS}0000 kingdon 1\.3 README ccvs/emx == <remote> +M 2001-06-10 17:33 ${PLUS}0000 kingdon 1\.281 cvs\.texinfo ccvs/doc == ~/work/ccvs/doc" + + dotest history-3 "${testcvs} history -e -a -D '10 Jun 2001 13:00 UT'" \ +"M 2001-06-10 17:33 ${PLUS}0000 kingdon 1\.281 cvs\.texinfo ccvs/doc == ~/work/ccvs/doc" + + dotest history-4 "${testcvs} history -ac sanity.sh" \ +"M 1997-06-10 21:12 ${PLUS}0000 kingdon 1\.231 sanity\.sh ccvs/src == ~/work/ccvs/src +M 1997-06-10 01:36 ${PLUS}0000 nk 1\.229 sanity\.sh ccvs/src == <remote>" + + dotest history-5 "${testcvs} history -a -xCGUWAMR README sanity.sh" \ +"M 1997-06-10 21:12 ${PLUS}0000 kingdon 1\.231 sanity\.sh ccvs/src == ~/work/ccvs/src +C 2001-06-10 11:51 ${PLUS}0000 kingdon 1\.3 README ccvs/emx == <remote> +M 1997-06-10 01:36 ${PLUS}0000 nk 1\.229 sanity\.sh ccvs/src == <remote>" + + dotest history-6 "${testcvs} history -xCGUWAMR -a -f README -f sanity.sh" \ +"M 1997-06-10 21:12 ${PLUS}0000 kingdon 1\.231 sanity\.sh ccvs/src == ~/work/ccvs/src +C 2001-06-10 11:51 ${PLUS}0000 kingdon 1\.3 README ccvs/emx == <remote> +M 1997-06-10 01:36 ${PLUS}0000 nk 1\.229 sanity\.sh ccvs/src == <remote>" + + dotest history-7 "${testcvs} history -xCGUWAMR -a -f sanity.sh README" \ +"M 1997-06-10 21:12 ${PLUS}0000 kingdon 1\.231 sanity\.sh ccvs/src == ~/work/ccvs/src +C 2001-06-10 11:51 ${PLUS}0000 kingdon 1\.3 README ccvs/emx == <remote> +M 1997-06-10 01:36 ${PLUS}0000 nk 1\.229 sanity\.sh ccvs/src == <remote>" + + dotest history-8 "${testcvs} history -ca -D '1970-01-01 00:00 UT'" \ +"M 1997-06-10 01:36 ${PLUS}0000 nk 1\.229 sanity.sh ccvs/src == <remote> +M 1997-06-10 01:38 ${PLUS}0000 anonymous 1\.23 Makefile ccvs/src == <remote> +M 1997-06-10 21:12 ${PLUS}0000 kingdon 1\.231 sanity.sh ccvs/src == ~/work/ccvs/src +M 2001-06-10 17:33 ${PLUS}0000 kingdon 1\.281 cvs.texinfo ccvs/doc == ~/work/ccvs/doc" + + dotest history-9 "${testcvs} history -acl" \ +"M 2001-06-10 17:33 ${PLUS}0000 kingdon 1\.281 cvs.texinfo ccvs/doc == ~/work/ccvs/doc +M 1997-06-10 01:38 ${PLUS}0000 anonymous 1\.23 Makefile ccvs/src == <remote> +M 1997-06-10 21:12 ${PLUS}0000 kingdon 1\.231 sanity.sh ccvs/src == ~/work/ccvs/src" + + dotest history-10 "${testcvs} history -lca -D '1970-01-01 00:00 UT'" \ +"M 2001-06-10 17:33 ${PLUS}0000 kingdon 1\.281 cvs.texinfo ccvs/doc == ~/work/ccvs/doc +M 1997-06-10 01:38 ${PLUS}0000 anonymous 1\.23 Makefile ccvs/src == <remote> +M 1997-06-10 21:12 ${PLUS}0000 kingdon 1\.231 sanity.sh ccvs/src == ~/work/ccvs/src" + + dotest history-11 "${testcvs} history -aw" \ +"O 1997-06-04 19:48 ${PLUS}0000 anonymous ccvs =ccvs= <remote>/\* +O 1997-06-05 14:00 ${PLUS}0000 anonymous ccvs =src= <remote>/\* +O 1997-06-06 08:12 ${PLUS}0000 kingdon ccvs =ccvs= <remote>/\*" + + dotest history-12 "${testcvs} history -aw -D'1970-01-01 00:00 UT'" \ +"O 1997-06-04 19:48 ${PLUS}0000 anonymous ccvs =ccvs= <remote>/\* +O 1997-06-05 14:00 ${PLUS}0000 anonymous ccvs =src= <remote>/\* +O 1997-06-06 08:12 ${PLUS}0000 kingdon ccvs =ccvs= <remote>/\*" + ;; + + + + big) + + # Test ability to operate on big files. Intention is to + # test various realloc'ing code in RCS_deltas, rcsgetkey, + # etc. "big" is currently defined to be 1000 lines (64000 + # bytes), which in terms of files that users will use is not + # large, merely average, but my reasoning is that this + # should be big enough to make sure realloc'ing is going on + # and that raising it a lot would start to stress resources + # on machines which run the tests, without any significant + # benefit. + + modify_repo mkdir $CVSROOT_DIRNAME/first-dir + dotest big-1 "$testcvs -q co first-dir" + cd first-dir + for i in 0 1 2 3 4 5 6 7 8 9; do + for j in 0 1 2 3 4 5 6 7 8 9; do + for k in 0 1 2 3 4 5 6 7 8 9; do + echo \ +"This is line ($i,$j,$k) which goes into the file file1 for testing" >>file1 + done + done + done + dotest big-2 "$testcvs add file1" \ +"$SPROG add: scheduling file .file1. for addition +$SPROG add: use .$SPROG commit. to add this file permanently" + dotest big-3 "$testcvs -q ci -m add" \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +initial revision: 1\.1" + cd .. + mkdir 2 + cd 2 + dotest big-4 "$testcvs -q get first-dir" "U first-dir/file1" + cd ../first-dir + echo "add a line to the end" >>file1 + + dotest_fail big-4b "$testcvs -q diff -u" \ +"Index: file1 +=================================================================== +RCS file: $CVSROOT_DIRNAME/first-dir/file1,v +retrieving revision 1\.1 +diff -u -r1\.1 file1 +--- file1 $RFCDATE 1\.1 +$PLUS$PLUS$PLUS file1 $RFCDATE +@@ -998,3 ${PLUS}998,4 @@ + This is line (9,9,7) which goes into the file file1 for testing + This is line (9,9,8) which goes into the file file1 for testing + This is line (9,9,9) which goes into the file file1 for testing +${PLUS}add a line to the end" + + dotest big-5 "$testcvs -q ci -m modify" \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +new revision: 1\.2; previous revision: 1\.1" + cd ../2/first-dir + # The idea here is particularly to test the Rcs-diff response + # and the reallocing thereof, for remote. + dotest big-6 "$testcvs -q update" "[UP] file1" + + dokeep + cd ../.. + rm -r first-dir 2 + modify_repo rm -rf $CVSROOT_DIRNAME/first-dir + ;; + + + + modes) + # Test repository permissions (CVSUMASK and so on). + # Although the tests in this section "cheat" by testing + # repository permissions, which are sort of not a user-visible + # sort of thing, the modes do have user-visible consequences, + # such as whether a second user can check out the files. But + # it would be awkward to test the consequences, so we don't. + + # Solaris /bin/sh doesn't support export -n. I'm not sure + # what we can do about this, other than hope that whoever + # is running the tests doesn't have CVSUMASK set. + #export -n CVSUMASK # if unset, defaults to 002 + + save_umask=`umask` + umask 077 + mkdir 1; cd 1 + dotest modes-1 "${testcvs} -q co -l ." '' + mkdir first-dir + dotest modes-2 "${testcvs} add first-dir" \ +"Directory ${CVSROOT_DIRNAME}/first-dir added to the repository" + cd first-dir + touch aa + dotest modes-3 "${testcvs} add aa" \ +"${SPROG} add: scheduling file .aa. for addition +${SPROG} add: use .${SPROG} commit. to add this file permanently" + dotest modes-4 "${testcvs} -q ci -m add" \ +"$CVSROOT_DIRNAME/first-dir/aa,v <-- aa +initial revision: 1\.1" + # Yawn. Cygwin. + if test -n "$remotehost"; then + dotest modes-5remotehost "$CVS_RSH $remotehost 'ls -l ${CVSROOT_DIRNAME}/first-dir/aa,v'" \ +"-r--r--r-- .*" + else + dotest modes-5 "ls -l ${CVSROOT_DIRNAME}/first-dir/aa,v" \ +"-r--r--r-- .*" + fi + + # Test for whether we can set the execute bit. + chmod +x aa + echo change it >>aa + dotest modes-6 "${testcvs} -q ci -m set-execute-bit" \ +"$CVSROOT_DIRNAME/first-dir/aa,v <-- aa +new revision: 1\.2; previous revision: 1\.1" + # If CVS let us update the execute bit, it would be set here. + # But it doesn't, and as far as I know that is longstanding + # CVS behavior. + # + # Yeah, yeah. Search for "Cygwin". + if test -n "$remotehost"; then + dotest modes-7remotehost "$CVS_RSH $remotehost 'ls -l ${CVSROOT_DIRNAME}/first-dir/aa,v'" \ +"-r--r--r-- .*" + else + dotest modes-7 "ls -l ${CVSROOT_DIRNAME}/first-dir/aa,v" \ +"-r--r--r-- .*" + fi + + # OK, now manually change the modes and see what happens. + # + # Cygwin, already. + if test -n "$remotehost"; then + $CVS_RSH $remotehost "chmod g=r,o= ${CVSROOT_DIRNAME}/first-dir/aa,v" + else + chmod g=r,o= ${CVSROOT_DIRNAME}/first-dir/aa,v + fi + echo second line >>aa + dotest modes-7a "${testcvs} -q ci -m set-execute-bit" \ +"$CVSROOT_DIRNAME/first-dir/aa,v <-- aa +new revision: 1\.3; previous revision: 1\.2" + # Cygwin. + if test -n "$remotehost"; then + dotest modes-7bremotehost "$CVS_RSH $remotehost 'ls -l ${CVSROOT_DIRNAME}/first-dir/aa,v'" \ +"-r--r----- .*" + else + dotest modes-7b "ls -l ${CVSROOT_DIRNAME}/first-dir/aa,v" \ +"-r--r----- .*" + fi + + CVSUMASK=007 + export CVSUMASK + touch ab + # Might as well test the execute bit too. + chmod +x ab + dotest modes-8 "$testcvs add ab" \ +"$SPROG add: scheduling file .ab. for addition +$SPROG add: use .$SPROG commit. to add this file permanently" + dotest modes-9 "$testcvs -q ci -m add" \ +"$CVSROOT_DIRNAME/first-dir/ab,v <-- ab +initial revision: 1\.1" + + # The ssh-wrapper script set up by this script forwards CVSUMASK to + # the server. In practice it would be set on the server in some + # other manner (for instance, by the `env' command, or as an option + # in the xinted.conf file). + # + # I don't recall why, but I used to look for: + # + # dotest modes-10remotehost \ + # "$CVS_RSH $remotehost 'ls -l $CVSROOT_DIRNAME/first-dir/ab,v'" \ + # "-r--r--r--.*" + # + # here when $remotehost was set. I'm not sure why. Maybe this was + # one of the innumerable Cygwin issues? + dotest modes-10 "ls -l $CVSROOT_DIRNAME/first-dir/ab,v" \ +"-r-xr-x---.*" + + # OK, now add a file on a branch. Check that the mode gets + # set the same way (it is a different code path in CVS). + dotest modes-11 "${testcvs} -q tag -b br" 'T aa +T ab' + dotest modes-12 "${testcvs} -q update -r br" '' + touch ac + dotest modes-13 "${testcvs} add ac" \ +"${SPROG} add: scheduling file .ac. for addition on branch .br. +${SPROG} add: use .${SPROG} commit. to add this file permanently" + # Not sure it really makes sense to refer to a "previous revision" + # when we are just now adding the file; as far as I know + # that is longstanding CVS behavior, for what it's worth. + dotest modes-14 "${testcvs} -q ci -m add" \ +"$CVSROOT_DIRNAME/first-dir/Attic/ac,v <-- ac +new revision: 1\.1\.2\.1; previous revision: 1\.1" + + # ssh-wrapper forwards CVSUMASK. See modes-10 for notes. + dotest modes-15 \ +"ls -l ${CVSROOT_DIRNAME}/first-dir/Attic/ac,v" \ +"-r--r-----.*" + + dokeep + cd ../.. + # Restore umask. + umask $save_umask + rm -r 1 + modify_repo rm -rf $CVSROOT_DIRNAME/first-dir + ;; + + + + modes2) + # More tests of file permissions in the working directory + # and that sort of thing. + + # The usual setup, file first-dir/aa with two revisions. + mkdir 1; cd 1 + dotest modes2-1 "${testcvs} -q co -l ." '' + mkdir first-dir + dotest modes2-2 "${testcvs} add first-dir" \ +"Directory ${CVSROOT_DIRNAME}/first-dir added to the repository" + cd first-dir + touch aa + dotest modes2-3 "${testcvs} add aa" \ +"${SPROG} add: scheduling file .aa. for addition +${SPROG} add: use .${SPROG} commit. to add this file permanently" + dotest modes2-4 "${testcvs} -q ci -m add" \ +"$CVSROOT_DIRNAME/first-dir/aa,v <-- aa +initial revision: 1\.1" + echo "more money" >> aa + dotest modes2-5 "${testcvs} -q ci -m add" \ +"$CVSROOT_DIRNAME/first-dir/aa,v <-- aa +new revision: 1\.2; previous revision: 1\.1" + + # OK, here is the test. The idea is to see what + # No_Difference does if it can't open the file. + # If we don't change the st_mtime, CVS doesn't even try to read + # the file. Note that some versions of "touch" require that we + # do this while the file is still writable. + touch aa + chmod a= aa + # Don't try this when permissions are broken, as with Cygwin. + if ${LS} ${CVSROOT_DIRNAME}/first-dir >/dev/null 2>&1; then :; else + dotest_fail modes2-6 "${testcvs} -q update -r 1.1 aa" \ +"${CPROG} \[update aborted\]: cannot open file aa for comparing: Permission denied" \ +"${CPROG} \[update aborted\]: reading aa: Permission denied" + fi + + dokeep + chmod u+rwx aa + cd ../.. + rm -r 1 + modify_repo rm -rf $CVSROOT_DIRNAME/first-dir + ;; + + + + modes3) + # Repository permissions. Particularly, what happens if we + # can't read/write in the repository. + # TODO: the case where we can access the repository, just not + # the attic (may that one can remain a fatal error, seems less + # useful for access control). + mkdir 1; cd 1 + dotest modes3-1 "$testcvs -q co -l ." + mkdir first-dir second-dir + dotest modes3-2 "${testcvs} add first-dir second-dir" \ +"Directory ${CVSROOT_DIRNAME}/first-dir added to the repository +Directory ${CVSROOT_DIRNAME}/second-dir added to the repository" + touch first-dir/aa second-dir/ab + dotest modes3-3 "${testcvs} add first-dir/aa second-dir/ab" \ +"${SPROG} add: scheduling file .first-dir/aa. for addition +${SPROG} add: scheduling file .second-dir/ab. for addition +${SPROG} add: use .${SPROG} commit. to add these files permanently" + dotest modes3-4 "${testcvs} -q ci -m add" \ +"$CVSROOT_DIRNAME/first-dir/aa,v <-- first-dir/aa +initial revision: 1\.1 +$CVSROOT_DIRNAME/second-dir/ab,v <-- second-dir/ab +initial revision: 1\.1" + # quiet down this one as it will be noisy in proxy mode + modify_repo chmod a= $CVSROOT_DIRNAME/first-dir >/dev/null 2>&1 + if ${LS} ${CVSROOT_DIRNAME}/first-dir >/dev/null 2>&1; then + # Avoid this test under Cygwin since permissions work differently + # there. + # + # This test also gets avoided under Mac OS X since the system `ls' + # is broken and exits with a 0 status despite the permission + # denied error. + if test -n "$remotehost"; then + cygwin_hack=false + else + cygwin_hack=: + fi + else + cygwin_hack=false + fi + + cd $TESTDIR/1 + if $cygwin_hack; then :; else + dotest modes3-5 "${testcvs} update" \ +"${SPROG} update: Updating \. +${SPROG} update: Updating first-dir +${SPROG} update: cannot open directory ${CVSROOT_DIRNAME}/first-dir: Permission denied +${SPROG} update: skipping directory first-dir +${SPROG} update: Updating second-dir" + fi + + # OK, I can see why one might say the above case could be a + # fatal error, because normally users without access to first-dir + # won't have it in their working directory. But the next + # one is more of a problem if it is fatal. + # + # The second text string below is for Cygwin again, and again it + # should really be XFAIL under Cygwin, but for now deal with the + # passing opendir by accepting the alternate string. + rm -r first-dir + dotest modes3-6 "${testcvs} update -dP" \ +"${SPROG} update: Updating . +${SPROG} update: Updating CVSROOT +U ${DOTSTAR} +${SPROG} update: Updating first-dir +${SPROG} update: cannot open directory ${CVSROOT_DIRNAME}/first-dir: Permission denied +${SPROG} update: skipping directory first-dir +${SPROG} update: Updating second-dir" \ +"${SPROG} update: Updating . +${SPROG} update: Updating CVSROOT +U ${DOTSTAR} +${SPROG} update: Updating first-dir +${SPROG} update: Updating second-dir" + + dokeep + cd .. + rm -r 1 + # quiet down this one as it will be noisy in proxy mode + modify_repo chmod u+rwx $CVSROOT_DIRNAME/first-dir 2>/dev/null + modify_repo rm -rf $CVSROOT_DIRNAME/first-dir \ + $CVSROOT_DIRNAME/second-dir + ;; + + + + stamps) + # Test timestamps. + mkdir 1; cd 1 + dotest stamps-1 "${testcvs} -q co -l ." '' + mkdir first-dir + dotest stamps-2 "${testcvs} add first-dir" \ +"Directory ${CVSROOT_DIRNAME}/first-dir added to the repository" + cd first-dir + touch aa + echo '$''Id$' >kw + # Cygwin, *cough*, puts the year in the time column until the minute + # is no longer the current minute. Sleep 60 seconds to avoid this + # problem. + sleep 60 + ls -l aa >${TESTDIR}/1/stamp.aa.touch + ls -l kw >${TESTDIR}/1/stamp.kw.touch + # "sleep 1" would suffice if we could assume ls --full-time, but + # that is as far as I know unique to GNU ls. Is there some POSIX.2 + # way to get the timestamp of a file, including the seconds? + sleep 60 + dotest stamps-3 "${testcvs} add aa kw" \ +"${SPROG} add: scheduling file .aa. for addition +${SPROG} add: scheduling file .kw. for addition +${SPROG} add: use .${SPROG} commit. to add these files permanently" + ls -l aa >${TESTDIR}/1/stamp.aa.add + ls -l kw >${TESTDIR}/1/stamp.kw.add + # "cvs add" should not muck with the timestamp. + dotest stamps-4aa \ +"cmp ${TESTDIR}/1/stamp.aa.touch ${TESTDIR}/1/stamp.aa.add" '' + dotest stamps-4kw \ +"cmp ${TESTDIR}/1/stamp.kw.touch ${TESTDIR}/1/stamp.kw.add" '' + sleep 60 + dotest stamps-5 "${testcvs} -q ci -m add" \ +"$CVSROOT_DIRNAME/first-dir/aa,v <-- aa +initial revision: 1\.1 +$CVSROOT_DIRNAME/first-dir/kw,v <-- kw +initial revision: 1\.1" + # Cygwin, *cough*, puts the year in the time column until the minute + # is no longer the current minute. Sleep 60 seconds to avoid this + # problem. + sleep 60 + ls -l aa >${TESTDIR}/1/stamp.aa.ci + ls -l kw >${TESTDIR}/1/stamp.kw.ci + # If there are no keywords, "cvs ci" leaves the timestamp alone + # If there are, it sets the timestamp to the date of the commit. + # I'm not sure how logical this is, but it is intentional. + # If we wanted to get fancy we would make sure the time as + # reported in "cvs log kw" matched stamp.kw.ci. But that would + # be a lot of work. + dotest stamps-6aa \ + "cmp ${TESTDIR}/1/stamp.aa.add ${TESTDIR}/1/stamp.aa.ci" '' + if cmp ${TESTDIR}/1/stamp.kw.add ${TESTDIR}/1/stamp.kw.ci >/dev/null + then + fail stamps-6kw + else + pass stamps-6kw + fi + cd ../.. + sleep 60 + mkdir 2 + cd 2 + dotest stamps-7 "${testcvs} -q get first-dir" "U first-dir/aa +U first-dir/kw" + cd first-dir + ls -l aa >${TESTDIR}/1/stamp.aa.get + ls -l kw >${TESTDIR}/1/stamp.kw.get + # On checkout, CVS should set the timestamp to the date that the + # file was committed. Could check that the time as reported in + # "cvs log aa" matches stamp.aa.get, but that would be a lot of + # work. + dotest_fail stamps-8aa \ +"cmp $TESTDIR/1/stamp.aa.ci $TESTDIR/1/stamp.aa.get >/dev/null" + dotest stamps-8kw \ +"cmp $TESTDIR/1/stamp.kw.ci $TESTDIR/1/stamp.kw.get" + + # Now we want to see what "cvs update" does. + sleep 60 + echo add a line >>aa + echo add a line >>kw + dotest stamps-9 "${testcvs} -q ci -m change-them" \ +"$CVSROOT_DIRNAME/first-dir/aa,v <-- aa +new revision: 1\.2; previous revision: 1\.1 +$CVSROOT_DIRNAME/first-dir/kw,v <-- kw +new revision: 1\.2; previous revision: 1\.1" + + # Cygwin, *cough*, puts the year in the time column until the minute + # is no longer the current minute. Sleep 60 seconds to avoid this + # problem. + sleep 60 + ls -l aa >${TESTDIR}/1/stamp.aa.ci2 + ls -l kw >${TESTDIR}/1/stamp.kw.ci2 + cd ../.. + cd 1/first-dir + sleep 60 + dotest stamps-10 "${testcvs} -q update" '[UP] aa +[UP] kw' + # this doesn't serve any function other than being able to + # look at it manually, as we have no machinery for dates being + # newer or older than other dates. + date >$TESTDIR/1/stamp.debug.update + ls -l aa >$TESTDIR/1/stamp.aa.update + ls -l kw >$TESTDIR/1/stamp.kw.update + # stamp.aa.update and stamp.kw.update should both be approximately + # the same as stamp.debug.update. Perhaps we could be testing + # this in a more fancy fashion by "touch stamp.before" before + # stamps-10, "touch stamp.after" after, and then using ls -t + # to check them. But for now we just make sure that the *.update + # stamps differ from the *.ci2 ones. + # As for the rationale, this is so that if one updates and gets + # a new revision, then "make" will be sure to regard those files + # as newer than .o files which may be sitting around. + dotest_fail stamps-11aa \ +"cmp $TESTDIR/1/stamp.aa.update $TESTDIR/1/stamp.aa.ci2 >/dev/null" + dotest_fail stamps-11kw \ +"cmp $TESTDIR/1/stamp.kw.update $TESTDIR/1/stamp.kw.ci2 >/dev/null" + + dokeep + cd ../.. + rm -r 1 2 + modify_repo rm -rf $CVSROOT_DIRNAME/first-dir + ;; + + + + perms) + mkdir 1; cd 1 + dotest perms-init-1 "$testcvs -Q co CVSROOT" + cd CVSROOT + echo 'PreservePermissions=yes' >> ${CVSROOT_DIRNAME}/CVSROOT/config + dotest perms-init-2 "$testcvs -Q ci -mperms" + cd .. + + dotest perms-1 "$testcvs -q co -l ." + mkdir first-dir + dotest perms-2 "${testcvs} add first-dir" \ +"Directory ${CVSROOT_DIRNAME}/first-dir added to the repository" + cd first-dir + + touch foo + chmod 431 foo + dotest perms-3 "${testcvs} add foo" \ +"${SPROG} add: scheduling file .foo. for addition +${SPROG} add: use .${SPROG} commit. to add this file permanently" + dotest perms-4 "${testcvs} -q ci -m ''" \ +"$CVSROOT_DIRNAME/first-dir/foo,v <-- foo +initial revision: 1\.1" + + # Test checking out files with different permissions. + cd ../.. + mkdir 2; cd 2 + dotest perms-5 "${testcvs} -q co first-dir" "U first-dir/foo" + cd first-dir + if $remote; then :; else + # PreservePermissions not yet implemented for remote. + dotest perms-6 "ls -l foo" "-r---wx--x .* foo" + fi + + dokeep + cd ../1/CVSROOT + restore_adm + cd ../.. + rm -rf 1 2 + modify_repo rm -rf $CVSROOT_DIRNAME/first-dir + ;; + + + + symlinks) + # short cut around checking out and committing CVSROOT + rm -f $CVSROOT_DIRNAME/CVSROOT/config + echo 'PreservePermissions=yes' >> $CVSROOT_DIRNAME/CVSROOT/config + chmod 444 $CVSROOT_DIRNAME/CVSROOT/config + + mkdir 1; cd 1 + dotest symlinks-1 "$testcvs -q co -l ." + mkdir first-dir + dotest symlinks-2 "$testcvs add first-dir" \ +"Directory $CVSROOT_DIRNAME/first-dir added to the repository" + cd first-dir + + dotest symlinks-2.1 "ln -s $TESTDIR/fumble slink" + dotest symlinks-3 "$testcvs add slink" \ +"$SPROG add: scheduling file .slink. for addition +$SPROG add: use .$SPROG commit. to add this file permanently" + if $remote; then + # Remote doesn't implement PreservePermissions, and in its + # absence the correct behavior is to follow the symlink. + dotest_fail symlinks-4r "$testcvs -q ci -m ''" \ +"$SPROG \[commit aborted\]: reading slink: No such file or directory" + else + dotest symlinks-4 "$testcvs -q ci -m ''" \ +"$CVSROOT_DIRNAME/first-dir/slink,v <-- slink +initial revision: 1\.1" + + # Test checking out symbolic links. + cd ../.. + mkdir 2; cd 2 + dotest symlinks-5 "$testcvs -q co first-dir" "U first-dir/slink" + cd first-dir + dotest symlinks-6 "ls -l slink" \ +"l[rwx\-]* .* slink -> $TESTDIR/fumble" + fi + + dokeep + cd ../.. + rm -rf 1 2 + modify_repo rm -rf $CVSROOT_DIRNAME/first-dir + restore_adm + ;; + + + + symlinks2) + # Symlinks in working directory without PreservePermissions. + # Also see: symlinks: with PreservePermissions + # rcslib-symlink-*: symlinks in repository. + mkdir 1; cd 1 + dotest symlinks2-1 "${testcvs} -q co -l ." '' + mkdir first-dir + dotest symlinks2-2 "${testcvs} add first-dir" \ +"Directory ${CVSROOT_DIRNAME}/first-dir added to the repository" + cd first-dir + echo nonsymlink > slink + dotest symlinks2-3 "${testcvs} add slink" \ +"${SPROG} add: scheduling file .slink. for addition +${SPROG} add: use .${SPROG} commit. to add this file permanently" + dotest symlinks2-4 "${testcvs} -q ci -m ''" \ +"$CVSROOT_DIRNAME/first-dir/slink,v <-- slink +initial revision: 1\.1" + rm slink + # Choose name cvslog.* so it is in default ignore list. + echo second file >cvslog.file2 + dotest symlinks2-5 "ln -s cvslog.file2 slink" "" + dotest symlinks2-6 "${testcvs} -q ci -m linkify" \ +"$CVSROOT_DIRNAME/first-dir/slink,v <-- slink +new revision: 1\.2; previous revision: 1\.1" + dotest symlinks2-7 "${testcvs} -q update -r 1.1 slink" "[UP] slink" + dotest symlinks2-8 "cat slink" "nonsymlink" + dotest symlinks2-9 "ls -l slink" "-[-rwx]* .* slink" + + dokeep + cd ../.. + rm -rf 1 + modify_repo rm -rf $CVSROOT_DIRNAME/first-dir + ;; + + + + hardlinks) + # short cut around checking out and committing CVSROOT + rm -f ${CVSROOT_DIRNAME}/CVSROOT/config + echo 'PreservePermissions=yes' > ${CVSROOT_DIRNAME}/CVSROOT/config + chmod 444 ${CVSROOT_DIRNAME}/CVSROOT/config + + mkdir 1; cd 1 + dotest hardlinks-1 "${testcvs} -q co -l ." '' + mkdir first-dir + dotest hardlinks-2 "${testcvs} add first-dir" \ +"Directory ${CVSROOT_DIRNAME}/first-dir added to the repository" + cd first-dir + + # Make up some ugly filenames, to test that they get + # encoded properly in the delta nodes. Note that `dotest' screws + # up if some arguments have embedded spaces. + if touch aaaa + then + pass hardlinks-2.1 + else + fail hardlinks-2.1 + fi + + if ln aaaa b.b.b.b + then + pass hardlinks-2.2 + else + fail hardlinks-2.2 + fi + + if ln aaaa 'dd dd dd' + then + pass hardlinks-2.3 + else + fail hardlinks-2.3 + fi + + dotest hardlinks-3 "${testcvs} add [abd]*" \ +"${SPROG} add: scheduling file .aaaa. for addition +${SPROG} add: scheduling file .b\.b\.b\.b. for addition +${SPROG} add: scheduling file .dd dd dd. for addition +${SPROG} add: use .${SPROG} commit. to add these files permanently" + dotest hardlinks-4 "${testcvs} -q ci -m ''" \ +"$CVSROOT_DIRNAME/first-dir/aaaa,v <-- aaaa +initial revision: 1\.1 +$CVSROOT_DIRNAME/first-dir/b\.b\.b\.b,v <-- b\.b\.b\.b +initial revision: 1\.1 +$CVSROOT_DIRNAME/first-dir/dd dd dd,v <-- dd dd dd +initial revision: 1\.1" + # Test checking out hardlinked files. + cd ../.. + mkdir 2; cd 2 + if $remote; then + # Remote does not implement PreservePermissions. + dotest hardlinks-5r "${testcvs} -q co first-dir" \ +"U first-dir/aaaa +U first-dir/b\.b\.b\.b +U first-dir/dd dd dd" + cd first-dir + dotest hardlinks-6r "ls -l [abd]*" \ +"-[rwx\-]* *1 .* aaaa +-[rwx\-]* *1 .* b\.b\.b\.b +-[rwx\-]* *1 .* dd dd dd" + else + dotest hardlinks-5 "${testcvs} -q co first-dir" \ +"U first-dir/aaaa +U first-dir/b\.b\.b\.b +U first-dir/dd dd dd" + cd first-dir + # To make sure that the files are properly hardlinked, it + # would be nice to do `ls -i' and make sure all the inodes + # match. But I think that would require expr to support + # tagged regexps, and I don't think we can rely on that. + # So instead we just see that each file has the right + # number of links. -twp + dotest hardlinks-6 "ls -l [abd]*" \ +"-[rwx\-]* *3 .* aaaa +-[rwx\-]* *3 .* b\.b\.b\.b +-[rwx\-]* *3 .* dd dd dd" + fi + + dokeep + cd ../.. + rm -rf 1 2 + modify_repo rm -rf $CVSROOT_DIRNAME/first-dir + restore_adm + ;; + + + + sticky) + # More tests of sticky tags, particularly non-branch sticky tags. + # See many tests (e.g. multibranch) for ordinary sticky tag + # operations such as adding files on branches. + # See "head" test for interaction between stick tags and HEAD. + mkdir 1; cd 1 + dotest sticky-1 "$testcvs -q co -l ." + mkdir first-dir + dotest sticky-2 "$testcvs add first-dir" \ +"Directory $CVSROOT_DIRNAME/first-dir added to the repository" + cd first-dir + + touch file1 + dotest sticky-3 "$testcvs add file1" \ +"$SPROG add: scheduling file .file1. for addition +$SPROG add: use .$SPROG commit. to add this file permanently" + dotest sticky-4 "$testcvs -q ci -m add" \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +initial revision: 1\.1" + dotest sticky-5 "$testcvs -q tag tag1" "T file1" + echo add a line >>file1 + dotest sticky-6 "$testcvs -q ci -m modify" \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +new revision: 1\.2; previous revision: 1\.1" + dotest sticky-7 "$testcvs -q update -r tag1" "[UP] file1" + dotest sticky-8 "cat file1" '' + dotest sticky-9 "$testcvs -q update" '' + dotest sticky-10 "cat file1" '' + touch file2 + dotest_fail sticky-11 "$testcvs add file2" \ +"$SPROG add: cannot add file on non-branch tag \`tag1'" + dotest sticky-12 "$testcvs -q update -A" "[UP] file1 +$QUESTION file2" "$QUESTION file2 +[UP] file1" + dotest sticky-13 "${testcvs} add file2" \ +"$SPROG add: scheduling file .file2. for addition +$SPROG add: use .$SPROG commit. to add this file permanently" + dotest sticky-14 "${testcvs} -q ci -m add" \ +"$CVSROOT_DIRNAME/first-dir/file2,v <-- file2 +initial revision: 1\.1" + + # Now back to tag1 + dotest sticky-15 "${testcvs} -q update -r tag1" "[UP] file1 +$SPROG update: \`file2' is no longer in the repository" + + rm file1 + dotest sticky-16 "${testcvs} rm file1" \ +"$SPROG remove: scheduling .file1. for removal +$SPROG remove: use .$SPROG commit. to remove this file permanently" + # Hmm, this command seems to silently remove the tag from + # the file. This appears to be intentional. + # The silently part especially strikes me as odd, though. + dotest sticky-17 "$testcvs -q ci -m remove-it" "" + dotest sticky-18 "$testcvs -q update -A" "U file1 +U file2" + dotest sticky-19 "$testcvs -q update -r tag1" \ +"${SPROG} update: \`file1' is no longer in the repository +${SPROG} update: \`file2' is no longer in the repository" + dotest sticky-20 "$testcvs -q update -A" "U file1 +U file2" + + # Now try with a numeric revision. + dotest sticky-21 "$testcvs -q update -r 1.1 file1" "U file1" + dotest sticky-22 "$testcvs rm -f file1" \ +"$SPROG remove: cannot remove file .file1. which has a numeric sticky tag of .1\.1." + # The old behavior was that remove allowed this and then commit + # gave an error, which was somewhat hard to clear. I mean, you + # could get into a long elaborate discussion of this being a + # conflict and two ways to resolve it, but I don't really see + # why CVS should have a concept of conflict that arises, not from + # parallel development, but from CVS's own sticky tags. + + # Ditto with a sticky date. + # + # I'm kind of surprised that the "file1 was lost" doesn't crop + # up elsewhere in the testsuite. It is a long-standing + # discrepency between local and remote CVS and should probably + # be cleaned up at some point. + dotest sticky-23 "$testcvs -q update -Dnow file1" \ +"$SPROG update: warning: \`file1' was lost +U file1" "U file1" + dotest sticky-24 "$testcvs rm -f file1" \ +"$SPROG remove: cannot remove file .file1. which has a sticky date of .[0-9.]*." + + dotest sticky-25 "$testcvs -q update -A" \ +"$SPROG update: warning: \`file1' was lost +U file1" "U file1" + + dokeep + restore_adm + cd ../.. + rm -r 1 + modify_repo rm -rf $CVSROOT_DIRNAME/first-dir + ;; + + + + keyword) + # Test keyword expansion. + # Various other tests relate to our ability to correctly + # set the keyword expansion mode. + # "binfiles" tests "cvs admin -k". + # "binfiles" and "binfiles2" test "cvs add -k". + # "rdiff" tests "cvs co -k". + # "binfiles" (and this test) test "cvs update -k". + # "binwrap" tests setting the mode from wrappers. + # "keyword2" tests "cvs update -kk -j" with text and binary files + # I don't think any test is testing "cvs import -k". + # Other keyword expansion tests: + # keywordlog - $Log. + mkdir 1; cd 1 + dotest keyword-1 "${testcvs} -q co -l ." '' + mkdir first-dir + dotest keyword-2 "${testcvs} add first-dir" \ +"Directory ${CVSROOT_DIRNAME}/first-dir added to the repository" + cd first-dir + + echo '$''Author$' > file1 + echo '$''Date$' >> file1 + echo '$''Header$' >> file1 + echo '$''Id$' >> file1 + echo '$''Locker$' >> file1 + echo '$''Name$' >> file1 + echo '$''RCSfile$' >> file1 + echo '$''Revision$' >> file1 + echo '$''Source$' >> file1 + echo '$''State$' >> file1 + echo '$''Nonkey$' >> file1 + # Omit the trailing dollar sign + echo '$''Date' >> file1 + # Put two keywords on one line + echo '$''State$' '$''State$' >> file1 + # Use a header for Log + echo 'xx $''Log$' >> file1 + + dotest keyword-3 "${testcvs} add file1" \ +"${SPROG} add: scheduling file .file1. for addition +${SPROG} add: use .${SPROG} commit. to add this file permanently" + dotest keyword-4 "${testcvs} -q ci -m add" \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +initial revision: 1\.1" + dotest keyword-5 "cat file1" \ +'\$'"Author: ${username} "'\$'" +"'\$'"Date: [0-9][0-9][0-9][0-9]/[0-9][0-9]/[0-9][0-9] [0-9][0-9]:[0-9][0-9]:[0-9][0-9] "'\$'" +"'\$'"Header: ${CVSROOT_DIRNAME}/first-dir/file1,v 1\.1 [0-9/]* [0-9:]* ${username} Exp "'\$'" +"'\$'"Id: file1,v 1\.1 [0-9/]* [0-9:]* ${username} Exp "'\$'" +"'\$'"Locker: "'\$'" +"'\$'"Name: "'\$'" +"'\$'"RCSfile: file1,v "'\$'" +"'\$'"Revision: 1\.1 "'\$'" +"'\$'"Source: ${CVSROOT_DIRNAME}/first-dir/file1,v "'\$'" +"'\$'"State: Exp "'\$'" +"'\$'"Nonkey"'\$'" +"'\$'"Date +"'\$'"State: Exp "'\$'" "'\$'"State: Exp "'\$'" +xx "'\$'"Log: file1,v "'\$'" +xx Revision 1\.1 [0-9/]* [0-9:]* ${username} +xx add +xx" + + # Use cvs admin to lock the RCS file in order to check -kkvl + # vs. -kkv. CVS does not normally lock RCS files, but some + # people use cvs admin to enforce reserved checkouts. + dotest keyword-6 "${testcvs} admin -l file1" \ +"RCS file: ${CVSROOT_DIRNAME}/first-dir/file1,v +1\.1 locked +done" + + dotest keyword-7 "${testcvs} update -kkv file1" "U file1" + dotest keyword-8 "cat file1" \ +'\$'"Author: ${username} "'\$'" +"'\$'"Date: [0-9][0-9][0-9][0-9]/[0-9][0-9]/[0-9][0-9] [0-9][0-9]:[0-9][0-9]:[0-9][0-9] "'\$'" +"'\$'"Header: ${CVSROOT_DIRNAME}/first-dir/file1,v 1\.1 [0-9/]* [0-9:]* ${username} Exp "'\$'" +"'\$'"Id: file1,v 1\.1 [0-9/]* [0-9:]* ${username} Exp "'\$'" +"'\$'"Locker: "'\$'" +"'\$'"Name: "'\$'" +"'\$'"RCSfile: file1,v "'\$'" +"'\$'"Revision: 1\.1 "'\$'" +"'\$'"Source: ${CVSROOT_DIRNAME}/first-dir/file1,v "'\$'" +"'\$'"State: Exp "'\$'" +"'\$'"Nonkey"'\$'" +"'\$'"Date +"'\$'"State: Exp "'\$'" "'\$'"State: Exp "'\$'" +xx "'\$'"Log: file1,v "'\$'" +xx Revision 1\.1 [0-9/]* [0-9:]* ${username} +xx add +xx" + + dotest keyword-9 "${testcvs} update -kkvl file1" "U file1" + dotest keyword-10 "cat file1" \ +'\$'"Author: ${username} "'\$'" +"'\$'"Date: ${RCSKEYDATE} "'\$'" +"'\$'"Header: ${CVSROOT_DIRNAME}/first-dir/file1,v 1\.1 ${RCSKEYDATE} ${username} Exp ${username} "'\$'" +"'\$'"Id: file1,v 1\.1 ${RCSKEYDATE} ${username} Exp ${username} "'\$'" +"'\$'"Locker: ${username} "'\$'" +"'\$'"Name: "'\$'" +"'\$'"RCSfile: file1,v "'\$'" +"'\$'"Revision: 1\.1 "'\$'" +"'\$'"Source: ${CVSROOT_DIRNAME}/first-dir/file1,v "'\$'" +"'\$'"State: Exp "'\$'" +"'\$'"Nonkey"'\$'" +"'\$'"Date +"'\$'"State: Exp "'\$'" "'\$'"State: Exp "'\$'" +xx "'\$'"Log: file1,v "'\$'" +xx Revision 1\.1 ${RCSKEYDATE} ${username} +xx add +xx" + + dotest keyword-11 "${testcvs} update -kk file1" "U file1" + dotest keyword-12 "cat file1" \ +'\$'"Author"'\$'" +"'\$'"Date"'\$'" +"'\$'"Header"'\$'" +"'\$'"Id"'\$'" +"'\$'"Locker"'\$'" +"'\$'"Name"'\$'" +"'\$'"RCSfile"'\$'" +"'\$'"Revision"'\$'" +"'\$'"Source"'\$'" +"'\$'"State"'\$'" +"'\$'"Nonkey"'\$'" +"'\$'"Date +"'\$'"State"'\$'" "'\$'"State"'\$'" +xx "'\$'"Log"'\$'" +xx Revision 1\.1 ${RCSKEYDATE} ${username} +xx add +xx" + + dotest keyword-13 "${testcvs} update -kv file1" "U file1" + dotest keyword-14 "cat file1" \ +"${username} +${RCSKEYDATE} +${CVSROOT_DIRNAME}/first-dir/file1,v 1\.1 ${RCSKEYDATE} ${username} Exp +file1,v 1\.1 ${RCSKEYDATE} ${username} Exp + + +file1,v +1\.1 +${CVSROOT_DIRNAME}/first-dir/file1,v +Exp +"'\$'"Nonkey"'\$'" +"'\$'"Date +Exp Exp +xx file1,v +xx Revision 1\.1 ${RCSKEYDATE} ${username} +xx add +xx" + + dotest keyword-15 "${testcvs} update -ko file1" "U file1" + dotest keyword-16 "cat file1" \ +'\$'"Author"'\$'" +"'\$'"Date"'\$'" +"'\$'"Header"'\$'" +"'\$'"Id"'\$'" +"'\$'"Locker"'\$'" +"'\$'"Name"'\$'" +"'\$'"RCSfile"'\$'" +"'\$'"Revision"'\$'" +"'\$'"Source"'\$'" +"'\$'"State"'\$'" +"'\$'"Nonkey"'\$'" +"'\$'"Date +"'\$'"State"'\$'" "'\$'"State"'\$'" +xx "'\$'"Log"'\$' + + # Test the Name keyword. First go back to normal expansion. + + dotest keyword-17 "${testcvs} update -A file1" "U file1" + + echo '$''Name$' > file1 + dotest keyword-18 "${testcvs} ci -m modify file1" \ +"${CVSROOT_DIRNAME}/first-dir/file1,v <-- file1 +new revision: 1\.2; previous revision: 1\.1" + dotest keyword-19 "${testcvs} -q tag tag1" "T file1" + echo "change" >> file1 + dotest keyword-20 "${testcvs} -q ci -m mod2 file1" \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +new revision: 1\.3; previous revision: 1\.2" + # FIXCVS - These unpatchable files are happening because the tag + # associated with the current base version of the file in the + # sandbox is not available in these cases. See the note in the + # patch_file function in update.c. + dotest keyword-21 "${testcvs} -q update -r tag1" "U file1" \ +"P file1 +${CPROG} update: checksum failure after patch to \./file1; will refetch +${CPROG} client: refetching unpatchable files +$SPROG update: warning: \`file1' was lost +U file1" + + dotest keyword-22 "cat file1" '\$'"Name: tag1 "'\$' + + if $remote; then + # Like serverpatch-8. Not sure there is anything much we + # can or should do about this. + dotest keyword-23r "${testcvs} update -A file1" "P file1 +${CPROG} update: checksum failure after patch to \./file1; will refetch +${CPROG} client: refetching unpatchable files +$SPROG update: warning: \`file1' was lost +U file1" + else + dotest keyword-23 "${testcvs} update -A file1" "[UP] file1" + fi + dotest keyword-24 "cat file1" '\$'"Name: "'\$'" +change" + + dokeep + cd ../.. + rm -r 1 + modify_repo rm -rf $CVSROOT_DIRNAME/first-dir + ;; + + + + keywordlog) + # Test the Log keyword. + mkdir 1; cd 1 + dotest keywordlog-1 "${testcvs} -q co -l ." '' + mkdir first-dir + dotest keywordlog-2 "${testcvs} add first-dir" \ +"Directory ${CVSROOT_DIRNAME}/first-dir added to the repository" + cd first-dir + echo initial >file1 + dotest keywordlog-3 "${testcvs} add file1" \ +"${SPROG} add: scheduling file .file1. for addition +${SPROG} add: use .${SPROG} commit. to add this file permanently" + + # See "rmadd" for a list of other tests of cvs ci -r. + dotest keywordlog-4 "${testcvs} -q ci -r 1.3 -m add file1" \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +initial revision: 1\.3" + + cd ../.. + mkdir 2; cd 2 + dotest keywordlog-4a "${testcvs} -q co first-dir" "U first-dir/file1" + cd ../1/first-dir + + echo 'xx $''Log$' >> file1 + cat >${TESTDIR}/comment.tmp <<EOF +First log line +Second log line +EOF + # As with rmadd-25, "cvs ci -r" sets a sticky tag. + dotest_fail keywordlog-4b \ +"${testcvs} ci -F ${TESTDIR}/comment.tmp file1" \ +"${SPROG} commit: sticky tag .1\.3. for file .file1. is not a branch +${SPROG} \[commit aborted\]: correct above errors first!" + dotest keywordlog-4c "${testcvs} -q update -A" "M file1" + + dotest keywordlog-5 "${testcvs} ci -F ${TESTDIR}/comment.tmp file1" \ +"${CVSROOT_DIRNAME}/first-dir/file1,v <-- file1 +new revision: 1\.4; previous revision: 1\.3" + rm -f ${TESTDIR}/comment.tmp + dotest keywordlog-6 "${testcvs} -q tag -b br" "T file1" + dotest keywordlog-7 "cat file1" \ +"initial +xx "'\$'"Log: file1,v "'\$'" +xx Revision 1\.4 ${RCSKEYDATE} ${username} +xx First log line +xx Second log line +xx" + + cd ../../2/first-dir + dotest keywordlog-8 "${testcvs} -q update" "[UP] file1" + dotest keywordlog-9 "cat file1" \ +"initial +xx "'\$'"Log: file1,v "'\$'" +xx Revision 1\.4 ${RCSKEYDATE} ${username} +xx First log line +xx Second log line +xx" + cd ../../1/first-dir + + echo "change" >> file1 + dotest keywordlog-10 "${testcvs} ci -m modify file1" \ +"${CVSROOT_DIRNAME}/first-dir/file1,v <-- file1 +new revision: 1\.5; previous revision: 1\.4" + dotest keywordlog-11 "cat file1" \ +"initial +xx "'\$'"Log: file1,v "'\$'" +xx Revision 1\.5 ${RCSKEYDATE} ${username} +xx modify +xx +xx Revision 1\.4 ${RCSKEYDATE} ${username} +xx First log line +xx Second log line +xx +change" + + cd ../../2/first-dir + dotest keywordlog-12 "${testcvs} -q update" "[UP] file1" + dotest keywordlog-13 "cat file1" \ +"initial +xx "'\$'"Log: file1,v "'\$'" +xx Revision 1\.5 ${RCSKEYDATE} ${username} +xx modify +xx +xx Revision 1\.4 ${RCSKEYDATE} ${username} +xx First log line +xx Second log line +xx +change" + + cd ../../1/first-dir + dotest keywordlog-14 "${testcvs} -q update -r br" "[UP] file1" + echo br-change >>file1 + dotest keywordlog-15 "${testcvs} -q ci -m br-modify" \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +new revision: 1\.4\.2\.1; previous revision: 1\.4" + dotest keywordlog-16 "cat file1" \ +"initial +xx "'\$'"Log: file1,v "'\$'" +xx Revision 1\.4\.2\.1 ${RCSKEYDATE} ${username} +xx br-modify +xx +xx Revision 1\.4 ${RCSKEYDATE} ${username} +xx First log line +xx Second log line +xx +br-change" + cd ../../2/first-dir + dotest keywordlog-17 "${testcvs} -q update -r br" "[UP] file1" + dotest keywordlog-18 "cat file1" \ +"initial +xx "'\$'"Log: file1,v "'\$'" +xx Revision 1\.4\.2\.1 ${RCSKEYDATE} ${username} +xx br-modify +xx +xx Revision 1\.4 ${RCSKEYDATE} ${username} +xx First log line +xx Second log line +xx +br-change" + cd ../.. + dotest keywordlog-19 "${testcvs} -q co -p -r br first-dir/file1" \ +"initial +xx "'\$'"Log: file1,v "'\$'" +xx Revision 1\.4\.2\.1 ${RCSKEYDATE} ${username} +xx br-modify +xx +xx Revision 1\.4 ${RCSKEYDATE} ${username} +xx First log line +xx Second log line +xx +br-change" + dotest keywordlog-20 "${testcvs} -q co -p first-dir/file1" \ +"initial +xx "'\$'"Log: file1,v "'\$'" +xx Revision 1\.5 ${RCSKEYDATE} ${username} +xx modify +xx +xx Revision 1\.4 ${RCSKEYDATE} ${username} +xx First log line +xx Second log line +xx +change" + dotest keywordlog-21 "${testcvs} -q co -p -r 1.4 first-dir/file1" \ +"initial +xx "'\$'"Log: file1,v "'\$'" +xx Revision 1\.4 ${RCSKEYDATE} ${username} +xx First log line +xx Second log line +xx" + + cd 2/first-dir + # OK, the basic rule for keyword expansion is that it + # happens on checkout. And the rule for annotate is that + # it annotates a checked-in revision, rather than a checked-out + # file. So, although it is kind of confusing that the latest + # revision does not appear in the annotated output, and the + # annotated output does not quite match what you'd get with + # update or checkout, the behavior is more or less logical. + # The same issue occurs with annotate and other keywords, + # I think, although it is particularly noticeable for $Log. + dotest keywordlog-22 "${testcvs} ann -r br file1" \ +" +Annotations for file1 +\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* +1\.3 ($username8 *[0-9a-zA-Z-]*): initial +1\.4\.2\.1 ($username8 *[0-9a-zA-Z-]*): xx "'\$'"Log: file1,v "'\$'" +1\.4\.2\.1 ($username8 *[0-9a-zA-Z-]*): xx Revision 1\.4 ${RCSKEYDATE} $username +1\.4\.2\.1 ($username8 *[0-9a-zA-Z-]*): xx First log line +1\.4\.2\.1 ($username8 *[0-9a-zA-Z-]*): xx Second log line +1\.4\.2\.1 ($username8 *[0-9a-zA-Z-]*): xx +1\.4\.2\.1 ($username8 *[0-9a-zA-Z-]*): br-change" + dotest keywordlog-23 "${testcvs} ann -r HEAD file1" \ +" +Annotations for file1 +\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* +1\.3 ($username8 *[0-9a-zA-Z-]*): initial +1\.5 ($username8 *[0-9a-zA-Z-]*): xx "'\$'"Log: file1,v "'\$'" +1\.5 ($username8 *[0-9a-zA-Z-]*): xx Revision 1\.4 ${RCSKEYDATE} $username +1\.5 ($username8 *[0-9a-zA-Z-]*): xx First log line +1\.5 ($username8 *[0-9a-zA-Z-]*): xx Second log line +1\.5 ($username8 *[0-9a-zA-Z-]*): xx +1\.5 ($username8 *[0-9a-zA-Z-]*): change" + cd ../.. + + # + # test the operation of 'admin -o' in conjunction with keywords + # (especially Log - this used to munge the RCS file for all time) + # + + dotest keywordlog-24 \ +"${testcvs} admin -oHEAD 1/first-dir/file1" \ +"RCS file: ${CVSROOT_DIRNAME}/first-dir/file1,v +deleting revision 1\.5 +done" + + dotest keywordlog-25 \ +"${testcvs} -q co -p first-dir/file1" \ +"initial +xx "'\$'"Log: file1,v "'\$'" +xx Revision 1\.4 ${RCSKEYDATE} ${username} +xx First log line +xx Second log line +xx" + + # Now test the behavior when the comment leader exceeds the + # configured maximum. + mkdir 3; cd 3 + dotest keywordlog-26 "$testcvs -Q co first-dir" + + cd first-dir + sed 's/xx \$/1234567890123456789 $/' <file1 >tmp + mv tmp file1 + dotest keywordlog-27 "$testcvs -Q ci -mrevision-5" + dotest keywordlog-28 "cat file1" \ +"initial +1234567890123456789 "'\$'"Log: file1,v "'\$'" +1234567890123456789 Revision 1\.5 $RCSKEYDATE $username +1234567890123456789 revision-5 +1234567890123456789 +xx Revision 1\.4 $RCSKEYDATE $username +xx First log line +xx Second log line +xx" + + sed 's/1234567890123456789 \$/12345678901234567890 $/' <file1 >tmp + mv tmp file1 + dotest keywordlog-29 "$testcvs -Q ci -mrevision-6" \ +"$SPROG commit: Skipping "'`$''Log$'"' keyword due to excessive comment leader\." + dotest keywordlog-30 "cat file1" \ +"initial +12345678901234567890 "'\$'"Log: file1,v "'\$'" +1234567890123456789 Revision 1\.5 $RCSKEYDATE $username +1234567890123456789 revision-5 +1234567890123456789 +xx Revision 1\.4 $RCSKEYDATE $username +xx First log line +xx Second log line +xx" + + # Check that the Log-related config options work. + cd .. + dotest keywordlog-31 "$testcvs -Q co CVSROOT" + cd CVSROOT + echo "UseArchiveCommentLeader=TrUe" >>config + dotest keywordlog-32 "$testcvs -Q ci -mset-UseArchiveCommentLeader" + + cd ../first-dir + dotest keywordlog-33 "$testcvs -Q ci -fmrevision-7 file1" + dotest keywordlog-34 "cat file1" \ +"initial +12345678901234567890 "'\$'"Log: file1,v "'\$'" +# Revision 1\.7 $RCSKEYDATE $username +# revision-7 +# +1234567890123456789 Revision 1\.5 $RCSKEYDATE $username +1234567890123456789 revision-5 +1234567890123456789 +xx Revision 1\.4 $RCSKEYDATE $username +xx First log line +xx Second log line +xx" + + cd ../CVSROOT + echo "MaxCommentLeaderLength=1k" >>config + dotest keywordlog-35 "$testcvs -Q ci -mset-MaxCommentLeaderLength" + + cd ../first-dir + dotest keywordlog-36 "$testcvs -Q ci -fmrevision-8 file1" + dotest keywordlog-37 "cat file1" \ +"initial +12345678901234567890 "'\$'"Log: file1,v "'\$'" +12345678901234567890 Revision 1\.8 $RCSKEYDATE $username +12345678901234567890 revision-8 +12345678901234567890 +# Revision 1\.7 $RCSKEYDATE $username +# revision-7 +# +1234567890123456789 Revision 1\.5 $RCSKEYDATE $username +1234567890123456789 revision-5 +1234567890123456789 +xx Revision 1\.4 $RCSKEYDATE $username +xx First log line +xx Second log line +xx" + + dokeep + cd ../.. + restore_adm + rm -r 1 2 3 + modify_repo rm -rf $CVSROOT_DIRNAME/first-dir + ;; + + + + keywordname) + # Test the Name keyword. + # See the keyword test for a descriptions of some other tests that + # test keyword expansion modes. + mkdir keywordname; cd keywordname + mkdir 1; cd 1 + dotest keywordname-init-1 "${testcvs} -q co -l ." '' + mkdir first-dir + dotest keywordname-init-2 "${testcvs} add first-dir" \ +"Directory ${CVSROOT_DIRNAME}/first-dir added to the repository" + cd first-dir + + echo '$'"Name$" >file1 + echo '$'"Name$" >file2 + dotest keywordname-init-3 "${testcvs} add file1 file2" \ +"${SPROG} add: scheduling file .file1. for addition +${SPROG} add: scheduling file .file2. for addition +${SPROG} add: use .${SPROG} commit. to add these files permanently" + + # See "rmadd" for a list of other tests of cvs ci -r. + dotest keywordname-init-4 "${testcvs} -q ci -r 1.3 -m add" \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +initial revision: 1\.3 +$CVSROOT_DIRNAME/first-dir/file2,v <-- file2 +initial revision: 1\.3" + + dotest keywordname-init-6 "${testcvs} -q up -A" + dotest keywordname-init-7 "${testcvs} -q tag -b br" \ +"T file1 +T file2" + + echo new data >>file1 + dotest keywordname-init-8 "${testcvs} -q ci -mchange" \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +new revision: 1\.4; previous revision: 1\.3" + + # First check out a branch. + # + # There used to be a bug where static tags would be substituted for + # Name keywords but not branch tags. + # + # FIXCVS - BUG + # Why shouldn't the non-update case not cause a substitution? + # An update -kk or -A will unsub and sub keywords without updates + # being required. + # FIXCVS - see note above keyword-21 + dotest keywordname-update-1 "${testcvs} -q up -rbr" "U file1" \ +"P file1 +${CPROG} update: checksum failure after patch to \./file1; will refetch +${CPROG} client: refetching unpatchable files +$SPROG update: warning: \`file1' was lost +U file1" + dotest keywordname-update-2 "cat file1" '\$'"Name: br "'\$' + dotest keywordname-update-3 "cat file2" '\$'"Name: "'\$' + + # Now verify that updating to the trunk leaves no substitution for + # $Name + dotest keywordname-update-4 "${testcvs} -q tag firsttag" \ +"T file1 +T file2" + # FIXCVS - see note above keyword-21 + dotest keywordname-update-5 "${testcvs} -q up -A" "U file1" \ +"P file1 +${CPROG} update: checksum failure after patch to \./file1; will refetch +${CPROG} client: refetching unpatchable files +$SPROG update: warning: \`file1' was lost +U file1" + dotest keywordname-update-6 "cat file1" \ +'\$'"Name: "'\$'" +new data" + dotest keywordname-update-7 "cat file2" '\$'"Name: "'\$' + + # But updating to a static tag does cause a substitution + # FIXCVS - see same note above + dotest keywordname-update-8 "${testcvs} -q up -rfirsttag" "U file1" \ +"P file1 +${CPROG} update: checksum failure after patch to \./file1; will refetch +${CPROG} client: refetching unpatchable files +$SPROG update: warning: \`file1' was lost +U file1" + dotest keywordname-update-9 "cat file1" '\$'"Name: firsttag "'\$' + dotest keywordname-update-10 "cat file2" '\$'"Name: "'\$' + + # And reverify the trunk update when the change is actually removed. + dotest keywordname-update-11 "${testcvs} -q up -A" "[UP] file1" \ +"P file1 +${CPROG} update: checksum failure after patch to ./file1; will refetch +${CPROG} client: refetching unpatchable files +$SPROG update: warning: \`file1' was lost +U file1" + dotest keywordname-update-12 "cat file1" \ +'\$'"Name: "'\$'" +new data" + dotest keywordname-update-13 "cat file2" '\$'"Name: "'\$' + + cd ../.. + + # now verify that a fresh checkout substitutes all the $Name fields + mkdir 2; cd 2 + dotest keywordname-checkout-1 \ +"${testcvs} -q co -rfirsttag first-dir" \ +"U first-dir/file1 +U first-dir/file2" + cd first-dir + dotest keywordname-checkout-2 "cat file1" '\$'"Name: firsttag "'\$' + dotest keywordname-checkout-3 "cat file2" '\$'"Name: firsttag "'\$' + + dokeep + cd ../../.. + rm -r keywordname + modify_repo rm -rf $CVSROOT_DIRNAME/first-dir + ;; + + + + keyword2) + # Test merging on files with keywords: + # without -kk + # with -kk + # on text files + # on binary files + # Note: This test assumes that CVS has already passed the binfiles + # test sequence + # Note2: We are testing positive on binary corruption here + # we probably really DON'T want to 'cvs update -kk' a binary file... + mkdir 1; cd 1 + dotest keyword2-1 "${testcvs} -q co -l ." '' + mkdir first-dir + dotest keyword2-2 "${testcvs} add first-dir" \ +"Directory ${CVSROOT_DIRNAME}/first-dir added to the repository" + cd first-dir + + echo '$''Revision$' >> file1 + echo "I" >>file1 + echo "like" >>file1 + echo "long" >>file1 + echo "files!" >>file1 + echo "" >>file1 + echo "a test line for our times" >>file1 + echo "" >>file1 + echo "They" >>file1 + echo "make" >>file1 + echo "diff" >>file1 + echo "look like it" >>file1 + echo "did a much better" >>file1 + echo "job." >>file1 + dotest keyword2-3 "${testcvs} add file1" \ +"${SPROG} add: scheduling file .file1. for addition +${SPROG} add: use .${SPROG} commit. to add this file permanently" + + ${AWK} 'BEGIN { printf "%c%c%c%sRevision: 1.1 $@%c%c", \ + 2, 10, 137, "$", 13, 10 }' \ + </dev/null | ${TR} '@' '\000' >../binfile.dat + cp ../binfile.dat . + dotest keyword2-5 "${testcvs} add -kb binfile.dat" \ +"${SPROG} add: scheduling file .binfile\.dat. for addition +${SPROG} add: use .${SPROG} commit. to add this file permanently" + + dotest keyword2-6 "${testcvs} -q ci -m add" \ +"$CVSROOT_DIRNAME/first-dir/binfile\.dat,v <-- binfile\.dat +initial revision: 1\.1 +$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +initial revision: 1\.1" + + dotest keyword2-7 "${testcvs} -q tag -b branch" \ +"T binfile\.dat +T file1" + + sed -e 's/our/the best of and the worst of/' file1 >f; mv f file1 + dotest keyword2-8 "${testcvs} -q ci -m change" \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +new revision: 1\.2; previous revision: 1\.1" + + dotest keyword2-9 "${testcvs} -q update -r branch" '[UP] file1' + + echo "what else do we have?" >>file1 + dotest keyword2-10 "${testcvs} -q ci -m change" \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +new revision: 1\.1\.2\.1; previous revision: 1\.1" + + # Okay, first a conflict in file1 - should be okay with binfile.dat + dotest keyword2-11 "${testcvs} -q update -A -j branch" \ +"U file1 +RCS file: ${CVSROOT_DIRNAME}/first-dir/file1,v +retrieving revision 1\.1 +retrieving revision 1\.1\.2\.1 +Merging differences between 1\.1 and 1\.1\.2\.1 into file1 +rcsmerge: warning: conflicts during merge" + + dotest_fail keyword2-12 "${testcvs} diff file1" \ +"Index: file1 +=================================================================== +RCS file: ${CVSROOT_DIRNAME}/first-dir/file1,v +retrieving revision 1\.2 +diff -r1\.2 file1 +0a1 +> <<<<<<< file1 +1a3,5 +> ======= +> \\\$""Revision: 1\.1\.2\.1 \\\$ +> >>>>>>> 1\.1\.2\.1 +14a19 +> what else do we have${QUESTION}" + + # Here's the problem... shouldn't -kk a binary file... + rm file1 + dotest keyword2-13 "${testcvs} -q update -A -kk -j branch" \ +"${SPROG} update: warning: \`file1' was lost +U file1 +RCS file: ${CVSROOT_DIRNAME}/first-dir/file1,v +retrieving revision 1\.1 +retrieving revision 1\.1\.2\.1 +Merging differences between 1\.1 and 1\.1\.2\.1 into file1" + + # binfile won't get checked in, but it is now corrupt and could + # have been checked in if it had changed on the branch... + dotest keyword2-14 "${testcvs} -q ci -m change" \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +new revision: 1\.3; previous revision: 1\.2" + + # "-kk" no longer corrupts binary files + dotest keyword2-15 "cmp binfile.dat ../binfile.dat" '' + + # Okay, restore everything and make CVS try and merge a binary file... + # "-kk" no longer affects binary files + dotest keyword2-16 "${testcvs} -q update -A" \ +"[UP] file1" + dotest keyword2-17 "${testcvs} -q tag -b branch2" \ +"T binfile\.dat +T file1" + dotest keyword2-18 "${testcvs} -q update -r branch2" '' + + ${AWK} 'BEGIN { printf "%c%c%c@%c%c", 2, 10, 137, 13, 10 }' \ + </dev/null | ${TR} '@' '\000' >>binfile.dat + dotest keyword2-19 "$testcvs -q ci -m badbadbad" \ +"$CVSROOT_DIRNAME/first-dir/binfile\.dat,v <-- binfile\.dat +new revision: 1\.1\.4\.1; previous revision: 1\.1" + # "-kk" no longer affects binary files + + # XXXX: do not ask, why we get the "U binfile.dat" line twice + # looks like a bug! + dotest keyword2-20 "${testcvs} -q update -A -kk -j branch2" \ +"U binfile\.dat +U binfile\.dat +U file1" + + dokeep + cd ../.. + rm -r 1 + modify_repo rm -rf $CVSROOT_DIRNAME/first-dir + ;; + + + + head) + # Testing handling of the HEAD special tag. + # There are many cases involving added and removed files + # which we don't yet try to deal with. + # TODO: We also could be paying much closer attention to + # "head of the trunk" versus "head of the default branch". + # That is what "cvs import" is doing here (but I didn't really + # fully follow through on writing the tests for that case). + mkdir imp-dir + cd imp-dir + echo 'imported contents' >file1 + # It may seem like we don't do much with file2, but do note that + # the "cvs diff" invocations do also diff file2 (and come up empty). + echo 'imported contents' >file2 + dotest_sort head-1 "${testcvs} import -m add first-dir tag1 tag2" \ +" + +N first-dir/file1 +N first-dir/file2 +No conflicts created by this import" + cd .. + rm -r imp-dir + mkdir 1 + cd 1 + dotest head-2 "${testcvs} -q co first-dir" \ +"U first-dir/file1 +U first-dir/file2" + cd first-dir + echo 'add a line on trunk' >> file1 + dotest head-3 "${testcvs} -q ci -m modify" \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +new revision: 1\.2; previous revision: 1\.1" + dotest head-4 "${testcvs} -q tag trunktag" "T file1 +T file2" + echo 'add a line on trunk after trunktag' >> file1 + dotest head-5 "${testcvs} -q ci -m modify" \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +new revision: 1\.3; previous revision: 1\.2" + dotest head-6 "${testcvs} -q tag -b br1" "T file1 +T file2" + dotest head-7 "${testcvs} -q update -r br1" "" + echo 'modify on branch' >>file1 + dotest head-8 "${testcvs} -q ci -m modify" \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +new revision: 1\.3\.2\.1; previous revision: 1\.3" + dotest head-9 "${testcvs} -q tag brtag" "T file1 +T file2" + echo 'modify on branch after brtag' >>file1 + dotest head-10 "${testcvs} -q ci -m modify" \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +new revision: 1\.3\.2\.2; previous revision: 1\.3\.2\.1" + # With no sticky tags, HEAD is the head of the trunk. + dotest head-trunk-setup "${testcvs} -q update -A" "[UP] file1" + dotest head-trunk-update "${testcvs} -q update -r HEAD -p file1" \ +"imported contents +add a line on trunk +add a line on trunk after trunktag" + # and diff thinks so too. Case (a) from the comment in + # cvs.texinfo (Common options). + dotest_fail head-trunk-diff "${testcvs} -q diff -c -r HEAD -r br1" \ +"Index: file1 +=================================================================== +RCS file: ${CVSROOT_DIRNAME}/first-dir/file1,v +retrieving revision 1\.3 +retrieving revision 1\.3\.2\.2 +diff -c -r1\.3 -r1\.3\.2\.2 +\*\*\* file1 ${RFCDATE} 1\.3 +--- file1 ${RFCDATE} 1\.3\.2\.2 +\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* +\*\*\* 1,3 \*\*\*\* +--- 1,5 ---- + imported contents + add a line on trunk + add a line on trunk after trunktag +${PLUS} modify on branch +${PLUS} modify on branch after brtag" + + # With a branch sticky tag, HEAD is the head of the trunk. + dotest head-br1-setup "${testcvs} -q update -r br1" "[UP] file1" + dotest head-br1-update "${testcvs} -q update -r HEAD -p file1" \ +"imported contents +add a line on trunk +add a line on trunk after trunktag" + # But diff thinks that HEAD is "br1". Case (b) from cvs.texinfo. + # Probably people are relying on it. + dotest head-br1-diff "${testcvs} -q diff -c -r HEAD -r br1" "" + + # With a nonbranch sticky tag on a branch, + # HEAD is the head of the trunk + dotest head-brtag-setup "${testcvs} -q update -r brtag" "[UP] file1" + dotest head-brtag-update "${testcvs} -q update -r HEAD -p file1" \ +"imported contents +add a line on trunk +add a line on trunk after trunktag" + + # CVS 1.9 and older thought that HEAD is "brtag" (this was + # noted as "strange, maybe accidental"). But "br1" makes a + # whole lot more sense. + dotest head-brtag-diff "${testcvs} -q diff -c -r HEAD -r br1" "" + + # With a nonbranch sticky tag on the trunk, HEAD is the head + # of the trunk, I think. + dotest head-trunktag-setup "${testcvs} -q update -r trunktag" \ +"[UP] file1" + dotest head-trunktag-check "cat file1" "imported contents +add a line on trunk" + dotest head-trunktag-update "${testcvs} -q update -r HEAD -p file1" \ +"imported contents +add a line on trunk +add a line on trunk after trunktag" + # Like head-brtag-diff, there is a non-branch sticky tag. + dotest_fail head-trunktag-diff \ + "${testcvs} -q diff -c -r HEAD -r br1" \ +"Index: file1 +=================================================================== +RCS file: ${CVSROOT_DIRNAME}/first-dir/file1,v +retrieving revision 1\.3 +retrieving revision 1\.3\.2\.2 +diff -c -r1\.3 -r1\.3\.2\.2 +\*\*\* file1 ${RFCDATE} 1\.3 +--- file1 ${RFCDATE} 1\.3\.2\.2 +\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* +\*\*\* 1,3 \*\*\*\* +--- 1,5 ---- + imported contents + add a line on trunk + add a line on trunk after trunktag +${PLUS} modify on branch +${PLUS} modify on branch after brtag" + + # Also might test what happens if we setup with update -r + # HEAD. In general, if sticky tags matter, does the + # behavior of "update -r <foo>" (without -p) depend on the + # sticky tags before or after the update? + + # Note that we are testing both the case where this deletes + # a revision (file1) and the case where it does not (file2) + dotest_fail head-o0a "${testcvs} admin -o ::br1" \ +"${SPROG} admin: Administrating \. +RCS file: ${CVSROOT_DIRNAME}/first-dir/file1,v +${SPROG} admin: cannot remove revision 1\.3\.2\.1 because it has tags +${SPROG} admin: RCS file for .file1. not modified\. +RCS file: ${CVSROOT_DIRNAME}/first-dir/file2,v +done" + dotest head-o0b "${testcvs} tag -d brtag" \ +"${SPROG} tag: Untagging \. +D file1 +D file2" + dotest head-o1 "${testcvs} admin -o ::br1" \ +"${SPROG} admin: Administrating \. +RCS file: ${CVSROOT_DIRNAME}/first-dir/file1,v +deleting revision 1\.3\.2\.1 +done +RCS file: ${CVSROOT_DIRNAME}/first-dir/file2,v +done" + + dokeep + cd ../.. + rm -r 1 + modify_repo rm -rf $CVSROOT_DIRNAME/first-dir + ;; + + + + tagdate) + # Test combining -r and -D. + # + # Note that this is not a complete test. It relies on the fact + # that update, checkout and export have a LOT of shared code. + # Notice: + # 1) checkout is never tested at all with -r -D + # 2) update never uses an argument to '-D' besides 'now' + # (this test does not provide enough data to prove + # that 'cvs update' with both a '-r' and a '-D' + # specified does not ignore '-D': a 'cvs up + # -r<branch> -Dnow' and a 'cvs up -r<branch>' + # should specify the same file revision). + # 3) export uses '-r<branch> -D<when there was a different + # revision>', hopefully completing this behavior test + # for checkout and update as well. + # + mkdir 1; cd 1 + save_TZ=$TZ + TZ=UTC0; export TZ + dotest tagdate-1 "${testcvs} -q co -l ." '' + mkdir first-dir + dotest tagdate-2 "${testcvs} add first-dir" \ +"Directory ${CVSROOT_DIRNAME}/first-dir added to the repository" + cd first-dir + + echo trunk-1 >file1 + dotest tagdate-3 "${testcvs} add file1" \ +"${SPROG} add: scheduling file .file1. for addition +${SPROG} add: use .${SPROG} commit. to add this file permanently" + dotest tagdate-4 "${testcvs} -q ci -m add" \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +initial revision: 1\.1" + date_T1=`getrlogdate -r1.1 first-dir/file1` + + dotest tagdate-5 "${testcvs} -q tag -b br1" "T file1" + dotest tagdate-6 "${testcvs} -q tag -b br2" "T file1" + echo trunk-2 >file1 + dotest tagdate-7 "${testcvs} -q ci -m modify-on-trunk" \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +new revision: 1\.2; previous revision: 1\.1" + date_T2=`getrlogdate -r1.2 first-dir/file1` + + # We are testing -r -D where br1 is a (magic) branch without + # any revisions. First the case where br2 doesn't have any + # revisions either: + dotest tagdate-8 "${testcvs} -q update -p -r br1 -D now" "trunk-1" + dotest tagdate-9 "${testcvs} -q update -r br2" "[UP] file1" + echo br2-1 >file1 + dotest tagdate-10 "${testcvs} -q ci -m modify-on-br2" \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +new revision: 1\.1\.4\.1; previous revision: 1\.1" + date_T3=`getrlogdate -r1.1.4.1 first-dir/file1` + + # Then the case where br2 does have revisions: + dotest tagdate-11 "${testcvs} -q update -p -r br1 -D now" "trunk-1" + + # Joins from dates on the head used to be prohibited. + dotest tagdate-12 "$testcvs -q update -j:yesterday -j:now" + dotest tagdate-12b "$testcvs -Q update -C" + # And check export + + echo br2-2 >file1 + dotest tagdate-13 "${testcvs} -q ci -m modify-2-on-br2" \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +new revision: 1\.1\.4\.2; previous revision: 1\.1\.4\.1" + date_T4=`getrlogdate -r1.1.4.2 first-dir/file1` + + # Test diff -r<tag>:<date> with two revisions specified. + dotest_fail tagdate-13b \ +"$testcvs -q diff -u -rbr2:'$date_T3' -rbr2:now file1" \ +"Index: file1 +=================================================================== +RCS file: $CVSROOT_DIRNAME/first-dir/file1,v +retrieving revision 1\.1\.4\.1 +retrieving revision 1\.1\.4\.2 +diff -u -r1\.1\.4\.1 -r1\.1\.4\.2 +--- file1 $RFCDATE 1\.1\.4\.1 ++++ file1 $RFCDATE 1\.1\.4\.2 +@@ -1 ${PLUS}1 @@ +-br2-1 +${PLUS}br2-2" + + # Tag a date on a branch. + dotest tagdate-13c "$testcvs -q tag -rbr2:'$date_T3' tagdate" \ +"T file1" + dotest tagdate-13d "$testcvs -q update -rtagdate" "[UP] file1" + dotest tagdate-13e "cat file1" "br2-1" + + # This one should fail, though currently without an error message, + # since a date on a static tag is meaningless. + dotest tagdate-13f "$testcvs -q tag -rtagdate:'$date_T3' tagdate" + + # and restore to using the trunk for future tests. + dotest tagdate-13g "$testcvs -q up -rbr2" "[UP] file1" + + cd ../.. + mkdir 2; cd 2 + dotest tagdate-14 \ +"$testcvs -q export -r br2 -D'$date_T3' first-dir" \ +"[UP] first-dir/file1" + dotest tagdate-14b "cat first-dir/file1" "br2-1" + dotest tagdate-15 \ +"$testcvs -q export -rbr2:'$date_T3' -dsecond-dir first-dir" \ +"[UP] second-dir/file1" + dotest tagdate-15b "cat second-dir/file1" "br2-1" + + # Now for annotate + cd ../1/first-dir + dotest tagdate-16 "${testcvs} annotate -rbr2 -D'$date_T3'" \ +" +Annotations for file1 +\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* +1\.1\.4\.1 ($username8 *[0-9a-zA-Z-]*): br2-1" + + dotest tagdate-17 "${testcvs} annotate -rbr2 -Dnow" \ +" +Annotations for file1 +\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* +1\.1\.4\.2 ($username8 *[0-9a-zA-Z-]*): br2-2" + + # Now check to see what happens when we add files to br2 and trunk + echo br2-1 > file3 + dotest tagdate-18 "${testcvs} add file3" \ +"${SPROG} add: scheduling file \`file3' for addition on branch \`br2' +${SPROG} add: use \`${SPROG} commit' to add this file permanently" + dotest tagdate-19 "${testcvs} -q ci -m add file3" \ +"$CVSROOT_DIRNAME/first-dir/Attic/file3,v <-- file3 +new revision: 1\.1\.2\.1; previous revision: 1\.1" + date_T5=`getrlogdate -r1.1 first-dir/file3` + date_T6=`getrlogdate -r1.1.2.1 first-dir/file3` + + cd ../.. + mkdir 3; cd 3 + dotest tagdate-20 "${testcvs} -Q co first-dir" '' + cd first-dir + echo trunk-1 > file2 + dotest tagdate-21 "${testcvs} add file2" \ +"${SPROG} add: scheduling file .file2. for addition +${SPROG} add: use .${SPROG} commit. to add this file permanently" + dotest tagdate-22 "${testcvs} -q ci -m add file2" \ +"$CVSROOT_DIRNAME/first-dir/file2,v <-- file2 +initial revision: 1\.1" + date_T7=`getrlogdate -r1.1 first-dir/file2` + echo "trunk-2" >file2 + dotest tagdate-23 "${testcvs} -q ci -m update file2" \ +"$CVSROOT_DIRNAME/first-dir/file2,v <-- file2 +new revision: 1\.2; previous revision: 1\.1" + date_T8=`getrlogdate -r1.2 first-dir/file2` + + cd ../../1/first-dir + echo br2-1 > file2 + dotest tagdate-24 "${testcvs} add file2" \ +"${SPROG} add: scheduling file \`file2' for addition on branch \`br2' +${SPROG} add: use \`${SPROG} commit' to add this file permanently" + dotest tagdate-25 "${testcvs} -q ci -m add file2" \ +"$CVSROOT_DIRNAME/first-dir/file2,v <-- file2 +new revision: 1\.2\.2\.2; previous revision: 1\.2\.2\.1" + date_T9=`getrlogdate -r1.2.2.2 first-dir/file2` + cd ../.. + + # Time Rev Branch Comments + # T0 trunk first-dir created + # T1 1.1 trunk first-dir/file1 committed "trunk-1" + # br1 branch created + # br2 branch created + # T2 1.2 trunk first-dir/file1 committed "trunk-2" + # T3 1.1.4.1 br2 first-dir/file1 committed "br2-1" + # +60s + # T4 1.1.4.2 br2 first-dir/file1 committed "br2-2" + # T5 1.1 trunk first-dir/file3 dead + # T6 1.1.2.1 br2 first-dir/file3 committed "br2-1" + # T7 1.1 trunk first-dir/file2 committed "trunk-1" + # T8 1.2 trunk first-dir/file2 committed "trunk-2" + # T8 1.2.2.1 br2 first-dir/file2 dead + # T9 1.2.2.2 br2 first-dir/file2 committed "br2-1" + # + + mkdir 4; cd 4 + (echo Dates for tagdate-26-* are:;\ + echo " date_T1='$date_T1'";\ + echo " date_T2='$date_T2'";\ + echo " date_T3='$date_T3'";\ + echo " date_T4='$date_T4'";\ + echo " date_T5='$date_T5'";\ + echo " date_T6='$date_T6'";\ + echo " date_T7='$date_T7'";\ + echo " date_T8='$date_T8'";\ + echo " date_T9='$date_T9'") >>$LOGFILE + dotest tagdate-26-trunk-t1 \ +"${testcvs} co -D'$date_T1' -d first-dir-trunk-t1 first-dir" \ +"${SPROG} checkout: Updating first-dir-trunk-t1 +U first-dir-trunk-t1/file1" + dotest tagdate-26-br2-t1 \ +"${testcvs} co -r br2 -D'$date_T1' -d first-dir-br2-t1 first-dir" \ +"${SPROG} checkout: Updating first-dir-br2-t1 +U first-dir-br2-t1/file1" + dotest tagdate-26-trunk-t2 \ +"${testcvs} co -D'$date_T2' -d first-dir-trunk-t2 first-dir" \ +"${SPROG} checkout: Updating first-dir-trunk-t2 +U first-dir-trunk-t2/file1" + dotest tagdate-26-br2-t2 \ +"${testcvs} co -r br2 -D'$date_T2' -d first-dir-br2-t2 first-dir" \ +"${SPROG} checkout: Updating first-dir-br2-t2 +U first-dir-br2-t2/file1" + dotest tagdate-26-br2-t3 \ +"${testcvs} co -r br2 -D'$date_T3' -d first-dir-br2-t3 first-dir" \ +"${SPROG} checkout: Updating first-dir-br2-t3 +U first-dir-br2-t3/file1" + dotest tagdate-26-br2-t4 \ +"${testcvs} co -r br2 -D'$date_T4' -d first-dir-br2-t4 first-dir" \ +"${SPROG} checkout: Updating first-dir-br2-t4 +U first-dir-br2-t4/file1" + dotest tagdate-26-br2-t6 \ +"${testcvs} co -r br2 -D'$date_T6' -d first-dir-br2-t6 first-dir" \ +"${SPROG} checkout: Updating first-dir-br2-t6 +U first-dir-br2-t6/file1 +U first-dir-br2-t6/file3" + dotest tagdate-26-trunk-t7 \ +"${testcvs} co -D'$date_T7' -d first-dir-trunk-t7 first-dir" \ +"${SPROG} checkout: Updating first-dir-trunk-t7 +U first-dir-trunk-t7/file1 +U first-dir-trunk-t7/file2" + dotest tagdate-26-br2-t7 \ +"${testcvs} co -r br2 -D'$date_T7' -d first-dir-br2-t7 first-dir" \ +"${SPROG} checkout: Updating first-dir-br2-t7 +U first-dir-br2-t7/file1 +U first-dir-br2-t7/file3" + dotest tagdate-26-trunk-t8 \ +"${testcvs} co -D'$date_T8' -d first-dir-trunk-t8 first-dir" \ +"${SPROG} checkout: Updating first-dir-trunk-t8 +U first-dir-trunk-t8/file1 +U first-dir-trunk-t8/file2" + dotest tagdate-26-br2-t8 \ +"${testcvs} co -r br2 -D'$date_T8' -d first-dir-br2-t8 first-dir" \ +"${SPROG} checkout: Updating first-dir-br2-t8 +U first-dir-br2-t8/file1 +U first-dir-br2-t8/file3" + dotest tagdate-26-br2-t9 \ +"${testcvs} co -r br2 -D'$date_T9' -d first-dir-br2-t9 first-dir" \ +"${SPROG} checkout: Updating first-dir-br2-t9 +U first-dir-br2-t9/file1 +U first-dir-br2-t9/file2 +U first-dir-br2-t9/file3" + dotest tagdate-27-trunk-t1 \ +"${testcvs} status first-dir-trunk-t1" \ +"${SPROG} status: Examining first-dir-trunk-t1 +=================================================================== +File: file1 Status: Up-to-date + + Working revision: 1\.1[^.]* + Repository revision: 1\.1 ${CVSROOT_DIRNAME}/first-dir/file1,v + Commit Identifier: ${commitid} + Sticky Tag: (none) + Sticky Date: ${RCSDELTADATE} + Sticky Options: (none)" + dotest tagdate-27-br2-t1 \ +"${testcvs} status first-dir-br2-t1" \ +"${SPROG} status: Examining first-dir-br2-t1 +=================================================================== +File: file1 Status: Needs Patch + + Working revision: 1\.1[^.]* + Repository revision: 1\.1\.4\.2 ${CVSROOT_DIRNAME}/first-dir/file1,v + Commit Identifier: ${commitid} + Sticky Tag: br2 (branch: 1\.1\.4) + Sticky Date: (none) + Sticky Options: (none)" + dotest tagdate-27-trunk-t2 \ +"${testcvs} status first-dir-trunk-t2" \ +"${SPROG} status: Examining first-dir-trunk-t2 +=================================================================== +File: file1 Status: Up-to-date + + Working revision: 1\.2[^.]* + Repository revision: 1\.2 ${CVSROOT_DIRNAME}/first-dir/file1,v + Commit Identifier: ${commitid} + Sticky Tag: (none) + Sticky Date: ${RCSDELTADATE} + Sticky Options: (none)" + dotest tagdate-27-br2-t2 \ +"${testcvs} status first-dir-br2-t2" \ +"${SPROG} status: Examining first-dir-br2-t2 +=================================================================== +File: file1 Status: Needs Patch + + Working revision: 1\.1[^.]* + Repository revision: 1\.1\.4\.2 ${CVSROOT_DIRNAME}/first-dir/file1,v + Commit Identifier: ${commitid} + Sticky Tag: br2 (branch: 1\.1\.4) + Sticky Date: (none) + Sticky Options: (none)" + dotest tagdate-27-br2-t3 \ +"${testcvs} status first-dir-br2-t3" \ +"${SPROG} status: Examining first-dir-br2-t3 +=================================================================== +File: file1 Status: Needs Patch + + Working revision: 1\.1\.4\.1[^.]* + Repository revision: 1\.1\.4\.2 ${CVSROOT_DIRNAME}/first-dir/file1,v + Commit Identifier: ${commitid} + Sticky Tag: br2 (branch: 1\.1\.4) + Sticky Date: (none) + Sticky Options: (none)" + dotest tagdate-27-br2-t4 \ +"${testcvs} status first-dir-br2-t4" \ +"${SPROG} status: Examining first-dir-br2-t4 +=================================================================== +File: file1 Status: Up-to-date + + Working revision: 1\.1\.4\.2[^.]* + Repository revision: 1\.1\.4\.2 ${CVSROOT_DIRNAME}/first-dir/file1,v + Commit Identifier: ${commitid} + Sticky Tag: br2 (branch: 1\.1\.4) + Sticky Date: (none) + Sticky Options: (none)" + dotest tagdate-27-br2-t6 \ +"${testcvs} status first-dir-br2-t6" \ +"${SPROG} status: Examining first-dir-br2-t6 +=================================================================== +File: file1 Status: Up-to-date + + Working revision: 1\.1\.4\.2[^.]* + Repository revision: 1\.1\.4\.2 ${CVSROOT_DIRNAME}/first-dir/file1,v + Commit Identifier: ${commitid} + Sticky Tag: br2 (branch: 1\.1\.4) + Sticky Date: (none) + Sticky Options: (none) + +=================================================================== +File: file3 Status: Up-to-date + + Working revision: 1\.1\.2\.1[^.]* + Repository revision: 1\.1\.2\.1 ${CVSROOT_DIRNAME}/first-dir/Attic/file3,v + Commit Identifier: ${commitid} + Sticky Tag: br2 (branch: 1\.1\.2) + Sticky Date: (none) + Sticky Options: (none)" + dotest tagdate-27-trunk-t7 \ +"${testcvs} status first-dir-trunk-t7" \ +"${SPROG} status: Examining first-dir-trunk-t7 +=================================================================== +File: file1 Status: Up-to-date + + Working revision: 1\.2[^.]* + Repository revision: 1\.2 ${CVSROOT_DIRNAME}/first-dir/file1,v + Commit Identifier: ${commitid} + Sticky Tag: (none) + Sticky Date: ${RCSDELTADATE} + Sticky Options: (none) + +=================================================================== +File: file2 Status: Up-to-date + + Working revision: 1\.1[^.]* + Repository revision: 1\.1 ${CVSROOT_DIRNAME}/first-dir/file2,v + Commit Identifier: ${commitid} + Sticky Tag: (none) + Sticky Date: ${RCSDELTADATE} + Sticky Options: (none)" + dotest tagdate-27-br2-t7 \ +"${testcvs} status first-dir-br2-t7" \ +"${SPROG} status: Examining first-dir-br2-t7 +=================================================================== +File: file1 Status: Up-to-date + + Working revision: 1\.1\.4\.2[^.]* + Repository revision: 1\.1\.4\.2 ${CVSROOT_DIRNAME}/first-dir/file1,v + Commit Identifier: ${commitid} + Sticky Tag: br2 (branch: 1\.1\.4) + Sticky Date: (none) + Sticky Options: (none) + +=================================================================== +File: file3 Status: Up-to-date + + Working revision: 1\.1\.2\.1[^.]* + Repository revision: 1\.1\.2\.1 ${CVSROOT_DIRNAME}/first-dir/Attic/file3,v + Commit Identifier: ${commitid} + Sticky Tag: br2 (branch: 1\.1\.2) + Sticky Date: (none) + Sticky Options: (none)" + dotest tagdate-27-trunk-t8 \ +"${testcvs} status first-dir-trunk-t8" \ +"${SPROG} status: Examining first-dir-trunk-t8 +=================================================================== +File: file1 Status: Up-to-date + + Working revision: 1\.2[^.]* + Repository revision: 1\.2 ${CVSROOT_DIRNAME}/first-dir/file1,v + Commit Identifier: ${commitid} + Sticky Tag: (none) + Sticky Date: ${RCSDELTADATE} + Sticky Options: (none) + +=================================================================== +File: file2 Status: Up-to-date + + Working revision: 1\.2[^.]* + Repository revision: 1\.2 ${CVSROOT_DIRNAME}/first-dir/file2,v + Commit Identifier: ${commitid} + Sticky Tag: (none) + Sticky Date: ${RCSDELTADATE} + Sticky Options: (none)" + dotest tagdate-27-br2-t8 \ +"${testcvs} status first-dir-br2-t8" \ +"${SPROG} status: Examining first-dir-br2-t8 +=================================================================== +File: file1 Status: Up-to-date + + Working revision: 1\.1\.4\.2[^.]* + Repository revision: 1\.1\.4\.2 ${CVSROOT_DIRNAME}/first-dir/file1,v + Commit Identifier: ${commitid} + Sticky Tag: br2 (branch: 1\.1\.4) + Sticky Date: (none) + Sticky Options: (none) + +=================================================================== +File: file3 Status: Up-to-date + + Working revision: 1\.1\.2\.1[^.]* + Repository revision: 1\.1\.2\.1 ${CVSROOT_DIRNAME}/first-dir/Attic/file3,v + Commit Identifier: ${commitid} + Sticky Tag: br2 (branch: 1\.1\.2) + Sticky Date: (none) + Sticky Options: (none)" + dotest tagdate-27-br2-t9 \ +"${testcvs} status first-dir-br2-t9" \ +"${SPROG} status: Examining first-dir-br2-t9 +=================================================================== +File: file1 Status: Up-to-date + + Working revision: 1\.1\.4\.2[^.]* + Repository revision: 1\.1\.4\.2 ${CVSROOT_DIRNAME}/first-dir/file1,v + Commit Identifier: ${commitid} + Sticky Tag: br2 (branch: 1\.1\.4) + Sticky Date: (none) + Sticky Options: (none) + +=================================================================== +File: file2 Status: Up-to-date + + Working revision: 1\.2\.2\.2[^.]* + Repository revision: 1\.2\.2\.2 ${CVSROOT_DIRNAME}/first-dir/file2,v + Commit Identifier: ${commitid} + Sticky Tag: br2 (branch: 1\.2\.2) + Sticky Date: (none) + Sticky Options: (none) + +=================================================================== +File: file3 Status: Up-to-date + + Working revision: 1\.1\.2\.1[^.]* + Repository revision: 1\.1\.2\.1 ${CVSROOT_DIRNAME}/first-dir/Attic/file3,v + Commit Identifier: ${commitid} + Sticky Tag: br2 (branch: 1\.1\.2) + Sticky Date: (none) + Sticky Options: (none)" + + # Now check the contents of the files + dotest tagdate-28-trunk-t1 'cat first-dir-trunk-t1/file1' 'trunk-1' + dotest tagdate-28-br2-t1 'cat first-dir-br2-t1/file1' 'trunk-1' + dotest tagdate-28-trunk-t2 'cat first-dir-trunk-t2/file1' 'trunk-2' + dotest tagdate-28-br2-t2 'cat first-dir-br2-t2/file1' 'trunk-1' + dotest tagdate-28-br2-t3 'cat first-dir-br2-t3/file1' 'br2-1' + dotest tagdate-28-br2-t4 'cat first-dir-br2-t4/file1' 'br2-2' + dotest tagdate-28-br2-t6a 'cat first-dir-br2-t6/file1' "br2-2" + dotest tagdate-28-br2-t6b 'cat first-dir-br2-t6/file3' "br2-1" + dotest tagdate-28-trunk-t7a 'cat first-dir-trunk-t7/file1' "trunk-2" + dotest tagdate-28-trunk-t7b 'cat first-dir-trunk-t7/file2' "trunk-1" + dotest tagdate-28-br2-t7a 'cat first-dir-br2-t7/file1' "br2-2" + dotest tagdate-28-br2-t7b 'cat first-dir-br2-t7/file3' "br2-1" + dotest tagdate-28-trunk-t8a 'cat first-dir-trunk-t8/file1' "trunk-2" + dotest tagdate-28-trunk-t8b 'cat first-dir-trunk-t8/file2' "trunk-2" + dotest tagdate-28-br2-t8a 'cat first-dir-br2-t8/file1' "br2-2" + dotest tagdate-28-br2-t8c 'cat first-dir-br2-t8/file3' "br2-1" + dotest tagdate-28-br2-t9a 'cat first-dir-br2-t9/file1' "br2-2" + dotest tagdate-28-br2-t9b 'cat first-dir-br2-t9/file2' "br2-1" + dotest tagdate-28-br2-t9c 'cat first-dir-br2-t9/file3' "br2-1" + cd .. + + unset date_T1 date_T2 date_T3 date_T4 date_T5 + unset date_T6 date_T7 date_T8 date_T9 + TZ=$save_TZ + + dokeep + rm -r 1 2 3 4 + modify_repo rm -rf $CVSROOT_DIRNAME/first-dir + ;; + + + + multibranch2) + # Commit the first delta on branch A when there is an older + # branch, B, that already has a delta. A and B come from the + # same branch point. Then verify that branches A and B are + # in the right order. + mkdir 1; cd 1 + dotest multibranch2-1 "${testcvs} -q co -l ." '' + mkdir first-dir + dotest multibranch2-2 "${testcvs} add first-dir" \ +"Directory ${CVSROOT_DIRNAME}/first-dir added to the repository" + cd first-dir + + echo trunk-1 >file1 + echo trunk-1 >file2 + dotest multibranch2-3 "${testcvs} add file1 file2" \ +"${SPROG} add: scheduling file .file1. for addition +${SPROG} add: scheduling file .file2. for addition +${SPROG} add: use .${SPROG} commit. to add these files permanently" + dotest multibranch2-4 "${testcvs} -q ci -m add" \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +initial revision: 1\.1 +$CVSROOT_DIRNAME/first-dir/file2,v <-- file2 +initial revision: 1\.1" + dotest multibranch2-5 "${testcvs} -q tag -b A" "T file1 +T file2" + dotest multibranch2-6 "${testcvs} -q tag -b B" "T file1 +T file2" + + dotest multibranch2-7 "${testcvs} -q update -r B" '' + echo branch-B >file1 + echo branch-B >file2 + dotest multibranch2-8 "${testcvs} -q ci -m modify-on-B" \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +new revision: 1\.1\.4\.1; previous revision: 1\.1 +$CVSROOT_DIRNAME/first-dir/file2,v <-- file2 +new revision: 1\.1\.4\.1; previous revision: 1\.1" + + dotest multibranch2-9 "${testcvs} -q update -r A" '[UP] file1 +[UP] file2' + echo branch-A >file1 + # When using cvs-1.9.20, this commit gets a failed assertion in rcs.c. + dotest multibranch2-10 "${testcvs} -q ci -m modify-on-A" \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +new revision: 1\.1\.2\.1; previous revision: 1\.1" + + dotest multibranch2-11 "${testcvs} -q log file1" \ +" +RCS file: ${CVSROOT_DIRNAME}/first-dir/file1,v +Working file: file1 +head: 1\.1 +branch: +locks: strict +access list: +symbolic names: + B: 1\.1\.0\.4 + A: 1\.1\.0\.2 +keyword substitution: kv +total revisions: 3; selected revisions: 3 +description: +---------------------------- +revision 1\.1 +date: ${ISO8601DATE}; author: $username; state: Exp; commitid: ${commitid}; +branches: 1\.1\.2; 1\.1\.4; +add +---------------------------- +revision 1\.1\.4\.1 +date: ${ISO8601DATE}; author: $username; state: Exp; lines: ${PLUS}1 -1; commitid: ${commitid}; +modify-on-B +---------------------------- +revision 1\.1\.2\.1 +date: ${ISO8601DATE}; author: $username; state: Exp; lines: ${PLUS}1 -1; commitid: ${commitid}; +modify-on-A +=============================================================================" + + # This one is more concise. + dotest multibranch2-12 "${testcvs} -q log -r1.1 file1" \ +" +RCS file: ${CVSROOT_DIRNAME}/first-dir/file1,v +Working file: file1 +head: 1\.1 +branch: +locks: strict +access list: +symbolic names: + B: 1\.1\.0\.4 + A: 1\.1\.0\.2 +keyword substitution: kv +total revisions: 3; selected revisions: 1 +description: +---------------------------- +revision 1\.1 +date: ${ISO8601DATE}; author: $username; state: Exp; commitid: ${commitid}; +branches: 1\.1\.2; 1\.1\.4; +add +=============================================================================" + + # OK, try very much the same thing except we run update -j to + # bring the changes from B to A. Probably tests many of the + # same code paths but might as well keep it separate, I guess. + + dotest multibranch2-13 "${testcvs} -q update -r B" "[UP] file1 +[UP] file2" + dotest multibranch2-14 "${testcvs} -q update -r A -j B file2" \ +"[UP] file2 +RCS file: ${CVSROOT_DIRNAME}/first-dir/file2,v +retrieving revision 1.1 +retrieving revision 1.1.4.1 +Merging differences between 1.1 and 1.1.4.1 into file2" + dotest multibranch2-15 "${testcvs} -q ci -m commit-on-A file2" \ +"$CVSROOT_DIRNAME/first-dir/file2,v <-- file2 +new revision: 1\.1\.2\.1; previous revision: 1\.1" + + dokeep + cd ../.. + rm -r 1 + modify_repo rm -rf $CVSROOT_DIRNAME/first-dir + ;; + + + + tag8k) + # In cvs-1.9.27, there is a bug that can cause an abort. + # It happens when you commit a change to a ,v file that has + # just the right amount of tag/branch info to align one of the + # semicolons in the branch info to be on a 8k-byte boundary. + # The result: rcsbuf_getkey got an abort. This failure doesn't + # corrupt the ,v file -- that would be really serious. But it + # does leave stale write locks that have to be removed manually. + + mkdir 1 + cd 1 + + module=x + + : > junk + dotest tag8k-1 "$testcvs -Q import -m . $module X Y" '' + dotest tag8k-2 "$testcvs -Q co $module" '' + cd $module + + file=m + : > $file + dotest tag8k-3 "$testcvs add $file" \ +"$SPROG add: scheduling file .$file. for addition +$SPROG add: use .$SPROG commit. to add this file permanently" + dotest tag8k-4 "$testcvs -Q ci -m . $file" + + # It seems there have to be at least two versions. + echo a > $file + dotest tag8k-5 "$testcvs -Q ci -m . $file" + + # Add just under 8K worth of tags. + t=TAG--------------------------------------------------------------------- + t=$t$t + t=$t$t$t$t$t + # Now $t is 720 bytes long. + + # Apply some tags with that long prefix. + dotest tag8k-6 "$testcvs -Q tag $t-0 $file" '' + dotest tag8k-7 "$testcvs -Q tag $t-1 $file" '' + dotest tag8k-8 "$testcvs -Q tag $t-2 $file" '' + dotest tag8k-9 "$testcvs -Q tag $t-3 $file" '' + dotest tag8k-10 "$testcvs -Q tag $t-4 $file" '' + dotest tag8k-11 "$testcvs -Q tag $t-5 $file" '' + dotest tag8k-12 "$testcvs -Q tag $t-6 $file" '' + dotest tag8k-13 "$testcvs -Q tag $t-7 $file" '' + dotest tag8k-14 "$testcvs -Q tag $t-8 $file" '' + dotest tag8k-15 "$testcvs -Q tag $t-9 $file" '' + dotest tag8k-16 "$testcvs -Q tag $t-a $file" '' + + # Extract the author value. + name=`sed -n 's/.*; author \([^;]*\);.*/\1/p' ${CVSROOT_DIRNAME}/$module/$file,v|sed 1q` + + # Form a suffix string of length (16 - length($name)). + # CAREFUL: this will lose if $name is longer than 16. + sed_pattern=`echo $name|sed s/././g` + suffix=`echo 1234567890123456|sed s/$sed_pattern//` + + # Add a final tag with length chosen so that it will push the + # offset of the `;' in the 2nd occurrence of `;\tauthor' in the + # ,v file to exactly 8192. + dotest tag8k-17 "$testcvs -Q tag "x8bytes-$suffix" $file" '' + + # This commit would fail with 1.9.27. + echo a >> $file + dotest tag8k-18 "$testcvs -Q ci -m . $file" + + dokeep + cd ../.. + rm -r 1 + modify_repo rm -rf $CVSROOT_DIRNAME/$module + ;; + + + + admin) + # More "cvs admin" tests. + # The basicb-21 test tests rejecting an invalid option. + # For -l and -u, see "reserved" and "keyword" tests. + # "binfiles" test has a test of "cvs admin -k". + # "log2" test has tests of -t and -q options to cvs admin. + # "rcs" tests -b option also. + # For -o, see: + # admin-22-o1 through admin-23 (various cases not involving ::) + # binfiles2-o* (:rev, rev on trunk; rev:, deleting entire branch) + # basicb-o* (attempt to delete all revisions) + # basica-o1 through basica-o3 (basic :: usage) + # head-o1 (::branch, where this deletes a revision or is noop) + # branches-o1 (::branch, similar, with different branch topology) + # log-o1 (1.3.2.1::) + # binfiles-o1 (1.3:: and ::1.3; binary files) + # binfiles3-9 (binary files) + # Also could be testing: + # 1.3.2.6::1.3.2.8 + # 1.3.2.6::1.3.2 + # 1.3.2.1::1.3.2.6 + # 1.3::1.3.2.6 (error? or synonym for ::1.3.2.6?) + # -n: admin, tagf tests. + + # Test the postadmin hook as a side effect of the rest of the tests. + # See the `info' test for notes on where other script hooks are + # tested. + mkdir 2; cd 2 + dotest admin-init-1 "$testcvs -Q co CVSROOT" + cd CVSROOT + echo "ALL $TESTDIR/2/loggit %r %p %c" >>postadmin + dotest admin-init-2 "$testcvs -Q ci -mlog-admin" + cd .. # 2 + + cat >loggit <<EOF +#!$TESTSHELL +echo \${1+"\$@"} >>$TESTDIR/2/admin-log +EOF + # #^@&!^@ Cygwin. + if test -n "$remotehost"; then + $CVS_RSH $remotehost "chmod +x $TESTDIR/2/loggit" + else + chmod +x loggit + fi + cd .. # $TESTDIR + + + mkdir 1; cd 1 + dotest admin-1 "${testcvs} -q co -l ." '' + mkdir first-dir + dotest admin-2 "${testcvs} add first-dir" \ +"Directory ${CVSROOT_DIRNAME}/first-dir added to the repository" + cd first-dir + + dotest_fail admin-3 "${testcvs} -q admin -i file1" \ +"${CPROG} admin: the -i option to admin is not supported +${CPROG} admin: run add or import to create an RCS file +${CPROG} \[admin aborted\]: specify ${CPROG} -H admin for usage information" + dotest_fail admin-4 "${testcvs} -q log file1" \ +"${SPROG} log: nothing known about file1" + dotest_fail admin-4a "${testcvs} -q admin file1" \ +"${SPROG} admin: nothing known about file1" + + # Set up some files, file2 a plain one and file1 with a revision + # on a branch. + touch file1 file2 + dotest admin-5 "${testcvs} add file1 file2" \ +"${SPROG} add: scheduling file .file1. for addition +${SPROG} add: scheduling file .file2. for addition +${SPROG} add: use .${SPROG} commit. to add these files permanently" + dotest admin-6 "${testcvs} -q ci -m add" \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +initial revision: 1\.1 +$CVSROOT_DIRNAME/first-dir/file2,v <-- file2 +initial revision: 1\.1" + dotest admin-7 "${testcvs} -q tag -b br" "T file1 +T file2" + dotest admin-8 "${testcvs} -q update -r br" "" + echo 'add a line on the branch' >> file1 + echo 'add a file on the branch' >> file3 + dotest admin-9a "${testcvs} -q add file3" \ +"${SPROG} add: use .${SPROG} commit. to add this file permanently" + dotest admin-9b "${testcvs} -q ci -m modify-on-branch" \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +new revision: 1\.1\.2\.1; previous revision: 1\.1 +$CVSROOT_DIRNAME/first-dir/Attic/file3,v <-- file3 +new revision: 1\.1\.2\.1; previous revision: 1\.1" + dotest admin-10 "${testcvs} -q update -A" \ +"U file1 +${SPROG} update: \`file3' is no longer in the repository" + + # Check that we can administer files in the repository that + # aren't in the working directory. + dotest admin-10-1 "${testcvs} admin ." \ +"${SPROG} admin: Administrating . +RCS file: ${CVSROOT_DIRNAME}/first-dir/file1,v +done +RCS file: ${CVSROOT_DIRNAME}/first-dir/file2,v +done" + dotest admin-10-2 "${testcvs} -q admin file3" \ +"RCS file: ${CVSROOT_DIRNAME}/first-dir/Attic/file3,v +done" + + # Try to recurse with a numeric revision arg. + # If we wanted to comprehensive about this, we would also test + # this for -l, -u, and all the different -o syntaxes. + dotest_fail admin-10a "${testcvs} -q admin -b1.1.2" \ +"${CPROG} admin: while processing more than one file: +${CPROG} \[admin aborted\]: attempt to specify a numeric revision" + dotest_fail admin-10b "${testcvs} -q admin -m1.1:bogus file1 file2" \ +"${CPROG} admin: while processing more than one file: +${CPROG} \[admin aborted\]: attempt to specify a numeric revision" + + # try a bad symbolic revision + dotest_fail admin-10c "${testcvs} -q admin -bBOGUS" \ +"RCS file: ${CVSROOT_DIRNAME}/first-dir/file1,v +${SPROG} admin: ${CVSROOT_DIRNAME}/first-dir/file1,v: Symbolic name BOGUS is undefined. +${SPROG} admin: RCS file for .file1. not modified\. +RCS file: ${CVSROOT_DIRNAME}/first-dir/file2,v +${SPROG} admin: ${CVSROOT_DIRNAME}/first-dir/file2,v: Symbolic name BOGUS is undefined. +${SPROG} admin: RCS file for .file2. not modified\." + + # Note that -s option applies to the new default branch, not + # the old one. + # Also note that the implementation of -a via "rcs" requires + # no space between -a and the argument. However, we expect + # to change that once CVS parses options. + dotest admin-11 "${testcvs} -q admin -afoo,bar -abaz \ +-b1.1.2 -cxx -U -sfoo file1" \ +"RCS file: ${CVSROOT_DIRNAME}/first-dir/file1,v +done" + dotest admin-11a "${testcvs} log -N file1" " +RCS file: ${CVSROOT_DIRNAME}/first-dir/file1,v +Working file: file1 +head: 1\.1 +branch: 1\.1\.2 +locks: +access list: + foo + bar + baz +keyword substitution: kv +total revisions: 2; selected revisions: 2 +description: +---------------------------- +revision 1\.1 +date: ${ISO8601DATE}; author: ${username}; state: Exp; commitid: ${commitid}; +branches: 1\.1\.2; +add +---------------------------- +revision 1\.1\.2\.1 +date: ${ISO8601DATE}; author: ${username}; state: foo; lines: ${PLUS}1 -0; commitid: ${commitid}; +modify-on-branch +=============================================================================" + dotest admin-12 "${testcvs} -q admin -bbr file1" \ +"RCS file: ${CVSROOT_DIRNAME}/first-dir/file1,v +done" + dotest admin-12a "${testcvs} log -N file1" " +RCS file: ${CVSROOT_DIRNAME}/first-dir/file1,v +Working file: file1 +head: 1\.1 +branch: 1\.1\.2 +locks: +access list: + foo + bar + baz +keyword substitution: kv +total revisions: 2; selected revisions: 2 +description: +---------------------------- +revision 1\.1 +date: ${ISO8601DATE}; author: ${username}; state: Exp; commitid: ${commitid}; +branches: 1\.1\.2; +add +---------------------------- +revision 1\.1\.2\.1 +date: ${ISO8601DATE}; author: ${username}; state: foo; lines: ${PLUS}1 -0; commitid: ${commitid}; +modify-on-branch +=============================================================================" + + # "cvs log" doesn't print the comment leader. RCS 5.7 will print + # the comment leader only if one specifies "-V4" to rlog. So it + # seems like the only way to test it is by looking at the RCS file + # directly. This also serves as a test of exporting RCS files + # (analogous to the import tests in "rcs"). + # Rather than try to write a rigorous check for whether the + # file CVS exports is valid, we just write a simpler + # test for what CVS actually exports, and figure we can revise + # the check as needed (within the confines of the RCS5 format as + # documented in RCSFILES). + # Note that we must accept either 2 or 4 digit year. + dotest admin-13 "cat ${CVSROOT_DIRNAME}/first-dir/file1,v" \ +"head 1\.1; +branch 1\.1\.2; +access + foo + bar + baz; +symbols + br:1\.1\.0\.2; +locks; +comment @xx@; + + +1\.1 +date ${RCSDELTADATE}; author ${username}; state Exp; +branches + 1\.1\.2\.1; +next ; +commitid ${commitid}; + +1\.1\.2\.1 +date ${RCSDELTADATE}; author ${username}; state foo; +branches; +next ; +commitid ${commitid}; + + +desc +@@ + + +1\.1 +log +@add +@ +text +@@ + + +1\.1\.2\.1 +log +@modify-on-branch +@ +text +@a0 1 +add a line on the branch +@" + dotest_fail admin-14-1 "${testcvs} -q admin \ +-m1.1.1.1:changed-bogus-log-message file2" \ +"RCS file: ${CVSROOT_DIRNAME}/first-dir/file2,v +$SPROG admin: $CVSROOT_DIRNAME/first-dir/file2,v: no such revision 1\.1\.1\.1 +$SPROG admin: RCS file for .file2. not modified." + dotest admin-14-2 "${testcvs} -q log file2" " +RCS file: ${CVSROOT_DIRNAME}/first-dir/file2,v +Working file: file2 +head: 1\.1 +branch: +locks: strict +access list: +symbolic names: + br: 1\.1\.0\.2 +keyword substitution: kv +total revisions: 1; selected revisions: 1 +description: +---------------------------- +revision 1\.1 +date: ${ISO8601DATE}; author: ${username}; state: Exp; commitid: ${commitid}; +add +=============================================================================" + + dotest admin-14-3 "${testcvs} -q admin -aauth3 -aauth2,foo \ +-soneone:1.1 -m1.1:changed-log-message -ntagone: file2" \ +"RCS file: ${CVSROOT_DIRNAME}/first-dir/file2,v +done" + dotest admin-15 "${testcvs} -q log file2" " +RCS file: ${CVSROOT_DIRNAME}/first-dir/file2,v +Working file: file2 +head: 1\.1 +branch: +locks: strict +access list: + auth3 + auth2 + foo +symbolic names: + tagone: 1\.1 + br: 1\.1\.0\.2 +keyword substitution: kv +total revisions: 1; selected revisions: 1 +description: +---------------------------- +revision 1\.1 +date: ${ISO8601DATE}; author: ${username}; state: oneone; commitid: ${commitid}; +changed-log-message +=============================================================================" + + dotest admin-16 "${testcvs} -q admin \ +-A${CVSROOT_DIRNAME}/first-dir/file2,v -b -L -Nbr:1.1 file1" \ +"RCS file: ${CVSROOT_DIRNAME}/first-dir/file1,v +done" + dotest admin-17 "${testcvs} -q log file1" " +RCS file: ${CVSROOT_DIRNAME}/first-dir/file1,v +Working file: file1 +head: 1\.1 +branch: +locks: strict +access list: + foo + bar + baz + auth3 + auth2 +symbolic names: + br: 1\.1 +keyword substitution: kv +total revisions: 2; selected revisions: 2 +description: +---------------------------- +revision 1\.1 +date: ${ISO8601DATE}; author: ${username}; state: Exp; commitid: ${commitid}; +branches: 1\.1\.2; +add +---------------------------- +revision 1\.1\.2\.1 +date: ${ISO8601DATE}; author: ${username}; state: foo; lines: ${PLUS}1 -0; commitid: ${commitid}; +modify-on-branch +=============================================================================" + + dotest_fail admin-18 "${testcvs} -q admin -nbr:1.1.2 file1" \ +"RCS file: ${CVSROOT_DIRNAME}/first-dir/file1,v +${SPROG} admin: ${CVSROOT_DIRNAME}/first-dir/file1,v: symbolic name br already bound to 1\.1 +${SPROG} admin: RCS file for .file1. not modified\." + dotest admin-19 "${testcvs} -q admin -ebaz -ebar,auth3 -nbr file1" \ +"RCS file: ${CVSROOT_DIRNAME}/first-dir/file1,v +done" + dotest admin-20 "${testcvs} -q log file1" " +RCS file: ${CVSROOT_DIRNAME}/first-dir/file1,v +Working file: file1 +head: 1\.1 +branch: +locks: strict +access list: + foo + auth2 +symbolic names: +keyword substitution: kv +total revisions: 2; selected revisions: 2 +description: +---------------------------- +revision 1\.1 +date: ${ISO8601DATE}; author: ${username}; state: Exp; commitid: ${commitid}; +branches: 1\.1\.2; +add +---------------------------- +revision 1.1.2.1 +date: ${ISO8601DATE}; author: ${username}; state: foo; lines: ${PLUS}1 -0; commitid: ${commitid}; +modify-on-branch +=============================================================================" + + # OK, this is starting to get ridiculous, in terms of + # testing a feature (access lists) which doesn't do anything + # useful, but what about nonexistent files and + # relative pathnames in admin -A? + dotest_fail admin-19a-nonexist \ +"${testcvs} -q admin -A${TESTDIR}/foo/bar file1" \ +"RCS file: ${CVSROOT_DIRNAME}/first-dir/file1,v +${SPROG} admin: Couldn't open rcs file .${TESTDIR}/foo/bar.: No such file or directory +${SPROG} \[admin aborted\]: cannot continue" + + # In the remote case, we are cd'd off into the temp directory + # and so these tests give "No such file or directory" errors. + if $remote; then :; else + dotest admin-19a-admin "${testcvs} -q admin -A../../cvsroot/first-dir/file2,v file1" \ +"RCS file: ${CVSROOT_DIRNAME}/first-dir/file1,v +done" + dotest admin-19a-log "${testcvs} -q log -h -N file1" " +RCS file: ${CVSROOT_DIRNAME}/first-dir/file1,v +Working file: file1 +head: 1\.1 +branch: +locks: strict +access list: + foo + auth2 + auth3 +keyword substitution: kv +total revisions: 2 +=============================================================================" + fi # end of tests skipped for remote + + # Now test that plain -e works right. + dotest admin-19a-2 "${testcvs} -q admin -e file1" \ +"RCS file: ${CVSROOT_DIRNAME}/first-dir/file1,v +done" + dotest admin-19a-3 "${testcvs} -q log -h -N file1" " +RCS file: ${CVSROOT_DIRNAME}/first-dir/file1,v +Working file: file1 +head: 1\.1 +branch: +locks: strict +access list: +keyword substitution: kv +total revisions: 2 +=============================================================================" + + # Put the access list back, to avoid special cases later. + dotest admin-19a-4 "${testcvs} -q admin -afoo,auth2 file1" \ +"RCS file: ${CVSROOT_DIRNAME}/first-dir/file1,v +done" + + # Add another revision to file2, so we can delete one. + echo 'add a line' >> file2 + dotest admin-21 "${testcvs} -q ci -m modify file2" \ +"$CVSROOT_DIRNAME/first-dir/file2,v <-- file2 +new revision: 1\.2; previous revision: 1\.1" + dotest admin-22 "${testcvs} -q admin -o1.1 file2" \ +"RCS file: ${CVSROOT_DIRNAME}/first-dir/file2,v +deleting revision 1\.1 +done" + # Test admin -o. More variants that we could be testing: + # * REV: [on branch] + # * REV1:REV2 [deleting whole branch] + # * high branch numbers (e.g. 1.2.2.3.2.3) + # ... and probably others. See RCS_delete_revs for ideas. + + echo first rev > aaa + dotest admin-22-o1 "${testcvs} add aaa" \ +"${SPROG} add: scheduling file .aaa. for addition +${SPROG} add: use .${SPROG} commit. to add this file permanently" + dotest admin-22-o2 "${testcvs} -q ci -m first aaa" \ +"$CVSROOT_DIRNAME/first-dir/aaa,v <-- aaa +initial revision: 1\.1" + echo second rev >> aaa + dotest admin-22-o3 "${testcvs} -q ci -m second aaa" \ +"$CVSROOT_DIRNAME/first-dir/aaa,v <-- aaa +new revision: 1\.2; previous revision: 1\.1" + echo third rev >> aaa + dotest admin-22-o4 "${testcvs} -q ci -m third aaa" \ +"$CVSROOT_DIRNAME/first-dir/aaa,v <-- aaa +new revision: 1\.3; previous revision: 1\.2" + echo fourth rev >> aaa + dotest admin-22-o5 "${testcvs} -q ci -m fourth aaa" \ +"$CVSROOT_DIRNAME/first-dir/aaa,v <-- aaa +new revision: 1\.4; previous revision: 1\.3" + echo fifth rev >>aaa + dotest admin-22-o6 "${testcvs} -q ci -m fifth aaa" \ +"$CVSROOT_DIRNAME/first-dir/aaa,v <-- aaa +new revision: 1\.5; previous revision: 1\.4" + echo sixth rev >> aaa + dotest admin-22-o7 "${testcvs} -q ci -m sixth aaa" \ +"$CVSROOT_DIRNAME/first-dir/aaa,v <-- aaa +new revision: 1\.6; previous revision: 1\.5" + dotest admin-22-o8 "${testcvs} admin -l1.6 aaa" \ +"RCS file: ${CVSROOT_DIRNAME}/first-dir/aaa,v +1\.6 locked +done" + dotest admin-22-o9 "${testcvs} log -r1.6 aaa" " +RCS file: ${CVSROOT_DIRNAME}/first-dir/aaa,v +Working file: aaa +head: 1\.6 +branch: +locks: strict + ${username}: 1\.6 +access list: +symbolic names: +keyword substitution: kv +total revisions: 6; selected revisions: 1 +description: +---------------------------- +revision 1\.6 locked by: ${username}; +date: ${ISO8601DATE}; author: ${username}; state: Exp; lines: ${PLUS}1 -0; commitid: ${commitid}; +sixth +=============================================================================" + dotest_fail admin-22-o10 "${testcvs} admin -o1.5: aaa" \ +"RCS file: ${CVSROOT_DIRNAME}/first-dir/aaa,v +${SPROG} admin: ${CVSROOT_DIRNAME}/first-dir/aaa,v: can't remove locked revision 1\.6 +${SPROG} admin: RCS file for .aaa. not modified\." + dotest admin-22-o11 "${testcvs} admin -u aaa" \ +"RCS file: ${CVSROOT_DIRNAME}/first-dir/aaa,v +1\.6 unlocked +done" + dotest admin-22-o12 "${testcvs} admin -o1.5: aaa" \ +"RCS file: ${CVSROOT_DIRNAME}/first-dir/aaa,v +deleting revision 1\.6 +deleting revision 1\.5 +done" + dotest admin-22-o13 "${testcvs} log aaa" " +RCS file: ${CVSROOT_DIRNAME}/first-dir/aaa,v +Working file: aaa +head: 1\.4 +branch: +locks: strict +access list: +symbolic names: +keyword substitution: kv +total revisions: 4; selected revisions: 4 +description: +---------------------------- +revision 1\.4 +date: ${ISO8601DATE}; author: ${username}; state: Exp; lines: ${PLUS}1 -0; commitid: ${commitid}; +fourth +---------------------------- +revision 1\.3 +date: ${ISO8601DATE}; author: ${username}; state: Exp; lines: ${PLUS}1 -0; commitid: ${commitid}; +third +---------------------------- +revision 1\.2 +date: ${ISO8601DATE}; author: ${username}; state: Exp; lines: ${PLUS}1 -0; commitid: ${commitid}; +second +---------------------------- +revision 1\.1 +date: ${ISO8601DATE}; author: ${username}; state: Exp; commitid: ${commitid}; +first +=============================================================================" + + dotest admin-22-o14 "${testcvs} tag -b -r1.3 br1 aaa" "T aaa" + dotest admin-22-o15 "${testcvs} update -rbr1 aaa" "U aaa" + echo new branch rev >> aaa + dotest admin-22-o16 "${testcvs} ci -m new-branch aaa" \ +"$CVSROOT_DIRNAME/first-dir/aaa,v <-- aaa +new revision: 1\.3\.2\.1; previous revision: 1\.3" + dotest_fail admin-22-o17 "${testcvs} admin -o1.2:1.4 aaa" \ +"RCS file: ${CVSROOT_DIRNAME}/first-dir/aaa,v +deleting revision 1\.4 +${SPROG} admin: ${CVSROOT_DIRNAME}/first-dir/aaa,v: can't remove branch point 1\.3 +${SPROG} admin: RCS file for .aaa. not modified\." + dotest admin-22-o18 "${testcvs} update -p -r1.4 aaa" \ +"=================================================================== +Checking out aaa +RCS: ${CVSROOT_DIRNAME}/first-dir/aaa,v +VERS: 1\.4 +\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* +first rev +second rev +third rev +fourth rev" + echo second branch rev >> aaa + dotest admin-22-o19 "${testcvs} ci -m branch-two aaa" \ +"$CVSROOT_DIRNAME/first-dir/aaa,v <-- aaa +new revision: 1\.3\.2\.2; previous revision: 1\.3\.2\.1" + echo third branch rev >> aaa + dotest admin-22-o20 "${testcvs} ci -m branch-three aaa" \ +"$CVSROOT_DIRNAME/first-dir/aaa,v <-- aaa +new revision: 1\.3\.2\.3; previous revision: 1\.3\.2\.2" + echo fourth branch rev >> aaa + dotest admin-22-o21 "${testcvs} ci -m branch-four aaa" \ +"$CVSROOT_DIRNAME/first-dir/aaa,v <-- aaa +new revision: 1\.3\.2\.4; previous revision: 1\.3\.2\.3" + dotest admin-22-o22 "${testcvs} admin -o:1.3.2.3 aaa" \ +"RCS file: ${CVSROOT_DIRNAME}/first-dir/aaa,v +deleting revision 1\.3\.2\.1 +deleting revision 1\.3\.2\.2 +deleting revision 1\.3\.2\.3 +done" + dotest admin-22-o23 "${testcvs} log aaa" " +RCS file: ${CVSROOT_DIRNAME}/first-dir/aaa,v +Working file: aaa +head: 1\.4 +branch: +locks: strict +access list: +symbolic names: + br1: 1\.3\.0\.2 +keyword substitution: kv +total revisions: 5; selected revisions: 5 +description: +---------------------------- +revision 1\.4 +date: ${ISO8601DATE}; author: ${username}; state: Exp; lines: ${PLUS}1 -0; commitid: ${commitid}; +fourth +---------------------------- +revision 1\.3 +date: ${ISO8601DATE}; author: ${username}; state: Exp; lines: ${PLUS}1 -0; commitid: ${commitid}; +branches: 1\.3\.2; +third +---------------------------- +revision 1\.2 +date: ${ISO8601DATE}; author: ${username}; state: Exp; lines: ${PLUS}1 -0; commitid: ${commitid}; +second +---------------------------- +revision 1\.1 +date: ${ISO8601DATE}; author: ${username}; state: Exp; commitid: ${commitid}; +first +---------------------------- +revision 1\.3\.2\.4 +date: ${ISO8601DATE}; author: ${username}; state: Exp; lines: ${PLUS}4 -0; commitid: ${commitid}; +branch-four +=============================================================================" + + dotest admin-22-o24 "${testcvs} -q update -p -r 1.3.2.4 aaa" \ +"first rev +second rev +third rev +new branch rev +second branch rev +third branch rev +fourth branch rev" + + # The bit here about how there is a "tagone" tag pointing to + # a nonexistent revision is documented by rcs. I dunno, I + # wonder whether the "cvs admin -o" should give a warning in + # this case. + dotest admin-23 "${testcvs} -q log file2" " +RCS file: ${CVSROOT_DIRNAME}/first-dir/file2,v +Working file: file2 +head: 1\.2 +branch: +locks: strict +access list: + auth3 + auth2 + foo +symbolic names: + tagone: 1\.1 + br: 1\.1\.0\.2 +keyword substitution: kv +total revisions: 1; selected revisions: 1 +description: +---------------------------- +revision 1\.2 +date: ${ISO8601DATE}; author: ${username}; state: Exp; commitid: ${commitid}; +modify +=============================================================================" + + dotest admin-25 "cat ${CVSROOT_DIRNAME}/first-dir/file1,v" \ +"head 1\.1; +access + foo + auth2; +symbols; +locks; strict; +comment @xx@; + + +1\.1 +date ${RCSDELTADATE}; author ${username}; state Exp; +branches + 1\.1\.2\.1; +next ; +commitid ${commitid}; + +1\.1\.2\.1 +date ${RCSDELTADATE}; author ${username}; state foo; +branches; +next ; +commitid ${commitid}; + + +desc +@@ + + +1\.1 +log +@add +@ +text +@@ + + +1\.1\.2\.1 +log +@modify-on-branch +@ +text +@a0 1 +add a line on the branch +@" + + # Tests of cvs admin -n. Make use of the results of + # admin-1 through admin-25. + # FIXME: We probably shouldn't make use of those results; + # this test is way too long as it is. + + # tagtwo should be a revision + # + dotest admin-26-1 "${testcvs} admin -ntagtwo:tagone file2" \ +"RCS file: ${CVSROOT_DIRNAME}/first-dir/file2,v +done" + + # br1 should be a branch + # + dotest admin-26-2 "${testcvs} admin -nbr1:br file2" \ +"RCS file: ${CVSROOT_DIRNAME}/first-dir/file2,v +done" + + # Attach some tags using RCS versions + # + dotest admin-26-3 "${testcvs} admin -ntagthree:1.1 file2" \ +"RCS file: ${CVSROOT_DIRNAME}/first-dir/file2,v +done" + + dotest admin-26-4 "${testcvs} admin -nbr2:1.1.2 file2" \ +"RCS file: ${CVSROOT_DIRNAME}/first-dir/file2,v +done" + + dotest admin-26-5 "${testcvs} admin -nbr4:1.1.0.2 file2" \ +"RCS file: ${CVSROOT_DIRNAME}/first-dir/file2,v +done" + + # Check results so far + # + dotest admin-26-6 "${testcvs} status -v file2" \ +"=================================================================== +File: file2 Status: Up-to-date + + Working revision: 1\.2.* + Repository revision: 1\.2 ${CVSROOT_DIRNAME}/first-dir/file2,v + Commit Identifier: ${commitid} + Sticky Tag: (none) + Sticky Date: (none) + Sticky Options: (none) + + Existing Tags: + br4 (branch: 1\.1\.2) + br2 (branch: 1\.1\.2) + tagthree (revision: 1\.1) + br1 (branch: 1\.1\.2) + tagtwo (revision: 1\.1) + tagone (revision: 1\.1) + br (branch: 1\.1\.2)" + + + # Add a couple more revisions + # + echo "nuthr_line" >> file2 + dotest admin-27-1 "${testcvs} commit -m nuthr_line file2" \ +"$CVSROOT_DIRNAME/first-dir/file2,v <-- file2 +new revision: 1\.3; previous revision: 1\.2" + + echo "yet_another" >> file2 + dotest admin-27-2 "${testcvs} commit -m yet_another file2" \ +"$CVSROOT_DIRNAME/first-dir/file2,v <-- file2 +new revision: 1\.4; previous revision: 1\.3" + + # Fail trying to reattach existing tag with -n + # + dotest admin-27-3 "${testcvs} admin -ntagfour:1.1 file2" \ +"RCS file: ${CVSROOT_DIRNAME}/first-dir/file2,v +done" + + dotest_fail admin-27-4 "${testcvs} admin -ntagfour:1.3 file2" \ +"RCS file: ${CVSROOT_DIRNAME}/first-dir/file2,v +${SPROG} admin: ${CVSROOT_DIRNAME}/first-dir/file2,v: symbolic name tagfour already bound to 1\.1 +${SPROG} admin: RCS file for .file2. not modified\." + + # Succeed at reattaching existing tag, using -N + # + dotest admin-27-5 "${testcvs} admin -Ntagfour:1.3 file2" \ +"RCS file: ${CVSROOT_DIRNAME}/first-dir/file2,v +done" + + # Fail on some bogus operations + # Try to attach to nonexistant tag + # + dotest_fail admin-28-1 "${testcvs} admin -ntagsix:tagfive file2" \ +"RCS file: ${CVSROOT_DIRNAME}/first-dir/file2,v +${SPROG} admin: ${CVSROOT_DIRNAME}/first-dir/file2,v: Symbolic name or revision tagfive is undefined\. +${SPROG} admin: RCS file for .file2. not modified\." + + # Try a some nonexisting numeric target tags + # + dotest_fail admin-28-2 "${testcvs} admin -ntagseven:2.1 file2" \ +"RCS file: ${CVSROOT_DIRNAME}/first-dir/file2,v +${SPROG} \[admin aborted\]: revision .2\.1. does not exist" + + dotest_fail admin-28-3 "${testcvs} admin -ntageight:2.1.2 file2" \ +"RCS file: ${CVSROOT_DIRNAME}/first-dir/file2,v +${SPROG} \[admin aborted\]: revision .2\.1\.2. does not exist" + + # Try some invalid targets + # + dotest_fail admin-28-4 "${testcvs} admin -ntagnine:1.a.2 file2" \ +"RCS file: ${CVSROOT_DIRNAME}/first-dir/file2,v +${SPROG} \[admin aborted\]: tag .1\.a\.2. must start with a letter" + + # Confirm that a missing tag is not a fatal error. + dotest admin-28-5.1 "${testcvs} -Q tag BO+GUS file1" '' + dotest_fail admin-28-5.2 "${testcvs} admin -ntagten:BO+GUS file2 file1" \ +"RCS file: ${CVSROOT_DIRNAME}/first-dir/file2,v +${SPROG} admin: ${CVSROOT_DIRNAME}/first-dir/file2,v: Symbolic name or revision BO${PLUS}GUS is undefined\. +${SPROG} admin: RCS file for .file2. not modified\. +RCS file: ${CVSROOT_DIRNAME}/first-dir/file1,v +done" + + dotest_fail admin-28-6 "${testcvs} admin -nq.werty:tagfour file2" \ +"RCS file: ${CVSROOT_DIRNAME}/first-dir/file2,v +${SPROG} \[admin aborted\]: tag .q\.werty. must not contain the characters ..*" + + # Verify the archive + # + dotest admin-29 "cat ${CVSROOT_DIRNAME}/first-dir/file2,v" \ +"head 1\.4; +access + auth3 + auth2 + foo; +symbols + tagfour:1\.3 + br4:1\.1\.0\.2 + br2:1\.1\.0\.2 + tagthree:1\.1 + br1:1\.1\.0\.2 + tagtwo:1\.1 + tagone:1\.1 + br:1\.1\.0\.2; +locks; strict; +comment @# @; + + +1\.4 +date ${RCSDELTADATE}; author ${username}; state Exp; +branches; +next 1\.3; +commitid ${commitid}; + +1\.3 +date ${RCSDELTADATE}; author ${username}; state Exp; +branches; +next 1\.2; +commitid ${commitid}; + +1\.2 +date ${RCSDELTADATE}; author ${username}; state Exp; +branches; +next ; +commitid ${commitid}; + + +desc +@@ + + +1\.4 +log +@yet_another +@ +text +@add a line +nuthr_line +yet_another +@ + + +1\.3 +log +@nuthr_line +@ +text +@d3 1 +@ + + +1\.2 +log +@modify +@ +text +@d2 1 +@" + + dotest_fail admin-30 "${testcvs} admin -mbr:another-log-message \ +file2 aaa file3" \ +"RCS file: ${CVSROOT_DIRNAME}/first-dir/file2,v +${SPROG} admin: ${CVSROOT_DIRNAME}/first-dir/file2,v: no such revision br: 1\.1 +${SPROG} admin: RCS file for .file2. not modified. +RCS file: ${CVSROOT_DIRNAME}/first-dir/aaa,v +${SPROG} admin: ${CVSROOT_DIRNAME}/first-dir/aaa,v: no such revision br +${SPROG} admin: RCS file for .aaa. not modified. +RCS file: ${CVSROOT_DIRNAME}/first-dir/Attic/file3,v +done" + dotest admin-31 "${testcvs} log" \ +"${SPROG} log: Logging \. + +RCS file: ${CVSROOT_DIRNAME}/first-dir/aaa,v +Working file: aaa +head: 1\.4 +branch: +locks: strict +access list: +symbolic names: + br1: 1\.3\.0\.2 +keyword substitution: kv +total revisions: 5; selected revisions: 5 +description: +---------------------------- +revision 1\.4 +date: ${ISO8601DATE}; author: ${username}; state: Exp; lines: ${PLUS}1 -0; commitid: ${commitid}; +fourth +---------------------------- +revision 1\.3 +date: ${ISO8601DATE}; author: ${username}; state: Exp; lines: ${PLUS}1 -0; commitid: ${commitid}; +branches: 1\.3\.2; +third +---------------------------- +revision 1\.2 +date: ${ISO8601DATE}; author: ${username}; state: Exp; lines: ${PLUS}1 -0; commitid: ${commitid}; +second +---------------------------- +revision 1\.1 +date: ${ISO8601DATE}; author: ${username}; state: Exp; commitid: ${commitid}; +first +---------------------------- +revision 1\.3\.2\.4 +date: ${ISO8601DATE}; author: ${username}; state: Exp; lines: ${PLUS}4 -0; commitid: ${commitid}; +branch-four +============================================================================= + +RCS file: ${CVSROOT_DIRNAME}/first-dir/file1,v +Working file: file1 +head: 1\.1 +branch: +locks: strict +access list: + foo + auth2 +symbolic names: + tagten: 1\.1 + BO${PLUS}GUS: 1\.1 +keyword substitution: kv +total revisions: 2; selected revisions: 2 +description: +---------------------------- +revision 1\.1 +date: ${ISO8601DATE}; author: ${username}; state: Exp; commitid: ${commitid}; +branches: 1\.1\.2; +add +---------------------------- +revision 1\.1\.2\.1 +date: ${ISO8601DATE}; author: ${username}; state: foo; lines: ${PLUS}1 -0; commitid: ${commitid}; +modify-on-branch +============================================================================= + +RCS file: ${CVSROOT_DIRNAME}/first-dir/file2,v +Working file: file2 +head: 1\.4 +branch: +locks: strict +access list: + auth3 + auth2 + foo +symbolic names: + tagfour: 1\.3 + br4: 1\.1\.0\.2 + br2: 1\.1\.0\.2 + tagthree: 1\.1 + br1: 1\.1\.0\.2 + tagtwo: 1\.1 + tagone: 1\.1 + br: 1\.1\.0\.2 +keyword substitution: kv +total revisions: 3; selected revisions: 3 +description: +---------------------------- +revision 1\.4 +date: ${ISO8601DATE}; author: ${username}; state: Exp; lines: ${PLUS}1 -0; commitid: ${commitid}; +yet_another +---------------------------- +revision 1\.3 +date: ${ISO8601DATE}; author: ${username}; state: Exp; lines: ${PLUS}1 -0; commitid: ${commitid}; +nuthr_line +---------------------------- +revision 1\.2 +date: ${ISO8601DATE}; author: ${username}; state: Exp; commitid: ${commitid}; +modify +============================================================================= + +RCS file: ${CVSROOT_DIRNAME}/first-dir/Attic/file3,v +Working file: file3 +head: 1\.1 +branch: +locks: strict +access list: +symbolic names: + br: 1\.1\.0\.2 +keyword substitution: kv +total revisions: 2; selected revisions: 2 +description: +---------------------------- +revision 1\.1 +date: ${ISO8601DATE}; author: ${username}; state: dead; commitid: ${commitid}; +branches: 1\.1\.2; +file file3 was initially added on branch br\. +---------------------------- +revision 1\.1\.2\.1 +date: ${ISO8601DATE}; author: ${username}; state: Exp; lines: ${PLUS}1 -0; commitid: ${commitid}; +another-log-message +=============================================================================" + + # Currently, this test outputs 36 identical lines, so I am just + # checking $DOTSTAR for brevity. + dotest admin-postadmin-examine-1 "cat $TESTDIR/2/admin-log" \ +"$CVSROOT_DIRNAME first-dir admin$DOTSTAR" + + dokeep + + # clean up our after ourselves + restore_adm + cd ../.. + rm -r 1 2 + modify_repo rm -rf $CVSROOT_DIRNAME/first-dir + ;; + + + + reserved) + # Tests of reserved checkouts. Eventually this will test + # rcslock.pl (or equivalent) and all kinds of stuff. Right + # now it just does some very basic checks on cvs admin -u + # and cvs admin -l. + # Also should test locking on a branch (and making sure that + # locks from one branch don't get mixed up with those from + # another. Both the case where one of the branches is the + # main branch, and in which neither one is). + # See also test keyword, which tests that keywords and -kkvl + # do the right thing in the presence of locks. + + # The usual setup, directory first-dir containing file file1. + mkdir 1; cd 1 + dotest reserved-1 "${testcvs} -q co -l ." '' + mkdir first-dir + dotest reserved-2 "${testcvs} add first-dir" \ +"Directory ${CVSROOT_DIRNAME}/first-dir added to the repository" + cd first-dir + touch file1 + dotest reserved-3 "${testcvs} add file1" \ +"${SPROG} add: scheduling file .file1. for addition +${SPROG} add: use .${SPROG} commit. to add this file permanently" + dotest reserved-4 "${testcvs} -q ci -m add" \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +initial revision: 1\.1" + + dotest reserved-5 "${testcvs} -q admin -l file1" \ +"RCS file: ${CVSROOT_DIRNAME}/first-dir/file1,v +1\.1 locked +done" + dotest reserved-6 "${testcvs} log -N file1" " +RCS file: ${CVSROOT_DIRNAME}/first-dir/file1,v +Working file: file1 +head: 1\.1 +branch: +locks: strict + ${username}: 1\.1 +access list: +keyword substitution: kv +total revisions: 1; selected revisions: 1 +description: +---------------------------- +revision 1\.1 locked by: ${username}; +date: ${ISO8601DATE}; author: ${username}; state: Exp; commitid: ${commitid}; +add +=============================================================================" + + # Note that this just tests the owner of the lock giving + # it up. It doesn't test breaking a lock. + dotest reserved-7 "${testcvs} -q admin -u file1" \ +"RCS file: ${CVSROOT_DIRNAME}/first-dir/file1,v +1\.1 unlocked +done" + + dotest reserved-8 "${testcvs} log -N file1" " +RCS file: ${CVSROOT_DIRNAME}/first-dir/file1,v +Working file: file1 +head: 1\.1 +branch: +locks: strict +access list: +keyword substitution: kv +total revisions: 1; selected revisions: 1 +description: +---------------------------- +revision 1\.1 +date: ${ISO8601DATE}; author: ${username}; state: Exp; commitid: ${commitid}; +add +=============================================================================" + + # rcslock.pl tests. Of course, the point isn't to test + # rcslock.pl from the distribution but equivalent + # functionality (for example, many sites may have an old + # rcslock.pl). The functionality of this hook falls + # short of the real rcslock.pl though. + # Note that we can use rlog or look at the RCS file directly, + # but we can't use "cvs log" because "cvs commit" has a lock. + + cat >${TESTDIR}/lockme <<EOF +#!${TESTSHELL} +line=\`grep <\$1/\$2,v 'locks $anyusername:1\.[0-9];'\` +if test -z "\$line"; then + # It isn't locked + exit 0 +else + user=\`echo \$line | sed -e 's/locks \\($anyusername\\):[0-9.]*;.*/\\1/'\` + version=\`echo \$line | sed -e 's/locks $anyusername:\\([0-9.]*\\);.*/\\1/'\` + echo "\$user has file a-lock locked for version \$version" >&2 + exit 1 +fi +EOF + # Cygwin. Blaaarg. + if test -n "$remotehost"; then + $CVS_RSH $remotehost "chmod +x ${TESTDIR}/lockme" + else + chmod +x ${TESTDIR}/lockme + fi + + echo stuff > a-lock + dotest reserved-9 "${testcvs} add a-lock" \ +"${SPROG} add: scheduling file .a-lock. for addition +${SPROG} add: use .${SPROG} commit. to add this file permanently" + dotest reserved-10 "${testcvs} -q ci -m new a-lock" \ +"$CVSROOT_DIRNAME/first-dir/a-lock,v <-- a-lock +initial revision: 1\.1" + # FIXME: the contents of CVSROOT fluctuate a lot + # here. Maybe the expect pattern should just + # confirm that commitinfo is one of the files checked out, + # but for now we just check that CVS exited with success. + cd .. + if ${testcvs} -q co CVSROOT >>${LOGFILE} ; then + pass reserved-11 + else + fail reserved-11 + fi + cd CVSROOT + echo "DEFAULT ${TESTDIR}/lockme" >>commitinfo + dotest reserved-12 "${testcvs} -q ci -m rcslock commitinfo" \ +"$CVSROOT_DIRNAME/CVSROOT/commitinfo,v <-- commitinfo +new revision: 1\.2; previous revision: 1\.1 +$SPROG commit: Rebuilding administrative file database" + cd ..; cd first-dir + + # Simulate (approximately) what a-lock would look like + # if someone else had locked revision 1.1. + sed -e 's/locks; strict;/locks fred:1.1; strict;/' ${CVSROOT_DIRNAME}/first-dir/a-lock,v > a-lock,v + # Cygwin. + if test -n "$remotehost"; then + $CVS_RSH $remotehost "chmod 644 ${CVSROOT_DIRNAME}/first-dir/a-lock,v" + else + chmod 644 ${CVSROOT_DIRNAME}/first-dir/a-lock,v + fi + dotest reserved-13 "mv a-lock,v ${CVSROOT_DIRNAME}/first-dir/a-lock,v" + # Cygwin. Blah. + if test -n "$remotehost"; then + $CVS_RSH $remotehost "chmod 444 ${CVSROOT_DIRNAME}/first-dir/a-lock,v" + else + chmod 444 ${CVSROOT_DIRNAME}/first-dir/a-lock,v + fi + echo more stuff >> a-lock + dotest_fail_sort reserved-13b "$testcvs ci -m '' a-lock" \ +" \"$TESTDIR/lockme\" +Appending defaults (\" %r/%p %s\"), but please be aware that this usage is +$SPROG \[commit aborted\]: correct above errors first! +$SPROG commit: Pre-commit check failed +$SPROG commit: warning: commitinfo line contains no format strings: +deprecated\. +fred has file a-lock locked for version 1\.1" + # OK, now test "cvs admin -l" in the case where someone + # else has the file locked. + dotest_fail reserved-13c "${testcvs} admin -l a-lock" \ +"RCS file: ${CVSROOT_DIRNAME}/first-dir/a-lock,v +${SPROG} \[admin aborted\]: Revision 1\.1 is already locked by fred" + + dotest reserved-14 "${testcvs} admin -u1.1 a-lock" \ +"RCS file: ${CVSROOT_DIRNAME}/first-dir/a-lock,v +${SPROG} admin: ${CVSROOT_DIRNAME}/first-dir/a-lock,v: revision 1\.1 locked by fred; breaking lock +1\.1 unlocked +done" + dotest reserved-15 "$testcvs -q ci -m success a-lock" \ +"$SPROG commit: warning: commitinfo line contains no format strings: + \"$TESTDIR/lockme\" +Appending defaults (\" %r/%p %s\"), but please be aware that this usage is +deprecated\. +$CVSROOT_DIRNAME/first-dir/a-lock,v <-- a-lock +new revision: 1\.2; previous revision: 1\.1" + + # Now test for a bug involving branches and locks + sed -e 's/locks; strict;/locks fred:1.2; strict;/' ${CVSROOT_DIRNAME}/first-dir/a-lock,v > a-lock,v + chmod 644 ${CVSROOT_DIRNAME}/first-dir/a-lock,v + dotest reserved-16 \ +"mv a-lock,v ${CVSROOT_DIRNAME}/first-dir/a-lock,v" "" + chmod 444 ${CVSROOT_DIRNAME}/first-dir/a-lock,v + dotest reserved-17 "${testcvs} -q tag -b br a-lock" "T a-lock" + dotest reserved-18 "${testcvs} -q update -r br a-lock" "" + echo edit it >>a-lock + dotest reserved-19 "${testcvs} -q ci -m modify a-lock" \ +"$SPROG commit: warning: commitinfo line contains no format strings: + \"$TESTDIR/lockme\" +Appending defaults (\" %r/%p %s\"), but please be aware that this usage is +deprecated\. +$CVSROOT_DIRNAME/first-dir/a-lock,v <-- a-lock +new revision: 1\.2\.2\.1; previous revision: 1\.2" + + # undo commitinfo changes + cd ../CVSROOT + echo '# vanilla commitinfo' >commitinfo + dotest reserved-cleanup-1 "${testcvs} -q ci -m back commitinfo" \ +"$SPROG commit: warning: commitinfo line contains no format strings: + \"$TESTDIR/lockme\" +Appending defaults (\" %r/%p %s\"), but please be aware that this usage is +deprecated\. +$CVSROOT_DIRNAME/CVSROOT/commitinfo,v <-- commitinfo +new revision: 1\.3; previous revision: 1\.2 +$SPROG commit: Rebuilding administrative file database" + + dokeep + cd ..; rm -r CVSROOT + cd .. + rm -r 1 + rm $TESTDIR/lockme + modify_repo rm -rf $CVSROOT_DIRNAME/first-dir + ;; + + + + diffmerge1) + # Make sure CVS can merge correctly in circumstances where it + # used to mess up (due to a bug which existed in diffutils 2.7 + # and 2.6, but not 2.5, and which has been fixed in CVS's diff + # lib by Paul Eggert, bless his bitty heart). + + # This first test involves two working copies, "mine" and + # "yours", checked out from the same repository at the same + # time. In yours, you remove some text from the end of the + # file and check it in; meanwhile, "me" has commented out some + # lines earlier in the file, and I go to check it in right + # after you checked yours in. CVS naturally tells me the file + # is not up-to-date, so I run cvs update, but it updates + # incorrectly, leaving in the lines of text you just deleted. + # Bad! I'm in too much of a hurry to actually look at the + # file, so I check it in and go home, and so your changes have + # been lost. Later you discover this, and you suspect me of + # deliberately sabotaging your work, so you let all the air + # out of my tires. Only after a series of expensive lawsuits + # and countersuits do we discover that this was all CVS's + # fault. + # + # Luckily, this problem has been fixed now, as our test will + # handily confirm, no doubt: + + # First make a repository containing the original text: + + # We should be here anyway, but cd to it just in case: + cd ${TESTDIR} + + mkdir diffmerge1 + cd diffmerge1 + + # These are the files we both start out with: + mkdir import + cd import + diffmerge_create_older_files + + dotest diffmerge1_import \ + "${testcvs} import -m import diffmerge1 tag1 tag2" \ + "${DOTSTAR}No conflicts created by this import" + cd .. + + # Check out two working copies, one for "you" and one for + # "me". If no branch is used and cvs detects that only one + # of the two people made changes, then cvs does not run the + # merge algorithm. But if a branch is used, then cvs does run + # the merge algorithm (even in this case of only one of the two + # people having made changes). CVS used to have a bug in this + # case. Therefore, it is important to test this case by + # using a branch: + ${testcvs} rtag -b tag diffmerge1 >/dev/null 2>&1 + ${testcvs} checkout -r tag diffmerge1 >/dev/null 2>&1 + mv diffmerge1 yours + ${testcvs} checkout diffmerge1 >/dev/null 2>&1 + mv diffmerge1 mine + + # In your working copy, you'll make changes, and + # then check in your changes before I check in mine: + cd yours + diffmerge_create_your_files + dotest diffmerge1_yours "${testcvs} -q ci -m yours" \ +"$CVSROOT_DIRNAME/diffmerge1/testcase01,v <-- testcase01 +new revision: 1\.1\.1\.1\.2\.1; previous revision: 1\.1\.1\.1 +$CVSROOT_DIRNAME/diffmerge1/testcase02,v <-- testcase02 +new revision: 1\.1\.1\.1\.2\.1; previous revision: 1\.1\.1\.1 +$CVSROOT_DIRNAME/diffmerge1/testcase03,v <-- testcase03 +new revision: 1\.1\.1\.1\.2\.1; previous revision: 1\.1\.1\.1 +$CVSROOT_DIRNAME/diffmerge1/testcase04,v <-- testcase04 +new revision: 1\.1\.1\.1\.2\.1; previous revision: 1\.1\.1\.1 +$CVSROOT_DIRNAME/diffmerge1/testcase05,v <-- testcase05 +new revision: 1\.1\.1\.1\.2\.1; previous revision: 1\.1\.1\.1 +$CVSROOT_DIRNAME/diffmerge1/testcase06,v <-- testcase06 +new revision: 1\.1\.1\.1\.2\.1; previous revision: 1\.1\.1\.1 +$CVSROOT_DIRNAME/diffmerge1/testcase07,v <-- testcase07 +new revision: 1\.1\.1\.1\.2\.1; previous revision: 1\.1\.1\.1 +$CVSROOT_DIRNAME/diffmerge1/testcase08,v <-- testcase08 +new revision: 1\.1\.1\.1\.2\.1; previous revision: 1\.1\.1\.1 +$CVSROOT_DIRNAME/diffmerge1/testcase09,v <-- testcase09 +new revision: 1\.1\.1\.1\.2\.1; previous revision: 1\.1\.1\.1 +$CVSROOT_DIRNAME/diffmerge1/testcase10,v <-- testcase10 +new revision: 1\.1\.1\.1\.2\.1; previous revision: 1\.1\.1\.1" + + # Change my copy. Then I + # update, after both my modifications and your checkin: + cd ../mine + diffmerge_create_my_files + dotest diffmerge1_mine "${testcvs} -q update -j tag" \ +"M testcase01 +RCS file: ${CVSROOT_DIRNAME}/diffmerge1/testcase01,v +retrieving revision 1\.1\.1\.1 +retrieving revision 1\.1\.1\.1\.2\.1 +Merging differences between 1\.1\.1\.1 and 1\.1\.1\.1\.2\.1 into testcase01 +M testcase02 +RCS file: ${CVSROOT_DIRNAME}/diffmerge1/testcase02,v +retrieving revision 1\.1\.1\.1 +retrieving revision 1\.1\.1\.1\.2\.1 +Merging differences between 1\.1\.1\.1 and 1\.1\.1\.1\.2\.1 into testcase02 +M testcase03 +RCS file: ${CVSROOT_DIRNAME}/diffmerge1/testcase03,v +retrieving revision 1\.1\.1\.1 +retrieving revision 1\.1\.1\.1\.2\.1 +Merging differences between 1\.1\.1\.1 and 1\.1\.1\.1\.2\.1 into testcase03 +M testcase04 +RCS file: ${CVSROOT_DIRNAME}/diffmerge1/testcase04,v +retrieving revision 1\.1\.1\.1 +retrieving revision 1\.1\.1\.1\.2\.1 +Merging differences between 1\.1\.1\.1 and 1\.1\.1\.1\.2\.1 into testcase04 +RCS file: ${CVSROOT_DIRNAME}/diffmerge1/testcase05,v +retrieving revision 1\.1\.1\.1 +retrieving revision 1\.1\.1\.1\.2\.1 +Merging differences between 1\.1\.1\.1 and 1\.1\.1\.1\.2\.1 into testcase05 +RCS file: ${CVSROOT_DIRNAME}/diffmerge1/testcase06,v +retrieving revision 1\.1\.1\.1 +retrieving revision 1\.1\.1\.1\.2\.1 +Merging differences between 1\.1\.1\.1 and 1\.1\.1\.1\.2\.1 into testcase06 +M testcase07 +RCS file: ${CVSROOT_DIRNAME}/diffmerge1/testcase07,v +retrieving revision 1\.1\.1\.1 +retrieving revision 1\.1\.1\.1\.2\.1 +Merging differences between 1\.1\.1\.1 and 1\.1\.1\.1\.2\.1 into testcase07 +testcase07 already contains the differences between 1\.1\.1\.1 and 1\.1\.1\.1\.2\.1 +M testcase08 +RCS file: ${CVSROOT_DIRNAME}/diffmerge1/testcase08,v +retrieving revision 1\.1\.1\.1 +retrieving revision 1\.1\.1\.1\.2\.1 +Merging differences between 1\.1\.1\.1 and 1\.1\.1\.1\.2\.1 into testcase08 +M testcase09 +RCS file: ${CVSROOT_DIRNAME}/diffmerge1/testcase09,v +retrieving revision 1\.1\.1\.1 +retrieving revision 1\.1\.1\.1\.2\.1 +Merging differences between 1\.1\.1\.1 and 1\.1\.1\.1\.2\.1 into testcase09 +M testcase10 +RCS file: ${CVSROOT_DIRNAME}/diffmerge1/testcase10,v +retrieving revision 1\.1\.1\.1 +retrieving revision 1\.1\.1\.1\.2\.1 +Merging differences between 1\.1\.1\.1 and 1\.1\.1\.1\.2\.1 into testcase10" + + # So if your changes didn't make it into my working copy, or + # in any case if the files do not look like the final text + # in the files in directory comp_me, then the test flunks: + cd .. + mkdir comp_me + cd comp_me + diffmerge_create_expected_files + cd .. + rm mine/.#* + + # If you have GNU's version of diff, you may try + # uncommenting the following line which will give more + # fine-grained information about how cvs differed from the + # correct result: + #dotest diffmerge1_cmp "diff -u --recursive --exclude=CVS comp_me mine" '' + dotest diffmerge1_cmp "directory_cmp comp_me mine" + + # Clean up after ourselves: + dokeep + cd .. + rm -r diffmerge1 + modify_repo rm -rf $CVSROOT_DIRNAME/diffmerge1 + ;; + + + + diffmerge2) + + # FIXME: This test should be rewritten to be much more concise. + # It currently weighs in at something like 600 lines, but the + # same thing could probably be tested in more like 50-100 lines. + mkdir diffmerge2 + + # This tests for another diffmerge bug reported by Martin + # Tomes; actually, his bug was probably caused by an initial + # fix for the bug in test diffmerge1, and likely wasn't ever + # a problem in CVS as long as one was using a normal + # distribution of diff or a version of CVS that has the diff + # lib in it. + # + # Nevertheless, once burned twice cautious, so we test for his + # bug here. + # + # Here is his report, more or less verbatim: + # ------------------------------------------ + # + # Put the attached file (sgrid.h,v) into your repository + # somewhere, check out the module and do this: + # + # cvs update -j Review_Phase_2_Enhancements sgrid.h + # cvs diff -r Review_V1p3 sgrid.h + # + # As there have been no changes made on the trunk there + # should be no differences, however this is output: + # + # % cvs diff -r Review_V1p3 sgrid.h + # Index: sgrid.h + # =================================================================== + # RCS file: /usr/local/repository/play/fred/sgrid.h,v + # retrieving revision 1.1.2.1 + # diff -r1.1.2.1 sgrid.h + # 178a179,184 + # > /*-------------------------------------------------------------- + # > INLINE FUNCTION : HORIZONTALLINES + # > NOTES : Description at the end of the file + # > ----------------------------------------------------------------*/ + # > uint16 horizontalLines( void ); + # > + # + # I did a cvs diff -c -r 1.1 -r 1.1.2.1 sgrid.h and patched those + # differences to sgrid.h version 1.1 and got the correct result + # so it looks like the built in patch is faulty. + # ------------------------------------------------------------------- + # + # This is the RCS file, sgrid.h,v, that he sent: + + echo "head 1.1; +access; +symbols + Review_V1p3:1.1.2.1 + Review_V1p3C:1.1.2.1 + Review_1p3A:1.1.2.1 + Review_V1p3A:1.1.2.1 + Review_Phase_2_Enhancements:1.1.0.2 + Review_V1p2:1.1 + Review_V1p2B:1.1 + Review_V1p2A:1.1 + Review_V1p1:1.1 + Review_1p1:1.1; +locks; strict; +comment @ * @; + + +1.1 +date 97.04.02.11.20.05; author colinl; state Exp; +branches + 1.1.2.1; +next ; + +1.1.2.1 +date 97.06.09.10.00.07; author colinl; state Exp; +branches; +next ; + + +desc +@@ + + +1.1 +log +@Project: DEV1175 +DCN: +Tested By: Colin Law +Reviewed By: +Reason for Change: Initial Revision of all files + +Design Change Details: + +Implications: +@ +text +@/* \$""Header: L:/gpanels/dis/sgrid.h_v 1.1.1.0 24 Jan 1996 14:59:20 PAULT \$ */ +/* + * \$""Log: L:/gpanels/dis/sgrid.h_v \$ + * + * Rev 1.1.1.0 24 Jan 1996 14:59:20 PAULT + * Branched + * + * Rev 1.1 24 Jan 1996 12:09:52 PAULT + * Consolidated 4100 code merged to trunk + * + * Rev 1.0.2.0 01 Jun 1995 14:18:58 DAVEH + * Branched + * + * Rev 1.0 19 Apr 1995 16:32:48 COLINL + * Initial revision. +*/ +/***************************************************************************** +FILE : SGRID.H +VERSION : 2.1 +AUTHOR : Dave Hartley +SYSTEM : Borland C++ +DESCRIPTION : The declaration of the scrolling grid class + +*****************************************************************************/ +#if !defined(__SGRID_H) +#define __SGRID_H + +#if !defined(__SCROLL_H) +#include <scroll.h> +#endif + +#if !defined(__GKI_H) +#include \"gki.h\" +#endif + +#if defined PRINTING_SUPPORT +class Printer; +#endif + +/***************************************************************************** +CLASS : ScrollingGrid +DESCRIPTION: This class inherits from a grid and a scrollable, and + can therefore use all the PUBLIC services provided by these + classes. A description of these can be found in + GRID.H and SCROLL.H. + A scrolling grid is a set of horizontal and vertical lines + that scroll and continually update to provide a complete grid + +*****************************************************************************/ + +class ScrollingGrid : public Scrollable +{ + public: +#if defined _WINDOWS +/*--------------------------------------------------------------------------- +FUNCTION : CONSTRUCTOR +DESCRIPTION : sets up the details of the grid, ready for painting +ARGUMENTS : name : sgColour + - the colour of the grid + sgLineType + - the syle of line + sgHorizontalTotal + - the total number of horizontal grid lines + verticalSpacingMin + - the min distance between the vertical grid lines + on the scrolling axis + currentTimestamp + - timestamp value now + ticksPerSecond + - number of timestamp ticks per second + ticksPerPixel + - number of timestamp ticks per pixel required + +RETURN : None +NOTES : +---------------------------------------------------------------------------*/ + ScrollingGrid( GkiColour sgColour, GkiLineType sgLineType, + uint16 sgHorizontalTotal, + uint16 verticalSpacingMin, uint32 currentTimestamp, + uint16 ticksPerSecond, uint32 ticksPerPixel ); +#else +/*--------------------------------------------------------------------------- +FUNCTION : CONSTRUCTOR +DESCRIPTION : sets up the details of the grid, ready for painting +ARGUMENTS : name : sgColour + - the colour of the grid + sgLineType + - the syle of line + sgHorizontalTotal ( THE MAX NUMBER OF LINES IS 100 ) + - the total number of horizontal grid lines + sgVerticalSpacing + - the distance between the vertical grid lines + on the scrolling axis + +RETURN : None +NOTES : If the caller does not get the total grid lines value, synced + with the overall size of the viewport, the spacing between + grid lines will not be consistent. + +---------------------------------------------------------------------------*/ + ScrollingGrid( GkiColour sgColour, GkiLineType sgLineType + , uint16 sgHorizontalTotal, uint16 sgVerticalSpacing ); +#endif +/*--------------------------------------------------------------------------- +FUNCTION : DESTRUCTOR +DESCRIPTION : tidies it all up +ARGUMENTS : name : + +RETURN : None +NOTES : +---------------------------------------------------------------------------*/ + ~ScrollingGrid( void ); + +/*--------------------------------------------------------------------------- +FUNCTION : ATTACH +DESCRIPTION : This service overloads the base class service, as it does + additional work at the time of attachment. + +ARGUMENTS : name : tDrawingArea + - the scrolled viewport to attach this trend to + +RETURN : None +NOTES : +---------------------------------------------------------------------------*/ + void attach( SViewport *tDrawingArea ); + +#if defined _WINDOWS +/*--------------------------------------------------------------------------- +FUNCTION : calculateVerticalSpacing +DESCRIPTION : determines optimum spacing along time axis +ARGUMENTS : +RETURN : None +NOTES : +---------------------------------------------------------------------------*/ + void calculateVerticalSpacing(); + +/*--------------------------------------------------------------------------- +FUNCTION : gridSpacingTicks +DESCRIPTION : Provides the grid spacing in the time axis in ticks +ARGUMENTS : +RETURN : Number of ticks +NOTES : +---------------------------------------------------------------------------*/ + uint32 gridSpacingTicks(); + +#endif + +/*--------------------------------------------------------------------------- +INLINE FUNCTION : HORIZONTALLINES +NOTES : Description at the end of the file +---------------------------------------------------------------------------*/ + uint16 horizontalLines( void ); + +#if defined _WINDOWS +// In Windows the OnDraw() function replaces paint() +/*--------------------------------------------------------------------------- +FUNCTION : ScrollingGrid OnDraw +DESCRIPTION : Paints the given area of the grid. + Pure virtual +ARGUMENTS : pDC pointer to the device context to use for display + Note that the device context operates in the coords + of the window owning the viewport +RETURN : None +NOTES : +---------------------------------------------------------------------------*/ + virtual void OnDraw( CDC *pDC ); + +#else // not Windows + +/*--------------------------------------------------------------------------- +FUNCTION : PAINT +DESCRIPTION : This extends the standard grid paint method to paint the + viewport relative to its current position. + +ARGUMENTS : name : + +RETURN : None +NOTES : +---------------------------------------------------------------------------*/ + void paint( void ); +#endif + +/*--------------------------------------------------------------------------- +FUNCTION : P A I N T T E X T M A R K E R S +DESCRIPTION : this service allow the text markers to be painted seperatley + from the grid lines + +ARGUMENTS : name : + +RETURN : None +NOTES : +---------------------------------------------------------------------------*/ + void paintTextMarkers(); + +#if defined PRINTING_SUPPORT +/*--------------------------------------------------------------------------- +FUNCTION : P R I N T +DESCRIPTION : This print service prints a grid marker ( being either a + timestamp or a date, IF there is one at the plot position + given + +ARGUMENTS : name : + displayPosition + - Where in the log to look to see if there is an + entry to print + + - printerPtr + the printer to print to + +RETURN : None +NOTES : +---------------------------------------------------------------------------*/ + void print( uint16 currentPrintPos, Printer *printerPtr ); +#endif + +/*--------------------------------------------------------------------------- +FUNCTION : S E T D R I V E D I R E C T I O N +DESCRIPTION : Sets direction for update and scrolling forwards or backwards +ARGUMENTS : direction - required direction +RETURN : None +NOTES : +---------------------------------------------------------------------------*/ + void setDriveDirection( ScrollDirection direction ); + +/*--------------------------------------------------------------------------- +FUNCTION : S E T U P +DESCRIPTION : service that will setup the grid prior to a paint + +ARGUMENTS : name : + - newTimestamp + + + - newTimeBase + the number of ticks that represent a plot point on + the trendgraph. + +RETURN : None +NOTES : +---------------------------------------------------------------------------*/ + void setup( uint32 newTimestamp, uint32 newTimeBase ); + +#if defined PRINTING_SUPPORT +/*--------------------------------------------------------------------------- +FUNCTION : S E T U P F O R P R I N T +DESCRIPTION : This service iis to be called prior to printing. It allows + the grid to prepare its markers ready for the print + commands + +ARGUMENTS : name : + +RETURN : None +NOTES : +---------------------------------------------------------------------------*/ + void setupForPrint(); +#endif + +/*--------------------------------------------------------------------------- +FUNCTION : UPDATE +DESCRIPTION : When this service is called it will calculate what needs to + be painted and fill in the display again. + +ARGUMENTS : name : timeStamp + - the reference time of this update. + +RETURN : None +NOTES : +---------------------------------------------------------------------------*/ + void update( uint32 timeStamp ); + +/*--------------------------------------------------------------------------- +FUNCTION : U P D A T E B U F F E R +DESCRIPTION : When a display update is not required, use this method. It + updates the internal data ready for a call to paint that + will then show the grid in the right position + +ARGUMENTS : name : + +RETURN : None +NOTES : +---------------------------------------------------------------------------*/ + void updateBuffer( void ); + + private: + +/*--------------------------------------------------------------------------- +FUNCTION : M A K E G R I D M A R K E R +DESCRIPTION : service that perpares a string for display. The string will + either be a short date, or short time. this is determined + by the current setting of the dateMarker flag + +ARGUMENTS : name : timestampVal + - the value to convert + + storePtr + - the place to put the string + +RETURN : None +NOTES : +---------------------------------------------------------------------------*/ + void makeGridMarker( uint32 timestampVal, char *storePtr ); + +/*--------------------------------------------------------------------------- +FUNCTION : P A I N T G R I D M A R K E R +DESCRIPTION : given a position will put the string on the display + +ARGUMENTS : name : + yPos + - were it goes on the Y-axis + + gridMarkerPtr + - what it is + +RETURN : None +NOTES : +---------------------------------------------------------------------------*/ + void paintGridMarker( uint16 yPos, char *gridMarkerPtr ); + +#if defined _WINDOWS +/*--------------------------------------------------------------------------- +FUNCTION : PAINTHORIZONTALLINES +DESCRIPTION : responsible for painting the grids horizontal lines +ARGUMENTS : pRectToDraw pointer to rectangle that needs refreshing. + in viewport coords + pDC pointer to device context to use + +RETURN : None +NOTES : +---------------------------------------------------------------------------*/ + void paintHorizontalLines(RectCoords* pRectToDraw, CDC* pDC ); +#else +/*--------------------------------------------------------------------------- +FUNCTION : PAINTHORIZONTALLINES +DESCRIPTION : responsible for painting the grids horizontal lines +ARGUMENTS : name: xStart + - the starting X co-ordinate for the horizontal line + xEnd + - the ending X co-ordinate for the horizontal line + +RETURN : None +NOTES : Remember lines are drawn from origin. The origin in a + horizontal viewport will be the top. +---------------------------------------------------------------------------*/ + void paintHorizontalLines( uint16 xStart, uint16 xEnd ); +#endif + +#if defined _WINDOWS +/*--------------------------------------------------------------------------- +FUNCTION : PAINTVERTICALLINES +DESCRIPTION : responsible for painting the grids vertical lines +ARGUMENTS : pRectToDraw pointer to rectangle that needs refreshing. + in viewport coords + offset offset from rhs that rightmost line would be + drawn if rectangle included whole viewport + pDC pointer to device context to use +RETURN : None +NOTES : +---------------------------------------------------------------------------*/ + void paintVerticalLines( RectCoords* pRectToDraw, uint16 offset, + CDC* pDC ); +#else +/*--------------------------------------------------------------------------- +FUNCTION : PAINTVERTICALLINES +DESCRIPTION : responsible for painting the grids vertical lines +ARGUMENTS : name : yStart + - the starting Y co-ordinate for the vertical line + yEnd + - the ending Y co-ordinate for the vertical line + offset + - a starting point offset that determines at what X + position the first line will be drawn + + +RETURN : None +NOTES : +---------------------------------------------------------------------------*/ + void paintVerticalLines( uint16 yStart, uint16 yEnd, uint16 offset ); +#endif + +#if defined _WINDOWS +/*--------------------------------------------------------------------------- +FUNCTION : PAINTVERTICALLINE +DESCRIPTION : paints one line at the position specified, and length +ARGUMENTS : name : yStart + - the starting point on the y axis for the line + yEnd + - the end point on the y axis for the line + xPosition + - The horizontal offset from the start of the viewport + pDC pointer to device context to use + +RETURN : None +NOTES : There is not an equivalent horizontal method as yet. This + is a seperate method because the service is useful to a + derivation of this class +---------------------------------------------------------------------------*/ + void paintVerticalLine( uint16 yStart, uint16 yEnd + , uint16 xPosition, CDC *pDC ); +#else +/*--------------------------------------------------------------------------- +FUNCTION : PAINTVERTICALLINE +DESCRIPTION : paints one line at the position specified, and length +ARGUMENTS : name : yStart + - the starting point on the y axis for the line + yEnd + - the end point on the y axis for the line + xPosition + - The horizontal offset from the start of the viewport + +RETURN : None +NOTES : There is not an equivalent horizontal method as yet. This + is a seperate method because the service is useful to a + derivation of this class +---------------------------------------------------------------------------*/ + void paintVerticalLine( uint16 yStart, uint16 yEnd + , uint16 xPosition ); +#endif + +/*--------------------------------------------------------------------------- +INLINE FUNCTION : VERTICALSPACING +NOTES : Description at the end of the file +---------------------------------------------------------------------------*/ + uint16 verticalSpacing( void ); + + + // Position in viewport that we are now writing to if going forwards + // Note that if this is greater than viewport length then we have + // just scrolled and value must be adjusted before use. + sint16 forwardsOutputPosition; + + // Position in viewport that we are now writing to if going backwards + // Note that if this is less than zero then we have + // just scrolled and value must be adjusted before use. + sint16 backwardsOutputPosition; + + // position in grid cycle of forwards output position. + // if zero then it is time to output a grid line + sint16 forwardsIntervalCount; + + // position in grid cycle of forwards output position. + // if zero then it is time to output a grid line + sint16 backwardsIntervalCount; + + uint32 lastUpdateTimestamp; + uint32 timeBase; // ticks per pixel + uint16 currentOutputPosition; + uint16 gridTimestampSpacing; + uint16 intervalCount; + uint16 horizontalTotal; + uint16 vSpacing; +#if defined PRINTING_SUPPORT + uint16 numberOfGridMarkersPrinted; +#endif + bool firstTime; // indicates first time through + bool dateMarker; + + GkiLineType lineType; + GkiColour gridColour; + + #if defined _WINDOWS + uint16 ticksPerSec; // number of time ticks per second + uint16 vSpacingMin; // minimum pixels per division along time axis + CPen *pPen; // the pen to use for drawing in windows + #endif + +}; + + +/***************************************************************************** + I N L I N E F U N C T I O N S +*****************************************************************************/ + +/*--------------------------------------------------------------------------- +FUNCTION : HORIZONTALLINES +DESCRIPTION : supplies the number of horizontal lines in the grid +ARGUMENTS : name : + +RETURN : +NOTES : +---------------------------------------------------------------------------*/ +inline uint16 ScrollingGrid::horizontalLines( void ) +{ + return( horizontalTotal ); +} +/*--------------------------------------------------------------------------- +FUNCTION : VERTICALSPACING +DESCRIPTION : returns the distance between adjacent vertical lines +ARGUMENTS : name : + +RETURN : None +NOTES : +---------------------------------------------------------------------------*/ +inline uint16 ScrollingGrid::verticalSpacing( void ) +{ + return( vSpacing ); +} + +#endif +@ + + +1.1.2.1 +log +@DEV1194:DS4 Provision of major and minor grid lines +@ +text +@d1 1 +a1 1 +/* \$""Header: /usr/local/repository/cmnsrc/review/src/sgrid.h,v 1.1 1997/04/02 11:20:05 colinl Exp \$ */ +d3 1 +a3 12 + * \$""Log: sgrid.h,v \$ + * Revision 1.1 1997/04/02 11:20:05 colinl + * Project: DEV1175 + * DCN: + * Tested By: Colin Law + * Reviewed By: + * Reason for Change: Initial Revision of all files + * + * Design Change Details: + * + * Implications: + * +d58 6 +a63 5 +ARGUMENTS : name : majorColour colour for major grid lines + minorColour colour for minor grid lines + sgLineType line type for minor grid lines + yMajorGridLines number of major y lines on grid + yMinorGridLines number of major y lines on grid +d77 2 +a78 3 + ScrollingGrid( GkiColour majorColour, GkiColour minorColour, + GkiLineType sgLineType, + uint16 yMajorGridLines, uint16 yMinorGridLines, +a137 17 +FUNCTION : DrawHorizontalGridLines + +DESCRIPTION : Draws major or minor grid lines +ARGUMENTS : pDC device context + pPen pen to use + numLines total lines required + yLow, yHigh, xLow, xHigh rectangle to draw in + yMax max y value +RETURN : None +NOTES : +---------------------------------------------------------------------------*/ + void DrawHorizontalGridLines( CDC* pDC, CPen* pPen, + uint16 numLines, + uint16 yLow, uint16 yHigh, uint16 xLow, uint16 xHigh, + uint16 yMax ); + +/*--------------------------------------------------------------------------- +d148 6 +d448 1 +a448 2 + uint16 m_yMajorGridLines; + uint16 m_yMinorGridLines; +d456 2 +a457 3 + GkiLineType lineType; // line type for minor grid lines + GkiColour m_majorColour; + GkiColour m_minorColour; +d462 1 +a462 2 + CPen *pMajorPen; // pen to use for drawing major grid lines + CPen *pMinorPen; // pen to use for drawing minor grid lines +d472 12 +@" > diffmerge2/sgrid.h,v + + # We have to put the RCS file in the repository by hand for + # this test: + modify_repo mkdir $CVSROOT_DIRNAME/diffmerge2 + modify_repo cp diffmerge2/sgrid.h,v \ + $CVSROOT_DIRNAME/diffmerge2/sgrid.h,v + rm -rf diffmerge2 + dotest diffmerge2_co \ + "$testcvs co diffmerge2" "${DOTSTAR}U $DOTSTAR" + cd diffmerge2 + dotest diffmerge2_update \ + "${testcvs} update -j Review_Phase_2_Enhancements sgrid.h" \ + "${DOTSTAR}erging ${DOTSTAR}" + # This is the one that counts -- there should be no output: + dotest diffmerge2_diff \ + "${testcvs} diff -r Review_V1p3 sgrid.h" '' + + dokeep + cd .. + rm -rf diffmerge2 + modify_repo rm -rf $CVSROOT_DIRNAME/diffmerge2 + ;; + + + + release) + # Tests of "cvs release", particularly multiple arguments. + # Other CVS release tests: + # info-cleanup-0 for "cvs -n release". + # ignore-193 for the text of the question that cvs release asks. + # Also for interactions with cvsignore. + # basicc: "-d .", global -Q, no arguments (is a noop), + # "cvs release" without -d, multiple arguments. + # dirs-4: repository directory has been deleted. + # modules2-6: multiple arguments. + + # First the usual setup; create a directory first-dir. + mkdir 1; cd 1 + dotest release-1 "${testcvs} -q co -l ." '' + mkdir first-dir + dotest release-2 "${testcvs} add first-dir" \ +"Directory ${CVSROOT_DIRNAME}/first-dir added to the repository" + cd first-dir + mkdir dir1 + dotest release-3 "${testcvs} add dir1" \ +"Directory ${CVSROOT_DIRNAME}/first-dir/dir1 added to the repository" + mkdir dir2 + dotest release-4 "${testcvs} add dir2" \ +"Directory ${CVSROOT_DIRNAME}/first-dir/dir2 added to the repository" + cd dir2 + mkdir dir3 + dotest release-5 "${testcvs} add dir3" \ +"Directory ${CVSROOT_DIRNAME}/first-dir/dir2/dir3 added to the repository" + + cd ../.. + dotest release-6 "${testcvs} release -d first-dir/dir2/dir3 first-dir/dir1" \ +"You have .0. altered files in this repository. +Are you sure you want to release (and delete) directory .first-dir/dir2/dir3.: \ +You have .0. altered files in this repository. +Are you sure you want to release (and delete) directory .first-dir/dir1.: " <<EOF +yes +yes +EOF + dotest_fail release-7 "test -d first-dir/dir1" '' + dotest_fail release-8 "test -d first-dir/dir2/dir3" '' + dotest release-9 "${testcvs} update" \ +"${SPROG} update: Updating \. +${SPROG} update: Updating first-dir +${SPROG} update: Updating first-dir/dir2" + + cd first-dir + mkdir dir1 + dotest release-10 "${testcvs} add dir1" \ +"Directory ${CVSROOT_DIRNAME}/first-dir/dir1 added to the repository" + cd dir2 + mkdir dir3 + dotest release-11 "${testcvs} add dir3" \ +"Directory ${CVSROOT_DIRNAME}/first-dir/dir2/dir3 added to the repository" + + cd ../.. + dotest release-12 "${testcvs} release first-dir/dir2/dir3 first-dir/dir1" \ +"You have .0. altered files in this repository. +Are you sure you want to release directory .first-dir/dir2/dir3.: .. .release. aborted by user choice. +You have .0. altered files in this repository. +Are you sure you want to release directory .first-dir/dir1.: " <<EOF +no +yes +EOF + dotest release-13 "${testcvs} release first-dir/dir2/dir3 first-dir/dir2" \ +"You have .0. altered files in this repository. +Are you sure you want to release directory .first-dir/dir2/dir3.: \ +You have .0. altered files in this repository. +Are you sure you want to release directory .first-dir/dir2.: " <<EOF +yes +yes +EOF + dotest release-14 "test -d first-dir/dir1" '' + dotest release-15 "test -d first-dir/dir2/dir3" '' + + mkdir first-dir/dir1/dir4 + # FIXCVS: There should be a path showing in front of dir below, + # I believe. + dotest release-unrecognized-dir-1 \ +"${testcvs} release -d first-dir/dir1" \ +"${QUESTION} dir4 +You have .0. altered files in this repository. +Are you sure you want to release (and delete) directory \`first-dir/dir1': " <<EOF +yes +EOF + + rm -rf first-dir/dir2 + + dotest release-16 "${testcvs} update" \ +"$SPROG update: Updating \. +$SPROG update: Updating first-dir" + + # Check to make sure release isn't overwriting a + # CVS/Entries file in the current directory (using data + # from the released directory). + + # cvs 1.11 (remote) fails on release-21 (a message about + # chdir into the removed directory), although it seemingly + # unedits and removes the directory correctly. If + # you manually continue, it then fails on release-22 do + # to the messed up CVS/Entries file from release-21. + cd first-dir + mkdir second-dir + dotest release-18 "$testcvs add second-dir" \ +"Directory $CVSROOT_DIRNAME/first-dir/second-dir added to the repository" + + cd second-dir + touch file1 + dotest release-19 "$testcvs -Q add file1" + dotest release-20 '$testcvs -q ci -m add' \ +"$CVSROOT_DIRNAME/first-dir/second-dir/file1,v <-- file1 +initial revision: 1\.1" + dotest release-21 "$testcvs edit file1" + cd .. + dotest release-22 "echo yes | $testcvs release -d second-dir" \ +"You have \[0\] altered files in this repository. +Are you sure you want to release (and delete) directory \`second-dir': " + dotest release-23 "$testcvs -q update -d" "U second-dir/file1" + dotest release-24 "$testcvs edit" + + dokeep + cd ../.. + rm -r 1 + modify_repo rm -rf 1 $CVSROOT_DIRNAME/first-dir + ;; + + + + recase) + # + # Some tests of behavior which broke at one time or another when run + # from case insensitive clients against case sensitive servers. + # + # These tests are namned according to the following convention: + # + # ci Client (sandbox filesystem) case Insensitive + # cs Client (sandbox filesystem) case Sensitive + # si Server (repository filesystem) case Insensitive + # ss Server (repository filesystem) case Sensitive + # + + mkdir 1; cd 1 + + # First, we will expect different results for a few of these tests + # based on whether the repository is on a case sensitive filesystem + # or not and whether the sandbox is on a case sensitive filesystem or + # not, so determine which cases we are dealing with: + echo file >file + echo FiLe >FiLe + if cmp file FiLe >/dev/null; then + client_sensitive=false + else + client_sensitive=: + fi + if test -n "$remotehost"; then + $CVS_RSH $remotehost 'echo file >file' + $CVS_RSH $remotehost 'echo FiLe >FiLe' + if $CVS_RSH $remotehost 'cmp file FiLe >/dev/null'; then + server_sensitive=false + else + server_sensitive=: + fi + else + server_sensitive=$client_sensitive + fi + + # The first test (recase-1 & recase-2) is for a remove of a file then + # a readd in a different case. + modify_repo mkdir $CVSROOT_DIRNAME/first-dir + dotest recase-init-1 "$testcvs -Q co first-dir" + cd first-dir + + echo this file has no content >file + dotest recase-init-2 "$testcvs -Q add file" + dotest recase-init-3 "$testcvs -Q ci -madd" + dotest recase-init-4 "$testcvs -Q tag first" + + # Now remove the file. + dotest recase-init-5 "$testcvs -Q rm -f file" + dotest recase-init-6 "$testcvs -Q ci -mrm" + + # Now the test - readd in a different case. + echo this file needs some content >FiLe + if $server_sensitive; then + dotest recase-1ss "$testcvs add FiLe" \ +"$SPROG add: scheduling file \`FiLe' for addition +$SPROG add: use \`$SPROG commit' to add this file permanently" + dotest recase-2ss "$testcvs -q ci -mrecase" \ +"$CVSROOT_DIRNAME/first-dir/FiLe,v <-- FiLe +initial revision: 1\.1" + else # server insensitive + dotest recase-1si "$testcvs add FiLe" \ +"$SPROG add: Re-adding file \`FiLe' after dead revision 1\.2\. +$SPROG add: use \`$SPROG commit' to add this file permanently" + dotest recase-2si "$testcvs -q ci -mrecase" \ +"$CVSROOT_DIRNAME/first-dir/FiLe,v <-- FiLe +new revision: 1\.3; previous revision: 1\.2" + fi + + # Now verify that a checkout will still work + cd ../.. + mkdir 2; cd 2 + dotest recase-3 "$testcvs -q co first-dir" \ +"U first-dir/FiLe" + + cd first-dir + # Prove that we can still get status and log information on + # conflicting case files (1 in Attic, one in parent). + if $remote; then + if $client_sensitive; then + file=file + fIlE=fIlE + else # client insensitive + # Because FiLe is present on a case insensitive client, it is the + # only one ever found and queried or altered. + file=FiLe + fIlE=FiLe + fi + else # ! $remote + file=file + fIlE=fIlE + fi + if $server_sensitive; then + if $client_sensitive; then + # Client finds Entry only for FiLe. Others returned by server. + dotest recase-4sscs "$testcvs status file" \ +"=================================================================== +File: no file file Status: Up-to-date + + Working revision: No entry for file + Repository revision: 1\.2 $CVSROOT_DIRNAME/first-dir/Attic/file,v + Commit Identifier: ${commitid}" + dotest recase-5sscs "$testcvs log file" \ +" +RCS file: $CVSROOT_DIRNAME/first-dir/Attic/file,v +Working file: file +head: 1\.2 +branch: +locks: strict +access list: +symbolic names: + first: 1\.1 +keyword substitution: kv +total revisions: 2; selected revisions: 2 +description: +---------------------------- +revision 1\.2 +date: ${ISO8601DATE}; author: $username; state: dead; lines: +0 -0; commitid: ${commitid}; +rm +---------------------------- +revision 1\.1 +date: ${ISO8601DATE}; author: $username; state: Exp; commitid: ${commitid}; +add +=============================================================================" + dotest recase-6sscs "$testcvs status FiLe" \ +"=================================================================== +File: FiLe Status: Up-to-date + + Working revision: 1\.1.* + Repository revision: 1\.1 $CVSROOT_DIRNAME/first-dir/FiLe,v + Commit Identifier: ${commitid} + Sticky Tag: (none) + Sticky Date: (none) + Sticky Options: (none)" + dotest recase-7sscs "$testcvs log FiLe" \ +" +RCS file: $CVSROOT_DIRNAME/first-dir/FiLe,v +Working file: FiLe +head: 1\.1 +branch: +locks: strict +access list: +symbolic names: +keyword substitution: kv +total revisions: 1; selected revisions: 1 +description: +---------------------------- +revision 1\.1 +date: ${ISO8601DATE}; author: $username; state: Exp; commitid: ${commitid}; +recase +=============================================================================" + else # server sensitive && client insensitive + # Client finds same Entry for file & FiLe. + dotest recase-4ssci "$testcvs status file" \ +"=================================================================== +File: FiLe Status: Up-to-date + + Working revision: 1\.1.* + Repository revision: 1\.1 $CVSROOT_DIRNAME/first-dir/FiLe,v + Commit Identifier: ${commitid} + Sticky Tag: (none) + Sticky Date: (none) + Sticky Options: (none)" + dotest recase-5ssci "$testcvs log file" \ +" +RCS file: $CVSROOT_DIRNAME/first-dir/FiLe,v +Working file: FiLe +head: 1\.1 +branch: +locks: strict +access list: +symbolic names: +keyword substitution: kv +total revisions: 1; selected revisions: 1 +description: +---------------------------- +revision 1\.1 +date: ${ISO8601DATE}; author: $username; state: Exp; commitid: ${commitid}; +recase +=============================================================================" + dotest recase-6ss "$testcvs status FiLe" \ +"=================================================================== +File: FiLe Status: Up-to-date + + Working revision: 1\.1.* + Repository revision: 1\.1 $CVSROOT_DIRNAME/first-dir/FiLe,v + Commit Identifier: ${commitid} + Sticky Tag: (none) + Sticky Date: (none) + Sticky Options: (none)" + dotest recase-7ss "$testcvs log FiLe" \ +" +RCS file: $CVSROOT_DIRNAME/first-dir/FiLe,v +Working file: FiLe +head: 1\.1 +branch: +locks: strict +access list: +symbolic names: +keyword substitution: kv +total revisions: 1; selected revisions: 1 +description: +---------------------------- +revision 1\.1 +date: ${ISO8601DATE}; author: $username; state: Exp; commitid: ${commitid}; +recase +=============================================================================" + fi + else # server insensitive + # There is only one archive when the server is insensitive, but the + # printed file/archive name can vary. + dotest recase-4si "$testcvs status file" \ +"=================================================================== +File: $file Status: Up-to-date + + Working revision: 1\.3.* + Repository revision: 1\.3 $CVSROOT_DIRNAME/first-dir/$file,v + Commit Identifier: ${commitid} + Sticky Tag: (none) + Sticky Date: (none) + Sticky Options: (none)" + dotest recase-5si "$testcvs log file" \ +" +RCS file: $CVSROOT_DIRNAME/first-dir/$file,v +Working file: $file +head: 1\.3 +branch: +locks: strict +access list: +symbolic names: + first: 1\.1 +keyword substitution: kv +total revisions: 3; selected revisions: 3 +description: +---------------------------- +revision 1\.3 +date: ${ISO8601DATE}; author: $username; state: Exp; lines: +1 -1; commitid: ${commitid}; +recase +---------------------------- +revision 1\.2 +date: ${ISO8601DATE}; author: $username; state: dead; lines: +0 -0; commitid: ${commitid}; +rm +---------------------------- +revision 1\.1 +date: ${ISO8601DATE}; author: $username; state: Exp; commitid: ${commitid}; +add +=============================================================================" + dotest recase-6si "$testcvs status FiLe" \ +"=================================================================== +File: FiLe Status: Up-to-date + + Working revision: 1\.3.* + Repository revision: 1\.3 $CVSROOT_DIRNAME/first-dir/FiLe,v + Commit Identifier: ${commitid} + Sticky Tag: (none) + Sticky Date: (none) + Sticky Options: (none)" + dotest recase-7si "$testcvs log FiLe" \ +" +RCS file: $CVSROOT_DIRNAME/first-dir/FiLe,v +Working file: FiLe +head: 1\.3 +branch: +locks: strict +access list: +symbolic names: + first: 1\.1 +keyword substitution: kv +total revisions: 3; selected revisions: 3 +description: +---------------------------- +revision 1\.3 +date: ${ISO8601DATE}; author: $username; state: Exp; lines: +1 -1; commitid: ${commitid}; +recase +---------------------------- +revision 1\.2 +date: ${ISO8601DATE}; author: $username; state: dead; lines: +0 -0; commitid: ${commitid}; +rm +---------------------------- +revision 1\.1 +date: ${ISO8601DATE}; author: $username; state: Exp; commitid: ${commitid}; +add +=============================================================================" + fi + + # And when the file does not exist on the client, we go with the + # client Entries match. + if $client_sensitive && $server_sensitive; then + dotest recase-8sscs "$testcvs status fIlE" \ +"$SPROG status: nothing known about \`fIlE' +=================================================================== +File: no file fIlE Status: Unknown + + Working revision: No entry for fIlE + Repository revision: No revision control file" + else # !$client_sensitive || !$server_sensitive + dotest recase-8anyi "$testcvs status fIlE" \ +"=================================================================== +File: $fIlE Status: Up-to-date + + Working revision: 1\.[0-9]*.* + Repository revision: 1\.[0-9]* $CVSROOT_DIRNAME/first-dir/$fIlE,v + Commit Identifier: ${commitid} + Sticky Tag: (none) + Sticky Date: (none) + Sticky Options: (none)" + fi + + # and an update + if $server_sensitive; then + dotest recase-9ss "$testcvs -q up -rfirst" \ +"$SPROG update: \`FiLe' is no longer in the repository +U file" + + if $client_sensitive; then + dotest recase-10sscs "$testcvs -q up -A" \ +"U FiLe +$SPROG update: \`file' is no longer in the repository" + else # client insensitive + # FIXCVS: This should remove the offending file first. + dotest_fail recase-10ssci "$testcvs -q up -A" \ +"$SPROG update: move away \`\./FiLe'; it is in the way +C FiLe +$SPROG update: \`file' is no longer in the repository" + + cd .. + rm -r first-dir + dotest recase-11ssci "$testcvs -q co first-dir" \ +"U first-dir/FiLe" + cd first-dir + fi + + # + # See what happens when cased names clash. + # + + # Copy the archive + if test -n "$remotehost"; then + modify_repo $CVS_RSH $remotehost \ + "cp $CVSROOT_DIRNAME/first-dir/FiLe,v \ + $CVSROOT_DIRNAME/first-dir/FILE,v" + else + modify_repo cp $CVSROOT_DIRNAME/first-dir/FiLe,v \ + $CVSROOT_DIRNAME/first-dir/FILE,v + fi + + if $client_sensitive; then + dotest recase-12sscs "$testcvs -q up" "U FILE" + else # client insensitive + dotest_fail recase-12ssci "$testcvs -q up" \ +"$SPROG update: move away \`\./FILE'; it is in the way +C FILE" + fi + else # server insensitive + dotest recase-9si "$testcvs -q up -rfirst" "U FiLe" + dotest recase-10si "$testcvs -q up -A" "U FiLe" + fi + + # Prove that we can still get status and log information on + # conflicting case files (1 in Attic, two in parent). + if $server_sensitive; then + if $client_sensitive; then + # Client finds Entry only for FiLe. Others returned by server. + dotest recase-13sscs "$testcvs status file" \ +"=================================================================== +File: no file file Status: Up-to-date + + Working revision: No entry for file + Repository revision: 1\.2 $CVSROOT_DIRNAME/first-dir/Attic/file,v + Commit Identifier: ${commitid}" + dotest recase-14sscs "$testcvs log file" \ +" +RCS file: $CVSROOT_DIRNAME/first-dir/Attic/file,v +Working file: file +head: 1\.2 +branch: +locks: strict +access list: +symbolic names: + first: 1\.1 +keyword substitution: kv +total revisions: 2; selected revisions: 2 +description: +---------------------------- +revision 1\.2 +date: ${ISO8601DATE}; author: $username; state: dead; lines: +0 -0; commitid: ${commitid}; +rm +---------------------------- +revision 1\.1 +date: ${ISO8601DATE}; author: $username; state: Exp; commitid: ${commitid}; +add +=============================================================================" + dotest recase-15sscs "$testcvs status FiLe" \ +"=================================================================== +File: FiLe Status: Up-to-date + + Working revision: 1\.1.* + Repository revision: 1\.1 $CVSROOT_DIRNAME/first-dir/FiLe,v + Commit Identifier: ${commitid} + Sticky Tag: (none) + Sticky Date: (none) + Sticky Options: (none)" + dotest recase-16sscs "$testcvs log FiLe" \ +" +RCS file: $CVSROOT_DIRNAME/first-dir/FiLe,v +Working file: FiLe +head: 1\.1 +branch: +locks: strict +access list: +symbolic names: +keyword substitution: kv +total revisions: 1; selected revisions: 1 +description: +---------------------------- +revision 1\.1 +date: ${ISO8601DATE}; author: $username; state: Exp; commitid: ${commitid}; +recase +=============================================================================" + dotest recase-17sscs "$testcvs status FILE" \ +"=================================================================== +File: FILE Status: Up-to-date + + Working revision: 1.1.* + Repository revision: 1.1 ${CVSROOT_DIRNAME}/first-dir/FILE,v + Commit Identifier: ${commitid} + Sticky Tag: (none) + Sticky Date: (none) + Sticky Options: (none)" + dotest recase-18sscs "$testcvs log FILE" \ +" +RCS file: $CVSROOT_DIRNAME/first-dir/FILE,v +Working file: FILE +head: 1\.1 +branch: +locks: strict +access list: +symbolic names: +keyword substitution: kv +total revisions: 1; selected revisions: 1 +description: +---------------------------- +revision 1\.1 +date: ${ISO8601DATE}; author: $username; state: Exp; commitid: ${commitid}; +recase +=============================================================================" + else # $server_sensitive && !$client_sensitive + # Client finds same Entry for file & FiLe. + dotest recase-13ssci "$testcvs status file" \ +"=================================================================== +File: FiLe Status: Up-to-date + + Working revision: 1\.1.* + Repository revision: 1\.1 $CVSROOT_DIRNAME/first-dir/FiLe,v + Commit Identifier: ${commitid} + Sticky Tag: (none) + Sticky Date: (none) + Sticky Options: (none)" + dotest recase-16ssci "$testcvs log FiLe" \ +" +RCS file: $CVSROOT_DIRNAME/first-dir/FiLe,v +Working file: FiLe +head: 1\.1 +branch: +locks: strict +access list: +symbolic names: +keyword substitution: kv +total revisions: 1; selected revisions: 1 +description: +---------------------------- +revision 1\.1 +date: ${ISO8601DATE}; author: $username; state: Exp; commitid: ${commitid}; +recase +=============================================================================" + dotest recase-17ssci "$testcvs status FILE" \ +"=================================================================== +File: FiLe Status: Up-to-date + + Working revision: 1\.1.* + Repository revision: 1\.1 $CVSROOT_DIRNAME/first-dir/FiLe,v + Commit Identifier: ${commitid} + Sticky Tag: (none) + Sticky Date: (none) + Sticky Options: (none)" + dotest recase-18ssci "$testcvs log FILE" \ +" +RCS file: $CVSROOT_DIRNAME/first-dir/FiLe,v +Working file: FiLe +head: 1\.1 +branch: +locks: strict +access list: +symbolic names: +keyword substitution: kv +total revisions: 1; selected revisions: 1 +description: +---------------------------- +revision 1\.1 +date: ${ISO8601DATE}; author: $username; state: Exp; commitid: ${commitid}; +recase +=============================================================================" + fi + else # !$server_sensitive + # Skip these when the server is case insensitive - nothing + # has changed since recase-[4-7]si + : + fi + + if $client_sensitive && $server_sensitive; then + dotest recase-19sscs "$testcvs status fIlE" \ +"$SPROG status: nothing known about \`fIlE' +=================================================================== +File: no file fIlE Status: Unknown + + Working revision: No entry for fIlE + Repository revision: No revision control file" + else # !$client_sensitive || !$server_sensitive + dotest recase-19anyi "$testcvs status fIlE" \ +"=================================================================== +File: $fIlE Status: Up-to-date + + Working revision: 1\.[0-9]*.* + Repository revision: 1\.[0-9]* $CVSROOT_DIRNAME/first-dir/$fIlE,v + Commit Identifier: ${commitid} + Sticky Tag: (none) + Sticky Date: (none) + Sticky Options: (none)" + fi + + # And last but not least, prove that a checkout is still possible. + cd ../.. + mkdir 3; cd 3 + if $server_sensitive; then + if $client_sensitive; then + dotest recase-20sscs "$testcvs -q co first-dir" \ +"U first-dir/FILE +U first-dir/FiLe" + else # $server_senstive && !$client_sensitive + dotest_fail recase-20ssci "$testcvs -q co first-dir" \ +"U first-dir/FILE +$SPROG checkout: move away \`first-dir/FiLe'; it is in the way +C first-dir/FiLe" + fi + else # !$server_sensitive + # Skip these since nothing has changed. + : + fi + + dokeep + cd .. + rm -r 1 2 3 + if $server_sensitive && test -n "$remotehost"; then + # It is necessary to remove one of the case-conflicted files before + # recursively removing the rest under Cygwin on a Samba share or + # Samba returns a permission denied error due to its case + # confusion. + $CVS_RSH $remotehost "rm -f $CVSROOT_DIRNAME/first-dir/FILE,v" + fi + modify_repo rm -rf $CVSROOT_DIRNAME/first-dir + ;; + + + + multiroot) + # + # set up two repositories + # + + if $proxy; then + # don't even try + continue + fi + + CVSROOT1_DIRNAME=${TESTDIR}/root.1 + CVSROOT2_DIRNAME=${TESTDIR}/root.2 + CVSROOT1=`newroot $CVSROOT1_DIRNAME` + CVSROOT2=`newroot $CVSROOT2_DIRNAME` + testcvs1="$testcvs -d '$CVSROOT1'" + testcvs2="$testcvs -d '$CVSROOT2'" + + dotest multiroot-setup-1 "mkdir $CVSROOT1_DIRNAME $CVSROOT2_DIRNAME" + dotest multiroot-setup-2 "$testcvs1 init" + dotest multiroot-setup-3 "$testcvs2 init" + + # + # create some directories in ${CVSROOT1_DIRNAME} + # + mkdir 1; cd 1 + dotest multiroot-setup-4 "${testcvs1} co -l ." "${SPROG} checkout: Updating ." + mkdir mod1-1 mod1-2 + dotest multiroot-setup-5 "${testcvs1} add mod1-1 mod1-2" \ +"Directory ${CVSROOT1_DIRNAME}/mod1-1 added to the repository +Directory ${CVSROOT1_DIRNAME}/mod1-2 added to the repository" + echo file1-1 > mod1-1/file1-1 + echo file1-2 > mod1-2/file1-2 + dotest multiroot-setup-6 "${testcvs1} add mod1-1/file1-1 mod1-2/file1-2" \ +"${SPROG} add: scheduling file .mod1-1/file1-1. for addition +${SPROG} add: scheduling file .mod1-2/file1-2. for addition +${SPROG} add: use \`${SPROG} commit' to add these files permanently" + dotest multiroot-setup-7 "${testcvs1} commit -m is" \ +"${CPROG} commit: Examining \. +${CPROG} commit: Examining mod1-1 +${CPROG} commit: Examining mod1-2 +${CVSROOT1_DIRNAME}/mod1-1/file1-1,v <-- mod1-1/file1-1 +initial revision: 1.1 +${CVSROOT1_DIRNAME}/mod1-2/file1-2,v <-- mod1-2/file1-2 +initial revision: 1.1" + cd .. + rm -rf 1 + + # + # create some directories in ${CVSROOT2_DIRNAME} + # + mkdir 1; cd 1 + dotest multiroot-setup-8 "${testcvs2} co -l ." "${SPROG} checkout: Updating ." + mkdir mod2-1 mod2-2 + dotest multiroot-setup-9 "${testcvs2} add mod2-1 mod2-2" \ +"Directory ${CVSROOT2_DIRNAME}/mod2-1 added to the repository +Directory ${CVSROOT2_DIRNAME}/mod2-2 added to the repository" + echo file2-1 > mod2-1/file2-1 + echo file2-2 > mod2-2/file2-2 + dotest multiroot-setup-6 "${testcvs2} add mod2-1/file2-1 mod2-2/file2-2" \ +"${SPROG} add: scheduling file .mod2-1/file2-1. for addition +${SPROG} add: scheduling file .mod2-2/file2-2. for addition +${SPROG} add: use \`${SPROG} commit' to add these files permanently" + dotest multiroot-setup-10 "${testcvs2} commit -m anyone" \ +"${CPROG} commit: Examining \. +${CPROG} commit: Examining mod2-1 +${CPROG} commit: Examining mod2-2 +${CVSROOT2_DIRNAME}/mod2-1/file2-1,v <-- mod2-1/file2-1 +initial revision: 1.1 +${CVSROOT2_DIRNAME}/mod2-2/file2-2,v <-- mod2-2/file2-2 +initial revision: 1.1" + cd .. + rm -rf 1 + + # check out a few directories, from simple/shallow to + # complex/deep + mkdir 1; cd 1 + + # OK, this case is kind of weird. If we just run things from + # here, without CVS/Root, then CVS will contact the server + # mentioned in CVSROOT (which is irrelevant) which will print + # some messages. Our workaround is to make sure we have a + # CVS/Root file at top level. In the future, it is possible + # the best behavior will be to extend the existing behavior + # ("being called from a directory without CVS administration + # has always meant to process each of the sub-dirs") to also + # do that if there is no CVSROOT, CVS/Root, or -d at top level. + # + # The local case could stumble through the tests without creating + # the top-level CVS/Root, but we create it for local and for + # remote to reduce special cases later in the test. + dotest multiroot-workaround "${testcvs1} -q co -l ." "" + + dotest multiroot-setup-11 "${testcvs1} co mod1-1 mod1-2" \ +"${SPROG} checkout: Updating mod1-1 +U mod1-1/file1-1 +${SPROG} checkout: Updating mod1-2 +U mod1-2/file1-2" + dotest multiroot-setup-12 "${testcvs2} co mod2-1 mod2-2" \ +"${SPROG} checkout: Updating mod2-1 +U mod2-1/file2-1 +${SPROG} checkout: Updating mod2-2 +U mod2-2/file2-2" + cd mod1-2 + dotest multiroot-setup-13 "${testcvs2} co mod2-2" \ +"${SPROG} checkout: Updating mod2-2 +U mod2-2/file2-2" + cd .. + cd mod2-2 + dotest multiroot-setup-14 "${testcvs1} co mod1-2" \ +"${SPROG} checkout: Updating mod1-2 +U mod1-2/file1-2" + cd .. + + # + # Make sure that the Root and Repository files contain the + # correct information. + # + dotest multiroot-cvsadm-1a "cat mod1-1/CVS/Root" "${CVSROOT1}" + dotest multiroot-cvsadm-1b "cat mod1-1/CVS/Repository" "mod1-1" + dotest multiroot-cvsadm-2a "cat mod2-1/CVS/Root" "${CVSROOT2}" + dotest multiroot-cvsadm-2b "cat mod2-1/CVS/Repository" "mod2-1" + dotest multiroot-cvsadm-3a "cat mod1-2/CVS/Root" "${CVSROOT1}" + dotest multiroot-cvsadm-3b "cat mod1-2/CVS/Repository" "mod1-2" + dotest multiroot-cvsadm-3c "cat mod1-2/mod2-2/CVS/Root" "${CVSROOT2}" + dotest multiroot-cvsadm-3d "cat mod1-2/mod2-2/CVS/Repository" "mod2-2" + dotest multiroot-cvsadm-4a "cat mod2-2/CVS/Root" "${CVSROOT2}" + dotest multiroot-cvsadm-4b "cat mod2-2/CVS/Repository" "mod2-2" + dotest multiroot-cvsadm-4c "cat mod2-2/mod1-2/CVS/Root" "${CVSROOT1}" + dotest multiroot-cvsadm-4d "cat mod2-2/mod1-2/CVS/Repository" "mod1-2" + + # + # Start testing various cvs commands. Begin with commands + # without extra arguments (e.g. "cvs update", "cvs diff", + # etc. + # + + # Do at least one command with both CVSROOTs to make sure + # that there's not some kind of unexpected dependency on the + # choice of which CVSROOT is specified on the command line. + + dotest multiroot-update-1a "${testcvs1} update" \ +"${SPROG} update: Updating \. +${SPROG} update: Updating mod1-1 +${SPROG} update: Updating mod1-2 +${SPROG} update: Updating mod1-2/mod2-2 +${SPROG} update: cannot open directory ${CVSROOT1_DIRNAME}/mod2-2: No such file or directory +${SPROG} update: skipping directory mod1-2/mod2-2 +${SPROG} update: Updating mod2-1 +${SPROG} update: cannot open directory ${CVSROOT1_DIRNAME}/mod2-1: No such file or directory +${SPROG} update: skipping directory mod2-1 +${SPROG} update: Updating mod2-2 +${SPROG} update: cannot open directory ${CVSROOT1_DIRNAME}/mod2-2: No such file or directory +${SPROG} update: skipping directory mod2-2" + + # Same deal but with -d ${CVSROOT2}. + dotest multiroot-update-1b "${testcvs2} update" \ +"${SPROG} update: Updating \. +${SPROG} update: Updating mod1-1 +${SPROG} update: cannot open directory ${CVSROOT2_DIRNAME}/mod1-1: No such file or directory +${SPROG} update: skipping directory mod1-1 +${SPROG} update: Updating mod1-2 +${SPROG} update: cannot open directory ${CVSROOT2_DIRNAME}/mod1-2: No such file or directory +${SPROG} update: skipping directory mod1-2 +${SPROG} update: Updating mod2-1 +${SPROG} update: Updating mod2-2 +${SPROG} update: Updating mod2-2/mod1-2 +${SPROG} update: cannot open directory ${CVSROOT2_DIRNAME}/mod1-2: No such file or directory +${SPROG} update: skipping directory mod2-2/mod1-2" + + # modify all files and do a diff + + echo bobby >> mod1-1/file1-1 + echo brown >> mod1-2/file1-2 + echo goes >> mod2-1/file2-1 + echo down >> mod2-2/file2-2 + + dotest_fail multiroot-diff-1 "${testcvs} diff" \ +"${SPROG} diff: Diffing \. +${SPROG} diff: Diffing mod1-1 +Index: mod1-1/file1-1 +=================================================================== +RCS file: ${CVSROOT1_DIRNAME}/mod1-1/file1-1,v +retrieving revision 1\.1 +diff -r1\.1 file1-1 +1a2 +> bobby +${SPROG} diff: Diffing mod1-2 +Index: mod1-2/file1-2 +=================================================================== +RCS file: ${CVSROOT1_DIRNAME}/mod1-2/file1-2,v +retrieving revision 1\.1 +diff -r1\.1 file1-2 +1a2 +> brown +${SPROG} diff: Diffing mod2-2/mod1-2 +${SPROG} diff: Diffing mod1-2/mod2-2 +${SPROG} diff: Diffing mod2-1 +Index: mod2-1/file2-1 +=================================================================== +RCS file: ${CVSROOT2_DIRNAME}/mod2-1/file2-1,v +retrieving revision 1\.1 +diff -r1\.1 file2-1 +1a2 +> goes +${SPROG} diff: Diffing mod2-2 +Index: mod2-2/file2-2 +=================================================================== +RCS file: ${CVSROOT2_DIRNAME}/mod2-2/file2-2,v +retrieving revision 1\.1 +diff -r1\.1 file2-2 +1a2 +> down" \ +"${SPROG} diff: Diffing \. +${SPROG} diff: Diffing mod1-1 +Index: mod1-1/file1-1 +=================================================================== +RCS file: ${CVSROOT1_DIRNAME}/mod1-1/file1-1,v +retrieving revision 1\.1 +diff -r1\.1 file1-1 +1a2 +> bobby +${SPROG} diff: Diffing mod1-2 +Index: mod1-2/file1-2 +=================================================================== +RCS file: ${CVSROOT1_DIRNAME}/mod1-2/file1-2,v +retrieving revision 1\.1 +diff -r1\.1 file1-2 +1a2 +> brown +${SPROG} diff: Diffing mod2-2 +${SPROG} diff: Diffing mod2-2/mod1-2 +${SPROG} diff: Diffing mod1-2 +${SPROG} diff: Diffing mod1-2/mod2-2 +${SPROG} diff: Diffing mod2-1 +Index: mod2-1/file2-1 +=================================================================== +RCS file: ${CVSROOT2_DIRNAME}/mod2-1/file2-1,v +retrieving revision 1\.1 +diff -r1\.1 file2-1 +1a2 +> goes +${SPROG} diff: Diffing mod2-2 +Index: mod2-2/file2-2 +=================================================================== +RCS file: ${CVSROOT2_DIRNAME}/mod2-2/file2-2,v +retrieving revision 1\.1 +diff -r1\.1 file2-2 +1a2 +> down" + + dotest multiroot-commit-1 "${testcvs} commit -m actually" \ +"${CPROG} commit: Examining \. +${CPROG} commit: Examining mod1-1 +${CPROG} commit: Examining mod1-2 +${CPROG} commit: Examining mod2-2/mod1-2 +${CVSROOT1_DIRNAME}/mod1-1/file1-1,v <-- mod1-1/file1-1 +new revision: 1.2; previous revision: 1.1 +${CVSROOT1_DIRNAME}/mod1-2/file1-2,v <-- mod1-2/file1-2 +new revision: 1.2; previous revision: 1.1 +${CPROG} commit: Examining mod1-2/mod2-2 +${CPROG} commit: Examining mod2-1 +${CPROG} commit: Examining mod2-2 +${CVSROOT2_DIRNAME}/mod2-1/file2-1,v <-- mod2-1/file2-1 +new revision: 1.2; previous revision: 1.1 +${CVSROOT2_DIRNAME}/mod2-2/file2-2,v <-- mod2-2/file2-2 +new revision: 1.2; previous revision: 1.1" + + dotest multiroot-update-2 "${testcvs} update" \ +"${CPROG} update: Updating \. +${CPROG} update: Updating mod1-1 +${CPROG} update: Updating mod1-2 +${CPROG} update: Updating mod2-2/mod1-2 +U mod2-2/mod1-2/file1-2 +${CPROG} update: Updating mod1-2/mod2-2 +U mod1-2/mod2-2/file2-2 +${CPROG} update: Updating mod2-1 +${CPROG} update: Updating mod2-2" \ +"${SPROG} update: Updating \. +${SPROG} update: Updating mod1-1 +${SPROG} update: Updating mod1-2 +${SPROG} update: Updating mod2-2 +${SPROG} update: Updating mod2-2/mod1-2 +P mod2-2/mod1-2/file1-2 +${SPROG} update: Updating mod1-2 +${SPROG} update: Updating mod1-2/mod2-2 +P mod1-2/mod2-2/file2-2 +${SPROG} update: Updating mod2-1 +${SPROG} update: Updating mod2-2" + + dotest multiroot-tag-1 "${testcvs} tag cattle" \ +"${SPROG} tag: Tagging \. +${SPROG} tag: Tagging mod1-1 +T mod1-1/file1-1 +${SPROG} tag: Tagging mod1-2 +T mod1-2/file1-2 +${SPROG} tag: Tagging mod2-2/mod1-2 +${SPROG} tag: Tagging mod1-2/mod2-2 +T mod1-2/mod2-2/file2-2 +${SPROG} tag: Tagging mod2-1 +T mod2-1/file2-1 +${SPROG} tag: Tagging mod2-2" \ +"${SPROG} tag: Tagging \. +${SPROG} tag: Tagging mod1-1 +T mod1-1/file1-1 +${SPROG} tag: Tagging mod1-2 +T mod1-2/file1-2 +${SPROG} tag: Tagging mod2-2 +${SPROG} tag: Tagging mod2-2/mod1-2 +${SPROG} tag: Tagging mod1-2 +${SPROG} tag: Tagging mod1-2/mod2-2 +T mod1-2/mod2-2/file2-2 +${SPROG} tag: Tagging mod2-1 +T mod2-1/file2-1 +${SPROG} tag: Tagging mod2-2" + + echo anotherfile1-1 > mod1-1/anotherfile1-1 + echo anotherfile2-1 > mod2-1/anotherfile2-1 + echo anotherfile1-2 > mod2-2/mod1-2/anotherfile1-2 + echo anotherfile2-2 > mod1-2/mod2-2/anotherfile2-2 + + if $remote; then + cd mod1-1 + dotest multiroot-add-1ar "${testcvs} add anotherfile1-1" \ +"${SPROG} add: scheduling file .anotherfile1-1. for addition +${SPROG} add: use .${SPROG} commit. to add this file permanently" + cd ../mod2-1 + dotest multiroot-add-1br "${testcvs} add anotherfile2-1" \ +"${SPROG} add: scheduling file .anotherfile2-1. for addition +${SPROG} add: use .${SPROG} commit. to add this file permanently" + cd ../mod2-2/mod1-2 + dotest multiroot-add-1cr "${testcvs} add anotherfile1-2" \ +"${SPROG} add: scheduling file .anotherfile1-2. for addition +${SPROG} add: use .${SPROG} commit. to add this file permanently" + cd ../../mod1-2/mod2-2 + dotest multiroot-add-1dr "${testcvs} add anotherfile2-2" \ +"${SPROG} add: scheduling file .anotherfile2-2. for addition +${SPROG} add: use .${SPROG} commit. to add this file permanently" + cd ../.. + else + dotest multiroot-add-1 "${testcvs} add mod1-1/anotherfile1-1 mod2-1/anotherfile2-1 mod2-2/mod1-2/anotherfile1-2 mod1-2/mod2-2/anotherfile2-2" \ +"${SPROG} add: scheduling file .mod1-1/anotherfile1-1. for addition +${SPROG} add: scheduling file .mod2-1/anotherfile2-1. for addition +${SPROG} add: scheduling file .mod2-2/mod1-2/anotherfile1-2. for addition +${SPROG} add: scheduling file .mod1-2/mod2-2/anotherfile2-2. for addition +${SPROG} add: use .${SPROG} commit. to add these files permanently" + fi + + dotest multiroot-status-1 "${testcvs} status -v" \ +"${SPROG} status: Examining \. +${SPROG} status: Examining mod1-1 +=================================================================== +File: anotherfile1-1 Status: Locally Added + + Working revision: New file! + Repository revision: No revision control file + Sticky Tag: (none) + Sticky Date: (none) + Sticky Options: (none) + +=================================================================== +File: file1-1 Status: Up-to-date + + Working revision: 1\.2.* + Repository revision: 1\.2 ${CVSROOT1_DIRNAME}/mod1-1/file1-1,v + Commit Identifier: ${commitid} + Sticky Tag: (none) + Sticky Date: (none) + Sticky Options: (none) + + Existing Tags: + cattle (revision: 1\.2) + +${SPROG} status: Examining mod1-2 +=================================================================== +File: file1-2 Status: Up-to-date + + Working revision: 1\.2.* + Repository revision: 1\.2 ${CVSROOT1_DIRNAME}/mod1-2/file1-2,v + Commit Identifier: ${commitid} + Sticky Tag: (none) + Sticky Date: (none) + Sticky Options: (none) + + Existing Tags: + cattle (revision: 1\.2) + +${SPROG} status: Examining mod2-2/mod1-2 +=================================================================== +File: anotherfile1-2 Status: Locally Added + + Working revision: New file! + Repository revision: No revision control file + Sticky Tag: (none) + Sticky Date: (none) + Sticky Options: (none) + +=================================================================== +File: file1-2 Status: Up-to-date + + Working revision: 1\.2.* + Repository revision: 1\.2 ${CVSROOT1_DIRNAME}/mod1-2/file1-2,v + Commit Identifier: ${commitid} + Sticky Tag: (none) + Sticky Date: (none) + Sticky Options: (none) + + Existing Tags: + cattle (revision: 1\.2) + +${SPROG} status: Examining mod1-2/mod2-2 +=================================================================== +File: anotherfile2-2 Status: Locally Added + + Working revision: New file! + Repository revision: No revision control file + Sticky Tag: (none) + Sticky Date: (none) + Sticky Options: (none) + +=================================================================== +File: file2-2 Status: Up-to-date + + Working revision: 1\.2.* + Repository revision: 1\.2 ${CVSROOT2_DIRNAME}/mod2-2/file2-2,v + Commit Identifier: ${commitid} + Sticky Tag: (none) + Sticky Date: (none) + Sticky Options: (none) + + Existing Tags: + cattle (revision: 1\.2) + +${SPROG} status: Examining mod2-1 +=================================================================== +File: anotherfile2-1 Status: Locally Added + + Working revision: New file! + Repository revision: No revision control file + Sticky Tag: (none) + Sticky Date: (none) + Sticky Options: (none) + +=================================================================== +File: file2-1 Status: Up-to-date + + Working revision: 1\.2.* + Repository revision: 1\.2 ${CVSROOT2_DIRNAME}/mod2-1/file2-1,v + Commit Identifier: ${commitid} + Sticky Tag: (none) + Sticky Date: (none) + Sticky Options: (none) + + Existing Tags: + cattle (revision: 1\.2) + +${SPROG} status: Examining mod2-2 +=================================================================== +File: file2-2 Status: Up-to-date + + Working revision: 1\.2.* + Repository revision: 1\.2 ${CVSROOT2_DIRNAME}/mod2-2/file2-2,v + Commit Identifier: ${commitid} + Sticky Tag: (none) + Sticky Date: (none) + Sticky Options: (none) + + Existing Tags: + cattle (revision: 1\.2)" \ +"${SPROG} status: Examining \. +${SPROG} status: Examining mod1-1 +=================================================================== +File: anotherfile1-1 Status: Locally Added + + Working revision: New file! + Repository revision: No revision control file + Sticky Tag: (none) + Sticky Date: (none) + Sticky Options: (none) + +=================================================================== +File: file1-1 Status: Up-to-date + + Working revision: 1\.2.* + Repository revision: 1\.2 ${CVSROOT1_DIRNAME}/mod1-1/file1-1,v + Commit Identifier: ${commitid} + Sticky Tag: (none) + Sticky Date: (none) + Sticky Options: (none) + + Existing Tags: + cattle (revision: 1\.2) + +${SPROG} status: Examining mod1-2 +=================================================================== +File: file1-2 Status: Up-to-date + + Working revision: 1\.2.* + Repository revision: 1\.2 ${CVSROOT1_DIRNAME}/mod1-2/file1-2,v + Commit Identifier: ${commitid} + Sticky Tag: (none) + Sticky Date: (none) + Sticky Options: (none) + + Existing Tags: + cattle (revision: 1\.2) + +${SPROG} status: Examining mod2-2 +${SPROG} status: Examining mod2-2/mod1-2 +=================================================================== +File: anotherfile1-2 Status: Locally Added + + Working revision: New file! + Repository revision: No revision control file + Sticky Tag: (none) + Sticky Date: (none) + Sticky Options: (none) + +=================================================================== +File: file1-2 Status: Up-to-date + + Working revision: 1\.2.* + Repository revision: 1\.2 ${CVSROOT1_DIRNAME}/mod1-2/file1-2,v + Commit Identifier: ${commitid} + Sticky Tag: (none) + Sticky Date: (none) + Sticky Options: (none) + + Existing Tags: + cattle (revision: 1\.2) + +${SPROG} status: Examining mod1-2 +${SPROG} status: Examining mod1-2/mod2-2 +=================================================================== +File: anotherfile2-2 Status: Locally Added + + Working revision: New file! + Repository revision: No revision control file + Sticky Tag: (none) + Sticky Date: (none) + Sticky Options: (none) + +=================================================================== +File: file2-2 Status: Up-to-date + + Working revision: 1\.2.* + Repository revision: 1\.2 ${CVSROOT2_DIRNAME}/mod2-2/file2-2,v + Commit Identifier: ${commitid} + Sticky Tag: (none) + Sticky Date: (none) + Sticky Options: (none) + + Existing Tags: + cattle (revision: 1\.2) + +${SPROG} status: Examining mod2-1 +=================================================================== +File: anotherfile2-1 Status: Locally Added + + Working revision: New file! + Repository revision: No revision control file + Sticky Tag: (none) + Sticky Date: (none) + Sticky Options: (none) + +=================================================================== +File: file2-1 Status: Up-to-date + + Working revision: 1\.2.* + Repository revision: 1\.2 ${CVSROOT2_DIRNAME}/mod2-1/file2-1,v + Commit Identifier: ${commitid} + Sticky Tag: (none) + Sticky Date: (none) + Sticky Options: (none) + + Existing Tags: + cattle (revision: 1\.2) + +${SPROG} status: Examining mod2-2 +=================================================================== +File: file2-2 Status: Up-to-date + + Working revision: 1\.2.* + Repository revision: 1\.2 ${CVSROOT2_DIRNAME}/mod2-2/file2-2,v + Commit Identifier: ${commitid} + Sticky Tag: (none) + Sticky Date: (none) + Sticky Options: (none) + + Existing Tags: + cattle (revision: 1\.2)" + + dotest multiroot-commit-2 "${testcvs} commit -m reading" \ +"${CPROG} commit: Examining \. +${CPROG} commit: Examining mod1-1 +${CPROG} commit: Examining mod1-2 +${CPROG} commit: Examining mod2-2/mod1-2 +${CVSROOT1_DIRNAME}/mod1-1/anotherfile1-1,v <-- mod1-1/anotherfile1-1 +initial revision: 1\.1 +${CVSROOT1_DIRNAME}/mod1-2/anotherfile1-2,v <-- mod2-2/mod1-2/anotherfile1-2 +initial revision: 1\.1 +${CPROG} commit: Examining mod1-2/mod2-2 +${CPROG} commit: Examining mod2-1 +${CPROG} commit: Examining mod2-2 +${CVSROOT2_DIRNAME}/mod2-2/anotherfile2-2,v <-- mod1-2/mod2-2/anotherfile2-2 +initial revision: 1\.1 +${CVSROOT2_DIRNAME}/mod2-1/anotherfile2-1,v <-- mod2-1/anotherfile2-1 +initial revision: 1\.1" + + dotest multiroot-update-3 "${testcvs} update" \ +"${CPROG} update: Updating \. +${CPROG} update: Updating mod1-1 +${CPROG} update: Updating mod1-2 +U mod1-2/anotherfile1-2 +${CPROG} update: Updating mod2-2/mod1-2 +${CPROG} update: Updating mod1-2/mod2-2 +${CPROG} update: Updating mod2-1 +${CPROG} update: Updating mod2-2 +U mod2-2/anotherfile2-2" \ +"${SPROG} update: Updating \. +${SPROG} update: Updating mod1-1 +${SPROG} update: Updating mod1-2 +U mod1-2/anotherfile1-2 +${SPROG} update: Updating mod2-2 +${SPROG} update: Updating mod2-2/mod1-2 +${SPROG} update: Updating mod1-2 +${SPROG} update: Updating mod1-2/mod2-2 +${SPROG} update: Updating mod2-1 +${SPROG} update: Updating mod2-2 +U mod2-2/anotherfile2-2" + + dotest multiroot-log-1 "${testcvs} log" \ +"${SPROG} log: Logging \. +${SPROG} log: Logging mod1-1 + +RCS file: ${CVSROOT1_DIRNAME}/mod1-1/anotherfile1-1,v +Working file: mod1-1/anotherfile1-1 +head: 1\.1 +branch: +locks: strict +access list: +symbolic names: +keyword substitution: kv +total revisions: 1; selected revisions: 1 +description: +---------------------------- +revision 1\.1 +date: ${ISO8601DATE}; author: ${username}; state: Exp; commitid: ${commitid}; +reading +============================================================================= + +RCS file: ${CVSROOT1_DIRNAME}/mod1-1/file1-1,v +Working file: mod1-1/file1-1 +head: 1\.2 +branch: +locks: strict +access list: +symbolic names: + cattle: 1\.2 +keyword substitution: kv +total revisions: 2; selected revisions: 2 +description: +---------------------------- +revision 1\.2 +date: ${ISO8601DATE}; author: ${username}; state: Exp; lines: ${PLUS}1 -0; commitid: ${commitid}; +actually +---------------------------- +revision 1\.1 +date: ${ISO8601DATE}; author: ${username}; state: Exp; commitid: ${commitid}; +is +============================================================================= +${SPROG} log: Logging mod1-2 + +RCS file: ${CVSROOT1_DIRNAME}/mod1-2/anotherfile1-2,v +Working file: mod1-2/anotherfile1-2 +head: 1\.1 +branch: +locks: strict +access list: +symbolic names: +keyword substitution: kv +total revisions: 1; selected revisions: 1 +description: +---------------------------- +revision 1\.1 +date: ${ISO8601DATE}; author: ${username}; state: Exp; commitid: ${commitid}; +reading +============================================================================= + +RCS file: ${CVSROOT1_DIRNAME}/mod1-2/file1-2,v +Working file: mod1-2/file1-2 +head: 1\.2 +branch: +locks: strict +access list: +symbolic names: + cattle: 1\.2 +keyword substitution: kv +total revisions: 2; selected revisions: 2 +description: +---------------------------- +revision 1\.2 +date: ${ISO8601DATE}; author: ${username}; state: Exp; lines: ${PLUS}1 -0; commitid: ${commitid}; +actually +---------------------------- +revision 1\.1 +date: ${ISO8601DATE}; author: ${username}; state: Exp; commitid: ${commitid}; +is +============================================================================= +${SPROG} log: Logging mod2-2/mod1-2 + +RCS file: ${CVSROOT1_DIRNAME}/mod1-2/anotherfile1-2,v +Working file: mod2-2/mod1-2/anotherfile1-2 +head: 1\.1 +branch: +locks: strict +access list: +symbolic names: +keyword substitution: kv +total revisions: 1; selected revisions: 1 +description: +---------------------------- +revision 1\.1 +date: ${ISO8601DATE}; author: ${username}; state: Exp; commitid: ${commitid}; +reading +============================================================================= + +RCS file: ${CVSROOT1_DIRNAME}/mod1-2/file1-2,v +Working file: mod2-2/mod1-2/file1-2 +head: 1\.2 +branch: +locks: strict +access list: +symbolic names: + cattle: 1\.2 +keyword substitution: kv +total revisions: 2; selected revisions: 2 +description: +---------------------------- +revision 1\.2 +date: ${ISO8601DATE}; author: ${username}; state: Exp; lines: ${PLUS}1 -0; commitid: ${commitid}; +actually +---------------------------- +revision 1\.1 +date: ${ISO8601DATE}; author: ${username}; state: Exp; commitid: ${commitid}; +is +============================================================================= +${SPROG} log: Logging mod1-2/mod2-2 + +RCS file: ${CVSROOT2_DIRNAME}/mod2-2/anotherfile2-2,v +Working file: mod1-2/mod2-2/anotherfile2-2 +head: 1\.1 +branch: +locks: strict +access list: +symbolic names: +keyword substitution: kv +total revisions: 1; selected revisions: 1 +description: +---------------------------- +revision 1\.1 +date: ${ISO8601DATE}; author: ${username}; state: Exp; commitid: ${commitid}; +reading +============================================================================= + +RCS file: ${CVSROOT2_DIRNAME}/mod2-2/file2-2,v +Working file: mod1-2/mod2-2/file2-2 +head: 1\.2 +branch: +locks: strict +access list: +symbolic names: + cattle: 1\.2 +keyword substitution: kv +total revisions: 2; selected revisions: 2 +description: +---------------------------- +revision 1\.2 +date: ${ISO8601DATE}; author: ${username}; state: Exp; lines: ${PLUS}1 -0; commitid: ${commitid}; +actually +---------------------------- +revision 1\.1 +date: ${ISO8601DATE}; author: ${username}; state: Exp; commitid: ${commitid}; +anyone +============================================================================= +${SPROG} log: Logging mod2-1 + +RCS file: ${CVSROOT2_DIRNAME}/mod2-1/anotherfile2-1,v +Working file: mod2-1/anotherfile2-1 +head: 1\.1 +branch: +locks: strict +access list: +symbolic names: +keyword substitution: kv +total revisions: 1; selected revisions: 1 +description: +---------------------------- +revision 1\.1 +date: ${ISO8601DATE}; author: ${username}; state: Exp; commitid: ${commitid}; +reading +============================================================================= + +RCS file: ${CVSROOT2_DIRNAME}/mod2-1/file2-1,v +Working file: mod2-1/file2-1 +head: 1\.2 +branch: +locks: strict +access list: +symbolic names: + cattle: 1\.2 +keyword substitution: kv +total revisions: 2; selected revisions: 2 +description: +---------------------------- +revision 1\.2 +date: ${ISO8601DATE}; author: ${username}; state: Exp; lines: ${PLUS}1 -0; commitid: ${commitid}; +actually +---------------------------- +revision 1\.1 +date: ${ISO8601DATE}; author: ${username}; state: Exp; commitid: ${commitid}; +anyone +============================================================================= +${SPROG} log: Logging mod2-2 + +RCS file: ${CVSROOT2_DIRNAME}/mod2-2/anotherfile2-2,v +Working file: mod2-2/anotherfile2-2 +head: 1\.1 +branch: +locks: strict +access list: +symbolic names: +keyword substitution: kv +total revisions: 1; selected revisions: 1 +description: +---------------------------- +revision 1\.1 +date: ${ISO8601DATE}; author: ${username}; state: Exp; commitid: ${commitid}; +reading +============================================================================= + +RCS file: ${CVSROOT2_DIRNAME}/mod2-2/file2-2,v +Working file: mod2-2/file2-2 +head: 1\.2 +branch: +locks: strict +access list: +symbolic names: + cattle: 1\.2 +keyword substitution: kv +total revisions: 2; selected revisions: 2 +description: +---------------------------- +revision 1\.2 +date: ${ISO8601DATE}; author: ${username}; state: Exp; lines: ${PLUS}1 -0; commitid: ${commitid}; +actually +---------------------------- +revision 1\.1 +date: ${ISO8601DATE}; author: ${username}; state: Exp; commitid: ${commitid}; +anyone +=============================================================================" \ +"${SPROG} log: Logging \. +${SPROG} log: Logging mod1-1 + +RCS file: ${CVSROOT1_DIRNAME}/mod1-1/anotherfile1-1,v +Working file: mod1-1/anotherfile1-1 +head: 1\.1 +branch: +locks: strict +access list: +symbolic names: +keyword substitution: kv +total revisions: 1; selected revisions: 1 +description: +---------------------------- +revision 1\.1 +date: ${ISO8601DATE}; author: ${username}; state: Exp; commitid: ${commitid}; +reading +============================================================================= + +RCS file: ${CVSROOT1_DIRNAME}/mod1-1/file1-1,v +Working file: mod1-1/file1-1 +head: 1\.2 +branch: +locks: strict +access list: +symbolic names: + cattle: 1\.2 +keyword substitution: kv +total revisions: 2; selected revisions: 2 +description: +---------------------------- +revision 1\.2 +date: ${ISO8601DATE}; author: ${username}; state: Exp; lines: ${PLUS}1 -0; commitid: ${commitid}; +actually +---------------------------- +revision 1\.1 +date: ${ISO8601DATE}; author: ${username}; state: Exp; commitid: ${commitid}; +is +============================================================================= +${SPROG} log: Logging mod1-2 + +RCS file: ${CVSROOT1_DIRNAME}/mod1-2/anotherfile1-2,v +Working file: mod1-2/anotherfile1-2 +head: 1\.1 +branch: +locks: strict +access list: +symbolic names: +keyword substitution: kv +total revisions: 1; selected revisions: 1 +description: +---------------------------- +revision 1\.1 +date: ${ISO8601DATE}; author: ${username}; state: Exp; commitid: ${commitid}; +reading +============================================================================= + +RCS file: ${CVSROOT1_DIRNAME}/mod1-2/file1-2,v +Working file: mod1-2/file1-2 +head: 1\.2 +branch: +locks: strict +access list: +symbolic names: + cattle: 1\.2 +keyword substitution: kv +total revisions: 2; selected revisions: 2 +description: +---------------------------- +revision 1\.2 +date: ${ISO8601DATE}; author: ${username}; state: Exp; lines: ${PLUS}1 -0; commitid: ${commitid}; +actually +---------------------------- +revision 1\.1 +date: ${ISO8601DATE}; author: ${username}; state: Exp; commitid: ${commitid}; +is +============================================================================= +${SPROG} log: Logging mod2-2 +${SPROG} log: Logging mod2-2/mod1-2 + +RCS file: ${CVSROOT1_DIRNAME}/mod1-2/anotherfile1-2,v +Working file: mod2-2/mod1-2/anotherfile1-2 +head: 1\.1 +branch: +locks: strict +access list: +symbolic names: +keyword substitution: kv +total revisions: 1; selected revisions: 1 +description: +---------------------------- +revision 1\.1 +date: ${ISO8601DATE}; author: ${username}; state: Exp; commitid: ${commitid}; +reading +============================================================================= + +RCS file: ${CVSROOT1_DIRNAME}/mod1-2/file1-2,v +Working file: mod2-2/mod1-2/file1-2 +head: 1\.2 +branch: +locks: strict +access list: +symbolic names: + cattle: 1\.2 +keyword substitution: kv +total revisions: 2; selected revisions: 2 +description: +---------------------------- +revision 1\.2 +date: ${ISO8601DATE}; author: ${username}; state: Exp; lines: ${PLUS}1 -0; commitid: ${commitid}; +actually +---------------------------- +revision 1\.1 +date: ${ISO8601DATE}; author: ${username}; state: Exp; commitid: ${commitid}; +is +============================================================================= +${SPROG} log: Logging mod1-2 +${SPROG} log: Logging mod1-2/mod2-2 + +RCS file: ${CVSROOT2_DIRNAME}/mod2-2/anotherfile2-2,v +Working file: mod1-2/mod2-2/anotherfile2-2 +head: 1\.1 +branch: +locks: strict +access list: +symbolic names: +keyword substitution: kv +total revisions: 1; selected revisions: 1 +description: +---------------------------- +revision 1\.1 +date: ${ISO8601DATE}; author: ${username}; state: Exp; commitid: ${commitid}; +reading +============================================================================= + +RCS file: ${CVSROOT2_DIRNAME}/mod2-2/file2-2,v +Working file: mod1-2/mod2-2/file2-2 +head: 1\.2 +branch: +locks: strict +access list: +symbolic names: + cattle: 1\.2 +keyword substitution: kv +total revisions: 2; selected revisions: 2 +description: +---------------------------- +revision 1\.2 +date: ${ISO8601DATE}; author: ${username}; state: Exp; lines: ${PLUS}1 -0; commitid: ${commitid}; +actually +---------------------------- +revision 1\.1 +date: ${ISO8601DATE}; author: ${username}; state: Exp; commitid: ${commitid}; +anyone +============================================================================= +${SPROG} log: Logging mod2-1 + +RCS file: ${CVSROOT2_DIRNAME}/mod2-1/anotherfile2-1,v +Working file: mod2-1/anotherfile2-1 +head: 1\.1 +branch: +locks: strict +access list: +symbolic names: +keyword substitution: kv +total revisions: 1; selected revisions: 1 +description: +---------------------------- +revision 1\.1 +date: ${ISO8601DATE}; author: ${username}; state: Exp; commitid: ${commitid}; +reading +============================================================================= + +RCS file: ${CVSROOT2_DIRNAME}/mod2-1/file2-1,v +Working file: mod2-1/file2-1 +head: 1\.2 +branch: +locks: strict +access list: +symbolic names: + cattle: 1\.2 +keyword substitution: kv +total revisions: 2; selected revisions: 2 +description: +---------------------------- +revision 1\.2 +date: ${ISO8601DATE}; author: ${username}; state: Exp; lines: ${PLUS}1 -0; commitid: ${commitid}; +actually +---------------------------- +revision 1\.1 +date: ${ISO8601DATE}; author: ${username}; state: Exp; commitid: ${commitid}; +anyone +============================================================================= +${SPROG} log: Logging mod2-2 + +RCS file: ${CVSROOT2_DIRNAME}/mod2-2/anotherfile2-2,v +Working file: mod2-2/anotherfile2-2 +head: 1\.1 +branch: +locks: strict +access list: +symbolic names: +keyword substitution: kv +total revisions: 1; selected revisions: 1 +description: +---------------------------- +revision 1\.1 +date: ${ISO8601DATE}; author: ${username}; state: Exp; commitid: ${commitid}; +reading +============================================================================= + +RCS file: ${CVSROOT2_DIRNAME}/mod2-2/file2-2,v +Working file: mod2-2/file2-2 +head: 1\.2 +branch: +locks: strict +access list: +symbolic names: + cattle: 1\.2 +keyword substitution: kv +total revisions: 2; selected revisions: 2 +description: +---------------------------- +revision 1\.2 +date: ${ISO8601DATE}; author: ${username}; state: Exp; lines: ${PLUS}1 -0; commitid: ${commitid}; +actually +---------------------------- +revision 1\.1 +date: ${ISO8601DATE}; author: ${username}; state: Exp; commitid: ${commitid}; +anyone +=============================================================================" + + + # After the simple cases, let's execute some commands which + # refer to parts of our checked-out tree (e.g. "cvs update + # mod1-1 mod2-2") + + dokeep + + # clean up after ourselves + cd .. + rm -r 1 + + # clean up our repositories + rm -rf ${CVSROOT1_DIRNAME} ${CVSROOT2_DIRNAME} + ;; + + + + multiroot2) + # More multiroot tests. In particular, nested directories. + + if $proxy; then + # don't even try + continue + fi + + CVSROOT1_DIRNAME=${TESTDIR}/root1 + CVSROOT2_DIRNAME=${TESTDIR}/root2 + CVSROOT1=`newroot $CVSROOT1_DIRNAME` + CVSROOT2=`newroot $CVSROOT2_DIRNAME` + + dotest multiroot2-1 "${testcvs} -d ${CVSROOT1} init" "" + dotest multiroot2-2 "${testcvs} -d ${CVSROOT2} init" "" + + mkdir imp-dir; cd imp-dir + echo file1 >file1 + mkdir sdir + echo sfile >sdir/sfile + mkdir sdir/ssdir + echo ssfile >sdir/ssdir/ssfile + dotest_sort multiroot2-3 \ +"${testcvs} -d ${CVSROOT1} import -m import-to-root1 dir1 vend rel" " + +N dir1/file1 +N dir1/sdir/sfile +N dir1/sdir/ssdir/ssfile +No conflicts created by this import +${SPROG} import: Importing ${TESTDIR}/root1/dir1/sdir +${SPROG} import: Importing ${TESTDIR}/root1/dir1/sdir/ssdir" + cd sdir + dotest_sort multiroot2-4 \ +"${testcvs} -d ${CVSROOT2} import -m import-to-root2 sdir vend2 rel2" " + +N sdir/sfile +N sdir/ssdir/ssfile +No conflicts created by this import +${SPROG} import: Importing ${TESTDIR}/root2/sdir/ssdir" + cd ../.. + + mkdir 1; cd 1 + # Get TopLevelAdmin-like behavior. + dotest multiroot2-5 "${testcvs} -d ${CVSROOT1} -q co -l ." + dotest multiroot2-5 "${testcvs} -d ${CVSROOT1} -q co dir1" \ +"U dir1/file1 +U dir1/sdir/sfile +U dir1/sdir/ssdir/ssfile" + cd dir1 + dotest multiroot2-6 "${testcvs} -Q release -d sdir" "" + dotest multiroot2-7 "${testcvs} -d ${CVSROOT2} -q co sdir" \ +"U sdir/sfile +U sdir/ssdir/ssfile" + cd .. + # This has one subtle effect - it deals with Entries.Log + # so that the next test doesn't get trace messages for + # Entries.Log + dotest multiroot2-8 "${testcvs} update" \ +"${CPROG} update: Updating \. +${CPROG} update: Updating dir1 +${CPROG} update: Updating dir1/sdir +${CPROG} update: Updating dir1/sdir/ssdir" \ +"${SPROG} update: Updating \. +${SPROG} update: Updating dir1 +${SPROG} update: Updating dir1 +${SPROG} update: Updating dir1/sdir +${SPROG} update: Updating dir1/sdir/ssdir" + # Two reasons we don't run this on the server: (1) the server + # also prints some trace messages, and (2) the server trace + # messages are subject to out-of-order bugs (this one is hard + # to work around). + if $remote; then :; else + dotest multiroot2-9a "${testcvs} -t update" \ +" *-> main: Session ID is ${commitid} + *-> main loop with CVSROOT=${TESTDIR}/root1 + *-> parse_config ($TESTDIR/root1) + *-> do_update ((null), (null), (null), 1, 0, 0, 0, 0, 0, 3, (null), (null), (null), (null), (null), 1, (null)) + *-> Write_Template (\., ${TESTDIR}/root1) +${CPROG} update: Updating \. + *-> Reader_Lock(${TESTDIR}/root1) + *-> Simple_Lock_Cleanup() + *-> Write_Template (dir1, ${TESTDIR}/root1/dir1) +${CPROG} update: Updating dir1 + *-> Reader_Lock(${TESTDIR}/root1/dir1) + *-> Simple_Lock_Cleanup() + *-> main loop with CVSROOT=${TESTDIR}/root2 + *-> parse_config ($TESTDIR/root2) + *-> do_update ((null), (null), (null), 1, 0, 0, 0, 0, 0, 3, (null), (null), (null), (null), (null), 1, (null)) + *-> Write_Template (dir1/sdir, ${TESTDIR}/root2/dir1/sdir) +${CPROG} update: Updating dir1/sdir + *-> Reader_Lock(${TESTDIR}/root2/sdir) + *-> Simple_Lock_Cleanup() + *-> Write_Template (dir1/sdir/ssdir, ${TESTDIR}/root2/sdir/ssdir) +${CPROG} update: Updating dir1/sdir/ssdir + *-> Reader_Lock(${TESTDIR}/root2/sdir/ssdir) + *-> Simple_Lock_Cleanup() + *-> Lock_Cleanup() + *-> Simple_Lock_Cleanup()" + fi + + dotest multiroot2-9 "${testcvs} -q tag tag1" \ +"T dir1/file1 +T dir1/sdir/sfile +T dir1/sdir/ssdir/ssfile" + echo "change it" >>dir1/file1 + echo "change him too" >>dir1/sdir/sfile + dotest multiroot2-10 "${testcvs} -q ci -m modify" \ +"$TESTDIR/root1/dir1/file1,v <-- dir1/file1 +new revision: 1\.2; previous revision: 1\.1 +$TESTDIR/root2/sdir/sfile,v <-- dir1/sdir/sfile +new revision: 1\.2; previous revision: 1\.1" + dotest multiroot2-11 "${testcvs} -q tag tag2" \ +"T dir1/file1 +T dir1/sdir/sfile +T dir1/sdir/ssdir/ssfile" + dotest_fail multiroot2-12 \ +"${testcvs} -q diff -u -r tag1 -r tag2" \ +"Index: dir1/file1 +=================================================================== +RCS file: ${TESTDIR}/root1/dir1/file1,v +retrieving revision 1\.1\.1\.1 +retrieving revision 1\.2 +diff -u -r1\.1\.1\.1 -r1\.2 +--- dir1/file1 ${RFCDATE} 1\.1\.1\.1 +${PLUS}${PLUS}${PLUS} dir1/file1 ${RFCDATE} 1\.2 +@@ -1 ${PLUS}1,2 @@ + file1 +${PLUS}change it +Index: dir1/sdir/sfile +=================================================================== +RCS file: ${TESTDIR}/root2/sdir/sfile,v +retrieving revision 1\.1\.1\.1 +retrieving revision 1\.2 +diff -u -r1\.1\.1\.1 -r1\.2 +--- dir1/sdir/sfile ${RFCDATE} 1\.1\.1\.1 +${PLUS}${PLUS}${PLUS} dir1/sdir/sfile ${RFCDATE} 1\.2 +@@ -1 ${PLUS}1,2 @@ + sfile +${PLUS}change him too" + + if $keep; then + echo Keeping ${TESTDIR} and exiting due to --keep + exit 0 + fi + + # clean up after ourselves + cd .. + rm -r imp-dir 1 + + # clean up our repositories + rm -rf root1 root2 + ;; + + + + multiroot3) + # More multiroot tests. Directories are side-by-side, not nested. + # Not drastically different from multiroot but it covers somewhat + # different stuff. + + if $proxy; then + # don't even try + continue + fi + + CVSROOT1=`newroot ${TESTDIR}/root1` + CVSROOT2=`newroot ${TESTDIR}/root2` + + mkdir 1; cd 1 + dotest multiroot3-1 "${testcvs} -d ${CVSROOT1} init" "" + dotest multiroot3-2 "${testcvs} -d ${CVSROOT1} -q co -l ." "" + mkdir dir1 + dotest multiroot3-3 "${testcvs} add dir1" \ +"Directory ${TESTDIR}/root1/dir1 added to the repository" + dotest multiroot3-4 "${testcvs} -d ${CVSROOT2} init" "" + rm -r CVS + dotest multiroot3-5 "${testcvs} -d ${CVSROOT2} -q co -l ." "" + mkdir dir2 + + # OK, the problem is that CVS/Entries doesn't look quite right, + # I suppose because of the "rm -r". Then again, why *should* it + # look right? CVS/Root can only point to a single location, but + # we expect CVS/Entries to hold entries for two repositories? It + # just plain isn't part of the filespec yet. + # + # Use the quick and dirty fix. + echo "D/dir1////" >CVS/Entries + echo "D/dir2////" >>CVS/Entries + + dotest multiroot3-7 "${testcvs} add dir2" \ +"Directory ${TESTDIR}/root2/dir2 added to the repository" + + touch dir1/file1 dir2/file2 + if $remote; then + # Trying to add them both in one command doesn't work, + # because add.c doesn't do multiroot (it doesn't use recurse.c). + # Furthermore, it can't deal with the parent directory + # having a different root from the child, hence the cd. + cd dir1 + dotest multiroot3-8 "${testcvs} add file1" \ +"${SPROG} add: scheduling file .file1. for addition +${SPROG} add: use .${SPROG} commit. to add this file permanently" + cd .. + dotest multiroot3-8a "${testcvs} add dir2/file2" \ +"${SPROG} add: scheduling file .dir2/file2. for addition +${SPROG} add: use .${SPROG} commit. to add this file permanently" + else + dotest multiroot3-8 "${testcvs} add dir1/file1 dir2/file2" \ +"${SPROG} add: scheduling file .dir1/file1. for addition +${SPROG} add: scheduling file .dir2/file2. for addition +${SPROG} add: use .${SPROG} commit. to add these files permanently" + fi + + dotest multiroot3-9 "${testcvs} -q ci -m add-them" \ +"$TESTDIR/root2/dir2/file2,v <-- dir2/file2 +initial revision: 1\.1 +$TESTDIR/root1/dir1/file1,v <-- dir1/file1 +initial revision: 1\.1" + + # That this is an error is good - we are asking CVS to do + # something which doesn't make sense. + dotest_fail multiroot3-10 \ +"${testcvs} -q -d ${CVSROOT1} diff dir1/file1 dir2/file2" \ +"${SPROG} diff: failed to create lock directory for .${TESTDIR}/root1/dir2' (${TESTDIR}/root1/dir2/#cvs.lock): No such file or directory +${SPROG} diff: failed to obtain dir lock in repository .${TESTDIR}/root1/dir2' +${SPROG} \[diff aborted\]: read lock failed - giving up" + + # This one is supposed to work. + dotest multiroot3-11 "${testcvs} -q diff dir1/file1 dir2/file2" "" + + # make sure we can't access across repositories + # FIXCVS: we probably shouldn't even create the local directories + # in this case, but we do, so deal with it. + mkdir 1a + cd 1a + dotest_fail multiroot3-12 \ +"$testcvs -d $CVSROOT1 -q co ../root2/dir2" \ +"$CPROG \[checkout aborted\]: up-level in module reference (\`..') invalid: \`\.\./root2/dir2'\." \ +"$SPROG \[server aborted\]: up-level in module reference (\`..') invalid: \`\.\./root2/dir2'\. +$CPROG \[checkout aborted\]: end of file from server (consult above messages if any)" + dotest_fail multiroot3-13 \ +"$testcvs -d $CVSROOT2 -q co ../root1/dir1" \ +"$CPROG \[checkout aborted\]: up-level in module reference (\`..') invalid: \`\.\./root1/dir1'\." \ +"$SPROG \[server aborted\]: up-level in module reference (\`..') invalid: \`\.\./root1/dir1'\. +$CPROG \[checkout aborted\]: end of file from server (consult above messages if any)" + dotest_fail multiroot3-14 \ +"$testcvs -d $CVSROOT1 -q co ./../root2/dir2" \ +"$CPROG \[checkout aborted\]: up-level in module reference (\`..') invalid: \`\./\.\./root2/dir2'\." \ +"$SPROG \[server aborted\]: up-level in module reference (\`..') invalid: \`\./\.\./root2/dir2'\. +$CPROG \[checkout aborted\]: end of file from server (consult above messages if any)" + dotest_fail multiroot3-15 \ +"$testcvs -d $CVSROOT2 -q co ./../root1/dir1" \ +"$CPROG \[checkout aborted\]: up-level in module reference (\`..') invalid: \`\./\.\./root1/dir1'\." \ +"$SPROG \[server aborted\]: up-level in module reference (\`..') invalid: \`\./\.\./root1/dir1'\. +$CPROG \[checkout aborted\]: end of file from server (consult above messages if any)" + dotest_fail multiroot3-16 \ +"$testcvs -d $CVSROOT1 -q co -p ../root2/dir2" \ +"$CPROG \[checkout aborted\]: up-level in module reference (\`..') invalid: \`\.\./root2/dir2'\." \ +"$SPROG \[server aborted\]: up-level in module reference (\`..') invalid: \`\.\./root2/dir2'\. +$CPROG \[checkout aborted\]: end of file from server (consult above messages if any)" + dotest_fail multiroot3-17 \ +"$testcvs -d $CVSROOT1 -q co -p ./../root1/dir1" \ +"$CPROG \[checkout aborted\]: up-level in module reference (\`..') invalid: \`\./\.\./root1/dir1'\." \ +"$SPROG \[server aborted\]: up-level in module reference (\`..') invalid: \`\./\.\./root1/dir1'\. +$CPROG \[checkout aborted\]: end of file from server (consult above messages if any)" + + cd ../.. + + if $keep; then + echo Keeping ${TESTDIR} and exiting due to --keep + exit 0 + fi + + rm -r 1 + rm -rf ${TESTDIR}/root1 ${TESTDIR}/root2 + unset CVSROOT1 + unset CVSROOT2 + ;; + + + + multiroot4) + # More multiroot tests, in particular we have two roots with + # similarly-named directories and we try to see that CVS can + # keep them separate. + + if $proxy; then + # don't even try + continue + fi + + CVSROOT1=`newroot ${TESTDIR}/root1` + CVSROOT2=`newroot ${TESTDIR}/root2` + + mkdir 1; cd 1 + dotest multiroot4-1 "${testcvs} -d ${CVSROOT1} init" "" + dotest multiroot4-2 "${testcvs} -d ${CVSROOT1} -q co -l ." "" + mkdir dircom + dotest multiroot4-3 "${testcvs} add dircom" \ +"Directory ${TESTDIR}/root1/dircom added to the repository" + cd dircom + touch file1 + dotest multiroot4-4 "${testcvs} add file1" \ +"${SPROG} add: scheduling file .file1. for addition +${SPROG} add: use .${SPROG} commit. to add this file permanently" + dotest multiroot4-5 "${testcvs} -q ci -m add" \ +"$TESTDIR/root1/dircom/file1,v <-- file1 +initial revision: 1\.1" + cd ../.. + mkdir 2; cd 2 + dotest multiroot4-6 "${testcvs} -d ${CVSROOT2} init" "" + dotest multiroot4-7 "${testcvs} -d ${CVSROOT2} -q co -l ." "" + mkdir dircom + dotest multiroot4-8 "${testcvs} add dircom" \ +"Directory ${TESTDIR}/root2/dircom added to the repository" + cd dircom + touch file2 + dotest multiroot4-9 "${testcvs} add file2" \ +"${SPROG} add: scheduling file .file2. for addition +${SPROG} add: use .${SPROG} commit. to add this file permanently" + dotest multiroot4-10 "${testcvs} -q ci -m add" \ +"$TESTDIR/root2/dircom/file2,v <-- file2 +initial revision: 1\.1" + + cd ../.. + cd 1/dircom + # This may look contrived; the real world example which inspired + # it was that a user was changing from local to remote. Cases + # like switching servers (among those mounting the same + # repository) and so on would also look the same. + mkdir sdir2 + dotest multiroot4-11 "${testcvs} -d ${CVSROOT2} add sdir2" \ +"Directory ${TESTDIR}/root2/dircom/sdir2 added to the repository" + + dotest multiroot4-12 "${testcvs} -q update" "" + cd .. + dotest multiroot4-13 "${testcvs} -q update dircom" "" + cd .. + + rm -r 1 2 + rm -rf ${TESTDIR}/root1 ${TESTDIR}/root2 + unset CVSROOT1 + unset CVSROOT2 + ;; + + + + rmroot) + # When the Entries/Root file is removed from an existing + # workspace, CVS should assume $CVSROOT instead + # + # Right now only checking that CVS exits normally on an + # update once CVS/Root is deleted + # + # There was a time when this would core dump when run in + # client/server mode + + mkdir 1; cd 1 + dotest rmroot-setup-1 "${testcvs} -q co -l ." '' + mkdir first-dir + dotest rmroot-setup-2 "${testcvs} add first-dir" \ +"Directory ${CVSROOT_DIRNAME}/first-dir added to the repository" + cd first-dir + touch file1 file2 + dotest rmroot-setup-3 "${testcvs} add file1 file2" \ +"${SPROG} add: scheduling file .file1. for addition +${SPROG} add: scheduling file .file2. for addition +${SPROG} add: use .${SPROG} commit. to add these files permanently" + dotest rmroot-setup-4 "${testcvs} -q commit -minit" \ +"$CVSROOT_DIRNAME/first-dir/file1,v <-- file1 +initial revision: 1\.1 +$CVSROOT_DIRNAME/first-dir/file2,v <-- file2 +initial revision: 1\.1" + rm CVS/Root + dotest rmroot-1 "${testcvs} -q update" '' + + dokeep + cd ../.. + rm -rf 1 + modify_repo rm -rf $CVSROOT_DIRNAME/first-dir + ;; + + + + reposmv) + # More tests of repositories and specifying them. + # Similar to crerepos but that test is probably getting big + # enough. + + if $proxy; then + # don't even try + continue + fi + + CVSROOT1=`newroot ${TESTDIR}/root1` + CVSROOT_MOVED=`newroot ${TESTDIR}/root-moved` + + dotest reposmv-setup-1 "${testcvs} -d ${CVSROOT1} init" "" + mkdir imp-dir; cd imp-dir + echo file1 >file1 + dotest reposmv-setup-2 \ +"${testcvs} -d ${CVSROOT1} import -m add dir1 vendor release" \ +"N dir1/file1 + +No conflicts created by this import" + cd .. + + mkdir 1; cd 1 + dotest reposmv-1 "${testcvs} -d ${CVSROOT1} -Q co dir1" "" + mv ${TESTDIR}/root1 ${TESTDIR}/root-moved + cd dir1 + + # If we didn't have a relative repository, get one now. + dotest reposmv-1a "cat CVS/Repository" \ +"${TESTDIR}/root1/dir1" "dir1" + echo dir1 >CVS/Repository + + # There were some duplicated warnings and such; only test + # for the part of the error message which makes sense. + # + # FIXCVS then FIXME + # Now the duplicated error messages only occur on some platforms, + # including, apparently, NetBSD 1.6.1, RedHat Linux 7.3, whatever + # kernel that is using, and Solaris 9. These platforms somehow + # decide to call Name_Root() up to four times, via do_recursion, but + # I'm not sure of the rest of the details. Other platforms, + # including Fedora Core 1 (Linux 2.4.22-1.2199.nptl), RH Linux 9 + # (Linux 2.4.20-37.9.legacy), and probably AIX 3.4, Solaris 8, + # BSD/OS 4.2, & IRIX 6.5 only call Name_Root() once as a result of + # this test. + # + # Bug: "skipping directory " without filename. + if $remote; then + dotest_fail reposmv-2r "${testcvs} update" \ +"Cannot access ${TESTDIR}/root1/CVSROOT +No such file or directory" + else + dotest reposmv-2 "$testcvs update" \ +"$DOTSTAR$CPROG update: in directory \.: +$CPROG update: ignoring CVS/Root because it specifies a non-existent repository $TESTDIR/root1 +$CPROG update: Updating \. +$DOTSTAR$CPROG update: cannot open directory $CVSROOT_DIRNAME/dir1: No such file or directory +$CPROG update: skipping directory " + fi + + # CVS/Root overrides $CVSROOT + if $remote; then + CVSROOT_save=${CVSROOT} + CVSROOT=:fork:${TESTDIR}/root-moved; export CVSROOT + dotest_fail reposmv-3r "${testcvs} update" \ +"Cannot access ${TESTDIR}/root1/CVSROOT +No such file or directory" + CVSROOT=${CVSROOT_save}; export CVSROOT + else + CVSROOT_save=$CVSROOT + CVSROOT=$TESTDIR/root-moved; export CVSROOT + dotest reposmv-3 "$testcvs update" \ +"$DOTSTAR$CPROG update: in directory \.: +$CPROG update: ignoring CVS/Root because it specifies a non-existent repository $TESTDIR/root1 +$CPROG update: Updating \.$DOTSTAR" + CVSROOT=$CVSROOT_save; export CVSROOT + fi + + if $remote; then + CVSROOT_save=${CVSROOT} + CVSROOT=:fork:${TESTDIR}/root-none; export CVSROOT + dotest_fail reposmv-4r "${testcvs} update" \ +"Cannot access ${TESTDIR}/root1/CVSROOT +No such file or directory" + CVSROOT=${CVSROOT_save}; export CVSROOT + else + # CVS/Root doesn't seem to quite completely override $CVSROOT + # Bug? Not necessarily a big deal if it only affects error + # messages. + CVSROOT_save=${CVSROOT} + CVSROOT=${TESTDIR}/root-none; export CVSROOT + dotest_fail reposmv-4 "${testcvs} update" \ +"${CPROG} update: in directory \.: +${CPROG} update: ignoring CVS/Root because it specifies a non-existent repository ${TESTDIR}/root1 +${CPROG} \[update aborted\]: ${TESTDIR}/root-none/CVSROOT: No such file or directory" + CVSROOT=${CVSROOT_save}; export CVSROOT + fi + + # -d overrides CVS/Root + # + # Oddly enough, with CVS 1.10 I think this didn't work for + # local (that is, it would appear that CVS/Root would not + # get used, but would produce an error if it didn't exist). + dotest reposmv-5 "${testcvs} -d ${CVSROOT_MOVED} update" \ +"${SPROG} update: Updating \." + + # TODO: could also test various other things, like what if the + # user removes CVS/Root (which is legit). Or another set of + # tests would be if both repositories exist but we want to make + # sure that CVS is using the correct one. + + cd ../.. + rm -r imp-dir 1 + rm -rf root1 root2 + unset CVSROOT1 + ;; + + + + pserver) + # Test basic pserver functionality. + if $remote; then + if test -n "$remotehost"; then + # Don't even try. (The issue is getting servercvs & testcvs + # set correctly for the following tests. Some expect one access + # method and some another, which in $remotehost mode, means that + # sometimes the executables must run on one platform and + # sometimes another.) + continue + fi + save_servercvs=$servercvs + servercvs=$testcvs + # First set SystemAuth=no. Not really necessary, I don't + # think, but somehow it seems like the clean thing for + # the testsuite. + mkdir 1; cd 1 + dotest pserver-1 "$testcvs -Q co CVSROOT" "" + cd CVSROOT + echo "SystemAuth=no" >>config + dotest pserver-2 "$testcvs -q ci -m config-it" \ +"$CVSROOT_DIRNAME/CVSROOT/config,v <-- config +new revision: 1\.[0-9]*; previous revision: 1\.[0-9]* +$SPROG commit: Rebuilding administrative file database" + cat >$CVSROOT_DIRNAME/CVSROOT/passwd <<EOF +testme:q6WV9d2t848B2:$username +dontroot:q6WV9d2t848B2:root +anonymous::$username +$username: +willfail: :whocares +EOF + dotest_fail pserver-3 "$servercvs pserver" \ +"error 0 Server configuration missing --allow-root in inetd.conf" <<EOF +BEGIN AUTH REQUEST +$CVSROOT_DIRNAME +testme +Ay::'d +END AUTH REQUEST +EOF + + # Confirm that not sending a newline during auth cannot constitute + # a denial-of-service attack. This assumes that PATH_MAX is less + # than 65536 bytes. If PATH_MAX is larger than 65535 bytes, this + # test could hang indefinitely. + ${AWK} 'BEGIN { printf "0123456789abcdef" }' </dev/null >garbageseg + echo "BEGIN AUTH REQUEST" >garbageinput + i=0 + while test $i -lt 64; do + cat <garbageseg >>garbageseg2 + i=`expr $i + 1` + done + i=0 + while test $i -lt 64; do + cat <garbageseg2 >>garbageinput + i=`expr $i + 1` + done + dotest_fail pserver-auth-no-dos \ +"${servercvs} --allow-root=${CVSROOT_DIRNAME} pserver" \ +"$CPROG \\[pserver aborted\\]: error reading from net while validating pserver: Not enough space" \ +"$CPROG \\[pserver aborted\\]: error reading from net while validating pserver: Cannot allocate memory" <garbageinput + unset i + rm garbageseg garbageseg2 garbageinput + + # Sending the Root and noop before waiting for the + # "I LOVE YOU" is bogus, but hopefully we can get + # away with it. + dotest pserver-4 "$servercvs --allow-root=$CVSROOT_DIRNAME pserver" \ +"$DOTSTAR LOVE YOU +ok" <<EOF +BEGIN AUTH REQUEST +$CVSROOT_DIRNAME +testme +Ay::'d +END AUTH REQUEST +Root $CVSROOT_DIRNAME +noop +EOF + + dotest_fail pserver-4.2 \ +"$servercvs --allow-root=$CVSROOT_DIRNAME pserver" \ +"error 0: root not allowed" <<EOF +BEGIN AUTH REQUEST +$CVSROOT_DIRNAME +dontroot +Ay::'d +END AUTH REQUEST +EOF + + dotest pserver-5 "$servercvs --allow-root=$CVSROOT_DIRNAME pserver" \ +"$DOTSTAR LOVE YOU +E Protocol error: Root says \"$TESTDIR/1\" but pserver says \"$CVSROOT_DIRNAME\" +error " <<EOF +BEGIN AUTH REQUEST +$CVSROOT_DIRNAME +testme +Ay::'d +END AUTH REQUEST +Root $TESTDIR/1 +noop +EOF + + dotest pserver-5a "${servercvs} --allow-root=${CVSROOT_DIRNAME} pserver" \ +"${DOTSTAR} LOVE YOU +E Protocol error: init says \"${TESTDIR}/2\" but pserver says \"${CVSROOT_DIRNAME}\" +error " <<EOF +BEGIN AUTH REQUEST +${CVSROOT_DIRNAME} +testme +Ay::'d +END AUTH REQUEST +init ${TESTDIR}/2 +EOF + dotest_fail pserver-5b "test -d ${TESTDIR}/2" '' + + dotest pserver-5c "${servercvs} --allow-root=${CVSROOT_DIRNAME} pserver" \ +"${DOTSTAR} LOVE YOU +E init xxx must be an absolute pathname +error " <<EOF +BEGIN AUTH REQUEST +${CVSROOT_DIRNAME} +testme +Ay::'d +END AUTH REQUEST +init xxx +EOF + dotest_fail pserver-5d "test -d xxx" '' + + dotest_fail pserver-6 "${servercvs} --allow-root=${CVSROOT_DIRNAME} pserver" \ +"I HATE YOU" <<EOF +BEGIN AUTH REQUEST +${CVSROOT_DIRNAME} +testme +Ay::'d^b?hd +END AUTH REQUEST +EOF + + dotest_fail pserver-7 "${servercvs} --allow-root=${CVSROOT_DIRNAME} pserver" \ +"I HATE YOU" <<EOF +BEGIN VERIFICATION REQUEST +${CVSROOT_DIRNAME} +testme +Ay::'d^b?hd +END VERIFICATION REQUEST +EOF + + dotest pserver-8 "${servercvs} --allow-root=${CVSROOT_DIRNAME} pserver" \ +"${DOTSTAR} LOVE YOU" <<EOF +BEGIN VERIFICATION REQUEST +${CVSROOT_DIRNAME} +testme +Ay::'d +END VERIFICATION REQUEST +EOF + +# Tests pserver-9 through pserver-13 are about empty passwords + + # Test empty password (both sides) for aliased user + dotest pserver-9 "${servercvs} --allow-root=${CVSROOT_DIRNAME} pserver" \ +"${DOTSTAR} LOVE YOU" <<EOF +BEGIN AUTH REQUEST +${CVSROOT_DIRNAME} +anonymous +A +END AUTH REQUEST +EOF + + # Test empty password (server side only) for aliased user + dotest pserver-10 "${servercvs} --allow-root=${CVSROOT_DIRNAME} pserver" \ +"${DOTSTAR} LOVE YOU" <<EOF +BEGIN AUTH REQUEST +${CVSROOT_DIRNAME} +anonymous +Aanythingwouldworkhereittrulydoesnotmatter +END AUTH REQUEST +EOF + + # Test empty (both sides) password for non-aliased user + dotest pserver-11 "${servercvs} --allow-root=${CVSROOT_DIRNAME} pserver" \ +"${DOTSTAR} LOVE YOU" <<EOF +BEGIN AUTH REQUEST +${CVSROOT_DIRNAME} +${username} +A +END AUTH REQUEST +EOF + + # Test empty (server side only) password for non-aliased user + dotest pserver-12 "${servercvs} --allow-root=${CVSROOT_DIRNAME} pserver" \ +"${DOTSTAR} LOVE YOU" <<EOF +BEGIN AUTH REQUEST +${CVSROOT_DIRNAME} +${username} +Anypasswordwouldworkwhynotthisonethen +END AUTH REQUEST +EOF + + # Test failure of whitespace password + dotest_fail pserver-13 "${servercvs} --allow-root=${CVSROOT_DIRNAME} pserver" \ +"${DOTSTAR} HATE YOU" <<EOF +BEGIN AUTH REQUEST +${CVSROOT_DIRNAME} +willfail +Amquiteunabletocomeupwithinterestingpasswordsanymore +END AUTH REQUEST +EOF + + # The following tests are for read-only access + + # Check that readers can only read, everyone else can write + + echo anonymous >$CVSROOT_DIRNAME/CVSROOT/readers + + dotest pserver-14 "$servercvs --allow-root=$CVSROOT_DIRNAME pserver" \ +"$DOTSTAR LOVE YOU +M Concurrent Versions System (CVS) .* +ok" <<EOF +BEGIN AUTH REQUEST +$CVSROOT_DIRNAME +anonymous +Ay::'d +END AUTH REQUEST +Root $CVSROOT_DIRNAME +version +EOF + + dotest pserver-15 "$servercvs --allow-root=$CVSROOT_DIRNAME pserver" \ +"$DOTSTAR LOVE YOU +E $CPROG \\[server aborted\\]: .init. requires write access to the repository +error " <<EOF +BEGIN AUTH REQUEST +$CVSROOT_DIRNAME +anonymous +Ay::'d +END AUTH REQUEST +init $CVSROOT_DIRNAME +EOF + + dotest pserver-16 "${servercvs} --allow-root=${CVSROOT_DIRNAME} pserver" \ +"${DOTSTAR} LOVE YOU +M Concurrent Versions System (CVS) .* +ok" <<EOF +BEGIN AUTH REQUEST +${CVSROOT_DIRNAME} +testme +Ay::'d +END AUTH REQUEST +Root ${CVSROOT_DIRNAME} +version +EOF + + dotest pserver-17 "${servercvs} --allow-root=${CVSROOT_DIRNAME} pserver" \ +"${DOTSTAR} LOVE YOU +ok" <<EOF +BEGIN AUTH REQUEST +${CVSROOT_DIRNAME} +testme +Ay::'d +END AUTH REQUEST +init ${CVSROOT_DIRNAME} +EOF + + dotest pserver-18 "${servercvs} --allow-root=${CVSROOT_DIRNAME} pserver" \ +"${DOTSTAR} LOVE YOU +M Concurrent Versions System (CVS) .* +ok" <<EOF +BEGIN AUTH REQUEST +${CVSROOT_DIRNAME} +${username} +Ay::'d +END AUTH REQUEST +Root ${CVSROOT_DIRNAME} +version +EOF + + dotest pserver-19 "${servercvs} --allow-root=${CVSROOT_DIRNAME} pserver" \ +"${DOTSTAR} LOVE YOU +ok" <<EOF +BEGIN AUTH REQUEST +${CVSROOT_DIRNAME} +${username} +Anything +END AUTH REQUEST +init ${CVSROOT_DIRNAME} +EOF + + # Check that writers can write, everyone else can only read + # even if not listed in readers + + cat >${CVSROOT_DIRNAME}/CVSROOT/writers <<EOF +testme +EOF + + dotest pserver-20 "${servercvs} --allow-root=${CVSROOT_DIRNAME} pserver" \ +"${DOTSTAR} LOVE YOU +M Concurrent Versions System (CVS) .* +ok" <<EOF +BEGIN AUTH REQUEST +${CVSROOT_DIRNAME} +anonymous +Ay::'d +END AUTH REQUEST +Root ${CVSROOT_DIRNAME} +version +EOF + + dotest pserver-21 "${servercvs} --allow-root=${CVSROOT_DIRNAME} pserver" \ +"${DOTSTAR} LOVE YOU +E $CPROG \\[server aborted\\]: .init. requires write access to the repository +error " <<EOF +BEGIN AUTH REQUEST +${CVSROOT_DIRNAME} +anonymous +Ay::'d +END AUTH REQUEST +init ${CVSROOT_DIRNAME} +EOF + + dotest pserver-22 "${servercvs} --allow-root=${CVSROOT_DIRNAME} pserver" \ +"${DOTSTAR} LOVE YOU +M Concurrent Versions System (CVS) .* +ok" <<EOF +BEGIN AUTH REQUEST +${CVSROOT_DIRNAME} +testme +Ay::'d +END AUTH REQUEST +Root ${CVSROOT_DIRNAME} +version +EOF + + dotest pserver-23 "${servercvs} --allow-root=${CVSROOT_DIRNAME} pserver" \ +"${DOTSTAR} LOVE YOU +ok" <<EOF +BEGIN AUTH REQUEST +${CVSROOT_DIRNAME} +testme +Ay::'d +END AUTH REQUEST +init ${CVSROOT_DIRNAME} +EOF + + dotest pserver-24 "${servercvs} --allow-root=${CVSROOT_DIRNAME} pserver" \ +"${DOTSTAR} LOVE YOU +M Concurrent Versions System (CVS) .* +ok" <<EOF +BEGIN AUTH REQUEST +${CVSROOT_DIRNAME} +${username} +Ay::'d +END AUTH REQUEST +Root ${CVSROOT_DIRNAME} +version +EOF + + dotest pserver-25 "${servercvs} --allow-root=${CVSROOT_DIRNAME} pserver" \ +"${DOTSTAR} LOVE YOU +E $CPROG \\[server aborted\\]: .init. requires write access to the repository +error " <<EOF +BEGIN AUTH REQUEST +${CVSROOT_DIRNAME} +${username} +Anything +END AUTH REQUEST +init ${CVSROOT_DIRNAME} +EOF + + # Should work the same without readers + + rm ${CVSROOT_DIRNAME}/CVSROOT/readers + + dotest pserver-26 "${servercvs} --allow-root=${CVSROOT_DIRNAME} pserver" \ +"${DOTSTAR} LOVE YOU +M Concurrent Versions System (CVS) .* +ok" <<EOF +BEGIN AUTH REQUEST +${CVSROOT_DIRNAME} +anonymous +Ay::'d +END AUTH REQUEST +Root ${CVSROOT_DIRNAME} +version +EOF + + dotest pserver-27 "${servercvs} --allow-root=${CVSROOT_DIRNAME} pserver" \ +"${DOTSTAR} LOVE YOU +E $CPROG \\[server aborted\\]: .init. requires write access to the repository +error " <<EOF +BEGIN AUTH REQUEST +${CVSROOT_DIRNAME} +anonymous +Ay::'d +END AUTH REQUEST +init ${CVSROOT_DIRNAME} +EOF + + dotest pserver-28 "${servercvs} --allow-root=${CVSROOT_DIRNAME} pserver" \ +"${DOTSTAR} LOVE YOU +M Concurrent Versions System (CVS) .* +ok" <<EOF +BEGIN AUTH REQUEST +${CVSROOT_DIRNAME} +testme +Ay::'d +END AUTH REQUEST +Root ${CVSROOT_DIRNAME} +version +EOF + + dotest pserver-29 "${servercvs} --allow-root=${CVSROOT_DIRNAME} pserver" \ +"${DOTSTAR} LOVE YOU +ok" <<EOF +BEGIN AUTH REQUEST +${CVSROOT_DIRNAME} +testme +Ay::'d +END AUTH REQUEST +init ${CVSROOT_DIRNAME} +EOF + + dotest pserver-30 "${servercvs} --allow-root=${CVSROOT_DIRNAME} pserver" \ +"${DOTSTAR} LOVE YOU +M Concurrent Versions System (CVS) .* +ok" <<EOF +BEGIN AUTH REQUEST +${CVSROOT_DIRNAME} +${username} +Ay::'d +END AUTH REQUEST +Root ${CVSROOT_DIRNAME} +version +EOF + + dotest pserver-31 "${servercvs} --allow-root=${CVSROOT_DIRNAME} pserver" \ +"${DOTSTAR} LOVE YOU +E $CPROG \\[server aborted\\]: .init. requires write access to the repository +error " <<EOF +BEGIN AUTH REQUEST +${CVSROOT_DIRNAME} +${username} +Anything +END AUTH REQUEST +init ${CVSROOT_DIRNAME} +EOF + + # pserver used to try and print from the NULL pointer + # in this error message in this case + dotest_fail pserver-bufinit "${servercvs} pserver" \ +"$CPROG \[pserver aborted\]: unexpected EOF encountered during authentication" </dev/null + + # Clean up. + dotest pserver-cleanup-1 "${testcvs} -q up -pr1.1 config >config" "" + dotest pserver-cleanup-2 "${testcvs} -q ci -m config-it" \ +"$CVSROOT_DIRNAME/CVSROOT/config,v <-- config +new revision: 1\.[0-9]*; previous revision: 1\.[0-9]* +$SPROG commit: Rebuilding administrative file database" + + dokeep + cd ../.. + rm -r 1 + restore_adm + servercvs=$save_servercvs + fi # skip the whole thing for local + ;; + + + + server) + # Some tests of the server (independent of the client). + if $remote; then + save_servercvs=$servercvs + servercvs=$testcvs + dotest server-1 "${servercvs} server" \ +"E Protocol error: Root request missing +error " <<EOF +Directory bogus +mumble/bar +update +EOF + + # Could also test for relative pathnames here (so that crerepos-6a + # and crerepos-6b can use :fork:). + dotest server-2 "${servercvs} server" "ok" <<EOF +Set OTHER=variable +Set MYENV=env-value +init ${TESTDIR}/crerepos +EOF + dotest server-3 "test -d ${TESTDIR}/crerepos/CVSROOT" "" + + # Now some tests of gzip-file-contents (used by jCVS). + ${AWK} 'BEGIN { \ +printf "%c%c%c%c%c%c.6%c%c+I-.%c%c%c%c5%c;%c%c%c%c", \ +31, 139, 8, 64, 5, 7, 64, 3, 225, 2, 64, 198, 185, 5, 64, 64, 64}' \ + </dev/null | ${TR} '\100' '\000' >gzipped.dat + # Note that the CVS client sends "-b 1.1.1", and this + # test doesn't. But the server also defaults to that. + cat <<EOF >session.dat +Root ${TESTDIR}/crerepos +UseUnchanged +gzip-file-contents 3 +Argument -m +Argument msg +Argumentx +Argument dir1 +Argument tag1 +Argument tag2 +Directory . +${TESTDIR}/crerepos +Modified file1 +u=rw,g=r,o=r +z25 +EOF + cat gzipped.dat >>session.dat + echo import >>session.dat + dotest server-4 "${servercvs} server" \ +"M N dir1/file1 +M +M No conflicts created by this import +M +ok" <session.dat + dotest server-5 \ +"${testcvs} -q -d ${TESTDIR}/crerepos co -p dir1/file1" "test" + + # OK, here are some notify tests. + dotest server-6 "${servercvs} server" \ +"Notified \./ +${TESTDIR}/crerepos/dir1/file1 +ok" <<EOF +Root ${TESTDIR}/crerepos +Directory . +${TESTDIR}/crerepos/dir1 +Notify file1 +E Fri May 7 13:21:09 1999 -0000 myhost some-work-dir EUC +noop +EOF + # Sending the second "noop" before waiting for the output + # from the first is bogus but hopefully we can get away + # with it. + dotest server-7 "${servercvs} server" \ +"M file1 $username Fri May 7 13:21:09 1999 -0000 myhost some-work-dir +Notified \./ +${TESTDIR}/crerepos/dir1/file1 +ok +M file1 $username Fri May 7 13:21:09 1999 -0000 myhost some-work-dir +Notified \./ +${TESTDIR}/crerepos/dir1/file1 +ok" <<EOF +Root ${TESTDIR}/crerepos +Directory . +${TESTDIR}/crerepos/dir1 +Notify file1 +E Fri May 7 13:21:09 1999 -0000 myhost some-work-dir EUC +noop +Notify file1 +E The 57th day of Discord in the YOLD 3165 myhost some-work-dir EUC +noop +EOF + + # OK, now test a few error conditions. + # FIXCVS: should give "error" and no "Notified", like server-9 + dotest server-8 "${servercvs} server" \ +"M file1 $username The 57th day of Discord in the YOLD 3165 myhost some-work-dir +E $CPROG server: invalid character in editor value +Notified \./ +${TESTDIR}/crerepos/dir1/file1 +ok" <<EOF +Root ${TESTDIR}/crerepos +Directory . +${TESTDIR}/crerepos/dir1 +Notify file1 +E Setting Orange, the 52th day of Discord in the YOLD 3165 myhost some-work-dir EUC +noop +EOF + + dotest server-9 "${servercvs} server" \ +"E Protocol error; misformed Notify request +error " <<EOF +Root ${TESTDIR}/crerepos +Directory . +${TESTDIR}/crerepos/dir1 +Notify file1 +E Setting Orange+57th day of Discord myhost some-work-dir EUC +noop +EOF + + # First demonstrate an interesting quirk in the protocol. + # The "watchers" request selects the files to operate based + # on files which exist in the working directory. So if we + # don't send "Entry" or the like, it won't do anything. + # Wants to be documented in cvsclient.texi... + dotest server-10 "${servercvs} server" "ok" <<EOF +Root ${TESTDIR}/crerepos +Directory . +${TESTDIR}/crerepos/dir1 +watchers +EOF + # See if "watchers" and "editors" display the right thing. + dotest server-11 "${servercvs} server" \ +"M file1 ${username} tedit tunedit tcommit +ok" <<EOF +Root ${TESTDIR}/crerepos +Directory . +${TESTDIR}/crerepos/dir1 +Entry /file1/1.1//// +watchers +EOF + dotest server-12 "${servercvs} server" \ +"M file1 ${username} The 57th day of Discord in the YOLD 3165 myhost some-work-dir +ok" <<EOF +Root ${TESTDIR}/crerepos +Directory . +${TESTDIR}/crerepos/dir1 +Entry /file1/1.1//// +editors +EOF + + # Now do an unedit. + dotest server-13 "${servercvs} server" \ +"Notified \./ +${TESTDIR}/crerepos/dir1/file1 +ok" <<EOF +Root ${TESTDIR}/crerepos +Directory . +${TESTDIR}/crerepos/dir1 +Notify file1 +U 7 May 1999 15:00 -0000 myhost some-work-dir EUC +noop +EOF + + # Now try "watchers" and "editors" again. + dotest server-14 "${servercvs} server" "ok" <<EOF +Root ${TESTDIR}/crerepos +Directory . +${TESTDIR}/crerepos/dir1 +watchers +EOF + dotest server-15 "${servercvs} server" "ok" <<EOF +Root ${TESTDIR}/crerepos +Directory . +${TESTDIR}/crerepos/dir1 +editors +EOF + + # Test that the global `-l' option is ignored nonfatally. + dotest server-16 "${testcvs} server" \ +"E $CPROG server: WARNING: global \`-l' option ignored\. +ok" <<EOF +Global_option -l +noop +EOF + + # There used to be some exploits based on malformed Entry requests + dotest server-17 "$testcvs server" \ +"E protocol error: Malformed Entry +error " <<EOF +Root $TESTDIR/crerepos +Directory . +$TESTDIR/crerepos/dir1 +Entry X/file1/1.1//// +noop +EOF + + dotest server-18 "$testcvs server" \ +"E protocol error: Malformed Entry +error " <<EOF +Root $TESTDIR/crerepos +Directory . +$TESTDIR/crerepos/dir1 +Entry /CC/CC/CC +noop +EOF + + # Check that the config file may be set from the command line. + # But first verify the default config produces no error messages. + dotest server-19 "$testcvs server" \ +"ok" <<EOF +Root $TESTDIR/crerepos +Directory . +$TESTDIR/crerepos +noop +EOF + echo THIS-CONFIG-OPTION-IS-BAD=XXX >$TESTDIR/newconfig + dotest_fail server-20 "$testcvs server -c $TESTDIR/newconfig" \ +"E $SPROG \[server aborted\]: Invalid path to config file specified: \`$TESTDIR/newconfig'" <<EOF +Root $TESTDIR/crerepos +Directory . +$TESTDIR/crerepos +noop +EOF + dotest_fail server-21 \ +"$testcvs server -c /etc/cvs/this-shouldnt-exist" \ +"E $SPROG \[server aborted\]: Failed to resolve path: \`/etc/cvs/this-shouldnt-exist': No such file or directory" <<EOF +Root $TESTDIR/crerepos +Directory . +$TESTDIR/crerepos +noop +EOF + + # Now make sure that the config file can't be set via the user's + # .cvsrc. + echo server -c $TESTDIR/newconfig >$HOME/.cvsrc + dotest server-22 "$testcvs server" \ +"ok" <<EOF +Root $TESTDIR/crerepos +Directory . +$TESTDIR/crerepos +noop +EOF + + dokeep + rm -rf $TESTDIR/crerepos + rm gzipped.dat session.dat + rm $TESTDIR/newconfig $HOME/.cvsrc + servercvs=$save_servercvs + fi # skip the whole thing for local + ;; + + + + server2) + # More server tests, in particular testing that various + # possible security holes are plugged. + if $remote; then + if test -n "$remotehost"; then + # Don't even try. (The issue is getting servercvs & testcvs + # set correctly for the following tests. Some expect one access + # method and some another, which in $remotehost mode, means that + # sometimes the executables must run on one platform and + # sometimes another.) + continue + fi + save_servercvs=$servercvs + servercvs=$testcvs + dotest server2-1 "${servercvs} server" \ +"E protocol error: directory '${CVSROOT_DIRNAME}/\.\./dir1' not within root '${CVSROOT_DIRNAME}' +error " <<EOF +Root ${CVSROOT_DIRNAME} +Directory . +${CVSROOT_DIRNAME}/../dir1 +noop +EOF + + dotest server2-2 "${servercvs} server" \ +"E protocol error: directory '${CVSROOT_DIRNAME}dir1' not within root '${CVSROOT_DIRNAME}' +error " <<EOF +Root ${CVSROOT_DIRNAME} +Directory . +${CVSROOT_DIRNAME}dir1 +noop +EOF + + dotest 2-3 "${servercvs} server" \ +"E protocol error: directory '${TESTDIR}' not within root '${CVSROOT_DIRNAME}' +error " <<EOF +Root ${CVSROOT_DIRNAME} +Directory . +${TESTDIR} +noop +EOF + + # OK, now a few tests for the rule that one cannot pass a + # filename containing a slash to Modified, Is-modified, + # Notify, Questionable, or Unchanged. For completeness + # we'd try them all. For lazyness/conciseness we don't. + dotest server2-4 "${servercvs} server" \ +"E protocol error: directory 'foo/bar' not within current directory +error " <<EOF +Root ${CVSROOT_DIRNAME} +Directory . +${CVSROOT_DIRNAME} +Unchanged foo/bar +noop +EOF + servercvs=$save_servercvs + fi + ;; + + + + client) + # Some tests of the client (independent of the server). + if $remote; then :; else + remoteonly client + continue + fi + + if $proxy; then + # Skip these tests in proxy mode since they assume we are not + # writing through a proxy server. There is no writeproxy-client + # test currently. The writeproxy & writeproxy-noredirect tests + # test the writeproxy server. + notproxy client + continue + fi + + cat >$TESTDIR/serveme <<EOF +#!$TESTSHELL +# This is admittedly a bit cheezy, in the sense that we make lots +# of assumptions about what the client is going to send us. +# We don't mention Repository, because current clients don't require it. +# Sending these at our own pace, rather than waiting for the client to +# make the requests, is bogus, but hopefully we can get away with it. +echo "Valid-requests Root Valid-responses valid-requests Directory Entry Modified Unchanged Argument Argumentx ci co update" +echo "ok" +echo "M special message" +echo "Created first-dir/" +echo "$CVSROOT_DIRNAME/first-dir/file1" +echo "/file1/1.1///" +echo "u=rw,g=rw,o=rw" +echo "4" +echo "xyz" +echo "ok" +cat >/dev/null +EOF + # Cygwin. Pthffffffffft! + if test -n "$remotehost"; then + $CVS_RSH $remotehost "chmod +x $TESTDIR/serveme" + else + chmod +x $TESTDIR/serveme + fi + save_CVS_SERVER=$CVS_SERVER + CVS_SERVER=$TESTDIR/serveme; export CVS_SERVER + mkdir 1; cd 1 + dotest_fail client-1 "$testcvs -q co first-dir" \ +"$CPROG \[checkout aborted\]: This server does not support the global -q option$DOTSTAR" + dotest client-2 "$testcvs co first-dir" "special message" + + cat >$TESTDIR/serveme <<EOF +#!$TESTSHELL +echo "Valid-requests Root Valid-responses valid-requests Directory Entry Modified Unchanged Argument Argumentx ci co update" +echo "ok" +echo "M merge-it" +echo "Copy-file ./" +echo "$CVSROOT_DIRNAME/first-dir/file1" +echo "$TESTDIR/bogus/.#file1.1.1" +echo "Merged ./" +echo "$CVSROOT_DIRNAME/first-dir/file1" +echo "/file1/1.2///" +echo "u=rw,g=rw,o=rw" +echo "4" +echo "abd" +echo "ok" +cat >/dev/null +EOF + cd first-dir + mkdir $TESTDIR/bogus + # The ${DOTSTAR} is to match a potential "broken pipe" if the + # client exits before the server script sends everything + dotest_fail client-3 "$testcvs update" \ +"merge-it +$CPROG \[update aborted\]: protocol error: Copy-file tried to specify director$DOTSTAR" + cat >$TESTDIR/serveme <<EOF +#!$TESTSHELL +echo "Valid-requests Root Valid-responses valid-requests Directory Entry Modified Unchanged Argument Argumentx ci co update" +echo "ok" +echo "M merge-it" +echo "Copy-file ./" +echo "$CVSROOT_DIRNAME/first-dir/file1" +echo ".#file1.1.1" +echo "Merged ./" +echo "$CVSROOT_DIRNAME/first-dir/file1" +echo "/file1/1.2///" +echo "u=rw,g=rw,o=rw" +echo "4" +echo "abc" +echo "ok" +cat >/dev/null +EOF + dotest client-4 "$testcvs update" "merge-it" + dotest client-5 "cat .#file1.1.1" "xyz" + dotest client-6 "cat CVS/Entries" "/file1/1.2/[A-Za-z0-9 :]*// +D" + dotest client-7 "cat file1" "abc" + + cat >$TESTDIR/serveme <<EOF +#!$TESTSHELL +echo "Valid-requests Root Valid-responses valid-requests Directory Entry Modified Unchanged Argument Argumentx ci co update" +echo "ok" +echo "M OK, whatever" +echo "ok" +cat >$TESTDIR/client.tmp +EOF + chmod u=rw,go= file1 + # By specifying the time zone in local time, we don't + # know exactly how that will translate to GMT. + dotest client-8 "$testcvs update -D 99-10-04" "OK, whatever" + # String 2 below is Cygwin again - ptoooey. + dotest client-9 "cat $TESTDIR/client.tmp" \ +"Root $CVSROOT_DIRNAME +Valid-responses [-a-zA-Z ]* +valid-requests +Argument -D +Argument [34] Oct 1999 [0-9][0-9]:00:00 -0000 +Argument -- +Directory \. +$CVSROOT_DIRNAME/first-dir +Entry /file1/1\.2/// +Modified file1 +u=rw,g=,o= +4 +abc +update" \ +"Root $CVSROOT_DIRNAME +Valid-responses [-a-zA-Z ]* +valid-requests +Argument -D +Argument [34] Oct 1999 [0-9][0-9]:00:00 -0000 +Argument -- +Directory \. +$CVSROOT_DIRNAME/first-dir +Entry /file1/1\.2/// +Modified file1 +u=rw,g=r,o=r +4 +abc +update" + + # The following test tests what was a potential client exploit in + # CVS versions 1.11.14 and CVS versions 1.12.6 and earlier. This + # exploit would allow a trojan server to create arbitrary files, + # anywhere the user had write permissions, even outside of the + # user's sandbox. + cat >$HOME/.bashrc <<EOF +#!$TESTSHELL +# This is where login scripts would usually be +# stored. +EOF + cat >$TESTDIR/serveme <<EOF +#!$TESTSHELL +echo "Valid-requests Root Valid-responses valid-requests Directory Entry Modified Unchanged Argument Argumentx ci co update" +echo "ok" +echo "Rcs-diff $HOME/" +echo "$HOME/.bashrc" +echo "/.bashrc/73.50///" +echo "u=rw,g=rw,o=rw" +echo "20" +echo "a1 1" +echo "echo 'gotcha!'" +echo "ok" +cat >/dev/null +EOF + + # If I don't run the following sleep between the above cat and + # the following calls to dotest, sometimes the serveme file isn't + # completely written yet by the time CVS tries to execute it, + # causing the shell to intermittantly report syntax errors (usually + # early EOF). There's probably a new race condition here, but this + # works. + # + # Incidentally, I can reproduce this behavior with Linux 2.4.20 and + # Bash 2.05 or Bash 2.05b. + sleep 1 + dotest_fail client-10 "$testcvs update" \ +"$CPROG update: Server attempted to update a file via an invalid pathname: +$CPROG \[update aborted\]: \`$HOME/.bashrc'\." + + # A second try at a client exploit. This one never actually + # failed in the past, but I thought it wouldn't hurt to add a test. + cat >$TESTDIR/serveme <<EOF +#!$TESTSHELL +echo "Valid-requests Root Valid-responses valid-requests Directory Entry Modified Unchanged Argument Argumentx ci co update" +echo "ok" +echo "Rcs-diff ./" +echo "$HOME/.bashrc" +echo "/.bashrc/73.50///" +echo "u=rw,g=rw,o=rw" +echo "20" +echo "a1 1" +echo "echo 'gotcha!'" +echo "ok" +cat >/dev/null +EOF + sleep 1 + dotest_fail client-11 "$testcvs update" \ +"$CPROG \[update aborted\]: patch original file \./\.bashrc does not exist" + + # A third try at a client exploit. This one did used to fail like + # client-10. + cat >$TESTDIR/serveme <<EOF +#!$TESTSHELL +echo "Valid-requests Root Valid-responses valid-requests Directory Entry Modified Unchanged Argument Argumentx ci co update" +echo "ok" +echo "Rcs-diff ../../home/" +echo "../../.bashrc" +echo "/.bashrc/73.50///" +echo "u=rw,g=rw,o=rw" +echo "20" +echo "a1 1" +echo "echo 'gotcha!'" +echo "ok" +cat >/dev/null +EOF + sleep 1 + dotest_fail client-12 "$testcvs update" \ +"$CPROG update: Server attempted to update a file via an invalid pathname: +$CPROG \[update aborted\]: \`\.\./\.\./home/.bashrc'\." + + # Try the same exploit using the Created response. + cat >$TESTDIR/serveme <<EOF +#!$TESTSHELL +echo "Valid-requests Root Valid-responses valid-requests Directory Entry Modified Unchanged Argument Argumentx ci co update" +echo "ok" +echo "Created $HOME/" +echo "$HOME/.bashrc" +echo "/.bashrc/73.50///" +echo "u=rw,g=rw,o=rw" +echo "26" +echo "#! $TESTSHELL" +echo "echo 'gotcha!'" +echo "ok" +cat >/dev/null +EOF + sleep 1 + dotest_fail client-13 "$testcvs update" \ +"$CPROG update: Server attempted to update a file via an invalid pathname: +$CPROG \[update aborted\]: \`$HOME/.bashrc'\." + + # Now try using the Update-existing response + cat >$TESTDIR/serveme <<EOF +#!$TESTSHELL +echo "Valid-requests Root Valid-responses valid-requests Directory Entry Modified Unchanged Argument Argumentx ci co update" +echo "ok" +echo "Update-existing ../../home/" +echo "../../home/.bashrc" +echo "/.bashrc/73.50///" +echo "u=rw,g=rw,o=rw" +echo "26" +echo "#! $TESTSHELL" +echo "echo 'gotcha!'" +echo "ok" +cat >/dev/null +EOF + sleep 1 + dotest_fail client-14 "$testcvs update" \ +"$CPROG update: Server attempted to update a file via an invalid pathname: +$CPROG \[update aborted\]: \`\.\./\.\./home/.bashrc'\." + + # Try the same exploit using the Merged response. + cat >$TESTDIR/serveme <<EOF +#!$TESTSHELL +echo "Valid-requests Root Valid-responses valid-requests Directory Entry Modified Unchanged Argument Argumentx ci co update" +echo "ok" +echo "Merged $HOME/" +echo "$HOME/.bashrc" +echo "/.bashrc/73.50///" +echo "u=rw,g=rw,o=rw" +echo "26" +echo "#! $TESTSHELL" +echo "echo 'gotcha!'" +echo "ok" +cat >/dev/null +EOF + sleep 1 + dotest_fail client-15 "$testcvs update" \ +"$CPROG update: Server attempted to update a file via an invalid pathname: +$CPROG \[update aborted\]: \`$HOME/.bashrc'\." + + # Now try using the Updated response + cat >$TESTDIR/serveme <<EOF +#!$TESTSHELL +echo "Valid-requests Root Valid-responses valid-requests Directory Entry Modified Unchanged Argument Argumentx ci co update" +echo "ok" +echo "Updated ../../home/" +echo "../../home/.bashrc" +echo "/.bashrc/73.50///" +echo "u=rw,g=rw,o=rw" +echo "26" +echo "#! $TESTSHELL" +echo "echo 'gotcha!'" +echo "ok" +cat >/dev/null +EOF + sleep 1 + dotest_fail client-16 "$testcvs update" \ +"$CPROG update: Server attempted to update a file via an invalid pathname: +$CPROG \[update aborted\]: \`\.\./\.\./home/.bashrc'\." + + # Try the same exploit using the Copy-file response. + # As far as I know, Copy-file was never exploitable either. + cat >$TESTDIR/serveme <<EOF +#!$TESTSHELL +echo "Valid-requests Root Valid-responses valid-requests Directory Entry Modified Unchanged Argument Argumentx ci co update" +echo "ok" +echo "Created ." +echo "./innocuous" +echo "/innocuous/73.50///" +echo "u=rw,g=rw,o=rw" +echo "26" +echo "#! $TESTSHELL" +echo "echo 'gotcha!'" +echo "Copy-file ." +echo "./innocuous" +echo "$HOME/innocuous" +echo "ok" +cat >/dev/null +EOF + sleep 1 + dotest_fail client-18 "$testcvs update" \ +"$CPROG \[update aborted\]: protocol error: Copy-file tried to specify directory" + + # And verify that none of the exploits was successful. + dotest client-19 "cat $HOME/.bashrc" \ +"#!$TESTSHELL +# This is where login scripts would usually be +# stored\." + + # Check that the client detects redirect loops. + cat >$TESTDIR/serveme <<EOF +#!$TESTSHELL +echo "Valid-requests Root Valid-responses valid-requests Command-prep Referrer Repository Directory Relative-directory Max-dotdot Static-directory Sticky Entry Kopt Checkin-time Modified Is-modified UseUnchanged Unchanged Notify Hostname LocalDir Questionable Argument Argumentx Global_option Gzip-stream wrapper-sendme-rcsOptions Set Gssapi-authenticate expand-modules ci co update diff log rlog list rlist global-list-quiet ls add remove update-patches gzip-file-contents status rdiff tag rtag import admin export history release watch-on watch-off watch-add watch-remove watchers editors edit init annotate rannotate noop version" +echo "ok" +echo "Redirect $CVSROOT" + +# Eat up data from the client to avoid broken pipe errors. +cat >/dev/null +EOF + echo newstuff >file1 + sleep 1 + dotest_fail client-20 "$testcvs ci" \ +"$CPROG commit: Examining \. +$CPROG \[commit aborted\]: \`Redirect' loop detected\. Server misconfiguration$QUESTION" + + dokeep + cd ../.. + rm -r 1 + rmdir $TESTDIR/bogus + rm $TESTDIR/serveme $HOME/.bashrc + CVS_SERVER=$save_CVS_SERVER; export CVS_SERVER + ;; + + + + dottedroot) + # Check that a CVSROOT with a "." in the name will work. + + if $proxy; then + # don't even try + continue + fi + + CVSROOT_save=${CVSROOT} + CVSROOT_DIRNAME_save=${CVSROOT_DIRNAME} + CVSROOT_DIRNAME=${TESTDIR}/cvs.root + CVSROOT=`newroot ${CVSROOT_DIRNAME}` + + dotest dottedroot-init-1 "${testcvs} init" "" + mkdir dir1 + mkdir dir1/dir2 + echo version1 >dir1/dir2/file1 + cd dir1 + dotest dottedroot-1 "${testcvs} import -m '' module1 AUTHOR INITIAL" \ +"${SPROG} import: Importing ${CVSROOT_DIRNAME}/module1/dir2 +N module1/dir2/file1 + +No conflicts created by this import" + cd .. + + # This is the test that used to cause an assertion failure + # in recurse.c:do_recursion(). + dotest dottedroot-2 "${testcvs} co -rINITIAL module1" \ +"${SPROG} checkout: Updating module1 +${SPROG} checkout: Updating module1/dir2 +U module1/dir2/file1" + + dokeep + + rm -rf ${CVSROOT_DIRNAME} + rm -r dir1 module1 + CVSROOT_DIRNAME=${CVSROOT_DIRNAME_save} + CVSROOT=${CVSROOT_save} + ;; + + + + fork) + # Test that the server defaults to the correct executable in :fork: + # mode. See the note in the TODO at the end of this file about this. + # + # This test and client should be left after all other references to + # CVS_SERVER are removed from this script. + # + # The client series of tests already tests that CVS_SERVER is + # working, but that test might be better here. + if $remote; then + if test -n "$remotehost"; then + # Don't even try. If our caller specified a remotehost, our + # access method has been determined anyhow. + continue + fi + mkdir fork; cd fork + save_CVS_SERVER=$CVS_SERVER + unset CVS_SERVER + # So looking through $PATH for cvs won't work... + echo "echo junk" >cvs + chmod a+x cvs + save_PATH=$PATH; PATH=.:$PATH + # The second error message below is for testing clients without + # server support. + if ${testcvs_server_support}; then + dotest fork-1 "$testcvs -d:fork:$CVSROOT_DIRNAME version" \ +'Client: \(.*\) +Server: \1' + else + dotest_fail fork-1-noss \ +"$testcvs -d:fork:$CVSROOT_DIRNAME version" \ +"Client: .* +Server: ${CPROG} version: You must set the CVS_SERVER environment variable when +${CPROG} version: using the :fork: access method\. +${CPROG} \[version aborted\]: This CVS was not compiled with server support\." + fi + + CVS_SERVER=${save_CVS_SERVER}; export CVS_SERVER + unset save_CVS_SERVER + PATH=$save_PATH; unset save_PATH + + dokeep + cd .. + rm -r fork + fi + ;; + + + + commit-add-missing) + # Make sure that a commit fails when a `cvs add'ed file has + # been removed from the working directory. + + mkdir 1; cd 1 + module=c-a-m + echo > unused-file + dotest commit-add-missing-1 \ + "$testcvs -Q import -m. $module X Y" '' + + file=F + # Check it out and tag it. + dotest commit-add-missing-2 "$testcvs -Q co $module" '' + cd $module + dotest commit-add-missing-3 "$testcvs -Q tag -b B" '' + echo v1 > $file + dotest commit-add-missing-4 "$testcvs -Q add $file" '' + rm -f $file + dotest_fail commit-add-missing-5 "$testcvs -Q ci -m. $file" \ +"${SPROG} commit: Up-to-date check failed for .$file' +${SPROG} \[commit aborted\]: correct above errors first!" + + dotest + cd ../.. + rm -rf 1 + modify_repo rm -rf $CVSROOT_DIRNAME/$module + ;; + + + + commit-d) + # Check that top-level commits work when CVS/Root + # is overridden by cvs -d. + + mkdir -p 1/subdir; cd 1 + touch file1 subdir/file2 + dotest commit-d-1 "$testcvs -Q import -m. c-d-c X Y" "" + dotest commit-d-2 "$testcvs -Q co c-d-c" "" + cd c-d-c + echo change >>file1; echo another change >>subdir/file2 + # Changing working root, then override with -d + echo nosuchhost:/cvs > CVS/Root + dotest commit-d-3 "$testcvs -q -d '$CVSROOT' commit -m." \ +"$CVSROOT_DIRNAME/c-d-c/file1,v <-- file1 +new revision: 1.2; previous revision: 1.1 +$CVSROOT_DIRNAME/c-d-c/subdir/file2,v <-- subdir/file2 +new revision: 1.2; previous revision: 1.1" + + dokeep + cd ../.. + rm -rf 1 cvsroot/c-d-c + ;; + + + + template) + # Check that the CVS/Template directory is being + # properly created. + modify_repo mkdir -p $CVSROOT_DIRNAME/first/subdir + modify_repo mkdir $CVSROOT_DIRNAME/second + mkdir template; cd template + + # check that no CVS/Template is created for an empty rcsinfo + # Note: For cvs clients with no Clear-template response, the + # CVS/Template file will exist and be zero bytes in length. + dotest template-empty-1 "${testcvs} -Q co first" '' + dotest template-empty-2 \ +"test ! -s first/CVS/Template" '' + dotest template-empty-3 \ +"test ! -s first/subdir/CVS/Template" '' + rm -fr first + + # create some template files + echo 'CVS: the default template' > ${TESTDIR}/template/temp.def + echo 'CVS: the first template' > ${TESTDIR}/template/temp.first + echo 'CVS: the subdir template' > ${TESTDIR}/template/temp.subdir + + dotest template-rcsinfo-1 "${testcvs} -Q co CVSROOT" '' + cd CVSROOT + echo DEFAULT ${TESTDIR}/template/temp.def >>rcsinfo + dotest template-rcsinfo-2 "$testcvs -Q ci -m." + # Make sure we get the update without a commit. + dotest template-rcsinfo-3 "${testcvs} -Q ci -m." '' + # Did the CVSROOT/CVS/Template file get the updated version? + if $remote; then + dotest template-rcsinfo-4r \ +"cmp CVS/Template ${TESTDIR}/template/temp.def" '' + else + dotest template-rcsinfo-4 \ +"test ! -f CVS/Template" '' + fi + echo "^first/subdir ${TESTDIR}/template/temp.subdir" >>rcsinfo + echo "^first ${TESTDIR}/template/temp.first" >>rcsinfo + dotest template-rcsinfo-4.1 "${testcvs} -Q ci -m. rcsinfo" + # Did the CVSROOT/CVS/Template file get the updated version? + if $remote; then + dotest template-rcsinfo-5r \ +"cmp CVS/Template ${TESTDIR}/template/temp.def" '' + else + dotest template-rcsinfo-5 \ +"test ! -f CVS/Template" '' + fi + cd .. + + # Now checkout the first and second modules and see + # if the proper template has been provided for each + dotest template-first "${testcvs} co first second" \ +"${SPROG} checkout: Updating first +${SPROG} checkout: Updating first/subdir +${SPROG} checkout: Updating second" + + if $remote; then + # When in client/server CVS/Template must exist + dotest template-first-r-1 "test -f first/CVS/Template" '' + dotest template-first-r-2 "test -f first/subdir/CVS/Template" '' + dotest template-first-r-3 "test -f second/CVS/Template" '' + # The value of the CVS/Template should be equal to the + # file called out in the rcsinfo file. + dotest template-first-r-4 \ +"cmp first/CVS/Template ${TESTDIR}/template/temp.first" '' + dotest template-first-r-5 \ +"cmp first/subdir/CVS/Template ${TESTDIR}/template/temp.subdir" '' + dotest template-first-r-6 \ +"cmp second/CVS/Template ${TESTDIR}/template/temp.def" '' + else + # When in local mode CVS/Template must NOT exist + dotest_fail template-first-1 "test -f first/CVS/Template" '' + dotest_fail template-first-2 "test -f first/subdir/CVS/Template" '' + dotest_fail template-first-3 "test -f second/CVS/Template" '' + fi + + # Next, create a new subdirectory and see if it gets the + # correct template or not + cd second + mkdir otherdir + dotest template-add-1 "${testcvs} add otherdir" \ +"Directory ${CVSROOT_DIRNAME}/second/otherdir added to the repository" + if $remote; then + dotest template-add-2r \ +"cmp otherdir/CVS/Template ${TESTDIR}/template/temp.def" '' + else + dotest_fail template-add-2 "test -f otherdir/CVS/Template" '' + fi + cd .. + + # Update the remote template. Then see if doing an + # update of a checked out tree will properly update + # the CVS/Template files. + echo 'CVS: Line two' >> ${TESTDIR}/template/temp.def + echo 'CVS: Line two' >> ${TESTDIR}/template/temp.first + echo 'CVS: Line two' >> ${TESTDIR}/template/temp.subdir + dotest template-second "${testcvs} update first second" \ +"${SPROG} update: Updating first +${SPROG} update: Updating first/subdir +${SPROG} update: Updating second +${SPROG} update: Updating second/otherdir" + + if $remote; then + dotest template-second-r-1 \ +"cmp first/CVS/Template ${TESTDIR}/template/temp.first" '' + dotest template-second-r-2 \ +"cmp first/subdir/CVS/Template ${TESTDIR}/template/temp.subdir" '' + dotest template-second-r-3 \ +"cmp second/CVS/Template ${TESTDIR}/template/temp.def" '' + dotest template-second-r-4 \ +"cmp second/otherdir/CVS/Template ${TESTDIR}/template/temp.def" '' + else + # When in local mode CVS/Template must NOT exist + dotest_fail template-second-1 "test -f CVS/Template" '' + dotest_fail template-second-2 "test -f subdir/CVS/Template" '' + dotest_fail template-second-3 "test -f second/CVS/Template" '' + dotest_fail template-second-4 \ +"test -f second/otherdir/CVS/Template" '' + fi + # Update the remote template with a zero-length template + : > ${TESTDIR}/template/temp.def + dotest template-third-1 "${testcvs} update second" \ +"${SPROG} update: Updating second +${SPROG} update: Updating second/otherdir" + + if $remote; then + dotest_fail template-third-r-2 "test -s second/CVS/Template" '' + dotest_fail template-third-r-3 "test -s second/otherdir/CVS/Template" '' + else + dotest_fail template-third-2 "test -f second/CVS/Template" '' + dotest_fail template-third-3 \ +"test -f second/otherdir/CVS/Template" '' + fi + + # fun with remote protocols and tags + if $remote; then + cd second + echo hello > file1 + dotest template-tag-r-1 "${testcvs} -Q add file1" '' + dotest template-tag-r-2 "${testcvs} -Q commit -madd file1" + dotest template-tag-r-3 "${testcvs} -q tag tag" 'T file1' + rm ${CVSROOT_DIRNAME}/CVSROOT/val-tags + cd .. + rm -fr second + dotest template-tag-r-4 "${testcvs} -Q co -rtag second" '' + fi + + cd CVSROOT + dotest template-norcsinfo-1 "${testcvs} up" \ +"${SPROG} update: Updating \." + # Did the CVSROOT/CVS/Template file get the updated version? + if $remote; then + dotest template-norcsinfo-r-2 \ +"cmp CVS/Template ${TESTDIR}/template/temp.def" '' + else + dotest_fail template-norcsinfo-2 "test -f CVS/Template" '' + fi + + : > rcsinfo + dotest template-norcsinfo-3 "${testcvs} -Q ci -m. rcsinfo" + # Did the CVSROOT/CVS/Template file get the updated version? + # The file should be gone or of zero length. + dotest template-norcsinfo-4 \ +"test ! -s CVS/Template" '' + cd .. + + dotest template-norcsinfo-5 "${testcvs} update first" \ +"${SPROG} update: Updating first +${SPROG} update: Updating first/subdir" + + # Note: For cvs clients with no Clear-template response, the + # CVS/Template file will exist and be zero bytes in length. + dotest template-norcsinfo-6 \ +"test ! -s first/CVS/Template" '' + dotest template-norcsinfo-7 \ +"test ! -s first/subdir/CVS/Template" '' + + dokeep + + # cleanup + modify_repo rm -rf $CVSROOT_DIRNAME/first $CVSROOT_DIRNAME/second + restore_adm + cd .. + rm -rf template + ;; + + + + writeproxy) + # Various tests for a read-only CVS mirror set up as a write-proxy + # for a central server. + # + # These tests are only meaningful in client/server mode. + if $remote; then :; else + remoteonly writeproxy + continue + fi + + if $noredirect; then + notnoredirect writeproxy + continue + fi + + require_rsync + if test $? -eq 77; then + skip writeproxy "$skipreason" + continue + fi + + PRIMARY_CVSROOT_DIRNAME_save=$PRIMARY_CVSROOT_DIRNAME + PRIMARY_CVSROOT_save=$PRIMARY_CVSROOT + PRIMARY_CVSROOT_DIRNAME=$TESTDIR/primary_cvsroot + PRIMARY_CVSROOT=`newroot $PRIMARY_CVSROOT_DIRNAME` + SECONDARY_CVSROOT_DIRNAME_save=$SECONDARY_CVSROOT_DIRNAME + SECONDARY_CVSROOT_save=$SECONDARY_CVSROOT + SECONDARY_CVSROOT_DIRNAME=$TESTDIR/writeproxy_cvsroot + SECONDARY_CVSROOT=`newroot $SECONDARY_CVSROOT_DIRNAME` + + # Initialize the primary repository + dotest writeproxy-init-1 "$testcvs -d$PRIMARY_CVSROOT init" + mkdir writeproxy; cd writeproxy + mkdir primary; cd primary + dotest writeproxy-init-2 "$testcvs -Qd$PRIMARY_CVSROOT co CVSROOT" + cd CVSROOT + cat >>loginfo <<EOF +ALL (cat >/dev/null; echo %R) >$TESTDIR/referrer +ALL $RSYNC -gopr --delete $PRIMARY_CVSROOT_DIRNAME/ $SECONDARY_CVSROOT_DIRNAME +EOF + cat >>config <<EOF +PrimaryServer=$PRIMARY_CVSROOT +EOF + dotest writeproxy-init-3 \ +"$testcvs -Q ci -mconfigure-writeproxy" + + # Quickly verify that the server can resolve symlinks when + # determining whether it is the primary. + # This shouldn't actually change the repository. + save_CVS_SERVER=$CVS_SERVER + ln -s $PRIMARY_CVSROOT_DIRNAME $TESTDIR/primary_link + dotest writeproxy-0 "$CVS_SERVER server" \ +"Valid-requests Root Valid-responses valid-requests Command-prep Referrer Repository Directory Relative-directory Max-dotdot Static-directory Sticky Entry Kopt Checkin-time Modified Is-modified UseUnchanged Unchanged Notify Hostname LocalDir Questionable Argument Argumentx Global_option Gzip-stream wrapper-sendme-rcsOptions Set ${DOTSTAR}expand-modules ci co update diff log rlog list rlist global-list-quiet ls add remove update-patches gzip-file-contents status rdiff tag rtag import admin export history release watch-on watch-off watch-add watch-remove watchers editors edit init annotate rannotate noop version +ok +ok +ok" \ +<< EOF +Root $TESTDIR/primary_link +Valid-responses ok error Valid-requests Redirect Checked-in New-entry Checksum Copy-file Updated Created Update-existing Merged Patched Rcs-diff Mode Mod-time Removed Remove-entry Set-static-directory Clear-static-directory Set-sticky Clear-sticky Edit-file Template Clear-template Notified Module-expansion Wrapper-rcsOption M Mbinary E F MT +valid-requests +UseUnchanged +Command-prep commit +Global_option -q +Global_option -Q +Argument -m +Argument configure-writeproxy +Argument -- +Directory . +CVSROOT +Entry /checkoutlist/1.1/// +Modified checkoutlist +u=rw,g=rw,o=r +495 +# The "checkoutlist" file is used to support additional version controlled +# administrative files in \$CVSROOT/CVSROOT, such as template files. +# +# The first entry on a line is a filename which will be checked out from +# the corresponding RCS file in the \$CVSROOT/CVSROOT directory. +# The remainder of the line is an error message to use if the file cannot +# be checked out. +# +# File format: +# +# [<whitespace>]<filename>[<whitespace><error message>]<end-of-line> +# +# comment lines begin with '#' +ci +EOF + rm $TESTDIR/primary_link + + # And now the secondary. + $RSYNC -gopr $PRIMARY_CVSROOT_DIRNAME/ $SECONDARY_CVSROOT_DIRNAME + + # Checkout from secondary + # + # For now, move the primary root out of the way to satisfy + # ourselves that the data is coming from the secondary. + mv $PRIMARY_CVSROOT_DIRNAME $TESTDIR/save-root + cd ../.. + mkdir secondary; cd secondary + dotest writeproxy-1 "$testcvs -qd$SECONDARY_CVSROOT co CVSROOT" \ +"U CVSROOT/checkoutlist +U CVSROOT/commitinfo +U CVSROOT/config +U CVSROOT/cvswrappers +U CVSROOT/loginfo +U CVSROOT/modules +U CVSROOT/notify +U CVSROOT/postadmin +U CVSROOT/postproxy +U CVSROOT/posttag +U CVSROOT/postwatch +U CVSROOT/preproxy +U CVSROOT/rcsinfo +U CVSROOT/taginfo +U CVSROOT/verifymsg" + + # Confirm data present + cd CVSROOT + dotest writeproxy-2 "grep rsync loginfo" \ +"ALL $RSYNC -gopr --delete $PRIMARY_CVSROOT_DIRNAME/ $SECONDARY_CVSROOT_DIRNAME" + dotest writeproxy-3 "grep PrimaryServer config" \ +"${DOTSTAR} +PrimaryServer=$PRIMARY_CVSROOT" + + # Checkin to secondary + cd .. + dotest writeproxy-4 "$testcvs -Qd$SECONDARY_CVSROOT co -ldtop ." + cd top + mkdir firstdir + + # Have to move the primary root back before we can perform write + # operations. + mv $TESTDIR/save-root $PRIMARY_CVSROOT_DIRNAME + + dotest writeproxy-5 "$testcvs -Q add firstdir" + cd firstdir + echo now you see me >file1 + dotest writeproxy-6 "$testcvs -Q add file1" + dotest writeproxy-6a "grep file1 CVS/Entries >/dev/null" + dotest writeproxy-7 "$testcvs -Q ci -mfirst-file file1" + + # Verify that the server got the correct referrer. + # + # This happens even when using a :fork:ed server because CVS is + # hardcoded to support only :ext: servers. + # + # This test meaningfully detects that a referrer was passed in fork + # mode because the only time the referrer string can be altered from + # its original state is when the server sends a Referrer response. + # If the client were not parsing and resending the referrer, this + # string would still match $SECONDARY_CVSROOT_DIRNAME. + dotest writeproxy-7a "cat $TESTDIR/referrer" \ +":ext:$username@$hostname$SECONDARY_CVSROOT_DIRNAME" + + # Make sure the sync took place + dotest writeproxy-7b "$testcvs -Q up" + + # Checkout from primary + cd ../../../primary + dotest writeproxy-8 "$testcvs -qd$PRIMARY_CVSROOT co firstdir" \ +"U firstdir/file1" + + # Confirm data present + # - This test indirectly confirms that the commit did not take + # place on the secondary. + cd firstdir + dotest writeproxy-9 "cat file1" "now you see me" + + # Commit to primary + echo now you see me again >file1 + dotest writeproxy-10 "$testcvs -Q ci -medit file1" + + # Update from secondary + cd ../../secondary/top/firstdir + dotest writeproxy-11 "$testcvs -q up" \ +"U file1" + + # Confirm data present + dotest writeproxy-12 "cat file1" "now you see me again" + + # Test a failing rsync + cd ../../CVSROOT + sed \$d <loginfo >tmp + mv tmp loginfo + echo >>loginfo \ +"ALL echo >&2 'Im rsync and I encountered an error!'; cat >/dev/null; exit 1" + dotest writeproxy-init-13 "$testcvs -Q ci -mbreak-rsync" \ +"Im rsync and I encountered an error!" + echo "# a comment" >>loginfo + dotest writeproxy-13 "$testcvs -Q ci -mtest-broken-rsync" \ +"Im rsync and I encountered an error!" + touch loginfo + dotest_fail writeproxy-14 "$testcvs up" \ +"$SPROG update: Updating \. +$SPROG \[update aborted\]: could not find desired version 1\.4 in $PRIMARY_CVSROOT_DIRNAME/CVSROOT/loginfo,v" + + dokeep + cd ../../.. + rm -r writeproxy $TESTDIR/referrer + rm -rf $PRIMARY_CVSROOT_DIRNAME $SECONDARY_CVSROOT_DIRNAME + PRIMARY_CVSROOT_DIRNAME=$PRIMARY_CVSROOT_DIRNAME_save + PRIMARY_CVSROOT=$PRIMARY_CVSROOT_save + SECONDARY_CVSROOT_DIRNAME=$SECONDARY_CVSROOT_DIRNAME_save + SECONDARY_CVSROOT=$SECONDARY_CVSROOT_save + ;; + + + + writeproxy-noredirect) + # Various tests for a read-only CVS mirror set up as a write-proxy + # for a central server. + # + # These tests are only meaningful in client/server mode. + # + # These tests are a few simple tests for a writeproxy setup with a + # client that can't handle the `Redirect' response. Mostly they + # parallel the "writeproxy" tests but, in the style of the "server", + # "server2", "pserver", and related tests, they bypass the CVS client + # for write commands by piping data into a server on STDIN to mimic + # a client that cannot handle the `Redirect' response. + if $remote; then :; else + remoteonly writeproxy-noredirect + continue + fi + + require_rsync + if test $? -eq 77; then + skip writeproxy-noredirect "$skipreason" + continue + fi + + PRIMARY_CVSROOT_DIRNAME_save=$PRIMARY_CVSROOT_DIRNAME + PRIMARY_CVSROOT_save=$PRIMARY_CVSROOT + PRIMARY_CVSROOT_DIRNAME=$TESTDIR/primary_cvsroot + PRIMARY_CVSROOT=`newroot $PRIMARY_CVSROOT_DIRNAME` + SECONDARY_CVSROOT_DIRNAME_save=$SECONDARY_CVSROOT_DIRNAME + SECONDARY_CVSROOT_DIRNAME=$TESTDIR/writeproxy_cvsroot + + # Initialize the primary repository + dotest writeproxy-noredirect-init-1 \ +"$testcvs -d'$PRIMARY_CVSROOT' init" + mkdir writeproxy-noredirect; cd writeproxy-noredirect + mkdir primary; cd primary + dotest writeproxy-noredirect-init-2 \ +"$testcvs -Qd'$PRIMARY_CVSROOT' co CVSROOT" + cd CVSROOT + cat >>loginfo <<EOF +ALL $RSYNC -gopr --delete $PRIMARY_CVSROOT_DIRNAME/ $SECONDARY_CVSROOT_DIRNAME +EOF + cat >>config <<EOF +PrimaryServer=$PRIMARY_CVSROOT +EOF + dotest writeproxy-noredirect-init-3 \ +"$testcvs -Q ci -mconfigure-writeproxy" + + # And now the secondary. + $RSYNC -gopr $PRIMARY_CVSROOT_DIRNAME/ $SECONDARY_CVSROOT_DIRNAME + + CVS_SERVER_save=$CVS_SERVER + CVS_SERVER_secondary=$TESTDIR/writeproxy-secondary-wrapper + CVS_SERVER=$CVS_SERVER_secondary + + # Wrap the CVS server to allow --primary-root to be set by the + # secondary. + cat <<EOF >$TESTDIR/writeproxy-secondary-wrapper +#! $TESTSHELL +CVS_SERVER=$TESTDIR/writeproxy-primary-wrapper +export CVS_SERVER + +# No need to check the PID of the last client since we are testing with +# Redirect disabled. +proot_arg="--allow-root $SECONDARY_CVSROOT_DIRNAME" +exec $servercvs \$proot_arg "\$@" +EOF + cat <<EOF >$TESTDIR/writeproxy-primary-wrapper +#! $TESTSHELL +#CVS_SERVER_LOG=/tmp/cvsprimarylog +exec $servercvs "\$@" +EOF + + chmod a+x $TESTDIR/writeproxy-secondary-wrapper \ + $TESTDIR/writeproxy-primary-wrapper + + # Checkout from secondary + # + # It may look like we are checking out from the primary here, but + # in fork mode, the deciding factor is the PrimaryServer translation + # above. + # + # When the primary and secondary hostname were different, the server + # the client is talking directly to is more obvious. + # + # For now, move the primary root out of the way to satisfy + # ourselves that the data is coming from the secondary. + mv $PRIMARY_CVSROOT_DIRNAME $TESTDIR/save-root + cd ../.. + mkdir secondary; cd secondary + dotest writeproxy-noredirect-1 \ +"$testcvs -qd'$PRIMARY_CVSROOT' co CVSROOT" \ +"U CVSROOT/checkoutlist +U CVSROOT/commitinfo +U CVSROOT/config +U CVSROOT/cvswrappers +U CVSROOT/loginfo +U CVSROOT/modules +U CVSROOT/notify +U CVSROOT/postadmin +U CVSROOT/postproxy +U CVSROOT/posttag +U CVSROOT/postwatch +U CVSROOT/preproxy +U CVSROOT/rcsinfo +U CVSROOT/taginfo +U CVSROOT/verifymsg" + + # Confirm data present + cd CVSROOT + dotest writeproxy-noredirect-2 "grep rsync loginfo" \ +"ALL $RSYNC -gopr --delete $PRIMARY_CVSROOT_DIRNAME/ $SECONDARY_CVSROOT_DIRNAME" + dotest writeproxy-noredirect-3 "grep PrimaryServer config" \ +"${DOTSTAR} +PrimaryServer=$PRIMARY_CVSROOT" + + # Checkin to secondary + cd .. + dotest writeproxy-noredirect-4 \ +"$testcvs -Qd'$PRIMARY_CVSROOT' co -ldtop ." + cd top + mkdir firstdir + + # Have to move the primary root back before we can perform write + # operations. + mv $TESTDIR/save-root $PRIMARY_CVSROOT_DIRNAME + + dotest writeproxy-noredirect-5 "$CVS_SERVER server" \ +"Valid-requests Root Valid-responses valid-requests Command-prep Referrer Repository Directory Relative-directory Max-dotdot Static-directory Sticky Entry Kopt Checkin-time Modified Is-modified UseUnchanged Unchanged Notify Hostname LocalDir Questionable Argument Argumentx Global_option Gzip-stream wrapper-sendme-rcsOptions Set ${DOTSTAR}expand-modules ci co update diff log rlog list rlist global-list-quiet ls add remove update-patches gzip-file-contents status rdiff tag rtag import admin export history release watch-on watch-off watch-add watch-remove watchers editors edit init annotate rannotate noop version +ok +ok +ok +Clear-template firstdir/ +firstdir/ +ok" \ +<< EOF +Root $PRIMARY_CVSROOT_DIRNAME +Valid-responses ok error Valid-requests Checked-in New-entry Checksum Copy-file Updated Created Update-existing Merged Patched Rcs-diff Mode Mod-time Removed Remove-entry Set-static-directory Clear-static-directory Set-sticky Clear-sticky Template Clear-template Notified Module-expansion Wrapper-rcsOption M Mbinary E F MT +valid-requests +UseUnchanged +Command-prep add +Global_option -q +Global_option -Q +wrapper-sendme-rcsOptions +Argument -- +Directory firstdir +firstdir +Directory . + +Argument firstdir +add +EOF + + # Gotta update the workspace ourselves since we bypassed the client. + cp -R CVS firstdir/CVS + echo "firstdir" >firstdir/CVS/Repository + + cd firstdir + echo now you see me >file1 + dotest writeproxy-noredirect-6 "$CVS_SERVER server" \ +"Valid-requests Root Valid-responses valid-requests Command-prep Referrer Repository Directory Relative-directory Max-dotdot Static-directory Sticky Entry Kopt Checkin-time Modified Is-modified UseUnchanged Unchanged Notify Hostname LocalDir Questionable Argument Argumentx Global_option Gzip-stream wrapper-sendme-rcsOptions Set ${DOTSTAR}expand-modules ci co update diff log rlog list rlist global-list-quiet ls add remove update-patches gzip-file-contents status rdiff tag rtag import admin export history release watch-on watch-off watch-add watch-remove watchers editors edit init annotate rannotate noop version +ok +ok +ok +Checked-in \./ +firstdir/file1 +/file1/0/// +ok" \ +<< EOF +Root $PRIMARY_CVSROOT_DIRNAME +Valid-responses ok error Valid-requests Checked-in New-entry Checksum Copy-file Updated Created Update-existing Merged Patched Rcs-diff Mode Mod-time Removed Remove-entry Set-static-directory Clear-static-directory Set-sticky Clear-sticky Template Clear-template Notified Module-expansion Wrapper-rcsOption M Mbinary E F MT +valid-requests +UseUnchanged +Command-prep add +Global_option -q +Global_option -Q +wrapper-sendme-rcsOptions +Argument -- +Directory . +firstdir +Is-modified file1 +Argument file1 +add +EOF + + # Have to add it to the workspace ourselves again since we are + # bypassing the client. + echo /file1/0/dummy+timestamp// >>CVS/Entries + + dotest writeproxy-noredirect-7 "$CVS_SERVER server" \ +"Valid-requests Root Valid-responses valid-requests Command-prep Referrer Repository Directory Relative-directory Max-dotdot Static-directory Sticky Entry Kopt Checkin-time Modified Is-modified UseUnchanged Unchanged Notify Hostname LocalDir Questionable Argument Argumentx Global_option Gzip-stream wrapper-sendme-rcsOptions Set ${DOTSTAR}expand-modules ci co update diff log rlog list rlist global-list-quiet ls add remove update-patches gzip-file-contents status rdiff tag rtag import admin export history release watch-on watch-off watch-add watch-remove watchers editors edit init annotate rannotate noop version +ok +ok +Mode u=rw,g=rw,o=r +Checked-in \./ +firstdir/file1 +/file1/1\.1/// +ok" \ +<< EOF +Root $PRIMARY_CVSROOT_DIRNAME +Valid-responses ok error Valid-requests Checked-in New-entry Checksum Copy-file Updated Created Update-existing Merged Patched Rcs-diff Mode Mod-time Removed Remove-entry Set-static-directory Clear-static-directory Set-sticky Clear-sticky Template Clear-template Notified Module-expansion Wrapper-rcsOption M Mbinary E F MT +valid-requests +UseUnchanged +Command-prep commit +Global_option -q +Global_option -Q +Argument -m +Argument first-file +Argument -- +Directory . +firstdir +Entry /file1/0/+modified// +Modified file1 +u=rw,g=rw,o=r +15 +now you see me +Argument file1 +ci +EOF + + # Have to add it to the workspace ourselves again since we are + # bypassing the client. + echo D >CVS/Entries + echo /file1/1.1/dummy+timestamp// >>CVS/Entries + + # Make sure the sync took place + dotest writeproxy-noredirect-7a "$testcvs -Q up" + + CVS_SERVER=$servercvs + # Checkout from primary + cd ../../../primary + dotest writeproxy-noredirect-8 \ +"$testcvs -qd'$PRIMARY_CVSROOT' co firstdir" \ +"U firstdir/file1" + + # Confirm data present + # - This test indirectly confirms that the commit did not take + # place on the secondary. + cd firstdir + dotest writeproxy-noredirect-9 "cat file1" "now you see me" + + # Commit to primary + echo now you see me again >file1 + dotest writeproxy-noredirect-10 "$testcvs -Q ci -medit file1" + + CVS_SERVER=$CVS_SERVER_secondary + # Update from secondary + cd ../../secondary/top/firstdir + dotest writeproxy-noredirect-11 "$testcvs -q up" "U file1" + + # Confirm data present + dotest writeproxy-noredirect-12 "cat file1" "now you see me again" + + dokeep + cd ../../../.. + rm -r writeproxy-noredirect + rm -rf $PRIMARY_CVSROOT_DIRNAME $SECONDARY_CVSROOT_DIRNAME + rm $TESTDIR/writeproxy-secondary-wrapper \ + $TESTDIR/writeproxy-primary-wrapper + CVS_SERVER=$CVS_SERVER_save + PRIMARY_CVSROOT_DIRNAME=$PRIMARY_CVSROOT_DIRNAME_save + PRIMARY_CVSROOT=$PRIMARY_CVSROOT_save + SECONDARY_CVSROOT_DIRNAME=$SECONDARY_CVSROOT_DIRNAME_save + ;; + + + + writeproxy-ssh) + # Various tests for a read-only CVS mirror set up as a write-proxy + # for a central server accessed via the :ext: method. + # + # Mostly these tests are intended to set up for the final test which + # verifies that the server registers the referrer. + if $remote; then :; else + remoteonly writeproxy-ssh + continue + fi + + if $noredirect; then + notnoredirect writeproxy-ssh + continue + fi + + require_rsh "$CVS_RSH" + if test $? -eq 77; then + skip writeproxy-ssh "$skipreason" + continue + fi + + require_rsync + if test $? -eq 77; then + skip writeproxy-ssh "$skipreason" + continue + fi + + # Save old roots. + PRIMARY_CVSROOT_DIRNAME_save=$PRIMARY_CVSROOT_DIRNAME + PRIMARY_CVSROOT_save=$PRIMARY_CVSROOT + SECONDARY_CVSROOT_DIRNAME_save=$SECONDARY_CVSROOT_DIRNAME + SECONDARY_CVSROOT_save=$SECONDARY_CVSROOT + + # Set new roots. + PRIMARY_CVSROOT_DIRNAME=$TESTDIR/primary_cvsroot + PRIMARY_CVSROOT=:ext:$host$PRIMARY_CVSROOT_DIRNAME + SECONDARY_CVSROOT_DIRNAME=$TESTDIR/writeproxy_cvsroot + SECONDARY_CVSROOT=":ext;Redirect=yes:$host$SECONDARY_CVSROOT_DIRNAME" + + # Initialize the primary repository + dotest writeproxy-ssh-init-1 "$testcvs -d$PRIMARY_CVSROOT init" + mkdir writeproxy-ssh; cd writeproxy-ssh + mkdir primary; cd primary + dotest writeproxy-ssh-init-2 "$testcvs -Qd$PRIMARY_CVSROOT co CVSROOT" + cd CVSROOT + cat >>loginfo <<EOF +ALL $RSYNC -gopr --delete $PRIMARY_CVSROOT_DIRNAME/ $SECONDARY_CVSROOT_DIRNAME +EOF + cat >>loginfo <<EOF +ALL echo Referrer=%R; cat >/dev/null +EOF + cat >>config <<EOF +PrimaryServer=$PRIMARY_CVSROOT +EOF + dotest writeproxy-ssh-init-3 \ +"$testcvs -Q ci -mconfigure-writeproxy-ssh" \ +"Referrer=NONE" + + # And now the secondary. + $RSYNC -gopr $PRIMARY_CVSROOT_DIRNAME/ $SECONDARY_CVSROOT_DIRNAME + + # Checkout from secondary + # + # For now, move the primary root out of the way to satisfy + # ourselves that the data is coming from the secondary. + mv $PRIMARY_CVSROOT_DIRNAME $TESTDIR/save-root + + # Checkin to secondary + cd ../.. + save_CVSROOT=$CVSROOT + CVSROOT=$SECONDARY_CVSROOT + export CVSROOT + dotest writeproxy-ssh-1 "$testcvs -Q co -ldtop ." + CVSROOT=$save_CVSROOT + export CVSROOT + cd top + mkdir firstdir + + # Have to move the primary root back before we can perform write + # operations. + mv $TESTDIR/save-root $PRIMARY_CVSROOT_DIRNAME + + dotest writeproxy-ssh-2 "$testcvs -Q add firstdir" \ +"Referrer=:ext:$username@$hostname$SECONDARY_CVSROOT_DIRNAME" + + cd firstdir + echo now you see me >file1 + dotest writeproxy-ssh-3 "$testcvs -Q add file1" + dotest writeproxy-ssh-4 "$testcvs -Q ci -mfirst-file file1" \ +"Referrer=:ext:$username@$hostname$SECONDARY_CVSROOT_DIRNAME" + + dokeep + cd ../../.. + rm -r writeproxy-ssh + rm -rf $PRIMARY_CVSROOT_DIRNAME $SECONDARY_CVSROOT_DIRNAME + PRIMARY_CVSROOT_DIRNAME=$PRIMARY_CVSROOT_DIRNAME_save + PRIMARY_CVSROOT=$PRIMARY_CVSROOT_save + SECONDARY_CVSROOT_DIRNAME=$SECONDARY_CVSROOT_DIRNAME_save + SECONDARY_CVSROOT=$SECONDARY_CVSROOT_save + ;; + + + + writeproxy-ssh-noredirect) + # Various tests for a read-only CVS mirror set up as a write-proxy + # for a central server accessed via the :ext: method. + # + # Mostly these tests are intended to set up for the final test which + # verifies that the server registers the referrer. + if $remote; then :; else + remoteonly writeproxy-ssh-noredirect + continue + fi + + require_rsh "$CVS_RSH" + if test $? -eq 77; then + skip writeproxy-ssh-noredirect "$skipreason" + continue + fi + + require_rsync + if test $? -eq 77; then + skip writeproxy-ssh-noredirect "$skipreason" + continue + fi + + # Save old roots. + PRIMARY_CVSROOT_DIRNAME_save=$PRIMARY_CVSROOT_DIRNAME + PRIMARY_CVSROOT_save=$PRIMARY_CVSROOT + SECONDARY_CVSROOT_DIRNAME_save=$SECONDARY_CVSROOT_DIRNAME + SECONDARY_CVSROOT_save=$SECONDARY_CVSROOT + + # Set new roots. + PRIMARY_CVSROOT_DIRNAME=$TESTDIR/primary_cvsroot + PRIMARY_CVSROOT=:ext:$host$PRIMARY_CVSROOT_DIRNAME + SECONDARY_CVSROOT_DIRNAME=$TESTDIR/writeproxy_cvsroot + SECONDARY_CVSROOT=":ext;Redirect=no:$host$PRIMARY_CVSROOT_DIRNAME" + + # Initialize the primary repository + dotest writeproxy-ssh-noredirect-init-1 \ +"$testcvs -d$PRIMARY_CVSROOT init" + mkdir writeproxy-ssh-noredirect; cd writeproxy-ssh-noredirect + mkdir primary; cd primary + dotest writeproxy-ssh-noredirect-init-2 \ +"$testcvs -Qd$PRIMARY_CVSROOT co CVSROOT" + cd CVSROOT + cat >>loginfo <<EOF +ALL $RSYNC -gopr --delete $PRIMARY_CVSROOT_DIRNAME/ $SECONDARY_CVSROOT_DIRNAME +EOF + cat >>loginfo <<EOF +ALL echo Referrer=%R; cat >/dev/null +EOF + cat >>config <<EOF +PrimaryServer=$PRIMARY_CVSROOT +EOF + dotest writeproxy-ssh-noredirect-init-3 \ +"$testcvs -Q ci -mconfigure-writeproxy-ssh-noredirect" \ +"Referrer=NONE" + + # And now the secondary. + $RSYNC -gopr $PRIMARY_CVSROOT_DIRNAME/ $SECONDARY_CVSROOT_DIRNAME + + # Wrap the CVS server to allow --primary-root to be set by the + # secondary. + cat <<EOF >$TESTDIR/writeproxy-secondary-wrapper +#! $TESTSHELL +CVS_SERVER=$TESTDIR/writeproxy-primary-wrapper +export CVS_SERVER + +# No need to check the PID of the last client since we are testing with +# Redirect disabled. +proot_arg="--allow-root=$SECONDARY_CVSROOT_DIRNAME" +exec $CVS_SERVER \$proot_arg "\$@" +EOF + cat <<EOF >$TESTDIR/writeproxy-primary-wrapper +#! $TESTSHELL +if test -n "\$CVS_SERVER_LOG"; then + CVS_SERVER_LOG=$TMPDIR/cvsprimarylog; export CVS_SERVER_LOG +fi +exec $CVS_SERVER "\$@" +EOF + + CVS_SERVER_save=$CVS_SERVER + CVS_SERVER_secondary=$TESTDIR/writeproxy-secondary-wrapper + CVS_SERVER=$CVS_SERVER_secondary + + chmod a+x $TESTDIR/writeproxy-secondary-wrapper \ + $TESTDIR/writeproxy-primary-wrapper + + # Checkout from secondary + # + # For now, move the primary root out of the way to satisfy + # ourselves that the data is coming from the secondary. + mv $PRIMARY_CVSROOT_DIRNAME $TESTDIR/save-root + + # Checkin to secondary + cd ../.. + dotest writeproxy-ssh-noredirect-1 \ +"$testcvs -qd '$SECONDARY_CVSROOT' co -ldtop ." + + cd top + mkdir firstdir + + # Have to move the primary root back before we can perform write + # operations. + mv $TESTDIR/save-root $PRIMARY_CVSROOT_DIRNAME + + dotest writeproxy-ssh-noredirect-2 "$testcvs -Q add firstdir" \ +"Referrer=NONE" + + cd firstdir + echo now you see me >file1 + dotest writeproxy-ssh-noredirect-3 "$testcvs -Q add file1" + dotest writeproxy-ssh-noredirect-4 \ +"$testcvs -Q ci -mfirst-file file1" \ +"Referrer=NONE" + + dokeep + cd ../../.. + rm -r writeproxy-ssh-noredirect + rm -rf $PRIMARY_CVSROOT_DIRNAME $SECONDARY_CVSROOT_DIRNAME + PRIMARY_CVSROOT_DIRNAME=$PRIMARY_CVSROOT_DIRNAME_save + PRIMARY_CVSROOT=$PRIMARY_CVSROOT_save + SECONDARY_CVSROOT_DIRNAME=$SECONDARY_CVSROOT_DIRNAME_save + SECONDARY_CVSROOT=$SECONDARY_CVSROOT_save + rm $TESTDIR/writeproxy-secondary-wrapper \ + $TESTDIR/writeproxy-primary-wrapper + CVS_SERVER=$CVS_SERVER_save + ;; + + + + trace) + # Check that there are no core dumps lurking in the trace + # options. + + # Perform some cleanup for normalized testing... + rm ${CVSROOT_DIRNAME}/CVSROOT/history + rm -f ${CVSROOT_DIRNAME}/CVSROOT/cvsignore + rm -f ${CVSROOT_DIRNAME}/CVSROOT/cvsignore,v + + # checkout the trace option + + mkdir trace && cd trace + mkdir imp && cd imp + touch file1 + + dotest_sort trace-1 "${testcvs} -t -t -t init" \ +" *-> Lock_Cleanup() + *-> RCS_checkout (checkoutlist,v, , , , \.#[0-9][0-9]*) + *-> RCS_checkout (commitinfo,v, , , , \.#[0-9][0-9]*) + *-> RCS_checkout (config,v, , , , \.#[0-9][0-9]*) + *-> RCS_checkout (cvswrappers,v, , , , \.#[0-9][0-9]*) + *-> RCS_checkout (loginfo,v, , , , \.#[0-9][0-9]*) + *-> RCS_checkout (modules,v, , , , \.#[0-9][0-9]*) + *-> RCS_checkout (notify,v, , , , \.#[0-9][0-9]*) + *-> RCS_checkout (postadmin,v, , , , \.#[0-9][0-9]*) + *-> RCS_checkout (postproxy,v, , , , \.#[0-9][0-9]*) + *-> RCS_checkout (posttag,v, , , , \.#[0-9][0-9]*) + *-> RCS_checkout (postwatch,v, , , , \.#[0-9][0-9]*) + *-> RCS_checkout (preproxy,v, , , , \.#[0-9][0-9]*) + *-> RCS_checkout (rcsinfo,v, , , , \.#[0-9][0-9]*) + *-> RCS_checkout (taginfo,v, , , , \.#[0-9][0-9]*) + *-> RCS_checkout (verifymsg,v, , , , \.#[0-9][0-9]*) + *-> Simple_Lock_Cleanup() + *-> main loop with CVSROOT=${CVSROOT_DIRNAME} + *-> parse_cvsroot ( ${CVSROOT_DIRNAME} ) + *-> remove_locks() + *-> unlink_file(\.#[0-9][0-9]*) + *-> unlink_file(\.#[0-9][0-9]*) + *-> unlink_file(\.#[0-9][0-9]*) + *-> unlink_file(\.#[0-9][0-9]*) + *-> unlink_file(\.#[0-9][0-9]*) + *-> unlink_file(\.#[0-9][0-9]*) + *-> unlink_file(\.#[0-9][0-9]*) + *-> unlink_file(\.#[0-9][0-9]*) + *-> unlink_file(\.#[0-9][0-9]*) + *-> unlink_file(\.#[0-9][0-9]*) + *-> unlink_file(\.#[0-9][0-9]*) + *-> unlink_file(\.#[0-9][0-9]*) + *-> unlink_file(\.#[0-9][0-9]*) + *-> unlink_file(\.#checkoutlist) + *-> unlink_file(\.#commitinfo) + *-> unlink_file(\.#config) + *-> unlink_file(\.#cvswrappers) + *-> unlink_file(\.#loginfo) + *-> unlink_file(\.#modules) + *-> unlink_file(\.#notify) + *-> unlink_file(\.#postadmin) + *-> unlink_file(\.#postproxy) + *-> unlink_file(\.#posttag) + *-> unlink_file(\.#postwatch) + *-> unlink_file(\.#preproxy) + *-> unlink_file(\.#rcsinfo) + *-> unlink_file(\.#taginfo) + *-> unlink_file(\.#verifymsg) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} )" \ +" + *-> Forking server: ${CVS_SERVER} server + *-> main loop with CVSROOT=${CVSROOT} + *-> parse_cvsroot ( ${CVSROOT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> CVS_SERVER_SLEEP not set\. +S -> Lock_Cleanup() +S -> Lock_Cleanup() +S -> RCS_checkout (checkoutlist,v, , , , \.#[0-9][0-9]*) +S -> RCS_checkout (commitinfo,v, , , , \.#[0-9][0-9]*) +S -> RCS_checkout (config,v, , , , \.#[0-9][0-9]*) +S -> RCS_checkout (cvswrappers,v, , , , \.#[0-9][0-9]*) +S -> RCS_checkout (loginfo,v, , , , \.#[0-9][0-9]*) +S -> RCS_checkout (modules,v, , , , \.#[0-9][0-9]*) +S -> RCS_checkout (notify,v, , , , \.#[0-9][0-9]*) +S -> RCS_checkout (postadmin,v, , , , \.#[0-9][0-9]*) +S -> RCS_checkout (postproxy,v, , , , \.#[0-9][0-9]*) +S -> RCS_checkout (posttag,v, , , , \.#[0-9][0-9]*) +S -> RCS_checkout (postwatch,v, , , , \.#[0-9][0-9]*) +S -> RCS_checkout (preproxy,v, , , , \.#[0-9][0-9]*) +S -> RCS_checkout (rcsinfo,v, , , , \.#[0-9][0-9]*) +S -> RCS_checkout (taginfo,v, , , , \.#[0-9][0-9]*) +S -> RCS_checkout (verifymsg,v, , , , \.#[0-9][0-9]*) +S -> Simple_Lock_Cleanup() +S -> Simple_Lock_Cleanup() +S -> do_cvs_command (init) +S -> remove_locks() +S -> remove_locks() +S -> server_cleanup() +S -> server_cleanup() +S -> server_notify() +S -> unlink_file(\.#[0-9][0-9]*) +S -> unlink_file(\.#[0-9][0-9]*) +S -> unlink_file(\.#[0-9][0-9]*) +S -> unlink_file(\.#[0-9][0-9]*) +S -> unlink_file(\.#[0-9][0-9]*) +S -> unlink_file(\.#[0-9][0-9]*) +S -> unlink_file(\.#[0-9][0-9]*) +S -> unlink_file(\.#[0-9][0-9]*) +S -> unlink_file(\.#[0-9][0-9]*) +S -> unlink_file(\.#[0-9][0-9]*) +S -> unlink_file(\.#[0-9][0-9]*) +S -> unlink_file(\.#[0-9][0-9]*) +S -> unlink_file(\.#[0-9][0-9]*) +S -> unlink_file(\.#checkoutlist) +S -> unlink_file(\.#commitinfo) +S -> unlink_file(\.#config) +S -> unlink_file(\.#cvswrappers) +S -> unlink_file(\.#loginfo) +S -> unlink_file(\.#modules) +S -> unlink_file(\.#notify) +S -> unlink_file(\.#postadmin) +S -> unlink_file(\.#postproxy) +S -> unlink_file(\.#posttag) +S -> unlink_file(\.#postwatch) +S -> unlink_file(\.#preproxy) +S -> unlink_file(\.#rcsinfo) +S -> unlink_file(\.#taginfo) +S -> unlink_file(\.#verifymsg)" \ + + dotest_sort trace-2 \ +"${testcvs} -t -t -t import -mimport trace MYVENDOR version-1" \ +" + + *-> Lock_Cleanup() + *-> Parse_Info (${CVSROOT_DIRNAME}/CVSROOT/loginfo, trace, ALL) + *-> Parse_Info (${CVSROOT_DIRNAME}/CVSROOT/verifymsg, trace, not ALL) + *-> Simple_Lock_Cleanup() + *-> main loop with CVSROOT=${CVSROOT_DIRNAME} + *-> parse_cvsroot ( ${CVSROOT_DIRNAME} ) + *-> remove_locks() + *-> safe_location( where=(null) ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +N trace/file1 +No conflicts created by this import" \ +" + + + *-> Forking server: ${CVS_SERVER} server + *-> Sending file \`file1' to server + *-> main loop with CVSROOT=${CVSROOT} + *-> parse_cvsroot ( ${CVSROOT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +N trace/file1 +No conflicts created by this import +S -> CVS_SERVER_SLEEP not set\. +S -> Lock_Cleanup() +S -> Lock_Cleanup() +S -> Parse_Info (${CVSROOT_DIRNAME}/CVSROOT/loginfo, trace, ALL) +S -> Parse_Info (${CVSROOT_DIRNAME}/CVSROOT/verifymsg, trace, not ALL) +S -> Simple_Lock_Cleanup() +S -> Simple_Lock_Cleanup() +S -> dirswitch (\., ${CVSROOT_DIRNAME}/trace) +S -> do_cvs_command (import) +S -> remove_locks() +S -> remove_locks() +S -> safe_location( where=(null) ) +S -> serve_directory (\.) +S -> server_cleanup() +S -> server_cleanup() +S -> server_notify()" + + cd .. + rm -fr imp + + dotest_sort trace-3 "${testcvs} -t -t -t co trace" \ +" *callerdat=${PFMT}, argc=0, argv=${PFMT}, + *direntproc=${PFMT}, dirleavproc=${PFMT}, + *dosrcs=1, repository_in=${CVSROOT_DIRNAME}/trace ) + *local=0, which=3, aflag=0, + *locktype=1, update_preload=trace + *-> Create_Admin + *-> Create_Admin (\., trace, ${CVSROOT_DIRNAME}/trace, , , 0, 0, 1) + *-> Leaving do_recursion ( frame=${PFMT} ) + *-> Leaving do_recursion ( frame=${PFMT} ) + *-> Lock_Cleanup() + *-> RCS_checkout (${CVSROOT_DIRNAME}/trace/file1,v, 1\.1\.1\.1, , , file1) + *-> Reader_Lock(${CVSROOT_DIRNAME}/trace) + *-> Register(file1, 1\.1\.1\.1, ${DATE}, , ) + *-> Simple_Lock_Cleanup() + *-> Simple_Lock_Cleanup() + *-> Write_Template (trace, ${CVSROOT_DIRNAME}/trace) + *-> chmod(file1,[0-7][0-7]*) + *-> do_module (trace, Updating, NULL, NULL) + *-> do_recursion ( frame=${PFMT} ) + *-> do_recursion ( frame=${PFMT} ) + *-> fopen(${CVSROOT_DIRNAME}/CVSROOT/history,a) + *-> lock_name (${CVSROOT_DIRNAME}/trace, #cvs\.lock) + *-> lock_name (${CVSROOT_DIRNAME}/trace, #cvs\.rfl\.${hostname}\.[0-9][0-9]*) + *-> lock_simple_remove() + *-> main loop with CVSROOT=${CVSROOT_DIRNAME} + *-> parse_cvsroot ( ${CVSROOT_DIRNAME} ) + *-> remove_locks() + *-> rename(CVS/Entries\.Backup,CVS/Entries) + *-> safe_location( where=(null) ) + *-> set_lock (${CVSROOT_DIRNAME}/trace, 1) + *-> start_recursion ( fileproc=${PFMT}, filesdoneproc=${PFMT}, + *-> unlink_file(\./CVS/Entries\.Static) + *-> unlink_file(\./CVS/Tag) + *-> unlink_file(CVS/Entries\.Log) + *-> unlink_file_dir(CVS/,,file1) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +U trace/file1 +${SPROG} checkout: Updating trace" \ +" + *callerdat=${PFMT}, argc=0, argv=${PFMT}, + *direntproc=${PFMT}, dirleavproc=${PFMT}, + *dosrcs=1, repository_in=${CVSROOT_DIRNAME}/trace ) + *local=0, which=3, aflag=0, + *locktype=1, update_preload=trace + *-> Create_Admin + *-> Create_Admin (trace, trace, ${CVSROOT_DIRNAME}/trace, , , 0, 0, 1) + *-> Forking server: ${CVS_SERVER} server + *-> Register(file1, 1\.1\.1\.1, ${DATE}, , ) + *-> main loop with CVSROOT=${CVSROOT} + *-> parse_cvsroot ( ${CVSROOT} ) + *-> rename(\.new\.file1,file1) + *-> rename(CVS/Entries\.Backup,CVS/Entries) + *-> safe_location( where=(null) ) + *-> unlink_file(CVS/Entries\.Log) + *-> unlink_file(CVS/Entries\.Static) + *-> unlink_file(CVS/Tag) + *-> unlink_file(CVS/Template) + *-> unlink_file(trace/CVS/Tag) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> CVS_SERVER_SLEEP not set\. +S -> Create_Admin +S -> Create_Admin (\., trace, ${CVSROOT_DIRNAME}/trace, , , 0, 0, 1) +S -> Leaving do_recursion ( frame=${PFMT} ) +S -> Leaving do_recursion ( frame=${PFMT} ) +S -> Lock_Cleanup() +S -> Lock_Cleanup() +S -> Parse_Info (${CVSROOT_DIRNAME}/CVSROOT/rcsinfo, trace, ALL) +S -> RCS_checkout (${CVSROOT_DIRNAME}/trace/file1,v, 1\.1\.1\.1, , , (function)) +S -> Reader_Lock(${CVSROOT_DIRNAME}/trace) +S -> Register(file1, 1\.1\.1\.1, , , ) +S -> Simple_Lock_Cleanup() +S -> Simple_Lock_Cleanup() +S -> Simple_Lock_Cleanup() +S -> Write_Template (trace, ${CVSROOT_DIRNAME}/trace) +S -> dirswitch (\., ${CVSROOT_DIRNAME}) +S -> dirswitch (\., ${CVSROOT_DIRNAME}) +S -> do_cvs_command (checkout) +S -> do_module (trace, Updating, NULL, NULL) +S -> do_module (trace, Updating, NULL, NULL) +S -> do_recursion ( frame=${PFMT} ) +S -> do_recursion ( frame=${PFMT} ) +S -> fopen(${CVSROOT_DIRNAME}/CVSROOT/history,a) +S -> lock_name (${CVSROOT_DIRNAME}/trace, #cvs\.lock) +S -> lock_name (${CVSROOT_DIRNAME}/trace, #cvs\.rfl\.${hostname}\.[0-9][0-9]*) +S -> lock_simple_remove() +S -> remove_locks() +S -> remove_locks() +S -> rename(CVS/Entries\.Backup,CVS/Entries) +S -> safe_location( where=(null) ) +S -> serve_directory (\.) +S -> serve_directory (\.) +S -> server_cleanup() +S -> server_cleanup() +S -> server_notify() +S -> server_register(file1, 1\.1\.1\.1, , , , , ) +S -> set_lock (${CVSROOT_DIRNAME}/trace, 1) +S -> start_recursion ( fileproc=${PFMT}, filesdoneproc=${PFMT}, +S -> unlink_file(\./CVS/Entries\.Static) +S -> unlink_file(\./CVS/Tag) +S -> unlink_file(CVS/Entries\.Log) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +U trace/file1 +${SPROG} checkout: Updating trace" + + cd trace + mkdir subdir + dotest_sort trace-4 "${testcvs} -t -t -t add subdir" \ +" *-> Create_Admin + *-> Create_Admin (\., subdir, ${CVSROOT_DIRNAME}/trace/subdir, , , 0, 0, 1) + *-> Lock_Cleanup() + *-> Parse_Info (${CVSROOT_DIRNAME}/CVSROOT/loginfo, trace/subdir, ALL) + *-> Simple_Lock_Cleanup() + *-> main loop with CVSROOT=${CVSROOT_DIRNAME} + *-> parse_cvsroot ( ${CVSROOT_DIRNAME} ) + *-> remove_locks() + *-> rename(CVS/Entries\.Backup,CVS/Entries) + *-> unlink_file(\./CVS/Tag) + *-> unlink_file(${CVSROOT_DIRNAME}/trace/subdir/CVS/fileattr) + *-> unlink_file(CVS/Entries\.Log) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +Directory ${CVSROOT_DIRNAME}/trace/subdir added to the repository" \ +" + *callerdat=${PFMT}, argc=1, argv=${PFMT}, + *direntproc=${PFMT}, dirleavproc=${PFMT}, + *dosrcs=0, repository_in=(null) ) + *local=0, which=1, aflag=0, + *locktype=0, update_preload=(null) + *-> Create_Admin + *-> Create_Admin (subdir, subdir, ${CVSROOT_DIRNAME}/trace/subdir, , , 0, 0, 1) + *-> Forking server: ${CVS_SERVER} server + *-> Leaving do_recursion ( frame=${PFMT} ) + *-> Leaving do_recursion ( frame=${PFMT} ) + *-> do_recursion ( frame=${PFMT} ) + *-> do_recursion ( frame=${PFMT} ) + *-> main loop with CVSROOT=${CVSROOT} + *-> parse_cvsroot ( ${CVSROOT} ) + *-> rename(CVS/Entries\.Backup,CVS/Entries) +${DOTSTAR} *-> start_recursion ( fileproc=${PFMT}, filesdoneproc=${PFMT}, + *-> unlink_file(CVS/Entries\.Log) +${DOTSTAR} *-> unlink_file(CVS/Template) + *-> unlink_file(subdir/CVS/Tag) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +${DOTSTAR}Directory ${CVSROOT_DIRNAME}/trace/subdir added to the repository +S -> CVS_SERVER_SLEEP not set\. +S -> Lock_Cleanup() +S -> Lock_Cleanup() +S -> Parse_Info (${CVSROOT_DIRNAME}/CVSROOT/loginfo, trace/subdir, ALL) +S -> Parse_Info (${CVSROOT_DIRNAME}/CVSROOT/rcsinfo, trace/subdir, ALL) +S -> Simple_Lock_Cleanup() +S -> Simple_Lock_Cleanup() +S -> Write_Template (subdir, ${CVSROOT_DIRNAME}/trace/subdir) +S -> dirswitch (\., ${CVSROOT_DIRNAME}/trace) +S -> dirswitch (subdir, ${CVSROOT_DIRNAME}/trace/subdir) +S -> do_cvs_command (add) +S -> remove_locks() +S -> remove_locks() +S -> rename(CVS/Entries\.Backup,CVS/Entries) +S -> rename(CVS/Entries\.Backup,CVS/Entries) +S -> serve_directory (\.) +S -> serve_directory (subdir) +S -> server_cleanup() +S -> server_cleanup() +S -> server_notify() +S -> unlink_file(${CVSROOT_DIRNAME}/trace/subdir/CVS/fileattr) +S -> unlink_file(CVS/Entries\.Log) +S -> unlink_file(CVS/Entries\.Log) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} )" + touch file2 + dotest_sort trace-5 "${testcvs} -t -t -t add file2" \ +" *-> Lock_Cleanup() + *-> Register(file2, 0, Initial file2, , ) + *-> Simple_Lock_Cleanup() + *-> main loop with CVSROOT=${CVSROOT_DIRNAME} + *-> parse_cvsroot ( ${CVSROOT_DIRNAME} ) + *-> remove_locks() + *-> rename(CVS/Entries\.Backup,CVS/Entries) + *-> unlink_file(CVS/Entries\.Log) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +${SPROG} add: scheduling file \`file2' for addition +${SPROG} add: use \`${SPROG} commit' to add this file permanently" \ +" + *callerdat=${PFMT}, argc=1, argv=${PFMT}, + *direntproc=${PFMT}, dirleavproc=${PFMT}, + *dosrcs=0, repository_in=(null) ) + *local=0, which=1, aflag=0, + *locktype=0, update_preload=(null) + *-> Forking server: ${CVS_SERVER} server + *-> Leaving do_recursion ( frame=${PFMT} ) + *-> Register(file2, 0, dummy timestamp, , ) + *-> do_recursion ( frame=${PFMT} ) + *-> main loop with CVSROOT=${CVSROOT} + *-> parse_cvsroot ( ${CVSROOT} ) + *-> rename(CVS/Entries\.Backup,CVS/Entries) +${DOTSTAR} *-> start_recursion ( fileproc=${PFMT}, filesdoneproc=${PFMT}, + *-> unlink_file(CVS/Entries\.Log) +${DOTSTAR} *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +${DOTSTAR}S -> CVS_SERVER_SLEEP not set\. +S -> Lock_Cleanup() +S -> Lock_Cleanup() +S -> Register(file2, 0, Initial file2, , ) +S -> Simple_Lock_Cleanup() +S -> Simple_Lock_Cleanup() +S -> dirswitch (\., ${CVSROOT_DIRNAME}/trace) +S -> do_cvs_command (add) +S -> remove_locks() +S -> remove_locks() +S -> rename(CVS/Entries\.Backup,CVS/Entries) +S -> serve_directory (\.) +S -> server_cleanup() +S -> server_cleanup() +S -> server_notify() +S -> server_register(file2, 0, Initial file2, , , , ) +S -> unlink_file(CVS/Entries\.Log) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +${SPROG} add: scheduling file \`file2' for addition +${SPROG} add: use \`${SPROG} commit' to add this file permanently" + dotest_sort trace-6 "${testcvs} -t -t -t ci -mnew-file file2" \ +" *callerdat=${PFMT}, argc=1, argv=${PFMT}, + *callerdat=${PFMT}, argc=1, argv=${PFMT}, + *callerdat=${PFMT}, argc=1, argv=${PFMT}, + *direntproc=${PFMT}, dirleavproc=${PFMT}, + *direntproc=${PFMT}, dirleavproc=${PFMT}, + *direntproc=${PFMT}, dirleavproc=${PFMT}, + *dosrcs=0, repository_in=(null) ) + *dosrcs=1, repository_in=(null) ) + *dosrcs=1, repository_in=(null) ) + *local=0, which=1, aflag=0, + *local=0, which=1, aflag=0, + *local=0, which=1, aflag=0, + *locktype=0, update_preload=(null) + *locktype=0, update_preload=(null) + *locktype=2, update_preload=(null) + *-> Leaving do_recursion ( frame=${PFMT} ) + *-> Leaving do_recursion ( frame=${PFMT} ) + *-> Leaving do_recursion ( frame=${PFMT} ) + *-> Lock_Cleanup() + *-> Lock_Cleanup() + *-> Parse_Info (${CVSROOT_DIRNAME}/CVSROOT/commitinfo, trace, ALL) + *-> Parse_Info (${CVSROOT_DIRNAME}/CVSROOT/loginfo, trace, ALL) + *-> Parse_Info (${CVSROOT_DIRNAME}/CVSROOT/verifymsg, trace, not ALL) + *-> Promotable_Lock () + *-> RCS_checkout (${CVSROOT_DIRNAME}/trace/file2,v, 1, , , (function)) + *-> RCS_cmp_file( ${CVSROOT_DIRNAME}/trace/file2,v, 1, (null), , file2 ) + *-> Register(file2, 1\.1, ${DATE}, , ) + *-> Simple_Lock_Cleanup() + *-> Simple_Lock_Cleanup() + *-> Simple_Lock_Cleanup() + *-> _lock_exists (${CVSROOT_DIRNAME}/trace, #cvs\.pfl\.\*, #cvs\.pfl\.${hostname}\.[0-9][0-9]*) + *-> _lock_exists (${CVSROOT_DIRNAME}/trace, #cvs\.pfl\.\*, #cvs\.pfl\.${hostname}\.[0-9][0-9]*) + *-> _lock_exists (${CVSROOT_DIRNAME}/trace, #cvs\.rfl\.\*, #cvs\.rfl\.${hostname}\.[0-9][0-9]*) + *-> do_recursion ( frame=${PFMT} ) + *-> do_recursion ( frame=${PFMT} ) + *-> do_recursion ( frame=${PFMT} ) + *-> fopen(${CVSROOT_DIRNAME}/CVSROOT/history,a) + *-> lock_dir_for_write (${CVSROOT_DIRNAME}/trace) + *-> lock_name (${CVSROOT_DIRNAME}/trace, #cvs\.lock) + *-> lock_name (${CVSROOT_DIRNAME}/trace, #cvs\.lock) + *-> lock_name (${CVSROOT_DIRNAME}/trace, #cvs\.lock) + *-> lock_name (${CVSROOT_DIRNAME}/trace, #cvs\.pfl\.${hostname}\.[0-9][0-9]*) + *-> lock_name (${CVSROOT_DIRNAME}/trace, #cvs\.rfl\.${hostname}\.[0-9][0-9]*) + *-> lock_name (${CVSROOT_DIRNAME}/trace, #cvs\.wfl\.${hostname}\.[0-9][0-9]*) + *-> lock_name (${CVSROOT_DIRNAME}/trace, ) + *-> lock_name (${CVSROOT_DIRNAME}/trace, ) + *-> lock_name (${CVSROOT_DIRNAME}/trace, ) + *-> lock_simple_remove() + *-> lock_simple_remove() + *-> lock_tree_promotably (1, argv, 0, 1, 0) + *-> main loop with CVSROOT=${CVSROOT_DIRNAME} + *-> parse_cvsroot ( ${CVSROOT_DIRNAME} ) + *-> promotable_exists (${CVSROOT_DIRNAME}/trace) + *-> promotable_exists (${CVSROOT_DIRNAME}/trace) + *-> promotable_lock(${CVSROOT_DIRNAME}/trace) + *-> rcs_cleanup() + *-> readers_exist (${CVSROOT_DIRNAME}/trace) + *-> remove_locks() + *-> remove_locks() + *-> rename(${CVSROOT_DIRNAME}/trace/,file2,,${CVSROOT_DIRNAME}/trace/file2,v) + *-> rename(${CVSROOT_DIRNAME}/trace/,file2,,${CVSROOT_DIRNAME}/trace/file2,v) + *-> rename(CVS/Entries\.Backup,CVS/Entries) + *-> set_lock (${CVSROOT_DIRNAME}/trace, 0) + *-> set_lock (${CVSROOT_DIRNAME}/trace, 1) + *-> start_recursion ( fileproc=${PFMT}, filesdoneproc=${PFMT}, + *-> start_recursion ( fileproc=${PFMT}, filesdoneproc=${PFMT}, + *-> start_recursion ( fileproc=${PFMT}, filesdoneproc=${PFMT}, + *-> unlink_file(CVS/Base/file2) + *-> unlink_file(CVS/Entries\.Log) + *-> unlink_file(CVS/file2,t) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +${CVSROOT_DIRNAME}/trace/file2,v <-- file2 +initial revision: 1\.1" \ +" + *callerdat=${PFMT}, argc=1, argv=${PFMT}, + *callerdat=${PFMT}, argc=1, argv=${PFMT}, + *callerdat=${PFMT}, argc=1, argv=${PFMT}, + *callerdat=${PFMT}, argc=1, argv=${PFMT}, + *callerdat=${PFMT}, argc=1, argv=${PFMT}, + *direntproc=${PFMT}, dirleavproc=${PFMT}, + *direntproc=${PFMT}, dirleavproc=${PFMT}, + *direntproc=${PFMT}, dirleavproc=${PFMT}, + *direntproc=${PFMT}, dirleavproc=${PFMT}, + *direntproc=${PFMT}, dirleavproc=${PFMT}, + *dosrcs=0, repository_in=(null) ) + *dosrcs=0, repository_in=(null) ) + *dosrcs=0, repository_in=(null) ) + *dosrcs=1, repository_in=(null) ) + *dosrcs=1, repository_in=(null) ) + *local=0, which=1, aflag=0, + *local=0, which=1, aflag=0, + *local=0, which=1, aflag=0, + *local=0, which=1, aflag=0, + *local=0, which=1, aflag=0, + *locktype=0, update_preload=(null) + *locktype=0, update_preload=(null) + *locktype=0, update_preload=(null) + *locktype=0, update_preload=(null) + *locktype=2, update_preload=(null) + *-> Forking server: ${CVS_SERVER} server + *-> Leaving do_recursion ( frame=${PFMT} ) + *-> Leaving do_recursion ( frame=${PFMT} ) + *-> Register(file2, 1\.1, ${DATE}, , ) + *-> Sending file \`file2' to server + *-> do_recursion ( frame=${PFMT} ) + *-> do_recursion ( frame=${PFMT} ) + *-> main loop with CVSROOT=${CVSROOT} + *-> parse_cvsroot ( ${CVSROOT} ) + *-> rename(CVS/Entries\.Backup,CVS/Entries) + *-> start_recursion ( fileproc=${PFMT}, filesdoneproc=${PFMT}, + *-> start_recursion ( fileproc=${PFMT}, filesdoneproc=${PFMT}, + *-> unlink_file(CVS/Base/file2) + *-> unlink_file(CVS/Entries\.Log) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +${CVSROOT_DIRNAME}/trace/file2,v <-- file2 +S -> CVS_SERVER_SLEEP not set\. +S -> Leaving do_recursion ( frame=${PFMT} ) +S -> Leaving do_recursion ( frame=${PFMT} ) +S -> Leaving do_recursion ( frame=${PFMT} ) +S -> Lock_Cleanup() +S -> Lock_Cleanup() +S -> Lock_Cleanup() +S -> Parse_Info (${CVSROOT_DIRNAME}/CVSROOT/commitinfo, trace, ALL) +S -> Parse_Info (${CVSROOT_DIRNAME}/CVSROOT/loginfo, trace, ALL) +S -> Parse_Info (${CVSROOT_DIRNAME}/CVSROOT/verifymsg, trace, not ALL) +S -> Promotable_Lock () +S -> RCS_checkout (${CVSROOT_DIRNAME}/trace/file2,v, 1, , , (function)) +S -> RCS_cmp_file( ${CVSROOT_DIRNAME}/trace/file2,v, 1, (null), , file2 ) +S -> Register(file2, 1\.1, ${DATE}, , ) +S -> Simple_Lock_Cleanup() +S -> Simple_Lock_Cleanup() +S -> Simple_Lock_Cleanup() +S -> Simple_Lock_Cleanup() +S -> _lock_exists (${CVSROOT_DIRNAME}/trace, #cvs\.pfl\.\*, #cvs\.pfl\.${hostname}\.[0-9][0-9]*) +S -> _lock_exists (${CVSROOT_DIRNAME}/trace, #cvs\.pfl\.\*, #cvs\.pfl\.${hostname}\.[0-9][0-9]*) +S -> _lock_exists (${CVSROOT_DIRNAME}/trace, #cvs\.rfl\.\*, #cvs\.rfl\.${hostname}\.[0-9][0-9]*) +S -> dirswitch (\., ${CVSROOT_DIRNAME}/trace) +S -> do_cvs_command (commit) +S -> do_recursion ( frame=${PFMT} ) +S -> do_recursion ( frame=${PFMT} ) +S -> do_recursion ( frame=${PFMT} ) +S -> fopen(${CVSROOT_DIRNAME}/CVSROOT/history,a) +S -> lock_dir_for_write (${CVSROOT_DIRNAME}/trace) +S -> lock_name (${CVSROOT_DIRNAME}/trace, #cvs\.lock) +S -> lock_name (${CVSROOT_DIRNAME}/trace, #cvs\.lock) +S -> lock_name (${CVSROOT_DIRNAME}/trace, #cvs\.lock) +S -> lock_name (${CVSROOT_DIRNAME}/trace, #cvs\.pfl\.${hostname}\.[0-9][0-9]*) +S -> lock_name (${CVSROOT_DIRNAME}/trace, #cvs\.rfl\.${hostname}\.[0-9][0-9]*) +S -> lock_name (${CVSROOT_DIRNAME}/trace, #cvs\.wfl\.${hostname}\.[0-9][0-9]*) +S -> lock_name (${CVSROOT_DIRNAME}/trace, ) +S -> lock_name (${CVSROOT_DIRNAME}/trace, ) +S -> lock_name (${CVSROOT_DIRNAME}/trace, ) +S -> lock_simple_remove() +S -> lock_simple_remove() +S -> lock_tree_promotably (1, argv, 0, 1, 0) +S -> promotable_exists (${CVSROOT_DIRNAME}/trace) +S -> promotable_exists (${CVSROOT_DIRNAME}/trace) +S -> promotable_lock(${CVSROOT_DIRNAME}/trace) +S -> rcs_cleanup() +S -> readers_exist (${CVSROOT_DIRNAME}/trace) +S -> remove_locks() +S -> remove_locks() +S -> remove_locks() +S -> rename(${CVSROOT_DIRNAME}/trace/,file2,,${CVSROOT_DIRNAME}/trace/file2,v) +S -> rename(${CVSROOT_DIRNAME}/trace/,file2,,${CVSROOT_DIRNAME}/trace/file2,v) +S -> rename(CVS/Entries\.Backup,CVS/Entries) +S -> serve_directory (\.) +S -> server_cleanup() +S -> server_cleanup() +S -> server_notify() +S -> server_pathname_check (file2) +S -> server_pathname_check (file2) +S -> server_pathname_check (file2) +S -> server_register(file2, 1\.1, ${DATE}, , , , ) +S -> set_lock (${CVSROOT_DIRNAME}/trace, 0) +S -> set_lock (${CVSROOT_DIRNAME}/trace, 1) +S -> start_recursion ( fileproc=${PFMT}, filesdoneproc=${PFMT}, +S -> start_recursion ( fileproc=${PFMT}, filesdoneproc=${PFMT}, +S -> start_recursion ( fileproc=${PFMT}, filesdoneproc=${PFMT}, +S -> unlink_file(CVS/Entries\.Log) +S -> unlink_file(CVS/file2,t) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +initial revision: 1\.1" + dotest_sort trace-7 "${testcvs} -t -t -t tag bp" \ +" *callerdat=${PFMT}, argc=0, argv=${PFMT}, + *callerdat=${PFMT}, argc=0, argv=${PFMT}, + *direntproc=${PFMT}, dirleavproc=${PFMT}, + *direntproc=${PFMT}, dirleavproc=${PFMT}, + *dosrcs=1, repository_in= ) + *dosrcs=1, repository_in= ) + *local=0, which=1, aflag=0, + *local=0, which=1, aflag=0, + *locktype=1, update_preload=(null) + *locktype=2, update_preload=(null) + *local_specified=0, mname=(null), msg=(null) ) + *mwhere=(null), mfile=(null), shorten=0, + *-> Leaving do_recursion ( frame=${PFMT} ) + *-> Leaving do_recursion ( frame=${PFMT} ) + *-> Leaving do_recursion ( frame=${PFMT} ) + *-> Leaving do_recursion ( frame=${PFMT} ) + *-> Leaving do_recursion ( frame=${PFMT} ) + *-> Leaving do_recursion ( frame=${PFMT} ) + *-> Lock_Cleanup() + *-> Parse_Info (${CVSROOT_DIRNAME}/CVSROOT/taginfo, trace, ALL) + *-> Reader_Lock(${CVSROOT_DIRNAME}/trace) + *-> Reader_Lock(${CVSROOT_DIRNAME}/trace/subdir) + *-> Simple_Lock_Cleanup() + *-> Simple_Lock_Cleanup() + *-> Simple_Lock_Cleanup() + *-> Simple_Lock_Cleanup() + *-> Simple_Lock_Cleanup() + *-> _lock_exists (${CVSROOT_DIRNAME}/trace, #cvs\.pfl\.\*, (null)) + *-> _lock_exists (${CVSROOT_DIRNAME}/trace, #cvs\.rfl\.\*, (null)) + *-> _lock_exists (${CVSROOT_DIRNAME}/trace/subdir, #cvs\.pfl\.\*, (null)) + *-> _lock_exists (${CVSROOT_DIRNAME}/trace/subdir, #cvs\.rfl\.\*, (null)) + *-> check_fileproc ( ${CVSROOT_DIRNAME}/trace, file1, ${CVSROOT_DIRNAME}/trace/file1,v ) + *-> check_fileproc ( ${CVSROOT_DIRNAME}/trace, file2, ${CVSROOT_DIRNAME}/trace/file2,v ) + *-> do_recursion ( frame=${PFMT} ) + *-> do_recursion ( frame=${PFMT} ) + *-> do_recursion ( frame=${PFMT} ) + *-> do_recursion ( frame=${PFMT} ) + *-> do_recursion ( frame=${PFMT} ) + *-> do_recursion ( frame=${PFMT} ) + *-> lock_dir_for_write (${CVSROOT_DIRNAME}/trace) + *-> lock_dir_for_write (${CVSROOT_DIRNAME}/trace/subdir) + *-> lock_name (${CVSROOT_DIRNAME}/trace, #cvs\.lock) + *-> lock_name (${CVSROOT_DIRNAME}/trace, #cvs\.lock) + *-> lock_name (${CVSROOT_DIRNAME}/trace, #cvs\.lock) + *-> lock_name (${CVSROOT_DIRNAME}/trace, #cvs\.rfl\.${hostname}\.[0-9][0-9]*) + *-> lock_name (${CVSROOT_DIRNAME}/trace, #cvs\.wfl\.${hostname}\.[0-9][0-9]*) + *-> lock_name (${CVSROOT_DIRNAME}/trace, ) + *-> lock_name (${CVSROOT_DIRNAME}/trace, ) + *-> lock_name (${CVSROOT_DIRNAME}/trace/subdir, #cvs\.lock) + *-> lock_name (${CVSROOT_DIRNAME}/trace/subdir, #cvs\.lock) + *-> lock_name (${CVSROOT_DIRNAME}/trace/subdir, #cvs\.lock) + *-> lock_name (${CVSROOT_DIRNAME}/trace/subdir, #cvs\.rfl\.${hostname}\.[0-9][0-9]*) + *-> lock_name (${CVSROOT_DIRNAME}/trace/subdir, #cvs\.wfl\.${hostname}\.[0-9][0-9]*) + *-> lock_name (${CVSROOT_DIRNAME}/trace/subdir, ) + *-> lock_name (${CVSROOT_DIRNAME}/trace/subdir, ) + *-> lock_simple_remove() + *-> lock_simple_remove() + *-> lock_simple_remove() + *-> lock_simple_remove() + *-> main loop with CVSROOT=${CVSROOT_DIRNAME} + *-> parse_cvsroot ( ${CVSROOT_DIRNAME} ) + *-> promotable_exists (${CVSROOT_DIRNAME}/trace) + *-> promotable_exists (${CVSROOT_DIRNAME}/trace/subdir) + *-> rcs_cleanup() + *-> readers_exist (${CVSROOT_DIRNAME}/trace) + *-> readers_exist (${CVSROOT_DIRNAME}/trace/subdir) + *-> remove_locks() + *-> rename(${CVSROOT_DIRNAME}/trace/,file1,,${CVSROOT_DIRNAME}/trace/file1,v) + *-> rename(${CVSROOT_DIRNAME}/trace/,file2,,${CVSROOT_DIRNAME}/trace/file2,v) + *-> rename(CVS/Entries\.Backup,CVS/Entries) + *-> rtag_proc ( argc=1, argv=${PFMT}, xwhere=(null), + *-> set_lock (${CVSROOT_DIRNAME}/trace, 1) + *-> set_lock (${CVSROOT_DIRNAME}/trace, 1) + *-> set_lock (${CVSROOT_DIRNAME}/trace/subdir, 1) + *-> set_lock (${CVSROOT_DIRNAME}/trace/subdir, 1) + *-> start_recursion ( fileproc=${PFMT}, filesdoneproc=${PFMT}, + *-> start_recursion ( fileproc=${PFMT}, filesdoneproc=${PFMT}, + *-> unlink_file(CVS/Entries\.Log) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +T file1 +T file2 +${SPROG} tag: Tagging \. +${SPROG} tag: Tagging subdir" \ +" + *callerdat=${PFMT}, argc=0, argv=${PFMT}, + *callerdat=${PFMT}, argc=0, argv=${PFMT}, + *callerdat=${PFMT}, argc=0, argv=${PFMT}, + *direntproc=${PFMT}, dirleavproc=${PFMT}, + *direntproc=${PFMT}, dirleavproc=${PFMT}, + *direntproc=${PFMT}, dirleavproc=${PFMT}, + *dosrcs=0, repository_in=(null) ) + *dosrcs=1, repository_in= ) + *dosrcs=1, repository_in= ) + *local=0, which=1, aflag=0, + *local=0, which=1, aflag=0, + *local=0, which=1, aflag=0, + *locktype=0, update_preload=(null) + *locktype=1, update_preload=(null) + *locktype=2, update_preload=(null) + *local_specified=0, mname=(null), msg=(null) ) + *mwhere=(null), mfile=(null), shorten=0, + *-> Forking server: ${CVS_SERVER} server + *-> Leaving do_recursion ( frame=${PFMT} ) + *-> Leaving do_recursion ( frame=${PFMT} ) + *-> Leaving do_recursion ( frame=${PFMT} ) + *-> do_recursion ( frame=${PFMT} ) + *-> do_recursion ( frame=${PFMT} ) + *-> do_recursion ( frame=${PFMT} ) + *-> main loop with CVSROOT=${CVSROOT} + *-> parse_cvsroot ( ${CVSROOT} ) + *-> start_recursion ( fileproc=${PFMT}, filesdoneproc=${PFMT}, + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> CVS_SERVER_SLEEP not set\. +S -> Leaving do_recursion ( frame=${PFMT} ) +S -> Leaving do_recursion ( frame=${PFMT} ) +S -> Leaving do_recursion ( frame=${PFMT} ) +S -> Leaving do_recursion ( frame=${PFMT} ) +S -> Leaving do_recursion ( frame=${PFMT} ) +S -> Leaving do_recursion ( frame=${PFMT} ) +S -> Lock_Cleanup() +S -> Lock_Cleanup() +S -> Parse_Info (${CVSROOT_DIRNAME}/CVSROOT/taginfo, trace, ALL) +S -> Reader_Lock(${CVSROOT_DIRNAME}/trace) +S -> Reader_Lock(${CVSROOT_DIRNAME}/trace/subdir) +S -> Simple_Lock_Cleanup() +S -> Simple_Lock_Cleanup() +S -> Simple_Lock_Cleanup() +S -> Simple_Lock_Cleanup() +S -> Simple_Lock_Cleanup() +S -> Simple_Lock_Cleanup() +S -> _lock_exists (${CVSROOT_DIRNAME}/trace, #cvs\.pfl\.\*, (null)) +S -> _lock_exists (${CVSROOT_DIRNAME}/trace, #cvs\.rfl\.\*, (null)) +S -> _lock_exists (${CVSROOT_DIRNAME}/trace/subdir, #cvs\.pfl\.\*, (null)) +S -> _lock_exists (${CVSROOT_DIRNAME}/trace/subdir, #cvs\.rfl\.\*, (null)) +S -> check_fileproc ( ${CVSROOT_DIRNAME}/trace, file1, ${CVSROOT_DIRNAME}/trace/file1,v ) +S -> check_fileproc ( ${CVSROOT_DIRNAME}/trace, file2, ${CVSROOT_DIRNAME}/trace/file2,v ) +S -> dirswitch (\., ${CVSROOT_DIRNAME}/trace) +S -> dirswitch (\., ${CVSROOT_DIRNAME}/trace) +S -> dirswitch (subdir, ${CVSROOT_DIRNAME}/trace/subdir) +S -> do_cvs_command (tag) +S -> do_recursion ( frame=${PFMT} ) +S -> do_recursion ( frame=${PFMT} ) +S -> do_recursion ( frame=${PFMT} ) +S -> do_recursion ( frame=${PFMT} ) +S -> do_recursion ( frame=${PFMT} ) +S -> do_recursion ( frame=${PFMT} ) +S -> lock_dir_for_write (${CVSROOT_DIRNAME}/trace) +S -> lock_dir_for_write (${CVSROOT_DIRNAME}/trace/subdir) +S -> lock_name (${CVSROOT_DIRNAME}/trace, #cvs\.lock) +S -> lock_name (${CVSROOT_DIRNAME}/trace, #cvs\.lock) +S -> lock_name (${CVSROOT_DIRNAME}/trace, #cvs\.lock) +S -> lock_name (${CVSROOT_DIRNAME}/trace, #cvs\.rfl\.${hostname}\.[0-9][0-9]*) +S -> lock_name (${CVSROOT_DIRNAME}/trace, #cvs\.wfl\.${hostname}\.[0-9][0-9]*) +S -> lock_name (${CVSROOT_DIRNAME}/trace, ) +S -> lock_name (${CVSROOT_DIRNAME}/trace, ) +S -> lock_name (${CVSROOT_DIRNAME}/trace/subdir, #cvs\.lock) +S -> lock_name (${CVSROOT_DIRNAME}/trace/subdir, #cvs\.lock) +S -> lock_name (${CVSROOT_DIRNAME}/trace/subdir, #cvs\.lock) +S -> lock_name (${CVSROOT_DIRNAME}/trace/subdir, #cvs\.rfl\.${hostname}\.[0-9][0-9]*) +S -> lock_name (${CVSROOT_DIRNAME}/trace/subdir, #cvs\.wfl\.${hostname}\.[0-9][0-9]*) +S -> lock_name (${CVSROOT_DIRNAME}/trace/subdir, ) +S -> lock_name (${CVSROOT_DIRNAME}/trace/subdir, ) +S -> lock_simple_remove() +S -> lock_simple_remove() +S -> lock_simple_remove() +S -> lock_simple_remove() +S -> promotable_exists (${CVSROOT_DIRNAME}/trace) +S -> promotable_exists (${CVSROOT_DIRNAME}/trace/subdir) +S -> rcs_cleanup() +S -> readers_exist (${CVSROOT_DIRNAME}/trace) +S -> readers_exist (${CVSROOT_DIRNAME}/trace/subdir) +S -> remove_locks() +S -> remove_locks() +S -> rename(${CVSROOT_DIRNAME}/trace/,file1,,${CVSROOT_DIRNAME}/trace/file1,v) +S -> rename(${CVSROOT_DIRNAME}/trace/,file2,,${CVSROOT_DIRNAME}/trace/file2,v) +S -> rename(CVS/Entries\.Backup,CVS/Entries) +S -> rename(CVS/Entries\.Backup,CVS/Entries) +S -> rtag_proc ( argc=1, argv=${PFMT}, xwhere=(null), +S -> serve_directory (\.) +S -> serve_directory (\.) +S -> serve_directory (subdir) +S -> server_cleanup() +S -> server_cleanup() +S -> server_notify() +S -> set_lock (${CVSROOT_DIRNAME}/trace, 1) +S -> set_lock (${CVSROOT_DIRNAME}/trace, 1) +S -> set_lock (${CVSROOT_DIRNAME}/trace/subdir, 1) +S -> set_lock (${CVSROOT_DIRNAME}/trace/subdir, 1) +S -> start_recursion ( fileproc=${PFMT}, filesdoneproc=${PFMT}, +S -> start_recursion ( fileproc=${PFMT}, filesdoneproc=${PFMT}, +S -> unlink_file(CVS/Entries\.Log) +S -> unlink_file(CVS/Entries\.Log) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +T file1 +T file2 +${SPROG} tag: Tagging \. +${SPROG} tag: Tagging subdir" + + dotest_sort trace-8 "${testcvs} -t -t -t tag -b branch1" \ +" *callerdat=${PFMT}, argc=0, argv=${PFMT}, + *callerdat=${PFMT}, argc=0, argv=${PFMT}, + *direntproc=${PFMT}, dirleavproc=${PFMT}, + *direntproc=${PFMT}, dirleavproc=${PFMT}, + *dosrcs=1, repository_in= ) + *dosrcs=1, repository_in= ) + *local=0, which=1, aflag=0, + *local=0, which=1, aflag=0, + *locktype=1, update_preload=(null) + *locktype=2, update_preload=(null) + *local_specified=0, mname=(null), msg=(null) ) + *mwhere=(null), mfile=(null), shorten=0, + *-> Leaving do_recursion ( frame=${PFMT} ) + *-> Leaving do_recursion ( frame=${PFMT} ) + *-> Leaving do_recursion ( frame=${PFMT} ) + *-> Leaving do_recursion ( frame=${PFMT} ) + *-> Leaving do_recursion ( frame=${PFMT} ) + *-> Leaving do_recursion ( frame=${PFMT} ) + *-> Lock_Cleanup() + *-> Parse_Info (${CVSROOT_DIRNAME}/CVSROOT/taginfo, trace, ALL) + *-> Reader_Lock(${CVSROOT_DIRNAME}/trace) + *-> Reader_Lock(${CVSROOT_DIRNAME}/trace/subdir) + *-> Simple_Lock_Cleanup() + *-> Simple_Lock_Cleanup() + *-> Simple_Lock_Cleanup() + *-> Simple_Lock_Cleanup() + *-> Simple_Lock_Cleanup() + *-> _lock_exists (${CVSROOT_DIRNAME}/trace, #cvs\.pfl\.\*, (null)) + *-> _lock_exists (${CVSROOT_DIRNAME}/trace, #cvs\.rfl\.\*, (null)) + *-> _lock_exists (${CVSROOT_DIRNAME}/trace/subdir, #cvs\.pfl\.\*, (null)) + *-> _lock_exists (${CVSROOT_DIRNAME}/trace/subdir, #cvs\.rfl\.\*, (null)) + *-> check_fileproc ( ${CVSROOT_DIRNAME}/trace, file1, ${CVSROOT_DIRNAME}/trace/file1,v ) + *-> check_fileproc ( ${CVSROOT_DIRNAME}/trace, file2, ${CVSROOT_DIRNAME}/trace/file2,v ) + *-> do_recursion ( frame=${PFMT} ) + *-> do_recursion ( frame=${PFMT} ) + *-> do_recursion ( frame=${PFMT} ) + *-> do_recursion ( frame=${PFMT} ) + *-> do_recursion ( frame=${PFMT} ) + *-> do_recursion ( frame=${PFMT} ) + *-> lock_dir_for_write (${CVSROOT_DIRNAME}/trace) + *-> lock_dir_for_write (${CVSROOT_DIRNAME}/trace/subdir) + *-> lock_name (${CVSROOT_DIRNAME}/trace, #cvs\.lock) + *-> lock_name (${CVSROOT_DIRNAME}/trace, #cvs\.lock) + *-> lock_name (${CVSROOT_DIRNAME}/trace, #cvs\.lock) + *-> lock_name (${CVSROOT_DIRNAME}/trace, #cvs\.rfl\.${hostname}\.[0-9][0-9]*) + *-> lock_name (${CVSROOT_DIRNAME}/trace, #cvs\.wfl\.${hostname}\.[0-9][0-9]*) + *-> lock_name (${CVSROOT_DIRNAME}/trace, ) + *-> lock_name (${CVSROOT_DIRNAME}/trace, ) + *-> lock_name (${CVSROOT_DIRNAME}/trace/subdir, #cvs\.lock) + *-> lock_name (${CVSROOT_DIRNAME}/trace/subdir, #cvs\.lock) + *-> lock_name (${CVSROOT_DIRNAME}/trace/subdir, #cvs\.lock) + *-> lock_name (${CVSROOT_DIRNAME}/trace/subdir, #cvs\.rfl\.${hostname}\.[0-9][0-9]*) + *-> lock_name (${CVSROOT_DIRNAME}/trace/subdir, #cvs\.wfl\.${hostname}\.[0-9][0-9]*) + *-> lock_name (${CVSROOT_DIRNAME}/trace/subdir, ) + *-> lock_name (${CVSROOT_DIRNAME}/trace/subdir, ) + *-> lock_simple_remove() + *-> lock_simple_remove() + *-> lock_simple_remove() + *-> lock_simple_remove() + *-> main loop with CVSROOT=${CVSROOT_DIRNAME} + *-> parse_cvsroot ( ${CVSROOT_DIRNAME} ) + *-> promotable_exists (${CVSROOT_DIRNAME}/trace) + *-> promotable_exists (${CVSROOT_DIRNAME}/trace/subdir) + *-> rcs_cleanup() + *-> readers_exist (${CVSROOT_DIRNAME}/trace) + *-> readers_exist (${CVSROOT_DIRNAME}/trace/subdir) + *-> remove_locks() + *-> rename(${CVSROOT_DIRNAME}/trace/,file1,,${CVSROOT_DIRNAME}/trace/file1,v) + *-> rename(${CVSROOT_DIRNAME}/trace/,file2,,${CVSROOT_DIRNAME}/trace/file2,v) + *-> rtag_proc ( argc=1, argv=${PFMT}, xwhere=(null), + *-> set_lock (${CVSROOT_DIRNAME}/trace, 1) + *-> set_lock (${CVSROOT_DIRNAME}/trace, 1) + *-> set_lock (${CVSROOT_DIRNAME}/trace/subdir, 1) + *-> set_lock (${CVSROOT_DIRNAME}/trace/subdir, 1) + *-> start_recursion ( fileproc=${PFMT}, filesdoneproc=${PFMT}, + *-> start_recursion ( fileproc=${PFMT}, filesdoneproc=${PFMT}, + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +T file1 +T file2 +${SPROG} tag: Tagging \. +${SPROG} tag: Tagging subdir" \ +" + *callerdat=${PFMT}, argc=0, argv=${PFMT}, + *callerdat=${PFMT}, argc=0, argv=${PFMT}, + *callerdat=${PFMT}, argc=0, argv=${PFMT}, + *direntproc=${PFMT}, dirleavproc=${PFMT}, + *direntproc=${PFMT}, dirleavproc=${PFMT}, + *direntproc=${PFMT}, dirleavproc=${PFMT}, + *dosrcs=0, repository_in=(null) ) + *dosrcs=1, repository_in= ) + *dosrcs=1, repository_in= ) + *local=0, which=1, aflag=0, + *local=0, which=1, aflag=0, + *local=0, which=1, aflag=0, + *locktype=0, update_preload=(null) + *locktype=1, update_preload=(null) + *locktype=2, update_preload=(null) + *local_specified=0, mname=(null), msg=(null) ) + *mwhere=(null), mfile=(null), shorten=0, + *-> Forking server: ${CVS_SERVER} server + *-> Leaving do_recursion ( frame=${PFMT} ) + *-> Leaving do_recursion ( frame=${PFMT} ) + *-> Leaving do_recursion ( frame=${PFMT} ) + *-> do_recursion ( frame=${PFMT} ) + *-> do_recursion ( frame=${PFMT} ) + *-> do_recursion ( frame=${PFMT} ) + *-> main loop with CVSROOT=${CVSROOT} + *-> parse_cvsroot ( ${CVSROOT} ) + *-> start_recursion ( fileproc=${PFMT}, filesdoneproc=${PFMT}, + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> CVS_SERVER_SLEEP not set\. +S -> Leaving do_recursion ( frame=${PFMT} ) +S -> Leaving do_recursion ( frame=${PFMT} ) +S -> Leaving do_recursion ( frame=${PFMT} ) +S -> Leaving do_recursion ( frame=${PFMT} ) +S -> Leaving do_recursion ( frame=${PFMT} ) +S -> Leaving do_recursion ( frame=${PFMT} ) +S -> Lock_Cleanup() +S -> Lock_Cleanup() +S -> Parse_Info (${CVSROOT_DIRNAME}/CVSROOT/taginfo, trace, ALL) +S -> Reader_Lock(${CVSROOT_DIRNAME}/trace) +S -> Reader_Lock(${CVSROOT_DIRNAME}/trace/subdir) +S -> Simple_Lock_Cleanup() +S -> Simple_Lock_Cleanup() +S -> Simple_Lock_Cleanup() +S -> Simple_Lock_Cleanup() +S -> Simple_Lock_Cleanup() +S -> Simple_Lock_Cleanup() +S -> _lock_exists (${CVSROOT_DIRNAME}/trace, #cvs\.pfl\.\*, (null)) +S -> _lock_exists (${CVSROOT_DIRNAME}/trace, #cvs\.rfl\.\*, (null)) +S -> _lock_exists (${CVSROOT_DIRNAME}/trace/subdir, #cvs\.pfl\.\*, (null)) +S -> _lock_exists (${CVSROOT_DIRNAME}/trace/subdir, #cvs\.rfl\.\*, (null)) +S -> check_fileproc ( ${CVSROOT_DIRNAME}/trace, file1, ${CVSROOT_DIRNAME}/trace/file1,v ) +S -> check_fileproc ( ${CVSROOT_DIRNAME}/trace, file2, ${CVSROOT_DIRNAME}/trace/file2,v ) +S -> dirswitch (\., ${CVSROOT_DIRNAME}/trace) +S -> dirswitch (\., ${CVSROOT_DIRNAME}/trace) +S -> dirswitch (subdir, ${CVSROOT_DIRNAME}/trace/subdir) +S -> do_cvs_command (tag) +S -> do_recursion ( frame=${PFMT} ) +S -> do_recursion ( frame=${PFMT} ) +S -> do_recursion ( frame=${PFMT} ) +S -> do_recursion ( frame=${PFMT} ) +S -> do_recursion ( frame=${PFMT} ) +S -> do_recursion ( frame=${PFMT} ) +S -> lock_dir_for_write (${CVSROOT_DIRNAME}/trace) +S -> lock_dir_for_write (${CVSROOT_DIRNAME}/trace/subdir) +S -> lock_name (${CVSROOT_DIRNAME}/trace, #cvs\.lock) +S -> lock_name (${CVSROOT_DIRNAME}/trace, #cvs\.lock) +S -> lock_name (${CVSROOT_DIRNAME}/trace, #cvs\.lock) +S -> lock_name (${CVSROOT_DIRNAME}/trace, #cvs\.rfl\.${hostname}\.[0-9][0-9]*) +S -> lock_name (${CVSROOT_DIRNAME}/trace, #cvs\.wfl\.${hostname}\.[0-9][0-9]*) +S -> lock_name (${CVSROOT_DIRNAME}/trace, ) +S -> lock_name (${CVSROOT_DIRNAME}/trace, ) +S -> lock_name (${CVSROOT_DIRNAME}/trace/subdir, #cvs\.lock) +S -> lock_name (${CVSROOT_DIRNAME}/trace/subdir, #cvs\.lock) +S -> lock_name (${CVSROOT_DIRNAME}/trace/subdir, #cvs\.lock) +S -> lock_name (${CVSROOT_DIRNAME}/trace/subdir, #cvs\.rfl\.${hostname}\.[0-9][0-9]*) +S -> lock_name (${CVSROOT_DIRNAME}/trace/subdir, #cvs\.wfl\.${hostname}\.[0-9][0-9]*) +S -> lock_name (${CVSROOT_DIRNAME}/trace/subdir, ) +S -> lock_name (${CVSROOT_DIRNAME}/trace/subdir, ) +S -> lock_simple_remove() +S -> lock_simple_remove() +S -> lock_simple_remove() +S -> lock_simple_remove() +S -> promotable_exists (${CVSROOT_DIRNAME}/trace) +S -> promotable_exists (${CVSROOT_DIRNAME}/trace/subdir) +S -> rcs_cleanup() +S -> readers_exist (${CVSROOT_DIRNAME}/trace) +S -> readers_exist (${CVSROOT_DIRNAME}/trace/subdir) +S -> remove_locks() +S -> remove_locks() +S -> rename(${CVSROOT_DIRNAME}/trace/,file1,,${CVSROOT_DIRNAME}/trace/file1,v) +S -> rename(${CVSROOT_DIRNAME}/trace/,file2,,${CVSROOT_DIRNAME}/trace/file2,v) +S -> rename(CVS/Entries\.Backup,CVS/Entries) +S -> rename(CVS/Entries\.Backup,CVS/Entries) +S -> rtag_proc ( argc=1, argv=${PFMT}, xwhere=(null), +S -> serve_directory (\.) +S -> serve_directory (\.) +S -> serve_directory (subdir) +S -> server_cleanup() +S -> server_cleanup() +S -> server_notify() +S -> set_lock (${CVSROOT_DIRNAME}/trace, 1) +S -> set_lock (${CVSROOT_DIRNAME}/trace, 1) +S -> set_lock (${CVSROOT_DIRNAME}/trace/subdir, 1) +S -> set_lock (${CVSROOT_DIRNAME}/trace/subdir, 1) +S -> start_recursion ( fileproc=${PFMT}, filesdoneproc=${PFMT}, +S -> start_recursion ( fileproc=${PFMT}, filesdoneproc=${PFMT}, +S -> unlink_file(CVS/Entries\.Log) +S -> unlink_file(CVS/Entries\.Log) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +T file1 +T file2 +${SPROG} tag: Tagging \. +${SPROG} tag: Tagging subdir" + dotest_sort trace-9 "${testcvs} -t -t -t log" \ +" + + *callerdat=${PFMT}, argc=0, argv=${PFMT}, + *direntproc=${PFMT}, dirleavproc=${PFMT}, + *dosrcs=1, repository_in=(null) ) + *local=0, which=7, aflag=0, + *locktype=1, update_preload=(null) + *-> Leaving do_recursion ( frame=${PFMT} ) + *-> Leaving do_recursion ( frame=${PFMT} ) + *-> Leaving do_recursion ( frame=${PFMT} ) + *-> Lock_Cleanup() + *-> Reader_Lock(${CVSROOT_DIRNAME}/trace) + *-> Reader_Lock(${CVSROOT_DIRNAME}/trace/subdir) + *-> Simple_Lock_Cleanup() + *-> Simple_Lock_Cleanup() + *-> Simple_Lock_Cleanup() + *-> do_recursion ( frame=${PFMT} ) + *-> do_recursion ( frame=${PFMT} ) + *-> do_recursion ( frame=${PFMT} ) + *-> lock_name (${CVSROOT_DIRNAME}/trace, #cvs\.lock) + *-> lock_name (${CVSROOT_DIRNAME}/trace, #cvs\.rfl\.${hostname}\.[0-9][0-9]*) + *-> lock_name (${CVSROOT_DIRNAME}/trace/subdir, #cvs\.lock) + *-> lock_name (${CVSROOT_DIRNAME}/trace/subdir, #cvs\.rfl\.${hostname}\.[0-9][0-9]*) + *-> lock_simple_remove() + *-> lock_simple_remove() + *-> main loop with CVSROOT=${CVSROOT_DIRNAME} + *-> parse_cvsroot ( ${CVSROOT_DIRNAME} ) + *-> remove_locks() + *-> set_lock (${CVSROOT_DIRNAME}/trace, 1) + *-> set_lock (${CVSROOT_DIRNAME}/trace/subdir, 1) + *-> start_recursion ( fileproc=${PFMT}, filesdoneproc=${PFMT}, + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + MYVENDOR: 1\.1\.1 + bp: 1\.1 + bp: 1\.1\.1\.1 + branch1: 1\.1\.0\.2 + branch1: 1\.1\.1\.1\.0\.2 + version-1: 1\.1\.1\.1 +---------------------------- +---------------------------- +---------------------------- +============================================================================= +============================================================================= +Initial revision +RCS file: ${CVSROOT_DIRNAME}/trace/file1,v +RCS file: ${CVSROOT_DIRNAME}/trace/file2,v +Working file: file1 +Working file: file2 +access list: +access list: +branch: +branch: 1\.1\.1 +branches: 1\.1\.1; +${SPROG} log: Logging \. +${SPROG} log: Logging subdir +date: ${ISO8601DATE}; author: ${username}; state: Exp; commitid: ${commitid}; +date: ${ISO8601DATE}; author: ${username}; state: Exp; lines: ${PLUS}0 -0; commitid: ${commitid}; +date: ${ISO8601DATE}; author: ${username}; state: Exp; commitid: ${commitid}; +description: +description: +head: 1\.1 +head: 1\.1 +import +keyword substitution: kv +keyword substitution: kv +locks: strict +locks: strict +new-file +revision 1\.1 +revision 1\.1 +revision 1\.1\.1\.1 +symbolic names: +symbolic names: +total revisions: 1; selected revisions: 1 +total revisions: 2; selected revisions: 2" \ +" + + + *callerdat=${PFMT}, argc=0, argv=${PFMT}, + *callerdat=${PFMT}, argc=0, argv=${PFMT}, + *direntproc=${PFMT}, dirleavproc=${PFMT}, + *direntproc=${PFMT}, dirleavproc=${PFMT}, + *dosrcs=0, repository_in=(null) ) + *dosrcs=1, repository_in=(null) ) + *local=0, which=1, aflag=0, + *local=0, which=7, aflag=0, + *locktype=0, update_preload=(null) + *locktype=1, update_preload=(null) + *-> Forking server: ${CVS_SERVER} server + *-> Leaving do_recursion ( frame=${PFMT} ) + *-> Leaving do_recursion ( frame=${PFMT} ) + *-> Leaving do_recursion ( frame=${PFMT} ) + *-> do_recursion ( frame=${PFMT} ) + *-> do_recursion ( frame=${PFMT} ) + *-> do_recursion ( frame=${PFMT} ) + *-> main loop with CVSROOT=${CVSROOT} + *-> parse_cvsroot ( ${CVSROOT} ) + *-> start_recursion ( fileproc=${PFMT}, filesdoneproc=${PFMT}, + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + MYVENDOR: 1\.1\.1 + bp: 1\.1 + bp: 1\.1\.1\.1 + branch1: 1\.1\.0\.2 + branch1: 1\.1\.1\.1\.0\.2 + version-1: 1\.1\.1\.1 +---------------------------- +---------------------------- +---------------------------- +============================================================================= +============================================================================= +Initial revision +RCS file: ${CVSROOT_DIRNAME}/trace/file1,v +RCS file: ${CVSROOT_DIRNAME}/trace/file2,v +S -> CVS_SERVER_SLEEP not set\. +S -> Leaving do_recursion ( frame=${PFMT} ) +S -> Leaving do_recursion ( frame=${PFMT} ) +S -> Leaving do_recursion ( frame=${PFMT} ) +S -> Lock_Cleanup() +S -> Lock_Cleanup() +S -> Reader_Lock(${CVSROOT_DIRNAME}/trace) +S -> Reader_Lock(${CVSROOT_DIRNAME}/trace/subdir) +S -> Simple_Lock_Cleanup() +S -> Simple_Lock_Cleanup() +S -> Simple_Lock_Cleanup() +S -> Simple_Lock_Cleanup() +S -> dirswitch (\., ${CVSROOT_DIRNAME}/trace) +S -> dirswitch (\., ${CVSROOT_DIRNAME}/trace) +S -> dirswitch (subdir, ${CVSROOT_DIRNAME}/trace/subdir) +S -> do_cvs_command (log) +S -> do_recursion ( frame=${PFMT} ) +S -> do_recursion ( frame=${PFMT} ) +S -> do_recursion ( frame=${PFMT} ) +S -> lock_name (${CVSROOT_DIRNAME}/trace, #cvs\.lock) +S -> lock_name (${CVSROOT_DIRNAME}/trace, #cvs\.rfl\.${hostname}\.[0-9][0-9]*) +S -> lock_name (${CVSROOT_DIRNAME}/trace/subdir, #cvs\.lock) +S -> lock_name (${CVSROOT_DIRNAME}/trace/subdir, #cvs\.rfl\.${hostname}\.[0-9][0-9]*) +S -> lock_simple_remove() +S -> lock_simple_remove() +S -> remove_locks() +S -> remove_locks() +S -> rename(CVS/Entries\.Backup,CVS/Entries) +S -> rename(CVS/Entries\.Backup,CVS/Entries) +S -> serve_directory (\.) +S -> serve_directory (\.) +S -> serve_directory (subdir) +S -> server_cleanup() +S -> server_cleanup() +S -> server_notify() +S -> set_lock (${CVSROOT_DIRNAME}/trace, 1) +S -> set_lock (${CVSROOT_DIRNAME}/trace/subdir, 1) +S -> start_recursion ( fileproc=${PFMT}, filesdoneproc=${PFMT}, +S -> unlink_file(CVS/Entries\.Log) +S -> unlink_file(CVS/Entries\.Log) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +Working file: file1 +Working file: file2 +access list: +access list: +branch: +branch: 1\.1\.1 +branches: 1\.1\.1; +${SPROG} log: Logging \. +${SPROG} log: Logging subdir +date: ${ISO8601DATE}; author: ${username}; state: Exp; commitid: ${commitid}; +date: ${ISO8601DATE}; author: ${username}; state: Exp; lines: ${PLUS}0 -0; commitid: ${commitid}; +date: ${ISO8601DATE}; author: ${username}; state: Exp; commitid: ${commitid}; +description: +description: +head: 1\.1 +head: 1\.1 +import +keyword substitution: kv +keyword substitution: kv +locks: strict +locks: strict +new-file +revision 1\.1 +revision 1\.1 +revision 1\.1\.1\.1 +symbolic names: +symbolic names: +total revisions: 1; selected revisions: 1 +total revisions: 2; selected revisions: 2" + + dotest_sort trace-10 "${testcvs} -t -t -t annotate file1" \ +" + *callerdat=${PFMT}, argc=1, argv=${PFMT}, + *direntproc=${PFMT}, dirleavproc=${PFMT}, + *dosrcs=1, repository_in= ) + *local=0, which=1, aflag=0, + *locktype=1, update_preload=(null) + *-> Leaving do_recursion ( frame=${PFMT} ) + *-> Lock_Cleanup() + *-> Reader_Lock(${CVSROOT_DIRNAME}/trace) + *-> Simple_Lock_Cleanup() + *-> Simple_Lock_Cleanup() + *-> do_recursion ( frame=${PFMT} ) + *-> lock_name (${CVSROOT_DIRNAME}/trace, #cvs\.lock) + *-> lock_name (${CVSROOT_DIRNAME}/trace, #cvs\.rfl\.${hostname}\.[0-9][0-9]*) + *-> lock_simple_remove() + *-> main loop with CVSROOT=${CVSROOT_DIRNAME} + *-> parse_cvsroot ( ${CVSROOT_DIRNAME} ) + *-> remove_locks() + *-> set_lock (${CVSROOT_DIRNAME}/trace, 1) + *-> start_recursion ( fileproc=${PFMT}, filesdoneproc=${PFMT}, + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* +Annotations for file1" \ +" + + *callerdat=${PFMT}, argc=1, argv=${PFMT}, + *callerdat=${PFMT}, argc=1, argv=${PFMT}, + *direntproc=${PFMT}, dirleavproc=${PFMT}, + *direntproc=${PFMT}, dirleavproc=${PFMT}, + *dosrcs=0, repository_in=(null) ) + *dosrcs=1, repository_in= ) + *local=0, which=1, aflag=0, + *local=0, which=1, aflag=0, + *locktype=0, update_preload=(null) + *locktype=1, update_preload=(null) + *-> Forking server: ${CVS_SERVER} server + *-> Leaving do_recursion ( frame=${PFMT} ) + *-> do_recursion ( frame=${PFMT} ) + *-> main loop with CVSROOT=${CVSROOT} + *-> parse_cvsroot ( ${CVSROOT} ) + *-> start_recursion ( fileproc=${PFMT}, filesdoneproc=${PFMT}, + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* +Annotations for file1 +S -> CVS_SERVER_SLEEP not set\. +S -> Leaving do_recursion ( frame=${PFMT} ) +S -> Lock_Cleanup() +S -> Lock_Cleanup() +S -> Reader_Lock(${CVSROOT_DIRNAME}/trace) +S -> Simple_Lock_Cleanup() +S -> Simple_Lock_Cleanup() +S -> Simple_Lock_Cleanup() +S -> dirswitch (\., ${CVSROOT_DIRNAME}/trace) +S -> do_cvs_command (annotate) +S -> do_recursion ( frame=${PFMT} ) +S -> lock_name (${CVSROOT_DIRNAME}/trace, #cvs\.lock) +S -> lock_name (${CVSROOT_DIRNAME}/trace, #cvs\.rfl\.${hostname}\.[0-9][0-9]*) +S -> lock_simple_remove() +S -> remove_locks() +S -> remove_locks() +S -> serve_directory (\.) +S -> server_cleanup() +S -> server_cleanup() +S -> server_notify() +S -> server_pathname_check (file1) +S -> set_lock (${CVSROOT_DIRNAME}/trace, 1) +S -> start_recursion ( fileproc=${PFMT}, filesdoneproc=${PFMT}, +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} )" + + dotest_sort \ +trace-11 "${testcvs} -t -t -t rtag -r bp -b branch2 trace" \ +" *aflag=0, repository=${CVSROOT_DIRNAME}/trace ) + *callerdat=${PFMT}, argc=0, argv=${PFMT}, + *callerdat=${PFMT}, argc=0, argv=${PFMT}, + *callerdat=${PFMT}, argc=0, argv=${PFMT}, + *direntproc=${PFMT}, dirleavproc=${PFMT}, + *direntproc=${PFMT}, dirleavproc=${PFMT}, + *direntproc=${PFMT}, dirleavproc=${PFMT}, + *dosrcs=1, repository_in=${CVSROOT_DIRNAME}/trace ) + *dosrcs=1, repository_in=${CVSROOT_DIRNAME}/trace ) + *dosrcs=1, repository_in=${CVSROOT_DIRNAME}/trace ) + *local=0, which=6, aflag=0, + *local=0, which=6, aflag=0, + *local=0, which=6, aflag=0, + *locktype=1, update_preload=(null) + *locktype=1, update_preload=trace + *locktype=2, update_preload=trace + *local_specified=0, mname=trace, msg=Tagging ) + *mwhere=(null), mfile=(null), shorten=0, + *-> Leaving do_recursion ( frame=${PFMT} ) + *-> Leaving do_recursion ( frame=${PFMT} ) + *-> Leaving do_recursion ( frame=${PFMT} ) + *-> Leaving do_recursion ( frame=${PFMT} ) + *-> Leaving do_recursion ( frame=${PFMT} ) + *-> Leaving do_recursion ( frame=${PFMT} ) + *-> Leaving do_recursion ( frame=${PFMT} ) + *-> Leaving do_recursion ( frame=${PFMT} ) + *-> Leaving do_recursion ( frame=${PFMT} ) + *-> Lock_Cleanup() + *-> Parse_Info (${CVSROOT_DIRNAME}/CVSROOT/taginfo, trace, ALL) + *-> Reader_Lock(${CVSROOT_DIRNAME}/trace) + *-> Reader_Lock(${CVSROOT_DIRNAME}/trace) + *-> Reader_Lock(${CVSROOT_DIRNAME}/trace/subdir) + *-> Reader_Lock(${CVSROOT_DIRNAME}/trace/subdir) + *-> Simple_Lock_Cleanup() + *-> Simple_Lock_Cleanup() + *-> Simple_Lock_Cleanup() + *-> Simple_Lock_Cleanup() + *-> Simple_Lock_Cleanup() + *-> Simple_Lock_Cleanup() + *-> Simple_Lock_Cleanup() + *-> _lock_exists (${CVSROOT_DIRNAME}/trace, #cvs\.pfl\.\*, (null)) + *-> _lock_exists (${CVSROOT_DIRNAME}/trace, #cvs\.rfl\.\*, (null)) + *-> _lock_exists (${CVSROOT_DIRNAME}/trace/subdir, #cvs\.pfl\.\*, (null)) + *-> _lock_exists (${CVSROOT_DIRNAME}/trace/subdir, #cvs\.rfl\.\*, (null)) + *-> check_fileproc ( ${CVSROOT_DIRNAME}/trace, trace/file1, ${CVSROOT_DIRNAME}/trace/file1,v ) + *-> check_fileproc ( ${CVSROOT_DIRNAME}/trace, trace/file2, ${CVSROOT_DIRNAME}/trace/file2,v ) + *-> do_module (trace, Tagging, NULL, branch2) + *-> do_recursion ( frame=${PFMT} ) + *-> do_recursion ( frame=${PFMT} ) + *-> do_recursion ( frame=${PFMT} ) + *-> do_recursion ( frame=${PFMT} ) + *-> do_recursion ( frame=${PFMT} ) + *-> do_recursion ( frame=${PFMT} ) + *-> do_recursion ( frame=${PFMT} ) + *-> do_recursion ( frame=${PFMT} ) + *-> do_recursion ( frame=${PFMT} ) + *-> fopen(${CVSROOT_DIRNAME}/CVSROOT/history,a) + *-> lock_dir_for_write (${CVSROOT_DIRNAME}/trace) + *-> lock_dir_for_write (${CVSROOT_DIRNAME}/trace/subdir) + *-> lock_name (${CVSROOT_DIRNAME}/trace, #cvs\.lock) + *-> lock_name (${CVSROOT_DIRNAME}/trace, #cvs\.lock) + *-> lock_name (${CVSROOT_DIRNAME}/trace, #cvs\.lock) + *-> lock_name (${CVSROOT_DIRNAME}/trace, #cvs\.lock) + *-> lock_name (${CVSROOT_DIRNAME}/trace, #cvs\.rfl\.${hostname}\.[0-9][0-9]*) + *-> lock_name (${CVSROOT_DIRNAME}/trace, #cvs\.rfl\.${hostname}\.[0-9][0-9]*) + *-> lock_name (${CVSROOT_DIRNAME}/trace, #cvs\.wfl\.${hostname}\.[0-9][0-9]*) + *-> lock_name (${CVSROOT_DIRNAME}/trace, ) + *-> lock_name (${CVSROOT_DIRNAME}/trace, ) + *-> lock_name (${CVSROOT_DIRNAME}/trace/subdir, #cvs\.lock) + *-> lock_name (${CVSROOT_DIRNAME}/trace/subdir, #cvs\.lock) + *-> lock_name (${CVSROOT_DIRNAME}/trace/subdir, #cvs\.lock) + *-> lock_name (${CVSROOT_DIRNAME}/trace/subdir, #cvs\.lock) + *-> lock_name (${CVSROOT_DIRNAME}/trace/subdir, #cvs\.rfl\.${hostname}\.[0-9][0-9]*) + *-> lock_name (${CVSROOT_DIRNAME}/trace/subdir, #cvs\.rfl\.${hostname}\.[0-9][0-9]*) + *-> lock_name (${CVSROOT_DIRNAME}/trace/subdir, #cvs\.wfl\.${hostname}\.[0-9][0-9]*) + *-> lock_name (${CVSROOT_DIRNAME}/trace/subdir, ) + *-> lock_name (${CVSROOT_DIRNAME}/trace/subdir, ) + *-> lock_simple_remove() + *-> lock_simple_remove() + *-> lock_simple_remove() + *-> lock_simple_remove() + *-> lock_simple_remove() + *-> lock_simple_remove() + *-> main loop with CVSROOT=${CVSROOT_DIRNAME} + *-> parse_cvsroot ( ${CVSROOT_DIRNAME} ) + *-> promotable_exists (${CVSROOT_DIRNAME}/trace) + *-> promotable_exists (${CVSROOT_DIRNAME}/trace/subdir) + *-> rcs_cleanup() + *-> readers_exist (${CVSROOT_DIRNAME}/trace) + *-> readers_exist (${CVSROOT_DIRNAME}/trace/subdir) + *-> remove_locks() + *-> rename(${CVSROOT_DIRNAME}/trace/,file1,,${CVSROOT_DIRNAME}/trace/file1,v) + *-> rename(${CVSROOT_DIRNAME}/trace/,file2,,${CVSROOT_DIRNAME}/trace/file2,v) + *-> rtag_proc ( argc=1, argv=${PFMT}, xwhere=(null), + *-> set_lock (${CVSROOT_DIRNAME}/trace, 1) + *-> set_lock (${CVSROOT_DIRNAME}/trace, 1) + *-> set_lock (${CVSROOT_DIRNAME}/trace, 1) + *-> set_lock (${CVSROOT_DIRNAME}/trace/subdir, 1) + *-> set_lock (${CVSROOT_DIRNAME}/trace/subdir, 1) + *-> set_lock (${CVSROOT_DIRNAME}/trace/subdir, 1) + *-> start_recursion ( fileproc=${PFMT}, filesdoneproc=${PFMT}, + *-> start_recursion ( fileproc=${PFMT}, filesdoneproc=${PFMT}, + *-> start_recursion ( fileproc=${PFMT}, filesdoneproc=${PFMT}, + *-> tag_check_valid ( name=bp, argc=0, argv=${PFMT}, local=0, + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +${SPROG} rtag: Tagging trace +${SPROG} rtag: Tagging trace/subdir" \ +" + *aflag=0, repository=${CVSROOT_DIRNAME}/trace ) + *callerdat=${PFMT}, argc=0, argv=${PFMT}, + *callerdat=${PFMT}, argc=0, argv=${PFMT}, + *callerdat=${PFMT}, argc=0, argv=${PFMT}, + *direntproc=${PFMT}, dirleavproc=${PFMT}, + *direntproc=${PFMT}, dirleavproc=${PFMT}, + *direntproc=${PFMT}, dirleavproc=${PFMT}, + *dosrcs=1, repository_in=${CVSROOT_DIRNAME}/trace ) + *dosrcs=1, repository_in=${CVSROOT_DIRNAME}/trace ) + *dosrcs=1, repository_in=${CVSROOT_DIRNAME}/trace ) + *local=0, which=6, aflag=0, + *local=0, which=6, aflag=0, + *local=0, which=6, aflag=0, + *locktype=1, update_preload=(null) + *locktype=1, update_preload=trace + *locktype=2, update_preload=trace + *local_specified=0, mname=trace, msg=Tagging ) + *mwhere=(null), mfile=(null), shorten=0, + *-> Forking server: ${CVS_SERVER} server + *-> main loop with CVSROOT=${CVSROOT} + *-> parse_cvsroot ( ${CVSROOT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> CVS_SERVER_SLEEP not set\. +S -> Leaving do_recursion ( frame=${PFMT} ) +S -> Leaving do_recursion ( frame=${PFMT} ) +S -> Leaving do_recursion ( frame=${PFMT} ) +S -> Leaving do_recursion ( frame=${PFMT} ) +S -> Leaving do_recursion ( frame=${PFMT} ) +S -> Leaving do_recursion ( frame=${PFMT} ) +S -> Leaving do_recursion ( frame=${PFMT} ) +S -> Leaving do_recursion ( frame=${PFMT} ) +S -> Leaving do_recursion ( frame=${PFMT} ) +S -> Lock_Cleanup() +S -> Lock_Cleanup() +S -> Parse_Info (${CVSROOT_DIRNAME}/CVSROOT/taginfo, trace, ALL) +S -> Reader_Lock(${CVSROOT_DIRNAME}/trace) +S -> Reader_Lock(${CVSROOT_DIRNAME}/trace) +S -> Reader_Lock(${CVSROOT_DIRNAME}/trace/subdir) +S -> Reader_Lock(${CVSROOT_DIRNAME}/trace/subdir) +S -> Simple_Lock_Cleanup() +S -> Simple_Lock_Cleanup() +S -> Simple_Lock_Cleanup() +S -> Simple_Lock_Cleanup() +S -> Simple_Lock_Cleanup() +S -> Simple_Lock_Cleanup() +S -> Simple_Lock_Cleanup() +S -> Simple_Lock_Cleanup() +S -> _lock_exists (${CVSROOT_DIRNAME}/trace, #cvs\.pfl\.\*, (null)) +S -> _lock_exists (${CVSROOT_DIRNAME}/trace, #cvs\.rfl\.\*, (null)) +S -> _lock_exists (${CVSROOT_DIRNAME}/trace/subdir, #cvs\.pfl\.\*, (null)) +S -> _lock_exists (${CVSROOT_DIRNAME}/trace/subdir, #cvs\.rfl\.\*, (null)) +S -> check_fileproc ( ${CVSROOT_DIRNAME}/trace, trace/file1, ${CVSROOT_DIRNAME}/trace/file1,v ) +S -> check_fileproc ( ${CVSROOT_DIRNAME}/trace, trace/file2, ${CVSROOT_DIRNAME}/trace/file2,v ) +S -> do_cvs_command (rtag) +S -> do_module (trace, Tagging, NULL, branch2) +S -> do_recursion ( frame=${PFMT} ) +S -> do_recursion ( frame=${PFMT} ) +S -> do_recursion ( frame=${PFMT} ) +S -> do_recursion ( frame=${PFMT} ) +S -> do_recursion ( frame=${PFMT} ) +S -> do_recursion ( frame=${PFMT} ) +S -> do_recursion ( frame=${PFMT} ) +S -> do_recursion ( frame=${PFMT} ) +S -> do_recursion ( frame=${PFMT} ) +S -> fopen(${CVSROOT_DIRNAME}/CVSROOT/history,a) +S -> lock_dir_for_write (${CVSROOT_DIRNAME}/trace) +S -> lock_dir_for_write (${CVSROOT_DIRNAME}/trace/subdir) +S -> lock_name (${CVSROOT_DIRNAME}/trace, #cvs\.lock) +S -> lock_name (${CVSROOT_DIRNAME}/trace, #cvs\.lock) +S -> lock_name (${CVSROOT_DIRNAME}/trace, #cvs\.lock) +S -> lock_name (${CVSROOT_DIRNAME}/trace, #cvs\.lock) +S -> lock_name (${CVSROOT_DIRNAME}/trace, #cvs\.rfl\.${hostname}\.[0-9][0-9]*) +S -> lock_name (${CVSROOT_DIRNAME}/trace, #cvs\.rfl\.${hostname}\.[0-9][0-9]*) +S -> lock_name (${CVSROOT_DIRNAME}/trace, #cvs\.wfl\.${hostname}\.[0-9][0-9]*) +S -> lock_name (${CVSROOT_DIRNAME}/trace, ) +S -> lock_name (${CVSROOT_DIRNAME}/trace, ) +S -> lock_name (${CVSROOT_DIRNAME}/trace/subdir, #cvs\.lock) +S -> lock_name (${CVSROOT_DIRNAME}/trace/subdir, #cvs\.lock) +S -> lock_name (${CVSROOT_DIRNAME}/trace/subdir, #cvs\.lock) +S -> lock_name (${CVSROOT_DIRNAME}/trace/subdir, #cvs\.lock) +S -> lock_name (${CVSROOT_DIRNAME}/trace/subdir, #cvs\.rfl\.${hostname}\.[0-9][0-9]*) +S -> lock_name (${CVSROOT_DIRNAME}/trace/subdir, #cvs\.rfl\.${hostname}\.[0-9][0-9]*) +S -> lock_name (${CVSROOT_DIRNAME}/trace/subdir, #cvs\.wfl\.${hostname}\.[0-9][0-9]*) +S -> lock_name (${CVSROOT_DIRNAME}/trace/subdir, ) +S -> lock_name (${CVSROOT_DIRNAME}/trace/subdir, ) +S -> lock_simple_remove() +S -> lock_simple_remove() +S -> lock_simple_remove() +S -> lock_simple_remove() +S -> lock_simple_remove() +S -> lock_simple_remove() +S -> promotable_exists (${CVSROOT_DIRNAME}/trace) +S -> promotable_exists (${CVSROOT_DIRNAME}/trace/subdir) +S -> rcs_cleanup() +S -> readers_exist (${CVSROOT_DIRNAME}/trace) +S -> readers_exist (${CVSROOT_DIRNAME}/trace/subdir) +S -> remove_locks() +S -> remove_locks() +S -> rename(${CVSROOT_DIRNAME}/trace/,file1,,${CVSROOT_DIRNAME}/trace/file1,v) +S -> rename(${CVSROOT_DIRNAME}/trace/,file2,,${CVSROOT_DIRNAME}/trace/file2,v) +S -> rtag_proc ( argc=1, argv=${PFMT}, xwhere=(null), +S -> server_cleanup() +S -> server_cleanup() +S -> server_notify() +S -> set_lock (${CVSROOT_DIRNAME}/trace, 1) +S -> set_lock (${CVSROOT_DIRNAME}/trace, 1) +S -> set_lock (${CVSROOT_DIRNAME}/trace, 1) +S -> set_lock (${CVSROOT_DIRNAME}/trace/subdir, 1) +S -> set_lock (${CVSROOT_DIRNAME}/trace/subdir, 1) +S -> set_lock (${CVSROOT_DIRNAME}/trace/subdir, 1) +S -> start_recursion ( fileproc=${PFMT}, filesdoneproc=${PFMT}, +S -> start_recursion ( fileproc=${PFMT}, filesdoneproc=${PFMT}, +S -> start_recursion ( fileproc=${PFMT}, filesdoneproc=${PFMT}, +S -> tag_check_valid ( name=bp, argc=0, argv=${PFMT}, local=0, +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +${SPROG} rtag: Tagging trace +${SPROG} rtag: Tagging trace/subdir" + + dotest_sort trace-12 "${testcvs} -t -t -t status file1" \ +" + + *callerdat=${PFMT}, argc=1, argv=${PFMT}, + *direntproc=${PFMT}, dirleavproc=${PFMT}, + *dosrcs=1, repository_in=(null) ) + *local=0, which=1, aflag=0, + *locktype=1, update_preload=(null) + Repository revision: 1\.1\.1\.1 ${CVSROOT_DIRNAME}/trace/file1,v + Sticky Date: (none) + Sticky Options: (none) + Sticky Tag: (none) + Working revision: 1\.1\.1\.1 ${DATE} + *-> Leaving do_recursion ( frame=${PFMT} ) + *-> Lock_Cleanup() + *-> Reader_Lock(${CVSROOT_DIRNAME}/trace) + *-> Simple_Lock_Cleanup() + *-> Simple_Lock_Cleanup() + *-> do_recursion ( frame=${PFMT} ) + *-> lock_name (${CVSROOT_DIRNAME}/trace, #cvs\.lock) + *-> lock_name (${CVSROOT_DIRNAME}/trace, #cvs\.rfl\.${hostname}\.[0-9][0-9]*) + *-> lock_simple_remove() + *-> main loop with CVSROOT=${CVSROOT_DIRNAME} + *-> parse_cvsroot ( ${CVSROOT_DIRNAME} ) + *-> remove_locks() + *-> set_lock (${CVSROOT_DIRNAME}/trace, 1) + *-> start_recursion ( fileproc=${PFMT}, filesdoneproc=${PFMT}, + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +=================================================================== +File: file1 *Status: Up-to-date" \ +" + + + *callerdat=${PFMT}, argc=1, argv=${PFMT}, + *callerdat=${PFMT}, argc=1, argv=${PFMT}, + *direntproc=${PFMT}, dirleavproc=${PFMT}, + *direntproc=${PFMT}, dirleavproc=${PFMT}, + *dosrcs=0, repository_in=(null) ) + *dosrcs=1, repository_in=(null) ) + *local=0, which=1, aflag=0, + *local=0, which=1, aflag=0, + *locktype=0, update_preload=(null) + *locktype=1, update_preload=(null) + Repository revision: 1\.1\.1\.1 ${CVSROOT_DIRNAME}/trace/file1,v + Sticky Date: (none) + Sticky Options: (none) + Sticky Tag: (none) + Working revision: 1\.1\.1\.1 + *-> Forking server: ${CVS_SERVER} server + *-> Leaving do_recursion ( frame=${PFMT} ) + *-> do_recursion ( frame=${PFMT} ) + *-> main loop with CVSROOT=${CVSROOT} + *-> parse_cvsroot ( ${CVSROOT} ) + *-> start_recursion ( fileproc=${PFMT}, filesdoneproc=${PFMT}, + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +=================================================================== +File: file1 *Status: Up-to-date +S -> CVS_SERVER_SLEEP not set\. +S -> Leaving do_recursion ( frame=${PFMT} ) +S -> Lock_Cleanup() +S -> Lock_Cleanup() +S -> Reader_Lock(${CVSROOT_DIRNAME}/trace) +S -> Simple_Lock_Cleanup() +S -> Simple_Lock_Cleanup() +S -> Simple_Lock_Cleanup() +S -> dirswitch (\., ${CVSROOT_DIRNAME}/trace) +S -> do_cvs_command (status) +S -> do_recursion ( frame=${PFMT} ) +S -> lock_name (${CVSROOT_DIRNAME}/trace, #cvs\.lock) +S -> lock_name (${CVSROOT_DIRNAME}/trace, #cvs\.rfl\.${hostname}\.[0-9][0-9]*) +S -> lock_simple_remove() +S -> remove_locks() +S -> remove_locks() +S -> serve_directory (\.) +S -> server_cleanup() +S -> server_cleanup() +S -> server_notify() +S -> server_pathname_check (file1) +S -> set_lock (${CVSROOT_DIRNAME}/trace, 1) +S -> start_recursion ( fileproc=${PFMT}, filesdoneproc=${PFMT}, +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} )" + + echo foo >> file1 + dotest_sort trace-13 "${testcvs} -t -t -t up -C file1" \ +" *callerdat=${PFMT}, argc=1, argv=${PFMT}, + *direntproc=${PFMT}, dirleavproc=${PFMT}, + *dosrcs=1, repository_in=(null) ) + *local=0, which=3, aflag=0, + *locktype=1, update_preload=(null) + *-> Leaving do_recursion ( frame=${PFMT} ) + *-> Lock_Cleanup() + *-> RCS_checkout (${CVSROOT_DIRNAME}/trace/file1,v, 1\.1\.1\.1, , , (function)) + *-> RCS_checkout (${CVSROOT_DIRNAME}/trace/file1,v, 1\.1\.1\.1, , , file1) + *-> RCS_cmp_file( ${CVSROOT_DIRNAME}/trace/file1,v, 1\.1\.1\.1, (null), , file1 ) + *-> Reader_Lock(${CVSROOT_DIRNAME}/trace) + *-> Register(file1, 1\.1\.1\.1, ${DATE}, , ) + *-> Simple_Lock_Cleanup() + *-> Simple_Lock_Cleanup() + *-> chmod(file1,[0-7][0-7]*) + *-> copy(file1,\.#file1\.1\.1\.1\.1) + *-> do_recursion ( frame=${PFMT} ) + *-> fopen(${CVSROOT_DIRNAME}/CVSROOT/history,a) + *-> lock_name (${CVSROOT_DIRNAME}/trace, #cvs\.lock) + *-> lock_name (${CVSROOT_DIRNAME}/trace, #cvs\.rfl\.${hostname}\.[0-9][0-9]*) + *-> lock_simple_remove() + *-> main loop with CVSROOT=${CVSROOT_DIRNAME} + *-> parse_cvsroot ( ${CVSROOT_DIRNAME} ) + *-> remove_locks() + *-> rename(CVS/Entries\.Backup,CVS/Entries) + *-> rename(file1,CVS/,,file1) + *-> set_lock (${CVSROOT_DIRNAME}/trace, 1) + *-> start_recursion ( fileproc=${PFMT}, filesdoneproc=${PFMT}, + *-> unlink_file(CVS/Entries\.Log) + *-> unlink_file_dir(CVS/,,file1) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +(Locally modified file1 moved to \.#file1\.1\.1\.1\.1) +U file1" \ +" + *callerdat=${PFMT}, argc=1, argv=${PFMT}, + *callerdat=${PFMT}, argc=1, argv=${PFMT}, + *direntproc=${PFMT}, dirleavproc=${PFMT}, + *direntproc=${PFMT}, dirleavproc=${PFMT}, + *dosrcs=0, repository_in=(null) ) + *dosrcs=1, repository_in=(null) ) + *local=0, which=1, aflag=0, + *local=0, which=3, aflag=0, + *locktype=0, update_preload=(null) + *locktype=1, update_preload=(null) + *-> Forking server: ${CVS_SERVER} server + *-> Leaving do_recursion ( frame=${PFMT} ) + *-> Register(file1, 1\.1\.1\.1, ${DATE}, , ) + *-> copy(file1,\.#file1\.1\.1\.1\.1) + *-> do_recursion ( frame=${PFMT} ) + *-> main loop with CVSROOT=${CVSROOT} + *-> parse_cvsroot ( ${CVSROOT} ) + *-> rename(\.new\.file1,file1) + *-> rename(CVS/Entries\.Backup,CVS/Entries) + *-> start_recursion ( fileproc=${PFMT}, filesdoneproc=${PFMT}, + *-> unlink_file(CVS/Entries\.Log) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +(Locally modified file1 moved to \.#file1\.1\.1\.1\.1) +S -> CVS_SERVER_SLEEP not set\. +S -> Leaving do_recursion ( frame=${PFMT} ) +S -> Lock_Cleanup() +S -> Lock_Cleanup() +S -> RCS_checkout (${CVSROOT_DIRNAME}/trace/file1,v, 1\.1\.1\.1, , , (function)) +S -> Reader_Lock(${CVSROOT_DIRNAME}/trace) +S -> Register(file1, 1\.1\.1\.1, M, , ) +S -> Simple_Lock_Cleanup() +S -> Simple_Lock_Cleanup() +S -> Simple_Lock_Cleanup() +S -> dirswitch (\., ${CVSROOT_DIRNAME}/trace) +S -> do_cvs_command (update) +S -> do_recursion ( frame=${PFMT} ) +S -> fopen(${CVSROOT_DIRNAME}/CVSROOT/history,a) +S -> lock_name (${CVSROOT_DIRNAME}/trace, #cvs\.lock) +S -> lock_name (${CVSROOT_DIRNAME}/trace, #cvs\.rfl\.${hostname}\.[0-9][0-9]*) +S -> lock_simple_remove() +S -> remove_locks() +S -> remove_locks() +S -> rename(CVS/Entries\.Backup,CVS/Entries) +S -> serve_directory (\.) +S -> server_cleanup() +S -> server_cleanup() +S -> server_notify() +S -> server_pathname_check (file1) +S -> server_register(file1, 1\.1\.1\.1, M, , , , ) +S -> set_lock (${CVSROOT_DIRNAME}/trace, 1) +S -> start_recursion ( fileproc=${PFMT}, filesdoneproc=${PFMT}, +S -> unlink_file(CVS/Entries\.Log) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +U file1" + echo foo >> file1 + dotest_sort trace-14 "${testcvs} -t -t -t ci -madd-data file1" \ +" *callerdat=${PFMT}, argc=1, argv=${PFMT}, + *callerdat=${PFMT}, argc=1, argv=${PFMT}, + *callerdat=${PFMT}, argc=1, argv=${PFMT}, + *direntproc=${PFMT}, dirleavproc=${PFMT}, + *direntproc=${PFMT}, dirleavproc=${PFMT}, + *direntproc=${PFMT}, dirleavproc=${PFMT}, + *dosrcs=0, repository_in=(null) ) + *dosrcs=1, repository_in=(null) ) + *dosrcs=1, repository_in=(null) ) + *local=0, which=1, aflag=0, + *local=0, which=1, aflag=0, + *local=0, which=1, aflag=0, + *locktype=0, update_preload=(null) + *locktype=0, update_preload=(null) + *locktype=2, update_preload=(null) + *-> Leaving do_recursion ( frame=${PFMT} ) + *-> Leaving do_recursion ( frame=${PFMT} ) + *-> Leaving do_recursion ( frame=${PFMT} ) + *-> Lock_Cleanup() + *-> Lock_Cleanup() + *-> Parse_Info (${CVSROOT_DIRNAME}/CVSROOT/commitinfo, trace, ALL) + *-> Parse_Info (${CVSROOT_DIRNAME}/CVSROOT/loginfo, trace, ALL) + *-> Parse_Info (${CVSROOT_DIRNAME}/CVSROOT/verifymsg, trace, not ALL) + *-> Promotable_Lock () + *-> RCS_checkout (${CVSROOT_DIRNAME}/trace/file1,v, , , , (function)) + *-> RCS_checkout (${CVSROOT_DIRNAME}/trace/file1,v, 1\.1, , -ko, ${tempname}) + *-> RCS_checkout (${CVSROOT_DIRNAME}/trace/file1,v, 1\.1\.1\.1, , , (function)) + *-> RCS_cmp_file( ${CVSROOT_DIRNAME}/trace/file1,v, (null), (null), , file1 ) + *-> RCS_cmp_file( ${CVSROOT_DIRNAME}/trace/file1,v, 1\.1\.1\.1, (null), , file1 ) + *-> Register(file1, 1\.2, ${DATE}, , ) + *-> Simple_Lock_Cleanup() + *-> Simple_Lock_Cleanup() + *-> Simple_Lock_Cleanup() + *-> _lock_exists (${CVSROOT_DIRNAME}/trace, #cvs\.pfl\.\*, #cvs\.pfl\.${hostname}\.[0-9][0-9]*) + *-> _lock_exists (${CVSROOT_DIRNAME}/trace, #cvs\.pfl\.\*, #cvs\.pfl\.${hostname}\.[0-9][0-9]*) + *-> _lock_exists (${CVSROOT_DIRNAME}/trace, #cvs\.rfl\.\*, #cvs\.rfl\.${hostname}\.[0-9][0-9]*) + *-> do_recursion ( frame=${PFMT} ) + *-> do_recursion ( frame=${PFMT} ) + *-> do_recursion ( frame=${PFMT} ) + *-> fopen(${CVSROOT_DIRNAME}/CVSROOT/history,a) + *-> lock_dir_for_write (${CVSROOT_DIRNAME}/trace) + *-> lock_name (${CVSROOT_DIRNAME}/trace, #cvs\.lock) + *-> lock_name (${CVSROOT_DIRNAME}/trace, #cvs\.lock) + *-> lock_name (${CVSROOT_DIRNAME}/trace, #cvs\.lock) + *-> lock_name (${CVSROOT_DIRNAME}/trace, #cvs\.pfl\.${hostname}\.[0-9][0-9]*) + *-> lock_name (${CVSROOT_DIRNAME}/trace, #cvs\.rfl\.${hostname}\.[0-9][0-9]*) + *-> lock_name (${CVSROOT_DIRNAME}/trace, #cvs\.wfl\.${hostname}\.[0-9][0-9]*) + *-> lock_name (${CVSROOT_DIRNAME}/trace, ) + *-> lock_name (${CVSROOT_DIRNAME}/trace, ) + *-> lock_name (${CVSROOT_DIRNAME}/trace, ) + *-> lock_simple_remove() + *-> lock_simple_remove() + *-> lock_tree_promotably (1, argv, 0, 1, 0) + *-> main loop with CVSROOT=${CVSROOT_DIRNAME} + *-> parse_cvsroot ( ${CVSROOT_DIRNAME} ) + *-> promotable_exists (${CVSROOT_DIRNAME}/trace) + *-> promotable_exists (${CVSROOT_DIRNAME}/trace) + *-> promotable_lock(${CVSROOT_DIRNAME}/trace) + *-> rcs_cleanup() + *-> readers_exist (${CVSROOT_DIRNAME}/trace) + *-> remove_locks() + *-> remove_locks() + *-> rename(${CVSROOT_DIRNAME}/trace/,file1,,${CVSROOT_DIRNAME}/trace/file1,v) + *-> rename(CVS/Entries\.Backup,CVS/Entries) + *-> set_lock (${CVSROOT_DIRNAME}/trace, 0) + *-> set_lock (${CVSROOT_DIRNAME}/trace, 1) + *-> start_recursion ( fileproc=${PFMT}, filesdoneproc=${PFMT}, + *-> start_recursion ( fileproc=${PFMT}, filesdoneproc=${PFMT}, + *-> start_recursion ( fileproc=${PFMT}, filesdoneproc=${PFMT}, + *-> unlink_file(${tempname}) + *-> unlink_file(${tempname}) + *-> unlink_file(CVS/Base/file1) + *-> unlink_file(CVS/Entries\.Log) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +${CVSROOT_DIRNAME}/trace/file1,v <-- file1 +new revision: 1\.2; previous revision: 1\.1" \ +" + *callerdat=${PFMT}, argc=1, argv=${PFMT}, + *callerdat=${PFMT}, argc=1, argv=${PFMT}, + *callerdat=${PFMT}, argc=1, argv=${PFMT}, + *callerdat=${PFMT}, argc=1, argv=${PFMT}, + *callerdat=${PFMT}, argc=1, argv=${PFMT}, + *direntproc=${PFMT}, dirleavproc=${PFMT}, + *direntproc=${PFMT}, dirleavproc=${PFMT}, + *direntproc=${PFMT}, dirleavproc=${PFMT}, + *direntproc=${PFMT}, dirleavproc=${PFMT}, + *direntproc=${PFMT}, dirleavproc=${PFMT}, + *dosrcs=0, repository_in=(null) ) + *dosrcs=0, repository_in=(null) ) + *dosrcs=0, repository_in=(null) ) + *dosrcs=1, repository_in=(null) ) + *dosrcs=1, repository_in=(null) ) + *local=0, which=1, aflag=0, + *local=0, which=1, aflag=0, + *local=0, which=1, aflag=0, + *local=0, which=1, aflag=0, + *local=0, which=1, aflag=0, + *locktype=0, update_preload=(null) + *locktype=0, update_preload=(null) + *locktype=0, update_preload=(null) + *locktype=0, update_preload=(null) + *locktype=2, update_preload=(null) + *-> Forking server: ${CVS_SERVER} server + *-> Leaving do_recursion ( frame=${PFMT} ) + *-> Leaving do_recursion ( frame=${PFMT} ) + *-> Register(file1, 1\.2, ${DATE}, , ) + *-> Sending file \`file1' to server + *-> do_recursion ( frame=${PFMT} ) + *-> do_recursion ( frame=${PFMT} ) + *-> main loop with CVSROOT=${CVSROOT} + *-> parse_cvsroot ( ${CVSROOT} ) + *-> rename(CVS/Entries\.Backup,CVS/Entries) + *-> start_recursion ( fileproc=${PFMT}, filesdoneproc=${PFMT}, + *-> start_recursion ( fileproc=${PFMT}, filesdoneproc=${PFMT}, + *-> unlink_file(CVS/Base/file1) + *-> unlink_file(CVS/Entries\.Log) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +${CVSROOT_DIRNAME}/trace/file1,v <-- file1 +S -> CVS_SERVER_SLEEP not set\. +S -> Leaving do_recursion ( frame=${PFMT} ) +S -> Leaving do_recursion ( frame=${PFMT} ) +S -> Leaving do_recursion ( frame=${PFMT} ) +S -> Lock_Cleanup() +S -> Lock_Cleanup() +S -> Lock_Cleanup() +S -> Parse_Info (${CVSROOT_DIRNAME}/CVSROOT/commitinfo, trace, ALL) +S -> Parse_Info (${CVSROOT_DIRNAME}/CVSROOT/loginfo, trace, ALL) +S -> Parse_Info (${CVSROOT_DIRNAME}/CVSROOT/verifymsg, trace, not ALL) +S -> Promotable_Lock () +S -> RCS_checkout (${CVSROOT_DIRNAME}/trace/file1,v, , , , (function)) +S -> RCS_checkout (${CVSROOT_DIRNAME}/trace/file1,v, 1\.1, , -ko, ${tempname}) +S -> RCS_checkout (${CVSROOT_DIRNAME}/trace/file1,v, 1\.1\.1\.1, , , (function)) +S -> RCS_cmp_file( ${CVSROOT_DIRNAME}/trace/file1,v, (null), (null), , file1 ) +S -> RCS_cmp_file( ${CVSROOT_DIRNAME}/trace/file1,v, 1\.1\.1\.1, (null), , file1 ) +S -> Register(file1, 1\.2, ${DATE}, , ) +S -> Simple_Lock_Cleanup() +S -> Simple_Lock_Cleanup() +S -> Simple_Lock_Cleanup() +S -> Simple_Lock_Cleanup() +S -> _lock_exists (${CVSROOT_DIRNAME}/trace, #cvs\.pfl\.\*, #cvs\.pfl\.${hostname}\.[0-9][0-9]*) +S -> _lock_exists (${CVSROOT_DIRNAME}/trace, #cvs\.pfl\.\*, #cvs\.pfl\.${hostname}\.[0-9][0-9]*) +S -> _lock_exists (${CVSROOT_DIRNAME}/trace, #cvs\.rfl\.\*, #cvs\.rfl\.${hostname}\.[0-9][0-9]*) +S -> dirswitch (\., ${CVSROOT_DIRNAME}/trace) +S -> do_cvs_command (commit) +S -> do_recursion ( frame=${PFMT} ) +S -> do_recursion ( frame=${PFMT} ) +S -> do_recursion ( frame=${PFMT} ) +S -> fopen(${CVSROOT_DIRNAME}/CVSROOT/history,a) +S -> lock_dir_for_write (${CVSROOT_DIRNAME}/trace) +S -> lock_name (${CVSROOT_DIRNAME}/trace, #cvs\.lock) +S -> lock_name (${CVSROOT_DIRNAME}/trace, #cvs\.lock) +S -> lock_name (${CVSROOT_DIRNAME}/trace, #cvs\.lock) +S -> lock_name (${CVSROOT_DIRNAME}/trace, #cvs\.pfl\.${hostname}\.[0-9][0-9]*) +S -> lock_name (${CVSROOT_DIRNAME}/trace, #cvs\.rfl\.${hostname}\.[0-9][0-9]*) +S -> lock_name (${CVSROOT_DIRNAME}/trace, #cvs\.wfl\.${hostname}\.[0-9][0-9]*) +S -> lock_name (${CVSROOT_DIRNAME}/trace, ) +S -> lock_name (${CVSROOT_DIRNAME}/trace, ) +S -> lock_name (${CVSROOT_DIRNAME}/trace, ) +S -> lock_simple_remove() +S -> lock_simple_remove() +S -> lock_tree_promotably (1, argv, 0, 1, 0) +S -> promotable_exists (${CVSROOT_DIRNAME}/trace) +S -> promotable_exists (${CVSROOT_DIRNAME}/trace) +S -> promotable_lock(${CVSROOT_DIRNAME}/trace) +S -> rcs_cleanup() +S -> readers_exist (${CVSROOT_DIRNAME}/trace) +S -> remove_locks() +S -> remove_locks() +S -> remove_locks() +S -> rename(${CVSROOT_DIRNAME}/trace/,file1,,${CVSROOT_DIRNAME}/trace/file1,v) +S -> rename(CVS/Entries\.Backup,CVS/Entries) +S -> serve_directory (\.) +S -> server_cleanup() +S -> server_cleanup() +S -> server_notify() +S -> server_pathname_check (file1) +S -> server_pathname_check (file1) +S -> server_pathname_check (file1) +S -> server_register(file1, 1\.2, ${DATE}, , , , ) +S -> set_lock (${CVSROOT_DIRNAME}/trace, 0) +S -> set_lock (${CVSROOT_DIRNAME}/trace, 1) +S -> start_recursion ( fileproc=${PFMT}, filesdoneproc=${PFMT}, +S -> start_recursion ( fileproc=${PFMT}, filesdoneproc=${PFMT}, +S -> start_recursion ( fileproc=${PFMT}, filesdoneproc=${PFMT}, +S -> unlink_file(${tempname}) +S -> unlink_file(${tempname}) +S -> unlink_file(CVS/Entries\.Log) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +new revision: 1\.2; previous revision: 1\.1" + + dotest_fail_sort trace-15 "${testcvs} -t -t -t diff -r1.1 file1" \ +" *aflag=0, repository= ) + *callerdat=${PFMT}, argc=1, argv=${PFMT}, + *direntproc=${PFMT}, dirleavproc=${PFMT}, + *dosrcs=1, repository_in=(null) ) + *local=0, which=7, aflag=0, + *locktype=1, update_preload=(null) + *-> Leaving do_recursion ( frame=${PFMT} ) + *-> Lock_Cleanup() + *-> RCS_checkout (${CVSROOT_DIRNAME}/trace/file1,v, 1\.1, , , ${tempname}) + *-> RCS_checkout (${CVSROOT_DIRNAME}/trace/file1,v, 1\.2, , , (function)) + *-> RCS_checkout (${CVSROOT_DIRNAME}/trace/file1,v, 1\.2, , , ${tempname}) + *-> RCS_cmp_file( ${CVSROOT_DIRNAME}/trace/file1,v, 1\.1, 1\.2, , file1 ) + *-> Reader_Lock(${CVSROOT_DIRNAME}/trace) + *-> Simple_Lock_Cleanup() + *-> Simple_Lock_Cleanup() + *-> diff_file_nodiff (file1, 3) + *-> do_recursion ( frame=${PFMT} ) + *-> lock_name (${CVSROOT_DIRNAME}/trace, #cvs\.lock) + *-> lock_name (${CVSROOT_DIRNAME}/trace, #cvs\.rfl\.${hostname}\.[0-9][0-9]*) + *-> lock_simple_remove() + *-> main loop with CVSROOT=${CVSROOT_DIRNAME} + *-> parse_cvsroot ( ${CVSROOT_DIRNAME} ) + *-> remove_locks() + *-> set_lock (${CVSROOT_DIRNAME}/trace, 1) + *-> start_recursion ( fileproc=${PFMT}, filesdoneproc=${PFMT}, + *-> tag_check_valid ( name=1\.1, argc=1, argv=${PFMT}, local=0, + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +0a1 +=================================================================== +> foo +Index: file1 +RCS file: ${CVSROOT_DIRNAME}/trace/file1,v +diff -r1\.1 -r1\.2 +retrieving revision 1\.1 +retrieving revision 1\.2" \ +" + *aflag=0, repository= ) + *callerdat=${PFMT}, argc=1, argv=${PFMT}, + *callerdat=${PFMT}, argc=1, argv=${PFMT}, + *direntproc=${PFMT}, dirleavproc=${PFMT}, + *direntproc=${PFMT}, dirleavproc=${PFMT}, + *dosrcs=0, repository_in=(null) ) + *dosrcs=1, repository_in=(null) ) + *local=0, which=1, aflag=0, + *local=0, which=7, aflag=0, + *locktype=0, update_preload=(null) + *locktype=1, update_preload=(null) + *-> Forking server: ${CVS_SERVER} server + *-> Leaving do_recursion ( frame=${PFMT} ) + *-> do_recursion ( frame=${PFMT} ) + *-> main loop with CVSROOT=${CVSROOT} + *-> parse_cvsroot ( ${CVSROOT} ) + *-> start_recursion ( fileproc=${PFMT}, filesdoneproc=${PFMT}, + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +0a1 +=================================================================== +> foo +Index: file1 +RCS file: ${CVSROOT_DIRNAME}/trace/file1,v +S -> CVS_SERVER_SLEEP not set\. +S -> Leaving do_recursion ( frame=${PFMT} ) +S -> Lock_Cleanup() +S -> Lock_Cleanup() +S -> RCS_checkout (${CVSROOT_DIRNAME}/trace/file1,v, 1\.1, , , ${tempname}) +S -> RCS_checkout (${CVSROOT_DIRNAME}/trace/file1,v, 1\.2, , , (function)) +S -> RCS_checkout (${CVSROOT_DIRNAME}/trace/file1,v, 1\.2, , , ${tempname}) +S -> RCS_cmp_file( ${CVSROOT_DIRNAME}/trace/file1,v, 1\.1, 1\.2, , file1 ) +S -> Reader_Lock(${CVSROOT_DIRNAME}/trace) +S -> Simple_Lock_Cleanup() +S -> Simple_Lock_Cleanup() +S -> Simple_Lock_Cleanup() +S -> diff_file_nodiff (file1, 3) +S -> dirswitch (\., ${CVSROOT_DIRNAME}/trace) +S -> do_cvs_command (diff) +S -> do_recursion ( frame=${PFMT} ) +S -> lock_name (${CVSROOT_DIRNAME}/trace, #cvs\.lock) +S -> lock_name (${CVSROOT_DIRNAME}/trace, #cvs\.rfl\.${hostname}\.[0-9][0-9]*) +S -> lock_simple_remove() +S -> remove_locks() +S -> remove_locks() +S -> serve_directory (\.) +S -> server_cleanup() +S -> server_cleanup() +S -> server_notify() +S -> server_pathname_check (file1) +S -> set_lock (${CVSROOT_DIRNAME}/trace, 1) +S -> start_recursion ( fileproc=${PFMT}, filesdoneproc=${PFMT}, +S -> tag_check_valid ( name=1\.1, argc=1, argv=${PFMT}, local=0, +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +diff -r1\.1 -r1\.2 +retrieving revision 1\.1 +retrieving revision 1\.2" + + dotest_sort trace-16 "${testcvs} -t -t -t rdiff -rbp trace/file1" \ +" *aflag=0, repository=${CVSROOT_DIRNAME}/trace ) + *callerdat=${PFMT}, argc=1, argv=${PFMT}, + *direntproc=${PFMT}, dirleavproc=${PFMT}, + *dosrcs=1, repository_in=${CVSROOT_DIRNAME}/trace ) + *local=0, which=6, aflag=0, + *locktype=1, update_preload=trace + *-> Leaving do_recursion ( frame=${PFMT} ) + *-> Lock_Cleanup() + *-> RCS_checkout (${CVSROOT_DIRNAME}/trace/file1,v, 1\.1\.1\.1, bp, , ${tempname}) + *-> RCS_checkout (${CVSROOT_DIRNAME}/trace/file1,v, 1\.2, , , ${tempname}) + *-> Reader_Lock(${CVSROOT_DIRNAME}/trace) + *-> Simple_Lock_Cleanup() + *-> Simple_Lock_Cleanup() + *-> do_module (trace/file1, Patching, NULL, NULL) + *-> do_recursion ( frame=${PFMT} ) + *-> lock_name (${CVSROOT_DIRNAME}/trace, #cvs\.lock) + *-> lock_name (${CVSROOT_DIRNAME}/trace, #cvs\.rfl\.${hostname}\.[0-9][0-9]*) + *-> lock_simple_remove() + *-> main loop with CVSROOT=${CVSROOT_DIRNAME} + *-> parse_cvsroot ( ${CVSROOT_DIRNAME} ) + *-> patch_proc ( (null), (null), (null), 0, 0, trace/file1, Patching ) + *-> remove_locks() + *-> set_lock (${CVSROOT_DIRNAME}/trace, 1) + *-> start_recursion ( fileproc=${PFMT}, filesdoneproc=${PFMT}, + *-> tag_check_valid ( name=bp, argc=1, argv=${PFMT}, local=0, + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +\*\*\* 0 \*\*\*\* +\*\*\* trace/file1:1\.1\.1\.1 ${DATE} +\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* +${PLUS} foo +--- 1 ---- +--- trace/file1 ${DATE} +Index: trace/file1 +diff -c trace/file1:1\.1\.1\.1 trace/file1:1\.2" \ +" + *aflag=0, repository=${CVSROOT_DIRNAME}/trace ) + *callerdat=${PFMT}, argc=1, argv=${PFMT}, + *direntproc=${PFMT}, dirleavproc=${PFMT}, + *dosrcs=1, repository_in=${CVSROOT_DIRNAME}/trace ) + *local=0, which=6, aflag=0, + *locktype=1, update_preload=trace + *-> Forking server: ${CVS_SERVER} server + *-> main loop with CVSROOT=${CVSROOT} + *-> parse_cvsroot ( ${CVSROOT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +\*\*\* 0 \*\*\*\* +\*\*\* trace/file1:1\.1\.1\.1 ${DATE} +\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* +${PLUS} foo +--- 1 ---- +--- trace/file1 ${DATE} +Index: trace/file1 +S -> CVS_SERVER_SLEEP not set\. +S -> Leaving do_recursion ( frame=${PFMT} ) +S -> Lock_Cleanup() +S -> Lock_Cleanup() +S -> RCS_checkout (${CVSROOT_DIRNAME}/trace/file1,v, 1\.1\.1\.1, bp, , ${tempname}) +S -> RCS_checkout (${CVSROOT_DIRNAME}/trace/file1,v, 1\.2, , , ${tempname}) +S -> Reader_Lock(${CVSROOT_DIRNAME}/trace) +S -> Simple_Lock_Cleanup() +S -> Simple_Lock_Cleanup() +S -> Simple_Lock_Cleanup() +S -> do_cvs_command (rdiff) +S -> do_module (trace/file1, Patching, NULL, NULL) +S -> do_recursion ( frame=${PFMT} ) +S -> lock_name (${CVSROOT_DIRNAME}/trace, #cvs\.lock) +S -> lock_name (${CVSROOT_DIRNAME}/trace, #cvs\.rfl\.${hostname}\.[0-9][0-9]*) +S -> lock_simple_remove() +S -> patch_proc ( (null), (null), (null), 0, 0, trace/file1, Patching ) +S -> remove_locks() +S -> remove_locks() +S -> server_cleanup() +S -> server_cleanup() +S -> server_notify() +S -> server_pathname_check (file1) +S -> set_lock (${CVSROOT_DIRNAME}/trace, 1) +S -> start_recursion ( fileproc=${PFMT}, filesdoneproc=${PFMT}, +S -> tag_check_valid ( name=bp, argc=1, argv=${PFMT}, local=0, +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +diff -c trace/file1:1\.1\.1\.1 trace/file1:1\.2" + + dotest_sort trace-17 "${testcvs} -t -t -t rm -f file1" \ +" *callerdat=${PFMT}, argc=1, argv=${PFMT}, + *direntproc=${PFMT}, dirleavproc=${PFMT}, + *dosrcs=1, repository_in=(null) ) + *local=0, which=1, aflag=0, + *locktype=1, update_preload=(null) + *-> Leaving do_recursion ( frame=${PFMT} ) + *-> Lock_Cleanup() + *-> Reader_Lock(${CVSROOT_DIRNAME}/trace) + *-> Register(file1, -1\.2, ${DATE}, , ) + *-> Simple_Lock_Cleanup() + *-> Simple_Lock_Cleanup() + *-> do_recursion ( frame=${PFMT} ) + *-> lock_name (${CVSROOT_DIRNAME}/trace, #cvs\.lock) + *-> lock_name (${CVSROOT_DIRNAME}/trace, #cvs\.rfl\.${hostname}\.[0-9][0-9]*) + *-> lock_simple_remove() + *-> main loop with CVSROOT=${CVSROOT_DIRNAME} + *-> parse_cvsroot ( ${CVSROOT_DIRNAME} ) + *-> remove_locks() + *-> rename(CVS/Entries\.Backup,CVS/Entries) + *-> set_lock (${CVSROOT_DIRNAME}/trace, 1) + *-> start_recursion ( fileproc=${PFMT}, filesdoneproc=${PFMT}, + *-> unlink_file(CVS/Entries\.Log) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +${SPROG} remove: scheduling \`file1' for removal +${SPROG} remove: use \`${SPROG} commit' to remove this file permanently" \ +" + *callerdat=${PFMT}, argc=1, argv=${PFMT}, + *callerdat=${PFMT}, argc=1, argv=${PFMT}, + *callerdat=${PFMT}, argc=1, argv=${PFMT}, + *direntproc=${PFMT}, dirleavproc=${PFMT}, + *direntproc=${PFMT}, dirleavproc=${PFMT}, + *direntproc=${PFMT}, dirleavproc=${PFMT}, + *dosrcs=0, repository_in=(null) ) + *dosrcs=0, repository_in=(null) ) + *dosrcs=1, repository_in=(null) ) + *local=0, which=1, aflag=0, + *local=0, which=1, aflag=0, + *local=0, which=1, aflag=0, + *locktype=0, update_preload=(null) + *locktype=0, update_preload=(null) + *locktype=1, update_preload=(null) + *-> Forking server: ${CVS_SERVER} server + *-> Leaving do_recursion ( frame=${PFMT} ) + *-> Leaving do_recursion ( frame=${PFMT} ) + *-> Register(file1, -1\.2, dummy timestamp, , ) + *-> do_recursion ( frame=${PFMT} ) + *-> do_recursion ( frame=${PFMT} ) + *-> main loop with CVSROOT=${CVSROOT} + *-> parse_cvsroot ( ${CVSROOT} ) + *-> rename(CVS/Entries\.Backup,CVS/Entries) + *-> start_recursion ( fileproc=${PFMT}, filesdoneproc=${PFMT}, + *-> start_recursion ( fileproc=${PFMT}, filesdoneproc=${PFMT}, + *-> unlink_file(CVS/Entries\.Log) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> CVS_SERVER_SLEEP not set\. +S -> Leaving do_recursion ( frame=${PFMT} ) +S -> Lock_Cleanup() +S -> Lock_Cleanup() +S -> Reader_Lock(${CVSROOT_DIRNAME}/trace) +S -> Register(file1, -1\.2, , , ) +S -> Simple_Lock_Cleanup() +S -> Simple_Lock_Cleanup() +S -> Simple_Lock_Cleanup() +S -> dirswitch (\., ${CVSROOT_DIRNAME}/trace) +S -> do_cvs_command (remove) +S -> do_recursion ( frame=${PFMT} ) +S -> lock_name (${CVSROOT_DIRNAME}/trace, #cvs\.lock) +S -> lock_name (${CVSROOT_DIRNAME}/trace, #cvs\.rfl\.${hostname}\.[0-9][0-9]*) +S -> lock_simple_remove() +S -> remove_locks() +S -> remove_locks() +S -> rename(CVS/Entries\.Backup,CVS/Entries) +S -> serve_directory (\.) +S -> server_cleanup() +S -> server_cleanup() +S -> server_notify() +S -> server_pathname_check (file1) +S -> server_register(file1, -1\.2, , , , , ) +S -> set_lock (${CVSROOT_DIRNAME}/trace, 1) +S -> start_recursion ( fileproc=${PFMT}, filesdoneproc=${PFMT}, +S -> unlink_file(CVS/Entries\.Log) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +${SPROG} remove: scheduling \`file1' for removal +${SPROG} remove: use \`${SPROG} commit' to remove this file permanently" + + dotest_sort trace-18 "${testcvs} -t -t -t ci -mremove file1" \ +" *callerdat=${PFMT}, argc=1, argv=${PFMT}, + *callerdat=${PFMT}, argc=1, argv=${PFMT}, + *callerdat=${PFMT}, argc=1, argv=${PFMT}, + *direntproc=${PFMT}, dirleavproc=${PFMT}, + *direntproc=${PFMT}, dirleavproc=${PFMT}, + *direntproc=${PFMT}, dirleavproc=${PFMT}, + *dosrcs=0, repository_in=(null) ) + *dosrcs=1, repository_in=(null) ) + *dosrcs=1, repository_in=(null) ) + *local=0, which=1, aflag=0, + *local=0, which=1, aflag=0, + *local=0, which=1, aflag=0, + *locktype=0, update_preload=(null) + *locktype=0, update_preload=(null) + *locktype=2, update_preload=(null) + *-> Leaving do_recursion ( frame=${PFMT} ) + *-> Leaving do_recursion ( frame=${PFMT} ) + *-> Leaving do_recursion ( frame=${PFMT} ) + *-> Lock_Cleanup() + *-> Lock_Cleanup() + *-> Parse_Info (${CVSROOT_DIRNAME}/CVSROOT/commitinfo, trace, ALL) + *-> Parse_Info (${CVSROOT_DIRNAME}/CVSROOT/loginfo, trace, ALL) + *-> Parse_Info (${CVSROOT_DIRNAME}/CVSROOT/verifymsg, trace, not ALL) + *-> Promotable_Lock () + *-> RCS_checkout (${CVSROOT_DIRNAME}/trace/file1,v, , , , file1) + *-> RCS_checkout (${CVSROOT_DIRNAME}/trace/file1,v, 1\.2, , -ko, ${tempname}) + *-> Scratch_Entry(file1) + *-> Simple_Lock_Cleanup() + *-> Simple_Lock_Cleanup() + *-> Simple_Lock_Cleanup() + *-> _lock_exists (${CVSROOT_DIRNAME}/trace, #cvs\.pfl\.\*, #cvs.pfl\.${hostname}\.[0-9][0-9]*) + *-> _lock_exists (${CVSROOT_DIRNAME}/trace, #cvs\.pfl\.\*, #cvs.pfl\.${hostname}\.[0-9][0-9]*) + *-> _lock_exists (${CVSROOT_DIRNAME}/trace, #cvs\.rfl\.\*, #cvs.rfl\.${hostname}\.[0-9][0-9]*) + *-> do_recursion ( frame=${PFMT} ) + *-> do_recursion ( frame=${PFMT} ) + *-> do_recursion ( frame=${PFMT} ) + *-> fopen(${CVSROOT_DIRNAME}/CVSROOT/history,a) + *-> lock_dir_for_write (${CVSROOT_DIRNAME}/trace) + *-> lock_name (${CVSROOT_DIRNAME}/trace, #cvs\.lock) + *-> lock_name (${CVSROOT_DIRNAME}/trace, #cvs\.lock) + *-> lock_name (${CVSROOT_DIRNAME}/trace, #cvs\.lock) + *-> lock_name (${CVSROOT_DIRNAME}/trace, #cvs\.pfl\.${hostname}\.[0-9][0-9]*) + *-> lock_name (${CVSROOT_DIRNAME}/trace, #cvs\.rfl\.${hostname}\.[0-9][0-9]*) + *-> lock_name (${CVSROOT_DIRNAME}/trace, #cvs\.wfl\.${hostname}\.[0-9][0-9]*) + *-> lock_name (${CVSROOT_DIRNAME}/trace, ) + *-> lock_name (${CVSROOT_DIRNAME}/trace, ) + *-> lock_name (${CVSROOT_DIRNAME}/trace, ) + *-> lock_simple_remove() + *-> lock_simple_remove() + *-> lock_tree_promotably (1, argv, 0, 1, 0) + *-> main loop with CVSROOT=${CVSROOT_DIRNAME} + *-> parse_cvsroot ( ${CVSROOT_DIRNAME} ) + *-> promotable_exists (${CVSROOT_DIRNAME}/trace) + *-> promotable_exists (${CVSROOT_DIRNAME}/trace) + *-> promotable_lock(${CVSROOT_DIRNAME}/trace) + *-> rcs_cleanup() + *-> readers_exist (${CVSROOT_DIRNAME}/trace) + *-> remove_locks() + *-> remove_locks() + *-> rename(${CVSROOT_DIRNAME}/trace/,file1,,${CVSROOT_DIRNAME}/trace/file1,v) + *-> rename(${CVSROOT_DIRNAME}/trace/,file1,,${CVSROOT_DIRNAME}/trace/file1,v) + *-> rename(${CVSROOT_DIRNAME}/trace/,file1,,${CVSROOT_DIRNAME}/trace/file1,v) + *-> rename(CVS/Entries\.Backup,CVS/Entries) + *-> set_lock (${CVSROOT_DIRNAME}/trace, 0) + *-> set_lock (${CVSROOT_DIRNAME}/trace, 1) + *-> start_recursion ( fileproc=${PFMT}, filesdoneproc=${PFMT}, + *-> start_recursion ( fileproc=${PFMT}, filesdoneproc=${PFMT}, + *-> start_recursion ( fileproc=${PFMT}, filesdoneproc=${PFMT}, + *-> unlink_file(${tempname}) + *-> unlink_file(${tempname}) + *-> unlink_file(CVS/Entries\.Log) + *-> unlink_file(file1) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +${CVSROOT_DIRNAME}/trace/file1,v <-- file1 +new revision: delete; previous revision: 1\.2" \ +" + *callerdat=${PFMT}, argc=1, argv=${PFMT}, + *callerdat=${PFMT}, argc=1, argv=${PFMT}, + *callerdat=${PFMT}, argc=1, argv=${PFMT}, + *callerdat=${PFMT}, argc=1, argv=${PFMT}, + *callerdat=${PFMT}, argc=1, argv=${PFMT}, + *direntproc=${PFMT}, dirleavproc=${PFMT}, + *direntproc=${PFMT}, dirleavproc=${PFMT}, + *direntproc=${PFMT}, dirleavproc=${PFMT}, + *direntproc=${PFMT}, dirleavproc=${PFMT}, + *direntproc=${PFMT}, dirleavproc=${PFMT}, + *dosrcs=0, repository_in=(null) ) + *dosrcs=0, repository_in=(null) ) + *dosrcs=0, repository_in=(null) ) + *dosrcs=1, repository_in=(null) ) + *dosrcs=1, repository_in=(null) ) + *local=0, which=1, aflag=0, + *local=0, which=1, aflag=0, + *local=0, which=1, aflag=0, + *local=0, which=1, aflag=0, + *local=0, which=1, aflag=0, + *locktype=0, update_preload=(null) + *locktype=0, update_preload=(null) + *locktype=0, update_preload=(null) + *locktype=0, update_preload=(null) + *locktype=2, update_preload=(null) + *-> Forking server: ${CVS_SERVER} server + *-> Leaving do_recursion ( frame=${PFMT} ) + *-> Leaving do_recursion ( frame=${PFMT} ) + *-> Scratch_Entry(file1) + *-> do_recursion ( frame=${PFMT} ) + *-> do_recursion ( frame=${PFMT} ) + *-> main loop with CVSROOT=${CVSROOT} + *-> parse_cvsroot ( ${CVSROOT} ) + *-> rename(CVS/Entries\.Backup,CVS/Entries) + *-> start_recursion ( fileproc=${PFMT}, filesdoneproc=${PFMT}, + *-> start_recursion ( fileproc=${PFMT}, filesdoneproc=${PFMT}, + *-> unlink_file(CVS/Entries\.Log) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +${CVSROOT_DIRNAME}/trace/file1,v <-- file1 +S -> CVS_SERVER_SLEEP not set\. +S -> Leaving do_recursion ( frame=${PFMT} ) +S -> Leaving do_recursion ( frame=${PFMT} ) +S -> Leaving do_recursion ( frame=${PFMT} ) +S -> Lock_Cleanup() +S -> Lock_Cleanup() +S -> Lock_Cleanup() +S -> Parse_Info (${CVSROOT_DIRNAME}/CVSROOT/commitinfo, trace, ALL) +S -> Parse_Info (${CVSROOT_DIRNAME}/CVSROOT/loginfo, trace, ALL) +S -> Parse_Info (${CVSROOT_DIRNAME}/CVSROOT/verifymsg, trace, not ALL) +S -> Promotable_Lock () +S -> RCS_checkout (${CVSROOT_DIRNAME}/trace/file1,v, , , , file1) +S -> RCS_checkout (${CVSROOT_DIRNAME}/trace/file1,v, 1\.2, , -ko, ${tempname}) +S -> Scratch_Entry(file1) +S -> Simple_Lock_Cleanup() +S -> Simple_Lock_Cleanup() +S -> Simple_Lock_Cleanup() +S -> Simple_Lock_Cleanup() +S -> _lock_exists (${CVSROOT_DIRNAME}/trace, #cvs\.pfl\.\*, #cvs.pfl\.${hostname}\.[0-9][0-9]*) +S -> _lock_exists (${CVSROOT_DIRNAME}/trace, #cvs\.pfl\.\*, #cvs.pfl\.${hostname}\.[0-9][0-9]*) +S -> _lock_exists (${CVSROOT_DIRNAME}/trace, #cvs\.rfl\.\*, #cvs.rfl\.${hostname}\.[0-9][0-9]*) +S -> dirswitch (\., ${CVSROOT_DIRNAME}/trace) +S -> do_cvs_command (commit) +S -> do_recursion ( frame=${PFMT} ) +S -> do_recursion ( frame=${PFMT} ) +S -> do_recursion ( frame=${PFMT} ) +S -> fopen(${CVSROOT_DIRNAME}/CVSROOT/history,a) +S -> lock_dir_for_write (${CVSROOT_DIRNAME}/trace) +S -> lock_name (${CVSROOT_DIRNAME}/trace, #cvs\.lock) +S -> lock_name (${CVSROOT_DIRNAME}/trace, #cvs\.lock) +S -> lock_name (${CVSROOT_DIRNAME}/trace, #cvs\.lock) +S -> lock_name (${CVSROOT_DIRNAME}/trace, #cvs\.pfl\.${hostname}\.[0-9][0-9]*) +S -> lock_name (${CVSROOT_DIRNAME}/trace, #cvs\.rfl\.${hostname}\.[0-9][0-9]*) +S -> lock_name (${CVSROOT_DIRNAME}/trace, #cvs\.wfl\.${hostname}\.[0-9][0-9]*) +S -> lock_name (${CVSROOT_DIRNAME}/trace, ) +S -> lock_name (${CVSROOT_DIRNAME}/trace, ) +S -> lock_name (${CVSROOT_DIRNAME}/trace, ) +S -> lock_simple_remove() +S -> lock_simple_remove() +S -> lock_tree_promotably (1, argv, 0, 1, 0) +S -> promotable_exists (${CVSROOT_DIRNAME}/trace) +S -> promotable_exists (${CVSROOT_DIRNAME}/trace) +S -> promotable_lock(${CVSROOT_DIRNAME}/trace) +S -> rcs_cleanup() +S -> readers_exist (${CVSROOT_DIRNAME}/trace) +S -> remove_locks() +S -> remove_locks() +S -> remove_locks() +S -> rename(${CVSROOT_DIRNAME}/trace/,file1,,${CVSROOT_DIRNAME}/trace/file1,v) +S -> rename(${CVSROOT_DIRNAME}/trace/,file1,,${CVSROOT_DIRNAME}/trace/file1,v) +S -> rename(${CVSROOT_DIRNAME}/trace/,file1,,${CVSROOT_DIRNAME}/trace/file1,v) +S -> rename(CVS/Entries\.Backup,CVS/Entries) +S -> serve_directory (\.) +S -> server_cleanup() +S -> server_cleanup() +S -> server_notify() +S -> server_pathname_check (file1) +S -> server_pathname_check (file1) +S -> server_pathname_check (file1) +S -> set_lock (${CVSROOT_DIRNAME}/trace, 0) +S -> set_lock (${CVSROOT_DIRNAME}/trace, 1) +S -> start_recursion ( fileproc=${PFMT}, filesdoneproc=${PFMT}, +S -> start_recursion ( fileproc=${PFMT}, filesdoneproc=${PFMT}, +S -> start_recursion ( fileproc=${PFMT}, filesdoneproc=${PFMT}, +S -> unlink_file(${tempname}) +S -> unlink_file(${tempname}) +S -> unlink_file(CVS/Entries\.Log) +S -> unlink_file(file1) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +done +new revision: delete; previous revision: 1\.2" + + # SGI IRIX seems to have problems with the stdout and stderr + # mix for this test, so separate them. + dotest_sort trace-19 "${testcvs} -t -t -t history file1 2>stderr19" \ +"O ${ISODATE} ${username} trace =trace= ${TESTDIR}/trace/\*" \ +"O ${ISODATE} ${username} trace =trace= <remote>/\*" + dotest_sort trace-19stderr "sort < stderr19" \ +" *-> Lock_Cleanup() + *-> Simple_Lock_Cleanup() + *-> main loop with CVSROOT=${CVSROOT_DIRNAME} + *-> parse_cvsroot ( ${CVSROOT_DIRNAME} ) + *-> remove_locks() + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} )" \ +" + *-> Forking server: ${CVS_SERVER} server + *-> main loop with CVSROOT=${CVSROOT} + *-> parse_cvsroot ( ${CVSROOT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +S -> CVS_SERVER_SLEEP not set\. +S -> Lock_Cleanup() +S -> Lock_Cleanup() +S -> Simple_Lock_Cleanup() +S -> Simple_Lock_Cleanup() +S -> do_cvs_command (history) +S -> remove_locks() +S -> remove_locks() +S -> server_cleanup() +S -> server_cleanup() +S -> server_notify()" + rm stderr19 + + cd .. + dotest_sort \ +trace-20 "echo yes | ${testcvs} -t -t -t release -d trace" \ +" *callerdat=${PFMT}, argc=0, argv=${PFMT}, + *callerdat=${PFMT}, argc=0, argv=${PFMT}, + *callerdat=${PFMT}, argc=0, argv=${PFMT}, + *direntproc=${PFMT}, dirleavproc=${PFMT}, + *direntproc=${PFMT}, dirleavproc=${PFMT}, + *direntproc=${PFMT}, dirleavproc=${PFMT}, + *dosrcs=0, repository_in=(null) ) + *dosrcs=0, repository_in=(null) ) + *dosrcs=0, repository_in=(null) ) + *local=0, which=1, aflag=0, + *local=0, which=1, aflag=0, + *local=0, which=1, aflag=0, + *locktype=0, update_preload=(null) + *locktype=0, update_preload=(null) + *locktype=2, update_preload=(null) + *-> Leaving do_recursion ( frame=${PFMT} ) + *-> Leaving do_recursion ( frame=${PFMT} ) + *-> Leaving do_recursion ( frame=${PFMT} ) + *-> Leaving do_recursion ( frame=${PFMT} ) + *-> Leaving do_recursion ( frame=${PFMT} ) + *-> Leaving do_recursion ( frame=${PFMT} ) + *-> Leaving do_recursion ( frame=${PFMT} ) + *-> Leaving do_recursion ( frame=${PFMT} ) + *-> Leaving do_recursion ( frame=${PFMT} ) + *-> Lock_Cleanup() + *-> Lock_Cleanup() + *-> Promotable_Lock () + *-> Simple_Lock_Cleanup() + *-> Simple_Lock_Cleanup() + *-> Simple_Lock_Cleanup() + *-> Simple_Lock_Cleanup() + *-> _lock_exists (${CVSROOT_DIRNAME}/trace, #cvs\.pfl\.\*, #cvs\.pfl\.${hostname}\.[0-9][0-9]*) + *-> _lock_exists (${CVSROOT_DIRNAME}/trace, #cvs\.pfl\.\*, #cvs\.pfl\.${hostname}\.[0-9][0-9]*) + *-> _lock_exists (${CVSROOT_DIRNAME}/trace, #cvs\.rfl\.\*, #cvs\.rfl\.${hostname}\.[0-9][0-9]*) + *-> _lock_exists (${CVSROOT_DIRNAME}/trace/subdir, #cvs\.pfl\.\*, #cvs\.pfl\.${hostname}\.[0-9][0-9]*) + *-> _lock_exists (${CVSROOT_DIRNAME}/trace/subdir, #cvs\.pfl\.\*, #cvs\.pfl\.${hostname}\.[0-9][0-9]*) + *-> _lock_exists (${CVSROOT_DIRNAME}/trace/subdir, #cvs\.rfl\.\*, #cvs\.rfl\.${hostname}\.[0-9][0-9]*) + *-> do_recursion ( frame=${PFMT} ) + *-> do_recursion ( frame=${PFMT} ) + *-> do_recursion ( frame=${PFMT} ) + *-> do_recursion ( frame=${PFMT} ) + *-> do_recursion ( frame=${PFMT} ) + *-> do_recursion ( frame=${PFMT} ) + *-> do_recursion ( frame=${PFMT} ) + *-> do_recursion ( frame=${PFMT} ) + *-> do_recursion ( frame=${PFMT} ) + *-> fopen(${CVSROOT_DIRNAME}/CVSROOT/history,a) + *-> lock_dir_for_write (${CVSROOT_DIRNAME}/trace) + *-> lock_dir_for_write (${CVSROOT_DIRNAME}/trace/subdir) + *-> lock_name (${CVSROOT_DIRNAME}/trace, #cvs\.lock) + *-> lock_name (${CVSROOT_DIRNAME}/trace, #cvs\.lock) + *-> lock_name (${CVSROOT_DIRNAME}/trace, #cvs\.lock) + *-> lock_name (${CVSROOT_DIRNAME}/trace, #cvs\.pfl\.${hostname}\.[0-9][0-9]*) + *-> lock_name (${CVSROOT_DIRNAME}/trace, #cvs\.rfl\.${hostname}\.[0-9][0-9]*) + *-> lock_name (${CVSROOT_DIRNAME}/trace, #cvs\.wfl\.${hostname}\.[0-9][0-9]*) + *-> lock_name (${CVSROOT_DIRNAME}/trace, ) + *-> lock_name (${CVSROOT_DIRNAME}/trace, ) + *-> lock_name (${CVSROOT_DIRNAME}/trace, ) + *-> lock_name (${CVSROOT_DIRNAME}/trace/subdir, #cvs\.lock) + *-> lock_name (${CVSROOT_DIRNAME}/trace/subdir, #cvs\.lock) + *-> lock_name (${CVSROOT_DIRNAME}/trace/subdir, #cvs\.lock) + *-> lock_name (${CVSROOT_DIRNAME}/trace/subdir, #cvs\.pfl\.${hostname}\.[0-9][0-9]*) + *-> lock_name (${CVSROOT_DIRNAME}/trace/subdir, #cvs\.rfl\.${hostname}\.[0-9][0-9]*) + *-> lock_name (${CVSROOT_DIRNAME}/trace/subdir, #cvs\.wfl\.${hostname}\.[0-9][0-9]*) + *-> lock_name (${CVSROOT_DIRNAME}/trace/subdir, ) + *-> lock_name (${CVSROOT_DIRNAME}/trace/subdir, ) + *-> lock_name (${CVSROOT_DIRNAME}/trace/subdir, ) + *-> lock_simple_remove() + *-> lock_simple_remove() + *-> lock_simple_remove() + *-> lock_simple_remove() + *-> lock_tree_promotably (0, argv, 0, 1, 0) + *-> main loop with CVSROOT=${CVSROOT_DIRNAME} + *-> parse_cvsroot ( ${CVSROOT_DIRNAME} ) + *-> promotable_exists (${CVSROOT_DIRNAME}/trace) + *-> promotable_exists (${CVSROOT_DIRNAME}/trace) + *-> promotable_exists (${CVSROOT_DIRNAME}/trace/subdir) + *-> promotable_exists (${CVSROOT_DIRNAME}/trace/subdir) + *-> promotable_lock(${CVSROOT_DIRNAME}/trace) + *-> promotable_lock(${CVSROOT_DIRNAME}/trace/subdir) + *-> readers_exist (${CVSROOT_DIRNAME}/trace) + *-> readers_exist (${CVSROOT_DIRNAME}/trace/subdir) + *-> remove_locks() + *-> remove_locks() + *-> run_popen(${testcvs} -n -q -d ${CVSROOT_DIRNAME} update,r) + *-> set_lock (${CVSROOT_DIRNAME}/trace, 0) + *-> set_lock (${CVSROOT_DIRNAME}/trace, 1) + *-> set_lock (${CVSROOT_DIRNAME}/trace/subdir, 0) + *-> set_lock (${CVSROOT_DIRNAME}/trace/subdir, 1) + *-> start_recursion ( fileproc=${PFMT}, filesdoneproc=${PFMT}, + *-> start_recursion ( fileproc=${PFMT}, filesdoneproc=${PFMT}, + *-> unlink_file_dir(trace) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +Are you sure you want to release (and delete) directory \`trace': *-> start_recursion ( fileproc=${PFMT}, filesdoneproc=${PFMT}, +You have \[0\] altered files in this repository\." \ +" + *callerdat=${PFMT}, argc=0, argv=${PFMT}, + *callerdat=${PFMT}, argc=0, argv=${PFMT}, + *direntproc=${PFMT}, dirleavproc=${PFMT}, + *direntproc=${PFMT}, dirleavproc=${PFMT}, + *dosrcs=0, repository_in=(null) ) + *dosrcs=0, repository_in=(null) ) + *local=0, which=1, aflag=0, + *local=0, which=1, aflag=0, + *locktype=0, update_preload=(null) + *locktype=0, update_preload=(null) + *-> Forking server: ${CVS_SERVER} server + *-> Leaving do_recursion ( frame=${PFMT} ) + *-> Leaving do_recursion ( frame=${PFMT} ) + *-> Leaving do_recursion ( frame=${PFMT} ) + *-> Leaving do_recursion ( frame=${PFMT} ) + *-> Leaving do_recursion ( frame=${PFMT} ) + *-> Leaving do_recursion ( frame=${PFMT} ) + *-> do_recursion ( frame=${PFMT} ) + *-> do_recursion ( frame=${PFMT} ) + *-> do_recursion ( frame=${PFMT} ) + *-> do_recursion ( frame=${PFMT} ) + *-> do_recursion ( frame=${PFMT} ) + *-> do_recursion ( frame=${PFMT} ) + *-> main loop with CVSROOT=${CVSROOT} + *-> parse_cvsroot ( ${CVSROOT} ) + *-> run_popen(${testcvs} -n -q -d ${CVSROOT} update,r) + *-> start_recursion ( fileproc=${PFMT}, filesdoneproc=${PFMT}, + *-> unlink_file_dir(trace) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) + *-> walklist ( list=${PFMT}, proc=${PFMT}, closure=${PFMT} ) +Are you sure you want to release (and delete) directory \`trace': *-> start_recursion ( fileproc=${PFMT}, filesdoneproc=${PFMT}, +S -> CVS_SERVER_SLEEP not set\. +S -> Lock_Cleanup() +S -> Lock_Cleanup() +S -> Simple_Lock_Cleanup() +S -> Simple_Lock_Cleanup() +S -> do_cvs_command (release) +S -> fopen(${CVSROOT_DIRNAME}/CVSROOT/history,a) +S -> remove_locks() +S -> remove_locks() +S -> server_cleanup() +S -> server_cleanup() +S -> server_notify() +S -> server_notify() +S -> server_notify() +You have \[0\] altered files in this repository\." + + dokeep + cd .. + rm -fr trace + modify_repo rm -fr $CVSROOT_DIRNAME/trace + ;; + + + + *) + echo $what is not the name of a test -- ignored + ;; + esac + + # Sanity check sanity.sh. :) + # + # Test our exit directory so that tests that exit in an incorrect directory + # are noticed during single test runs. + # + # FIXME? + # Sparc Solaris 9 is dereferencing paths here as if /bin/pwd were + # called when /tmp is a symlink. This might be a new problem with this + # test, but since this was recently tested I think it more likely to be + # A Solaris issue. + if test "x$TESTDIR" != "x`pwd`"; then + fail "cleanup: PWD != TESTDIR (\``pwd`' != \`$TESTDIR')" + fi + + # Test that the last test didn't overwrite any write proxy configuration + # which may be in place. + if $proxy; then + problem=false + for file in \ + $SECONDARY_CVSROOT_DIRNAME/CVSROOT/config \ + $CVSROOT_DIRNAME/CVSROOT/config \ + $SECONDARY_CVSROOT_DIRNAME/CVSROOT/loginfo \ + $CVSROOT_DIRNAME/CVSROOT/loginfo \ + $SECONDARY_CVSROOT_DIRNAME/CVSROOT/postadmin \ + $CVSROOT_DIRNAME/CVSROOT/postadmin \ + $SECONDARY_CVSROOT_DIRNAME/CVSROOT/posttag \ + $CVSROOT_DIRNAME/CVSROOT/posttag \ + $SECONDARY_CVSROOT_DIRNAME/CVSROOT/postwatch \ + $CVSROOT_DIRNAME/CVSROOT/postwatch; do + if cmp $file $TESTDIR/`basename $file`-clean >/dev/null 2>&1; then + :; + else + echo "\`$file' and \`$TESTDIR/`basename $file`-clean' differ." \ + >>$LOGFILE + problem=: + fi + done + if $problem; then + fail "cleanup: write proxy configuration not preserved" + fi + fi + + if $remote && test "$servercvs_orig" != "$servercvs" >/dev/null 2>&1; then + fail "test slagged \$servercvs" + fi + + # Reset val-tags to a pristine state. + if test -s $CVSROOT_DIRNAME/CVSROOT/val-tags; then + modify_repo ":" > $CVSROOT_DIRNAME/CVSROOT/val-tags + fi + verify_tmp_empty "post $what" + +done # The big loop + +# Set up summary data for output. +skippedoutput= +warningsoutput= +extendedinfo= +if test $skipped -ne 0; then + skippedoutput="$skipped test group" + if test $skipped -ne 1; then + skippedoutput="${skippedoutput}s" + fi + skippedoutput="$skippedoutput skipped" +fi +if test $warnings -ne 0; then + warningsoutput="$warnings test" + if test $warnings -ne 1; then + warningsoutput="${warningsoutput}s" + fi + warningsoutput="$warningsoutput passed with warnings" +fi +if test -n "$skippedoutput" || test -n "$warningsoutput"; then + extendedinfo=" (" + if test -n "$skippedoutput"; then + extendedinfo="$extendedinfo$skippedoutput" + fi + if test -n "$skippedoutput" && test -n "$warningsoutput"; then + extendedinfo="$extendedinfo and " + fi + if test -n "$warningsoutput"; then + extendedinfo="$extendedinfo$warningsoutput" + fi + extendedinfo="$extendedinfo)" +fi + +echo "OK, all $passed tests passed$extendedinfo." + +# TODO: +# * Test `cvs update -d foo' (where foo does not exist). +# * Test `cvs update foo bar' (where foo and bar are both from the +# same directory in the repository). Suppose one is a branch--make +# sure that both directories get updated with the respective correct +# thing. +# * `cvs update ../foo'. Also ../../foo ./../foo foo/../../bar /foo/bar +# foo/.././../bar foo/../bar etc. +# * Test all flags in modules file. +# Test that ciprog gets run both on checkin in that directory, or a +# higher-level checkin which recurses into it. +# * Test operations on a directory that contains other directories but has +# no files of its own. +# * -t global option +# * cvs rm followed by cvs add or vice versa (with no checkin in between). +# * cvs rm twice (should be a nice error message). +# * -P option to checkout--(a) refrains from checking out new empty dirs, +# (b) prunes empty dirs already there. +# * Test that cvs -d `hostname`:${TESTDIR}/non/existent co foo +# gives an appropriate error (e.g. +# Cannot access ${TESTDIR}/non-existent/CVSROOT +# No such file or directory). +# (like basica-9, but for remote). +# * Test ability to send notifications in response to watches. (currently +# hard to test because CVS doesn't send notifications if username is the +# same). +# * Test the contents of adm files other than Root and Repository. +# Entries seems the next most important thing. +# * Test the following compatibility issues: +# - The filler fields in "D" entries in CVS/Entries get preserved +# (per cvs.texinfo). +# - Unrecognized entry types in CVS/Entries get ignored (looks like +# this needs to be documented in cvs.texinfo, but is not) +# - Test that unrecognized files in CVS directories (e.g. CVS/Foobar) +# are ignored (per cvs.texinfo). +# - Test 'cvs history' with symlinks in the path to the working directory. +# - Remove most of the CVS_SERVER stuff after a reasonable amount of time. +# The "fork" & "client" series of tests should be left. 4/2/00, CVS +# 1.11.0.1 was altered so that it would default to program_name (set from +# argv[0]) rather than "cvs", but I'd like this script to work on legacy +# versions of CVS for awhile. +# - Testsuite doesn't work with usernames over eight characters in length. +# Fix it. +# End of TODO list. + +# Exit if keep set +dokeep + +# Remove the test directory, but first change out of it. +if $TIMING; then + echo "exiting without removing test dir in order to preserve timing information." +else + cd `dirname $TESTDIR` + rm -rf $TESTDIR +fi + +# end of sanity.sh |