tests: skip CVS tests for root

It is not uncommon for cvs to check for root and to refuse work
in that case.

Differential Revision: https://phab.mercurial-scm.org/D8395

tests/test-convert-cvs-branch.t

@@ -1,196 +1,196 b''
-#require cvs
+#require cvs no-root
 
 This is https://bz.mercurial-scm.org/1148
 and https://bz.mercurial-scm.org/1447
 
   $ cvscall()
   > {
   >     cvs -f "$@" > /dev/null
   > }
   $ cat <<EOF >> $HGRCPATH
   > [extensions]
   > convert =
   > [convert]
   > cvsps.cache = 0
   > EOF
 
 create cvs repository
 
   $ mkdir cvsrepo
   $ cd cvsrepo
   $ CVSROOT=`pwd`
   $ export CVSROOT
   $ CVS_OPTIONS=-f
   $ export CVS_OPTIONS
   $ cd ..
   $ rmdir cvsrepo
   $ cvscall -q -d "$CVSROOT" init
 
 Create a new project
 
   $ mkdir src
   $ cd src
   $ echo "1" > a
   $ echo "1" > b
   $ cvscall import -m "init" src v0 r0 | sort
   $ cd ..
   $ cvscall co src
   cvs checkout: Updating src
   $ cd src
 
 Branch the project
 
   $ cvscall tag -b BRANCH
   cvs tag: Tagging .
   $ cvscall up -r BRANCH > /dev/null
   cvs update: Updating .
 
 Modify file a, then b, then a
 
   $ sleep 1
   $ echo "2" > a
   $ cvscall ci -m "mod a"
   cvs commit: Examining .
   $ echo "2" > b
   $ cvscall ci -m "mod b"
   cvs commit: Examining .
   $ sleep 1
   $ echo "3" > a
   $ cvscall ci -m "mod a again"
   cvs commit: Examining .
 
 Convert
 
   $ cd ..
   $ hg convert src
   assuming destination src-hg
   initializing destination src-hg repository
   connecting to $TESTTMP/cvsrepo
   scanning source...
   collecting CVS rlog
   7 log entries
   creating changesets
   5 changeset entries
   sorting...
   converting...
   4 Initial revision
   3 init
   2 mod a
   1 mod b
   0 mod a again
   updating tags
 
 Check the result
 
   $ hg -R src-hg log -G --template '{rev} ({branches}) {desc} files: {files}\n'
   o  5 () update tags files: .hgtags
   |
   | o  4 (BRANCH) mod a again files: a
   | |
   | o  3 (BRANCH) mod b files: b
   | |
   | o  2 (BRANCH) mod a files: a
   | |
   | o  1 (v0) init files:
   |/
   o  0 () Initial revision files: a b
   
 
 
 issue 1447
 
   $ cvscall()
   > {
   >     cvs -f "$@" > /dev/null
   >     sleep 1
   > }
   $ cvsci()
   > {
   >     cvs -f ci "$@" >/dev/null
   >     sleep 1
   > }
   $ cvscall -Q -d `pwd`/cvsmaster2 init
   $ cd cvsmaster2
   $ CVSROOT=`pwd`
   $ export CVSROOT
   $ mkdir foo
   $ cd ..
   $ cvscall -Q co -d cvswork2 foo
   $ cd cvswork2
   $ echo foo > a.txt
   $ echo bar > b.txt
   $ cvscall -Q add a.txt b.txt
   $ cvsci -m "Initial commit"
   cvs commit: Examining .
   $ echo foo > b.txt
   $ cvsci -m "Fix b on HEAD"
   cvs commit: Examining .
   $ echo bar > a.txt
   $ cvsci -m "Small fix in a on HEAD"
   cvs commit: Examining .
   $ cvscall -Q tag -b BRANCH
   $ cvscall -Q up -P -rBRANCH
   $ echo baz > b.txt
   $ cvsci -m "Change on BRANCH in b"
   cvs commit: Examining .
   $ hg debugcvsps -x --parents foo
   collecting CVS rlog
   5 log entries
   creating changesets
   4 changeset entries
   ---------------------
   PatchSet 1 
   Date: * (glob)
   Author: * (glob)
   Branch: HEAD
   Tag: (none) 
   Log:
   Initial commit
   
   Members: 
   	a.txt:INITIAL->1.1 
   	b.txt:INITIAL->1.1 
   
   ---------------------
   PatchSet 2 
   Date: * (glob)
   Author: * (glob)
   Branch: HEAD
   Tag: (none) 
   Branchpoints: BRANCH 
   Parent: 1
   Log:
   Fix b on HEAD
   
   Members: 
   	b.txt:1.1->1.2 
   
   ---------------------
   PatchSet 3 
   Date: * (glob)
   Author: * (glob)
   Branch: HEAD
   Tag: (none) 
   Branchpoints: BRANCH 
   Parent: 2
   Log:
   Small fix in a on HEAD
   
   Members: 
   	a.txt:1.1->1.2 
   
   ---------------------
   PatchSet 4 
   Date: * (glob)
   Author: * (glob)
   Branch: BRANCH
   Tag: (none) 
   Parent: 3
   Log:
   Change on BRANCH in b
   
   Members: 
   	b.txt:1.2->1.2.2.1 
   
 
   $ cd ..

tests/test-convert-cvs-detectmerge.t

@@ -1,234 +1,234 b''
-#require cvs
+#require cvs no-root
 
 Test config convert.cvsps.mergefrom config setting.
 (Should test similar mergeto feature, but I don't understand it yet.)
 Requires builtin cvsps.
 
   $ CVSROOT=`pwd`/cvsrepo
   $ export CVSROOT
 
   $ cvscall()
   > {
   >     cvs -f "$@"
   > }
 
 output of 'cvs ci' varies unpredictably, so just discard it
 XXX copied from test-convert-cvs-synthetic
 
   $ cvsci()
   > {
   >     sleep 1
   >     cvs -f ci "$@" > /dev/null
   > }
 
 XXX copied from test-convert-cvs-synthetic
 
   $ cat <<EOF >> $HGRCPATH
   > [extensions]
   > convert =
   > [convert]
   > cvsps.cache = 0
   > cvsps.mergefrom = \[MERGE from (\S+)\]
   > EOF
 
 create cvs repository with one project
 
   $ cvscall -q -d "$CVSROOT" init
   $ mkdir cvsrepo/proj
 
 populate cvs repository
 
   $ cvscall -Q co proj
   $ cd proj
   $ touch file1
   $ cvscall -Q add file1
   $ cvsci -m"add file1 on trunk"
   cvs commit: Examining .
 
 create two release branches
 
   $ cvscall -q tag -b v1_0
   T file1
   $ cvscall -q tag -b v1_1
   T file1
 
 modify file1 on branch v1_0
 
   $ cvscall -Q update -rv1_0
   $ sleep 1
   $ echo "change" >> file1
   $ cvsci -m"add text"
   cvs commit: Examining .
 
 make unrelated change on v1_1
 
   $ cvscall -Q update -rv1_1
   $ touch unrelated
   $ cvscall -Q add unrelated
   $ cvsci -m"unrelated change"
   cvs commit: Examining .
 
 merge file1 to v1_1
 
   $ cvscall -Q update -jv1_0
   RCS file: $TESTTMP/cvsrepo/proj/file1,v
   retrieving revision 1.1
   retrieving revision 1.1.2.1
   Merging differences between 1.1 and 1.1.2.1 into file1
   $ cvsci -m"add text [MERGE from v1_0]"
   cvs commit: Examining .
 
 merge change to trunk
 
   $ cvscall -Q update -A
   $ cvscall -Q update -jv1_1
   RCS file: $TESTTMP/cvsrepo/proj/file1,v
   retrieving revision 1.1
   retrieving revision 1.1.4.1
   Merging differences between 1.1 and 1.1.4.1 into file1
   $ cvsci -m"add text [MERGE from v1_1]"
   cvs commit: Examining .
 
 non-merged change on trunk
 
   $ echo "foo" > file2
   $ cvscall -Q add file2
   $ cvsci -m"add file2 on trunk" file2
 
 this will create rev 1.3
 change on trunk to backport
 
   $ echo "backport me" >> file1
   $ cvsci -m"add other text" file1
   $ cvscall log file1
   
   RCS file: $TESTTMP/cvsrepo/proj/file1,v
   Working file: file1
   head: 1.3
   branch:
   locks: strict
   access list:
   symbolic names:
   	v1_1: 1.1.0.4
   	v1_0: 1.1.0.2
   keyword substitution: kv
   total revisions: 5;	selected revisions: 5
   description:
   ----------------------------
   revision 1.3
   date: * (glob)
   add other text
   ----------------------------
   revision 1.2
   date: * (glob)
   add text [MERGE from v1_1]
   ----------------------------
   revision 1.1
   date: * (glob)
   branches:  1.1.2;  1.1.4;
   add file1 on trunk
   ----------------------------
   revision 1.1.4.1
   date: * (glob)
   add text [MERGE from v1_0]
   ----------------------------
   revision 1.1.2.1
   date: * (glob)
   add text
   =============================================================================
 
 XXX how many ways are there to spell "trunk" with CVS?
 backport trunk change to v1_1
 
   $ cvscall -Q update -rv1_1
   $ cvscall -Q update -j1.2 -j1.3 file1
   RCS file: $TESTTMP/cvsrepo/proj/file1,v
   retrieving revision 1.2
   retrieving revision 1.3
   Merging differences between 1.2 and 1.3 into file1
   $ cvsci -m"add other text [MERGE from HEAD]" file1
 
 fix bug on v1_1, merge to trunk with error
 
   $ cvscall -Q update -rv1_1
   $ echo "merge forward" >> file1
   $ cvscall -Q tag unmerged
   $ cvsci -m"fix file1"
   cvs commit: Examining .
   $ cvscall -Q update -A
   $ cvscall -Q update -junmerged -jv1_1
   RCS file: $TESTTMP/cvsrepo/proj/file1,v
   retrieving revision 1.1.4.2
   retrieving revision 1.1.4.3
   Merging differences between 1.1.4.2 and 1.1.4.3 into file1
 
 note the typo in the commit log message
 
   $ cvsci -m"fix file1 [MERGE from v1-1]"
   cvs commit: Examining .
   $ cvs -Q tag -d unmerged
 
 convert to hg
 
   $ cd ..
   $ hg convert proj proj.hg
   initializing destination proj.hg repository
   connecting to $TESTTMP/cvsrepo
   scanning source...
   collecting CVS rlog
   12 log entries
   creating changesets
   warning: CVS commit message references non-existent branch 'v1-1':
   fix file1 [MERGE from v1-1]
   10 changeset entries
   sorting...
   converting...
   9 add file1 on trunk
   8 unrelated change
   7 add text
   6 add text [MERGE from v1_0]
   5 add text [MERGE from v1_1]
   4 add file2 on trunk
   3 add other text
   2 add other text [MERGE from HEAD]
   1 fix file1
   0 fix file1 [MERGE from v1-1]
 
 complete log
 
   $ template="{rev}: '{branches}' {desc}\n"
   $ hg -R proj.hg log --template="$template"
   9: '' fix file1 [MERGE from v1-1]
   8: 'v1_1' fix file1
   7: 'v1_1' add other text [MERGE from HEAD]
   6: '' add other text
   5: '' add file2 on trunk
   4: '' add text [MERGE from v1_1]
   3: 'v1_1' add text [MERGE from v1_0]
   2: 'v1_0' add text
   1: 'v1_1' unrelated change
   0: '' add file1 on trunk
 
 graphical log
 
   $ hg -R proj.hg log -G --template="$template"
   o  9: '' fix file1 [MERGE from v1-1]
   |
   | o  8: 'v1_1' fix file1
   | |
   | o  7: 'v1_1' add other text [MERGE from HEAD]
   |/|
   o |  6: '' add other text
   | |
   o |  5: '' add file2 on trunk
   | |
   o |  4: '' add text [MERGE from v1_1]
   |\|
   | o    3: 'v1_1' add text [MERGE from v1_0]
   | |\
   +---o  2: 'v1_0' add text
   | |
   | o  1: 'v1_1' unrelated change
   |/
   o  0: '' add file1 on trunk
   

tests/test-convert-cvs-synthetic.t

@@ -1,224 +1,224 b''
-#require cvs112
+#require cvs112 no-root
 
 This feature requires use of builtin cvsps!
 
   $ echo "[extensions]" >> $HGRCPATH
   $ echo "convert = " >> $HGRCPATH
 
 create cvs repository with one project
 
   $ mkdir cvsrepo
   $ cd cvsrepo
   $ CVSROOT=`pwd`
   $ export CVSROOT
   $ CVS_OPTIONS=-f
   $ export CVS_OPTIONS
   $ cd ..
   $ rmdir cvsrepo
   $ cvscall()
   > {
   >     cvs -f "$@"
   > }
 
 output of 'cvs ci' varies unpredictably, so just discard it
 
   $ cvsci()
   > {
   >     sleep 1
   >     cvs -f ci "$@" >/dev/null
   > }
   $ cvscall -d "$CVSROOT" init
   $ mkdir cvsrepo/proj
   $ cvscall -q co proj
 
 create file1 on the trunk
 
   $ cd proj
   $ touch file1
   $ cvscall -Q add file1
   $ cvsci -m"add file1 on trunk" file1
 
 create two branches
 
   $ cvscall -q tag -b v1_0
   T file1
   $ cvscall -q tag -b v1_1
   T file1
 
 create file2 on branch v1_0
 
   $ cvscall -Q up -rv1_0
   $ touch file2
   $ cvscall -Q add file2
   $ cvsci -m"add file2" file2
 
 create file3, file4 on branch v1_1
 
   $ cvscall -Q up -rv1_1
   $ touch file3
   $ touch file4
   $ cvscall -Q add file3 file4
   $ cvsci -m"add file3, file4 on branch v1_1" file3 file4
 
 merge file2 from v1_0 to v1_1
 
   $ cvscall -Q up -jv1_0
   $ cvsci -m"MERGE from v1_0: add file2"
   cvs commit: Examining .
 
 Step things up a notch: now we make the history really hairy, with
 changes bouncing back and forth between trunk and v1_2 and merges
 going both ways.  (I.e., try to model the real world.)
 create branch v1_2
 
   $ cvscall -Q up -A
   $ cvscall -q tag -b v1_2
   T file1
 
 create file5 on branch v1_2
 
   $ cvscall -Q up -rv1_2
   $ touch file5
   $ cvs -Q add file5
   $ cvsci -m"add file5 on v1_2"
   cvs commit: Examining .
 
 create file6 on trunk post-v1_2
 
   $ cvscall -Q up -A
   $ touch file6
   $ cvscall -Q add file6
   $ cvsci -m"add file6 on trunk post-v1_2"
   cvs commit: Examining .
 
 merge file5 from v1_2 to trunk
 
   $ cvscall -Q up -A
   $ cvscall -Q up -jv1_2 file5
   $ cvsci -m"MERGE from v1_2: add file5"
   cvs commit: Examining .
 
 merge file6 from trunk to v1_2
 
   $ cvscall -Q up -rv1_2
   $ cvscall up -jHEAD file6
   U file6
   $ cvsci -m"MERGE from HEAD: add file6"
   cvs commit: Examining .
 
 cvs rlog output
 
   $ cvscall -q rlog proj | egrep '^(RCS file|revision)'
   RCS file: $TESTTMP/cvsrepo/proj/file1,v
   revision 1.1
   RCS file: $TESTTMP/cvsrepo/proj/Attic/file2,v
   revision 1.1
   revision 1.1.4.2
   revision 1.1.4.1
   revision 1.1.2.1
   RCS file: $TESTTMP/cvsrepo/proj/Attic/file3,v
   revision 1.1
   revision 1.1.2.1
   RCS file: $TESTTMP/cvsrepo/proj/Attic/file4,v
   revision 1.1
   revision 1.1.2.1
   RCS file: $TESTTMP/cvsrepo/proj/file5,v
   revision 1.2
   revision 1.1
   revision 1.1.2.1
   RCS file: $TESTTMP/cvsrepo/proj/file6,v
   revision 1.1
   revision 1.1.2.2
   revision 1.1.2.1
 
 convert to hg (#1)
 
   $ cd ..
   $ hg convert --datesort proj proj.hg
   initializing destination proj.hg repository
   connecting to $TESTTMP/cvsrepo
   scanning source...
   collecting CVS rlog
   15 log entries
   creating changesets
   9 changeset entries
   sorting...
   converting...
   8 add file1 on trunk
   7 add file2
   6 MERGE from v1_0: add file2
   5 file file3 was initially added on branch v1_1.
   4 add file3, file4 on branch v1_1
   3 add file5 on v1_2
   2 add file6 on trunk post-v1_2
   1 MERGE from HEAD: add file6
   0 MERGE from v1_2: add file5
 
 hg log -G output (#1)
 
   $ hg -R proj.hg log -G --template "{rev} {desc}\n"
   o  8 MERGE from v1_2: add file5
   |
   | o  7 MERGE from HEAD: add file6
   | |
   o |  6 add file6 on trunk post-v1_2
   | |
   | o  5 add file5 on v1_2
   | |
   | | o  4 add file3, file4 on branch v1_1
   | | |
   o | |  3 file file3 was initially added on branch v1_1.
   |/ /
   | o  2 MERGE from v1_0: add file2
   |/
   | o  1 add file2
   |/
   o  0 add file1 on trunk
   
 
 convert to hg (#2: with merge detection)
 
   $ hg convert \
   >   --config convert.cvsps.mergefrom='"^MERGE from (\S+):"' \
   >   --datesort \
   >   proj proj.hg2
   initializing destination proj.hg2 repository
   connecting to $TESTTMP/cvsrepo
   scanning source...
   collecting CVS rlog
   15 log entries
   creating changesets
   9 changeset entries
   sorting...
   converting...
   8 add file1 on trunk
   7 add file2
   6 MERGE from v1_0: add file2
   5 file file3 was initially added on branch v1_1.
   4 add file3, file4 on branch v1_1
   3 add file5 on v1_2
   2 add file6 on trunk post-v1_2
   1 MERGE from HEAD: add file6
   0 MERGE from v1_2: add file5
 
 hg log -G output (#2)
 
   $ hg -R proj.hg2 log -G --template "{rev} {desc}\n"
   o  8 MERGE from v1_2: add file5
   |
   | o  7 MERGE from HEAD: add file6
   | |
   o |  6 add file6 on trunk post-v1_2
   | |
   | o  5 add file5 on v1_2
   | |
   | | o  4 add file3, file4 on branch v1_1
   | | |
   o | |  3 file file3 was initially added on branch v1_1.
   |/ /
   | o  2 MERGE from v1_0: add file2
   |/
   | o  1 add file2
   |/
   o  0 add file1 on trunk
   

tests/test-convert-cvs.t

@@ -1,659 +1,659 b''
-#require cvs
+#require cvs no-root
 
   $ cvscall()
   > {
   >     cvs -f "$@"
   > }
   $ hgcat()
   > {
   >     hg --cwd src-hg cat -r tip "$1"
   > }
   $ echo "[extensions]" >> $HGRCPATH
   $ echo "convert = " >> $HGRCPATH
   $ cat > cvshooks.py <<EOF
   > def cvslog(ui, repo, hooktype, log):
   >     ui.write(b'%s hook: %d entries\n' % (hooktype, len(log)))
   > 
   > def cvschangesets(ui, repo, hooktype, changesets):
   >     ui.write(b'%s hook: %d changesets\n' % (hooktype, len(changesets)))
   > EOF
   $ hookpath=`pwd`
   $ cat <<EOF >> $HGRCPATH
   > [hooks]
   > cvslog = python:$hookpath/cvshooks.py:cvslog
   > cvschangesets = python:$hookpath/cvshooks.py:cvschangesets
   > EOF
 
 create cvs repository
 
   $ mkdir cvsrepo
   $ cd cvsrepo
   $ CVSROOT=`pwd`
   $ export CVSROOT
   $ CVS_OPTIONS=-f
   $ export CVS_OPTIONS
   $ cd ..
   $ rmdir cvsrepo
   $ cvscall -q -d "$CVSROOT" init
 
 create source directory
 
   $ mkdir src-temp
   $ cd src-temp
   $ echo a > a
   $ mkdir b
   $ cd b
   $ echo c > c
   $ cd ..
 
 import source directory
 
   $ cvscall -q import -m import src INITIAL start
   N src/a
   N src/b/c
   
   No conflicts created by this import
   
   $ cd ..
 
 checkout source directory
 
   $ cvscall -q checkout src
   U src/a
   U src/b/c
 
 commit a new revision changing b/c
 
   $ cd src
   $ sleep 1
   $ echo c >> b/c
   $ cvscall -q commit -mci0 . | grep '<--'
   $TESTTMP/cvsrepo/src/b/c,v  <--  *c (glob)
   $ cd ..
 
 convert fresh repo and also check localtimezone option
 
 NOTE: This doesn't check all time zones -- it merely determines that
 the configuration option is taking effect.
 
 An arbitrary (U.S.) time zone is used here.  TZ=US/Hawaii is selected
 since it does not use DST (unlike other U.S. time zones) and is always
 a fixed difference from UTC.
 
 This choice is limited to work on Linux environments. At least on
 FreeBSD 11 this timezone is not known. A better choice is
 TZ=Pacific/Johnston. On Linux "US/Hawaii" is just a symlink to this
 name and also it is known on FreeBSD and on Solaris.
 
   $ TZ=Pacific/Johnston hg convert --config convert.localtimezone=True src src-hg
   initializing destination src-hg repository
   connecting to $TESTTMP/cvsrepo
   scanning source...
   collecting CVS rlog
   5 log entries
   cvslog hook: 5 entries
   creating changesets
   3 changeset entries
   cvschangesets hook: 3 changesets
   sorting...
   converting...
   2 Initial revision
   1 ci0
   0 import
   updating tags
   $ hgcat a
   a
   $ hgcat b/c
   c
   c
 
 convert fresh repo with --filemap
 
   $ echo include b/c > filemap
   $ hg convert --filemap filemap src src-filemap
   initializing destination src-filemap repository
   connecting to $TESTTMP/cvsrepo
   scanning source...
   collecting CVS rlog
   5 log entries
   cvslog hook: 5 entries
   creating changesets
   3 changeset entries
   cvschangesets hook: 3 changesets
   sorting...
   converting...
   2 Initial revision
   1 ci0
   0 import
   filtering out empty revision
   repository tip rolled back to revision 1 (undo convert)
   updating tags
   $ hgcat b/c
   c
   c
   $ hg -R src-filemap log --template '{rev} {desc} files: {files}\n'
   2 update tags files: .hgtags
   1 ci0 files: b/c
   0 Initial revision files: b/c
 
 convert full repository (issue1649)
 
   $ cvscall -q -d "$CVSROOT" checkout -d srcfull "." | grep -v CVSROOT
   U srcfull/src/a
   U srcfull/src/b/c
   $ ls srcfull
   CVS
   CVSROOT
   src
   $ hg convert srcfull srcfull-hg \
   >     | grep -v 'log entries' | grep -v 'hook:' \
   >     | grep -v '^[0-3] .*' # filter instable changeset order
   initializing destination srcfull-hg repository
   connecting to $TESTTMP/cvsrepo
   scanning source...
   collecting CVS rlog
   creating changesets
   4 changeset entries
   sorting...
   converting...
   updating tags
   $ hg cat -r tip --cwd srcfull-hg src/a
   a
   $ hg cat -r tip --cwd srcfull-hg src/b/c
   c
   c
 
 commit new file revisions
 
   $ cd src
   $ echo a >> a
   $ echo c >> b/c
   $ cvscall -q commit -mci1 . | grep '<--'
   $TESTTMP/cvsrepo/src/a,v  <--  a
   $TESTTMP/cvsrepo/src/b/c,v  <--  *c (glob)
   $ cd ..
 
 convert again
 
   $ TZ=Pacific/Johnston hg convert --config convert.localtimezone=True src src-hg
   connecting to $TESTTMP/cvsrepo
   scanning source...
   collecting CVS rlog
   7 log entries
   cvslog hook: 7 entries
   creating changesets
   4 changeset entries
   cvschangesets hook: 4 changesets
   sorting...
   converting...
   0 ci1
   $ hgcat a
   a
   a
   $ hgcat b/c
   c
   c
   c
 
 convert again with --filemap
 
   $ hg convert --filemap filemap src src-filemap
   connecting to $TESTTMP/cvsrepo
   scanning source...
   collecting CVS rlog
   7 log entries
   cvslog hook: 7 entries
   creating changesets
   4 changeset entries
   cvschangesets hook: 4 changesets
   sorting...
   converting...
   0 ci1
   $ hgcat b/c
   c
   c
   c
   $ hg -R src-filemap log --template '{rev} {desc} files: {files}\n'
   3 ci1 files: b/c
   2 update tags files: .hgtags
   1 ci0 files: b/c
   0 Initial revision files: b/c
 
 commit branch
 
   $ cd src
   $ cvs -q update -r1.1 b/c
   U b/c
   $ cvs -q tag -b branch
   T a
   T b/c
   $ cvs -q update -r branch > /dev/null
   $ sleep 1
   $ echo d >> b/c
   $ cvs -q commit -mci2 . | grep '<--'
   $TESTTMP/cvsrepo/src/b/c,v  <--  *c (glob)
   $ cd ..
 
 convert again
 
   $ TZ=Pacific/Johnston hg convert --config convert.localtimezone=True src src-hg
   connecting to $TESTTMP/cvsrepo
   scanning source...
   collecting CVS rlog
   8 log entries
   cvslog hook: 8 entries
   creating changesets
   5 changeset entries
   cvschangesets hook: 5 changesets
   sorting...
   converting...
   0 ci2
   $ hgcat b/c
   c
   d
 
 convert again with --filemap
 
   $ TZ=Pacific/Johnston hg convert --config convert.localtimezone=True --filemap filemap src src-filemap
   connecting to $TESTTMP/cvsrepo
   scanning source...
   collecting CVS rlog
   8 log entries
   cvslog hook: 8 entries
   creating changesets
   5 changeset entries
   cvschangesets hook: 5 changesets
   sorting...
   converting...
   0 ci2
   $ hgcat b/c
   c
   d
   $ hg -R src-filemap log --template '{rev} {desc} files: {files}\n'
   4 ci2 files: b/c
   3 ci1 files: b/c
   2 update tags files: .hgtags
   1 ci0 files: b/c
   0 Initial revision files: b/c
 
 commit a new revision with funny log message
 
   $ cd src
   $ sleep 1
   $ echo e >> a
   $ cvscall -q commit -m'funny
   > ----------------------------
   > log message' . | grep '<--' |\
   >  sed -e 's:.*src/\(.*\),v.*:checking in src/\1,v:g'
   checking in src/a,v
 
 commit new file revisions with some fuzz
 
   $ sleep 1
   $ echo f >> a
   $ cvscall -q commit -mfuzzy . | grep '<--'
   $TESTTMP/cvsrepo/src/a,v  <--  a
   $ sleep 4 # the two changes will be split if fuzz < 4
   $ echo g >> b/c
   $ cvscall -q commit -mfuzzy . | grep '<--'
   $TESTTMP/cvsrepo/src/b/c,v  <--  *c (glob)
   $ cd ..
 
 convert again
 
   $ TZ=Pacific/Johnston hg convert --config convert.cvsps.fuzz=2 --config convert.localtimezone=True src src-hg
   connecting to $TESTTMP/cvsrepo
   scanning source...
   collecting CVS rlog
   11 log entries
   cvslog hook: 11 entries
   creating changesets
   8 changeset entries
   cvschangesets hook: 8 changesets
   sorting...
   converting...
   2 funny
   1 fuzzy
   0 fuzzy
   $ hg -R src-hg log -G --template '{rev} ({branches}) {desc} date: {date|date} files: {files}\n'
   o  8 (branch) fuzzy date: * -1000 files: b/c (glob)
   |
   o  7 (branch) fuzzy date: * -1000 files: a (glob)
   |
   o  6 (branch) funny
   |  ----------------------------
   |  log message date: * -1000 files: a (glob)
   o  5 (branch) ci2 date: * -1000 files: b/c (glob)
   
   o  4 () ci1 date: * -1000 files: a b/c (glob)
   |
   o  3 () update tags date: * +0000 files: .hgtags (glob)
   |
   | o  2 (INITIAL) import date: * -1000 files: (glob)
   | |
   o |  1 () ci0 date: * -1000 files: b/c (glob)
   |/
   o  0 () Initial revision date: * -1000 files: a b/c (glob)
   
 
 testing debugcvsps
 
   $ cd src
   $ hg debugcvsps --fuzz=2 -x >/dev/null
 
 commit a new revision changing a and removing b/c
 
   $ cvscall -q update -A
   U a
   U b/c
   $ sleep 1
   $ echo h >> a
   $ cvscall -Q remove -f b/c
   $ cvscall -q commit -mci | grep '<--'
   $TESTTMP/cvsrepo/src/a,v  <--  a
   $TESTTMP/cvsrepo/src/b/c,v  <--  *c (glob)
 
 update and verify the cvsps cache
 
   $ hg debugcvsps --fuzz=2 -u
   collecting CVS rlog
   13 log entries
   cvslog hook: 13 entries
   creating changesets
   11 changeset entries
   cvschangesets hook: 11 changesets
   ---------------------
   PatchSet 1 
   Date: * (glob)
   Author: * (glob)
   Branch: HEAD
   Tag: (none) 
   Branchpoints: INITIAL 
   Log:
   Initial revision
   
   Members: 
   	a:INITIAL->1.1 
   
   ---------------------
   PatchSet 2 
   Date: * (glob)
   Author: * (glob)
   Branch: HEAD
   Tag: (none) 
   Branchpoints: INITIAL, branch 
   Log:
   Initial revision
   
   Members: 
   	b/c:INITIAL->1.1 
   
   ---------------------
   PatchSet 3 
   Date: * (glob)
   Author: * (glob)
   Branch: INITIAL
   Tag: start 
   Log:
   import
   
   Members: 
   	a:1.1->1.1.1.1 
   	b/c:1.1->1.1.1.1 
   
   ---------------------
   PatchSet 4 
   Date: * (glob)
   Author: * (glob)
   Branch: HEAD
   Tag: (none) 
   Log:
   ci0
   
   Members: 
   	b/c:1.1->1.2 
   
   ---------------------
   PatchSet 5 
   Date: * (glob)
   Author: * (glob)
   Branch: HEAD
   Tag: (none) 
   Branchpoints: branch 
   Log:
   ci1
   
   Members: 
   	a:1.1->1.2 
   
   ---------------------
   PatchSet 6 
   Date: * (glob)
   Author: * (glob)
   Branch: HEAD
   Tag: (none) 
   Log:
   ci1
   
   Members: 
   	b/c:1.2->1.3 
   
   ---------------------
   PatchSet 7 
   Date: * (glob)
   Author: * (glob)
   Branch: branch
   Tag: (none) 
   Log:
   ci2
   
   Members: 
   	b/c:1.1->1.1.2.1 
   
   ---------------------
   PatchSet 8 
   Date: * (glob)
   Author: * (glob)
   Branch: branch
   Tag: (none) 
   Log:
   funny
   ----------------------------
   log message
   
   Members: 
   	a:1.2->1.2.2.1 
   
   ---------------------
   PatchSet 9 
   Date: * (glob)
   Author: * (glob)
   Branch: branch
   Tag: (none) 
   Log:
   fuzzy
   
   Members: 
   	a:1.2.2.1->1.2.2.2 
   
   ---------------------
   PatchSet 10 
   Date: * (glob)
   Author: * (glob)
   Branch: branch
   Tag: (none) 
   Log:
   fuzzy
   
   Members: 
   	b/c:1.1.2.1->1.1.2.2 
   
   ---------------------
   PatchSet 11 
   Date: * (glob)
   Author: * (glob)
   Branch: HEAD
   Tag: (none) 
   Log:
   ci
   
   Members: 
   	a:1.2->1.3 
   	b/c:1.3->1.4(DEAD) 
   
 
   $ cd ..
 
 Test transcoding CVS log messages (issue5597)
 =============================================
 
 To emulate commit messages in (non-ascii) multiple encodings portably,
 this test scenario writes CVS history file (*,v file) directly via
 python code.
 
 Commit messages of version 1.2 - 1.4 use u3042 in 3 encodings below.
 
 |encoding  |byte sequence | decodable as:      |
 |          |              | utf-8 euc-jp cp932 |
 +----------+--------------+--------------------+
 |utf-8     |\xe3\x81\x82  |  o      x     x    |
 |euc-jp    |\xa4\xa2      |  x      o     o    |
 |cp932     |\x82\xa0      |  x      x     o    |
 
   $ mkdir -p cvsrepo/transcoding
   $ python <<EOF
   > fp = open('cvsrepo/transcoding/file,v', 'wb')
   > fp.write((b'''
   > head	1.4;
   > access;
   > symbols
   > 	start:1.1.1.1 INITIAL:1.1.1;
   > locks; strict;
   > comment	@# @;
   > 
   > 
   > 1.4
   > date	2017.07.10.00.00.04;	author nobody;	state Exp;
   > branches;
   > next	1.3;
   > commitid	10059635D016A510FFA;
   > 
   > 1.3
   > date	2017.07.10.00.00.03;	author nobody;	state Exp;
   > branches;
   > next	1.2;
   > commitid	10059635CFF6A4FF34E;
   > 
   > 1.2
   > date	2017.07.10.00.00.02;	author nobody;	state Exp;
   > branches;
   > next	1.1;
   > commitid	10059635CFD6A4D5095;
   > 
   > 1.1
   > date	2017.07.10.00.00.01;	author nobody;	state Exp;
   > branches
   > 	1.1.1.1;
   > next	;
   > commitid	10059635CFB6A4A3C33;
   > 
   > 1.1.1.1
   > date	2017.07.10.00.00.01;	author nobody;	state Exp;
   > branches;
   > next	;
   > commitid	10059635CFB6A4A3C33;
   > 
   > 
   > desc
   > @@
   > 
   > 
   > 1.4
   > log
   > @''' + u'\u3042'.encode('cp932') + b''' (cp932)
   > @
   > text
   > @1
   > 2
   > 3
   > 4
   > @
   > 
   > 
   > 1.3
   > log
   > @''' + u'\u3042'.encode('euc-jp') + b''' (euc-jp)
   > @
   > text
   > @d4 1
   > @
   > 
   > 
   > 1.2
   > log
   > @''' + u'\u3042'.encode('utf-8') +  b''' (utf-8)
   > @
   > text
   > @d3 1
   > @
   > 
   > 
   > 1.1
   > log
   > @Initial revision
   > @
   > text
   > @d2 1
   > @
   > 
   > 
   > 1.1.1.1
   > log
   > @import
   > @
   > text
   > @@
   > ''').lstrip())
   > EOF
 
   $ cvscall -q checkout transcoding
   U transcoding/file
 
 Test converting in normal case
 ------------------------------
 
 (filtering by grep in order to check only form of debug messages)
 
   $ hg convert --config convert.cvsps.logencoding=utf-8,euc-jp,cp932 -q --debug transcoding transcoding-hg | grep 'transcoding by'
   transcoding by utf-8: 1.1 of file
   transcoding by utf-8: 1.1.1.1 of file
   transcoding by utf-8: 1.2 of file
   transcoding by euc-jp: 1.3 of file
   transcoding by cp932: 1.4 of file
   $ hg -R transcoding-hg --encoding utf-8 log -T "{rev}: {desc}\n"
   5: update tags
   4: import
   3: \xe3\x81\x82 (cp932) (esc)
   2: \xe3\x81\x82 (euc-jp) (esc)
   1: \xe3\x81\x82 (utf-8) (esc)
   0: Initial revision
   $ rm -rf transcoding-hg
 
 Test converting in error cases
 ------------------------------
 
 unknown encoding in convert.cvsps.logencoding
 
   $ hg convert --config convert.cvsps.logencoding=foobar -q transcoding transcoding-hg
   abort: unknown encoding: foobar
   (check convert.cvsps.logencoding configuration)
   [255]
   $ rm -rf transcoding-hg
 
 no acceptable encoding in convert.cvsps.logencoding
 
   $ hg convert --config convert.cvsps.logencoding=utf-8,euc-jp -q transcoding transcoding-hg
   abort: no encoding can transcode CVS log message for 1.4 of file
   (check convert.cvsps.logencoding configuration)
   [255]
   $ rm -rf transcoding-hg

tests/test-convert-cvsnt-mergepoints.t

@@ -1,207 +1,207 b''
-#require cvs
+#require cvs no-root
 
   $ filterpath()
   > {
   >     eval "$@" | sed "s:$CVSROOT:*REPO*:g"
   > }
   $ cvscall()
   > {
   >     cvs -f "$@"
   > }
 
 output of 'cvs ci' varies unpredictably, so discard most of it
 -- just keep the part that matters
 
   $ cvsci()
   > {
   >     cvs -f ci -f "$@" > /dev/null
   > }
   $ hgcat()
   > {
   >     hg --cwd src-hg cat -r tip "$1"
   > }
   $ echo "[extensions]" >> $HGRCPATH
   $ echo "convert = " >> $HGRCPATH
 
 create cvs repository
 
   $ mkdir cvsmaster
   $ cd cvsmaster
   $ CVSROOT=`pwd`
   $ export CVSROOT
   $ CVS_OPTIONS=-f
   $ export CVS_OPTIONS
   $ cd ..
   $ rmdir cvsmaster
   $ filterpath cvscall -Q -d "$CVSROOT" init
 
 checkout #1: add foo.txt
 
   $ cvscall -Q checkout -d cvsworktmp .
   $ cd cvsworktmp
   $ mkdir foo
   $ cvscall -Q add foo
   $ cd foo
   $ echo foo > foo.txt
   $ cvscall -Q add foo.txt
   $ cvsci -m "add foo.txt" foo.txt
   $ cd ../..
   $ rm -rf cvsworktmp
 
 checkout #2: create MYBRANCH1 and modify foo.txt on it
 
   $ cvscall -Q checkout -d cvswork foo
   $ cd cvswork
   $ cvscall -q rtag -b -R MYBRANCH1 foo
   $ cvscall -Q update -P -r MYBRANCH1
   $ echo bar > foo.txt
   $ cvsci -m "bar" foo.txt
   $ echo baz > foo.txt
   $ cvsci -m "baz" foo.txt
 
 create MYBRANCH1_2 and modify foo.txt some more
 
   $ cvscall -q rtag -b -R -r MYBRANCH1 MYBRANCH1_2 foo
   $ cvscall -Q update -P -r MYBRANCH1_2
   $ echo bazzie > foo.txt
   $ cvsci -m "bazzie" foo.txt
 
 create MYBRANCH1_1 and modify foo.txt yet again
 
   $ cvscall -q rtag -b -R MYBRANCH1_1 foo
   $ cvscall -Q update -P -r MYBRANCH1_1
   $ echo quux > foo.txt
   $ cvsci -m "quux" foo.txt
 
 merge MYBRANCH1 to MYBRANCH1_1
 
   $ filterpath cvscall -Q update -P -jMYBRANCH1
   rcsmerge: warning: conflicts during merge
   RCS file: *REPO*/foo/foo.txt,v
   retrieving revision 1.1
   retrieving revision 1.1.2.2
   Merging differences between 1.1 and 1.1.2.2 into foo.txt
 
 carefully placed sleep to dodge cvs bug (optimization?) where it
 sometimes ignores a "commit" command if it comes too fast (the -f
 option in cvsci seems to work for all the other commits in this
 script)
 
   $ sleep 1
   $ echo xyzzy > foo.txt
   $ cvsci -m "merge1+clobber" foo.txt
 
 #if unix-permissions
 
 return to trunk and merge MYBRANCH1_2
 
   $ cvscall -Q update -P -A
   $ filterpath cvscall -Q update -P -jMYBRANCH1_2
   RCS file: *REPO*/foo/foo.txt,v
   retrieving revision 1.1
   retrieving revision 1.1.2.2.2.1
   Merging differences between 1.1 and 1.1.2.2.2.1 into foo.txt
   $ cvsci -m "merge2" foo.txt
   $ REALCVS=`which cvs`
   $ echo "for x in \$*; do if [ \"\$x\" = \"rlog\" ]; then echo \"RCS file: $CVSROOT/foo/foo.txt,v\"; cat \"$TESTDIR/test-convert-cvsnt-mergepoints.rlog\"; exit 0; fi; done; $REALCVS \$*" > ../cvs
   $ chmod +x ../cvs
   $ PATH=..:${PATH} hg debugcvsps --parents foo
   collecting CVS rlog
   7 log entries
   creating changesets
   7 changeset entries
   ---------------------
   PatchSet 1 
   Date: * (glob)
   Author: user
   Branch: HEAD
   Tag: (none) 
   Branchpoints: MYBRANCH1, MYBRANCH1_1 
   Log:
   foo.txt
   
   Members: 
   	foo.txt:INITIAL->1.1 
   
   ---------------------
   PatchSet 2 
   Date: * (glob)
   Author: user
   Branch: MYBRANCH1
   Tag: (none) 
   Parent: 1
   Log:
   bar
   
   Members: 
   	foo.txt:1.1->1.1.2.1 
   
   ---------------------
   PatchSet 3 
   Date: * (glob)
   Author: user
   Branch: MYBRANCH1
   Tag: (none) 
   Branchpoints: MYBRANCH1_2 
   Parent: 2
   Log:
   baz
   
   Members: 
   	foo.txt:1.1.2.1->1.1.2.2 
   
   ---------------------
   PatchSet 4 
   Date: * (glob)
   Author: user
   Branch: MYBRANCH1_1
   Tag: (none) 
   Parent: 1
   Log:
   quux
   
   Members: 
   	foo.txt:1.1->1.1.4.1 
   
   ---------------------
   PatchSet 5 
   Date: * (glob)
   Author: user
   Branch: MYBRANCH1_2
   Tag: (none) 
   Parent: 3
   Log:
   bazzie
   
   Members: 
   	foo.txt:1.1.2.2->1.1.2.2.2.1 
   
   ---------------------
   PatchSet 6 
   Date: * (glob)
   Author: user
   Branch: HEAD
   Tag: (none) 
   Parents: 1,5
   Log:
   merge
   
   Members: 
   	foo.txt:1.1->1.2 
   
   ---------------------
   PatchSet 7 
   Date: * (glob)
   Author: user
   Branch: MYBRANCH1_1
   Tag: (none) 
   Parents: 4,3
   Log:
   merge
   
   Members: 
   	foo.txt:1.1.4.1->1.1.4.2 
   
 #endif
 
   $ cd ..