tests: convert some 'hghave execbit' to #if

This enables some new tests for running on windows.

tests/test-convert-bzr.t

@@ -1,284 +1,287 b''
-  $ "$TESTDIR/hghave" symlink execbit || exit 80
-
   $ . "$TESTDIR/bzr-definitions"
 
 create and rename on the same file in the same step
 
   $ mkdir test-createandrename
   $ cd test-createandrename
   $ bzr init -q source
 
 test empty repo conversion (issue3233)
 
   $ hg convert source source-hg
   initializing destination source-hg repository
   scanning source...
   sorting...
   converting...
 
 back to the rename stuff
 
   $ cd source
   $ echo a > a
   $ echo c > c
   $ echo e > e
   $ bzr add -q a c e
   $ bzr commit -q -m 'Initial add: a, c, e'
   $ bzr mv a b
   a => b
   $ bzr mv c d
   c => d
   $ bzr mv e f
   e => f
   $ echo a2 >> a
   $ mkdir e
   $ bzr add -q a e
   $ bzr commit -q -m 'rename a into b, create a, rename c into d'
   $ cd ..
   $ hg convert source source-hg
   scanning source...
   sorting...
   converting...
   1 Initial add: a, c, e
   0 rename a into b, create a, rename c into d
   $ glog -R source-hg
   o  1@source "rename a into b, create a, rename c into d" files: a b c d e f
   |
   o  0@source "Initial add: a, c, e" files: a c e
   
 
 manifest
 
   $ hg manifest -R source-hg -r tip
   a
   b
   d
   f
 
 test --rev option
 
   $ hg convert -r 1 source source-1-hg
   initializing destination source-1-hg repository
   scanning source...
   sorting...
   converting...
   0 Initial add: a, c, e
   $ glog -R source-1-hg
   o  0@source "Initial add: a, c, e" files: a c e
   
 
 test with filemap
 
   $ cat > filemap <<EOF
   > exclude a
   > EOF
   $ hg convert --filemap filemap source source-filemap-hg
   initializing destination source-filemap-hg repository
   scanning source...
   sorting...
   converting...
   1 Initial add: a, c, e
   0 rename a into b, create a, rename c into d
   $ hg -R source-filemap-hg manifest -r tip
   b
   d
   f
 
 convert from lightweight checkout
 
   $ bzr checkout --lightweight source source-light
   $ hg convert -s bzr source-light source-light-hg
   initializing destination source-light-hg repository
   warning: lightweight checkouts may cause conversion failures, try with a regular branch instead.
   $TESTTMP/test-createandrename/source-light does not look like a Bazaar repository
   abort: source-light: missing or unsupported repository
   [255]
 
 extract timestamps that look just like hg's {date|isodate}:
 yyyy-mm-dd HH:MM zzzz (no seconds!)
 compare timestamps
 
   $ cd source
   $ bzr log | \
   >   sed '/timestamp/!d;s/.\{15\}\([0-9: -]\{16\}\):.. \(.[0-9]\{4\}\)/\1 \2/' \
   >   > ../bzr-timestamps
   $ cd ..
   $ hg -R source-hg log --template "{date|isodate}\n" > hg-timestamps
   $ diff -u bzr-timestamps hg-timestamps
   $ cd ..
 
 merge
 
   $ mkdir test-merge
   $ cd test-merge
   $ cat > helper.py <<EOF
   > import sys
   > from bzrlib import workingtree
   > wt = workingtree.WorkingTree.open('.')
   > 
   > message, stamp = sys.argv[1:]
   > wt.commit(message, timestamp=int(stamp))
   > EOF
   $ bzr init -q source
   $ cd source
   $ echo content > a
   $ echo content2 > b
   $ bzr add -q a b
   $ bzr commit -q -m 'Initial add'
   $ cd ..
   $ bzr branch -q source source-improve
   $ cd source
   $ echo more >> a
   $ python ../helper.py 'Editing a' 100
   $ cd ../source-improve
   $ echo content3 >> b
   $ python ../helper.py 'Editing b' 200
   $ cd ../source
   $ bzr merge -q ../source-improve
   $ bzr commit -q -m 'Merged improve branch'
   $ cd ..
   $ hg convert --datesort source source-hg
   initializing destination source-hg repository
   scanning source...
   sorting...
   converting...
   3 Initial add
   2 Editing a
   1 Editing b
   0 Merged improve branch
   $ glog -R source-hg
   o    3@source "Merged improve branch" files:
   |\
   | o  2@source-improve "Editing b" files: b
   | |
   o |  1@source "Editing a" files: a
   |/
   o  0@source "Initial add" files: a b
   
   $ cd ..
 
+#if symlink execbit
+
 symlinks and executable files
 
   $ mkdir test-symlinks
   $ cd test-symlinks
   $ bzr init -q source
   $ cd source
   $ touch program
   $ chmod +x program
   $ ln -s program altname
   $ mkdir d
   $ echo a > d/a
   $ ln -s a syma
   $ bzr add -q altname program syma d/a
   $ bzr commit -q -m 'Initial setup'
   $ touch newprog
   $ chmod +x newprog
   $ rm altname
   $ ln -s newprog altname
   $ chmod -x program
   $ bzr add -q newprog
   $ bzr commit -q -m 'Symlink changed, x bits changed'
   $ cd ..
   $ hg convert source source-hg
   initializing destination source-hg repository
   scanning source...
   sorting...
   converting...
   1 Initial setup
   0 Symlink changed, x bits changed
   $ manifest source-hg 0
   % manifest of 0
   644 @ altname
   644   d/a
   755 * program
   644 @ syma
   $ manifest source-hg tip
   % manifest of tip
   644 @ altname
   644   d/a
   755 * newprog
   644   program
   644 @ syma
-  $ cd source-hg
 
 test the symlinks can be recreated
 
+  $ cd source-hg
   $ hg up
   5 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg cat syma; echo
   a
+  $ cd ../..
+
+#endif
 
 Multiple branches
 
   $ bzr init-repo -q --no-trees repo
   $ bzr init -q repo/trunk
   $ bzr co repo/trunk repo-trunk
   $ cd repo-trunk
   $ echo a > a
   $ bzr add a
   adding a
   $ bzr ci -qm adda --commit-time '2012-01-01 00:00:01 +0000'
   $ bzr tag trunk-tag
   Created tag trunk-tag.
   $ bzr switch -b branch
   Tree is up to date at revision 1.
   Switched to branch: *repo/branch/ (glob)
   $ echo b > b
   $ bzr add b
   adding b
   $ bzr ci -qm addb --commit-time '2012-01-01 00:00:02 +0000'
   $ bzr tag branch-tag
   Created tag branch-tag.
   $ bzr switch --force ../repo/trunk
   Updated to revision 1.
   Switched to branch: */repo/trunk/ (glob)
   $ echo a >> a
   $ bzr ci -qm changea --commit-time '2012-01-01 00:00:03 +0000'
   $ cd ..
   $ hg convert --datesort repo repo-bzr
   initializing destination repo-bzr repository
   scanning source...
   sorting...
   converting...
   2 adda
   1 addb
   0 changea
   updating tags
   $ (cd repo-bzr; glog)
   o  3@default "update tags" files: .hgtags
   |
   o  2@default "changea" files: a
   |
   | o  1@branch "addb" files: b
   |/
   o  0@default "adda" files: a
   
 
 Test tags (converted identifiers are not stable because bzr ones are
 not and get incorporated in extra fields).
 
   $ hg -R repo-bzr tags
   tip                                3:* (glob)
   branch-tag                         1:* (glob)
   trunk-tag                          0:* (glob)
 
 Nested repositories (issue3254)
 
   $ bzr init-repo -q --no-trees repo/inner
   $ bzr init -q repo/inner/trunk
   $ bzr co repo/inner/trunk inner-trunk
   $ cd inner-trunk
   $ echo b > b
   $ bzr add b
   adding b
   $ bzr ci -qm addb
   $ cd ..
   $ hg convert --datesort repo noinner-bzr
   initializing destination noinner-bzr repository
   scanning source...
   sorting...
   converting...
   2 adda
   1 addb
   0 changea
   updating tags

tests/test-convert-hg-source.t

@@ -1,140 +1,149 b''
-  $ "$TESTDIR/hghave" execbit || exit 80
-
   $ cat >> $HGRCPATH <<EOF
   > [extensions]
   > convert=
   > [convert]
   > hg.saverev=False
   > EOF
   $ hg init orig
   $ cd orig
   $ echo foo > foo
   $ echo bar > bar
   $ hg ci -qAm 'add foo bar' -d '0 0'
   $ echo >> foo
   $ hg ci -m 'change foo' -d '1 0'
   $ hg up -qC 0
   $ hg copy --after --force foo bar
   $ hg copy foo baz
   $ hg ci -m 'make bar and baz copies of foo' -d '2 0'
   created new head
   $ hg bookmark premerge1
   $ hg merge -r 1
   merging baz and foo to baz
   1 files updated, 1 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg ci -m 'merge local copy' -d '3 0'
   $ hg up -C 1
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg bookmark premerge2
   $ hg merge 2
   merging foo and baz to baz
   1 files updated, 1 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg ci -m 'merge remote copy' -d '4 0'
   created new head
+#if execbit
   $ chmod +x baz
+#else
+  $ echo some other change to make sure we get a rev 5 > baz
+#endif
   $ hg ci -m 'mark baz executable' -d '5 0'
   $ cd ..
   $ hg convert --datesort orig new 2>&1 | grep -v 'subversion python bindings could not be loaded'
   initializing destination new repository
   scanning source...
   sorting...
   converting...
   5 add foo bar
   4 change foo
   3 make bar and baz copies of foo
   2 merge local copy
   1 merge remote copy
   0 mark baz executable
   updating bookmarks
   $ cd new
   $ hg out ../orig
   comparing with ../orig
   searching for changes
   no changes found
   [1]
+#if execbit
   $ hg bookmarks
      premerge1                 3:973ef48a98a4
      premerge2                 5:13d9b87cf8f8
+#else
+Different hash because no x bit
+  $ hg bookmarks
+     premerge1                 3:973ef48a98a4
+     premerge2                 5:df0779bcf33c
+#endif
   $ cd ..
 
 check shamap LF and CRLF handling
 
   $ cat > rewrite.py <<EOF
   > import sys
   > # Interlace LF and CRLF
   > lines = [(l.rstrip() + ((i % 2) and '\n' or '\r\n'))
   >          for i, l in enumerate(file(sys.argv[1]))]
   > file(sys.argv[1], 'wb').write(''.join(lines))
   > EOF
   $ python rewrite.py new/.hg/shamap
   $ cd orig
   $ hg up -qC 1
   $ echo foo >> foo
   $ hg ci -qm 'change foo again'
   $ hg up -qC 2
   $ echo foo >> foo
   $ hg ci -qm 'change foo again again'
   $ cd ..
   $ hg convert --datesort orig new 2>&1 | grep -v 'subversion python bindings could not be loaded'
   scanning source...
   sorting...
   converting...
   1 change foo again again
   0 change foo again
   updating bookmarks
 
 init broken repository
 
   $ hg init broken
   $ cd broken
   $ echo a >> a
   $ echo b >> b
   $ hg ci -qAm init
   $ echo a >> a
   $ echo b >> b
   $ hg copy b c
   $ hg ci -qAm changeall
   $ hg up -qC 0
   $ echo bc >> b
   $ hg ci -m changebagain
   created new head
   $ HGMERGE=internal:local hg -q merge
   $ hg ci -m merge
   $ hg mv b d
   $ hg ci -m moveb
 
 break it
 
   $ rm .hg/store/data/b.*
   $ cd ..
   $ hg --config convert.hg.ignoreerrors=True convert broken fixed
   initializing destination fixed repository
   scanning source...
   sorting...
   converting...
   4 init
   ignoring: data/b.i@1e88685f5dde: no match found
   3 changeall
   2 changebagain
   1 merge
   0 moveb
   $ hg -R fixed verify
   checking changesets
   checking manifests
   crosschecking files in changesets and manifests
   checking files
   3 files, 5 changesets, 5 total revisions
 
 manifest -r 0
 
   $ hg -R fixed manifest -r 0
   a
 
 manifest -r tip
 
   $ hg -R fixed manifest -r tip
   a
   c
   d

tests/test-convert-svn-sink.t

@@ -1,405 +1,422 b''
-  $ "$TESTDIR/hghave" svn13 no-outer-repo symlink execbit || exit 80
+  $ "$TESTDIR/hghave" svn13 no-outer-repo symlink || exit 80
 
   $ fixpath()
   > {
   >     tr '\\' /
   > }
   $ svnupanddisplay()
   > {
   >     (
   >        cd $1;
   >        svn up -q;
   >        svn st -v | fixpath | sed 's/  */ /g' | sort
   >        limit=''
   >        if [ $2 -gt 0 ]; then
   >            limit="--limit=$2"
   >        fi
   >        svn log --xml -v $limit | python "$TESTDIR/svnxml.py"
   >     )
   > }
 
   $ cat >> $HGRCPATH <<EOF
   > [extensions]
   > convert = 
   > graphlog =
   > EOF
 
   $ hg init a
 
 Add
 
   $ echo a > a/a
   $ mkdir -p a/d1/d2
   $ echo b > a/d1/d2/b
   $ ln -s a/missing a/link
   $ hg --cwd a ci -d '0 0' -A -m 'add a file'
   adding a
   adding d1/d2/b
   adding link
 
 Modify
 
   $ "$TESTDIR/svn-safe-append.py" a a/a
   $ hg --cwd a ci -d '1 0' -m 'modify a file'
   $ hg --cwd a tip -q
   1:8231f652da37
 
   $ hg convert -d svn a
   assuming destination a-hg
   initializing svn repository 'a-hg'
   initializing svn working copy 'a-hg-wc'
   scanning source...
   sorting...
   converting...
   1 add a file
   0 modify a file
   $ svnupanddisplay a-hg-wc 2
    2 1 test d1
    2 1 test d1/d2
    2 1 test d1/d2/b
    2 1 test link
    2 2 test .
    2 2 test a
   revision: 2
   author: test
   msg: modify a file
    M /a
   revision: 1
   author: test
   msg: add a file
    A /a
    A /d1
    A /d1/d2
    A /d1/d2/b
    A /link
   $ ls a a-hg-wc
   a:
   a
   d1
   link
   
   a-hg-wc:
   a
   d1
   link
   $ cmp a/a a-hg-wc/a
 
 Rename
 
   $ hg --cwd a mv a b
   $ hg --cwd a mv link newlink
 
   $ hg --cwd a ci -d '2 0' -m 'rename a file'
   $ hg --cwd a tip -q
   2:a67e26ccec09
 
   $ hg convert -d svn a
   assuming destination a-hg
   initializing svn working copy 'a-hg-wc'
   scanning source...
   sorting...
   converting...
   0 rename a file
   $ svnupanddisplay a-hg-wc 1
    3 1 test d1
    3 1 test d1/d2
    3 1 test d1/d2/b
    3 3 test .
    3 3 test b
    3 3 test newlink
   revision: 3
   author: test
   msg: rename a file
    D /a
    A /b (from /a@2)
    D /link
    A /newlink (from /link@2)
   $ ls a a-hg-wc
   a:
   b
   d1
   newlink
   
   a-hg-wc:
   b
   d1
   newlink
 
 Copy
 
   $ hg --cwd a cp b c
 
   $ hg --cwd a ci -d '3 0' -m 'copy a file'
   $ hg --cwd a tip -q
   3:0cf087b9ab02
 
   $ hg convert -d svn a
   assuming destination a-hg
   initializing svn working copy 'a-hg-wc'
   scanning source...
   sorting...
   converting...
   0 copy a file
   $ svnupanddisplay a-hg-wc 1
    4 1 test d1
    4 1 test d1/d2
    4 1 test d1/d2/b
    4 3 test b
    4 3 test newlink
    4 4 test .
    4 4 test c
   revision: 4
   author: test
   msg: copy a file
    A /c (from /b@3)
   $ ls a a-hg-wc
   a:
   b
   c
   d1
   newlink
   
   a-hg-wc:
   b
   c
   d1
   newlink
 
   $ hg --cwd a rm b
 
 Remove
 
   $ hg --cwd a ci -d '4 0' -m 'remove a file'
   $ hg --cwd a tip -q
   4:07b2e34a5b17
 
   $ hg convert -d svn a
   assuming destination a-hg
   initializing svn working copy 'a-hg-wc'
   scanning source...
   sorting...
   converting...
   0 remove a file
   $ svnupanddisplay a-hg-wc 1
    5 1 test d1
    5 1 test d1/d2
    5 1 test d1/d2/b
    5 3 test newlink
    5 4 test c
    5 5 test .
   revision: 5
   author: test
   msg: remove a file
    D /b
   $ ls a a-hg-wc
   a:
   c
   d1
   newlink
   
   a-hg-wc:
   c
   d1
   newlink
 
-Exectutable
+Executable
 
+#if execbit
   $ chmod +x a/c
+#else
+  $ echo fake >> a/c
+#endif
   $ hg --cwd a ci -d '5 0' -m 'make a file executable'
+#if execbit
   $ hg --cwd a tip -q
   5:31093672760b
+#else
+  $ hg --cwd a tip -q
+  5:034971d37224
+#endif
 
   $ hg convert -d svn a
   assuming destination a-hg
   initializing svn working copy 'a-hg-wc'
   scanning source...
   sorting...
   converting...
   0 make a file executable
   $ svnupanddisplay a-hg-wc 1
    6 1 test d1
    6 1 test d1/d2
    6 1 test d1/d2/b
    6 3 test newlink
    6 6 test .
    6 6 test c
   revision: 6
   author: test
   msg: make a file executable
    M /c
+#if execbit
   $ test -x a-hg-wc/c
+#endif
+  $ rm -rf a a-hg a-hg-wc
 
 Executable in new directory
 
-  $ rm -rf a a-hg a-hg-wc
   $ hg init a
 
   $ mkdir a/d1
   $ echo a > a/d1/a
+#if execbit
   $ chmod +x a/d1/a
+#else
+  $ echo fake >> a/d1/a
+#endif
   $ hg --cwd a ci -d '0 0' -A -m 'add executable file in new directory'
   adding d1/a
 
   $ hg convert -d svn a
   assuming destination a-hg
   initializing svn repository 'a-hg'
   initializing svn working copy 'a-hg-wc'
   scanning source...
   sorting...
   converting...
   0 add executable file in new directory
   $ svnupanddisplay a-hg-wc 1
    1 1 test .
    1 1 test d1
    1 1 test d1/a
   revision: 1
   author: test
   msg: add executable file in new directory
    A /d1
    A /d1/a
+#if execbit
   $ test -x a-hg-wc/d1/a
+#endif
 
 Copy to new directory
 
   $ mkdir a/d2
   $ hg --cwd a cp d1/a d2/a
   $ hg --cwd a ci -d '1 0' -A -m 'copy file to new directory'
 
   $ hg convert -d svn a
   assuming destination a-hg
   initializing svn working copy 'a-hg-wc'
   scanning source...
   sorting...
   converting...
   0 copy file to new directory
   $ svnupanddisplay a-hg-wc 1
    2 1 test d1
    2 1 test d1/a
    2 2 test .
    2 2 test d2
    2 2 test d2/a
   revision: 2
   author: test
   msg: copy file to new directory
    A /d2
    A /d2/a (from /d1/a@1)
 
 Branchy history
 
   $ hg init b
   $ echo base > b/b
   $ hg --cwd b ci -d '0 0' -Ambase
   adding b
 
   $ "$TESTDIR/svn-safe-append.py" left-1 b/b
   $ echo left-1 > b/left-1
   $ hg --cwd b ci -d '1 0' -Amleft-1
   adding left-1
 
   $ "$TESTDIR/svn-safe-append.py" left-2 b/b
   $ echo left-2 > b/left-2
   $ hg --cwd b ci -d '2 0' -Amleft-2
   adding left-2
 
   $ hg --cwd b up 0
   1 files updated, 0 files merged, 2 files removed, 0 files unresolved
 
   $ "$TESTDIR/svn-safe-append.py" right-1 b/b
   $ echo right-1 > b/right-1
   $ hg --cwd b ci -d '3 0' -Amright-1
   adding right-1
   created new head
 
   $ "$TESTDIR/svn-safe-append.py" right-2 b/b
   $ echo right-2 > b/right-2
   $ hg --cwd b ci -d '4 0' -Amright-2
   adding right-2
 
   $ hg --cwd b up -C 2
   3 files updated, 0 files merged, 2 files removed, 0 files unresolved
   $ hg --cwd b merge
   merging b
   warning: conflicts during merge.
   merging b incomplete! (edit conflicts, then use 'hg resolve --mark')
   2 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
   [1]
   $ hg --cwd b revert -r 2 b
   $ hg resolve -m b
   $ hg --cwd b ci -d '5 0' -m 'merge'
 
 Expect 4 changes
 
   $ hg convert -d svn b
   assuming destination b-hg
   initializing svn repository 'b-hg'
   initializing svn working copy 'b-hg-wc'
   scanning source...
   sorting...
   converting...
   5 base
   4 left-1
   3 left-2
   2 right-1
   1 right-2
   0 merge
 
   $ svnupanddisplay b-hg-wc 0
    4 2 test left-1
    4 3 test b
    4 3 test left-2
    4 4 test .
    4 4 test right-1
    4 4 test right-2
   revision: 4
   author: test
   msg: merge
    A /right-1
    A /right-2
   revision: 3
   author: test
   msg: left-2
    M /b
    A /left-2
   revision: 2
   author: test
   msg: left-1
    M /b
    A /left-1
   revision: 1
   author: test
   msg: base
    A /b
 
 Tags are not supported, but must not break conversion
 
   $ rm -rf a a-hg a-hg-wc
   $ hg init a
   $ echo a > a/a
   $ hg --cwd a ci -d '0 0' -A -m 'Add file a'
   adding a
   $ hg --cwd a tag -d '1 0' -m 'Tagged as v1.0' v1.0
 
   $ hg convert -d svn a
   assuming destination a-hg
   initializing svn repository 'a-hg'
   initializing svn working copy 'a-hg-wc'
   scanning source...
   sorting...
   converting...
   1 Add file a
   0 Tagged as v1.0
   writing Subversion tags is not yet implemented
   $ svnupanddisplay a-hg-wc 2
    2 1 test a
    2 2 test .
    2 2 test .hgtags
   revision: 2
   author: test
   msg: Tagged as v1.0
    A /.hgtags
   revision: 1
   author: test
   msg: Add file a
    A /a
   $ rm -rf a a-hg a-hg-wc

tests/test-diff-color.t

@@ -1,126 +1,128 b''
-  $ "$TESTDIR/hghave" execbit || exit 80
-
 Setup
 
   $ echo "[color]" >> $HGRCPATH
   $ echo "mode = ansi" >> $HGRCPATH
   $ echo "[extensions]" >> $HGRCPATH
   $ echo "color=" >> $HGRCPATH
   $ hg init repo
   $ cd repo
   $ cat > a <<EOF
   > c
   > c
   > a
   > a
   > b
   > a
   > a
   > c
   > c
   > EOF
   $ hg ci -Am adda
   adding a
   $ cat > a <<EOF
   > c
   > c
   > a
   > a
   > dd
   > a
   > a
   > c
   > c
   > EOF
 
 default context
 
   $ hg diff --nodates --color=always
   \x1b[0;1mdiff -r cf9f4ba66af2 a\x1b[0m (esc)
   \x1b[0;31;1m--- a/a\x1b[0m (esc)
   \x1b[0;32;1m+++ b/a\x1b[0m (esc)
   \x1b[0;35m@@ -2,7 +2,7 @@\x1b[0m (esc)
    c
    a
    a
   \x1b[0;31m-b\x1b[0m (esc)
   \x1b[0;32m+dd\x1b[0m (esc)
    a
    a
    c
 
 --unified=2
 
   $ hg diff --nodates -U 2  --color=always
   \x1b[0;1mdiff -r cf9f4ba66af2 a\x1b[0m (esc)
   \x1b[0;31;1m--- a/a\x1b[0m (esc)
   \x1b[0;32;1m+++ b/a\x1b[0m (esc)
   \x1b[0;35m@@ -3,5 +3,5 @@\x1b[0m (esc)
    a
    a
   \x1b[0;31m-b\x1b[0m (esc)
   \x1b[0;32m+dd\x1b[0m (esc)
    a
    a
 
 diffstat
 
   $ hg diff --stat --color=always
    a |  2 \x1b[0;32m+\x1b[0m\x1b[0;31m-\x1b[0m (esc)
    1 files changed, 1 insertions(+), 1 deletions(-)
   $ echo "record=" >> $HGRCPATH
   $ echo "[ui]" >> $HGRCPATH
   $ echo "interactive=true" >> $HGRCPATH
   $ echo "[diff]" >> $HGRCPATH
   $ echo "git=True" >> $HGRCPATH
 
+#if execbit
+
 record
 
   $ chmod +x a
   $ hg record --color=always -m moda a <<EOF
   > y
   > y
   > EOF
   \x1b[0;1mdiff --git a/a b/a\x1b[0m (esc)
   \x1b[0;36;1mold mode 100644\x1b[0m (esc)
   \x1b[0;36;1mnew mode 100755\x1b[0m (esc)
   1 hunks, 1 lines changed
   \x1b[0;33mexamine changes to 'a'? [Ynesfdaq?]\x1b[0m  (esc)
   \x1b[0;35m@@ -2,7 +2,7 @@\x1b[0m (esc)
    c
    a
    a
   \x1b[0;31m-b\x1b[0m (esc)
   \x1b[0;32m+dd\x1b[0m (esc)
    a
    a
    c
   \x1b[0;33mrecord this change to 'a'? [Ynesfdaq?]\x1b[0m  (esc)
 
   $ echo "[extensions]" >> $HGRCPATH
   $ echo "mq=" >> $HGRCPATH
   $ hg rollback
   repository tip rolled back to revision 0 (undo commit)
   working directory now based on revision 0
 
 qrecord
 
   $ hg qrecord --color=always -m moda patch <<EOF
   > y
   > y
   > EOF
   \x1b[0;1mdiff --git a/a b/a\x1b[0m (esc)
   \x1b[0;36;1mold mode 100644\x1b[0m (esc)
   \x1b[0;36;1mnew mode 100755\x1b[0m (esc)
   1 hunks, 1 lines changed
   \x1b[0;33mexamine changes to 'a'? [Ynesfdaq?]\x1b[0m  (esc)
   \x1b[0;35m@@ -2,7 +2,7 @@\x1b[0m (esc)
    c
    a
    a
   \x1b[0;31m-b\x1b[0m (esc)
   \x1b[0;32m+dd\x1b[0m (esc)
    a
    a
    c
   \x1b[0;33mrecord this change to 'a'? [Ynesfdaq?]\x1b[0m  (esc)
+
+#endif

tests/test-extdiff.t

@@ -1,198 +1,204 b''
-  $ "$TESTDIR/hghave" symlink execbit || exit 80
-
   $ echo "[extensions]" >> $HGRCPATH
   $ echo "extdiff=" >> $HGRCPATH
 
   $ hg init a
   $ cd a
   $ echo a > a
   $ echo b > b
   $ hg add
   adding a
   adding b
 
 Should diff cloned directories:
 
   $ hg extdiff -o -r $opt
   Only in a: a
   Only in a: b
   [1]
 
   $ echo "[extdiff]" >> $HGRCPATH
   $ echo "cmd.falabala=echo" >> $HGRCPATH
   $ echo "opts.falabala=diffing" >> $HGRCPATH
 
   $ hg falabala
   diffing a.000000000000 a
   [1]
 
   $ hg help falabala
   hg falabala [OPTION]... [FILE]...
   
   use 'echo' to diff repository (or selected files)
   
       Show differences between revisions for the specified files, using the
       'echo' program.
   
       When two revision arguments are given, then changes are shown between
       those revisions. If only one revision is specified then that revision is
       compared to the working directory, and, when no revisions are specified,
       the working directory files are compared to its parent.
   
   options:
   
    -o --option OPT [+]      pass option to comparison program
    -r --rev REV [+]         revision
    -c --change REV          change made by revision
    -I --include PATTERN [+] include names matching the given patterns
    -X --exclude PATTERN [+] exclude names matching the given patterns
   
   [+] marked option can be specified multiple times
   
   use "hg -v help falabala" to show more info
 
   $ hg ci -d '0 0' -mtest1
 
   $ echo b >> a
   $ hg ci -d '1 0' -mtest2
 
 Should diff cloned files directly:
 
   $ hg falabala -r 0:1
   diffing */extdiff.*/a.8a5febb7f867/a a.34eed99112ab/a (glob)
   [1]
 
 Test diff during merge:
 
   $ hg update -C 0
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo c >> c
   $ hg add c
   $ hg ci -m "new branch" -d '1 0'
   created new head
   $ hg merge 1
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
 
 Should diff cloned file against wc file:
 
   $ hg falabala
   diffing */extdiff.*/a.2a13a4d2da36/a */a/a (glob)
   [1]
 
 
 Test --change option:
 
   $ hg ci -d '2 0' -mtest3
   $ hg falabala -c 1
   diffing */extdiff.*/a.8a5febb7f867/a a.34eed99112ab/a (glob)
   [1]
 
 Check diff are made from the first parent:
 
   $ hg falabala -c 3 || echo "diff-like tools yield a non-zero exit code"
   diffing */extdiff.*/a.2a13a4d2da36/a a.46c0e4daeb72/a (glob)
   diff-like tools yield a non-zero exit code
 
+#if execbit
+
 Test extdiff of multiple files in tmp dir:
 
   $ hg update -C 0 > /dev/null
   $ echo changed > a
   $ echo changed > b
   $ chmod +x b
 
 Diff in working directory, before:
 
   $ hg diff --git
   diff --git a/a b/a
   --- a/a
   +++ b/a
   @@ -1,1 +1,1 @@
   -a
   +changed
   diff --git a/b b/b
   old mode 100644
   new mode 100755
   --- a/b
   +++ b/b
   @@ -1,1 +1,1 @@
   -b
   +changed
 
 
 Edit with extdiff -p:
 
 Prepare custom diff/edit tool:
 
   $ cat > 'diff tool.py' << EOT
   > #!/usr/bin/env python
   > import time
   > time.sleep(1) # avoid unchanged-timestamp problems
   > file('a/a', 'ab').write('edited\n')
   > file('a/b', 'ab').write('edited\n')
   > EOT
 
   $ chmod +x 'diff tool.py'
 
 will change to /tmp/extdiff.TMP and populate directories a.TMP and a
 and start tool
 
   $ hg extdiff -p "`pwd`/diff tool.py"
   [1]
 
 Diff in working directory, after:
 
   $ hg diff --git
   diff --git a/a b/a
   --- a/a
   +++ b/a
   @@ -1,1 +1,2 @@
   -a
   +changed
   +edited
   diff --git a/b b/b
   old mode 100644
   new mode 100755
   --- a/b
   +++ b/b
   @@ -1,1 +1,2 @@
   -b
   +changed
   +edited
 
 Test extdiff with --option:
 
   $ hg extdiff -p echo -o this -c 1
   this */extdiff.*/a.8a5febb7f867/a a.34eed99112ab/a (glob)
   [1]
 
   $ hg falabala -o this -c 1
   diffing this */extdiff.*/a.8a5febb7f867/a a.34eed99112ab/a (glob)
   [1]
 
 Test with revsets:
 
   $ hg extdif -p echo -c "rev(1)"
   */extdiff.*/a.8a5febb7f867/a a.34eed99112ab/a (glob)
   [1]
 
   $ hg extdif -p echo -r "0::1"
   */extdiff.*/a.8a5febb7f867/a a.34eed99112ab/a (glob)
   [1]
 
   $ cd ..
 
+#endif
+
+#if symlink
+
 Test symlinks handling (issue1909)
 
   $ hg init testsymlinks
   $ cd testsymlinks
   $ echo a > a
   $ hg ci -Am adda
   adding a
   $ echo a >> a
   $ ln -s missing linka
   $ hg add linka
   $ hg falabala -r 0 --traceback
   diffing testsymlinks.07f494440405 testsymlinks
   [1]
   $ cd ..
+
+#endif

tests/test-git-export.t

@@ -1,351 +1,362 b''
-  $ "$TESTDIR/hghave" execbit || exit 80
-
   $ hg init
   $ echo start > start
   $ hg ci -Amstart
   adding start
 
 New file:
 
   $ echo new > new
   $ hg ci -Amnew
   adding new
   $ hg diff --git -r 0
   diff --git a/new b/new
   new file mode 100644
   --- /dev/null
   +++ b/new
   @@ -0,0 +1,1 @@
   +new
 
 Copy:
 
   $ hg cp new copy
   $ hg ci -mcopy
   $ hg diff --git -r 1:tip
   diff --git a/new b/copy
   copy from new
   copy to copy
 
 Rename:
 
   $ hg mv copy rename
   $ hg ci -mrename
   $ hg diff --git -r 2:tip
   diff --git a/copy b/rename
   rename from copy
   rename to rename
 
 Delete:
 
   $ hg rm rename
   $ hg ci -mdelete
   $ hg diff --git -r 3:tip
   diff --git a/rename b/rename
   deleted file mode 100644
   --- a/rename
   +++ /dev/null
   @@ -1,1 +0,0 @@
   -new
 
   $ cat > src <<EOF
   > 1
   > 2
   > 3
   > 4
   > 5
   > EOF
   $ hg ci -Amsrc
   adding src
 
+#if execbit
+
 chmod 644:
 
   $ chmod +x src
   $ hg ci -munexec
   $ hg diff --git -r 5:tip
   diff --git a/src b/src
   old mode 100644
   new mode 100755
 
 Rename+mod+chmod:
 
   $ hg mv src dst
   $ chmod -x dst
   $ echo a >> dst
   $ hg ci -mrenamemod
   $ hg diff --git -r 6:tip
   diff --git a/src b/dst
   old mode 100755
   new mode 100644
   rename from src
   rename to dst
   --- a/src
   +++ b/dst
   @@ -3,3 +3,4 @@
    3
    4
    5
   +a
 
 Nonexistent in tip+chmod:
 
   $ hg diff --git -r 5:6
   diff --git a/src b/src
   old mode 100644
   new mode 100755
 
+#else
+
+Dummy changes when no exec bit, mocking the execbit commit structure
+
+  $ echo change >> src
+  $ hg ci -munexec
+  $ hg mv src dst
+  $ hg ci -mrenamemod
+
+#endif
+
 Binary diff:
 
   $ cp "$TESTDIR/binfile.bin" .
   $ hg add binfile.bin
   $ hg diff --git > b.diff
   $ cat b.diff
   diff --git a/binfile.bin b/binfile.bin
   new file mode 100644
   index 0000000000000000000000000000000000000000..37ba3d1c6f17137d9c5f5776fa040caf5fe73ff9
   GIT binary patch
   literal 593
   zc$@)I0<QguP)<h;3K|Lk000e1NJLTq000mG000mO0ssI2kdbIM00009a7bBm000XU
   z000XU0RWnu7ytkO2XskIMF-Uh9TW;VpMjwv0005-Nkl<ZD9@FWPs=e;7{<>W$NUkd
   zX$nnYLt$-$V!?uy+1V%`z&Eh=ah|duER<4|QWhju3gb^nF*8iYobxWG-qqXl=2~5M
   z*IoDB)sG^CfNuoBmqLTVU^<;@nwHP!1wrWd`{(mHo6VNXWtyh{alzqmsH*yYzpvLT
   zLdY<T=ks|woh-`&01!ej#(xbV1f|pI*=%;d-%F*E*X#ZH`4I%6SS+$EJDE&ct=8po
   ziN#{?_j|kD%Cd|oiqds`xm@;oJ-^?NG3Gdqrs?5u*zI;{nogxsx~^|Fn^Y?Gdc6<;
   zfMJ+iF1J`LMx&A2?dEwNW8ClebzPTbIh{@$hS6*`kH@1d%Lo7fA#}N1)oN7`gm$~V
   z+wDx#)OFqMcE{s!JN0-xhG8ItAjVkJwEcb`3WWlJfU2r?;Pd%dmR+q@mSri5q9_W-
   zaR2~ECX?B2w+zELozC0s*6Z~|QG^f{3I#<`?)Q7U-JZ|q5W;9Q8i_=pBuSzunx=U;
   z9C)5jBoYw9^?EHyQl(M}1OlQcCX>lXB*ODN003Z&P17_@)3Pi=i0wb04<W?v-u}7K
   zXmmQA+wDgE!qR9o8jr`%=ab_&uh(l?R=r;Tjiqon91I2-hIu?57~@*4h7h9uORK#=
   fQItJW-{SoTm)8|5##k|m00000NkvXXu0mjf{mKw4
   
 
 Import binary diff:
 
   $ hg revert binfile.bin
   $ rm binfile.bin
   $ hg import -mfoo b.diff
   applying b.diff
   $ cmp binfile.bin "$TESTDIR/binfile.bin"
 
 Rename binary file:
 
   $ hg mv binfile.bin renamed.bin
   $ hg diff --git
   diff --git a/binfile.bin b/renamed.bin
   rename from binfile.bin
   rename to renamed.bin
 
 Diff across many revisions:
 
   $ hg mv dst dst2
   $ hg ci -m 'mv dst dst2'
 
   $ echo >> start
   $ hg ci -m 'change start'
 
   $ hg revert -r -2 start
   $ hg mv dst2 dst3
   $ hg ci -m 'mv dst2 dst3; revert start'
 
   $ hg diff --git -r 9:11
   diff --git a/dst2 b/dst3
   rename from dst2
   rename to dst3
 
 Reversed:
 
   $ hg diff --git -r 11:9
   diff --git a/dst3 b/dst2
   rename from dst3
   rename to dst2
 
 
   $ echo a >> foo
   $ hg add foo
   $ hg ci -m 'add foo'
   $ echo b >> foo
   $ hg ci -m 'change foo'
   $ hg mv foo bar
   $ hg ci -m 'mv foo bar'
   $ echo c >> bar
   $ hg ci -m 'change bar'
 
 File created before r1 and renamed before r2:
 
   $ hg diff --git -r -3:-1
   diff --git a/foo b/bar
   rename from foo
   rename to bar
   --- a/foo
   +++ b/bar
   @@ -1,2 +1,3 @@
    a
    b
   +c
 
 Reversed:
 
   $ hg diff --git -r -1:-3
   diff --git a/bar b/foo
   rename from bar
   rename to foo
   --- a/bar
   +++ b/foo
   @@ -1,3 +1,2 @@
    a
    b
   -c
 
 File created in r1 and renamed before r2:
 
   $ hg diff --git -r -4:-1
   diff --git a/foo b/bar
   rename from foo
   rename to bar
   --- a/foo
   +++ b/bar
   @@ -1,1 +1,3 @@
    a
   +b
   +c
 
 Reversed:
 
   $ hg diff --git -r -1:-4
   diff --git a/bar b/foo
   rename from bar
   rename to foo
   --- a/bar
   +++ b/foo
   @@ -1,3 +1,1 @@
    a
   -b
   -c
 
 File created after r1 and renamed before r2:
 
   $ hg diff --git -r -5:-1
   diff --git a/bar b/bar
   new file mode 100644
   --- /dev/null
   +++ b/bar
   @@ -0,0 +1,3 @@
   +a
   +b
   +c
 
 Reversed:
 
   $ hg diff --git -r -1:-5
   diff --git a/bar b/bar
   deleted file mode 100644
   --- a/bar
   +++ /dev/null
   @@ -1,3 +0,0 @@
   -a
   -b
   -c
 
 
 Comparing with the working dir:
 
   $ echo >> start
   $ hg ci -m 'change start again'
 
   $ echo > created
   $ hg add created
   $ hg ci -m 'add created'
 
   $ hg mv created created2
   $ hg ci -m 'mv created created2'
 
   $ hg mv created2 created3
 
 There's a copy in the working dir:
 
   $ hg diff --git
   diff --git a/created2 b/created3
   rename from created2
   rename to created3
 
 There's another copy between the original rev and the wd:
 
   $ hg diff --git -r -2
   diff --git a/created b/created3
   rename from created
   rename to created3
 
 The source of the copy was created after the original rev:
 
   $ hg diff --git -r -3
   diff --git a/created3 b/created3
   new file mode 100644
   --- /dev/null
   +++ b/created3
   @@ -0,0 +1,1 @@
   +
   $ hg ci -m 'mv created2 created3'
 
 
   $ echo > brand-new
   $ hg add brand-new
   $ hg ci -m 'add brand-new'
   $ hg mv brand-new brand-new2
 
 Created in parent of wd; renamed in the wd:
 
   $ hg diff --git
   diff --git a/brand-new b/brand-new2
   rename from brand-new
   rename to brand-new2
 
 Created between r1 and parent of wd; renamed in the wd:
 
   $ hg diff --git -r -2
   diff --git a/brand-new2 b/brand-new2
   new file mode 100644
   --- /dev/null
   +++ b/brand-new2
   @@ -0,0 +1,1 @@
   +
   $ hg ci -m 'mv brand-new brand-new2'
 
 One file is copied to many destinations and removed:
 
   $ hg cp brand-new2 brand-new3
   $ hg mv brand-new2 brand-new3-2
   $ hg ci -m 'multiple renames/copies'
   $ hg diff --git -r -2 -r -1
   diff --git a/brand-new2 b/brand-new3
   rename from brand-new2
   rename to brand-new3
   diff --git a/brand-new2 b/brand-new3-2
   copy from brand-new2
   copy to brand-new3-2
 
 Reversed:
 
   $ hg diff --git -r -1 -r -2
   diff --git a/brand-new3 b/brand-new2
   rename from brand-new3
   rename to brand-new2
   diff --git a/brand-new3-2 b/brand-new3-2
   deleted file mode 100644
   --- a/brand-new3-2
   +++ /dev/null
   @@ -1,1 +0,0 @@
   -
 
 There should be a trailing TAB if there are spaces in the file name:
 
   $ echo foo > 'with spaces'
   $ hg add 'with spaces'
   $ hg diff --git
   diff --git a/with spaces b/with spaces
   new file mode 100644
   --- /dev/null
   +++ b/with spaces	
   @@ -0,0 +1,1 @@
   +foo
   $ hg ci -m 'add filename with spaces'
 

tests/test-import-bypass.t

@@ -1,267 +1,268 b''
-  $ "$TESTDIR/hghave" symlink execbit || exit 80
-
   $ echo "[extensions]" >> $HGRCPATH
   $ echo "purge=" >> $HGRCPATH
   $ echo "graphlog=" >> $HGRCPATH
 
   $ shortlog() {
   >     hg glog --template '{rev}:{node|short} {author} {date|hgdate} - {branch} - {desc|firstline}\n'
   > }
 
 Test --bypass with other options
 
   $ hg init repo-options
   $ cd repo-options
   $ echo a > a
   $ hg ci -Am adda
   adding a
   $ echo a >> a
   $ hg branch foo
   marked working directory as branch foo
   (branches are permanent and global, did you want a bookmark?)
   $ hg ci -Am changea
   $ hg export . > ../test.diff
   $ hg up null
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
 
 Test importing an existing revision
 
   $ hg import --bypass --exact ../test.diff
   applying ../test.diff
   $ shortlog
   o  1:4e322f7ce8e3 test 0 0 - foo - changea
   |
   o  0:07f494440405 test 0 0 - default - adda
   
 
 Test failure without --exact
 
   $ hg import --bypass ../test.diff
   applying ../test.diff
   unable to find 'a' for patching
   abort: patch failed to apply
   [255]
   $ hg st
   $ shortlog
   o  1:4e322f7ce8e3 test 0 0 - foo - changea
   |
   o  0:07f494440405 test 0 0 - default - adda
   
 
 Test --user, --date and --message
 
   $ hg up 0
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg import --bypass --u test2 -d '1 0' -m patch2 ../test.diff
   applying ../test.diff
   $ cat .hg/last-message.txt
   patch2 (no-eol)
   $ shortlog
   o  2:2e127d1da504 test2 1 0 - default - patch2
   |
   | o  1:4e322f7ce8e3 test 0 0 - foo - changea
   |/
   @  0:07f494440405 test 0 0 - default - adda
   
   $ hg rollback
   repository tip rolled back to revision 1 (undo import)
 
 Test --import-branch
 
   $ hg import --bypass --import-branch ../test.diff
   applying ../test.diff
   $ shortlog
   o  1:4e322f7ce8e3 test 0 0 - foo - changea
   |
   @  0:07f494440405 test 0 0 - default - adda
   
   $ hg rollback
   repository tip rolled back to revision 1 (undo import)
 
 Test --strip
 
   $ hg import --bypass --strip 0 - <<EOF
   > # HG changeset patch
   > # User test
   > # Date 0 0
   > # Branch foo
   > # Node ID 4e322f7ce8e3e4203950eac9ece27bf7e45ffa6c
   > # Parent  07f4944404050f47db2e5c5071e0e84e7a27bba9
   > changea
   > 
   > diff -r 07f494440405 -r 4e322f7ce8e3 a
   > --- a	Thu Jan 01 00:00:00 1970 +0000
   > +++ a	Thu Jan 01 00:00:00 1970 +0000
   > @@ -1,1 +1,2 @@
   >  a
   > +a
   > EOF
   applying patch from stdin
   $ hg rollback
   repository tip rolled back to revision 1 (undo import)
 
 Test unsupported combinations
 
   $ hg import --bypass --no-commit ../test.diff
   abort: cannot use --no-commit with --bypass
   [255]
   $ hg import --bypass --similarity 50 ../test.diff
   abort: cannot use --similarity with --bypass
   [255]
 
 Test commit editor
 
   $ cat > ../test.diff <<EOF
   > diff -r 07f494440405 -r 4e322f7ce8e3 a
   > --- a/a	Thu Jan 01 00:00:00 1970 +0000
   > +++ b/a	Thu Jan 01 00:00:00 1970 +0000
   > @@ -1,1 +1,2 @@
   > -a
   > +b
   > +c
   > EOF
   $ HGEDITOR=cat hg import --bypass ../test.diff
   applying ../test.diff
   
   
   HG: Enter commit message.  Lines beginning with 'HG:' are removed.
   HG: Leave message empty to abort commit.
   HG: --
   HG: user: test
   HG: branch 'default'
   HG: changed a
   abort: empty commit message
   [255]
 
 Test patch.eol is handled
 
   $ python -c 'file("a", "wb").write("a\r\n")'
   $ hg ci -m makeacrlf
   $ hg import -m 'should fail because of eol' --bypass ../test.diff
   applying ../test.diff
   patching file a
   Hunk #1 FAILED at 0
   abort: patch failed to apply
   [255]
   $ hg --config patch.eol=auto import -d '0 0' -m 'test patch.eol' --bypass ../test.diff
   applying ../test.diff
   $ shortlog
   o  3:c606edafba99 test 0 0 - default - test patch.eol
   |
   @  2:872023de769d test 0 0 - default - makeacrlf
   |
   | o  1:4e322f7ce8e3 test 0 0 - foo - changea
   |/
   o  0:07f494440405 test 0 0 - default - adda
   
 
 Test applying multiple patches
 
   $ hg up -qC 0
   $ echo e > e
   $ hg ci -Am adde
   adding e
   created new head
   $ hg export . > ../patch1.diff
   $ hg up -qC 1
   $ echo f > f
   $ hg ci -Am addf
   adding f
   $ hg export . > ../patch2.diff
   $ cd ..
   $ hg clone -r1 repo-options repo-multi1
   adding changesets
   adding manifests
   adding file changes
   added 2 changesets with 2 changes to 1 files
   updating to branch foo
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd repo-multi1
   $ hg up 0
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg import --bypass ../patch1.diff ../patch2.diff
   applying ../patch1.diff
   applying ../patch2.diff
   $ shortlog
   o  3:bc8ca3f8a7c4 test 0 0 - default - addf
   |
   o  2:16581080145e test 0 0 - default - adde
   |
   | o  1:4e322f7ce8e3 test 0 0 - foo - changea
   |/
   @  0:07f494440405 test 0 0 - default - adda
   
 
 Test applying multiple patches with --exact
 
   $ cd ..
   $ hg clone -r1 repo-options repo-multi2
   adding changesets
   adding manifests
   adding file changes
   added 2 changesets with 2 changes to 1 files
   updating to branch foo
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd repo-multi2
   $ hg import --bypass --exact ../patch1.diff ../patch2.diff
   applying ../patch1.diff
   applying ../patch2.diff
   $ shortlog
   o  3:d60cb8989666 test 0 0 - foo - addf
   |
   | o  2:16581080145e test 0 0 - default - adde
   | |
   @ |  1:4e322f7ce8e3 test 0 0 - foo - changea
   |/
   o  0:07f494440405 test 0 0 - default - adda
   
 
   $ cd ..
 
+#if symlink execbit
+
 Test complicated patch with --exact
 
   $ hg init repo-exact
   $ cd repo-exact
   $ echo a > a
   $ echo c > c
   $ echo d > d
   $ echo e > e
   $ echo f > f
   $ chmod +x f
   $ ln -s c linkc
   $ hg ci -Am t
   adding a
   adding c
   adding d
   adding e
   adding f
   adding linkc
   $ hg cp a aa1
   $ echo b >> a
   $ echo b > b
   $ hg add b
   $ hg cp a aa2
   $ echo aa >> aa2
   $ chmod +x e
   $ chmod -x f
   $ ln -s a linka
   $ hg rm d
   $ hg rm linkc
   $ hg mv c cc
   $ hg ci -m patch
   $ hg export --git . > ../test.diff
   $ hg up -C null
   0 files updated, 0 files merged, 7 files removed, 0 files unresolved
   $ hg purge
   $ hg st
   $ hg import --bypass --exact ../test.diff
   applying ../test.diff
 
 The patch should have matched the exported revision and generated no additional
 data. If not, diff both heads to debug it.
 
   $ shortlog
   o  1:2978fd5c8aa4 test 0 0 - default - patch
   |
   o  0:a0e19e636a43 test 0 0 - default - t
   
+#endif

tests/test-mq.t

@@ -1,1529 +1,1541 b''
-  $ "$TESTDIR/hghave" execbit || exit 80
-
   $ checkundo()
   > {
   >     if [ -f .hg/store/undo ]; then
   >     echo ".hg/store/undo still exists after $1"
   >     fi
   > }
 
   $ echo "[extensions]" >> $HGRCPATH
   $ echo "mq=" >> $HGRCPATH
 
   $ echo "[mq]" >> $HGRCPATH
   $ echo "plain=true" >> $HGRCPATH
 
 
 help
 
   $ hg help mq
   mq extension - manage a stack of patches
   
   This extension lets you work with a stack of patches in a Mercurial
   repository. It manages two stacks of patches - all known patches, and applied
   patches (subset of known patches).
   
   Known patches are represented as patch files in the .hg/patches directory.
   Applied patches are both patch files and changesets.
   
   Common tasks (use "hg help command" for more details):
   
     create new patch                          qnew
     import existing patch                     qimport
   
     print patch series                        qseries
     print applied patches                     qapplied
   
     add known patch to applied stack          qpush
     remove patch from applied stack           qpop
     refresh contents of top applied patch     qrefresh
   
   By default, mq will automatically use git patches when required to avoid
   losing file mode changes, copy records, binary files or empty files creations
   or deletions. This behaviour can be configured with:
   
     [mq]
     git = auto/keep/yes/no
   
   If set to 'keep', mq will obey the [diff] section configuration while
   preserving existing git patches upon qrefresh. If set to 'yes' or 'no', mq
   will override the [diff] section and always generate git or regular patches,
   possibly losing data in the second case.
   
   It may be desirable for mq changesets to be kept in the secret phase (see "hg
   help phases"), which can be enabled with the following setting:
   
     [mq]
     secret = True
   
   You will by default be managing a patch queue named "patches". You can create
   other, independent patch queues with the "hg qqueue" command.
   
   If the working directory contains uncommitted files, qpush, qpop and qgoto
   abort immediately. If -f/--force is used, the changes are discarded. Setting:
   
     [mq]
     keepchanges = True
   
   make them behave as if --keep-changes were passed, and non-conflicting local
   changes will be tolerated and preserved. If incompatible options such as
   -f/--force or --exact are passed, this setting is ignored.
   
   list of commands:
   
    qapplied      print the patches already applied
    qclone        clone main and patch repository at same time
    qdelete       remove patches from queue
    qdiff         diff of the current patch and subsequent modifications
    qfinish       move applied patches into repository history
    qfold         fold the named patches into the current patch
    qgoto         push or pop patches until named patch is at top of stack
    qguard        set or print guards for a patch
    qheader       print the header of the topmost or specified patch
    qimport       import a patch or existing changeset
    qnew          create a new patch
    qnext         print the name of the next pushable patch
    qpop          pop the current patch off the stack
    qprev         print the name of the preceding applied patch
    qpush         push the next patch onto the stack
    qqueue        manage multiple patch queues
    qrefresh      update the current patch
    qrename       rename a patch
    qselect       set or print guarded patches to push
    qseries       print the entire series file
    qtop          print the name of the current patch
    qunapplied    print the patches not yet applied
    strip         strip changesets and all their descendants from the repository
   
   use "hg -v help mq" to show builtin aliases and global options
 
   $ hg init a
   $ cd a
   $ echo a > a
   $ hg ci -Ama
   adding a
 
   $ hg clone . ../k
   updating to branch default
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
   $ mkdir b
   $ echo z > b/z
   $ hg ci -Ama
   adding b/z
 
 
 qinit
 
   $ hg qinit
 
   $ cd ..
   $ hg init b
 
 
 -R qinit
 
   $ hg -R b qinit
 
   $ hg init c
 
 
 qinit -c
 
   $ hg --cwd c qinit -c
   $ hg -R c/.hg/patches st
   A .hgignore
   A series
 
 
 qinit; qinit -c
 
   $ hg init d
   $ cd d
   $ hg qinit
   $ hg qinit -c
 
 qinit -c should create both files if they don't exist
 
   $ cat .hg/patches/.hgignore
   ^\.hg
   ^\.mq
   syntax: glob
   status
   guards
   $ cat .hg/patches/series
   $ hg qinit -c
   abort: repository $TESTTMP/d/.hg/patches already exists! (glob)
   [255]
   $ cd ..
 
   $ echo '% qinit; <stuff>; qinit -c'
   % qinit; <stuff>; qinit -c
   $ hg init e
   $ cd e
   $ hg qnew A
   $ checkundo qnew
   $ echo foo > foo
   $ hg phase -r qbase
   0: draft
   $ hg add foo
   $ hg qrefresh
   $ hg phase -r qbase
   0: draft
   $ hg qnew B
   $ echo >> foo
   $ hg qrefresh
   $ echo status >> .hg/patches/.hgignore
   $ echo bleh >> .hg/patches/.hgignore
   $ hg qinit -c
   adding .hg/patches/A (glob)
   adding .hg/patches/B (glob)
   $ hg -R .hg/patches status
   A .hgignore
   A A
   A B
   A series
 
 qinit -c shouldn't touch these files if they already exist
 
   $ cat .hg/patches/.hgignore
   status
   bleh
   $ cat .hg/patches/series
   A
   B
 
 add an untracked file
 
   $ echo >> .hg/patches/flaf
 
 status --mq with color (issue2096)
 
   $ hg status --mq --config extensions.color= --config color.mode=ansi --color=always
   \x1b[0;32;1mA .hgignore\x1b[0m (esc)
   \x1b[0;32;1mA A\x1b[0m (esc)
   \x1b[0;32;1mA B\x1b[0m (esc)
   \x1b[0;32;1mA series\x1b[0m (esc)
   \x1b[0;35;1;4m? flaf\x1b[0m (esc)
 
 try the --mq option on a command provided by an extension
 
   $ hg purge --mq --verbose --config extensions.purge=
   Removing file flaf
 
   $ cd ..
 
 init --mq without repo
 
   $ mkdir f
   $ cd f
   $ hg init --mq
   abort: there is no Mercurial repository here (.hg not found)
   [255]
   $ cd ..
 
 init --mq with repo path
 
   $ hg init g
   $ hg init --mq g
   $ test -d g/.hg/patches/.hg
 
 init --mq with nonexistent directory
 
   $ hg init --mq nonexistentdir
   abort: repository nonexistentdir not found!
   [255]
 
 
 init --mq with bundle (non "local")
 
   $ hg -R a bundle --all a.bundle >/dev/null
   $ hg init --mq a.bundle
   abort: only a local queue repository may be initialized
   [255]
 
   $ cd a
 
   $ hg qnew -m 'foo bar' test.patch
 
   $ echo '# comment' > .hg/patches/series.tmp
   $ echo >> .hg/patches/series.tmp # empty line
   $ cat .hg/patches/series >> .hg/patches/series.tmp
   $ mv .hg/patches/series.tmp .hg/patches/series
 
 
 qrefresh
 
   $ echo a >> a
   $ hg qrefresh
   $ cat .hg/patches/test.patch
   foo bar
   
   diff -r [a-f0-9]* a (re)
   --- a/a\t(?P<date>.*) (re)
   \+\+\+ b/a\t(?P<date2>.*) (re)
   @@ -1,1 +1,2 @@
    a
   +a
 
 empty qrefresh
 
   $ hg qrefresh -X a
 
 revision:
 
   $ hg diff -r -2 -r -1
 
 patch:
 
   $ cat .hg/patches/test.patch
   foo bar
   
 
 working dir diff:
 
   $ hg diff --nodates -q
   --- a/a
   +++ b/a
   @@ -1,1 +1,2 @@
    a
   +a
 
 restore things
 
   $ hg qrefresh
   $ checkundo qrefresh
 
 
 qpop
 
   $ hg qpop
   popping test.patch
   patch queue now empty
   $ checkundo qpop
 
 
 qpush with dump of tag cache
 Dump the tag cache to ensure that it has exactly one head after qpush.
 
   $ rm -f .hg/cache/tags
   $ hg tags > /dev/null
 
 .hg/cache/tags (pre qpush):
 
   $ cat .hg/cache/tags
   1 [\da-f]{40} (re)
   
   $ hg qpush
   applying test.patch
   now at: test.patch
   $ hg phase -r qbase
   2: draft
   $ hg tags > /dev/null
 
 .hg/cache/tags (post qpush):
 
   $ cat .hg/cache/tags
   2 [\da-f]{40} (re)
   
   $ checkundo qpush
   $ cd ..
 
 
 pop/push outside repo
   $ hg -R a qpop
   popping test.patch
   patch queue now empty
   $ hg -R a qpush
   applying test.patch
   now at: test.patch
 
   $ cd a
   $ hg qnew test2.patch
 
 qrefresh in subdir
 
   $ cd b
   $ echo a > a
   $ hg add a
   $ hg qrefresh
 
 pop/push -a in subdir
 
   $ hg qpop -a
   popping test2.patch
   popping test.patch
   patch queue now empty
   $ hg --traceback qpush -a
   applying test.patch
   applying test2.patch
   now at: test2.patch
 
 
 setting columns & formatted tests truncating (issue1912)
 
   $ COLUMNS=4 hg qseries --config ui.formatted=true
   test.patch
   test2.patch
   $ COLUMNS=20 hg qseries --config ui.formatted=true -vs
   0 A test.patch: f...
   1 A test2.patch: 
   $ hg qpop
   popping test2.patch
   now at: test.patch
   $ hg qseries -vs
   0 A test.patch: foo bar
   1 U test2.patch: 
   $ hg sum | grep mq
   mq:     1 applied, 1 unapplied
   $ hg qpush
   applying test2.patch
   now at: test2.patch
   $ hg sum | grep mq
   mq:     2 applied
   $ hg qapplied
   test.patch
   test2.patch
   $ hg qtop
   test2.patch
 
 
 prev
 
   $ hg qapp -1
   test.patch
 
 next
 
   $ hg qunapp -1
   all patches applied
   [1]
 
   $ hg qpop
   popping test2.patch
   now at: test.patch
 
 commit should fail
 
   $ hg commit
   abort: cannot commit over an applied mq patch
   [255]
 
 push should fail if draft
 
   $ hg push ../../k
   pushing to ../../k
   abort: source has mq patches applied
   [255]
 
 
 import should fail
 
   $ hg st .
   $ echo foo >> ../a
   $ hg diff > ../../import.diff
   $ hg revert --no-backup ../a
   $ hg import ../../import.diff
   abort: cannot import over an applied patch
   [255]
   $ hg st
 
 import --no-commit should succeed
 
   $ hg import --no-commit ../../import.diff
   applying ../../import.diff
   $ hg st
   M a
   $ hg revert --no-backup ../a
 
 
 qunapplied
 
   $ hg qunapplied
   test2.patch
 
 
 qpush/qpop with index
 
   $ hg qnew test1b.patch
   $ echo 1b > 1b
   $ hg add 1b
   $ hg qrefresh
   $ hg qpush 2
   applying test2.patch
   now at: test2.patch
   $ hg qpop 0
   popping test2.patch
   popping test1b.patch
   now at: test.patch
   $ hg qpush test.patch+1
   applying test1b.patch
   now at: test1b.patch
   $ hg qpush test.patch+2
   applying test2.patch
   now at: test2.patch
   $ hg qpop test2.patch-1
   popping test2.patch
   now at: test1b.patch
   $ hg qpop test2.patch-2
   popping test1b.patch
   now at: test.patch
   $ hg qpush test1b.patch+1
   applying test1b.patch
   applying test2.patch
   now at: test2.patch
 
 
 qpush --move
 
   $ hg qpop -a
   popping test2.patch
   popping test1b.patch
   popping test.patch
   patch queue now empty
   $ hg qguard test1b.patch -- -negguard
   $ hg qguard test2.patch -- +posguard
   $ hg qpush --move test2.patch # can't move guarded patch
   cannot push 'test2.patch' - guarded by '+posguard'
   [1]
   $ hg qselect posguard
   number of unguarded, unapplied patches has changed from 2 to 3
   $ hg qpush --move test2.patch # move to front
   applying test2.patch
   now at: test2.patch
   $ hg qpush --move test1b.patch # negative guard unselected
   applying test1b.patch
   now at: test1b.patch
   $ hg qpush --move test.patch # noop move
   applying test.patch
   now at: test.patch
   $ hg qseries -v
   0 A test2.patch
   1 A test1b.patch
   2 A test.patch
   $ hg qpop -a
   popping test.patch
   popping test1b.patch
   popping test2.patch
   patch queue now empty
 
 cleaning up
 
   $ hg qselect --none
   guards deactivated
   number of unguarded, unapplied patches has changed from 3 to 2
   $ hg qguard --none test1b.patch
   $ hg qguard --none test2.patch
   $ hg qpush --move test.patch
   applying test.patch
   now at: test.patch
   $ hg qpush --move test1b.patch
   applying test1b.patch
   now at: test1b.patch
   $ hg qpush --move bogus # nonexistent patch
   abort: patch bogus not in series
   [255]
   $ hg qpush --move # no patch
   abort: please specify the patch to move
   [255]
   $ hg qpush --move test.patch # already applied
   abort: cannot push to a previous patch: test.patch
   [255]
   $ sed '2i\
   > # make qtip index different in series and fullseries
   > ' `hg root`/.hg/patches/series > $TESTTMP/sedtmp
   $ cp $TESTTMP/sedtmp `hg root`/.hg/patches/series
   $ cat `hg root`/.hg/patches/series
   # comment
   # make qtip index different in series and fullseries
   
   test.patch
   test1b.patch
   test2.patch
   $ hg qpush --move test2.patch
   applying test2.patch
   now at: test2.patch
 
 
 series after move
 
   $ cat `hg root`/.hg/patches/series
   # comment
   # make qtip index different in series and fullseries
   
   test.patch
   test1b.patch
   test2.patch
 
 
 pop, qapplied, qunapplied
 
   $ hg qseries -v
   0 A test.patch
   1 A test1b.patch
   2 A test2.patch
 
 qapplied -1 test.patch
 
   $ hg qapplied -1 test.patch
   only one patch applied
   [1]
 
 qapplied -1 test1b.patch
 
   $ hg qapplied -1 test1b.patch
   test.patch
 
 qapplied -1 test2.patch
 
   $ hg qapplied -1 test2.patch
   test1b.patch
 
 qapplied -1
 
   $ hg qapplied -1
   test1b.patch
 
 qapplied
 
   $ hg qapplied
   test.patch
   test1b.patch
   test2.patch
 
 qapplied test1b.patch
 
   $ hg qapplied test1b.patch
   test.patch
   test1b.patch
 
 qunapplied -1
 
   $ hg qunapplied -1
   all patches applied
   [1]
 
 qunapplied
 
   $ hg qunapplied
 
 popping
 
   $ hg qpop
   popping test2.patch
   now at: test1b.patch
 
 qunapplied -1
 
   $ hg qunapplied -1
   test2.patch
 
 qunapplied
 
   $ hg qunapplied
   test2.patch
 
 qunapplied test2.patch
 
   $ hg qunapplied test2.patch
 
 qunapplied -1 test2.patch
 
   $ hg qunapplied -1 test2.patch
   all patches applied
   [1]
 
 popping -a
 
   $ hg qpop -a
   popping test1b.patch
   popping test.patch
   patch queue now empty
 
 qapplied
 
   $ hg qapplied
 
 qapplied -1
 
   $ hg qapplied -1
   no patches applied
   [1]
   $ hg qpush
   applying test.patch
   now at: test.patch
 
 
 push should succeed
 
   $ hg qpop -a
   popping test.patch
   patch queue now empty
   $ hg push ../../k
   pushing to ../../k
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
 
 
 we want to start with some patches applied
 
   $ hg qpush -a
   applying test.patch
   applying test1b.patch
   applying test2.patch
   now at: test2.patch
 
 % pops all patches and succeeds
 
   $ hg qpop -a
   popping test2.patch
   popping test1b.patch
   popping test.patch
   patch queue now empty
 
 % does nothing and succeeds
 
   $ hg qpop -a
   no patches applied
 
 % fails - nothing else to pop
 
   $ hg qpop
   no patches applied
   [1]
 
 % pushes a patch and succeeds
 
   $ hg qpush
   applying test.patch
   now at: test.patch
 
 % pops a patch and succeeds
 
   $ hg qpop
   popping test.patch
   patch queue now empty
 
 % pushes up to test1b.patch and succeeds
 
   $ hg qpush test1b.patch
   applying test.patch
   applying test1b.patch
   now at: test1b.patch
 
 % does nothing and succeeds
 
   $ hg qpush test1b.patch
   qpush: test1b.patch is already at the top
 
 % does nothing and succeeds
 
   $ hg qpop test1b.patch
   qpop: test1b.patch is already at the top
 
 % fails - can't push to this patch
 
   $ hg qpush test.patch
   abort: cannot push to a previous patch: test.patch
   [255]
 
 % fails - can't pop to this patch
 
   $ hg qpop test2.patch
   abort: patch test2.patch is not applied
   [255]
 
 % pops up to test.patch and succeeds
 
   $ hg qpop test.patch
   popping test1b.patch
   now at: test.patch
 
 % pushes all patches and succeeds
 
   $ hg qpush -a
   applying test1b.patch
   applying test2.patch
   now at: test2.patch
 
 % does nothing and succeeds
 
   $ hg qpush -a
   all patches are currently applied
 
 % fails - nothing else to push
 
   $ hg qpush
   patch series already fully applied
   [1]
 
 % does nothing and succeeds
 
   $ hg qpush test2.patch
   qpush: test2.patch is already at the top
 
 strip
 
   $ cd ../../b
   $ echo x>x
   $ hg ci -Ama
   adding x
   $ hg strip tip
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   saved backup bundle to $TESTTMP/b/.hg/strip-backup/*-backup.hg (glob)
   $ hg unbundle .hg/strip-backup/*
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
   (run 'hg update' to get a working copy)
 
 
 strip with local changes, should complain
 
   $ hg up
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo y>y
   $ hg add y
   $ hg strip tip
   abort: local changes found
   [255]
 
 --force strip with local changes
 
   $ hg strip -f tip
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   saved backup bundle to $TESTTMP/b/.hg/strip-backup/*-backup.hg (glob)
 
 
 cd b; hg qrefresh
 
   $ hg init refresh
   $ cd refresh
   $ echo a > a
   $ hg ci -Ama
   adding a
   $ hg qnew -mfoo foo
   $ echo a >> a
   $ hg qrefresh
   $ mkdir b
   $ cd b
   $ echo f > f
   $ hg add f
   $ hg qrefresh
   $ cat ../.hg/patches/foo
   foo
   
   diff -r cb9a9f314b8b a
   --- a/a\t(?P<date>.*) (re)
   \+\+\+ b/a\t(?P<date>.*) (re)
   @@ -1,1 +1,2 @@
    a
   +a
   diff -r cb9a9f314b8b b/f
   --- /dev/null\t(?P<date>.*) (re)
   \+\+\+ b/b/f\t(?P<date>.*) (re)
   @@ -0,0 +1,1 @@
   +f
 
 hg qrefresh .
 
   $ hg qrefresh .
   $ cat ../.hg/patches/foo
   foo
   
   diff -r cb9a9f314b8b b/f
   --- /dev/null\t(?P<date>.*) (re)
   \+\+\+ b/b/f\t(?P<date>.*) (re)
   @@ -0,0 +1,1 @@
   +f
   $ hg status
   M a
 
 
 qpush failure
 
   $ cd ..
   $ hg qrefresh
   $ hg qnew -mbar bar
   $ echo foo > foo
   $ echo bar > bar
   $ hg add foo bar
   $ hg qrefresh
   $ hg qpop -a
   popping bar
   popping foo
   patch queue now empty
   $ echo bar > foo
   $ hg qpush -a
   applying foo
   applying bar
   file foo already exists
   1 out of 1 hunks FAILED -- saving rejects to file foo.rej
   patch failed, unable to continue (try -v)
   patch failed, rejects left in working dir
   errors during apply, please fix and refresh bar
   [2]
   $ hg st
   ? foo
   ? foo.rej
 
 
 mq tags
 
   $ hg log --template '{rev} {tags}\n' -r qparent:qtip
   0 qparent
   1 foo qbase
   2 bar qtip tip
 
 mq revset
 
   $ hg log -r 'mq()' --template '{rev}\n'
   1
   2
   $ hg help revsets | grep -i mq
       "mq()"
         Changesets managed by MQ.
 
 bad node in status
 
   $ hg qpop
   popping bar
   now at: foo
   $ hg strip -qn tip
   $ hg tip
   changeset:   0:cb9a9f314b8b
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     a
   
   $ hg branches
   default                        0:cb9a9f314b8b
   $ hg qpop
   no patches applied
   [1]
 
   $ cat >>$HGRCPATH <<EOF
   > [diff]
   > git = True
   > EOF
   $ cd ..
   $ hg init git
   $ cd git
   $ hg qinit
 
   $ hg qnew -m'new file' new
   $ echo foo > new
+#if execbit
   $ chmod +x new
+#endif
   $ hg add new
   $ hg qrefresh
+#if execbit
   $ cat .hg/patches/new
   new file
   
   diff --git a/new b/new
   new file mode 100755
   --- /dev/null
   +++ b/new
   @@ -0,0 +1,1 @@
   +foo
+#else
+  $ cat .hg/patches/new
+  new file
+  
+  diff --git a/new b/new
+  new file mode 100644
+  --- /dev/null
+  +++ b/new
+  @@ -0,0 +1,1 @@
+  +foo
+#endif
 
   $ hg qnew -m'copy file' copy
   $ hg cp new copy
   $ hg qrefresh
   $ cat .hg/patches/copy
   copy file
   
   diff --git a/new b/copy
   copy from new
   copy to copy
 
   $ hg qpop
   popping copy
   now at: new
   $ hg qpush
   applying copy
   now at: copy
   $ hg qdiff
   diff --git a/new b/copy
   copy from new
   copy to copy
   $ cat >>$HGRCPATH <<EOF
   > [diff]
   > git = False
   > EOF
   $ hg qdiff --git
   diff --git a/new b/copy
   copy from new
   copy to copy
   $ cd ..
 
 empty lines in status
 
   $ hg init emptystatus
   $ cd emptystatus
   $ hg qinit
   $ printf '\n\n' > .hg/patches/status
   $ hg qser
   $ cd ..
 
 bad line in status (without ":")
 
   $ hg init badstatus
   $ cd badstatus
   $ hg qinit
   $ printf 'babar has no colon in this line\n' > .hg/patches/status
   $ hg qser
   malformated mq status line: ['babar has no colon in this line']
   $ cd ..
 
 
 test file addition in slow path
 
   $ hg init slow
   $ cd slow
   $ hg qinit
   $ echo foo > foo
   $ hg add foo
   $ hg ci -m 'add foo'
   $ hg qnew bar
   $ echo bar > bar
   $ hg add bar
   $ hg mv foo baz
   $ hg qrefresh --git
   $ hg up -C 0
   1 files updated, 0 files merged, 2 files removed, 0 files unresolved
   $ echo >> foo
   $ hg ci -m 'change foo'
   created new head
   $ hg up -C 1
   2 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg qrefresh --git
   $ cat .hg/patches/bar
   diff --git a/bar b/bar
   new file mode 100644
   --- /dev/null
   +++ b/bar
   @@ -0,0 +1,1 @@
   +bar
   diff --git a/foo b/baz
   rename from foo
   rename to baz
   $ hg log -v --template '{rev} {file_copies}\n' -r .
   2 baz (foo)
   $ hg qrefresh --git
   $ cat .hg/patches/bar
   diff --git a/bar b/bar
   new file mode 100644
   --- /dev/null
   +++ b/bar
   @@ -0,0 +1,1 @@
   +bar
   diff --git a/foo b/baz
   rename from foo
   rename to baz
   $ hg log -v --template '{rev} {file_copies}\n' -r .
   2 baz (foo)
   $ hg qrefresh
   $ grep 'diff --git' .hg/patches/bar
   diff --git a/bar b/bar
   diff --git a/foo b/baz
 
 
 test file move chains in the slow path
 
   $ hg up -C 1
   1 files updated, 0 files merged, 2 files removed, 0 files unresolved
   $ echo >> foo
   $ hg ci -m 'change foo again'
   $ hg up -C 2
   2 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg mv bar quux
   $ hg mv baz bleh
   $ hg qrefresh --git
   $ cat .hg/patches/bar
   diff --git a/foo b/bleh
   rename from foo
   rename to bleh
   diff --git a/quux b/quux
   new file mode 100644
   --- /dev/null
   +++ b/quux
   @@ -0,0 +1,1 @@
   +bar
   $ hg log -v --template '{rev} {file_copies}\n' -r .
   3 bleh (foo)
   $ hg mv quux fred
   $ hg mv bleh barney
   $ hg qrefresh --git
   $ cat .hg/patches/bar
   diff --git a/foo b/barney
   rename from foo
   rename to barney
   diff --git a/fred b/fred
   new file mode 100644
   --- /dev/null
   +++ b/fred
   @@ -0,0 +1,1 @@
   +bar
   $ hg log -v --template '{rev} {file_copies}\n' -r .
   3 barney (foo)
 
 
 refresh omitting an added file
 
   $ hg qnew baz
   $ echo newfile > newfile
   $ hg add newfile
   $ hg qrefresh
   $ hg st -A newfile
   C newfile
   $ hg qrefresh -X newfile
   $ hg st -A newfile
   A newfile
   $ hg revert newfile
   $ rm newfile
   $ hg qpop
   popping baz
   now at: bar
   $ hg qdel baz
 
 
 create a git patch
 
   $ echo a > alexander
   $ hg add alexander
   $ hg qnew -f --git addalexander
   $ grep diff .hg/patches/addalexander
   diff --git a/alexander b/alexander
 
 
 create a git binary patch
 
   $ cat > writebin.py <<EOF
   > import sys
   > path = sys.argv[1]
   > open(path, 'wb').write('BIN\x00ARY')
   > EOF
   $ python writebin.py bucephalus
 
   $ python "$TESTDIR/md5sum.py" bucephalus
   8ba2a2f3e77b55d03051ff9c24ad65e7  bucephalus
   $ hg add bucephalus
   $ hg qnew -f --git addbucephalus
   $ grep diff .hg/patches/addbucephalus
   diff --git a/bucephalus b/bucephalus
 
 
 check binary patches can be popped and pushed
 
   $ hg qpop
   popping addbucephalus
   now at: addalexander
   $ test -f bucephalus && echo % bucephalus should not be there
   [1]
   $ hg qpush
   applying addbucephalus
   now at: addbucephalus
   $ test -f bucephalus
   $ python "$TESTDIR/md5sum.py" bucephalus
   8ba2a2f3e77b55d03051ff9c24ad65e7  bucephalus
 
 
 
 strip again
 
   $ cd ..
   $ hg init strip
   $ cd strip
   $ touch foo
   $ hg add foo
   $ hg ci -m 'add foo'
   $ echo >> foo
   $ hg ci -m 'change foo 1'
   $ hg up -C 0
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo 1 >> foo
   $ hg ci -m 'change foo 2'
   created new head
   $ HGMERGE=true hg merge
   merging foo
   0 files updated, 1 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg ci -m merge
   $ hg log
   changeset:   3:99615015637b
   tag:         tip
   parent:      2:20cbbe65cff7
   parent:      1:d2871fc282d4
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     merge
   
   changeset:   2:20cbbe65cff7
   parent:      0:53245c60e682
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     change foo 2
   
   changeset:   1:d2871fc282d4
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     change foo 1
   
   changeset:   0:53245c60e682
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     add foo
   
   $ hg strip 1
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   saved backup bundle to $TESTTMP/b/strip/.hg/strip-backup/*-backup.hg (glob)
   $ checkundo strip
   $ hg log
   changeset:   1:20cbbe65cff7
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     change foo 2
   
   changeset:   0:53245c60e682
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     add foo
   
   $ cd ..
 
 
 qclone
 
   $ qlog()
   > {
   >     echo 'main repo:'
   >     hg log --template '    rev {rev}: {desc}\n'
   >     echo 'patch repo:'
   >     hg -R .hg/patches log --template '    rev {rev}: {desc}\n'
   > }
   $ hg init qclonesource
   $ cd qclonesource
   $ echo foo > foo
   $ hg add foo
   $ hg ci -m 'add foo'
   $ hg qinit
   $ hg qnew patch1
   $ echo bar >> foo
   $ hg qrefresh -m 'change foo'
   $ cd ..
 
 
 repo with unversioned patch dir
 
   $ hg qclone qclonesource failure
   abort: versioned patch repository not found (see init --mq)
   [255]
 
   $ cd qclonesource
   $ hg qinit -c
   adding .hg/patches/patch1 (glob)
   $ hg qci -m checkpoint
   $ qlog
   main repo:
       rev 1: change foo
       rev 0: add foo
   patch repo:
       rev 0: checkpoint
   $ cd ..
 
 
 repo with patches applied
 
   $ hg qclone qclonesource qclonedest
   updating to branch default
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd qclonedest
   $ qlog
   main repo:
       rev 0: add foo
   patch repo:
       rev 0: checkpoint
   $ cd ..
 
 
 repo with patches unapplied
 
   $ cd qclonesource
   $ hg qpop -a
   popping patch1
   patch queue now empty
   $ qlog
   main repo:
       rev 0: add foo
   patch repo:
       rev 0: checkpoint
   $ cd ..
   $ hg qclone qclonesource qclonedest2
   updating to branch default
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd qclonedest2
   $ qlog
   main repo:
       rev 0: add foo
   patch repo:
       rev 0: checkpoint
   $ cd ..
 
 
 Issue1033: test applying on an empty file
 
   $ hg init empty
   $ cd empty
   $ touch a
   $ hg ci -Am addempty
   adding a
   $ echo a > a
   $ hg qnew -f -e changea
   $ hg qpop
   popping changea
   patch queue now empty
   $ hg qpush
   applying changea
   now at: changea
   $ cd ..
 
 test qpush with --force, issue1087
 
   $ hg init forcepush
   $ cd forcepush
   $ echo hello > hello.txt
   $ echo bye > bye.txt
   $ hg ci -Ama
   adding bye.txt
   adding hello.txt
   $ hg qnew -d '0 0' empty
   $ hg qpop
   popping empty
   patch queue now empty
   $ echo world >> hello.txt
 
 
 qpush should fail, local changes
 
   $ hg qpush
   abort: local changes found
   [255]
 
 
 apply force, should not discard changes with empty patch
 
   $ hg qpush -f
   applying empty
   patch empty is empty
   now at: empty
   $ hg diff --config diff.nodates=True
   diff -r d58265112590 hello.txt
   --- a/hello.txt
   +++ b/hello.txt
   @@ -1,1 +1,2 @@
    hello
   +world
   $ hg qdiff --config diff.nodates=True
   diff -r 9ecee4f634e3 hello.txt
   --- a/hello.txt
   +++ b/hello.txt
   @@ -1,1 +1,2 @@
    hello
   +world
   $ hg log -l1 -p
   changeset:   1:d58265112590
   tag:         empty
   tag:         qbase
   tag:         qtip
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     imported patch empty
   
   
   $ hg qref -d '0 0'
   $ hg qpop
   popping empty
   patch queue now empty
   $ echo universe >> hello.txt
   $ echo universe >> bye.txt
 
 
 qpush should fail, local changes
 
   $ hg qpush
   abort: local changes found
   [255]
 
 
 apply force, should discard changes in hello, but not bye
 
   $ hg qpush -f --verbose
   applying empty
   saving current version of hello.txt as hello.txt.orig
   patching file hello.txt
   hello.txt
   now at: empty
   $ hg st
   M bye.txt
   ? hello.txt.orig
   $ hg diff --config diff.nodates=True
   diff -r ba252371dbc1 bye.txt
   --- a/bye.txt
   +++ b/bye.txt
   @@ -1,1 +1,2 @@
    bye
   +universe
   $ hg qdiff --config diff.nodates=True
   diff -r 9ecee4f634e3 bye.txt
   --- a/bye.txt
   +++ b/bye.txt
   @@ -1,1 +1,2 @@
    bye
   +universe
   diff -r 9ecee4f634e3 hello.txt
   --- a/hello.txt
   +++ b/hello.txt
   @@ -1,1 +1,3 @@
    hello
   +world
   +universe
 
 
 test popping revisions not in working dir ancestry
 
   $ hg qseries -v
   0 A empty
   $ hg up qparent
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg qpop
   popping empty
   patch queue now empty
 
   $ cd ..
   $ hg init deletion-order
   $ cd deletion-order
 
   $ touch a
   $ hg ci -Aqm0
 
   $ hg qnew rename-dir
   $ hg rm a
   $ hg qrefresh
 
   $ mkdir a b
   $ touch a/a b/b
   $ hg add -q a b
   $ hg qrefresh
 
 
 test popping must remove files added in subdirectories first
 
   $ hg qpop
   popping rename-dir
   patch queue now empty
   $ cd ..
 
 
 test case preservation through patch pushing especially on case
 insensitive filesystem
 
   $ hg init casepreserve
   $ cd casepreserve
 
   $ hg qnew add-file1
   $ echo a > TeXtFiLe.TxT
   $ hg add TeXtFiLe.TxT
   $ hg qrefresh
 
   $ hg qnew add-file2
   $ echo b > AnOtHeRFiLe.TxT
   $ hg add AnOtHeRFiLe.TxT
   $ hg qrefresh
 
   $ hg qnew modify-file
   $ echo c >> AnOtHeRFiLe.TxT
   $ hg qrefresh
 
   $ hg qapplied
   add-file1
   add-file2
   modify-file
   $ hg qpop -a
   popping modify-file
   popping add-file2
   popping add-file1
   patch queue now empty
 
 this qpush causes problems below, if case preservation on case
 insensitive filesystem is not enough:
 (1) unexpected "adding ..." messages are shown
 (2) patching fails in modification of (1) files
 
   $ hg qpush -a
   applying add-file1
   applying add-file2
   applying modify-file
   now at: modify-file
 
 Proper phase default with mq:
 
 1. mq.secret=false
 
   $ rm .hg/store/phaseroots
   $ hg phase 'qparent::'
   0: draft
   1: draft
   2: draft
   $ echo '[mq]' >> $HGRCPATH
   $ echo 'secret=true' >> $HGRCPATH
   $ rm -f .hg/store/phaseroots
   $ hg phase 'qparent::'
   0: secret
   1: secret
   2: secret
 
 Test that qfinish change phase when mq.secret=true
 
   $ hg qfinish qbase
   patch add-file1 finalized without changeset message
   $ hg phase 'all()'
   0: draft
   1: secret
   2: secret
 
 Test that qfinish respect phases.new-commit setting
 
   $ echo '[phases]' >> $HGRCPATH
   $ echo 'new-commit=secret' >> $HGRCPATH
   $ hg qfinish qbase
   patch add-file2 finalized without changeset message
   $ hg phase 'all()'
   0: draft
   1: secret
   2: secret
 
 (restore env for next test)
 
   $ sed -e 's/new-commit=secret//' $HGRCPATH > $TESTTMP/sedtmp
   $ cp $TESTTMP/sedtmp $HGRCPATH
   $ hg qimport -r 1 --name  add-file2
 
 Test that qfinish preserve phase when mq.secret=false
 
   $ sed -e 's/secret=true/secret=false/' $HGRCPATH > $TESTTMP/sedtmp
   $ cp $TESTTMP/sedtmp $HGRCPATH
   $ hg qfinish qbase
   patch add-file2 finalized without changeset message
   $ hg phase 'all()'
   0: draft
   1: secret
   2: secret

tests/test-record.t

@@ -1,1113 +1,1227 b''
   $ "$TESTDIR/hghave" execbit || exit 80
 
 Set up a repo
 
   $ echo "[ui]" >> $HGRCPATH
   $ echo "interactive=true" >> $HGRCPATH
   $ echo "[extensions]" >> $HGRCPATH
   $ echo "record=" >> $HGRCPATH
 
   $ hg init a
   $ cd a
 
 Select no files
 
   $ touch empty-rw
   $ hg add empty-rw
 
   $ hg record empty-rw<<EOF
   > n
   > EOF
   diff --git a/empty-rw b/empty-rw
   new file mode 100644
   examine changes to 'empty-rw'? [Ynesfdaq?] 
   no changes to record
 
   $ hg tip -p
   changeset:   -1:000000000000
   tag:         tip
   user:        
   date:        Thu Jan 01 00:00:00 1970 +0000
   
   
 
 Select files but no hunks
 
   $ hg record empty-rw<<EOF
   > y
   > n
   > EOF
   diff --git a/empty-rw b/empty-rw
   new file mode 100644
   examine changes to 'empty-rw'? [Ynesfdaq?] 
   abort: empty commit message
   [255]
 
   $ hg tip -p
   changeset:   -1:000000000000
   tag:         tip
   user:        
   date:        Thu Jan 01 00:00:00 1970 +0000
   
   
 
 Record empty file
 
   $ hg record -d '0 0' -m empty empty-rw<<EOF
   > y
   > y
   > EOF
   diff --git a/empty-rw b/empty-rw
   new file mode 100644
   examine changes to 'empty-rw'? [Ynesfdaq?] 
 
   $ hg tip -p
   changeset:   0:c0708cf4e46e
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     empty
   
   
 
 Summary shows we updated to the new cset
 
   $ hg summary
   parent: 0:c0708cf4e46e tip
    empty
   branch: default
   commit: (clean)
   update: (current)
 
 Rename empty file
 
   $ hg mv empty-rw empty-rename
   $ hg record -d '1 0' -m rename<<EOF
   > y
   > EOF
   diff --git a/empty-rw b/empty-rename
   rename from empty-rw
   rename to empty-rename
   examine changes to 'empty-rw' and 'empty-rename'? [Ynesfdaq?] 
 
   $ hg tip -p
   changeset:   1:d695e8dcb197
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:01 1970 +0000
   summary:     rename
   
   
 
 Copy empty file
 
   $ hg cp empty-rename empty-copy
   $ hg record -d '2 0' -m copy<<EOF
   > y
   > EOF
   diff --git a/empty-rename b/empty-copy
   copy from empty-rename
   copy to empty-copy
   examine changes to 'empty-rename' and 'empty-copy'? [Ynesfdaq?] 
 
   $ hg tip -p
   changeset:   2:1d4b90bea524
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:02 1970 +0000
   summary:     copy
   
   
 
 Delete empty file
 
   $ hg rm empty-copy
   $ hg record -d '3 0' -m delete<<EOF
   > y
   > EOF
   diff --git a/empty-copy b/empty-copy
   deleted file mode 100644
   examine changes to 'empty-copy'? [Ynesfdaq?] 
 
   $ hg tip -p
   changeset:   3:b39a238f01a1
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:03 1970 +0000
   summary:     delete
   
   
 
 Add binary file
 
   $ hg bundle --base -2 tip.bundle
   1 changesets found
   $ hg add tip.bundle
   $ hg record -d '4 0' -m binary<<EOF
   > y
   > EOF
   diff --git a/tip.bundle b/tip.bundle
   new file mode 100644
   this is a binary file
   examine changes to 'tip.bundle'? [Ynesfdaq?] 
 
   $ hg tip -p
   changeset:   4:ad816da3711e
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:04 1970 +0000
   summary:     binary
   
   diff -r b39a238f01a1 -r ad816da3711e tip.bundle
   Binary file tip.bundle has changed
   
 
 Change binary file
 
   $ hg bundle --base -2 tip.bundle
   1 changesets found
   $ hg record -d '5 0' -m binary-change<<EOF
   > y
   > EOF
   diff --git a/tip.bundle b/tip.bundle
   this modifies a binary file (all or nothing)
   examine changes to 'tip.bundle'? [Ynesfdaq?] 
 
   $ hg tip -p
   changeset:   5:dccd6f3eb485
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:05 1970 +0000
   summary:     binary-change
   
   diff -r ad816da3711e -r dccd6f3eb485 tip.bundle
   Binary file tip.bundle has changed
   
 
 Rename and change binary file
 
   $ hg mv tip.bundle top.bundle
   $ hg bundle --base -2 top.bundle
   1 changesets found
   $ hg record -d '6 0' -m binary-change-rename<<EOF
   > y
   > EOF
   diff --git a/tip.bundle b/top.bundle
   rename from tip.bundle
   rename to top.bundle
   this modifies a binary file (all or nothing)
   examine changes to 'tip.bundle' and 'top.bundle'? [Ynesfdaq?] 
 
   $ hg tip -p
   changeset:   6:7fa44105f5b3
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:06 1970 +0000
   summary:     binary-change-rename
   
   diff -r dccd6f3eb485 -r 7fa44105f5b3 tip.bundle
   Binary file tip.bundle has changed
   diff -r dccd6f3eb485 -r 7fa44105f5b3 top.bundle
   Binary file top.bundle has changed
   
 
 Add plain file
 
   $ for i in 1 2 3 4 5 6 7 8 9 10; do
   >     echo $i >> plain
   > done
 
   $ hg add plain
   $ hg record -d '7 0' -m plain plain<<EOF
   > y
   > y
   > EOF
   diff --git a/plain b/plain
   new file mode 100644
   examine changes to 'plain'? [Ynesfdaq?] 
 
   $ hg tip -p
   changeset:   7:11fb457c1be4
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:07 1970 +0000
   summary:     plain
   
   diff -r 7fa44105f5b3 -r 11fb457c1be4 plain
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/plain	Thu Jan 01 00:00:07 1970 +0000
   @@ -0,0 +1,10 @@
   +1
   +2
   +3
   +4
   +5
   +6
   +7
   +8
   +9
   +10
   
 
 Modify end of plain file
 
   $ echo 11 >> plain
   $ hg record -d '8 0' -m end plain <<EOF
   > y
   > y
   > EOF
   diff --git a/plain b/plain
   1 hunks, 1 lines changed
   examine changes to 'plain'? [Ynesfdaq?] 
   @@ -8,3 +8,4 @@
    8
    9
    10
   +11
   record this change to 'plain'? [Ynesfdaq?] 
 
 Modify end of plain file, no EOL
 
   $ hg tip --template '{node}' >> plain
   $ hg record -d '9 0' -m noeol plain <<EOF
   > y
   > y
   > EOF
   diff --git a/plain b/plain
   1 hunks, 1 lines changed
   examine changes to 'plain'? [Ynesfdaq?] 
   @@ -9,3 +9,4 @@
    9
    10
    11
   +7264f99c5f5ff3261504828afa4fb4d406c3af54
   \ No newline at end of file
   record this change to 'plain'? [Ynesfdaq?] 
 
 Modify end of plain file, add EOL
 
   $ echo >> plain
   $ echo 1 > plain2
   $ hg add plain2
   $ hg record -d '10 0' -m eol plain plain2 <<EOF
   > y
   > y
   > y
   > EOF
   diff --git a/plain b/plain
   1 hunks, 1 lines changed
   examine changes to 'plain'? [Ynesfdaq?] 
   @@ -9,4 +9,4 @@
    9
    10
    11
   -7264f99c5f5ff3261504828afa4fb4d406c3af54
   \ No newline at end of file
   +7264f99c5f5ff3261504828afa4fb4d406c3af54
   record change 1/2 to 'plain'? [Ynesfdaq?] 
   diff --git a/plain2 b/plain2
   new file mode 100644
   examine changes to 'plain2'? [Ynesfdaq?] 
 
 Modify beginning, trim end, record both, add another file to test
 changes numbering
 
   $ rm plain
   $ for i in 2 2 3 4 5 6 7 8 9 10; do
   >   echo $i >> plain
   > done
   $ echo 2 >> plain2
 
   $ hg record -d '10 0' -m begin-and-end plain plain2 <<EOF
   > y
   > y
   > y
   > y
   > y
   > EOF
   diff --git a/plain b/plain
   2 hunks, 3 lines changed
   examine changes to 'plain'? [Ynesfdaq?] 
   @@ -1,4 +1,4 @@
   -1
   +2
    2
    3
    4
   record change 1/3 to 'plain'? [Ynesfdaq?] 
   @@ -8,5 +8,3 @@
    8
    9
    10
   -11
   -7264f99c5f5ff3261504828afa4fb4d406c3af54
   record change 2/3 to 'plain'? [Ynesfdaq?] 
   diff --git a/plain2 b/plain2
   1 hunks, 1 lines changed
   examine changes to 'plain2'? [Ynesfdaq?] 
   @@ -1,1 +1,2 @@
    1
   +2
   record change 3/3 to 'plain2'? [Ynesfdaq?] 
 
   $ hg tip -p
   changeset:   11:21df83db12b8
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:10 1970 +0000
   summary:     begin-and-end
   
   diff -r ddb8b281c3ff -r 21df83db12b8 plain
   --- a/plain	Thu Jan 01 00:00:10 1970 +0000
   +++ b/plain	Thu Jan 01 00:00:10 1970 +0000
   @@ -1,4 +1,4 @@
   -1
   +2
    2
    3
    4
   @@ -8,5 +8,3 @@
    8
    9
    10
   -11
   -7264f99c5f5ff3261504828afa4fb4d406c3af54
   diff -r ddb8b281c3ff -r 21df83db12b8 plain2
   --- a/plain2	Thu Jan 01 00:00:10 1970 +0000
   +++ b/plain2	Thu Jan 01 00:00:10 1970 +0000
   @@ -1,1 +1,2 @@
    1
   +2
   
 
 Trim beginning, modify end
 
   $ rm plain
   > for i in 4 5 6 7 8 9 10.new; do
   >   echo $i >> plain
   > done
 
 Record end
 
   $ hg record -d '11 0' -m end-only plain <<EOF
   > y
   > n
   > y
   > EOF
   diff --git a/plain b/plain
   2 hunks, 4 lines changed
   examine changes to 'plain'? [Ynesfdaq?] 
   @@ -1,9 +1,6 @@
   -2
   -2
   -3
    4
    5
    6
    7
    8
    9
   record change 1/2 to 'plain'? [Ynesfdaq?] 
   @@ -4,7 +1,7 @@
    4
    5
    6
    7
    8
    9
   -10
   +10.new
   record change 2/2 to 'plain'? [Ynesfdaq?] 
 
   $ hg tip -p
   changeset:   12:99337501826f
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:11 1970 +0000
   summary:     end-only
   
   diff -r 21df83db12b8 -r 99337501826f plain
   --- a/plain	Thu Jan 01 00:00:10 1970 +0000
   +++ b/plain	Thu Jan 01 00:00:11 1970 +0000
   @@ -7,4 +7,4 @@
    7
    8
    9
   -10
   +10.new
   
 
 Record beginning
 
   $ hg record -d '12 0' -m begin-only plain <<EOF
   > y
   > y
   > EOF
   diff --git a/plain b/plain
   1 hunks, 3 lines changed
   examine changes to 'plain'? [Ynesfdaq?] 
   @@ -1,6 +1,3 @@
   -2
   -2
   -3
    4
    5
    6
   record this change to 'plain'? [Ynesfdaq?] 
 
   $ hg tip -p
   changeset:   13:bbd45465d540
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:12 1970 +0000
   summary:     begin-only
   
   diff -r 99337501826f -r bbd45465d540 plain
   --- a/plain	Thu Jan 01 00:00:11 1970 +0000
   +++ b/plain	Thu Jan 01 00:00:12 1970 +0000
   @@ -1,6 +1,3 @@
   -2
   -2
   -3
    4
    5
    6
   
 
 Add to beginning, trim from end
 
   $ rm plain
   $ for i in 1 2 3 4 5 6 7 8 9; do
   >  echo $i >> plain
   > done
 
 Record end
 
   $ hg record --traceback -d '13 0' -m end-again plain<<EOF
   > y
   > n
   > y
   > EOF
   diff --git a/plain b/plain
   2 hunks, 4 lines changed
   examine changes to 'plain'? [Ynesfdaq?] 
   @@ -1,6 +1,9 @@
   +1
   +2
   +3
    4
    5
    6
    7
    8
    9
   record change 1/2 to 'plain'? [Ynesfdaq?] 
   @@ -1,7 +4,6 @@
    4
    5
    6
    7
    8
    9
   -10.new
   record change 2/2 to 'plain'? [Ynesfdaq?] 
 
 Add to beginning, middle, end
 
   $ rm plain
   $ for i in 1 2 3 4 5 5.new 5.reallynew 6 7 8 9 10 11; do
   >   echo $i >> plain
   > done
 
 Record beginning, middle
 
   $ hg record -d '14 0' -m middle-only plain <<EOF
   > y
   > y
   > y
   > n
   > EOF
   diff --git a/plain b/plain
   3 hunks, 7 lines changed
   examine changes to 'plain'? [Ynesfdaq?] 
   @@ -1,2 +1,5 @@
   +1
   +2
   +3
    4
    5
   record change 1/3 to 'plain'? [Ynesfdaq?] 
   @@ -1,6 +4,8 @@
    4
    5
   +5.new
   +5.reallynew
    6
    7
    8
    9
   record change 2/3 to 'plain'? [Ynesfdaq?] 
   @@ -3,4 +8,6 @@
    6
    7
    8
    9
   +10
   +11
   record change 3/3 to 'plain'? [Ynesfdaq?] 
 
   $ hg tip -p
   changeset:   15:f34a7937ec33
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:14 1970 +0000
   summary:     middle-only
   
   diff -r 82c065d0b850 -r f34a7937ec33 plain
   --- a/plain	Thu Jan 01 00:00:13 1970 +0000
   +++ b/plain	Thu Jan 01 00:00:14 1970 +0000
   @@ -1,5 +1,10 @@
   +1
   +2
   +3
    4
    5
   +5.new
   +5.reallynew
    6
    7
    8
   
 
 Record end
 
   $ hg record -d '15 0' -m end-only plain <<EOF
   > y
   > y
   > EOF
   diff --git a/plain b/plain
   1 hunks, 2 lines changed
   examine changes to 'plain'? [Ynesfdaq?] 
   @@ -9,3 +9,5 @@
    7
    8
    9
   +10
   +11
   record this change to 'plain'? [Ynesfdaq?] 
 
   $ hg tip -p
   changeset:   16:f9900b71a04c
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:15 1970 +0000
   summary:     end-only
   
   diff -r f34a7937ec33 -r f9900b71a04c plain
   --- a/plain	Thu Jan 01 00:00:14 1970 +0000
   +++ b/plain	Thu Jan 01 00:00:15 1970 +0000
   @@ -9,3 +9,5 @@
    7
    8
    9
   +10
   +11
   
 
   $ mkdir subdir
   $ cd subdir
   $ echo a > a
   $ hg ci -d '16 0' -Amsubdir
   adding subdir/a
 
   $ echo a >> a
   $ hg record -d '16 0' -m subdir-change a <<EOF
   > y
   > y
   > EOF
   diff --git a/subdir/a b/subdir/a
   1 hunks, 1 lines changed
   examine changes to 'subdir/a'? [Ynesfdaq?] 
   @@ -1,1 +1,2 @@
    a
   +a
   record this change to 'subdir/a'? [Ynesfdaq?] 
 
   $ hg tip -p
   changeset:   18:61be427a9deb
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:16 1970 +0000
   summary:     subdir-change
   
   diff -r a7ffae4d61cb -r 61be427a9deb subdir/a
   --- a/subdir/a	Thu Jan 01 00:00:16 1970 +0000
   +++ b/subdir/a	Thu Jan 01 00:00:16 1970 +0000
   @@ -1,1 +1,2 @@
    a
   +a
   
 
   $ echo a > f1
   $ echo b > f2
   $ hg add f1 f2
 
   $ hg ci -mz -d '17 0'
 
   $ echo a >> f1
   $ echo b >> f2
 
 Help, quit
 
   $ hg record <<EOF
   > ?
   > q
   > EOF
   diff --git a/subdir/f1 b/subdir/f1
   1 hunks, 1 lines changed
   examine changes to 'subdir/f1'? [Ynesfdaq?] 
   y - record this change
   n - skip this change
   e - edit this change manually
   s - skip remaining changes to this file
   f - record remaining changes to this file
   d - done, skip remaining changes and files
   a - record all changes to all remaining files
   q - quit, recording no changes
   ? - display help
   examine changes to 'subdir/f1'? [Ynesfdaq?] 
   abort: user quit
   [255]
 
 Skip
 
   $ hg record <<EOF
   > s
   > EOF
   diff --git a/subdir/f1 b/subdir/f1
   1 hunks, 1 lines changed
   examine changes to 'subdir/f1'? [Ynesfdaq?] 
   diff --git a/subdir/f2 b/subdir/f2
   1 hunks, 1 lines changed
   examine changes to 'subdir/f2'? [Ynesfdaq?] abort: response expected
   [255]
 
 No
 
   $ hg record <<EOF
   > n
   > EOF
   diff --git a/subdir/f1 b/subdir/f1
   1 hunks, 1 lines changed
   examine changes to 'subdir/f1'? [Ynesfdaq?] 
   diff --git a/subdir/f2 b/subdir/f2
   1 hunks, 1 lines changed
   examine changes to 'subdir/f2'? [Ynesfdaq?] abort: response expected
   [255]
 
 f, quit
 
   $ hg record <<EOF
   > f
   > q
   > EOF
   diff --git a/subdir/f1 b/subdir/f1
   1 hunks, 1 lines changed
   examine changes to 'subdir/f1'? [Ynesfdaq?] 
   diff --git a/subdir/f2 b/subdir/f2
   1 hunks, 1 lines changed
   examine changes to 'subdir/f2'? [Ynesfdaq?] 
   abort: user quit
   [255]
 
 s, all
 
   $ hg record -d '18 0' -mx <<EOF
   > s
   > a
   > EOF
   diff --git a/subdir/f1 b/subdir/f1
   1 hunks, 1 lines changed
   examine changes to 'subdir/f1'? [Ynesfdaq?] 
   diff --git a/subdir/f2 b/subdir/f2
   1 hunks, 1 lines changed
   examine changes to 'subdir/f2'? [Ynesfdaq?] 
 
   $ hg tip -p
   changeset:   20:b3df3dda369a
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:18 1970 +0000
   summary:     x
   
   diff -r 6e02d6c9906d -r b3df3dda369a subdir/f2
   --- a/subdir/f2	Thu Jan 01 00:00:17 1970 +0000
   +++ b/subdir/f2	Thu Jan 01 00:00:18 1970 +0000
   @@ -1,1 +1,2 @@
    b
   +b
   
 
 f
 
   $ hg record -d '19 0' -my <<EOF
   > f
   > EOF
   diff --git a/subdir/f1 b/subdir/f1
   1 hunks, 1 lines changed
   examine changes to 'subdir/f1'? [Ynesfdaq?] 
 
   $ hg tip -p
   changeset:   21:38ec577f126b
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:19 1970 +0000
   summary:     y
   
   diff -r b3df3dda369a -r 38ec577f126b subdir/f1
   --- a/subdir/f1	Thu Jan 01 00:00:18 1970 +0000
   +++ b/subdir/f1	Thu Jan 01 00:00:19 1970 +0000
   @@ -1,1 +1,2 @@
    a
   +a
   
 
+#if execbit
+
 Preserve chmod +x
 
   $ chmod +x f1
   $ echo a >> f1
   $ hg record -d '20 0' -mz <<EOF
   > y
   > y
   > y
   > EOF
   diff --git a/subdir/f1 b/subdir/f1
   old mode 100644
   new mode 100755
   1 hunks, 1 lines changed
   examine changes to 'subdir/f1'? [Ynesfdaq?] 
   @@ -1,2 +1,3 @@
    a
    a
   +a
   record this change to 'subdir/f1'? [Ynesfdaq?] 
 
   $ hg tip --config diff.git=True -p
   changeset:   22:3261adceb075
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:20 1970 +0000
   summary:     z
   
   diff --git a/subdir/f1 b/subdir/f1
   old mode 100644
   new mode 100755
   --- a/subdir/f1
   +++ b/subdir/f1
   @@ -1,2 +1,3 @@
    a
    a
   +a
   
 
 Preserve execute permission on original
 
   $ echo b >> f1
   $ hg record -d '21 0' -maa <<EOF
   > y
   > y
   > y
   > EOF
   diff --git a/subdir/f1 b/subdir/f1
   1 hunks, 1 lines changed
   examine changes to 'subdir/f1'? [Ynesfdaq?] 
   @@ -1,3 +1,4 @@
    a
    a
    a
   +b
   record this change to 'subdir/f1'? [Ynesfdaq?] 
 
   $ hg tip --config diff.git=True -p
   changeset:   23:b429867550db
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:21 1970 +0000
   summary:     aa
   
   diff --git a/subdir/f1 b/subdir/f1
   --- a/subdir/f1
   +++ b/subdir/f1
   @@ -1,3 +1,4 @@
    a
    a
    a
   +b
   
 
 Preserve chmod -x
 
   $ chmod -x f1
   $ echo c >> f1
   $ hg record -d '22 0' -mab <<EOF
   > y
   > y
   > y
   > EOF
   diff --git a/subdir/f1 b/subdir/f1
   old mode 100755
   new mode 100644
   1 hunks, 1 lines changed
   examine changes to 'subdir/f1'? [Ynesfdaq?] 
   @@ -2,3 +2,4 @@
    a
    a
    b
   +c
   record this change to 'subdir/f1'? [Ynesfdaq?] 
 
   $ hg tip --config diff.git=True -p
   changeset:   24:0b082130c20a
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:22 1970 +0000
   summary:     ab
   
   diff --git a/subdir/f1 b/subdir/f1
   old mode 100755
   new mode 100644
   --- a/subdir/f1
   +++ b/subdir/f1
   @@ -2,3 +2,4 @@
    a
    a
    b
   +c
   
 
+#else
+
+Slightly bogus tests to get almost same repo structure as when x bit is used
+- but with different hashes.
+
+Mock "Preserve chmod +x"
+
+  $ echo a >> f1
+  $ hg record -d '20 0' -mz <<EOF
+  > y
+  > y
+  > y
+  > EOF
+  diff --git a/subdir/f1 b/subdir/f1
+  1 hunks, 1 lines changed
+  examine changes to 'subdir/f1'? [Ynesfdaq?] 
+  @@ -1,2 +1,3 @@
+   a
+   a
+  +a
+  record this change to 'subdir/f1'? [Ynesfdaq?] 
+
+  $ hg tip --config diff.git=True -p
+  changeset:   22:0d463bd428f5
+  tag:         tip
+  user:        test
+  date:        Thu Jan 01 00:00:20 1970 +0000
+  summary:     z
+  
+  diff --git a/subdir/f1 b/subdir/f1
+  --- a/subdir/f1
+  +++ b/subdir/f1
+  @@ -1,2 +1,3 @@
+   a
+   a
+  +a
+  
+
+Mock "Preserve execute permission on original"
+
+  $ echo b >> f1
+  $ hg record -d '21 0' -maa <<EOF
+  > y
+  > y
+  > y
+  > EOF
+  diff --git a/subdir/f1 b/subdir/f1
+  1 hunks, 1 lines changed
+  examine changes to 'subdir/f1'? [Ynesfdaq?] 
+  @@ -1,3 +1,4 @@
+   a
+   a
+   a
+  +b
+  record this change to 'subdir/f1'? [Ynesfdaq?] 
+
+  $ hg tip --config diff.git=True -p
+  changeset:   23:0eab41a3e524
+  tag:         tip
+  user:        test
+  date:        Thu Jan 01 00:00:21 1970 +0000
+  summary:     aa
+  
+  diff --git a/subdir/f1 b/subdir/f1
+  --- a/subdir/f1
+  +++ b/subdir/f1
+  @@ -1,3 +1,4 @@
+   a
+   a
+   a
+  +b
+  
+
+Mock "Preserve chmod -x"
+
+  $ chmod -x f1
+  $ echo c >> f1
+  $ hg record -d '22 0' -mab <<EOF
+  > y
+  > y
+  > y
+  > EOF
+  diff --git a/subdir/f1 b/subdir/f1
+  1 hunks, 1 lines changed
+  examine changes to 'subdir/f1'? [Ynesfdaq?] 
+  @@ -2,3 +2,4 @@
+   a
+   a
+   b
+  +c
+  record this change to 'subdir/f1'? [Ynesfdaq?] 
+
+  $ hg tip --config diff.git=True -p
+  changeset:   24:f4f718f27b7c
+  tag:         tip
+  user:        test
+  date:        Thu Jan 01 00:00:22 1970 +0000
+  summary:     ab
+  
+  diff --git a/subdir/f1 b/subdir/f1
+  --- a/subdir/f1
+  +++ b/subdir/f1
+  @@ -2,3 +2,4 @@
+   a
+   a
+   b
+  +c
+  
+
+#endif
+
   $ cd ..
 
+
 Abort early when a merge is in progress
 
   $ hg up 4
   1 files updated, 0 files merged, 6 files removed, 0 files unresolved
 
   $ touch iwillmergethat
   $ hg add iwillmergethat
 
   $ hg branch thatbranch
   marked working directory as branch thatbranch
   (branches are permanent and global, did you want a bookmark?)
 
   $ hg ci -m'new head'
 
   $ hg up default
   6 files updated, 0 files merged, 2 files removed, 0 files unresolved
 
   $ hg merge thatbranch
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
 
   $ hg record -m'will abort'
   abort: cannot partially commit a merge (use "hg commit" instead)
   [255]
 
   $ hg up -C
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
 
 Editing patch
 
   $ cat > editor << '__EOF__'
   > #!/bin/sh
   > sed -e 7d -e '5s/^-/ /' "$1" > tmp
   > mv tmp "$1"
   > __EOF__
   $ chmod +x editor
   $ cat > editedfile << '__EOF__'
   > This is the first line
   > This is the second line
   > This is the third line
   > __EOF__
   $ hg add editedfile
   $ hg commit -medit-patch-1
   $ cat > editedfile << '__EOF__'
   > This line has changed
   > This change will be committed
   > This is the third line
   > __EOF__
   $ HGEDITOR="'`pwd`'"/editor hg record -d '23 0' -medit-patch-2 <<EOF
   > y
   > e
   > EOF
   diff --git a/editedfile b/editedfile
   1 hunks, 2 lines changed
   examine changes to 'editedfile'? [Ynesfdaq?] 
   @@ -1,3 +1,3 @@
   -This is the first line
   -This is the second line
   +This line has changed
   +This change will be committed
    This is the third line
   record this change to 'editedfile'? [Ynesfdaq?] 
   $ cat editedfile
   This line has changed
   This change will be committed
   This is the third line
   $ hg cat -r tip editedfile
   This is the first line
   This change will be committed
   This is the third line
   $ hg revert editedfile
 
 Trying to edit patch for whole file
 
   $ echo "This is the fourth line" >> editedfile
   $ hg record <<EOF
   > e
   > q
   > EOF
   diff --git a/editedfile b/editedfile
   1 hunks, 1 lines changed
   examine changes to 'editedfile'? [Ynesfdaq?] 
   cannot edit patch for whole file
   examine changes to 'editedfile'? [Ynesfdaq?] 
   abort: user quit
   [255]
   $ hg revert editedfile
 
 Removing changes from patch
 
   $ sed -e '3s/third/second/' -e '2s/will/will not/' -e 1d editedfile > tmp
   $ mv tmp editedfile
   $ echo "This line has been added" >> editedfile
   $ cat > editor << '__EOF__'
   > #!/bin/sh
   > sed -e 's/^[-+]/ /' "$1" > tmp
   > mv tmp "$1"
   > __EOF__
   $ chmod +x editor
   $ HGEDITOR="'`pwd`'"/editor hg record <<EOF
   > y
   > e
   > EOF
   diff --git a/editedfile b/editedfile
   1 hunks, 3 lines changed
   examine changes to 'editedfile'? [Ynesfdaq?] 
   @@ -1,3 +1,3 @@
   -This is the first line
   -This change will be committed
   -This is the third line
   +This change will not be committed
   +This is the second line
   +This line has been added
   record this change to 'editedfile'? [Ynesfdaq?] 
   no changes to record
   $ cat editedfile
   This change will not be committed
   This is the second line
   This line has been added
   $ hg cat -r tip editedfile
   This is the first line
   This change will be committed
   This is the third line
   $ hg revert editedfile
 
 Invalid patch
 
   $ sed -e '3s/third/second/' -e '2s/will/will not/' -e 1d editedfile > tmp
   $ mv tmp editedfile
   $ echo "This line has been added" >> editedfile
   $ cat > editor << '__EOF__'
   > #!/bin/sh
   > sed s/This/That/ "$1" > tmp
   > mv tmp "$1"
   > __EOF__
   $ chmod +x editor
   $ HGEDITOR="'`pwd`'"/editor hg record <<EOF
   > y
   > e
   > EOF
   diff --git a/editedfile b/editedfile
   1 hunks, 3 lines changed
   examine changes to 'editedfile'? [Ynesfdaq?] 
   @@ -1,3 +1,3 @@
   -This is the first line
   -This change will be committed
   -This is the third line
   +This change will not be committed
   +This is the second line
   +This line has been added
   record this change to 'editedfile'? [Ynesfdaq?] 
   patching file editedfile
   Hunk #1 FAILED at 0
   1 out of 1 hunks FAILED -- saving rejects to file editedfile.rej
   abort: patch failed to apply
   [255]
   $ cat editedfile
   This change will not be committed
   This is the second line
   This line has been added
   $ hg cat -r tip editedfile
   This is the first line
   This change will be committed
   This is the third line
   $ cat editedfile.rej
   --- editedfile
   +++ editedfile
   @@ -1,3 +1,3 @@
   -That is the first line
   -That change will be committed
   -That is the third line
   +That change will not be committed
   +That is the second line
   +That line has been added
   $ hg up -C
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 With win32text
 
   $ echo '[extensions]' >> .hg/hgrc
   $ echo 'win32text = ' >> .hg/hgrc
   $ echo '[decode]' >> .hg/hgrc
   $ echo '** = cleverdecode:' >> .hg/hgrc
   $ echo '[encode]' >> .hg/hgrc
   $ echo '** = cleverencode:' >> .hg/hgrc
   $ echo '[patch]' >> .hg/hgrc
   $ echo 'eol = crlf' >> .hg/hgrc
 
 Ignore win32text deprecation warning for now:
 
   $ echo '[win32text]' >> .hg/hgrc
   $ echo 'warn = no' >> .hg/hgrc
 
   $ echo d >> subdir/f1
   $ hg record -d '24 0' -mw1 <<EOF
   > y
   > y
   > EOF
   diff --git a/subdir/f1 b/subdir/f1
   1 hunks, 1 lines changed
   examine changes to 'subdir/f1'? [Ynesfdaq?] 
   @@ -3,3 +3,4 @@
    a
    b
    c
   +d
   record this change to 'subdir/f1'? [Ynesfdaq?] 
 
   $ hg tip -p
-  changeset:   28:287ad1f41a72
+  changeset:   28:* (glob)
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:24 1970 +0000
   summary:     w1
   
-  diff -r 65ce23a81197 -r 287ad1f41a72 subdir/f1
+  diff -r ???????????? -r ???????????? subdir/f1 (glob)
   --- a/subdir/f1	Thu Jan 01 00:00:23 1970 +0000
   +++ b/subdir/f1	Thu Jan 01 00:00:24 1970 +0000
   @@ -3,3 +3,4 @@
    a
    b
    c
   +d