tests: fix bashism to load helpers.sh

`source` isn't available at POSIX sh.

tests/test-bookmarks-rebase

@@ -1,34 +1,34 b''
 #!/bin/sh
 
-source $TESTDIR/helpers.sh
+. $TESTDIR/helpers.sh
 
 echo "[extensions]" >> $HGRCPATH
 echo "rebase=" >> $HGRCPATH
 echo "bookmarks=" >> $HGRCPATH
 
 echo % initialize repository
 hg init
 
 echo 'a' > a
 hg ci -A -m "0"
 
 echo 'b' > b
 hg ci -A -m "1"
 
 hg up 0
 echo 'c' > c
 hg ci -A -m "2"
 
 echo 'd' > d
 hg ci -A -m "3"
 
 hg bookmark -r 1 one
 hg bookmark -r 3 two
 
 echo % bookmark list
 hg bookmark
 
 echo % rebase
 hg rebase -s two -d one 2>&1 | cleanrebase
 
 hg log

tests/test-bookmarks-strip

@@ -1,45 +1,45 b''
 #!/bin/sh
 
-source $TESTDIR/helpers.sh
+. $TESTDIR/helpers.sh
 echo "[extensions]" >> $HGRCPATH
 echo "bookmarks=" >> $HGRCPATH
 echo "mq=" >> $HGRCPATH
 
 hg init
 
 echo qqq>qqq.txt
 
 echo % add file
 hg add
 
 echo % commit first revision
 hg ci -m 1 -u user -d "1 0"
 
 echo % set bookmark
 hg book test
 
 echo www>>qqq.txt
 
 echo % commit second revision
 hg ci -m 2 -u usr -d "1 0"
 
 echo % set bookmark
 hg book test2
 
 echo % update to -2
 hg update -r -2
 
 echo eee>>qqq.txt
 
 echo % commit new head
 hg ci -m 3 -u user -d "1 0"
 
 echo % bookmarks updated?
 hg book
 
 echo % strip to revision 1
 hg strip 1 | hidebackup
 
 echo % list bookmarks
 hg book
 

tests/test-mq

@@ -1,622 +1,622 b''
 #!/bin/sh
 
-source $TESTDIR/helpers.sh
+. $TESTDIR/helpers.sh
 
 checkundo()
 {
     if [ -f .hg/store/undo ]; then
 	echo ".hg/store/undo still exists after $1"
     fi
 }
 
 echo "[extensions]" >> $HGRCPATH
 echo "mq=" >> $HGRCPATH
 
 echo "[mq]" >> $HGRCPATH
 echo "plain=true" >> $HGRCPATH
 
 echo % help
 hg help mq
 
 hg init a
 cd a
 echo a > a
 hg ci -Ama
 
 hg clone . ../k
 
 mkdir b
 echo z > b/z
 hg ci -Ama
 
 echo % qinit
 
 hg qinit
 
 cd ..
 hg init b
 
 echo % -R qinit
 
 hg -R b qinit
 
 hg init c
 
 echo % qinit -c
 
 hg --cwd c qinit -c
 hg -R c/.hg/patches st
 
 echo '% qinit; qinit -c'
 hg init d
 cd d
 hg qinit
 hg qinit -c
 # qinit -c should create both files if they don't exist
 echo '  .hgignore:'
 cat .hg/patches/.hgignore
 echo '  series:'
 cat .hg/patches/series
 hg qinit -c 2>&1 | sed -e 's/repository.*already/repository already/'
 cd ..
 
 echo '% qinit; <stuff>; qinit -c'
 hg init e
 cd e
 hg qnew A
 checkundo qnew
 echo foo > foo
 hg add foo
 hg qrefresh
 hg qnew B
 echo >> foo
 hg qrefresh
 echo status >> .hg/patches/.hgignore
 echo bleh >> .hg/patches/.hgignore
 hg qinit -c
 hg -R .hg/patches status
 # qinit -c shouldn't touch these files if they already exist
 echo '  .hgignore:'
 cat .hg/patches/.hgignore
 echo '  series:'
 cat .hg/patches/series
 cd ..
 
 echo '% init --mq without repo'
 mkdir f
 cd f
 hg init --mq
 cd ..
 
 echo '% init --mq with repo path'
 hg init g
 hg init --mq g
 test -d g/.hg/patches/.hg && echo "ok" || echo "failed"
 
 echo '% init --mq with nonexistent directory'
 hg init --mq nonexistentdir
 
 echo '% init --mq with bundle (non "local")'
 hg -R a bundle --all a.bundle >/dev/null
 hg init --mq a.bundle
 
 cd a
 
 hg qnew -m 'foo bar' test.patch
 
 echo % qrefresh
 
 echo a >> a
 hg qrefresh
 sed -e "s/^\(diff -r \)\([a-f0-9]* \)/\1 x/" \
     -e "s/\(+++ [a-zA-Z0-9_/.-]*\).*/\1/" \
     -e "s/\(--- [a-zA-Z0-9_/.-]*\).*/\1/" .hg/patches/test.patch
 
 echo % empty qrefresh
 
 hg qrefresh -X a
 echo 'revision:'
 hg diff -r -2 -r -1
 echo 'patch:'
 cat .hg/patches/test.patch
 echo 'working dir diff:'
 hg diff --nodates -q
 # restore things
 hg qrefresh
 checkundo qrefresh
 
 echo % qpop
 
 hg qpop
 checkundo qpop
 
 echo % qpush with dump of tag cache
 
 # Dump the tag cache to ensure that it has exactly one head after qpush.
 rm -f .hg/tags.cache
 hg tags > /dev/null
 echo ".hg/tags.cache (pre qpush):"
 sed 's/ [0-9a-f]*//' .hg/tags.cache
 hg qpush
 hg tags > /dev/null
 echo ".hg/tags.cache (post qpush):"
 sed 's/ [0-9a-f]*//' .hg/tags.cache
 
 checkundo qpush
 
 cd ..
 
 echo % pop/push outside repo
 
 hg -R a qpop
 hg -R a qpush
 
 cd a
 hg qnew test2.patch
 
 echo % qrefresh in subdir
 
 cd b
 echo a > a
 hg add a
 hg qrefresh
 
 echo % pop/push -a in subdir
 
 hg qpop -a
 hg --traceback qpush -a
 
 # setting columns & interactive tests truncating (issue1912)
 echo % qseries
 COLUMNS=4 hg qseries --config ui.interactive=true
 COLUMNS=20 hg qseries --config ui.interactive=true -vs
 hg qpop
 hg qseries -vs
 hg sum | grep mq
 hg qpush
 hg sum | grep mq
 
 echo % qapplied
 hg qapplied
 
 echo % qtop
 hg qtop
 
 echo % prev
 hg qapp -1
 
 echo % next
 hg qunapp -1
 
 hg qpop
 echo % commit should fail
 hg commit
 
 echo % push should fail
 hg push ../../k
 
 echo % import should fail
 hg st .
 echo foo >> ../a
 hg diff > ../../import.diff
 hg revert --no-backup ../a
 hg import ../../import.diff
 hg st
 echo % import --no-commit should succeed
 hg import --no-commit ../../import.diff
 hg st
 hg revert --no-backup ../a
 
 echo % qunapplied
 hg qunapplied
 
 echo % qpush/qpop with index
 hg qnew test1b.patch
 echo 1b > 1b
 hg add 1b
 hg qrefresh
 hg qpush 2
 hg qpop 0
 hg qpush test.patch+1
 hg qpush test.patch+2
 hg qpop test2.patch-1
 hg qpop test2.patch-2
 hg qpush test1b.patch+1
 
 echo % qpush --move
 hg qpop -a
 hg qpush --move test2.patch # move to front
 hg qpush --move test1b.patch
 hg qpush --move test.patch # noop move
 hg qseries -v
 hg qpop -a
 hg qpush --move test.patch # cleaning up
 hg qpush --move test1b.patch
 hg qpush --move bogus # nonexistent patch
 hg qpush --move test.patch # already applied
 hg qpush
 
 echo % pop, qapplied, qunapplied
 hg qseries -v
 echo % qapplied -1 test.patch
 hg qapplied -1 test.patch
 echo % qapplied -1 test1b.patch
 hg qapplied -1 test1b.patch
 echo % qapplied -1 test2.patch
 hg qapplied -1 test2.patch
 echo % qapplied -1
 hg qapplied -1
 echo % qapplied
 hg qapplied
 echo % qapplied test1b.patch
 hg qapplied test1b.patch
 echo % qunapplied -1
 hg qunapplied -1
 echo % qunapplied
 hg qunapplied
 echo % popping
 hg qpop
 echo % qunapplied -1
 hg qunapplied -1
 echo % qunapplied
 hg qunapplied
 echo % qunapplied test2.patch
 hg qunapplied test2.patch
 echo % qunapplied -1 test2.patch
 hg qunapplied -1 test2.patch
 echo % popping -a
 hg qpop -a
 echo % qapplied
 hg qapplied
 echo % qapplied -1
 hg qapplied -1
 hg qpush
 
 echo % push should succeed
 hg qpop -a
 hg push ../../k
 
 echo % qpush/qpop error codes
 errorcode()
 {
     hg "$@" && echo "  $@ succeeds" || echo "  $@ fails"
 }
 
 # we want to start with some patches applied
 hg qpush -a
 echo "  % pops all patches and succeeds"
 errorcode qpop -a
 echo "  % does nothing and succeeds"
 errorcode qpop -a
 echo "  % fails - nothing else to pop"
 errorcode qpop
 echo "  % pushes a patch and succeeds"
 errorcode qpush
 echo "  % pops a patch and succeeds"
 errorcode qpop
 echo "  % pushes up to test1b.patch and succeeds"
 errorcode qpush test1b.patch
 echo "  % does nothing and succeeds"
 errorcode qpush test1b.patch
 echo "  % does nothing and succeeds"
 errorcode qpop test1b.patch
 echo "  % fails - can't push to this patch"
 errorcode qpush test.patch
 echo "  % fails - can't pop to this patch"
 errorcode qpop test2.patch
 echo "  % pops up to test.patch and succeeds"
 errorcode qpop test.patch
 echo "  % pushes all patches and succeeds"
 errorcode qpush -a
 echo "  % does nothing and succeeds"
 errorcode qpush -a
 echo "  % fails - nothing else to push"
 errorcode qpush
 echo "  % does nothing and succeeds"
 errorcode qpush test2.patch
 
 
 echo % strip
 cd ../../b
 echo x>x
 hg ci -Ama
 hg strip tip | hidebackup
 hg unbundle .hg/strip-backup/*
 
 echo % strip with local changes, should complain
 hg up
 echo y>y
 hg add y
 hg strip tip | hidebackup
 echo % --force strip with local changes
 hg strip -f tip | hidebackup
 
 echo '% cd b; hg qrefresh'
 hg init refresh
 cd refresh
 echo a > a
 hg ci -Ama
 hg qnew -mfoo foo
 echo a >> a
 hg qrefresh
 mkdir b
 cd b
 echo f > f
 hg add f
 hg qrefresh
 sed -e "s/\(+++ [a-zA-Z0-9_/.-]*\).*/\1/" \
     -e "s/\(--- [a-zA-Z0-9_/.-]*\).*/\1/" ../.hg/patches/foo
 echo % hg qrefresh .
 hg qrefresh .
 sed -e "s/\(+++ [a-zA-Z0-9_/.-]*\).*/\1/" \
     -e "s/\(--- [a-zA-Z0-9_/.-]*\).*/\1/" ../.hg/patches/foo
 hg status
 
 echo % qpush failure
 cd ..
 hg qrefresh
 hg qnew -mbar bar
 echo foo > foo
 echo bar > bar
 hg add foo bar
 hg qrefresh
 hg qpop -a
 echo bar > foo
 hg qpush -a
 hg st
 
 echo % mq tags
 hg log --template '{rev} {tags}\n' -r qparent:qtip
 
 echo % bad node in status
 hg qpop
 hg strip -qn tip
 hg tip 2>&1 | sed -e 's/unknown node .*/unknown node/'
 hg branches 2>&1 | sed -e 's/unknown node .*/unknown node/'
 hg qpop 2>&1 | sed -e 's/unknown node .*/unknown node/'
 
 cat >>$HGRCPATH <<EOF
 [diff]
 git = True
 EOF
 cd ..
 hg init git
 cd git
 hg qinit
 
 hg qnew -m'new file' new
 echo foo > new
 chmod +x new
 hg add new
 hg qrefresh
 sed -e "s/\(+++ [a-zA-Z0-9_/.-]*\).*/\1/" \
     -e "s/\(--- [a-zA-Z0-9_/.-]*\).*/\1/" .hg/patches/new
 
 hg qnew -m'copy file' copy
 hg cp new copy
 hg qrefresh
 sed -e "s/\(+++ [a-zA-Z0-9_/.-]*\).*/\1/" \
     -e "s/\(--- [a-zA-Z0-9_/.-]*\).*/\1/" .hg/patches/copy
 
 hg qpop
 hg qpush
 hg qdiff
 cat >>$HGRCPATH <<EOF
 [diff]
 git = False
 EOF
 hg qdiff --git
 cd ..
 
 echo % test file addition in slow path
 hg init slow
 cd slow
 hg qinit
 echo foo > foo
 hg add foo
 hg ci -m 'add foo'
 hg qnew bar
 echo bar > bar
 hg add bar
 hg mv foo baz
 hg qrefresh --git
 hg up -C 0
 echo >> foo
 hg ci -m 'change foo'
 hg up -C 1
 hg qrefresh --git 2>&1 | grep -v 'saving bundle'
 cat .hg/patches/bar
 hg log -v --template '{rev} {file_copies}\n' -r .
 hg qrefresh --git
 cat .hg/patches/bar
 hg log -v --template '{rev} {file_copies}\n' -r .
 hg qrefresh
 grep 'diff --git' .hg/patches/bar
 
 echo % test file move chains in the slow path
 hg up -C 1
 echo >> foo
 hg ci -m 'change foo again'
 hg up -C 2
 hg mv bar quux
 hg mv baz bleh
 hg qrefresh --git 2>&1 | grep -v 'saving bundle'
 cat .hg/patches/bar
 hg log -v --template '{rev} {file_copies}\n' -r .
 hg mv quux fred
 hg mv bleh barney
 hg qrefresh --git
 cat .hg/patches/bar
 hg log -v --template '{rev} {file_copies}\n' -r .
 
 echo % refresh omitting an added file
 hg qnew baz
 echo newfile > newfile
 hg add newfile
 hg qrefresh
 hg st -A newfile
 hg qrefresh -X newfile
 hg st -A newfile
 hg revert newfile
 rm newfile
 hg qpop
 hg qdel baz
 
 echo % create a git patch
 echo a > alexander
 hg add alexander
 hg qnew -f --git addalexander
 grep diff .hg/patches/addalexander
 
 echo % create a git binary patch
 cat > writebin.py <<EOF
 import sys
 path = sys.argv[1]
 open(path, 'wb').write('BIN\x00ARY')
 EOF
 python writebin.py bucephalus
 
 python "$TESTDIR/md5sum.py" bucephalus
 hg add bucephalus
 hg qnew -f --git addbucephalus
 grep diff .hg/patches/addbucephalus
 
 echo % check binary patches can be popped and pushed
 hg qpop
 test -f bucephalus && echo % bucephalus should not be there
 hg qpush
 test -f bucephalus || echo % bucephalus should be there
 python "$TESTDIR/md5sum.py" bucephalus
 
 
 echo '% strip again'
 cd ..
 hg init strip
 cd strip
 touch foo
 hg add foo
 hg ci -m 'add foo'
 echo >> foo
 hg ci -m 'change foo 1'
 hg up -C 0
 echo 1 >> foo
 hg ci -m 'change foo 2'
 HGMERGE=true hg merge
 hg ci -m merge
 hg log
 hg strip 1 | hidebackup
 checkundo strip
 hg log
 cd ..
 
 echo '% qclone'
 qlog()
 {
     echo 'main repo:'
     hg log --template '    rev {rev}: {desc}\n'
     echo 'patch repo:'
     hg -R .hg/patches log --template '    rev {rev}: {desc}\n'
 }
 hg init qclonesource
 cd qclonesource
 echo foo > foo
 hg add foo
 hg ci -m 'add foo'
 hg qinit
 hg qnew patch1
 echo bar >> foo
 hg qrefresh -m 'change foo'
 cd ..
 
 # repo with unversioned patch dir
 hg qclone qclonesource failure
 
 cd qclonesource
 hg qinit -c
 hg qci -m checkpoint
 qlog
 cd ..
 
 # repo with patches applied
 hg qclone qclonesource qclonedest
 cd qclonedest
 qlog
 cd ..
 
 # repo with patches unapplied
 cd qclonesource
 hg qpop -a
 qlog
 cd ..
 hg qclone qclonesource qclonedest2
 cd qclonedest2
 qlog
 cd ..
 
 echo % 'test applying on an empty file (issue 1033)'
 hg init empty
 cd empty
 touch a
 hg ci -Am addempty
 echo a > a
 hg qnew -f -e changea
 hg qpop
 hg qpush
 cd ..
 
 echo % test qpush with --force, issue1087
 hg init forcepush
 cd forcepush
 echo hello > hello.txt
 echo bye > bye.txt
 hg ci -Ama
 hg qnew -d '0 0' empty
 hg qpop
 echo world >> hello.txt
 
 echo % qpush should fail, local changes
 hg qpush
 
 echo % apply force, should not discard changes with empty patch
 hg qpush -f 2>&1 | sed 's,^.*/patch,patch,g'
 hg diff --config diff.nodates=True
 hg qdiff --config diff.nodates=True
 hg log -l1 -p
 hg qref -d '0 0'
 hg qpop
 echo universe >> hello.txt
 echo universe >> bye.txt
 
 echo % qpush should fail, local changes
 hg qpush
 
 echo % apply force, should discard changes in hello, but not bye
 hg qpush -f
 hg st
 hg diff --config diff.nodates=True
 hg qdiff --config diff.nodates=True
 
 echo % test popping revisions not in working dir ancestry
 hg qseries -v
 hg up qparent
 hg qpop
 
 cd ..
 hg init deletion-order
 cd deletion-order
 
 touch a
 hg ci -Aqm0
 
 hg qnew rename-dir
 hg rm a
 hg qrefresh
 
 mkdir a b
 touch a/a b/b
 hg add -q a b
 hg qrefresh
 
 echo % test popping must remove files added in subdirectories first
 hg qpop
 cd ..

tests/test-mq-strip

@@ -1,55 +1,55 b''
 #!/bin/sh
 
-source $TESTDIR/helpers.sh
+. $TESTDIR/helpers.sh
 
 echo "[extensions]" >> $HGRCPATH
 echo "mq=" >> $HGRCPATH
 
 teststrip() {
     hg up -C $1
     echo % before update $1, strip $2
     hg parents
     hg strip $2 | hidebackup
     echo % after update $1, strip $2
     hg parents
     hg unbundle -q .hg/strip-backup/*
     rm .hg/strip-backup/*
 }
 
 hg init test
 cd test
 
 echo foo > bar
 hg ci -Ama
 
 echo more >> bar
 hg ci -Amb
 
 echo blah >> bar
 hg ci -Amc
 
 hg up 1
 echo blah >> bar
 hg ci -Amd
 
 echo final >> bar
 hg ci -Ame
 
 hg log
 
 teststrip 4 4
 teststrip 4 3
 teststrip 1 4
 teststrip 4 2
 teststrip 4 1
 teststrip null 4
 
 hg log
 
 hg up -C 2
 hg merge 4
 echo % before strip of merge parent
 hg parents
 hg strip 4 2>&1 | hidebackup
 echo % after strip of merge parent
 hg parents

tests/test-rebase-abort

@@ -1,40 +1,40 b''
 #!/bin/sh
 
-source $TESTDIR/helpers.sh
+. $TESTDIR/helpers.sh
 
 echo "[extensions]" >> $HGRCPATH
 echo "graphlog=" >> $HGRCPATH
 echo "rebase=" >> $HGRCPATH
 
 hg init a
 cd a
 echo 'c1' >common
 hg add common
 hg commit -d '0 0' -m "C1"
 
 echo 'c2' >>common
 hg commit -d '1 0' -m "C2"
 
 echo 'c3' >>common
 hg commit -d '2 0' -m "C3"
 
 hg update -C 1
 echo 'l1' >>extra
 hg add extra
 hg commit -d '3 0' -m "L1"
 
 sed -e 's/c2/l2/' common > common.new
 mv common.new common
 hg commit -d '4 0' -m "L2"
 
 hg glog  --template '{rev}: {desc}\n'
 
 echo
 echo '% Conflicting rebase'
 hg rebase -s 3 -d 2 | cleanrebase
 
 echo
 echo '% Abort'
 hg rebase --abort | cleanrebase
 
 hg glog  --template '{rev}: {desc}\n'

tests/test-rebase-cache

@@ -1,106 +1,106 b''
 #!/bin/sh
 
-source $TESTDIR/helpers.sh
+. $TESTDIR/helpers.sh
 
 createrepo() {
     rm -rf repo
     hg init repo
     cd repo
 
     echo "a" > a
     hg commit -d '0 0' -A -m 'A'
 
     hg branch branch1
     hg commit -d '1 0' -m 'Branch1'
 
     echo "b" > b
     hg commit -A -d '2 0' -m 'B'
 
     hg up 0
     hg branch branch2
     hg commit -d '3 0' -m 'Branch2'
 
     echo "c" > C
     hg commit -A -d '4 0' -m 'C'
 
     hg up 2
     hg branch -f branch2
     echo "d" > d
     hg commit -A -d '5 0' -m 'D'
 
     echo "e" > e
     hg commit -A -d '6 0' -m 'E'
 
     hg update default
 
     hg branch branch3
     hg commit -d '7 0' -m 'Branch3'
 
     echo "f" > f
     hg commit -A -d '8 0' -m 'F'
 }
 
 echo
 createrepo > /dev/null 2>&1
 hg --config extensions.hgext.graphlog= glog --template '{rev}:{node|short} {desc} branch: {branches}\n'
 
 echo
 echo '% Branches'
 hg branches
 
 echo
 echo '% Heads'
 hg heads --template '{rev}:{node|short} {desc} branch: {branches}\n'
 
 echo
 echo '% Rebase part of branch2 (5-6) onto branch3 (8)'
 hg --config extensions.hgext.rebase= rebase --detach -s 5 -d 8 | hidebackup
 
 echo
 echo '% Branches'
 hg branches
 
 echo
 echo '% Heads'
 hg heads --template '{rev}:{node|short} {desc} branch: {branches}\n'
 
 echo
 hg --config extensions.hgext.graphlog= glog --template '{rev}:{node|short} {desc} branch: {branches}\n'
 
 echo
 echo '% Rebase head of branch3 (8) onto branch2 (6)'
 createrepo > /dev/null 2>&1
 hg --config extensions.hgext.graphlog= glog --template '{rev}:{node|short} {desc} branch: {branches}\n'
 
 hg --config extensions.hgext.rebase= rebase --detach -s 8 -d 6 | hidebackup
 
 echo
 echo '% Branches'
 hg branches
 
 echo
 echo '% Heads'
 hg heads --template '{rev}:{node|short} {desc} branch: {branches}\n'
 
 echo
 hg --config extensions.hgext.graphlog= glog --template '{rev}:{node|short} {desc} branch: {branches}\n'
 hg verify -q
 
 echo
 echo '% Rebase entire branch3 (7-8) onto branch2 (6)'
 createrepo > /dev/null 2>&1
 hg --config extensions.hgext.graphlog= glog --template '{rev}:{node|short} {desc} branch: {branches}\n'
 
 hg --config extensions.hgext.rebase= rebase --detach -s 7 -d 6 | hidebackup
 
 echo
 echo '% Branches'
 hg branches
 
 echo
 echo '% Heads'
 hg heads --template '{rev}:{node|short} {desc} branch: {branches}\n'
 
 echo
 hg --config extensions.hgext.graphlog= glog --template '{rev}:{node|short} {desc} branch: {branches}\n'
 hg verify -q

tests/test-rebase-check-restore

@@ -1,70 +1,70 b''
 #!/bin/sh
 
-source $TESTDIR/helpers.sh
+. $TESTDIR/helpers.sh
 
 echo "[extensions]" >> $HGRCPATH
 echo "graphlog=" >> $HGRCPATH
 echo "rebase=" >> $HGRCPATH
 
 BASE=`pwd`
 
 addcommit () {
     echo $1 > $1
     hg add $1
     hg commit -d "${2} 0" -m $1
 }
 
 commit () {
     hg commit -d "${2} 0" -m $1
 }
 
 createrepo () {
     cd $BASE
     rm -rf a
     hg init a
     cd a
     addcommit "A" 0
     addcommit "B" 1
     echo "C" >> A
     commit "C" 2
 
     hg update -C 0
     echo "D" >> A
     commit "D" 3
     addcommit "E" 4
 
     hg update -C 0
     hg branch 'notdefault'
     echo "F" >> A
     commit "F" 5
 }
 
 echo
 echo "% - Rebasing B onto E - check keep"
 createrepo > /dev/null 2>&1
 hg glog  --template '{rev}:{desc}:{branches}\n'
 hg rebase -s 1 -d 4 --keep | hidebackup
 
 echo
 echo "% - Solve the conflict and go on"
 echo 'conflict solved' > A
 rm A.orig
 hg resolve -m A
 hg rebase --continue | hidebackup
 hg glog  --template '{rev}:{desc}:{branches}\n'
 
 echo
 echo "% - Rebase F onto E - check keepbranches"
 createrepo > /dev/null 2>&1
 hg glog  --template '{rev}:{desc}:{branches}\n'
 hg rebase -s 5 -d 4 --keepbranches | hidebackup
 
 echo
 echo "% - Solve the conflict and go on"
 echo 'conflict solved' > A
 rm A.orig
 hg resolve -m A
 hg rebase --continue 2>&1 | hidebackup
 hg glog  --template '{rev}:{desc}:{branches}\n'
 
 exit 0

tests/test-rebase-collapse

@@ -1,177 +1,177 b''
 #!/bin/sh
 
-source $TESTDIR/helpers.sh
+. $TESTDIR/helpers.sh
 
 echo "[extensions]" >> $HGRCPATH
 echo "graphlog=" >> $HGRCPATH
 echo "rebase=" >> $HGRCPATH
 
 BASE=`pwd`
 
 addcommit () {
     echo $1 > $1
     hg add $1
     hg commit -d "${2} 0" -m $1
 }
 
 commit () {
     hg commit -d "${2} 0" -m $1
 }
 
 createrepo () {
     cd $BASE
     rm -rf a
     hg init a
     cd a
     addcommit "A" 0
     addcommit "B" 1
     addcommit "C" 2
     addcommit "D" 3
 
     hg update -C 0
     addcommit "E" 4
 
     hg update -C 0
     addcommit "F" 5
 
     hg merge -r 4
     commit "G" 6
 
     hg update -C 5
     addcommit "H" 7
 }
 
 createrepo > /dev/null 2>&1
 hg glog  --template '{rev}: {desc}\n'
 echo '% Rebasing B onto H'
 hg up -C 3
 hg rebase --collapse --keepbranches | hidebackup
 hg glog  --template '{rev}: {desc}\n'
 echo "Expected A, B, C, D, F, H"
 hg manifest
 
 createrepo > /dev/null 2>&1
 echo
 echo '% Rebasing G onto H'
 hg rebase --base 6 --collapse | hidebackup
 hg glog  --template '{rev}: {desc}\n'
 echo "Expected A, E, F, H"
 hg manifest
 
 createrepocomplex () {
     cd $BASE
     rm -rf a
     hg init a
     cd a
     addcommit "A" 0
     addcommit "B" 1
 
     hg up 0
     addcommit "C" 2
     hg merge
     commit "D" 3
 
     hg up 1
     addcommit "E" 4
 
     addcommit "F" 5
 
     hg merge
     commit "G" 6
 
     hg up 0
     addcommit "H" 7
 }
 
 echo
 createrepocomplex > /dev/null 2>&1
 hg glog  --template '{rev}: {desc}\n'
 
 echo
 echo '% Rebase and collapse - more than one external (fail)'
 hg rebase -s 2 --collapse
 
 echo
 echo '% Rebase and collapse - E onto H'
 hg rebase -s 4 --collapse | hidebackup
 hg glog  --template '{rev}: {desc}\n'
 echo "Expected A, B, C, E, F, H"
 hg manifest
 
 createrepocomplex () {
     cd $BASE
     rm -rf a
     hg init a
     cd a
     addcommit "A" 0
     addcommit "B" 1
 
     hg up 0
     addcommit "C" 2
     hg merge
     commit "D" 3
 
     hg up 1
     addcommit "E" 4
     
     echo "F" > E
     commit "F" 5
 
     addcommit "G" 6
 
     hg merge
     commit "H" 7
 
     hg up 0
     addcommit "I" 8
 }
 
 echo
 createrepocomplex > /dev/null 2>&1
 hg glog  --template '{rev}: {desc}\n'
 
 echo
 echo '% Rebase and collapse - E onto I'
 hg rebase -s 4 --collapse | hidebackup
 
 hg glog  --template '{rev}: {desc}\n'
 
 echo "Expected A, B, C, E, G, I"
 hg manifest
 
 echo 'Cat E:'
 cat E
 
 createrepocomplex () {
     cd $BASE
     rm -rf a
     hg init a
     cd a
     addcommit "A" 0
     addcommit "B" 1
 
     addcommit "C" 2
     hg up 1
 
     addcommit "D" 3
     
     hg merge
     commit "E" 4
 
     hg up 0
     addcommit "F" 5
 }
 
 echo
 createrepocomplex > /dev/null 2>&1
 hg glog  --template '{rev}: {desc}\n'
 
 echo
 echo '% Rebase and collapse - B onto F'
 hg rebase -s 1 --collapse | hidebackup
 
 hg glog  --template '{rev}: {desc}\n'
 
 echo "Expected A, B, C, D, F"
 hg manifest
 exit 0

tests/test-rebase-conflicts

@@ -1,74 +1,74 b''
 #!/bin/sh
 
-source $TESTDIR/helpers.sh
+. $TESTDIR/helpers.sh
 
 echo "[extensions]" >> $HGRCPATH
 echo "graphlog=" >> $HGRCPATH
 echo "rebase=" >> $HGRCPATH
 
 hg init a
 cd a
 echo 'c1' >common
 hg add common
 hg commit -d '0 0' -m "C1"
 
 echo 'c2' >>common
 hg commit -d '1 0' -m "C2"
 
 echo 'c3' >>common
 hg commit -d '2 0' -m "C3"
 
 hg update -C 1
 echo 'l1' >>extra
 hg add extra
 hg commit -d '3 0' -m "L1"
 
 sed -e 's/c2/l2/' common > common.new
 mv common.new common
 hg commit -d '4 0' -m "L2"
 
 echo 'l3' >> extra2
 hg add extra2
 hg commit -d '5 0' -m "L3"
 
 hg glog  --template '{rev}: {desc}\n'
 
 echo
 echo '% Try to call --continue'
 hg rebase --continue
 
 echo
 echo '% Conflicting rebase'
 hg rebase -s 3 -d 2
 
 echo
 echo '% Try to continue without solving the conflict'
 hg rebase --continue 
 
 echo
 echo '% Conclude rebase'
 echo 'resolved merge' >common
 hg resolve -m common
 hg rebase --continue | cleanrebase
 
 hg glog  --template '{rev}: {desc}\n'
 
 echo
 echo '% Check correctness'
 echo '  - Rev. 0'
 hg cat -r 0 common
 
 echo '  - Rev. 1'
 hg cat -r 1 common
 
 echo '  - Rev. 2'
 hg cat -r 2 common
 
 echo '  - Rev. 3'
 hg cat -r 3 common
 
 echo '  - Rev. 4'
 hg cat -r 4 common
 
 echo '  - Rev. 5'
 hg cat -r 5 common

tests/test-rebase-detach

@@ -1,70 +1,70 b''
 #!/bin/sh
 
-source $TESTDIR/helpers.sh
+. $TESTDIR/helpers.sh
 
 echo "[extensions]" >> $HGRCPATH
 echo "graphlog=" >> $HGRCPATH
 echo "rebase=" >> $HGRCPATH
 
 BASE=`pwd`
 
 addcommit () {
     echo $1 > $1
     hg add $1
     hg commit -d "${2} 0" -m $1
 }
 
 commit () {
     hg commit -d "${2} 0" -m $1
 }
 
 createrepo () {
     cd $BASE
     rm -rf a
     hg init a
     cd a
     addcommit "A" 0
     addcommit "B" 1
     addcommit "C" 2
     addcommit "D" 3
 
     hg update -C 0
     addcommit "E" 4
 }
 
 createrepo > /dev/null 2>&1
 hg glog  --template '{rev}: {desc}\n'
 echo '% Rebasing D onto E detaching from C'
 hg rebase --detach -s 3 -d 4 | hidebackup
 hg glog  --template '{rev}: {desc}\n'
 echo "Expected A, D, E"
 hg manifest
 
 echo
 createrepo > /dev/null 2>&1
 hg glog  --template '{rev}: {desc}\n'
 echo '% Rebasing C onto E detaching from B'
 hg rebase --detach -s 2 -d 4 | hidebackup
 hg glog  --template '{rev}: {desc}\n'
 echo "Expected A, C, D, E"
 hg manifest
 
 echo
 createrepo > /dev/null 2>&1
 hg glog  --template '{rev}: {desc}\n'
 echo '% Rebasing B onto E using detach (same as not using it)'
 hg rebase --detach -s 1 -d 4 | hidebackup
 hg glog  --template '{rev}: {desc}\n'
 echo "Expected A, B, C, D, E"
 hg manifest
 
 echo
 createrepo > /dev/null 2>&1
 hg glog  --template '{rev}: {desc}\n'
 echo '% Rebasing C onto E detaching from B and collapsing'
 hg rebase --detach --collapse -s 2 -d 4 | hidebackup
 hg glog  --template '{rev}: {desc}\n'
 echo "Expected A, C, D, E"
 hg manifest
 
 exit 0

tests/test-rebase-interruptions

@@ -1,83 +1,83 b''
 #!/bin/sh
 
-source $TESTDIR/helpers.sh
+. $TESTDIR/helpers.sh
 echo "[extensions]" >> $HGRCPATH
 echo "graphlog=" >> $HGRCPATH
 echo "rebase=" >> $HGRCPATH
 
 BASE=`pwd`
 
 addcommit () {
     echo $1 > $1
     hg add $1
     hg commit -d "${2} 0" -m $1
 }
 
 commit () {
     hg commit -d "${2} 0" -m $1
 }
 
 createrepo () {
     cd $BASE
     rm -rf a
     hg init a
     cd a
     addcommit "A" 0
     addcommit "B" 1
     echo "C" >> A
     commit "C" 2
 
     hg update -C 0
     echo "D" >> A
     commit "D" 3
     addcommit "E" 4
 }
 
 echo "% Changes during an interruption - continue"
 createrepo > /dev/null 2>&1
 hg glog  --template '{rev}: {desc}\n'
 
 echo
 echo "% - Rebasing B onto E"
 hg rebase -s 1 -d 4 | hidebackup
 
 echo
 echo "% - Force a commit on C during the interruption"
 hg update -C 2
 addcommit "Extra" 5
 hg glog  --template '{rev}: {desc}\n'
 
 echo
 echo "% - Resume the rebasing"
 hg rebase --continue
 
 echo
 echo "% - Solve the conflict and go on"
 echo 'conflict solved' > A
 rm A.orig
 hg resolve -m A
 hg rebase --continue
 hg glog  --template '{rev}: {desc}\n'
 
 echo
 echo
 echo "% Changes during an interruption - abort"
 createrepo > /dev/null 2>&1
 hg glog  --template '{rev}: {desc}\n'
 
 echo
 echo "% Rebasing B onto E"
 hg rebase -s 1 -d 4 | hidebackup
 
 echo
 echo "% Force a commit on B' during the interruption"
 hg update -C 5
 addcommit "Extra" 6
 hg glog  --template '{rev}: {desc}\n'
 
 echo
 echo "% Abort the rebasing"
 hg rebase --abort
 hg glog  --template '{rev}: {desc}\n'
 
 exit 0

tests/test-rebase-issue-noparam-single-rev

@@ -1,51 +1,51 b''
 #!/bin/sh
 
-source $TESTDIR/helpers.sh
+. $TESTDIR/helpers.sh
 
 echo "[extensions]" >> $HGRCPATH
 echo "graphlog=" >> $HGRCPATH
 echo "rebase=" >> $HGRCPATH
 
 addcommit () {
     echo $1 > $1
     hg add $1
     hg commit -d "${2} 0" -m $1
 }
 
 hg init a
 cd a
 addcommit "c1" 0
 addcommit "c2" 1
 
 addcommit "l1" 2
 
 hg update -C 1
 addcommit "r1" 3
 addcommit "r2" 4
 hg glog --template '{rev}:{desc}\n'
 
 echo
 echo '% Rebase with no arguments - single revision in source branch'
 hg update -C 2
 hg rebase | hidebackup
 hg glog --template '{rev}:{desc}\n'
 
 cd ..
 rm -rf a
 hg init a
 cd a
 addcommit "c1" 0
 addcommit "c2" 1
 
 addcommit "l1" 2
 addcommit "l2" 3
 
 hg update -C 1
 addcommit "r1" 4
 hg glog --template '{rev}:{desc}\n'
 
 echo
 echo '% Rebase with no arguments - single revision in target branch'
 hg update -C 3
 hg rebase 2>&1 | hidebackup
 hg glog --template '{rev}:{desc}\n'

tests/test-rebase-mq

@@ -1,123 +1,123 b''
 #!/bin/sh
 
-source $TESTDIR/helpers.sh
+. $TESTDIR/helpers.sh
 
 echo "[extensions]" >> $HGRCPATH
 echo "graphlog=" >> $HGRCPATH
 echo "rebase=" >> $HGRCPATH
 echo "mq=" >> $HGRCPATH
 
 echo "[mq]" >> $HGRCPATH
 echo "plain=true" >> $HGRCPATH
 
 filterpatch()
 {
     sed -e "s/^\(# Date\).*/\1/" \
         -e "s/^\(# Node ID\).*/\1/" \
         -e "s/^\(# Parent\).*/\1/" \
         -e "s/^\(diff -r \)\([a-f0-9]* \)\(-r \)\([a-f0-9]* \)/\1x \3y /" \
         -e "s/^\(diff -r \)\([a-f0-9]* \)/\1x /" \
         -e "s/\(--- [a-zA-Z0-9_/.-]*\).*/\1/" \
         -e "s/\(+++ [a-zA-Z0-9_/.-]*\).*/\1/"
 }
 
 hg init a
 cd a
 hg qinit -c # This must work even with a managed mq queue
 
 echo 'c1' > f
 hg add f
 hg commit -d '0 0' -m "C1"
 
 echo 'r1' > f
 hg commit -d '2 0' -m "R1"
 
 hg up 0
 hg qnew f.patch
 echo 'mq1' > f
 hg qref -m 'P0'
 
 hg qnew f2.patch
 echo 'mq2' > f
 hg qref -m 'P1'
 hg glog  --template '{rev} {desc} tags: {tags}\n'
 
 echo
 echo '% Rebase - try to rebase on an applied mq patch'
 hg rebase -s 1 -d 3
 
 echo
 echo '% Rebase - same thing, but mq patch is default dest'
 hg update -q 1
 hg rebase
 hg update -q qtip
 
 echo
 echo '% Rebase - generate a conflict'
 hg rebase -s 2 -d 1
 
 echo
 echo '% Fix the 1st conflict'
 echo 'mq1r1' > f
 hg resolve -m f
 hg rebase -c | hidebackup
 
 echo
 echo '% Fix the 2nd conflict'
 echo 'mq1r1mq2' > f
 hg resolve -m f
 hg rebase -c | hidebackup
 
 hg glog  --template '{rev} {desc} tags: {tags}\n'
 
 echo
 echo '% Update to qbase'
 hg up qbase
 echo '% f correctly reflects the merge result'
 cat f
 echo '% And the patch is correct'
 cat .hg/patches/f.patch | filterpatch
 
 echo
 echo '% Update to qtip'
 hg up qtip
 echo '% f correctly reflects the merge result'
 cat f
 echo '% And the patch is correct'
 cat .hg/patches/f2.patch | filterpatch
 
 echo
 echo '% Adding one git-style patch and one normal'
 hg qpop -a
 rm -fr .hg/patches
 hg qinit -c
 
 hg up 0
 hg qnew --git f_git.patch
 echo 'mq1' > p
 hg add p
 hg qref --git -m 'P0 (git)'
 
 hg qnew f.patch
 echo 'mq2' > p
 hg qref -m 'P1'
 
 echo '% Git patch'
 cat .hg/patches/f_git.patch  | filterpatch
 
 echo
 echo '% Normal patch'
 cat .hg/patches/f.patch | filterpatch
 
 echo
 echo '% Rebase the applied mq patches'
 hg rebase -s 2 -d 1 --quiet
 
 echo '% And the patches are correct'
 echo '% Git patch'
 cat .hg/patches/f_git.patch  | filterpatch
 
 echo
 echo '% Normal patch'
 cat .hg/patches/f.patch | filterpatch
 

tests/test-rebase-mq-skip

@@ -1,46 +1,46 b''
 #!/bin/sh
 # This emulates the effects of an hg pull --rebase in which the remote repo 
 # already has one local mq patch
 
-source $TESTDIR/helpers.sh
+. $TESTDIR/helpers.sh
 
 echo "[extensions]" >> $HGRCPATH
 echo "graphlog=" >> $HGRCPATH
 echo "rebase=" >> $HGRCPATH
 echo "mq=" >> $HGRCPATH
 
 hg init a
 cd a
 hg qinit -c # This must work even with a managed mq queue
 
 echo 'c1' > c1
 hg add c1
 hg commit -d '0 0' -m "C1"
 
 echo 'r1' > r1
 hg add r1
 hg commit -d '1 0' -m "R1"
 
 hg up 0
 hg qnew p0.patch
 echo 'p0' > p0
 hg add p0
 hg qref -m 'P0'
 
 hg qnew p1.patch
 echo 'p1' > p1
 hg add p1
 hg qref -m 'P1'
 hg export qtip > p1.patch 
 
 echo
 echo '% "Mainstream" import p1.patch'
 hg up -C 1
 hg import p1.patch
 rm p1.patch
 
 echo
 echo '% Rebase'
 hg up -C qtip
 hg rebase | hidebackup
 hg glog  --template '{rev} {desc} tags: {tags}\n'

tests/test-rebase-newancestor

@@ -1,33 +1,33 b''
 #!/bin/sh
 
-source $TESTDIR/helpers.sh
+. $TESTDIR/helpers.sh
 
 echo "[extensions]" >> $HGRCPATH
 echo "graphlog=" >> $HGRCPATH
 echo "rebase=" >> $HGRCPATH
 
 rm -rf repo
 hg init repo
 cd repo
 
 echo A > a
 echo >> a
 hg commit -AmA -u test -d '0 0'
 
 echo B > a
 echo >> a
 hg commit -mB -u test -d '1 0'
 
 echo C > a
 echo >> a
 hg commit -mC -u test -d '2 0'
 
 hg up -C 0
 echo D >> a
 hg commit -AmAD -u test -d '3 0'
 
 hg glog --template '{rev}:{desc} {node|short}\n'
 hg rebase -q -s 1 -d 3 | hidebackup
 hg glog --template '{rev}:{desc} {node|short}\n'
 
 exit 0

tests/test-rebase-parameters

@@ -1,110 +1,110 b''
 #!/bin/sh
 
-source $TESTDIR/helpers.sh
+. $TESTDIR/helpers.sh
 
 echo "[extensions]" >> $HGRCPATH
 echo "rebase=" >> $HGRCPATH
 
 addcommit () {
     echo $1 > $1
     hg add $1
     hg commit -d "${2} 0" -m $1
 }
 
 commit () {
     hg commit -d "${2} 0" -m $1
 }
 
 createrepo () {
     hg init a
     cd a
     addcommit "c1" 0
     addcommit "c2" 1
     addcommit "c3" 2
 
     hg update -C 1
     addcommit "l1" 3
     addcommit "l2" 4
     addcommit "l3" 5
 
     hg update -C 2
     addcommit "r1" 6
     addcommit "r2" 7
 }
 
 createrepo > /dev/null 2>&1
 echo "% These fail"
 echo
 echo "% Use continue and abort"
 hg rebase --continue --abort
 
 echo
 echo "% Use continue and collapse"
 hg rebase --continue --collapse
 
 echo
 echo "% Use continue/abort and dest/source"
 hg rebase --continue --dest 4
 
 echo
 echo "% Use source and base"
 hg rebase --base 5 --source 4
 
 echo
 echo "% Rebase with no arguments - from current"
 hg rebase
 
 echo
 echo "% Rebase with no arguments - from the current branch"
 hg update 6
 hg rebase
 
 echo "% ----------"
 echo "% These work"
 echo
 echo "% Rebase with no arguments (from 3 onto 7)"
 hg update -C 5
 hg rebase 2>&1 | hidebackup
 
 echo "% Try to rollback after a rebase (fail)"
 hg rollback
 
 createrepo > /dev/null 2>&1
 echo
 echo "% Rebase with base == '.' => same as no arguments (from 3 onto 7)"
 hg update -C 5
 hg rebase --base . | hidebackup
 
 createrepo > /dev/null 2>&1
 echo
 echo "% Rebase with dest == `hg branch` => same as no arguments (from 3 onto 7)"
 hg update -C 5
 hg rebase --dest `hg branch` | hidebackup
 
 createrepo > /dev/null 2>&1
 echo
 echo "% Specify only source (from 4 onto 7)"
 hg rebase --source 4 | hidebackup
 
 createrepo > /dev/null 2>&1
 echo
 echo "% Specify only dest (from 3 onto 6)"
 hg update -C 5
 hg rebase --dest 6 | hidebackup
 
 createrepo > /dev/null 2>&1
 echo
 echo "% Specify only base (from 3 onto 7)"
 hg rebase --base 5 | hidebackup
 
 createrepo > /dev/null 2>&1
 echo
 echo "% Specify source and dest (from 4 onto 6)"
 hg rebase --source 4 --dest 6 | hidebackup
 
 createrepo > /dev/null 2>&1
 echo
 echo "% Specify base and dest (from 3 onto 6)"
 hg rebase --base 4 --dest 6 | hidebackup
 
 exit 0

tests/test-rebase-pull

@@ -1,63 +1,63 b''
 #!/bin/sh
 
-source $TESTDIR/helpers.sh
+. $TESTDIR/helpers.sh
 
 echo "[extensions]" >> $HGRCPATH
 echo "graphlog=" >> $HGRCPATH
 echo "rebase=" >> $HGRCPATH
 
 addcommit () {
     echo $1 > $1
     hg add $1
     hg commit -d "${2} 0" -m $1
 }
 
 commit () {
     hg commit -d "${2} 0" -m $1
 }
 
 rm -rf a
 hg init a
 cd a
 addcommit "C1" 0
 addcommit "C2" 1
 
 cd ..
 hg clone a b
 # This is needed to test pull --rebase
 hg clone a c
 
 cd b
 addcommit "L1" 2
 
 cd ../a
 addcommit "R1" 3
 
 cd ../b
 echo
 echo "% Now b has one revision to be pulled from a"
 hg pull --rebase | hidebackup | sed -e 's/\(pulling from \).*/\1/'
 
 hg glog --template '{rev}:{desc}\n'
 
 echo
 echo "% Re-run pull --rebase"
 hg pull --rebase | sed 's/\(pulling from \).*/\1/'
 
 echo
 echo "% Invoke pull --rebase and nothing to rebase"
 cd ../c
 hg pull --rebase 2>&1 | sed 's/\(pulling from \).*/\1/'
 hg glog --template '{rev}\n' -l 1
 
 echo
 echo "% pull --rebase --update should ignore --update"
 hg pull --rebase --update 2>&1 | sed 's/\(pulling from \).*/\1/'
 
 echo
 echo "% pull --rebase doesn't update if nothing has been pulled"
 hg up 1
 hg pull --rebase 2>&1 | sed 's/\(pulling from \).*/\1/'
 hg glog --template '{rev}\n' -l 1
 
 exit 0

tests/test-rebase-rename

@@ -1,55 +1,55 b''
 #!/bin/sh
 
-source $TESTDIR/helpers.sh
+. $TESTDIR/helpers.sh
 
 echo "[extensions]" >> $HGRCPATH
 echo "rebase=" >> $HGRCPATH
 echo "[diff]" >> $HGRCPATH
 echo "git=1" >> $HGRCPATH
 
 BASE=`pwd`
 
 hg init repo1
 cd repo1
 echo "a">a
 hg commit -Am "A" --date '0 0'
 echo "b"> b
 hg commit -Am "B" --date '1 0'
 hg up -C 0
 hg mv a a-renamed
 hg commit -m 'rename A' --date '2 0'
 
 echo
 echo '% Rename is tracked'
 hg log -p -r tip --template '{rev}:{desc}\n'
 
 echo '% Rebase the revision containing the rename'
 hg rebase -s 2 -d 1 --quiet | cleanrebase
 
 echo
 echo '% Rename is not lost'
 hg log -p -r tip --template '{rev}:{desc}\n'
 
 cd $BASE
 rm -rf repo1
 hg init repo1
 cd repo1
 echo "a">a
 hg commit -Am "A" --date '0 0'
 echo "b"> b
 hg commit -Am "B" --date '1 0'
 hg up -C 0
 hg cp a a-copied
 hg commit -m 'copy A' --date '2 0'
 
 echo
 echo '% Copy is tracked'
 hg log -p -r tip --template '{rev}:{desc}\n'
 
 echo '% Rebase the revision containing the copy'
 hg rebase -s 2 -d 1 --quiet | cleanrebase
 
 echo
 echo '% Copy is not lost'
 hg log -p -r tip --template '{rev}:{desc}\n'
 

tests/test-rebase-scenario-global

@@ -1,93 +1,93 b''
 #!/bin/sh
 
-source $TESTDIR/helpers.sh
+. $TESTDIR/helpers.sh
 
 echo "[extensions]" >> $HGRCPATH
 echo "graphlog=" >> $HGRCPATH
 echo "rebase=" >> $HGRCPATH
 
 BASE=`pwd`
 
 addcommit () {
     echo $1 > $1
     hg add $1
     hg commit -d "${2} 0" -m $1
 }
 
 commit () {
     hg commit -d "${2} 0" -m $1
 }
 
 createrepo () {
     cd $BASE
     rm -rf a
     hg init a
     cd a
     addcommit "A" 0
     addcommit "B" 1
 
     hg update -C 0
     addcommit "C" 2
 
     hg update -C 0
     addcommit "D" 3
 
     hg merge -r 2
     commit "E" 4
 
     hg update -C 3
     addcommit "F" 5
 }
 
 createrepo > /dev/null 2>&1
 hg glog  --template '{rev}: {desc}\n'
 
 echo '% Rebasing'
 echo '% B onto F - simple rebase'
 hg rebase -s 1 -d 5 | hidebackup
 hg glog  --template '{rev}: {desc}\n'
 
 createrepo > /dev/null 2>&1
 echo '% B onto D - intermediate point'
 hg rebase -s 1 -d 3 | hidebackup
 hg glog  --template '{rev}: {desc}\n'
 
 createrepo > /dev/null 2>&1
 echo '% C onto F - skip of E'
 hg rebase -s 2 -d 5 | hidebackup
 hg glog  --template '{rev}: {desc}\n'
 
 createrepo > /dev/null 2>&1
 echo '% D onto C - rebase of a branching point (skip E)'
 hg rebase -s 3 -d 2 | hidebackup
 hg glog  --template '{rev}: {desc}\n'
 
 createrepo > /dev/null 2>&1
 echo '% E onto F - merged revision having a parent in ancestors of target'
 hg rebase -s 4 -d 5 | hidebackup
 hg glog  --template '{rev}: {desc}\n'
 
 createrepo > /dev/null 2>&1
 echo '% D onto B - E maintains C as parent'
 hg rebase -s 3 -d 1 | hidebackup
 hg glog  --template '{rev}: {desc}\n'
 
 echo '% These will fail (using --source)'
 createrepo > /dev/null 2>&1
 echo '% E onto D - rebase onto an ancestor'
 hg rebase -s 4 -d 3
 echo '% D onto E - rebase onto a descendant'
 hg rebase -s 3 -d 4
 echo '% E onto B - merge revision with both parents not in ancestors of target'
 hg rebase -s 4 -d 1
 
 echo
 echo '% These will abort gracefully (using --base)'
 echo '% E onto E - rebase onto same changeset'
 hg rebase -b 4 -d 4
 echo '% E onto D - rebase onto an ancestor'
 hg rebase -b 4 -d 3
 echo '% D onto E - rebase onto a descendant'
 hg rebase -b 3 -d 4
 
 exit 0

tests/test-strip-cross

@@ -1,64 +1,64 b''
 #!/bin/sh
 
 # test stripping of filelogs where the linkrev doesn't always increase
 
-source $TESTDIR/helpers.sh
+. $TESTDIR/helpers.sh
 echo '[extensions]' >> $HGRCPATH
 echo 'hgext.mq =' >> $HGRCPATH
 
 hg init orig
 cd orig
 
 commit()
 {
     hg up -qC null
     count=1
     for i in "$@"; do
 	for f in $i; do
 	    echo $count > $f
 	done
 	count=`expr $count + 1`
     done
     hg commit -qAm "$*"
 }
 
 # 2 1 0 2 0 1 2
 commit '201 210'
 
 commit '102 120' '210'
 
 commit '021'
 
 commit '201' '021 120'
 
 commit '012 021' '102 201' '120 210'
 
 commit 'manifest-file'
 
 commit '102 120' '012 210' '021 201'
 
 commit '201 210' '021 120' '012 102'
 
 HGUSER=another-user; export HGUSER
 commit 'manifest-file'
 
 commit '012' 'manifest-file'
 
 cd ..
 hg clone -q -U -r -1 -r -2 -r -3 -r -4 -r -6 orig crossed
 
 for i in crossed/.hg/store/00manifest.i crossed/.hg/store/data/*.i; do
     echo $i
     hg debugindex $i
     echo
 done
 
 for i in 0 1 2 3 4; do
     hg clone -q -U --pull crossed $i
     echo "% Trying to strip revision $i"
     hg --cwd $i strip $i | hidebackup
     echo "% Verifying"
     hg --cwd $i verify
     echo
 done