merge with stable

tests/test-largefiles-cache.t

@@ -1,136 +1,136 b''
 Create user cache directory
 
   $ USERCACHE=`pwd`/cache; export USERCACHE
   $ cat <<EOF >> ${HGRCPATH}
   > [extensions]
   > hgext.largefiles=
   > [largefiles]
   > usercache=${USERCACHE}
   > EOF
   $ mkdir -p ${USERCACHE}
 
 Create source repo, and commit adding largefile.
 
   $ hg init src
   $ cd src
   $ echo large > large
   $ hg add --large large
   $ hg commit -m 'add largefile'
   $ hg rm large
   $ hg commit -m 'branchhead without largefile'
   $ hg up -qr 0
   $ cd ..
 
 Discard all cached largefiles in USERCACHE
 
   $ rm -rf ${USERCACHE}
 
 Create mirror repo, and pull from source without largefile:
 "pull" is used instead of "clone" for suppression of (1) updating to
 tip (= cahcing largefile from source repo), and (2) recording source
 repo as "default" path in .hg/hgrc.
 
   $ hg init mirror
   $ cd mirror
   $ hg pull ../src
   pulling from ../src
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 2 changesets with 1 changes to 1 files
   (run 'hg update' to get a working copy)
 
 Update working directory to "tip", which requires largefile("large"),
 but there is no cache file for it.  So, hg must treat it as
 "missing"(!) file.
 
   $ hg update -r0
   getting changed largefiles
-  large: largefile 7f7097b041ccf68cc5561e9600da4655d21c6d18 not available from file:$TESTTMP/mirror
+  large: largefile 7f7097b041ccf68cc5561e9600da4655d21c6d18 not available from file:$TESTTMP/mirror (glob)
   0 largefiles updated, 0 removed
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg status
   ! large
 
 Update working directory to null: this cleanup .hg/largefiles/dirstate
 
   $ hg update null
   getting changed largefiles
   0 largefiles updated, 0 removed
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
 
 Update working directory to tip, again.
 
   $ hg update -r0
   getting changed largefiles
-  large: largefile 7f7097b041ccf68cc5561e9600da4655d21c6d18 not available from file:$TESTTMP/mirror
+  large: largefile 7f7097b041ccf68cc5561e9600da4655d21c6d18 not available from file:$TESTTMP/mirror (glob)
   0 largefiles updated, 0 removed
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg status
   ! large
   $ cd ..
 
 Verify that largefiles from pulled branchheads are fetched, also to an empty repo
 
   $ hg init mirror2
   $ hg -R mirror2 pull src -r0
   pulling from src
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
   (run 'hg update' to get a working copy)
 
 #if unix-permissions
 
 Portable way to print file permissions:
 
   $ cat > ls-l.py <<EOF
   > #!/usr/bin/env python
   > import sys, os
   > path = sys.argv[1]
   > print '%03o' % (os.lstat(path).st_mode & 0777)
   > EOF
   $ chmod +x ls-l.py
 
 Test that files in .hg/largefiles inherit mode from .hg/store, not
 from file in working copy:
 
   $ cd src
   $ chmod 750 .hg/store
   $ chmod 660 large
   $ echo change >> large
   $ hg commit -m change
   created new head
   $ ../ls-l.py .hg/largefiles/e151b474069de4ca6898f67ce2f2a7263adf8fea
   640
 
 Test permission of with files in .hg/largefiles created by update:
 
   $ cd ../mirror
   $ rm -r "$USERCACHE" .hg/largefiles # avoid links
   $ chmod 750 .hg/store
   $ hg pull ../src --update -q
   $ ../ls-l.py .hg/largefiles/e151b474069de4ca6898f67ce2f2a7263adf8fea
   640
 
 Test permission of files created by push:
 
   $ hg serve -R ../src -d -p $HGPORT --pid-file hg.pid \
   >          --config "web.allow_push=*" --config web.push_ssl=no
   $ cat hg.pid >> $DAEMON_PIDS
 
   $ echo change >> large
   $ hg commit -m change
 
   $ rm -r "$USERCACHE"
 
   $ hg push -q http://localhost:$HGPORT/
 
   $ ../ls-l.py ../src/.hg/largefiles/b734e14a0971e370408ab9bce8d56d8485e368a9
   640
 
   $ cd ..
 
 #endif

tests/test-largefiles.t

@@ -1,2191 +1,2191 b''
   $ USERCACHE="$TESTTMP/cache"; export USERCACHE
   $ mkdir "${USERCACHE}"
   $ cat >> $HGRCPATH <<EOF
   > [extensions]
   > largefiles=
   > purge=
   > rebase=
   > transplant=
   > [phases]
   > publish=False
   > [largefiles]
   > minsize=2
   > patterns=glob:**.dat
   > usercache=${USERCACHE}
   > [hooks]
   > precommit=sh -c "echo \\"Invoking status precommit hook\\"; hg status"
   > EOF
 
 Create the repo with a couple of revisions of both large and normal
 files.
 Test status and dirstate of largefiles and that summary output is correct.
 
   $ hg init a
   $ cd a
   $ mkdir sub
   $ echo normal1 > normal1
   $ echo normal2 > sub/normal2
   $ echo large1 > large1
   $ echo large2 > sub/large2
   $ hg add normal1 sub/normal2
   $ hg add --large large1 sub/large2
   $ hg commit -m "add files"
   Invoking status precommit hook
   A large1
   A normal1
   A sub/large2
   A sub/normal2
   $ touch large1 sub/large2
   $ sleep 1
   $ hg st
   $ hg debugstate --nodates
   n 644         41 .hglf/large1
   n 644         41 .hglf/sub/large2
   n 644          8 normal1
   n 644          8 sub/normal2
   $ hg debugstate --large
   n 644          7 large1
   n 644          7 sub/large2
   $ echo normal11 > normal1
   $ echo normal22 > sub/normal2
   $ echo large11 > large1
   $ echo large22 > sub/large2
   $ hg commit -m "edit files"
   Invoking status precommit hook
   M large1
   M normal1
   M sub/large2
   M sub/normal2
   $ hg sum --large
   parent: 1:ce8896473775 tip
    edit files
   branch: default
   commit: (clean)
   update: (current)
   largefiles: (no remote repo)
 
 Commit preserved largefile contents.
 
   $ cat normal1
   normal11
   $ cat large1
   large11
   $ cat sub/normal2
   normal22
   $ cat sub/large2
   large22
 
 Test status, subdir and unknown files
 
   $ echo unknown > sub/unknown
   $ hg st --all
   ? sub/unknown
   C large1
   C normal1
   C sub/large2
   C sub/normal2
   $ hg st --all sub
   ? sub/unknown
   C sub/large2
   C sub/normal2
   $ rm sub/unknown
 
 Test messages and exit codes for remove warning cases
 
   $ hg remove -A large1
   not removing large1: file still exists
   [1]
   $ echo 'modified' > large1
   $ hg remove large1
   not removing large1: file is modified (use -f to force removal)
   [1]
   $ echo 'new' > normalnew
   $ hg add normalnew
   $ echo 'new' > largenew
   $ hg add --large normalnew
   normalnew already tracked!
   $ hg remove normalnew largenew
   not removing largenew: file is untracked
   not removing normalnew: file has been marked for add (use forget to undo)
   [1]
   $ rm normalnew largenew
   $ hg up -Cq
 
 Remove both largefiles and normal files.
 
   $ hg remove normal1 large1
   $ hg status large1
   R large1
   $ hg commit -m "remove files"
   Invoking status precommit hook
   R large1
   R normal1
   $ ls
   sub
   $ echo "testlargefile" > large1-test
   $ hg add --large large1-test
   $ hg st
   A large1-test
   $ hg rm large1-test
   not removing large1-test: file has been marked for add (use forget to undo)
   [1]
   $ hg st
   A large1-test
   $ hg forget large1-test
   $ hg st
   ? large1-test
   $ hg remove large1-test
   not removing large1-test: file is untracked
   [1]
   $ hg forget large1-test
   not removing large1-test: file is already untracked
   [1]
   $ rm large1-test
 
 Copy both largefiles and normal files (testing that status output is correct).
 
   $ hg cp sub/normal2 normal1
   $ hg cp sub/large2 large1
   $ hg commit -m "copy files"
   Invoking status precommit hook
   A large1
   A normal1
   $ cat normal1
   normal22
   $ cat large1
   large22
 
 Test moving largefiles and verify that normal files are also unaffected.
 
   $ hg mv normal1 normal3
   $ hg mv large1 large3
   $ hg mv sub/normal2 sub/normal4
   $ hg mv sub/large2 sub/large4
   $ hg commit -m "move files"
   Invoking status precommit hook
   A large3
   A normal3
   A sub/large4
   A sub/normal4
   R large1
   R normal1
   R sub/large2
   R sub/normal2
   $ cat normal3
   normal22
   $ cat large3
   large22
   $ cat sub/normal4
   normal22
   $ cat sub/large4
   large22
 
 Test copies and moves from a directory other than root (issue3516)
 
   $ cd ..
   $ hg init lf_cpmv
   $ cd lf_cpmv
   $ mkdir dira
   $ mkdir dira/dirb
   $ touch dira/dirb/largefile
   $ hg add --large dira/dirb/largefile
   $ hg commit -m "added"
   Invoking status precommit hook
   A dira/dirb/largefile
   $ cd dira
   $ hg cp dirb/largefile foo/largefile
   $ hg ci -m "deep copy"
   Invoking status precommit hook
   A dira/foo/largefile
   $ find . | sort
   .
   ./dirb
   ./dirb/largefile
   ./foo
   ./foo/largefile
   $ hg mv foo/largefile baz/largefile
   $ hg ci -m "moved"
   Invoking status precommit hook
   A dira/baz/largefile
   R dira/foo/largefile
   $ find . | sort
   .
   ./baz
   ./baz/largefile
   ./dirb
   ./dirb/largefile
   ./foo
   $ cd ../../a
 
 #if serve
 Test display of largefiles in hgweb
 
   $ hg serve -d -p $HGPORT --pid-file ../hg.pid
   $ cat ../hg.pid >> $DAEMON_PIDS
   $ "$TESTDIR/get-with-headers.py" 127.0.0.1:$HGPORT 'file/tip/?style=raw'
   200 Script output follows
   
   
   drwxr-xr-x sub
   -rw-r--r-- 41 large3
   -rw-r--r-- 9 normal3
   
   
   $ "$TESTDIR/get-with-headers.py" 127.0.0.1:$HGPORT 'file/tip/sub/?style=raw'
   200 Script output follows
   
   
   -rw-r--r-- 41 large4
   -rw-r--r-- 9 normal4
   
   
   $ "$TESTDIR/killdaemons.py" $DAEMON_PIDS
 #endif
 
 Test archiving the various revisions.  These hit corner cases known with
 archiving.
 
   $ hg archive -r 0 ../archive0
   $ hg archive -r 1 ../archive1
   $ hg archive -r 2 ../archive2
   $ hg archive -r 3 ../archive3
   $ hg archive -r 4 ../archive4
   $ cd ../archive0
   $ cat normal1
   normal1
   $ cat large1
   large1
   $ cat sub/normal2
   normal2
   $ cat sub/large2
   large2
   $ cd ../archive1
   $ cat normal1
   normal11
   $ cat large1
   large11
   $ cat sub/normal2
   normal22
   $ cat sub/large2
   large22
   $ cd ../archive2
   $ ls
   sub
   $ cat sub/normal2
   normal22
   $ cat sub/large2
   large22
   $ cd ../archive3
   $ cat normal1
   normal22
   $ cat large1
   large22
   $ cat sub/normal2
   normal22
   $ cat sub/large2
   large22
   $ cd ../archive4
   $ cat normal3
   normal22
   $ cat large3
   large22
   $ cat sub/normal4
   normal22
   $ cat sub/large4
   large22
 
 Commit corner case: specify files to commit.
 
   $ cd ../a
   $ echo normal3 > normal3
   $ echo large3 > large3
   $ echo normal4 > sub/normal4
   $ echo large4 > sub/large4
   $ hg commit normal3 large3 sub/normal4 sub/large4 -m "edit files again"
   Invoking status precommit hook
   M large3
   M normal3
   M sub/large4
   M sub/normal4
   $ cat normal3
   normal3
   $ cat large3
   large3
   $ cat sub/normal4
   normal4
   $ cat sub/large4
   large4
 
 One more commit corner case: commit from a subdirectory.
 
   $ cd ../a
   $ echo normal33 > normal3
   $ echo large33 > large3
   $ echo normal44 > sub/normal4
   $ echo large44 > sub/large4
   $ cd sub
   $ hg commit -m "edit files yet again"
   Invoking status precommit hook
   M large3
   M normal3
   M sub/large4
   M sub/normal4
   $ cat ../normal3
   normal33
   $ cat ../large3
   large33
   $ cat normal4
   normal44
   $ cat large4
   large44
 
 Committing standins is not allowed.
 
   $ cd ..
   $ echo large3 > large3
   $ hg commit .hglf/large3 -m "try to commit standin"
   abort: file ".hglf/large3" is a largefile standin
   (commit the largefile itself instead)
   [255]
 
 Corner cases for adding largefiles.
 
   $ echo large5 > large5
   $ hg add --large large5
   $ hg add --large large5
   large5 already a largefile
   $ mkdir sub2
   $ echo large6 > sub2/large6
   $ echo large7 > sub2/large7
   $ hg add --large sub2
   adding sub2/large6 as a largefile (glob)
   adding sub2/large7 as a largefile (glob)
   $ hg st
   M large3
   A large5
   A sub2/large6
   A sub2/large7
 
 Committing directories containing only largefiles.
 
   $ mkdir -p z/y/x/m
   $ touch z/y/x/m/large1
   $ touch z/y/x/large2
   $ hg add --large z/y/x/m/large1 z/y/x/large2
   $ hg commit -m "Subdir with directory only containing largefiles" z
   Invoking status precommit hook
   M large3
   A large5
   A sub2/large6
   A sub2/large7
   A z/y/x/large2
   A z/y/x/m/large1
   $ hg rollback --quiet
   $ touch z/y/x/m/normal
   $ hg add z/y/x/m/normal
   $ hg commit -m "Subdir with mixed contents" z
   Invoking status precommit hook
   M large3
   A large5
   A sub2/large6
   A sub2/large7
   A z/y/x/large2
   A z/y/x/m/large1
   A z/y/x/m/normal
   $ hg st
   M large3
   A large5
   A sub2/large6
   A sub2/large7
   $ hg rollback --quiet
   $ hg revert z/y/x/large2 z/y/x/m/large1
   $ rm z/y/x/large2 z/y/x/m/large1
   $ hg commit -m "Subdir with normal contents" z
   Invoking status precommit hook
   M large3
   A large5
   A sub2/large6
   A sub2/large7
   A z/y/x/m/normal
   $ hg st
   M large3
   A large5
   A sub2/large6
   A sub2/large7
   $ hg rollback --quiet
   $ hg revert --quiet z
   $ hg commit -m "Empty subdir" z
   abort: z: no match under directory!
   [255]
   $ rm -rf z
   $ hg ci -m "standin" .hglf
   abort: file ".hglf" is a largefile standin
   (commit the largefile itself instead)
   [255]
 
 Test "hg status" with combination of 'file pattern' and 'directory
 pattern' for largefiles:
 
   $ hg status sub2/large6 sub2
   A sub2/large6
   A sub2/large7
 
 Config settings (pattern **.dat, minsize 2 MB) are respected.
 
   $ echo testdata > test.dat
   $ dd bs=1k count=2k if=/dev/zero of=reallylarge > /dev/null 2> /dev/null
   $ hg add
   adding reallylarge as a largefile
   adding test.dat as a largefile
 
 Test that minsize and --lfsize handle float values;
 also tests that --lfsize overrides largefiles.minsize.
 (0.250 MB = 256 kB = 262144 B)
 
   $ dd if=/dev/zero of=ratherlarge bs=1024 count=256 > /dev/null 2> /dev/null
   $ dd if=/dev/zero of=medium bs=1024 count=128 > /dev/null 2> /dev/null
   $ hg --config largefiles.minsize=.25 add
   adding ratherlarge as a largefile
   adding medium
   $ hg forget medium
   $ hg --config largefiles.minsize=.25 add --lfsize=.125
   adding medium as a largefile
   $ dd if=/dev/zero of=notlarge bs=1024 count=127 > /dev/null 2> /dev/null
   $ hg --config largefiles.minsize=.25 add --lfsize=.125
   adding notlarge
   $ hg forget notlarge
 
 Test forget on largefiles.
 
   $ hg forget large3 large5 test.dat reallylarge ratherlarge medium
   $ hg commit -m "add/edit more largefiles"
   Invoking status precommit hook
   A sub2/large6
   A sub2/large7
   R large3
   ? large5
   ? medium
   ? notlarge
   ? ratherlarge
   ? reallylarge
   ? test.dat
   $ hg st
   ? large3
   ? large5
   ? medium
   ? notlarge
   ? ratherlarge
   ? reallylarge
   ? test.dat
 
 Purge with largefiles: verify that largefiles are still in the working
 dir after a purge.
 
   $ hg purge --all
   $ cat sub/large4
   large44
   $ cat sub2/large6
   large6
   $ cat sub2/large7
   large7
 
 Test addremove: verify that files that should be added as largfiles are added as
 such and that already-existing largfiles are not added as normal files by
 accident.
 
   $ rm normal3
   $ rm sub/large4
   $ echo "testing addremove with patterns" > testaddremove.dat
   $ echo "normaladdremove" > normaladdremove
   $ hg addremove
   removing sub/large4
   adding testaddremove.dat as a largefile
   removing normal3
   adding normaladdremove
 
 Test addremove with -R
 
   $ hg up -C
   getting changed largefiles
   1 largefiles updated, 0 removed
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ rm normal3
   $ rm sub/large4
   $ echo "testing addremove with patterns" > testaddremove.dat
   $ echo "normaladdremove" > normaladdremove
   $ cd ..
   $ hg -R a addremove
   removing sub/large4
   adding a/testaddremove.dat as a largefile (glob)
   removing normal3
   adding normaladdremove
   $ cd a
 
 Test 3364
   $ hg clone . ../addrm
   updating to branch default
   getting changed largefiles
   3 largefiles updated, 0 removed
   5 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd ../addrm
   $ cat >> .hg/hgrc <<EOF
   > [hooks]
   > post-commit.stat=sh -c "echo \\"Invoking status postcommit hook\\"; hg status -A"
   > EOF
   $ touch foo
   $ hg add --large foo
   $ hg ci -m "add foo"
   Invoking status precommit hook
   A foo
   Invoking status postcommit hook
   C foo
   C normal3
   C sub/large4
   C sub/normal4
   C sub2/large6
   C sub2/large7
   $ rm foo
   $ hg st
   ! foo
 hmm.. no precommit invoked, but there is a postcommit??
   $ hg ci -m "will not checkin"
   nothing changed
   Invoking status postcommit hook
   ! foo
   C normal3
   C sub/large4
   C sub/normal4
   C sub2/large6
   C sub2/large7
   [1]
   $ hg addremove
   removing foo
   $ hg st
   R foo
   $ hg ci -m "used to say nothing changed"
   Invoking status precommit hook
   R foo
   Invoking status postcommit hook
   C normal3
   C sub/large4
   C sub/normal4
   C sub2/large6
   C sub2/large7
   $ hg st
 
 Test 3507 (both normal files and largefiles were a problem)
 
   $ touch normal
   $ touch large
   $ hg add normal
   $ hg add --large large
   $ hg ci -m "added"
   Invoking status precommit hook
   A large
   A normal
   Invoking status postcommit hook
   C large
   C normal
   C normal3
   C sub/large4
   C sub/normal4
   C sub2/large6
   C sub2/large7
   $ hg remove normal
   $ hg addremove --traceback
   $ hg ci -m "addremoved normal"
   Invoking status precommit hook
   R normal
   Invoking status postcommit hook
   C large
   C normal3
   C sub/large4
   C sub/normal4
   C sub2/large6
   C sub2/large7
   $ hg up -C '.^'
   getting changed largefiles
   0 largefiles updated, 0 removed
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg remove large
   $ hg addremove --traceback
   $ hg ci -m "removed large"
   Invoking status precommit hook
   R large
   created new head
   Invoking status postcommit hook
   C normal
   C normal3
   C sub/large4
   C sub/normal4
   C sub2/large6
   C sub2/large7
 
 Test commit -A (issue 3542)
   $ echo large8 > large8
   $ hg add --large large8
   $ hg ci -Am 'this used to add large8 as normal and commit both'
   Invoking status precommit hook
   A large8
   Invoking status postcommit hook
   C large8
   C normal
   C normal3
   C sub/large4
   C sub/normal4
   C sub2/large6
   C sub2/large7
   $ rm large8
   $ hg ci -Am 'this used to not notice the rm'
   removing large8
   Invoking status precommit hook
   R large8
   Invoking status postcommit hook
   C normal
   C normal3
   C sub/large4
   C sub/normal4
   C sub2/large6
   C sub2/large7
 
 Test that a standin can't be added as a large file
 
   $ touch large
   $ hg add --large large
   $ hg ci -m "add"
   Invoking status precommit hook
   A large
   Invoking status postcommit hook
   C large
   C normal
   C normal3
   C sub/large4
   C sub/normal4
   C sub2/large6
   C sub2/large7
   $ hg remove large
   $ touch large
   $ hg addremove --config largefiles.patterns=**large --traceback
   adding large as a largefile
 
 Test that outgoing --large works (with revsets too)
   $ hg outgoing --rev '.^' --large
   comparing with $TESTTMP/a (glob)
   searching for changes
   changeset:   8:c02fd3b77ec4
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     add foo
   
   changeset:   9:289dd08c9bbb
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     used to say nothing changed
   
   changeset:   10:34f23ac6ac12
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     added
   
   changeset:   12:710c1b2f523c
   parent:      10:34f23ac6ac12
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     removed large
   
   changeset:   13:0a3e75774479
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     this used to add large8 as normal and commit both
   
   changeset:   14:84f3d378175c
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     this used to not notice the rm
   
   searching for changes
   largefiles to upload:
   foo
   large
   large8
   
   $ cd ../a
 
 Clone a largefiles repo.
 
   $ hg clone . ../b
   updating to branch default
   getting changed largefiles
   3 largefiles updated, 0 removed
   5 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd ../b
   $ hg log --template '{rev}:{node|short}  {desc|firstline}\n'
   7:daea875e9014  add/edit more largefiles
   6:4355d653f84f  edit files yet again
   5:9d5af5072dbd  edit files again
   4:74c02385b94c  move files
   3:9e8fbc4bce62  copy files
   2:51a0ae4d5864  remove files
   1:ce8896473775  edit files
   0:30d30fe6a5be  add files
   $ cat normal3
   normal33
   $ cat sub/normal4
   normal44
   $ cat sub/large4
   large44
   $ cat sub2/large6
   large6
   $ cat sub2/large7
   large7
   $ cd ..
   $ hg clone a -r 3 c
   adding changesets
   adding manifests
   adding file changes
   added 4 changesets with 10 changes to 4 files
   updating to branch default
   getting changed largefiles
   2 largefiles updated, 0 removed
   4 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd c
   $ hg log --template '{rev}:{node|short}  {desc|firstline}\n'
   3:9e8fbc4bce62  copy files
   2:51a0ae4d5864  remove files
   1:ce8896473775  edit files
   0:30d30fe6a5be  add files
   $ cat normal1
   normal22
   $ cat large1
   large22
   $ cat sub/normal2
   normal22
   $ cat sub/large2
   large22
 
 Old revisions of a clone have correct largefiles content (this also
 tests update).
 
   $ hg update -r 1
   getting changed largefiles
   1 largefiles updated, 0 removed
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cat large1
   large11
   $ cat sub/large2
   large22
   $ cd ..
 
 Test cloning with --all-largefiles flag
 
   $ rm "${USERCACHE}"/*
   $ hg clone --all-largefiles a a-backup
   updating to branch default
   getting changed largefiles
   3 largefiles updated, 0 removed
   5 files updated, 0 files merged, 0 files removed, 0 files unresolved
   8 additional largefiles cached
 
   $ rm "${USERCACHE}"/*
   $ hg clone --all-largefiles -u 0 a a-clone0
   updating to branch default
   getting changed largefiles
   2 largefiles updated, 0 removed
   4 files updated, 0 files merged, 0 files removed, 0 files unresolved
   9 additional largefiles cached
   $ hg -R a-clone0 sum
   parent: 0:30d30fe6a5be 
    add files
   branch: default
   commit: (clean)
   update: 7 new changesets (update)
 
   $ rm "${USERCACHE}"/*
   $ hg clone --all-largefiles -u 1 a a-clone1
   updating to branch default
   getting changed largefiles
   2 largefiles updated, 0 removed
   4 files updated, 0 files merged, 0 files removed, 0 files unresolved
   8 additional largefiles cached
   $ hg -R a-clone1 verify --large --lfa --lfc
   checking changesets
   checking manifests
   crosschecking files in changesets and manifests
   checking files
   10 files, 8 changesets, 24 total revisions
   searching 8 changesets for largefiles
   verified contents of 13 revisions of 6 largefiles
   $ hg -R a-clone1 sum
   parent: 1:ce8896473775 
    edit files
   branch: default
   commit: (clean)
   update: 6 new changesets (update)
 
   $ rm "${USERCACHE}"/*
   $ hg clone --all-largefiles -U a a-clone-u
   11 additional largefiles cached
   $ hg -R a-clone-u sum
   parent: -1:000000000000  (no revision checked out)
   branch: default
   commit: (clean)
   update: 8 new changesets (update)
 
 Show computed destination directory:
 
   $ mkdir xyz
   $ cd xyz
   $ hg clone ../a
   destination directory: a
   updating to branch default
   getting changed largefiles
   3 largefiles updated, 0 removed
   5 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd ..
 
 Clone URL without path:
 
   $ hg clone file://
   abort: repository / not found!
   [255]
 
 Ensure base clone command argument validation
 
   $ hg clone -U -u 0 a a-clone-failure
   abort: cannot specify both --noupdate and --updaterev
   [255]
 
   $ hg clone --all-largefiles a ssh://localhost/a
   abort: --all-largefiles is incompatible with non-local destination ssh://localhost/a
   [255]
 
 Test pulling with --all-largefiles flag.  Also test that the largefiles are
 downloaded from 'default' instead of 'default-push' when no source is specified
 (issue3584)
 
   $ rm -Rf a-backup
   $ hg clone -r 1 a a-backup
   adding changesets
   adding manifests
   adding file changes
   added 2 changesets with 8 changes to 4 files
   updating to branch default
   getting changed largefiles
   2 largefiles updated, 0 removed
   4 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ rm "${USERCACHE}"/*
   $ cd a-backup
   $ hg pull --all-largefiles --config paths.default-push=bogus/path
   pulling from $TESTTMP/a (glob)
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 6 changesets with 16 changes to 8 files
   (run 'hg update' to get a working copy)
   6 largefiles cached
 
 redo pull with --lfrev and check it pulls largefiles for the right revs
 
   $ hg rollback
   repository tip rolled back to revision 1 (undo pull)
   $ hg pull -v --lfrev 'heads(pulled())+min(pulled())'
   pulling from $TESTTMP/a (glob)
   searching for changes
   all local heads known remotely
   6 changesets found
   adding changesets
   adding manifests
   adding file changes
   added 6 changesets with 16 changes to 8 files
   calling hook changegroup.lfiles: <function checkrequireslfiles at *> (glob)
   (run 'hg update' to get a working copy)
   pulling largefiles for revision 7
   found 971fb41e78fea4f8e0ba5244784239371cb00591 in store
   found 0d6d75887db61b2c7e6c74b5dd8fc6ad50c0cc30 in store
   found bb3151689acb10f0c3125c560d5e63df914bc1af in store
   pulling largefiles for revision 2
   found eb7338044dc27f9bc59b8dd5a246b065ead7a9c4 in store
   0 largefiles cached
 
 lfpull
 
   $ hg lfpull -r : --config largefiles.usercache=usercache-lfpull
   2 largefiles cached
   $ hg lfpull -v -r 4+2 --config largefiles.usercache=usercache-lfpull
   pulling largefiles for revision 4
   found eb7338044dc27f9bc59b8dd5a246b065ead7a9c4 in store
   found eb7338044dc27f9bc59b8dd5a246b065ead7a9c4 in store
   pulling largefiles for revision 2
   found eb7338044dc27f9bc59b8dd5a246b065ead7a9c4 in store
   0 largefiles cached
 
   $ ls usercache-lfpull/* | sort
   usercache-lfpull/1deebade43c8c498a3c8daddac0244dc55d1331d
   usercache-lfpull/4669e532d5b2c093a78eca010077e708a071bb64
 
   $ cd ..
 
 Rebasing between two repositories does not revert largefiles to old
 revisions (this was a very bad bug that took a lot of work to fix).
 
   $ hg clone a d
   updating to branch default
   getting changed largefiles
   3 largefiles updated, 0 removed
   5 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd b
   $ echo large4-modified > sub/large4
   $ echo normal3-modified > normal3
   $ hg commit -m "modify normal file and largefile in repo b"
   Invoking status precommit hook
   M normal3
   M sub/large4
   $ cd ../d
   $ echo large6-modified > sub2/large6
   $ echo normal4-modified > sub/normal4
   $ hg commit -m "modify normal file largefile in repo d"
   Invoking status precommit hook
   M sub/normal4
   M sub2/large6
   $ cd ..
   $ hg clone d e
   updating to branch default
   getting changed largefiles
   3 largefiles updated, 0 removed
   5 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd d
 
 More rebase testing, but also test that the largefiles are downloaded from
 'default-push' when no source is specified (issue3584). (The largefile from the
 pulled revision is however not downloaded but found in the local cache.)
 Largefiles are fetched for the new pulled revision, not for existing revisions,
 rebased or not.
 
   $ [ ! -f .hg/largefiles/e166e74c7303192238d60af5a9c4ce9bef0b7928 ]
   $ hg pull --rebase --all-largefiles --config paths.default-push=bogus/path --config paths.default=../b
   pulling from $TESTTMP/b (glob)
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 2 changes to 2 files (+1 heads)
   Invoking status precommit hook
   M sub/normal4
   M sub2/large6
   saved backup bundle to $TESTTMP/d/.hg/strip-backup/f574fb32bb45-backup.hg (glob)
   0 largefiles cached
   nothing to rebase
   $ [ -f .hg/largefiles/e166e74c7303192238d60af5a9c4ce9bef0b7928 ]
   $ hg log --template '{rev}:{node|short}  {desc|firstline}\n'
   9:598410d3eb9a  modify normal file largefile in repo d
   8:a381d2c8c80e  modify normal file and largefile in repo b
   7:daea875e9014  add/edit more largefiles
   6:4355d653f84f  edit files yet again
   5:9d5af5072dbd  edit files again
   4:74c02385b94c  move files
   3:9e8fbc4bce62  copy files
   2:51a0ae4d5864  remove files
   1:ce8896473775  edit files
   0:30d30fe6a5be  add files
   $ cat normal3
   normal3-modified
   $ cat sub/normal4
   normal4-modified
   $ cat sub/large4
   large4-modified
   $ cat sub2/large6
   large6-modified
   $ cat sub2/large7
   large7
   $ cd ../e
   $ hg pull ../b
   pulling from ../b
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 2 changes to 2 files (+1 heads)
   (run 'hg heads' to see heads, 'hg merge' to merge)
   $ hg rebase
   Invoking status precommit hook
   M sub/normal4
   M sub2/large6
   saved backup bundle to $TESTTMP/e/.hg/strip-backup/f574fb32bb45-backup.hg (glob)
   $ hg log --template '{rev}:{node|short}  {desc|firstline}\n'
   9:598410d3eb9a  modify normal file largefile in repo d
   8:a381d2c8c80e  modify normal file and largefile in repo b
   7:daea875e9014  add/edit more largefiles
   6:4355d653f84f  edit files yet again
   5:9d5af5072dbd  edit files again
   4:74c02385b94c  move files
   3:9e8fbc4bce62  copy files
   2:51a0ae4d5864  remove files
   1:ce8896473775  edit files
   0:30d30fe6a5be  add files
   $ cat normal3
   normal3-modified
   $ cat sub/normal4
   normal4-modified
   $ cat sub/large4
   large4-modified
   $ cat sub2/large6
   large6-modified
   $ cat sub2/large7
   large7
 
 Log on largefiles
 
 - same output
   $ hg log --template '{rev}:{node|short}  {desc|firstline}\n' .hglf/sub/large4
   8:a381d2c8c80e  modify normal file and largefile in repo b
   6:4355d653f84f  edit files yet again
   5:9d5af5072dbd  edit files again
   4:74c02385b94c  move files
   $ hg log --template '{rev}:{node|short}  {desc|firstline}\n' sub/large4
   8:a381d2c8c80e  modify normal file and largefile in repo b
   6:4355d653f84f  edit files yet again
   5:9d5af5072dbd  edit files again
   4:74c02385b94c  move files
 
 - .hglf only matches largefiles, without .hglf it matches 9 bco sub/normal
   $ hg log --template '{rev}:{node|short}  {desc|firstline}\n' .hglf/sub
   8:a381d2c8c80e  modify normal file and largefile in repo b
   6:4355d653f84f  edit files yet again
   5:9d5af5072dbd  edit files again
   4:74c02385b94c  move files
   1:ce8896473775  edit files
   0:30d30fe6a5be  add files
   $ hg log --template '{rev}:{node|short}  {desc|firstline}\n' sub
   9:598410d3eb9a  modify normal file largefile in repo d
   8:a381d2c8c80e  modify normal file and largefile in repo b
   6:4355d653f84f  edit files yet again
   5:9d5af5072dbd  edit files again
   4:74c02385b94c  move files
   1:ce8896473775  edit files
   0:30d30fe6a5be  add files
 
 - globbing gives same result
   $ hg log --template '{rev}:{node|short}  {desc|firstline}\n' 'glob:sub/*'
   9:598410d3eb9a  modify normal file largefile in repo d
   8:a381d2c8c80e  modify normal file and largefile in repo b
   6:4355d653f84f  edit files yet again
   5:9d5af5072dbd  edit files again
   4:74c02385b94c  move files
   1:ce8896473775  edit files
   0:30d30fe6a5be  add files
 
 Rollback on largefiles.
 
   $ echo large4-modified-again > sub/large4
   $ hg commit -m "Modify large4 again"
   Invoking status precommit hook
   M sub/large4
   $ hg rollback
   repository tip rolled back to revision 9 (undo commit)
   working directory now based on revision 9
   $ hg st
   M sub/large4
   $ hg log --template '{rev}:{node|short}  {desc|firstline}\n'
   9:598410d3eb9a  modify normal file largefile in repo d
   8:a381d2c8c80e  modify normal file and largefile in repo b
   7:daea875e9014  add/edit more largefiles
   6:4355d653f84f  edit files yet again
   5:9d5af5072dbd  edit files again
   4:74c02385b94c  move files
   3:9e8fbc4bce62  copy files
   2:51a0ae4d5864  remove files
   1:ce8896473775  edit files
   0:30d30fe6a5be  add files
   $ cat sub/large4
   large4-modified-again
 
 "update --check" refuses to update with uncommitted changes.
   $ hg update --check 8
   abort: uncommitted local changes
   [255]
 
 "update --clean" leaves correct largefiles in working copy, even when there is
 .orig files from revert in .hglf.
 
   $ echo mistake > sub2/large7
   $ hg revert sub2/large7
   $ hg -q update --clean -r null
   $ hg update --clean
   getting changed largefiles
   3 largefiles updated, 0 removed
   5 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cat normal3
   normal3-modified
   $ cat sub/normal4
   normal4-modified
   $ cat sub/large4
   large4-modified
   $ cat sub2/large6
   large6-modified
   $ cat sub2/large7
   large7
   $ cat sub2/large7.orig
   mistake
   $ cat .hglf/sub2/large7.orig
   9dbfb2c79b1c40981b258c3efa1b10b03f18ad31
 
 demonstrate misfeature: .orig file is overwritten on every update -C,
 also when clean:
   $ hg update --clean
   getting changed largefiles
   0 largefiles updated, 0 removed
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cat sub2/large7.orig
   large7
   $ rm sub2/large7.orig .hglf/sub2/large7.orig
 
 Now "update check" is happy.
   $ hg update --check 8
   getting changed largefiles
   1 largefiles updated, 0 removed
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg update --check
   getting changed largefiles
   1 largefiles updated, 0 removed
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 Test removing empty largefiles directories on update
   $ test -d sub2 && echo "sub2 exists"
   sub2 exists
   $ hg update -q null
   $ test -d sub2 && echo "error: sub2 should not exist anymore"
   [1]
   $ hg update -q
 
 Test hg remove removes empty largefiles directories
   $ test -d sub2 && echo "sub2 exists"
   sub2 exists
   $ hg remove sub2/*
   $ test -d sub2 && echo "error: sub2 should not exist anymore"
   [1]
   $ hg revert sub2/large6 sub2/large7
 
 "revert" works on largefiles (and normal files too).
   $ echo hack3 >> normal3
   $ echo hack4 >> sub/normal4
   $ echo hack4 >> sub/large4
   $ rm sub2/large6
   $ hg revert sub2/large6
   $ hg rm sub2/large6
   $ echo new >> sub2/large8
   $ hg add --large sub2/large8
 # XXX we don't really want to report that we're reverting the standin;
 # that's just an implementation detail. But I don't see an obvious fix. ;-(
   $ hg revert sub
   reverting .hglf/sub/large4 (glob)
   reverting sub/normal4 (glob)
   $ hg status
   M normal3
   A sub2/large8
   R sub2/large6
   ? sub/large4.orig
   ? sub/normal4.orig
   $ cat sub/normal4
   normal4-modified
   $ cat sub/large4
   large4-modified
   $ hg revert -a --no-backup
   undeleting .hglf/sub2/large6 (glob)
   forgetting .hglf/sub2/large8 (glob)
   reverting normal3
   $ hg status
   ? sub/large4.orig
   ? sub/normal4.orig
   ? sub2/large8
   $ cat normal3
   normal3-modified
   $ cat sub2/large6
   large6-modified
   $ rm sub/*.orig sub2/large8
 
 revert some files to an older revision
   $ hg revert --no-backup -r 8 sub2
   reverting .hglf/sub2/large6 (glob)
   $ cat sub2/large6
   large6
   $ hg revert --no-backup -C -r '.^' sub2
   reverting .hglf/sub2/large6 (glob)
   $ hg revert --no-backup sub2
   reverting .hglf/sub2/large6 (glob)
   $ hg status
 
 "verify --large" actually verifies largefiles
 
 - Where Do We Come From? What Are We? Where Are We Going?
   $ pwd
   $TESTTMP/e
   $ hg paths
   default = $TESTTMP/d (glob)
 
   $ hg verify --large
   checking changesets
   checking manifests
   crosschecking files in changesets and manifests
   checking files
   10 files, 10 changesets, 28 total revisions
   searching 1 changesets for largefiles
   verified existence of 3 revisions of 3 largefiles
 
 - introduce missing blob in local store repo and make sure that this is caught:
   $ mv $TESTTMP/d/.hg/largefiles/e166e74c7303192238d60af5a9c4ce9bef0b7928 .
   $ hg verify --large
   checking changesets
   checking manifests
   crosschecking files in changesets and manifests
   checking files
   10 files, 10 changesets, 28 total revisions
   searching 1 changesets for largefiles
   changeset 9:598410d3eb9a: sub/large4 references missing $TESTTMP/d/.hg/largefiles/e166e74c7303192238d60af5a9c4ce9bef0b7928 (glob)
   verified existence of 3 revisions of 3 largefiles
   [1]
 
 - introduce corruption and make sure that it is caught when checking content:
   $ echo '5 cents' > $TESTTMP/d/.hg/largefiles/e166e74c7303192238d60af5a9c4ce9bef0b7928
   $ hg verify -q --large --lfc
   changeset 9:598410d3eb9a: sub/large4 references corrupted $TESTTMP/d/.hg/largefiles/e166e74c7303192238d60af5a9c4ce9bef0b7928 (glob)
   [1]
 
 - cleanup
   $ mv e166e74c7303192238d60af5a9c4ce9bef0b7928 $TESTTMP/d/.hg/largefiles/
 
 - verifying all revisions will fail because we didn't clone all largefiles to d:
   $ echo 'T-shirt' > $TESTTMP/d/.hg/largefiles/eb7338044dc27f9bc59b8dd5a246b065ead7a9c4
   $ hg verify -q --lfa --lfc
   changeset 0:30d30fe6a5be: large1 references missing $TESTTMP/d/.hg/largefiles/4669e532d5b2c093a78eca010077e708a071bb64 (glob)
   changeset 0:30d30fe6a5be: sub/large2 references missing $TESTTMP/d/.hg/largefiles/1deebade43c8c498a3c8daddac0244dc55d1331d (glob)
   changeset 1:ce8896473775: large1 references missing $TESTTMP/d/.hg/largefiles/5f78770c0e77ba4287ad6ef3071c9bf9c379742f (glob)
   changeset 1:ce8896473775: sub/large2 references corrupted $TESTTMP/d/.hg/largefiles/eb7338044dc27f9bc59b8dd5a246b065ead7a9c4 (glob)
   changeset 3:9e8fbc4bce62: large1 references corrupted $TESTTMP/d/.hg/largefiles/eb7338044dc27f9bc59b8dd5a246b065ead7a9c4 (glob)
   changeset 4:74c02385b94c: large3 references corrupted $TESTTMP/d/.hg/largefiles/eb7338044dc27f9bc59b8dd5a246b065ead7a9c4 (glob)
   changeset 4:74c02385b94c: sub/large4 references corrupted $TESTTMP/d/.hg/largefiles/eb7338044dc27f9bc59b8dd5a246b065ead7a9c4 (glob)
   changeset 5:9d5af5072dbd: large3 references missing $TESTTMP/d/.hg/largefiles/baaf12afde9d8d67f25dab6dced0d2bf77dba47c (glob)
   changeset 5:9d5af5072dbd: sub/large4 references missing $TESTTMP/d/.hg/largefiles/aeb2210d19f02886dde00dac279729a48471e2f9 (glob)
   changeset 6:4355d653f84f: large3 references missing $TESTTMP/d/.hg/largefiles/7838695e10da2bb75ac1156565f40a2595fa2fa0 (glob)
   [1]
 
 - cleanup
   $ rm $TESTTMP/d/.hg/largefiles/eb7338044dc27f9bc59b8dd5a246b065ead7a9c4
   $ rm -f .hglf/sub/*.orig
 
 Update to revision with missing largefile - and make sure it really is missing
 
   $ rm ${USERCACHE}/7838695e10da2bb75ac1156565f40a2595fa2fa0
   $ hg up -r 6
   getting changed largefiles
-  large3: largefile 7838695e10da2bb75ac1156565f40a2595fa2fa0 not available from file:$TESTTMP/d
+  large3: largefile 7838695e10da2bb75ac1156565f40a2595fa2fa0 not available from file:$TESTTMP/d (glob)
   1 largefiles updated, 2 removed
   4 files updated, 0 files merged, 2 files removed, 0 files unresolved
   $ rm normal3
   $ echo >> sub/normal4
   $ hg ci -m 'commit with missing files'
   Invoking status precommit hook
   M sub/normal4
   ! large3
   ! normal3
   created new head
   $ hg st
   ! large3
   ! normal3
   $ hg up -r.
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg st
   ! large3
   ! normal3
   $ hg up -Cr.
   getting changed largefiles
-  large3: largefile 7838695e10da2bb75ac1156565f40a2595fa2fa0 not available from file:$TESTTMP/d
+  large3: largefile 7838695e10da2bb75ac1156565f40a2595fa2fa0 not available from file:$TESTTMP/d (glob)
   0 largefiles updated, 0 removed
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg st
   ! large3
   $ hg rollback
   repository tip rolled back to revision 9 (undo commit)
   working directory now based on revision 6
 
 Merge with revision with missing largefile - and make sure it tries to fetch it.
 
   $ hg up -Cqr null
   $ echo f > f
   $ hg ci -Am branch
   adding f
   Invoking status precommit hook
   A f
   created new head
   $ hg merge -r 6
   4 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   getting changed largefiles
-  large3: largefile 7838695e10da2bb75ac1156565f40a2595fa2fa0 not available from file:$TESTTMP/d
+  large3: largefile 7838695e10da2bb75ac1156565f40a2595fa2fa0 not available from file:$TESTTMP/d (glob)
   1 largefiles updated, 0 removed
 
   $ hg rollback -q
   $ hg up -Cq
 
 Pulling 0 revisions with --all-largefiles should not fetch for all revisions
 
   $ hg pull --all-largefiles
   pulling from $TESTTMP/d (glob)
   searching for changes
   no changes found
 
 Merging does not revert to old versions of largefiles and also check
 that merging after having pulled from a non-default remote works
 correctly.
 
   $ cd ..
   $ hg clone -r 7 e temp
   adding changesets
   adding manifests
   adding file changes
   added 8 changesets with 24 changes to 10 files
   updating to branch default
   getting changed largefiles
   3 largefiles updated, 0 removed
   5 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg clone temp f
   updating to branch default
   getting changed largefiles
   3 largefiles updated, 0 removed
   5 files updated, 0 files merged, 0 files removed, 0 files unresolved
 # Delete the largefiles in the largefiles system cache so that we have an
 # opportunity to test that caching after a pull works.
   $ rm "${USERCACHE}"/*
   $ cd f
   $ echo "large4-merge-test" > sub/large4
   $ hg commit -m "Modify large4 to test merge"
   Invoking status precommit hook
   M sub/large4
 # Test --cache-largefiles flag
   $ hg pull --lfrev 'heads(pulled())' ../e
   pulling from ../e
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 2 changesets with 4 changes to 4 files (+1 heads)
   (run 'hg heads' to see heads, 'hg merge' to merge)
   2 largefiles cached
   $ hg merge
   merging sub/large4
   largefile sub/large4 has a merge conflict
   keep (l)ocal or take (o)ther? l
   3 files updated, 1 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   getting changed largefiles
   1 largefiles updated, 0 removed
   $ hg commit -m "Merge repos e and f"
   Invoking status precommit hook
   M normal3
   M sub/normal4
   M sub2/large6
   $ cat normal3
   normal3-modified
   $ cat sub/normal4
   normal4-modified
   $ cat sub/large4
   large4-merge-test
   $ cat sub2/large6
   large6-modified
   $ cat sub2/large7
   large7
 
 Test status after merging with a branch that introduces a new largefile:
 
   $ echo large > large
   $ hg add --large large
   $ hg commit -m 'add largefile'
   Invoking status precommit hook
   A large
   $ hg update -q ".^"
   $ echo change >> normal3
   $ hg commit -m 'some change'
   Invoking status precommit hook
   M normal3
   created new head
   $ hg merge
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   getting changed largefiles
   1 largefiles updated, 0 removed
   $ hg status
   M large
 
 - make sure update of merge with removed largefiles fails as expected
   $ hg rm sub2/large6
   $ hg up -r.
   abort: outstanding uncommitted merges
   [255]
 
 - revert should be able to revert files introduced in a pending merge
   $ hg revert --all -r .
   removing .hglf/large (glob)
   undeleting .hglf/sub2/large6 (glob)
 
 Test that a normal file and a largefile with the same name and path cannot
 coexist.
 
   $ rm sub2/large7
   $ echo "largeasnormal" > sub2/large7
   $ hg add sub2/large7
   sub2/large7 already a largefile
 
 Test that transplanting a largefile change works correctly.
 
   $ cd ..
   $ hg clone -r 8 d g
   adding changesets
   adding manifests
   adding file changes
   added 9 changesets with 26 changes to 10 files
   updating to branch default
   getting changed largefiles
   3 largefiles updated, 0 removed
   5 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd g
   $ hg transplant -s ../d 598410d3eb9a
   searching for changes
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 2 changes to 2 files
   getting changed largefiles
   1 largefiles updated, 0 removed
   $ hg log --template '{rev}:{node|short}  {desc|firstline}\n'
   9:598410d3eb9a  modify normal file largefile in repo d
   8:a381d2c8c80e  modify normal file and largefile in repo b
   7:daea875e9014  add/edit more largefiles
   6:4355d653f84f  edit files yet again
   5:9d5af5072dbd  edit files again
   4:74c02385b94c  move files
   3:9e8fbc4bce62  copy files
   2:51a0ae4d5864  remove files
   1:ce8896473775  edit files
   0:30d30fe6a5be  add files
   $ cat normal3
   normal3-modified
   $ cat sub/normal4
   normal4-modified
   $ cat sub/large4
   large4-modified
   $ cat sub2/large6
   large6-modified
   $ cat sub2/large7
   large7
 
 Cat a largefile
   $ hg cat normal3
   normal3-modified
   $ hg cat sub/large4
   large4-modified
   $ rm "${USERCACHE}"/*
   $ hg cat -r a381d2c8c80e -o cat.out sub/large4
   $ cat cat.out
   large4-modified
   $ rm cat.out
   $ hg cat -r a381d2c8c80e normal3
   normal3-modified
   $ hg cat -r '.^' normal3
   normal3-modified
   $ hg cat -r '.^' sub/large4 doesntexist
   large4-modified
   doesntexist: no such file in rev a381d2c8c80e
   $ hg --cwd sub cat -r '.^' large4
   large4-modified
   $ hg --cwd sub cat -r '.^' ../normal3
   normal3-modified
 
 Test that renaming a largefile results in correct output for status
 
   $ hg rename sub/large4 large4-renamed
   $ hg commit -m "test rename output"
   Invoking status precommit hook
   A large4-renamed
   R sub/large4
   $ cat large4-renamed
   large4-modified
   $ cd sub2
   $ hg rename large6 large6-renamed
   $ hg st
   A sub2/large6-renamed
   R sub2/large6
   $ cd ..
 
 Test --normal flag
 
   $ dd if=/dev/zero bs=2k count=11k > new-largefile 2> /dev/null
   $ hg add --normal --large new-largefile
   abort: --normal cannot be used with --large
   [255]
   $ hg add --normal new-largefile
   new-largefile: up to 69 MB of RAM may be required to manage this file
   (use 'hg revert new-largefile' to cancel the pending addition)
   $ cd ..
 
 #if serve
 vanilla clients not locked out from largefiles servers on vanilla repos
   $ mkdir r1
   $ cd r1
   $ hg init
   $ echo c1 > f1
   $ hg add f1
   $ hg commit -m "m1"
   Invoking status precommit hook
   A f1
   $ cd ..
   $ hg serve -R r1 -d -p $HGPORT --pid-file hg.pid
   $ cat hg.pid >> $DAEMON_PIDS
   $ hg --config extensions.largefiles=! clone http://localhost:$HGPORT r2
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
   updating to branch default
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 largefiles clients still work with vanilla servers
   $ hg --config extensions.largefiles=! serve -R r1 -d -p $HGPORT1 --pid-file hg.pid
   $ cat hg.pid >> $DAEMON_PIDS
   $ hg clone http://localhost:$HGPORT1 r3
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
   updating to branch default
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 #endif
 
 
 vanilla clients locked out from largefiles http repos
   $ mkdir r4
   $ cd r4
   $ hg init
   $ echo c1 > f1
   $ hg add --large f1
   $ hg commit -m "m1"
   Invoking status precommit hook
   A f1
   $ cd ..
 
 largefiles can be pushed locally (issue3583)
   $ hg init dest
   $ cd r4
   $ hg outgoing ../dest
   comparing with ../dest
   searching for changes
   changeset:   0:639881c12b4c
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     m1
   
   $ hg push ../dest
   pushing to ../dest
   searching for changes
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
 
 exit code with nothing outgoing (issue3611)
   $ hg outgoing ../dest
   comparing with ../dest
   searching for changes
   no changes found
   [1]
   $ cd ..
 
 #if serve
   $ hg serve -R r4 -d -p $HGPORT2 --pid-file hg.pid
   $ cat hg.pid >> $DAEMON_PIDS
   $ hg --config extensions.largefiles=! clone http://localhost:$HGPORT2 r5
   abort: remote error:
   
   This repository uses the largefiles extension.
   
   Please enable it in your Mercurial config file.
   [255]
 
 used all HGPORTs, kill all daemons
   $ "$TESTDIR/killdaemons.py" $DAEMON_PIDS
 #endif
 
 vanilla clients locked out from largefiles ssh repos
   $ hg --config extensions.largefiles=! clone -e "python \"$TESTDIR/dummyssh\"" ssh://user@dummy/r4 r5
   abort: remote error:
   
   This repository uses the largefiles extension.
   
   Please enable it in your Mercurial config file.
   [255]
 
 #if serve
 
 largefiles clients refuse to push largefiles repos to vanilla servers
   $ mkdir r6
   $ cd r6
   $ hg init
   $ echo c1 > f1
   $ hg add f1
   $ hg commit -m "m1"
   Invoking status precommit hook
   A f1
   $ cat >> .hg/hgrc <<!
   > [web]
   > push_ssl = false
   > allow_push = *
   > !
   $ cd ..
   $ hg clone r6 r7
   updating to branch default
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd r7
   $ echo c2 > f2
   $ hg add --large f2
   $ hg commit -m "m2"
   Invoking status precommit hook
   A f2
   $ hg --config extensions.largefiles=! -R ../r6 serve -d -p $HGPORT --pid-file ../hg.pid
   $ cat ../hg.pid >> $DAEMON_PIDS
   $ hg push http://localhost:$HGPORT
   pushing to http://localhost:$HGPORT/
   searching for changes
   abort: http://localhost:$HGPORT/ does not appear to be a largefile store
   [255]
   $ cd ..
 
 putlfile errors are shown (issue3123)
 Corrupt the cached largefile in r7 and move it out of the servers usercache
   $ mv r7/.hg/largefiles/4cdac4d8b084d0b599525cf732437fb337d422a8 .
   $ echo 'client side corruption' > r7/.hg/largefiles/4cdac4d8b084d0b599525cf732437fb337d422a8
   $ rm "$USERCACHE/4cdac4d8b084d0b599525cf732437fb337d422a8"
   $ hg init empty
   $ hg serve -R empty -d -p $HGPORT1 --pid-file hg.pid \
   >   --config 'web.allow_push=*' --config web.push_ssl=False
   $ cat hg.pid >> $DAEMON_PIDS
   $ hg push -R r7 http://localhost:$HGPORT1
   pushing to http://localhost:$HGPORT1/
   searching for changes
   remote: largefiles: failed to put 4cdac4d8b084d0b599525cf732437fb337d422a8 into store: largefile contents do not match hash
   abort: remotestore: could not put $TESTTMP/r7/.hg/largefiles/4cdac4d8b084d0b599525cf732437fb337d422a8 to remote store http://localhost:$HGPORT1/ (glob)
   [255]
   $ mv 4cdac4d8b084d0b599525cf732437fb337d422a8 r7/.hg/largefiles/4cdac4d8b084d0b599525cf732437fb337d422a8
 Push of file that exists on server but is corrupted - magic healing would be nice ... but too magic
   $ echo "server side corruption" > empty/.hg/largefiles/4cdac4d8b084d0b599525cf732437fb337d422a8
   $ hg push -R r7 http://localhost:$HGPORT1
   pushing to http://localhost:$HGPORT1/
   searching for changes
   searching for changes
   remote: adding changesets
   remote: adding manifests
   remote: adding file changes
   remote: added 2 changesets with 2 changes to 2 files
   $ cat empty/.hg/largefiles/4cdac4d8b084d0b599525cf732437fb337d422a8
   server side corruption
   $ rm -rf empty
 
 Push a largefiles repository to a served empty repository
   $ hg init r8
   $ echo c3 > r8/f1
   $ hg add --large r8/f1 -R r8
   $ hg commit -m "m1" -R r8
   Invoking status precommit hook
   A f1
   $ hg init empty
   $ hg serve -R empty -d -p $HGPORT2 --pid-file hg.pid \
   >   --config 'web.allow_push=*' --config web.push_ssl=False
   $ cat hg.pid >> $DAEMON_PIDS
   $ rm "${USERCACHE}"/*
   $ hg push -R r8 http://localhost:$HGPORT2/#default
   pushing to http://localhost:$HGPORT2/
   searching for changes
   searching for changes
   remote: adding changesets
   remote: adding manifests
   remote: adding file changes
   remote: added 1 changesets with 1 changes to 1 files
   $ [ -f "${USERCACHE}"/02a439e5c31c526465ab1a0ca1f431f76b827b90 ]
   $ [ -f empty/.hg/largefiles/02a439e5c31c526465ab1a0ca1f431f76b827b90 ]
 
 Clone over http, no largefiles pulled on clone.
 
   $ hg clone http://localhost:$HGPORT2/#default http-clone -U
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
 
 test 'verify' with remotestore:
 
   $ rm "${USERCACHE}"/02a439e5c31c526465ab1a0ca1f431f76b827b90
   $ mv empty/.hg/largefiles/02a439e5c31c526465ab1a0ca1f431f76b827b90 .
   $ hg -R http-clone verify --large --lfa
   checking changesets
   checking manifests
   crosschecking files in changesets and manifests
   checking files
   1 files, 1 changesets, 1 total revisions
   searching 1 changesets for largefiles
   changeset 0:cf03e5bb9936: f1 missing
   verified existence of 1 revisions of 1 largefiles
   [1]
   $ mv 02a439e5c31c526465ab1a0ca1f431f76b827b90 empty/.hg/largefiles/
   $ hg -R http-clone -q verify --large --lfa
 
 largefiles pulled on update - a largefile missing on the server:
   $ mv empty/.hg/largefiles/02a439e5c31c526465ab1a0ca1f431f76b827b90 .
   $ hg -R http-clone up --config largefiles.usercache=http-clone-usercache
   getting changed largefiles
   f1: largefile 02a439e5c31c526465ab1a0ca1f431f76b827b90 not available from http://localhost:$HGPORT2/
   0 largefiles updated, 0 removed
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg -R http-clone st
   ! f1
   $ hg -R http-clone up -Cqr null
 
 largefiles pulled on update - a largefile corrupted on the server:
   $ echo corruption > empty/.hg/largefiles/02a439e5c31c526465ab1a0ca1f431f76b827b90
   $ hg -R http-clone up --config largefiles.usercache=http-clone-usercache
   getting changed largefiles
   f1: data corruption (expected 02a439e5c31c526465ab1a0ca1f431f76b827b90, got 6a7bb2556144babe3899b25e5428123735bb1e27)
   0 largefiles updated, 0 removed
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg -R http-clone st
   ! f1
   $ [ ! -f http-clone/.hg/largefiles/02a439e5c31c526465ab1a0ca1f431f76b827b90 ]
   $ [ ! -f http-clone/f1 ]
   $ [ ! -f http-clone-usercache ]
   $ hg -R http-clone verify --large --lfc
   checking changesets
   checking manifests
   crosschecking files in changesets and manifests
   checking files
   1 files, 1 changesets, 1 total revisions
   searching 1 changesets for largefiles
   verified contents of 1 revisions of 1 largefiles
   $ hg -R http-clone up -Cqr null
 
 largefiles pulled on update - no server side problems:
   $ mv 02a439e5c31c526465ab1a0ca1f431f76b827b90 empty/.hg/largefiles/
   $ hg -R http-clone --debug up --config largefiles.usercache=http-clone-usercache
   resolving manifests
    branchmerge: False, force: False, partial: False
    ancestor: 000000000000, local: 000000000000+, remote: cf03e5bb9936
    .hglf/f1: remote created -> g
   getting .hglf/f1
   updating: .hglf/f1 1/1 files (100.00%)
   getting changed largefiles
   using http://localhost:$HGPORT2/
   sending capabilities command
   sending batch command
   getting largefiles: 0/1 lfile (0.00%)
   getting f1:02a439e5c31c526465ab1a0ca1f431f76b827b90
   sending getlfile command
   found 02a439e5c31c526465ab1a0ca1f431f76b827b90 in store
   1 largefiles updated, 0 removed
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
   $ ls http-clone-usercache/*
   http-clone-usercache/02a439e5c31c526465ab1a0ca1f431f76b827b90
 
   $ rm -rf empty http-clone*
 
 used all HGPORTs, kill all daemons
   $ "$TESTDIR/killdaemons.py" $DAEMON_PIDS
 
 #endif
 
 
 #if unix-permissions
 
 Clone a local repository owned by another user
 We have to simulate that here by setting $HOME and removing write permissions
   $ ORIGHOME="$HOME"
   $ mkdir alice
   $ HOME="`pwd`/alice"
   $ cd alice
   $ hg init pubrepo
   $ cd pubrepo
   $ dd if=/dev/zero bs=1k count=11k > a-large-file 2> /dev/null
   $ hg add --large a-large-file
   $ hg commit -m "Add a large file"
   Invoking status precommit hook
   A a-large-file
   $ cd ..
   $ chmod -R a-w pubrepo
   $ cd ..
   $ mkdir bob
   $ HOME="`pwd`/bob"
   $ cd bob
   $ hg clone --pull ../alice/pubrepo pubrepo
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
   updating to branch default
   getting changed largefiles
   1 largefiles updated, 0 removed
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd ..
   $ chmod -R u+w alice/pubrepo
   $ HOME="$ORIGHOME"
 
 #endif
 
 #if symlink
 
 Symlink to a large largefile should behave the same as a symlink to a normal file
   $ hg init largesymlink
   $ cd largesymlink
   $ dd if=/dev/zero bs=1k count=10k of=largefile 2>/dev/null
   $ hg add --large largefile
   $ hg commit -m "commit a large file"
   Invoking status precommit hook
   A largefile
   $ ln -s largefile largelink
   $ hg add largelink
   $ hg commit -m "commit a large symlink"
   Invoking status precommit hook
   A largelink
   $ rm -f largelink
   $ hg up >/dev/null
   $ test -f largelink
   [1]
   $ test -L largelink
   [1]
   $ rm -f largelink # make next part of the test independent of the previous
   $ hg up -C >/dev/null
   $ test -f largelink
   $ test -L largelink
   $ cd ..
 
 #endif
 
 test for pattern matching on 'hg status':
 to boost performance, largefiles checks whether specified patterns are
 related to largefiles in working directory (NOT to STANDIN) or not.
 
   $ hg init statusmatch
   $ cd statusmatch
 
   $ mkdir -p a/b/c/d
   $ echo normal > a/b/c/d/e.normal.txt
   $ hg add a/b/c/d/e.normal.txt
   $ echo large > a/b/c/d/e.large.txt
   $ hg add --large a/b/c/d/e.large.txt
   $ mkdir -p a/b/c/x
   $ echo normal > a/b/c/x/y.normal.txt
   $ hg add a/b/c/x/y.normal.txt
   $ hg commit -m 'add files'
   Invoking status precommit hook
   A a/b/c/d/e.large.txt
   A a/b/c/d/e.normal.txt
   A a/b/c/x/y.normal.txt
 
 (1) no pattern: no performance boost
   $ hg status -A
   C a/b/c/d/e.large.txt
   C a/b/c/d/e.normal.txt
   C a/b/c/x/y.normal.txt
 
 (2) pattern not related to largefiles: performance boost
   $ hg status -A a/b/c/x
   C a/b/c/x/y.normal.txt
 
 (3) pattern related to largefiles: no performance boost
   $ hg status -A a/b/c/d
   C a/b/c/d/e.large.txt
   C a/b/c/d/e.normal.txt
 
 (4) pattern related to STANDIN (not to largefiles): performance boost
   $ hg status -A .hglf/a
   C .hglf/a/b/c/d/e.large.txt
 
 (5) mixed case: no performance boost
   $ hg status -A a/b/c/x a/b/c/d
   C a/b/c/d/e.large.txt
   C a/b/c/d/e.normal.txt
   C a/b/c/x/y.normal.txt
 
 verify that largefiles doesn't break filesets
 
   $ hg log --rev . --exclude "set:binary()"
   changeset:   0:41bd42f10efa
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     add files
   
 verify that large files in subrepos handled properly
   $ hg init subrepo
   $ echo "subrepo = subrepo" > .hgsub
   $ hg add .hgsub
   $ hg ci -m "add subrepo"
   Invoking status precommit hook
   A .hgsub
   ? .hgsubstate
   $ echo "rev 1" > subrepo/large.txt
   $ hg -R subrepo add --large subrepo/large.txt
   $ hg sum
   parent: 1:8ee150ea2e9c tip
    add subrepo
   branch: default
   commit: 1 subrepos
   update: (current)
   $ hg st
   $ hg st -S
   A subrepo/large.txt
   $ hg ci -S -m "commit top repo"
   committing subrepository subrepo
   Invoking status precommit hook
   A large.txt
   Invoking status precommit hook
   M .hgsubstate
 # No differences
   $ hg st -S
   $ hg sum
   parent: 2:ce4cd0c527a6 tip
    commit top repo
   branch: default
   commit: (clean)
   update: (current)
   $ echo "rev 2" > subrepo/large.txt
   $ hg st -S
   M subrepo/large.txt
   $ hg sum
   parent: 2:ce4cd0c527a6 tip
    commit top repo
   branch: default
   commit: 1 subrepos
   update: (current)
   $ hg ci -m "this commit should fail without -S"
   abort: uncommitted changes in subrepo subrepo
   (use --subrepos for recursive commit)
   [255]
 
 Add a normal file to the subrepo, then test archiving
 
   $ echo 'normal file' > subrepo/normal.txt
   $ hg -R subrepo add subrepo/normal.txt
 
 Lock in subrepo, otherwise the change isn't archived
 
   $ hg ci -S -m "add normal file to top level"
   committing subrepository subrepo
   Invoking status precommit hook
   M large.txt
   A normal.txt
   Invoking status precommit hook
   M .hgsubstate
   $ hg archive -S ../lf_subrepo_archive
   $ find ../lf_subrepo_archive | sort
   ../lf_subrepo_archive
   ../lf_subrepo_archive/.hg_archival.txt
   ../lf_subrepo_archive/.hgsub
   ../lf_subrepo_archive/.hgsubstate
   ../lf_subrepo_archive/a
   ../lf_subrepo_archive/a/b
   ../lf_subrepo_archive/a/b/c
   ../lf_subrepo_archive/a/b/c/d
   ../lf_subrepo_archive/a/b/c/d/e.large.txt
   ../lf_subrepo_archive/a/b/c/d/e.normal.txt
   ../lf_subrepo_archive/a/b/c/x
   ../lf_subrepo_archive/a/b/c/x/y.normal.txt
   ../lf_subrepo_archive/subrepo
   ../lf_subrepo_archive/subrepo/large.txt
   ../lf_subrepo_archive/subrepo/normal.txt
 
 Test update with subrepos.
 
   $ hg update 0
   getting changed largefiles
   0 largefiles updated, 1 removed
   0 files updated, 0 files merged, 2 files removed, 0 files unresolved
   $ hg status -S
   $ hg update tip
   getting changed largefiles
   1 largefiles updated, 0 removed
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg status -S
 # modify a large file
   $ echo "modified" > subrepo/large.txt
   $ hg st -S
   M subrepo/large.txt
 # update -C should revert the change.
   $ hg update -C
   getting changed largefiles
   1 largefiles updated, 0 removed
   getting changed largefiles
   0 largefiles updated, 0 removed
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg status -S
 
 Test archiving a revision that references a subrepo that is not yet
 cloned (see test-subrepo-recursion.t):
 
   $ hg clone -U . ../empty
   $ cd ../empty
   $ hg archive --subrepos -r tip ../archive.tar.gz
   cloning subrepo subrepo from $TESTTMP/statusmatch/subrepo
   $ cd ..
 
 Test that addremove picks up largefiles prior to the initial commit (issue3541)
 
   $ hg init addrm2
   $ cd addrm2
   $ touch large.dat
   $ touch large2.dat
   $ touch normal
   $ hg add --large large.dat
   $ hg addremove -v
   adding large2.dat as a largefile
   adding normal
 
 Test that forgetting all largefiles reverts to islfilesrepo() == False
 (addremove will add *.dat as normal files now)
   $ hg forget large.dat
   $ hg forget large2.dat
   $ hg addremove -v
   adding large.dat
   adding large2.dat
 
 Test commit's addremove option prior to the first commit
   $ hg forget large.dat
   $ hg forget large2.dat
   $ hg add --large large.dat
   $ hg ci -Am "commit"
   adding large2.dat as a largefile
   Invoking status precommit hook
   A large.dat
   A large2.dat
   A normal
   $ find .hglf | sort
   .hglf
   .hglf/large.dat
   .hglf/large2.dat
 
 Test actions on largefiles using relative paths from subdir
 
   $ mkdir sub
   $ cd sub
   $ echo anotherlarge > anotherlarge
   $ hg add --large anotherlarge
   $ hg st
   A sub/anotherlarge
   $ hg st anotherlarge
   A anotherlarge
   $ hg commit -m anotherlarge anotherlarge
   Invoking status precommit hook
   A sub/anotherlarge
   $ hg log anotherlarge
   changeset:   1:9627a577c5e9
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     anotherlarge
   
   $ echo more >> anotherlarge
   $ hg st .
   M anotherlarge
   $ hg cat anotherlarge
   anotherlarge
   $ hg revert anotherlarge
   $ hg st
   ? sub/anotherlarge.orig
   $ cd ..
 
   $ cd ..
 
 issue3651: summary/outgoing with largefiles shows "no remote repo"
 unexpectedly
 
   $ mkdir issue3651
   $ cd issue3651
 
   $ hg init src
   $ echo a > src/a
   $ hg -R src add --large src/a
   $ hg -R src commit -m '#0'
   Invoking status precommit hook
   A a
 
 check messages when no remote repository is specified:
 "no remote repo" route for "hg outgoing --large" is not tested here,
 because it can't be reproduced easily.
 
   $ hg init clone1
   $ hg -R clone1 -q pull src
   $ hg -R clone1 -q update
   $ hg -R clone1 paths | grep default
   [1]
 
   $ hg -R clone1 summary --large
   parent: 0:fc0bd45326d3 tip
    #0
   branch: default
   commit: (clean)
   update: (current)
   largefiles: (no remote repo)
 
 check messages when there is no files to upload:
 
   $ hg -q clone src clone2
   $ hg -R clone2 paths | grep default
   default = $TESTTMP/issue3651/src (glob)
 
   $ hg -R clone2 summary --large
   parent: 0:fc0bd45326d3 tip
    #0
   branch: default
   commit: (clean)
   update: (current)
   searching for changes
   largefiles: (no files to upload)
   $ hg -R clone2 outgoing --large
   comparing with $TESTTMP/issue3651/src (glob)
   searching for changes
   no changes found
   searching for changes
   largefiles: no files to upload
   [1]
 
 check messages when there are files to upload:
 
   $ echo b > clone2/b
   $ hg -R clone2 add --large clone2/b
   $ hg -R clone2 commit -m '#1'
   Invoking status precommit hook
   A b
   $ hg -R clone2 summary --large
   parent: 1:1acbe71ce432 tip
    #1
   branch: default
   commit: (clean)
   update: (current)
   searching for changes
   largefiles: 1 to upload
   $ hg -R clone2 outgoing --large
   comparing with $TESTTMP/issue3651/src (glob)
   searching for changes
   changeset:   1:1acbe71ce432
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     #1
   
   searching for changes
   largefiles to upload:
   b
   
 
   $ cd ..

tests/test-lfconvert.t

@@ -1,350 +1,350 b''
   $ USERCACHE="$TESTTMP/cache"; export USERCACHE
   $ mkdir "${USERCACHE}"
   $ cat >> $HGRCPATH <<EOF
   > [extensions]
   > largefiles =
   > share =
   > graphlog =
   > mq =
   > convert =
   > [largefiles]
   > minsize = 0.5
   > patterns = **.other
   >     **.dat
   > usercache=${USERCACHE}
   > EOF
 
 "lfconvert" works
   $ hg init bigfile-repo
   $ cd bigfile-repo
   $ cat >> .hg/hgrc <<EOF
   > [extensions]
   > largefiles = !
   > EOF
   $ mkdir sub
   $ dd if=/dev/zero bs=1k count=256 > large 2> /dev/null
   $ dd if=/dev/zero bs=1k count=256 > large2 2> /dev/null
   $ echo normal > normal1
   $ echo alsonormal > sub/normal2
   $ dd if=/dev/zero bs=1k count=10 > sub/maybelarge.dat 2> /dev/null
   $ hg addremove
   adding large
   adding large2
   adding normal1
   adding sub/maybelarge.dat
   adding sub/normal2
   $ hg commit -m"add large, normal1" large normal1
   $ hg commit -m"add sub/*" sub
 
 Test tag parsing
   $ cat >> .hgtags <<EOF
   > IncorrectlyFormattedTag!
   > invalidhash sometag
   > 0123456789abcdef anothertag
   > EOF
   $ hg add .hgtags
   $ hg commit -m"add large2" large2 .hgtags
 
 Test link+rename largefile codepath
   $ [ -d .hg/largefiles ] && echo fail || echo pass
   pass
   $ cd ..
   $ hg lfconvert --size 0.2 bigfile-repo largefiles-repo
   initializing destination largefiles-repo
   skipping incorrectly formatted tag IncorrectlyFormattedTag!
   skipping incorrectly formatted id invalidhash
   no mapping for id 0123456789abcdef
 #if symlink
   $ hg --cwd bigfile-repo rename large2 large3
   $ ln -sf large bigfile-repo/large3
   $ hg --cwd bigfile-repo commit -m"make large2 a symlink" large2 large3
   $ hg lfconvert --size 0.2 bigfile-repo largefiles-repo-symlink
   initializing destination largefiles-repo-symlink
   skipping incorrectly formatted tag IncorrectlyFormattedTag!
   skipping incorrectly formatted id invalidhash
   no mapping for id 0123456789abcdef
   abort: renamed/copied largefile large3 becomes symlink
   [255]
 #endif
   $ cd bigfile-repo
   $ hg strip --no-backup 2
   0 files updated, 0 files merged, 2 files removed, 0 files unresolved
   $ cd ..
   $ rm -rf largefiles-repo largefiles-repo-symlink
 
   $ hg lfconvert --size 0.2 bigfile-repo largefiles-repo
   initializing destination largefiles-repo
 
 "lfconvert" converts content correctly
   $ cd largefiles-repo
   $ hg up
   getting changed largefiles
   2 largefiles updated, 0 removed
   4 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg locate
   .hglf/large
   .hglf/sub/maybelarge.dat
   normal1
   sub/normal2
   $ cat normal1
   normal
   $ cat sub/normal2
   alsonormal
   $ "$TESTDIR/md5sum.py" large sub/maybelarge.dat
   ec87a838931d4d5d2e94a04644788a55  large
   1276481102f218c981e0324180bafd9f  sub/maybelarge.dat
 
 "lfconvert" adds 'largefiles' to .hg/requires.
   $ cat .hg/requires
   dotencode
   fncache
   largefiles
   revlogv1
   store
 
 "lfconvert" includes a newline at the end of the standin files.
   $ cat .hglf/large .hglf/sub/maybelarge.dat
   2e000fa7e85759c7f4c254d4d9c33ef481e459a7
   34e163be8e43c5631d8b92e9c43ab0bf0fa62b9c
   $ cd ..
 
 add some changesets to rename/remove/merge
   $ cd bigfile-repo
   $ hg mv -q sub stuff
   $ hg commit -m"rename sub/ to stuff/"
   $ hg update -q 1
   $ echo blah >> normal3
   $ echo blah >> sub/normal2
   $ echo blah >> sub/maybelarge.dat
   $ "$TESTDIR/md5sum.py" sub/maybelarge.dat
   1dd0b99ff80e19cff409702a1d3f5e15  sub/maybelarge.dat
   $ hg commit -A -m"add normal3, modify sub/*"
   adding normal3
   created new head
   $ hg rm large normal3
   $ hg commit -q -m"remove large, normal3"
   $ hg merge
   merging sub/maybelarge.dat and stuff/maybelarge.dat to stuff/maybelarge.dat
   warning: $TESTTMP/bigfile-repo/stuff/maybelarge.dat looks like a binary file. (glob)
   merging stuff/maybelarge.dat incomplete! (edit conflicts, then use 'hg resolve --mark')
   merging sub/normal2 and stuff/normal2 to stuff/normal2
   0 files updated, 1 files merged, 0 files removed, 1 files unresolved
   use 'hg resolve' to retry unresolved file merges or 'hg update -C .' to abandon
   [1]
   $ hg cat -r . sub/maybelarge.dat > stuff/maybelarge.dat
   $ hg resolve -m stuff/maybelarge.dat
   $ hg commit -m"merge"
   $ hg glog --template "{rev}:{node|short}  {desc|firstline}\n"
   @    5:4884f215abda  merge
   |\
   | o  4:7285f817b77e  remove large, normal3
   | |
   | o  3:67e3892e3534  add normal3, modify sub/*
   | |
   o |  2:c96c8beb5d56  rename sub/ to stuff/
   |/
   o  1:020c65d24e11  add sub/*
   |
   o  0:117b8328f97a  add large, normal1
   
   $ cd ..
 
 lfconvert with rename, merge, and remove
   $ rm -rf largefiles-repo
   $ hg lfconvert --size 0.2 bigfile-repo largefiles-repo
   initializing destination largefiles-repo
   $ cd largefiles-repo
   $ hg glog --template "{rev}:{node|short}  {desc|firstline}\n"
   o    5:8e05f5f2b77e  merge
   |\
   | o  4:a5a02de7a8e4  remove large, normal3
   | |
   | o  3:55759520c76f  add normal3, modify sub/*
   | |
   o |  2:261ad3f3f037  rename sub/ to stuff/
   |/
   o  1:334e5237836d  add sub/*
   |
   o  0:d4892ec57ce2  add large, normal1
   
   $ hg locate -r 2
   .hglf/large
   .hglf/stuff/maybelarge.dat
   normal1
   stuff/normal2
   $ hg locate -r 3
   .hglf/large
   .hglf/sub/maybelarge.dat
   normal1
   normal3
   sub/normal2
   $ hg locate -r 4
   .hglf/sub/maybelarge.dat
   normal1
   sub/normal2
   $ hg locate -r 5
   .hglf/stuff/maybelarge.dat
   normal1
   stuff/normal2
   $ hg update
   getting changed largefiles
   1 largefiles updated, 0 removed
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cat stuff/normal2
   alsonormal
   blah
   $ "$TESTDIR/md5sum.py" stuff/maybelarge.dat
   1dd0b99ff80e19cff409702a1d3f5e15  stuff/maybelarge.dat
   $ cat .hglf/stuff/maybelarge.dat
   76236b6a2c6102826c61af4297dd738fb3b1de38
   $ cd ..
 
 "lfconvert" error cases
   $ hg lfconvert http://localhost/foo foo
   abort: http://localhost/foo is not a local Mercurial repo
   [255]
   $ hg lfconvert foo ssh://localhost/foo
   abort: ssh://localhost/foo is not a local Mercurial repo
   [255]
   $ hg lfconvert nosuchrepo foo
   abort: repository nosuchrepo not found!
   [255]
   $ hg share -q -U bigfile-repo shared
   $ printf 'bogus' > shared/.hg/sharedpath
   $ hg lfconvert shared foo
   abort: .hg/sharedpath points to nonexistent directory $TESTTMP/bogus! (glob)
   [255]
   $ hg lfconvert bigfile-repo largefiles-repo
   initializing destination largefiles-repo
   abort: repository largefiles-repo already exists!
   [255]
 
 add another largefile to the new largefiles repo
   $ cd largefiles-repo
   $ dd if=/dev/zero bs=1k count=1k > anotherlarge 2> /dev/null
   $ hg add --lfsize=1 anotherlarge
   $ hg commit -m "add anotherlarge (should be a largefile)"
   $ cat .hglf/anotherlarge
   3b71f43ff30f4b15b5cd85dd9e95ebc7e84eb5a3
   $ cd ..
 
 round-trip: converting back to a normal (non-largefiles) repo with
 "lfconvert --to-normal" should give the same as ../bigfile-repo
   $ cd largefiles-repo
   $ hg lfconvert --to-normal . ../normal-repo
   initializing destination ../normal-repo
   $ cd ../normal-repo
   $ cat >> .hg/hgrc <<EOF
   > [extensions]
   > largefiles = !
   > EOF
 
 # Hmmm: the changeset ID for rev 5 is different from the original
 # normal repo (../bigfile-repo), because the changelog filelist
 # differs between the two incarnations of rev 5: this repo includes
 # 'large' in the list, but ../bigfile-repo does not. Since rev 5
 # removes 'large' relative to the first parent in both repos, it seems
 # to me that lfconvert is doing a *better* job than
 # "hg remove" + "hg merge" + "hg commit".
 #  $ hg -R ../bigfile-repo debugdata -c 5
 #  $ hg debugdata -c 5
   $ hg glog --template "{rev}:{node|short}  {desc|firstline}\n"
   o  6:1635824e6f59  add anotherlarge (should be a largefile)
   |
   o    5:7215f8deeaaf  merge
   |\
   | o  4:7285f817b77e  remove large, normal3
   | |
   | o  3:67e3892e3534  add normal3, modify sub/*
   | |
   o |  2:c96c8beb5d56  rename sub/ to stuff/
   |/
   o  1:020c65d24e11  add sub/*
   |
   o  0:117b8328f97a  add large, normal1
   
   $ hg update
   4 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg locate
   anotherlarge
   normal1
   stuff/maybelarge.dat
   stuff/normal2
   $ [ -d .hg/largefiles ] && echo fail || echo pass
   pass
 
   $ cd ..
 
 Clearing the usercache ensures that commitctx doesn't try to cache largefiles
 from the working dir on a convert.
   $ rm "${USERCACHE}"/*
   $ hg convert largefiles-repo
   assuming destination largefiles-repo-hg
   initializing destination largefiles-repo-hg repository
   scanning source...
   sorting...
   converting...
   6 add large, normal1
   5 add sub/*
   4 rename sub/ to stuff/
   3 add normal3, modify sub/*
   2 remove large, normal3
   1 merge
   0 add anotherlarge (should be a largefile)
 
   $ hg -R largefiles-repo-hg glog --template "{rev}:{node|short}  {desc|firstline}\n"
   o  6:17126745edfd  add anotherlarge (should be a largefile)
   |
   o    5:9cc5aa7204f0  merge
   |\
   | o  4:a5a02de7a8e4  remove large, normal3
   | |
   | o  3:55759520c76f  add normal3, modify sub/*
   | |
   o |  2:261ad3f3f037  rename sub/ to stuff/
   |/
   o  1:334e5237836d  add sub/*
   |
   o  0:d4892ec57ce2  add large, normal1
   
 Verify will fail (for now) if the usercache is purged before converting, since
 largefiles are not cached in the converted repo's local store by the conversion
 process.
   $ hg -R largefiles-repo-hg verify --large --lfa
   checking changesets
   checking manifests
   crosschecking files in changesets and manifests
   checking files
   8 files, 7 changesets, 12 total revisions
   searching 7 changesets for largefiles
   changeset 0:d4892ec57ce2: large references missing $TESTTMP/largefiles-repo-hg/.hg/largefiles/2e000fa7e85759c7f4c254d4d9c33ef481e459a7 (glob)
   changeset 1:334e5237836d: sub/maybelarge.dat references missing $TESTTMP/largefiles-repo-hg/.hg/largefiles/34e163be8e43c5631d8b92e9c43ab0bf0fa62b9c (glob)
   changeset 2:261ad3f3f037: stuff/maybelarge.dat references missing $TESTTMP/largefiles-repo-hg/.hg/largefiles/34e163be8e43c5631d8b92e9c43ab0bf0fa62b9c (glob)
   changeset 3:55759520c76f: sub/maybelarge.dat references missing $TESTTMP/largefiles-repo-hg/.hg/largefiles/76236b6a2c6102826c61af4297dd738fb3b1de38 (glob)
   changeset 5:9cc5aa7204f0: stuff/maybelarge.dat references missing $TESTTMP/largefiles-repo-hg/.hg/largefiles/76236b6a2c6102826c61af4297dd738fb3b1de38 (glob)
   changeset 6:17126745edfd: anotherlarge references missing $TESTTMP/largefiles-repo-hg/.hg/largefiles/3b71f43ff30f4b15b5cd85dd9e95ebc7e84eb5a3 (glob)
   verified existence of 6 revisions of 4 largefiles
   [1]
   $ hg -R largefiles-repo-hg showconfig paths
 
 
 Avoid a traceback if a largefile isn't available (issue3519)
 
 Ensure the largefile can be cached in the source if necessary
   $ hg clone -U largefiles-repo issue3519
   $ rm -f "${USERCACHE}"/*
   $ hg lfconvert --to-normal issue3519 normalized3519
   initializing destination normalized3519
 
 Ensure the abort message is useful if a largefile is entirely unavailable
   $ rm -rf normalized3519
   $ rm "${USERCACHE}"/*
   $ rm issue3519/.hg/largefiles/*
   $ rm largefiles-repo/.hg/largefiles/*
   $ hg lfconvert --to-normal issue3519 normalized3519
   initializing destination normalized3519
-  large: largefile 2e000fa7e85759c7f4c254d4d9c33ef481e459a7 not available from file:$TESTTMP/largefiles-repo
+  large: largefile 2e000fa7e85759c7f4c254d4d9c33ef481e459a7 not available from file:$TESTTMP/largefiles-repo (glob)
   abort: missing largefile 'large' from revision d4892ec57ce212905215fad1d9018f56b99202ad
   [255]
 
 

tests/test-phases-exchange.t

@@ -1,1104 +1,1106 b''
   $ "$TESTDIR/hghave" killdaemons || exit 80
 
   $ cat >> $HGRCPATH <<EOF
   > [extensions]
   > graphlog=
   > EOF
   $ hgph() { hg log -G --template "{rev} {phase} {desc} - {node|short}\n" $*; }
 
   $ mkcommit() {
   >    echo "$1" > "$1"
   >    hg add "$1"
   >    message="$1"
   >    shift
   >    hg ci -m "$message" $*
   > }
 
   $ hg init alpha
   $ cd alpha
   $ mkcommit a-A
   $ mkcommit a-B
   $ mkcommit a-C
   $ mkcommit a-D
   $ hgph
   @  3 draft a-D - b555f63b6063
   |
   o  2 draft a-C - 54acac6f23ab
   |
   o  1 draft a-B - 548a3d25dbf0
   |
   o  0 draft a-A - 054250a37db4
   
 
   $ hg init ../beta
   $ hg push -r 1 ../beta
   pushing to ../beta
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 2 changesets with 2 changes to 2 files
   $ hgph
   @  3 draft a-D - b555f63b6063
   |
   o  2 draft a-C - 54acac6f23ab
   |
   o  1 public a-B - 548a3d25dbf0
   |
   o  0 public a-A - 054250a37db4
   
 
   $ cd ../beta
   $ hgph
   o  1 public a-B - 548a3d25dbf0
   |
   o  0 public a-A - 054250a37db4
   
   $ hg up -q
   $ mkcommit b-A
   $ hgph
   @  2 draft b-A - f54f1bb90ff3
   |
   o  1 public a-B - 548a3d25dbf0
   |
   o  0 public a-A - 054250a37db4
   
   $ hg pull ../alpha
   pulling from ../alpha
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 2 changesets with 2 changes to 2 files (+1 heads)
   (run 'hg heads' to see heads, 'hg merge' to merge)
   $ hgph
   o  4 public a-D - b555f63b6063
   |
   o  3 public a-C - 54acac6f23ab
   |
   | @  2 draft b-A - f54f1bb90ff3
   |/
   o  1 public a-B - 548a3d25dbf0
   |
   o  0 public a-A - 054250a37db4
   
 
 pull did not updated ../alpha state.
 push from alpha to beta should update phase even if nothing is transferred
 
   $ cd ../alpha
   $ hgph # not updated by remote pull
   @  3 draft a-D - b555f63b6063
   |
   o  2 draft a-C - 54acac6f23ab
   |
   o  1 public a-B - 548a3d25dbf0
   |
   o  0 public a-A - 054250a37db4
   
   $ hg push ../beta
   pushing to ../beta
   searching for changes
   no changes found
   [1]
   $ hgph
   @  3 public a-D - b555f63b6063
   |
   o  2 public a-C - 54acac6f23ab
   |
   o  1 public a-B - 548a3d25dbf0
   |
   o  0 public a-A - 054250a37db4
   
 
 update must update phase of common changeset too
 
   $ hg pull ../beta # getting b-A
   pulling from ../beta
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files (+1 heads)
   (run 'hg heads' to see heads, 'hg merge' to merge)
 
   $ cd ../beta
   $ hgph # not updated by remote pull
   o  4 public a-D - b555f63b6063
   |
   o  3 public a-C - 54acac6f23ab
   |
   | @  2 draft b-A - f54f1bb90ff3
   |/
   o  1 public a-B - 548a3d25dbf0
   |
   o  0 public a-A - 054250a37db4
   
   $ hg pull ../alpha
   pulling from ../alpha
   searching for changes
   no changes found
   $ hgph
   o  4 public a-D - b555f63b6063
   |
   o  3 public a-C - 54acac6f23ab
   |
   | @  2 public b-A - f54f1bb90ff3
   |/
   o  1 public a-B - 548a3d25dbf0
   |
   o  0 public a-A - 054250a37db4
   
 
 Publish configuration option
 ----------------------------
 
 Pull
 ````
 
 changegroup are added without phase movement
 
   $ hg bundle -a ../base.bundle
   5 changesets found
   $ cd ..
   $ hg init mu
   $ cd mu
   $ cat > .hg/hgrc << EOF
   > [phases]
   > publish=0
   > EOF
   $ hg unbundle ../base.bundle
   adding changesets
   adding manifests
   adding file changes
   added 5 changesets with 5 changes to 5 files (+1 heads)
   (run 'hg heads' to see heads, 'hg merge' to merge)
   $ hgph
   o  4 draft a-D - b555f63b6063
   |
   o  3 draft a-C - 54acac6f23ab
   |
   | o  2 draft b-A - f54f1bb90ff3
   |/
   o  1 draft a-B - 548a3d25dbf0
   |
   o  0 draft a-A - 054250a37db4
   
   $ cd ..
 
 Pulling from publish=False to publish=False does not move boundary.
 
   $ hg init nu
   $ cd nu
   $ cat > .hg/hgrc << EOF
   > [phases]
   > publish=0
   > EOF
   $ hg pull ../mu -r 54acac6f23ab
   pulling from ../mu
   adding changesets
   adding manifests
   adding file changes
   added 3 changesets with 3 changes to 3 files
   (run 'hg update' to get a working copy)
   $ hgph
   o  2 draft a-C - 54acac6f23ab
   |
   o  1 draft a-B - 548a3d25dbf0
   |
   o  0 draft a-A - 054250a37db4
   
 
 Even for common
 
   $ hg pull ../mu -r f54f1bb90ff3
   pulling from ../mu
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files (+1 heads)
   (run 'hg heads' to see heads, 'hg merge' to merge)
   $ hgph
   o  3 draft b-A - f54f1bb90ff3
   |
   | o  2 draft a-C - 54acac6f23ab
   |/
   o  1 draft a-B - 548a3d25dbf0
   |
   o  0 draft a-A - 054250a37db4
   
 
 
 Pulling from Publish=True to Publish=False move boundary in common set.
 we are in nu
 
   $ hg pull ../alpha -r b555f63b6063
   pulling from ../alpha
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
   (run 'hg update' to get a working copy)
   $ hgph # f54f1bb90ff3 stay draft, not ancestor of -r
   o  4 public a-D - b555f63b6063
   |
   | o  3 draft b-A - f54f1bb90ff3
   | |
   o |  2 public a-C - 54acac6f23ab
   |/
   o  1 public a-B - 548a3d25dbf0
   |
   o  0 public a-A - 054250a37db4
   
 
 pulling from Publish=False to publish=False with some public
 
   $ hg up -q f54f1bb90ff3
   $ mkcommit n-A
   $ mkcommit n-B
   $ hgph
   @  6 draft n-B - 145e75495359
   |
   o  5 draft n-A - d6bcb4f74035
   |
   | o  4 public a-D - b555f63b6063
   | |
   o |  3 draft b-A - f54f1bb90ff3
   | |
   | o  2 public a-C - 54acac6f23ab
   |/
   o  1 public a-B - 548a3d25dbf0
   |
   o  0 public a-A - 054250a37db4
   
   $ cd ../mu
   $ hg pull ../nu
   pulling from ../nu
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 2 changesets with 2 changes to 2 files
   (run 'hg update' to get a working copy)
   $ hgph
   o  6 draft n-B - 145e75495359
   |
   o  5 draft n-A - d6bcb4f74035
   |
   | o  4 public a-D - b555f63b6063
   | |
   | o  3 public a-C - 54acac6f23ab
   | |
   o |  2 draft b-A - f54f1bb90ff3
   |/
   o  1 public a-B - 548a3d25dbf0
   |
   o  0 public a-A - 054250a37db4
   
   $ cd ..
 
 pulling into publish=True
 
   $ cd alpha
   $ hgph
   o  4 public b-A - f54f1bb90ff3
   |
   | @  3 public a-D - b555f63b6063
   | |
   | o  2 public a-C - 54acac6f23ab
   |/
   o  1 public a-B - 548a3d25dbf0
   |
   o  0 public a-A - 054250a37db4
   
   $ hg pull ../mu
   pulling from ../mu
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 2 changesets with 2 changes to 2 files
   (run 'hg update' to get a working copy)
   $ hgph
   o  6 draft n-B - 145e75495359
   |
   o  5 draft n-A - d6bcb4f74035
   |
   o  4 public b-A - f54f1bb90ff3
   |
   | @  3 public a-D - b555f63b6063
   | |
   | o  2 public a-C - 54acac6f23ab
   |/
   o  1 public a-B - 548a3d25dbf0
   |
   o  0 public a-A - 054250a37db4
   
   $ cd ..
 
 pulling back into original repo
 
   $ cd nu
   $ hg pull ../alpha
   pulling from ../alpha
   searching for changes
   no changes found
   $ hgph
   @  6 public n-B - 145e75495359
   |
   o  5 public n-A - d6bcb4f74035
   |
   | o  4 public a-D - b555f63b6063
   | |
   o |  3 public b-A - f54f1bb90ff3
   | |
   | o  2 public a-C - 54acac6f23ab
   |/
   o  1 public a-B - 548a3d25dbf0
   |
   o  0 public a-A - 054250a37db4
   
 
 Push
 ````
 
 (inserted)
 
 Test that phase are pushed even when they are nothing to pus
 (this might be tested later bu are very convenient to not alter too much test)
 
 Push back to alpha
 
   $ hg push ../alpha # from nu
   pushing to ../alpha
   searching for changes
   no changes found
   [1]
   $ cd ..
   $ cd alpha
   $ hgph
   o  6 public n-B - 145e75495359
   |
   o  5 public n-A - d6bcb4f74035
   |
   o  4 public b-A - f54f1bb90ff3
   |
   | @  3 public a-D - b555f63b6063
   | |
   | o  2 public a-C - 54acac6f23ab
   |/
   o  1 public a-B - 548a3d25dbf0
   |
   o  0 public a-A - 054250a37db4
   
 
 (end insertion)
 
 
 initial setup
 
   $ hg glog # of alpha
   o  changeset:   6:145e75495359
   |  tag:         tip
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     n-B
   |
   o  changeset:   5:d6bcb4f74035
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     n-A
   |
   o  changeset:   4:f54f1bb90ff3
   |  parent:      1:548a3d25dbf0
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     b-A
   |
   | @  changeset:   3:b555f63b6063
   | |  user:        test
   | |  date:        Thu Jan 01 00:00:00 1970 +0000
   | |  summary:     a-D
   | |
   | o  changeset:   2:54acac6f23ab
   |/   user:        test
   |    date:        Thu Jan 01 00:00:00 1970 +0000
   |    summary:     a-C
   |
   o  changeset:   1:548a3d25dbf0
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     a-B
   |
   o  changeset:   0:054250a37db4
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     a-A
   
   $ mkcommit a-E
   $ mkcommit a-F
   $ mkcommit a-G
   $ hg up d6bcb4f74035 -q
   $ mkcommit a-H
   created new head
   $ hgph
   @  10 draft a-H - 967b449fbc94
   |
   | o  9 draft a-G - 3e27b6f1eee1
   | |
   | o  8 draft a-F - b740e3e5c05d
   | |
   | o  7 draft a-E - e9f537e46dea
   | |
   +---o  6 public n-B - 145e75495359
   | |
   o |  5 public n-A - d6bcb4f74035
   | |
   o |  4 public b-A - f54f1bb90ff3
   | |
   | o  3 public a-D - b555f63b6063
   | |
   | o  2 public a-C - 54acac6f23ab
   |/
   o  1 public a-B - 548a3d25dbf0
   |
   o  0 public a-A - 054250a37db4
   
 
 Pulling from bundle does not alter phases of changeset not present in the bundle
 
   $ hg bundle  --base 1 -r 6 -r 3 ../partial-bundle.hg
   5 changesets found
   $ hg pull ../partial-bundle.hg
   pulling from ../partial-bundle.hg
   searching for changes
   no changes found
   $ hgph
   @  10 draft a-H - 967b449fbc94
   |
   | o  9 draft a-G - 3e27b6f1eee1
   | |
   | o  8 draft a-F - b740e3e5c05d
   | |
   | o  7 draft a-E - e9f537e46dea
   | |
   +---o  6 public n-B - 145e75495359
   | |
   o |  5 public n-A - d6bcb4f74035
   | |
   o |  4 public b-A - f54f1bb90ff3
   | |
   | o  3 public a-D - b555f63b6063
   | |
   | o  2 public a-C - 54acac6f23ab
   |/
   o  1 public a-B - 548a3d25dbf0
   |
   o  0 public a-A - 054250a37db4
   
 
 Pushing to Publish=False (unknown changeset)
 
   $ hg push ../mu -r b740e3e5c05d # a-F
   pushing to ../mu
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 2 changesets with 2 changes to 2 files
   $ hgph
   @  10 draft a-H - 967b449fbc94
   |
   | o  9 draft a-G - 3e27b6f1eee1
   | |
   | o  8 draft a-F - b740e3e5c05d
   | |
   | o  7 draft a-E - e9f537e46dea
   | |
   +---o  6 public n-B - 145e75495359
   | |
   o |  5 public n-A - d6bcb4f74035
   | |
   o |  4 public b-A - f54f1bb90ff3
   | |
   | o  3 public a-D - b555f63b6063
   | |
   | o  2 public a-C - 54acac6f23ab
   |/
   o  1 public a-B - 548a3d25dbf0
   |
   o  0 public a-A - 054250a37db4
   
 
   $ cd ../mu
   $ hgph # again f54f1bb90ff3, d6bcb4f74035 and 145e75495359 stay draft,
   >      # not ancestor of -r
   o  8 draft a-F - b740e3e5c05d
   |
   o  7 draft a-E - e9f537e46dea
   |
   | o  6 draft n-B - 145e75495359
   | |
   | o  5 draft n-A - d6bcb4f74035
   | |
   o |  4 public a-D - b555f63b6063
   | |
   o |  3 public a-C - 54acac6f23ab
   | |
   | o  2 draft b-A - f54f1bb90ff3
   |/
   o  1 public a-B - 548a3d25dbf0
   |
   o  0 public a-A - 054250a37db4
   
 
 Pushing to Publish=True (unknown changeset)
 
   $ hg push ../beta -r b740e3e5c05d
   pushing to ../beta
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 2 changesets with 2 changes to 2 files
   $ hgph # again f54f1bb90ff3, d6bcb4f74035 and 145e75495359 stay draft,
   >      # not ancestor of -r
   o  8 public a-F - b740e3e5c05d
   |
   o  7 public a-E - e9f537e46dea
   |
   | o  6 draft n-B - 145e75495359
   | |
   | o  5 draft n-A - d6bcb4f74035
   | |
   o |  4 public a-D - b555f63b6063
   | |
   o |  3 public a-C - 54acac6f23ab
   | |
   | o  2 draft b-A - f54f1bb90ff3
   |/
   o  1 public a-B - 548a3d25dbf0
   |
   o  0 public a-A - 054250a37db4
   
 
 Pushing to Publish=True (common changeset)
 
   $ cd ../beta
   $ hg push ../alpha
   pushing to ../alpha
   searching for changes
   no changes found
   [1]
   $ hgph
   o  6 public a-F - b740e3e5c05d
   |
   o  5 public a-E - e9f537e46dea
   |
   o  4 public a-D - b555f63b6063
   |
   o  3 public a-C - 54acac6f23ab
   |
   | @  2 public b-A - f54f1bb90ff3
   |/
   o  1 public a-B - 548a3d25dbf0
   |
   o  0 public a-A - 054250a37db4
   
   $ cd ../alpha
   $ hgph
   @  10 draft a-H - 967b449fbc94
   |
   | o  9 draft a-G - 3e27b6f1eee1
   | |
   | o  8 public a-F - b740e3e5c05d
   | |
   | o  7 public a-E - e9f537e46dea
   | |
   +---o  6 public n-B - 145e75495359
   | |
   o |  5 public n-A - d6bcb4f74035
   | |
   o |  4 public b-A - f54f1bb90ff3
   | |
   | o  3 public a-D - b555f63b6063
   | |
   | o  2 public a-C - 54acac6f23ab
   |/
   o  1 public a-B - 548a3d25dbf0
   |
   o  0 public a-A - 054250a37db4
   
 
 Pushing to Publish=False (common changeset that change phase + unknown one)
 
   $ hg push ../mu -r 967b449fbc94 -f
   pushing to ../mu
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files (+1 heads)
   $ hgph
   @  10 draft a-H - 967b449fbc94
   |
   | o  9 draft a-G - 3e27b6f1eee1
   | |
   | o  8 public a-F - b740e3e5c05d
   | |
   | o  7 public a-E - e9f537e46dea
   | |
   +---o  6 public n-B - 145e75495359
   | |
   o |  5 public n-A - d6bcb4f74035
   | |
   o |  4 public b-A - f54f1bb90ff3
   | |
   | o  3 public a-D - b555f63b6063
   | |
   | o  2 public a-C - 54acac6f23ab
   |/
   o  1 public a-B - 548a3d25dbf0
   |
   o  0 public a-A - 054250a37db4
   
   $ cd ../mu
   $ hgph # d6bcb4f74035 should have changed phase
   >      # 145e75495359 is still draft. not ancestor of -r
   o  9 draft a-H - 967b449fbc94
   |
   | o  8 public a-F - b740e3e5c05d
   | |
   | o  7 public a-E - e9f537e46dea
   | |
   +---o  6 draft n-B - 145e75495359
   | |
   o |  5 public n-A - d6bcb4f74035
   | |
   | o  4 public a-D - b555f63b6063
   | |
   | o  3 public a-C - 54acac6f23ab
   | |
   o |  2 public b-A - f54f1bb90ff3
   |/
   o  1 public a-B - 548a3d25dbf0
   |
   o  0 public a-A - 054250a37db4
   
 
 
 Pushing to Publish=True (common changeset from publish=False)
 
 (in mu)
   $ hg push ../alpha
   pushing to ../alpha
   searching for changes
   no changes found
   [1]
   $ hgph
   o  9 public a-H - 967b449fbc94
   |
   | o  8 public a-F - b740e3e5c05d
   | |
   | o  7 public a-E - e9f537e46dea
   | |
   +---o  6 public n-B - 145e75495359
   | |
   o |  5 public n-A - d6bcb4f74035
   | |
   | o  4 public a-D - b555f63b6063
   | |
   | o  3 public a-C - 54acac6f23ab
   | |
   o |  2 public b-A - f54f1bb90ff3
   |/
   o  1 public a-B - 548a3d25dbf0
   |
   o  0 public a-A - 054250a37db4
   
   $ hgph -R ../alpha # a-H should have been synced to 0
   @  10 public a-H - 967b449fbc94
   |
   | o  9 draft a-G - 3e27b6f1eee1
   | |
   | o  8 public a-F - b740e3e5c05d
   | |
   | o  7 public a-E - e9f537e46dea
   | |
   +---o  6 public n-B - 145e75495359
   | |
   o |  5 public n-A - d6bcb4f74035
   | |
   o |  4 public b-A - f54f1bb90ff3
   | |
   | o  3 public a-D - b555f63b6063
   | |
   | o  2 public a-C - 54acac6f23ab
   |/
   o  1 public a-B - 548a3d25dbf0
   |
   o  0 public a-A - 054250a37db4
   
 
 
 Discovery locally secret changeset on a remote repository:
 
 - should make it non-secret
 
   $ cd ../alpha
   $ mkcommit A-secret --config phases.new-commit=2
   $ hgph
   @  11 secret A-secret - 435b5d83910c
   |
   o  10 public a-H - 967b449fbc94
   |
   | o  9 draft a-G - 3e27b6f1eee1
   | |
   | o  8 public a-F - b740e3e5c05d
   | |
   | o  7 public a-E - e9f537e46dea
   | |
   +---o  6 public n-B - 145e75495359
   | |
   o |  5 public n-A - d6bcb4f74035
   | |
   o |  4 public b-A - f54f1bb90ff3
   | |
   | o  3 public a-D - b555f63b6063
   | |
   | o  2 public a-C - 54acac6f23ab
   |/
   o  1 public a-B - 548a3d25dbf0
   |
   o  0 public a-A - 054250a37db4
   
   $ hg bundle --base 'parents(.)' -r . ../secret-bundle.hg
   1 changesets found
   $ hg -R ../mu unbundle ../secret-bundle.hg
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
   (run 'hg update' to get a working copy)
   $ hgph -R ../mu
   o  10 draft A-secret - 435b5d83910c
   |
   o  9 public a-H - 967b449fbc94
   |
   | o  8 public a-F - b740e3e5c05d
   | |
   | o  7 public a-E - e9f537e46dea
   | |
   +---o  6 public n-B - 145e75495359
   | |
   o |  5 public n-A - d6bcb4f74035
   | |
   | o  4 public a-D - b555f63b6063
   | |
   | o  3 public a-C - 54acac6f23ab
   | |
   o |  2 public b-A - f54f1bb90ff3
   |/
   o  1 public a-B - 548a3d25dbf0
   |
   o  0 public a-A - 054250a37db4
   
   $ hg pull ../mu
   pulling from ../mu
   searching for changes
   no changes found
   $ hgph
   @  11 draft A-secret - 435b5d83910c
   |
   o  10 public a-H - 967b449fbc94
   |
   | o  9 draft a-G - 3e27b6f1eee1
   | |
   | o  8 public a-F - b740e3e5c05d
   | |
   | o  7 public a-E - e9f537e46dea
   | |
   +---o  6 public n-B - 145e75495359
   | |
   o |  5 public n-A - d6bcb4f74035
   | |
   o |  4 public b-A - f54f1bb90ff3
   | |
   | o  3 public a-D - b555f63b6063
   | |
   | o  2 public a-C - 54acac6f23ab
   |/
   o  1 public a-B - 548a3d25dbf0
   |
   o  0 public a-A - 054250a37db4
   
 
 pushing a locally public and draft changesets remotly secret should make them
 appear on the remote side.
 
 
   $ hg -R ../mu phase --secret --force 967b449fbc94
   $ hg push -r 435b5d83910c ../mu
   pushing to ../mu
   searching for changes
   abort: push creates new remote head 435b5d83910c!
   (did you forget to merge? use push -f to force)
   [255]
   $ hg push -fr 435b5d83910c ../mu # because the push will create new visible head
   pushing to ../mu
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 0 changesets with 0 changes to 2 files
   $ hgph -R ../mu
   o  10 draft A-secret - 435b5d83910c
   |
   o  9 public a-H - 967b449fbc94
   |
   | o  8 public a-F - b740e3e5c05d
   | |
   | o  7 public a-E - e9f537e46dea
   | |
   +---o  6 public n-B - 145e75495359
   | |
   o |  5 public n-A - d6bcb4f74035
   | |
   | o  4 public a-D - b555f63b6063
   | |
   | o  3 public a-C - 54acac6f23ab
   | |
   o |  2 public b-A - f54f1bb90ff3
   |/
   o  1 public a-B - 548a3d25dbf0
   |
   o  0 public a-A - 054250a37db4
   
 
 pull new changeset with common draft locally
 
   $ hg up -q 967b449fbc94 # create a new root for draft
   $ mkcommit 'alpha-more'
   created new head
   $ hg push -fr . ../mu
   pushing to ../mu
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files (+1 heads)
   $ cd ../mu
   $ hg phase --secret --force 1c5cfd894796
   $ hg up -q 435b5d83910c
   $ mkcommit 'mu-more'
   $ cd ../alpha
   $ hg pull ../mu
   pulling from ../mu
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
   (run 'hg update' to get a working copy)
   $ hgph
   o  13 draft mu-more - 5237fb433fc8
   |
   | @  12 draft alpha-more - 1c5cfd894796
   | |
   o |  11 draft A-secret - 435b5d83910c
   |/
   o  10 public a-H - 967b449fbc94
   |
   | o  9 draft a-G - 3e27b6f1eee1
   | |
   | o  8 public a-F - b740e3e5c05d
   | |
   | o  7 public a-E - e9f537e46dea
   | |
   +---o  6 public n-B - 145e75495359
   | |
   o |  5 public n-A - d6bcb4f74035
   | |
   o |  4 public b-A - f54f1bb90ff3
   | |
   | o  3 public a-D - b555f63b6063
   | |
   | o  2 public a-C - 54acac6f23ab
   |/
   o  1 public a-B - 548a3d25dbf0
   |
   o  0 public a-A - 054250a37db4
   
 
 Test that test are properly ignored on remote event when existing locally
 
   $ cd ..
   $ hg clone -qU -r b555f63b6063 -r f54f1bb90ff3 beta gamma
 
 # pathological case are
 #
 # * secret remotely
 # * known locally
 # * repo have uncommon changeset
 
   $ hg -R beta phase --secret --force f54f1bb90ff3
   $ hg -R gamma phase --draft --force f54f1bb90ff3
 
   $ cd gamma
   $ hg pull ../beta
   pulling from ../beta
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 2 changesets with 2 changes to 2 files
   (run 'hg update' to get a working copy)
   $ hg phase f54f1bb90ff3
   2: draft
 
 same over the wire
 
   $ cd ../beta
   $ hg serve -p $HGPORT -d --pid-file=../beta.pid -E ../beta-error.log
   $ cat ../beta.pid >> $DAEMON_PIDS
   $ cd ../gamma
 
   $ hg pull http://localhost:$HGPORT/
   pulling from http://localhost:$HGPORT/
   searching for changes
   no changes found
   $ hg phase f54f1bb90ff3
   2: draft
 
 check that secret local on both side are not synced to public
 
   $ hg push -r b555f63b6063 http://localhost:$HGPORT/
   pushing to http://localhost:$HGPORT/
   searching for changes
   no changes found
   [1]
   $ hg phase f54f1bb90ff3
   2: draft
 
 put the changeset in the draft state again
 (first test after this one expect to be able to copy)
 
   $ cd ..
 
 
 Test Clone behavior
 
 A. Clone without secret changeset
 
 1.  cloning non-publishing repository
 (Phase should be preserved)
 
 # make sure there is no secret so we can use a copy clone
 
   $ hg -R mu phase --draft 'secret()'
 
   $ hg clone -U mu Tau
   $ hgph -R Tau
   o  12 draft mu-more - 5237fb433fc8
   |
   | o  11 draft alpha-more - 1c5cfd894796
   | |
   o |  10 draft A-secret - 435b5d83910c
   |/
   o  9 public a-H - 967b449fbc94
   |
   | o  8 public a-F - b740e3e5c05d
   | |
   | o  7 public a-E - e9f537e46dea
   | |
   +---o  6 public n-B - 145e75495359
   | |
   o |  5 public n-A - d6bcb4f74035
   | |
   | o  4 public a-D - b555f63b6063
   | |
   | o  3 public a-C - 54acac6f23ab
   | |
   o |  2 public b-A - f54f1bb90ff3
   |/
   o  1 public a-B - 548a3d25dbf0
   |
   o  0 public a-A - 054250a37db4
   
 
 2. cloning publishing repository
 
 (everything should be public)
 
   $ hg clone -U alpha Upsilon
   $ hgph -R Upsilon
   o  13 public mu-more - 5237fb433fc8
   |
   | o  12 public alpha-more - 1c5cfd894796
   | |
   o |  11 public A-secret - 435b5d83910c
   |/
   o  10 public a-H - 967b449fbc94
   |
   | o  9 public a-G - 3e27b6f1eee1
   | |
   | o  8 public a-F - b740e3e5c05d
   | |
   | o  7 public a-E - e9f537e46dea
   | |
   +---o  6 public n-B - 145e75495359
   | |
   o |  5 public n-A - d6bcb4f74035
   | |
   o |  4 public b-A - f54f1bb90ff3
   | |
   | o  3 public a-D - b555f63b6063
   | |
   | o  2 public a-C - 54acac6f23ab
   |/
   o  1 public a-B - 548a3d25dbf0
   |
   o  0 public a-A - 054250a37db4
   
+#if unix-permissions
 
 Pushing From an unlockable repo
 --------------------------------
 (issue3684)
 
 Unability to lock the source repo should not prevent the push. It will prevent
 the retrieval of remote phase during push. For example, pushing to a publishing
 server won't turn changeset public.
 
 1. Test that push is not prevented
 
   $ hg init Phi
   $ cd Upsilon
   $ chmod -R -w .hg
   $ hg push ../Phi
   pushing to ../Phi
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 14 changesets with 14 changes to 14 files (+3 heads)
   $ chmod -R +w .hg
 
 2. Test that failed phases movement are reported
 
   $ hg phase --force --draft 3
   $ chmod -R -w .hg
   $ hg push ../Phi
   pushing to ../Phi
   searching for changes
   no changes found
   cannot lock source repo, skipping local public phase update
   [1]
   $ chmod -R +w .hg
   $ hgph Upsilon
 
   $ cd ..
 
   $ "$TESTDIR/killdaemons.py" $DAEMON_PIDS
 
+#endif

tests/test-subrepo.t

@@ -1,1216 +1,1216 b''
 Let commit recurse into subrepos by default to match pre-2.0 behavior:
 
   $ echo "[ui]" >> $HGRCPATH
   $ echo "commitsubrepos = Yes" >> $HGRCPATH
 
   $ hg init t
   $ cd t
 
 first revision, no sub
 
   $ echo a > a
   $ hg ci -Am0
   adding a
 
 add first sub
 
   $ echo s = s > .hgsub
   $ hg add .hgsub
   $ hg init s
   $ echo a > s/a
 
 Issue2232: committing a subrepo without .hgsub
 
   $ hg ci -mbad s
   abort: can't commit subrepos without .hgsub
   [255]
 
   $ hg -R s ci -Ams0
   adding a
   $ hg sum
   parent: 0:f7b1eb17ad24 tip
    0
   branch: default
   commit: 1 added, 1 subrepos
   update: (current)
   $ hg ci -m1
 
 Revert subrepo and test subrepo fileset keyword:
 
   $ echo b > s/a
   $ hg revert "set:subrepo('glob:s*')"
   reverting subrepo s
   reverting s/a (glob)
   $ rm s/a.orig
 
 Revert subrepo with no backup. The "reverting s/a" line is gone since
 we're really running 'hg update' in the subrepo:
 
   $ echo b > s/a
   $ hg revert --no-backup s
   reverting subrepo s
 
 Issue2022: update -C
 
   $ echo b > s/a
   $ hg sum
   parent: 1:7cf8cfea66e4 tip
    1
   branch: default
   commit: 1 subrepos
   update: (current)
   $ hg co -C 1
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg sum
   parent: 1:7cf8cfea66e4 tip
    1
   branch: default
   commit: (clean)
   update: (current)
 
 commands that require a clean repo should respect subrepos
 
   $ echo b >> s/a
   $ hg backout tip
   abort: uncommitted changes in subrepo s
   [255]
   $ hg revert -C -R s s/a
 
 add sub sub
 
   $ echo ss = ss > s/.hgsub
   $ hg init s/ss
   $ echo a > s/ss/a
   $ hg -R s add s/.hgsub
   $ hg -R s/ss add s/ss/a
   $ hg sum
   parent: 1:7cf8cfea66e4 tip
    1
   branch: default
   commit: 1 subrepos
   update: (current)
   $ hg ci -m2
   committing subrepository s
   committing subrepository s/ss (glob)
   $ hg sum
   parent: 2:df30734270ae tip
    2
   branch: default
   commit: (clean)
   update: (current)
 
 bump sub rev (and check it is ignored by ui.commitsubrepos)
 
   $ echo b > s/a
   $ hg -R s ci -ms1
   $ hg --config ui.commitsubrepos=no ci -m3
 
 leave sub dirty (and check ui.commitsubrepos=no aborts the commit)
 
   $ echo c > s/a
   $ hg --config ui.commitsubrepos=no ci -m4
   abort: uncommitted changes in subrepo s
   (use --subrepos for recursive commit)
   [255]
   $ hg id
   f6affe3fbfaa+ tip
   $ hg -R s ci -mc
   $ hg id
   f6affe3fbfaa+ tip
   $ echo d > s/a
   $ hg ci -m4
   committing subrepository s
   $ hg tip -R s
   changeset:   4:02dcf1d70411
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     4
   
 
 check caching
 
   $ hg co 0
   0 files updated, 0 files merged, 2 files removed, 0 files unresolved
   $ hg debugsub
 
 restore
 
   $ hg co
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg debugsub
   path s
    source   s
    revision 02dcf1d704118aee3ee306ccfa1910850d5b05ef
 
 new branch for merge tests
 
   $ hg co 1
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo t = t >> .hgsub
   $ hg init t
   $ echo t > t/t
   $ hg -R t add t
   adding t/t (glob)
 
 5
 
   $ hg ci -m5 # add sub
   committing subrepository t
   created new head
   $ echo t2 > t/t
 
 6
 
   $ hg st -R s
   $ hg ci -m6 # change sub
   committing subrepository t
   $ hg debugsub
   path s
    source   s
    revision e4ece1bf43360ddc8f6a96432201a37b7cd27ae4
   path t
    source   t
    revision 6747d179aa9a688023c4b0cad32e4c92bb7f34ad
   $ echo t3 > t/t
 
 7
 
   $ hg ci -m7 # change sub again for conflict test
   committing subrepository t
   $ hg rm .hgsub
 
 8
 
   $ hg ci -m8 # remove sub
 
 merge tests
 
   $ hg co -C 3
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg merge 5 # test adding
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg debugsub
   path s
    source   s
    revision fc627a69481fcbe5f1135069e8a3881c023e4cf5
   path t
    source   t
    revision 60ca1237c19474e7a3978b0dc1ca4e6f36d51382
   $ hg ci -m9
   created new head
   $ hg merge 6 --debug # test change
     searching for copies back to rev 2
   resolving manifests
    branchmerge: True, force: False, partial: False
    ancestor: 1f14a2e2d3ec, local: f0d2028bf86d+, remote: 1831e14459c4
    .hgsubstate: versions differ -> m
   updating: .hgsubstate 1/1 files (100.00%)
   subrepo merge f0d2028bf86d+ 1831e14459c4 1f14a2e2d3ec
     subrepo t: other changed, get t:6747d179aa9a688023c4b0cad32e4c92bb7f34ad:hg
   getting subrepo t
   resolving manifests
    branchmerge: False, force: False, partial: False
    ancestor: 60ca1237c194, local: 60ca1237c194+, remote: 6747d179aa9a
    t: remote is newer -> g
   getting t
   updating: t 1/1 files (100.00%)
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg debugsub
   path s
    source   s
    revision fc627a69481fcbe5f1135069e8a3881c023e4cf5
   path t
    source   t
    revision 6747d179aa9a688023c4b0cad32e4c92bb7f34ad
   $ echo conflict > t/t
   $ hg ci -m10
   committing subrepository t
   $ HGMERGE=internal:merge hg merge --debug 7 # test conflict
     searching for copies back to rev 2
   resolving manifests
    branchmerge: True, force: False, partial: False
    ancestor: 1831e14459c4, local: e45c8b14af55+, remote: f94576341bcf
    .hgsubstate: versions differ -> m
   updating: .hgsubstate 1/1 files (100.00%)
   subrepo merge e45c8b14af55+ f94576341bcf 1831e14459c4
     subrepo t: both sides changed, merge with t:7af322bc1198a32402fe903e0b7ebcfc5c9bf8f4:hg
   merging subrepo t
     searching for copies back to rev 2
   resolving manifests
    branchmerge: True, force: False, partial: False
    ancestor: 6747d179aa9a, local: 20a0db6fbf6c+, remote: 7af322bc1198
    t: versions differ -> m
     preserving t for resolve of t
   updating: t 1/1 files (100.00%)
   picked tool 'internal:merge' for t (binary False symlink False)
   merging t
   my t@20a0db6fbf6c+ other t@7af322bc1198 ancestor t@6747d179aa9a
   warning: conflicts during merge.
   merging t incomplete! (edit conflicts, then use 'hg resolve --mark')
   0 files updated, 0 files merged, 0 files removed, 1 files unresolved
   use 'hg resolve' to retry unresolved file merges or 'hg update -C .' to abandon
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
 
 should conflict
 
   $ cat t/t
   <<<<<<< local
   conflict
   =======
   t3
   >>>>>>> other
 
 clone
 
   $ cd ..
   $ hg clone t tc
   updating to branch default
   cloning subrepo s from $TESTTMP/t/s
   cloning subrepo s/ss from $TESTTMP/t/s/ss (glob)
   cloning subrepo t from $TESTTMP/t/t
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd tc
   $ hg debugsub
   path s
    source   s
    revision fc627a69481fcbe5f1135069e8a3881c023e4cf5
   path t
    source   t
    revision 20a0db6fbf6c3d2836e6519a642ae929bfc67c0e
 
 push
 
   $ echo bah > t/t
   $ hg ci -m11
   committing subrepository t
   $ hg push
   pushing to $TESTTMP/t (glob)
-  no changes made to subrepo s/ss since last push to $TESTTMP/t/s/ss
+  no changes made to subrepo s/ss since last push to $TESTTMP/t/s/ss (glob)
   no changes made to subrepo s since last push to $TESTTMP/t/s
   pushing subrepo t to $TESTTMP/t/t
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
 
 push -f
 
   $ echo bah > s/a
   $ hg ci -m12
   committing subrepository s
   $ hg push
   pushing to $TESTTMP/t (glob)
-  no changes made to subrepo s/ss since last push to $TESTTMP/t/s/ss
+  no changes made to subrepo s/ss since last push to $TESTTMP/t/s/ss (glob)
   pushing subrepo s to $TESTTMP/t/s
   searching for changes
   abort: push creates new remote head 12a213df6fa9! (in subrepo s)
   (did you forget to merge? use push -f to force)
   [255]
   $ hg push -f
   pushing to $TESTTMP/t (glob)
   pushing subrepo s/ss to $TESTTMP/t/s/ss (glob)
   searching for changes
   no changes found
   pushing subrepo s to $TESTTMP/t/s
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files (+1 heads)
   pushing subrepo t to $TESTTMP/t/t
   searching for changes
   no changes found
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
 
 check that unmodified subrepos are not pushed
 
   $ hg clone . ../tcc
   updating to branch default
   cloning subrepo s from $TESTTMP/tc/s
-  cloning subrepo s/ss from $TESTTMP/tc/s/ss
+  cloning subrepo s/ss from $TESTTMP/tc/s/ss (glob)
   cloning subrepo t from $TESTTMP/tc/t
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 the subrepos on the new clone have nothing to push to its source
 
   $ hg push -R ../tcc .
   pushing to .
-  no changes made to subrepo s/ss since last push to s/ss
+  no changes made to subrepo s/ss since last push to s/ss (glob)
   no changes made to subrepo s since last push to s
   no changes made to subrepo t since last push to t
   searching for changes
   no changes found
   [1]
 
 the subrepos on the source do not have a clean store versus the clone target
 because they were never explicitly pushed to the source
 
   $ hg push ../tcc
   pushing to ../tcc
-  pushing subrepo s/ss to ../tcc/s/ss
+  pushing subrepo s/ss to ../tcc/s/ss (glob)
   searching for changes
   no changes found
   pushing subrepo s to ../tcc/s
   searching for changes
   no changes found
   pushing subrepo t to ../tcc/t
   searching for changes
   no changes found
   searching for changes
   no changes found
   [1]
 
 after push their stores become clean
 
   $ hg push ../tcc
   pushing to ../tcc
-  no changes made to subrepo s/ss since last push to ../tcc/s/ss
+  no changes made to subrepo s/ss since last push to ../tcc/s/ss (glob)
   no changes made to subrepo s since last push to ../tcc/s
   no changes made to subrepo t since last push to ../tcc/t
   searching for changes
   no changes found
   [1]
 
 updating a subrepo to a different revision or changing
 its working directory does not make its store dirty
 
   $ hg -R s update '.^'
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg push
   pushing to $TESTTMP/t
-  no changes made to subrepo s/ss since last push to $TESTTMP/t/s/ss
+  no changes made to subrepo s/ss since last push to $TESTTMP/t/s/ss (glob)
   no changes made to subrepo s since last push to $TESTTMP/t/s
   no changes made to subrepo t since last push to $TESTTMP/t/t
   searching for changes
   no changes found
   [1]
   $ echo foo >> s/a
   $ hg push
   pushing to $TESTTMP/t
-  no changes made to subrepo s/ss since last push to $TESTTMP/t/s/ss
+  no changes made to subrepo s/ss since last push to $TESTTMP/t/s/ss (glob)
   no changes made to subrepo s since last push to $TESTTMP/t/s
   no changes made to subrepo t since last push to $TESTTMP/t/t
   searching for changes
   no changes found
   [1]
   $ hg -R s update -C tip
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 committing into a subrepo makes its store (but not its parent's store) dirty
 
   $ echo foo >> s/ss/a
   $ hg -R s/ss commit -m 'test dirty store detection'
   $ hg push
   pushing to $TESTTMP/t
-  pushing subrepo s/ss to $TESTTMP/t/s/ss
+  pushing subrepo s/ss to $TESTTMP/t/s/ss (glob)
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
   no changes made to subrepo s since last push to $TESTTMP/t/s
   no changes made to subrepo t since last push to $TESTTMP/t/t
   searching for changes
   no changes found
   [1]
 
 a subrepo store may be clean versus one repo but not versus another
 
   $ hg push
   pushing to $TESTTMP/t
-  no changes made to subrepo s/ss since last push to $TESTTMP/t/s/ss
+  no changes made to subrepo s/ss since last push to $TESTTMP/t/s/ss (glob)
   no changes made to subrepo s since last push to $TESTTMP/t/s
   no changes made to subrepo t since last push to $TESTTMP/t/t
   searching for changes
   no changes found
   [1]
   $ hg push ../tcc
   pushing to ../tcc
   pushing subrepo s/ss to ../tcc/s/ss
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
   no changes made to subrepo s since last push to ../tcc/s
   no changes made to subrepo t since last push to ../tcc/t
   searching for changes
   no changes found
   [1]
 
 update
 
   $ cd ../t
   $ hg up -C # discard our earlier merge
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo blah > t/t
   $ hg ci -m13
   committing subrepository t
 
 backout calls revert internally with minimal opts, which should not raise
 KeyError
 
   $ hg backout ".^"
   reverting .hgsubstate
   reverting subrepo s
-  reverting s/a
+  reverting s/a (glob)
   reverting subrepo ss
   reverting subrepo t
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
   $ hg up -C # discard changes
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 pull
 
   $ cd ../tc
   $ hg pull
   pulling from $TESTTMP/t (glob)
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
   (run 'hg update' to get a working copy)
 
 should pull t
 
   $ hg up
   pulling subrepo t from $TESTTMP/t/t
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cat t/t
   blah
 
 bogus subrepo path aborts
 
   $ echo 'bogus=[boguspath' >> .hgsub
   $ hg ci -m 'bogus subrepo path'
   abort: missing ] in subrepo source
   [255]
 
 Issue1986: merge aborts when trying to merge a subrepo that
 shouldn't need merging
 
 # subrepo layout
 #
 #   o   5 br
 #  /|
 # o |   4 default
 # | |
 # | o   3 br
 # |/|
 # o |   2 default
 # | |
 # | o   1 br
 # |/
 # o     0 default
 
   $ cd ..
   $ rm -rf sub
   $ hg init main
   $ cd main
   $ hg init s
   $ cd s
   $ echo a > a
   $ hg ci -Am1
   adding a
   $ hg branch br
   marked working directory as branch br
   (branches are permanent and global, did you want a bookmark?)
   $ echo a >> a
   $ hg ci -m1
   $ hg up default
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo b > b
   $ hg ci -Am1
   adding b
   $ hg up br
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg merge tip
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg ci -m1
   $ hg up 2
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo c > c
   $ hg ci -Am1
   adding c
   $ hg up 3
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg merge 4
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg ci -m1
 
 # main repo layout:
 #
 #   * <-- try to merge default into br again
 # .`|
 # . o   5 br      --> substate = 5
 # . |
 # o |   4 default --> substate = 4
 # | |
 # | o   3 br      --> substate = 2
 # |/|
 # o |   2 default --> substate = 2
 # | |
 # | o   1 br      --> substate = 3
 # |/
 # o     0 default --> substate = 2
 
   $ cd ..
   $ echo 's = s' > .hgsub
   $ hg -R s up 2
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg ci -Am1
   adding .hgsub
   $ hg branch br
   marked working directory as branch br
   (branches are permanent and global, did you want a bookmark?)
   $ echo b > b
   $ hg -R s up 3
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg ci -Am1
   adding b
   $ hg up default
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ echo c > c
   $ hg ci -Am1
   adding c
   $ hg up 1
   2 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg merge 2
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg ci -m1
   $ hg up 2
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg -R s up 4
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo d > d
   $ hg ci -Am1
   adding d
   $ hg up 3
   2 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg -R s up 5
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo e > e
   $ hg ci -Am1
   adding e
 
   $ hg up 5
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg merge 4    # try to merge default into br again
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ cd ..
 
 test subrepo delete from .hgsubstate
 
   $ hg init testdelete
   $ mkdir testdelete/nested testdelete/nested2
   $ hg init testdelete/nested
   $ hg init testdelete/nested2
   $ echo test > testdelete/nested/foo
   $ echo test > testdelete/nested2/foo
   $ hg -R testdelete/nested add
   adding testdelete/nested/foo (glob)
   $ hg -R testdelete/nested2 add
   adding testdelete/nested2/foo (glob)
   $ hg -R testdelete/nested ci -m test
   $ hg -R testdelete/nested2 ci -m test
   $ echo nested = nested > testdelete/.hgsub
   $ echo nested2 = nested2 >> testdelete/.hgsub
   $ hg -R testdelete add
   adding testdelete/.hgsub (glob)
   $ hg -R testdelete ci -m "nested 1 & 2 added"
   $ echo nested = nested > testdelete/.hgsub
   $ hg -R testdelete ci -m "nested 2 deleted"
   $ cat testdelete/.hgsubstate
   bdf5c9a3103743d900b12ae0db3ffdcfd7b0d878 nested
   $ hg -R testdelete remove testdelete/.hgsub
   $ hg -R testdelete ci -m ".hgsub deleted"
   $ cat testdelete/.hgsubstate
   bdf5c9a3103743d900b12ae0db3ffdcfd7b0d878 nested
 
 test repository cloning
 
   $ mkdir mercurial mercurial2
   $ hg init nested_absolute
   $ echo test > nested_absolute/foo
   $ hg -R nested_absolute add
   adding nested_absolute/foo (glob)
   $ hg -R nested_absolute ci -mtest
   $ cd mercurial
   $ hg init nested_relative
   $ echo test2 > nested_relative/foo2
   $ hg -R nested_relative add
   adding nested_relative/foo2 (glob)
   $ hg -R nested_relative ci -mtest2
   $ hg init main
   $ echo "nested_relative = ../nested_relative" > main/.hgsub
   $ echo "nested_absolute = `pwd`/nested_absolute" >> main/.hgsub
   $ hg -R main add
   adding main/.hgsub (glob)
   $ hg -R main ci -m "add subrepos"
   $ cd ..
   $ hg clone mercurial/main mercurial2/main
   updating to branch default
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cat mercurial2/main/nested_absolute/.hg/hgrc \
   >     mercurial2/main/nested_relative/.hg/hgrc
   [paths]
   default = $TESTTMP/mercurial/nested_absolute
   [paths]
   default = $TESTTMP/mercurial/nested_relative
   $ rm -rf mercurial mercurial2
 
 Issue1977: multirepo push should fail if subrepo push fails
 
   $ hg init repo
   $ hg init repo/s
   $ echo a > repo/s/a
   $ hg -R repo/s ci -Am0
   adding a
   $ echo s = s > repo/.hgsub
   $ hg -R repo ci -Am1
   adding .hgsub
   $ hg clone repo repo2
   updating to branch default
   cloning subrepo s from $TESTTMP/repo/s
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg -q -R repo2 pull -u
   $ echo 1 > repo2/s/a
   $ hg -R repo2/s ci -m2
   $ hg -q -R repo2/s push
   $ hg -R repo2/s up -C 0
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo 2 > repo2/s/b
   $ hg -R repo2/s ci -m3 -A
   adding b
   created new head
   $ hg -R repo2 ci -m3
   $ hg -q -R repo2 push
   abort: push creates new remote head cc505f09a8b2! (in subrepo s)
   (did you forget to merge? use push -f to force)
   [255]
   $ hg -R repo update
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 test if untracked file is not overwritten
 
   $ echo issue3276_ok > repo/s/b
   $ hg -R repo2 push -f -q
   $ hg -R repo update
   b: untracked file differs
   abort: untracked files in working directory differ from files in requested revision (in subrepo s)
   [255]
 
   $ cat repo/s/b
   issue3276_ok
   $ rm repo/s/b
   $ hg -R repo revert --all
   reverting repo/.hgsubstate (glob)
   reverting subrepo s
   $ hg -R repo update
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cat repo/s/b
   2
   $ rm -rf repo2 repo
 
 
 Issue1852 subrepos with relative paths always push/pull relative to default
 
 Prepare a repo with subrepo
 
   $ hg init issue1852a
   $ cd issue1852a
   $ hg init sub/repo
   $ echo test > sub/repo/foo
   $ hg -R sub/repo add sub/repo/foo
   $ echo sub/repo = sub/repo > .hgsub
   $ hg add .hgsub
   $ hg ci -mtest
   committing subrepository sub/repo (glob)
   $ echo test >> sub/repo/foo
   $ hg ci -mtest
   committing subrepository sub/repo (glob)
   $ cd ..
 
 Create repo without default path, pull top repo, and see what happens on update
 
   $ hg init issue1852b
   $ hg -R issue1852b pull issue1852a
   pulling from issue1852a
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 2 changesets with 3 changes to 2 files
   (run 'hg update' to get a working copy)
   $ hg -R issue1852b update
   abort: default path for subrepository not found (in subrepo sub/repo) (glob)
   [255]
 
 Ensure a full traceback, not just the SubrepoAbort part
 
   $ hg -R issue1852b update --traceback 2>&1 | grep 'raise util\.Abort'
       raise util.Abort(_("default path for subrepository not found"))
 
 Pull -u now doesn't help
 
   $ hg -R issue1852b pull -u issue1852a
   pulling from issue1852a
   searching for changes
   no changes found
 
 Try the same, but with pull -u
 
   $ hg init issue1852c
   $ hg -R issue1852c pull -r0 -u issue1852a
   pulling from issue1852a
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 2 changes to 2 files
   cloning subrepo sub/repo from issue1852a/sub/repo (glob)
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 Try to push from the other side
 
   $ hg -R issue1852a push `pwd`/issue1852c
   pushing to $TESTTMP/issue1852c
   pushing subrepo sub/repo to $TESTTMP/issue1852c/sub/repo (glob)
   searching for changes
   no changes found
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
 
 Incoming and outgoing should not use the default path:
 
   $ hg clone -q issue1852a issue1852d
   $ hg -R issue1852d outgoing --subrepos issue1852c
   comparing with issue1852c
   searching for changes
   no changes found
   comparing with issue1852c/sub/repo
   searching for changes
   no changes found
   [1]
   $ hg -R issue1852d incoming --subrepos issue1852c
   comparing with issue1852c
   searching for changes
   no changes found
   comparing with issue1852c/sub/repo
   searching for changes
   no changes found
   [1]
 
 Check status of files when none of them belong to the first
 subrepository:
 
   $ hg init subrepo-status
   $ cd subrepo-status
   $ hg init subrepo-1
   $ hg init subrepo-2
   $ cd subrepo-2
   $ touch file
   $ hg add file
   $ cd ..
   $ echo subrepo-1 = subrepo-1 > .hgsub
   $ echo subrepo-2 = subrepo-2 >> .hgsub
   $ hg add .hgsub
   $ hg ci -m 'Added subrepos'
   committing subrepository subrepo-2
   $ hg st subrepo-2/file
 
 Check that share works with subrepo
   $ hg --config extensions.share= share . ../shared
   updating working directory
   cloning subrepo subrepo-2 from $TESTTMP/subrepo-status/subrepo-2
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ test -f ../shared/subrepo-1/.hg/sharedpath
   [1]
   $ hg -R ../shared in
   abort: repository default not found!
   [255]
   $ hg -R ../shared/subrepo-2 showconfig paths
   paths.default=$TESTTMP/subrepo-status/subrepo-2
   $ hg -R ../shared/subrepo-1 sum --remote
   parent: -1:000000000000 tip (empty repository)
   branch: default
   commit: (clean)
   update: (current)
   remote: (synced)
 
 Check hg update --clean
   $ cd $TESTTMP/t
   $ rm -r t/t.orig
   $ hg status -S --all
   C .hgsub
   C .hgsubstate
   C a
   C s/.hgsub
   C s/.hgsubstate
   C s/a
   C s/ss/a
   C t/t
   $ echo c1 > s/a
   $ cd s
   $ echo c1 > b
   $ echo c1 > c
   $ hg add b
   $ cd ..
   $ hg status -S
   M s/a
   A s/b
   ? s/c
   $ hg update -C
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg status -S
   ? s/b
   ? s/c
 
 Sticky subrepositories, no changes
   $ cd $TESTTMP/t
   $ hg id
   925c17564ef8 tip
   $ hg -R s id
   12a213df6fa9 tip
   $ hg -R t id
   52c0adc0515a tip
   $ hg update 11
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg id
   365661e5936a
   $ hg -R s id
   fc627a69481f
   $ hg -R t id
   e95bcfa18a35
 
 Sticky subrepositorys, file changes
   $ touch s/f1
   $ touch t/f1
   $ hg add -S s/f1
   $ hg add -S t/f1
   $ hg id
   365661e5936a+
   $ hg -R s id
   fc627a69481f+
   $ hg -R t id
   e95bcfa18a35+
   $ hg update tip
    subrepository sources for s differ
   use (l)ocal source (fc627a69481f) or (r)emote source (12a213df6fa9)?
    l
    subrepository sources for t differ
   use (l)ocal source (e95bcfa18a35) or (r)emote source (52c0adc0515a)?
    l
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg id
   925c17564ef8+ tip
   $ hg -R s id
   fc627a69481f+
   $ hg -R t id
   e95bcfa18a35+
   $ hg update --clean tip
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 Sticky subrepository, revision updates
   $ hg id
   925c17564ef8 tip
   $ hg -R s id
   12a213df6fa9 tip
   $ hg -R t id
   52c0adc0515a tip
   $ cd s
   $ hg update -r -2
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd ../t
   $ hg update -r 2
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd ..
   $ hg update 10
    subrepository sources for t differ (in checked out version)
   use (l)ocal source (7af322bc1198) or (r)emote source (20a0db6fbf6c)?
    l
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg id
   e45c8b14af55+
   $ hg -R s id
   02dcf1d70411
   $ hg -R t id
   7af322bc1198
 
 Sticky subrepository, file changes and revision updates
   $ touch s/f1
   $ touch t/f1
   $ hg add -S s/f1
   $ hg add -S t/f1
   $ hg id
   e45c8b14af55+
   $ hg -R s id
   02dcf1d70411+
   $ hg -R t id
   7af322bc1198+
   $ hg update tip
    subrepository sources for s differ
   use (l)ocal source (02dcf1d70411) or (r)emote source (12a213df6fa9)?
    l
    subrepository sources for t differ
   use (l)ocal source (7af322bc1198) or (r)emote source (52c0adc0515a)?
    l
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg id
   925c17564ef8+ tip
   $ hg -R s id
   02dcf1d70411+
   $ hg -R t id
   7af322bc1198+
 
 Sticky repository, update --clean
   $ hg update --clean tip
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg id
   925c17564ef8 tip
   $ hg -R s id
   12a213df6fa9 tip
   $ hg -R t id
   52c0adc0515a tip
 
 Test subrepo already at intended revision:
   $ cd s
   $ hg update fc627a69481f
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd ..
   $ hg update 11
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg id -n
   11+
   $ hg -R s id
   fc627a69481f
   $ hg -R t id
   e95bcfa18a35
 
 Test that removing .hgsubstate doesn't break anything:
 
   $ hg rm -f .hgsubstate
   $ hg ci -mrm
   nothing changed
   [1]
   $ hg log -vr tip
   changeset:   13:925c17564ef8
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   files:       .hgsubstate
   description:
   13
   
   
 
 Test that removing .hgsub removes .hgsubstate:
 
   $ hg rm .hgsub
   $ hg ci -mrm2
   created new head
   $ hg log -vr tip
   changeset:   14:2400bccd50af
   tag:         tip
   parent:      11:365661e5936a
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   files:       .hgsub .hgsubstate
   description:
   rm2
   
   
 Test issue3153: diff -S with deleted subrepos
 
   $ hg diff --nodates -S -c .
   diff -r 365661e5936a -r 2400bccd50af .hgsub
   --- a/.hgsub
   +++ /dev/null
   @@ -1,2 +0,0 @@
   -s = s
   -t = t
   diff -r 365661e5936a -r 2400bccd50af .hgsubstate
   --- a/.hgsubstate
   +++ /dev/null
   @@ -1,2 +0,0 @@
   -fc627a69481fcbe5f1135069e8a3881c023e4cf5 s
   -e95bcfa18a358dc4936da981ebf4147b4cad1362 t
 
 Test behavior of add for explicit path in subrepo:
   $ cd ..
   $ hg init explicit
   $ cd explicit
   $ echo s = s > .hgsub
   $ hg add .hgsub
   $ hg init s
   $ hg ci -m0
 Adding with an explicit path in a subrepo adds the file
   $ echo c1 > f1
   $ echo c2 > s/f2
   $ hg st -S
   ? f1
   ? s/f2
   $ hg add s/f2
   $ hg st -S
   A s/f2
   ? f1
   $ hg ci -R s -m0
   $ hg ci -Am1
   adding f1
 Adding with an explicit path in a subrepo with -S has the same behavior
   $ echo c3 > f3
   $ echo c4 > s/f4
   $ hg st -S
   ? f3
   ? s/f4
   $ hg add -S s/f4
   $ hg st -S
   A s/f4
   ? f3
   $ hg ci -R s -m1
   $ hg ci -Ama2
   adding f3
 Adding without a path or pattern silently ignores subrepos
   $ echo c5 > f5
   $ echo c6 > s/f6
   $ echo c7 > s/f7
   $ hg st -S
   ? f5
   ? s/f6
   ? s/f7
   $ hg add
   adding f5
   $ hg st -S
   A f5
   ? s/f6
   ? s/f7
   $ hg ci -R s -Am2
   adding f6
   adding f7
   $ hg ci -m3
 Adding without a path or pattern with -S also adds files in subrepos
   $ echo c8 > f8
   $ echo c9 > s/f9
   $ echo c10 > s/f10
   $ hg st -S
   ? f8
   ? s/f10
   ? s/f9
   $ hg add -S
   adding f8
   adding s/f10 (glob)
   adding s/f9 (glob)
   $ hg st -S
   A f8
   A s/f10
   A s/f9
   $ hg ci -R s -m3
   $ hg ci -m4
 Adding with a pattern silently ignores subrepos
   $ echo c11 > fm11
   $ echo c12 > fn12
   $ echo c13 > s/fm13
   $ echo c14 > s/fn14
   $ hg st -S
   ? fm11
   ? fn12
   ? s/fm13
   ? s/fn14
   $ hg add 'glob:**fm*'
   adding fm11
   $ hg st -S
   A fm11
   ? fn12
   ? s/fm13
   ? s/fn14
   $ hg ci -R s -Am4
   adding fm13
   adding fn14
   $ hg ci -Am5
   adding fn12
 Adding with a pattern with -S also adds matches in subrepos
   $ echo c15 > fm15
   $ echo c16 > fn16
   $ echo c17 > s/fm17
   $ echo c18 > s/fn18
   $ hg st -S
   ? fm15
   ? fn16
   ? s/fm17
   ? s/fn18
   $ hg add -S 'glob:**fm*'
   adding fm15
   adding s/fm17 (glob)
   $ hg st -S
   A fm15
   A s/fm17
   ? fn16
   ? s/fn18
   $ hg ci -R s -Am5
   adding fn18
   $ hg ci -Am6
   adding fn16
 
 Test behavior of forget for explicit path in subrepo:
 Forgetting an explicit path in a subrepo untracks the file
   $ echo c19 > s/f19
   $ hg add s/f19
   $ hg st -S
   A s/f19
   $ hg forget s/f19
   $ hg st -S
   ? s/f19
   $ rm s/f19
   $ cd ..
 
 Courtesy phases synchronisation to publishing server does not block the push
 (issue3781)
 
   $ cp -r main issue3781
   $ cp -r main issue3781-dest
   $ cd issue3781-dest/s
   $ hg phase tip # show we have draft changeset
   5: draft
   $ chmod a-w .hg/store/phaseroots # prevent phase push
   $ cd ../../issue3781
   $ cat >> .hg/hgrc << EOF
   > [paths]
   > default=../issue3781-dest/
   > EOF
   $ hg push
   pushing to $TESTTMP/issue3781-dest (glob)
   pushing subrepo s to $TESTTMP/issue3781-dest/s
   searching for changes
   no changes found
   searching for changes
   no changes found
   [1]