dirstate-v2: Add a variant of some tests, that uses the new format

With this, the new format receives some testing every time someone runs tests
with Rust extensions enabled, including on CI.

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

tests/test-dirstate-race.t

@@ -1,244 +1,250 b''
-#testcases dirstate-v1 dirstate-v1-tree
+#testcases dirstate-v1 dirstate-v1-tree dirstate-v2
 
 #if dirstate-v1-tree
 #require rust
   $ echo '[experimental]' >> $HGRCPATH
   $ echo 'dirstate-tree.in-memory=1' >> $HGRCPATH
 #endif
 
+#if dirstate-v2
+#require rust
+  $ echo '[format]' >> $HGRCPATH
+  $ echo 'exp-dirstate-v2=1' >> $HGRCPATH
+#endif
+
   $ hg init repo
   $ cd repo
   $ echo a > a
   $ hg add a
   $ hg commit -m test
 
 Do we ever miss a sub-second change?:
 
   $ for i in 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20; do
   >     hg co -qC 0
   >     echo b > a
   >     hg st
   > done
   M a
   M a
   M a
   M a
   M a
   M a
   M a
   M a
   M a
   M a
   M a
   M a
   M a
   M a
   M a
   M a
   M a
   M a
   M a
   M a
 
   $ echo test > b
   $ mkdir dir1
   $ echo test > dir1/c
   $ echo test > d
 
   $ echo test > e
 #if execbit
 A directory will typically have the execute bit -- make sure it doesn't get
 confused with a file with the exec bit set
   $ chmod +x e
 #endif
 
   $ hg add b dir1 d e
   adding dir1/c
   $ hg commit -m test2
 
   $ cat >> $TESTTMP/dirstaterace.py << EOF
   > from mercurial import (
   >     context,
   >     extensions,
   > )
   > def extsetup(ui):
   >     extensions.wrapfunction(context.workingctx, '_checklookup', overridechecklookup)
   > def overridechecklookup(orig, self, files):
   >     # make an update that changes the dirstate from underneath
   >     self._repo.ui.system(br"sh '$TESTTMP/dirstaterace.sh'",
   >                          cwd=self._repo.root)
   >     return orig(self, files)
   > EOF
 
   $ hg debugrebuilddirstate
   $ hg debugdirstate
   n   0         -1 unset               a
   n   0         -1 unset               b
   n   0         -1 unset               d
   n   0         -1 unset               dir1/c
   n   0         -1 unset               e
 
 XXX Note that this returns M for files that got replaced by directories. This is
 definitely a bug, but the fix for that is hard and the next status run is fine
 anyway.
 
   $ cat > $TESTTMP/dirstaterace.sh <<EOF
   > rm b && rm -r dir1 && rm d && mkdir d && rm e && mkdir e
   > EOF
 
   $ hg status --config extensions.dirstaterace=$TESTTMP/dirstaterace.py
   M d
   M e
   ! b
   ! dir1/c
   $ hg debugdirstate
   n 644          2 * a (glob)
   n   0         -1 unset               b
   n   0         -1 unset               d
   n   0         -1 unset               dir1/c
   n   0         -1 unset               e
 
   $ hg status
   ! b
   ! d
   ! dir1/c
   ! e
 
   $ rmdir d e
   $ hg update -C -q .
 
 Test that dirstate changes aren't written out at the end of "hg
 status", if .hg/dirstate is already changed simultaneously before
 acquisition of wlock in workingctx._poststatusfixup().
 
 This avoidance is important to keep consistency of dirstate in race
 condition (see issue5584 for detail).
 
   $ hg parents -q
   1:* (glob)
 
   $ hg debugrebuilddirstate
   $ hg debugdirstate
   n   0         -1 unset               a
   n   0         -1 unset               b
   n   0         -1 unset               d
   n   0         -1 unset               dir1/c
   n   0         -1 unset               e
 
   $ cat > $TESTTMP/dirstaterace.sh <<EOF
   > # This script assumes timetable of typical issue5584 case below:
   > #
   > # 1. "hg status" loads .hg/dirstate
   > # 2. "hg status" confirms clean-ness of FILE
   > # 3. "hg update -C 0" updates the working directory simultaneously
   > #    (FILE is removed, and FILE is dropped from .hg/dirstate)
   > # 4. "hg status" acquires wlock
   > #    (.hg/dirstate is re-loaded = no FILE entry in dirstate)
   > # 5. "hg status" marks FILE in dirstate as clean
   > #    (FILE entry is added to in-memory dirstate)
   > # 6. "hg status" writes dirstate changes into .hg/dirstate
   > #    (FILE entry is written into .hg/dirstate)
   > #
   > # To reproduce similar situation easily and certainly, #2 and #3
   > # are swapped.  "hg cat" below ensures #2 on "hg status" side.
   > 
   > hg update -q -C 0
   > hg cat -r 1 b > b
   > EOF
 
 "hg status" below should excludes "e", of which exec flag is set, for
 portability of test scenario, because unsure but missing "e" is
 treated differently in _checklookup() according to runtime platform.
 
 - "missing(!)" on POSIX, "pctx[f].cmp(self[f])" raises ENOENT
 - "modified(M)" on Windows, "self.flags(f) != pctx.flags(f)" is True
 
   $ hg status --config extensions.dirstaterace=$TESTTMP/dirstaterace.py --debug -X path:e
   skip updating dirstate: identity mismatch
   M a
   ! d
   ! dir1/c
 
   $ hg parents -q
   0:* (glob)
   $ hg files
   a
   $ hg debugdirstate
   n * * * a (glob)
 
   $ rm b
 
 #if fsmonitor
 
 Create fsmonitor state.
 
   $ hg status
   $ f --type .hg/fsmonitor.state
   .hg/fsmonitor.state: file
 
 Test that invalidating fsmonitor state in the middle (which doesn't require the
 wlock) causes the fsmonitor update to be skipped.
 hg debugrebuilddirstate ensures that the dirstaterace hook will be called, but
 it also invalidates the fsmonitor state. So back it up and restore it.
 
   $ mv .hg/fsmonitor.state .hg/fsmonitor.state.tmp
   $ hg debugrebuilddirstate
   $ mv .hg/fsmonitor.state.tmp .hg/fsmonitor.state
 
   $ cat > $TESTTMP/dirstaterace.sh <<EOF
   > rm .hg/fsmonitor.state
   > EOF
 
   $ hg status --config extensions.dirstaterace=$TESTTMP/dirstaterace.py --debug
   skip updating fsmonitor.state: identity mismatch
   $ f .hg/fsmonitor.state
   .hg/fsmonitor.state: file not found
 
 #endif
 
 Set up a rebase situation for issue5581.
 
   $ echo c2 > a
   $ echo c2 > b
   $ hg add b
   $ hg commit -m c2
   created new head
   $ echo c3 >> a
   $ hg commit -m c3
   $ hg update 2
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo c4 >> a
   $ echo c4 >> b
   $ hg commit -m c4
   created new head
 
 Configure a merge tool that runs status in the middle of the rebase. The goal of
 the status call is to trigger a potential bug if fsmonitor's state is written
 even though the wlock is held by another process. The output of 'hg status' in
 the merge tool goes to /dev/null because we're more interested in the results of
 'hg status' run after the rebase.
 
   $ cat >> $TESTTMP/mergetool-race.sh << EOF
   > echo "custom merge tool"
   > printf "c2\nc3\nc4\n" > \$1
   > hg --cwd "$TESTTMP/repo" status > /dev/null
   > echo "custom merge tool end"
   > EOF
   $ cat >> $HGRCPATH << EOF
   > [extensions]
   > rebase =
   > [merge-tools]
   > test.executable=sh
   > test.args=$TESTTMP/mergetool-race.sh \$output
   > EOF
 
   $ hg rebase -s . -d 3 --tool test
   rebasing 4:b08445fd6b2a tip "c4"
   merging a
   custom merge tool
   custom merge tool end
   saved backup bundle to $TESTTMP/repo/.hg/strip-backup/* (glob)
 
 This hg status should be empty, whether or not fsmonitor is enabled (issue5581).
 
   $ hg status

tests/test-dirstate-race2.t

@@ -1,45 +1,51 b''
-#testcases dirstate-v1 dirstate-v1-tree
+#testcases dirstate-v1 dirstate-v1-tree dirstate-v2
 
 #if dirstate-v1-tree
 #require rust
   $ echo '[experimental]' >> $HGRCPATH
   $ echo 'dirstate-tree.in-memory=1' >> $HGRCPATH
 #endif
 
+#if dirstate-v2
+#require rust
+  $ echo '[format]' >> $HGRCPATH
+  $ echo 'exp-dirstate-v2=1' >> $HGRCPATH
+#endif
+
 Checking the size/permissions/file-type of files stored in the
 dirstate after an update where the files are changed concurrently
 outside of hg's control.
 
   $ hg init repo
   $ cd repo
   $ echo a > a
   $ hg commit -qAm _
   $ echo aa > a
   $ hg commit -m _
 
   $ hg debugdirstate --no-dates
   n 644          3 (set  |unset)               a (re)
 
   $ cat >> $TESTTMP/dirstaterace.py << EOF
   > from mercurial import (
   >     extensions,
   >     merge,
   > )
   > def extsetup(ui):
   >     extensions.wrapfunction(merge, 'applyupdates', wrap)
   > def wrap(orig, *args, **kwargs):
   >     res = orig(*args, **kwargs)
   >     with open("a", "w"):
   >         pass # just truncate the file
   >     return res
   > EOF
 
 Do an update where file 'a' is changed between hg writing it to disk
 and hg writing the dirstate. The dirstate is correct nonetheless, and
 so hg status correctly shows a as clean.
 
   $ hg up -r 0 --config extensions.race=$TESTTMP/dirstaterace.py
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg debugdirstate --no-dates
   n 644          2 (set  |unset)               a (re)
   $ echo a > a; hg status; hg diff

tests/test-dirstate.t

@@ -1,102 +1,108 b''
-#testcases dirstate-v1 dirstate-v1-tree
+#testcases dirstate-v1 dirstate-v1-tree dirstate-v2
 
 #if dirstate-v1-tree
 #require rust
   $ echo '[experimental]' >> $HGRCPATH
   $ echo 'dirstate-tree.in-memory=1' >> $HGRCPATH
 #endif
 
+#if dirstate-v2
+#require rust
+  $ echo '[format]' >> $HGRCPATH
+  $ echo 'exp-dirstate-v2=1' >> $HGRCPATH
+#endif
+
 ------ Test dirstate._dirs refcounting
 
   $ hg init t
   $ cd t
   $ mkdir -p a/b/c/d
   $ touch a/b/c/d/x
   $ touch a/b/c/d/y
   $ touch a/b/c/d/z
   $ hg ci -Am m
   adding a/b/c/d/x
   adding a/b/c/d/y
   adding a/b/c/d/z
   $ hg mv a z
   moving a/b/c/d/x to z/b/c/d/x
   moving a/b/c/d/y to z/b/c/d/y
   moving a/b/c/d/z to z/b/c/d/z
 
 Test name collisions
 
   $ rm z/b/c/d/x
   $ mkdir z/b/c/d/x
   $ touch z/b/c/d/x/y
   $ hg add z/b/c/d/x/y
   abort: file 'z/b/c/d/x' in dirstate clashes with 'z/b/c/d/x/y'
   [255]
   $ rm -rf z/b/c/d
   $ touch z/b/c/d
   $ hg add z/b/c/d
   abort: directory 'z/b/c/d' already in dirstate
   [255]
 
   $ cd ..
 
 Issue1790: dirstate entry locked into unset if file mtime is set into
 the future
 
 Prepare test repo:
 
   $ hg init u
   $ cd u
   $ echo a > a
   $ hg add
   adding a
   $ hg ci -m1
 
 Set mtime of a into the future:
 
   $ touch -t 202101011200 a
 
 Status must not set a's entry to unset (issue1790):
 
   $ hg status
   $ hg debugstate
   n 644          2 2021-01-01 12:00:00 a
 
 Test modulo storage/comparison of absurd dates:
 
 #if no-aix
   $ touch -t 195001011200 a
   $ hg st
   $ hg debugstate
   n 644          2 2018-01-19 15:14:08 a
 #endif
 
 Verify that exceptions during a dirstate change leave the dirstate
 coherent (issue4353)
 
   $ cat > ../dirstateexception.py <<EOF
   > from __future__ import absolute_import
   > from mercurial import (
   >   error,
   >   extensions,
   >   mergestate as mergestatemod,
   > )
   > 
   > def wraprecordupdates(*args):
   >     raise error.Abort(b"simulated error while recording dirstateupdates")
   > 
   > def reposetup(ui, repo):
   >     extensions.wrapfunction(mergestatemod, 'recordupdates',
   >                             wraprecordupdates)
   > EOF
 
   $ hg rm a
   $ hg commit -m 'rm a'
   $ echo "[extensions]" >> .hg/hgrc
   $ echo "dirstateex=../dirstateexception.py" >> .hg/hgrc
   $ hg up 0
   abort: simulated error while recording dirstateupdates
   [255]
   $ hg log -r . -T '{rev}\n'
   1
   $ hg status
   ? a

tests/test-hgignore.t

@@ -1,398 +1,404 b''
-#testcases dirstate-v1 dirstate-v1-tree
+#testcases dirstate-v1 dirstate-v1-tree dirstate-v2
 
 #if dirstate-v1-tree
 #require rust
   $ echo '[experimental]' >> $HGRCPATH
   $ echo 'dirstate-tree.in-memory=1' >> $HGRCPATH
 #endif
 
+#if dirstate-v2
+#require rust
+  $ echo '[format]' >> $HGRCPATH
+  $ echo 'exp-dirstate-v2=1' >> $HGRCPATH
+#endif
+
   $ hg init ignorerepo
   $ cd ignorerepo
 
 debugignore with no hgignore should be deterministic:
   $ hg debugignore
   <nevermatcher>
 
 Issue562: .hgignore requires newline at end:
 
   $ touch foo
   $ touch bar
   $ touch baz
   $ cat > makeignore.py <<EOF
   > f = open(".hgignore", "w")
   > f.write("ignore\n")
   > f.write("foo\n")
   > # No EOL here
   > f.write("bar")
   > f.close()
   > EOF
 
   $ "$PYTHON" makeignore.py
 
 Should display baz only:
 
   $ hg status
   ? baz
 
   $ rm foo bar baz .hgignore makeignore.py
 
   $ touch a.o
   $ touch a.c
   $ touch syntax
   $ mkdir dir
   $ touch dir/a.o
   $ touch dir/b.o
   $ touch dir/c.o
 
   $ hg add dir/a.o
   $ hg commit -m 0
   $ hg add dir/b.o
 
   $ hg status
   A dir/b.o
   ? a.c
   ? a.o
   ? dir/c.o
   ? syntax
 
   $ echo "*.o" > .hgignore
   $ hg status
   abort: $TESTTMP/ignorerepo/.hgignore: invalid pattern (relre): *.o (glob)
   [255]
 
 Ensure given files are relative to cwd
 
   $ echo "dir/.*\.o" > .hgignore
   $ hg status -i
   I dir/c.o
 
   $ hg debugignore dir/c.o dir/missing.o
   dir/c.o is ignored
   (ignore rule in $TESTTMP/ignorerepo/.hgignore, line 1: 'dir/.*\.o') (glob)
   dir/missing.o is ignored
   (ignore rule in $TESTTMP/ignorerepo/.hgignore, line 1: 'dir/.*\.o') (glob)
   $ cd dir
   $ hg debugignore c.o missing.o
   c.o is ignored
   (ignore rule in $TESTTMP/ignorerepo/.hgignore, line 1: 'dir/.*\.o') (glob)
   missing.o is ignored
   (ignore rule in $TESTTMP/ignorerepo/.hgignore, line 1: 'dir/.*\.o') (glob)
 
 For icasefs, inexact matches also work, except for missing files
 
 #if icasefs
   $ hg debugignore c.O missing.O
   c.o is ignored
   (ignore rule in $TESTTMP/ignorerepo/.hgignore, line 1: 'dir/.*\.o') (glob)
   missing.O is not ignored
 #endif
 
   $ cd ..
 
   $ echo ".*\.o" > .hgignore
   $ hg status
   A dir/b.o
   ? .hgignore
   ? a.c
   ? syntax
 
 Ensure that comments work:
 
   $ touch 'foo#bar' 'quux#' 'quu0#'
 #if no-windows
   $ touch 'baz\' 'baz\wat' 'ba0\#wat' 'ba1\\' 'ba1\\wat' 'quu0\'
 #endif
 
   $ cat <<'EOF' >> .hgignore
   > # full-line comment
   >   # whitespace-only comment line
   > syntax# pattern, no whitespace, then comment
   > a.c  # pattern, then whitespace, then comment
   > baz\\# # (escaped) backslash, then comment
   > ba0\\\#w # (escaped) backslash, escaped comment character, then comment
   > ba1\\\\# # (escaped) backslashes, then comment
   > foo\#b # escaped comment character
   > quux\## escaped comment character at end of name
   > EOF
   $ hg status
   A dir/b.o
   ? .hgignore
   ? quu0#
   ? quu0\ (no-windows !)
 
   $ cat <<'EOF' > .hgignore
   > .*\.o
   > syntax: glob
   > syntax# pattern, no whitespace, then comment
   > a.c  # pattern, then whitespace, then comment
   > baz\\#* # (escaped) backslash, then comment
   > ba0\\\#w* # (escaped) backslash, escaped comment character, then comment
   > ba1\\\\#* # (escaped) backslashes, then comment
   > foo\#b* # escaped comment character
   > quux\## escaped comment character at end of name
   > quu0[\#]# escaped comment character inside [...]
   > EOF
   $ hg status
   A dir/b.o
   ? .hgignore
   ? ba1\\wat (no-windows !)
   ? baz\wat (no-windows !)
   ? quu0\ (no-windows !)
 
   $ rm 'foo#bar' 'quux#' 'quu0#'
 #if no-windows
   $ rm 'baz\' 'baz\wat' 'ba0\#wat' 'ba1\\' 'ba1\\wat' 'quu0\'
 #endif
 
 Check that '^\.' does not ignore the root directory:
 
   $ echo "^\." > .hgignore
   $ hg status
   A dir/b.o
   ? a.c
   ? a.o
   ? dir/c.o
   ? syntax
 
 Test that patterns from ui.ignore options are read:
 
   $ echo > .hgignore
   $ cat >> $HGRCPATH << EOF
   > [ui]
   > ignore.other = $TESTTMP/ignorerepo/.hg/testhgignore
   > EOF
   $ echo "glob:**.o" > .hg/testhgignore
   $ hg status
   A dir/b.o
   ? .hgignore
   ? a.c
   ? syntax
 
 empty out testhgignore
   $ echo > .hg/testhgignore
 
 Test relative ignore path (issue4473):
 
   $ cat >> $HGRCPATH << EOF
   > [ui]
   > ignore.relative = .hg/testhgignorerel
   > EOF
   $ echo "glob:*.o" > .hg/testhgignorerel
   $ cd dir
   $ hg status
   A dir/b.o
   ? .hgignore
   ? a.c
   ? syntax
   $ hg debugignore
   <includematcher includes='.*\\.o(?:/|$)'>
 
   $ cd ..
   $ echo > .hg/testhgignorerel
   $ echo "syntax: glob" > .hgignore
   $ echo "re:.*\.o" >> .hgignore
   $ hg status
   A dir/b.o
   ? .hgignore
   ? a.c
   ? syntax
 
   $ echo "syntax: invalid" > .hgignore
   $ hg status
   $TESTTMP/ignorerepo/.hgignore: ignoring invalid syntax 'invalid'
   A dir/b.o
   ? .hgignore
   ? a.c
   ? a.o
   ? dir/c.o
   ? syntax
 
   $ echo "syntax: glob" > .hgignore
   $ echo "*.o" >> .hgignore
   $ hg status
   A dir/b.o
   ? .hgignore
   ? a.c
   ? syntax
 
   $ echo "relglob:syntax*" > .hgignore
   $ hg status
   A dir/b.o
   ? .hgignore
   ? a.c
   ? a.o
   ? dir/c.o
 
   $ echo "relglob:*" > .hgignore
   $ hg status
   A dir/b.o
 
   $ cd dir
   $ hg status .
   A b.o
 
   $ hg debugignore
   <includematcher includes='.*(?:/|$)'>
 
   $ hg debugignore b.o
   b.o is ignored
   (ignore rule in $TESTTMP/ignorerepo/.hgignore, line 1: '*') (glob)
 
   $ cd ..
 
 Check patterns that match only the directory
 
 "(fsmonitor !)" below assumes that fsmonitor is enabled with
 "walk_on_invalidate = false" (default), which doesn't involve
 re-walking whole repository at detection of .hgignore change.
 
   $ echo "^dir\$" > .hgignore
   $ hg status
   A dir/b.o
   ? .hgignore
   ? a.c
   ? a.o
   ? dir/c.o (fsmonitor !)
   ? syntax
 
 Check recursive glob pattern matches no directories (dir/**/c.o matches dir/c.o)
 
   $ echo "syntax: glob" > .hgignore
   $ echo "dir/**/c.o" >> .hgignore
   $ touch dir/c.o
   $ mkdir dir/subdir
   $ touch dir/subdir/c.o
   $ hg status
   A dir/b.o
   ? .hgignore
   ? a.c
   ? a.o
   ? syntax
   $ hg debugignore a.c
   a.c is not ignored
   $ hg debugignore dir/c.o
   dir/c.o is ignored
   (ignore rule in $TESTTMP/ignorerepo/.hgignore, line 2: 'dir/**/c.o') (glob)
 
 Check rooted globs
 
   $ hg purge --all --config extensions.purge=
   $ echo "syntax: rootglob" > .hgignore
   $ echo "a/*.ext" >> .hgignore
   $ for p in a b/a aa; do mkdir -p $p; touch $p/b.ext; done
   $ hg status -A 'set:**.ext'
   ? aa/b.ext
   ? b/a/b.ext
   I a/b.ext
 
 Check using 'include:' in ignore file
 
   $ hg purge --all --config extensions.purge=
   $ touch foo.included
 
   $ echo ".*.included" > otherignore
   $ hg status -I "include:otherignore"
   ? foo.included
 
   $ echo "include:otherignore" >> .hgignore
   $ hg status
   A dir/b.o
   ? .hgignore
   ? otherignore
 
 Check recursive uses of 'include:'
 
   $ echo "include:nested/ignore" >> otherignore
   $ mkdir nested nested/more
   $ echo "glob:*ignore" > nested/ignore
   $ echo "rootglob:a" >> nested/ignore
   $ touch a nested/a nested/more/a
   $ hg status
   A dir/b.o
   ? nested/a
   ? nested/more/a
   $ rm a nested/a nested/more/a
 
   $ cp otherignore goodignore
   $ echo "include:badignore" >> otherignore
   $ hg status
   skipping unreadable pattern file 'badignore': $ENOENT$
   A dir/b.o
 
   $ mv goodignore otherignore
 
 Check using 'include:' while in a non-root directory
 
   $ cd ..
   $ hg -R ignorerepo status
   A dir/b.o
   $ cd ignorerepo
 
 Check including subincludes
 
   $ hg revert -q --all
   $ hg purge --all --config extensions.purge=
   $ echo ".hgignore" > .hgignore
   $ mkdir dir1 dir2
   $ touch dir1/file1 dir1/file2 dir2/file1 dir2/file2
   $ echo "subinclude:dir2/.hgignore" >> .hgignore
   $ echo "glob:file*2" > dir2/.hgignore
   $ hg status
   ? dir1/file1
   ? dir1/file2
   ? dir2/file1
 
 Check including subincludes with other patterns
 
   $ echo "subinclude:dir1/.hgignore" >> .hgignore
 
   $ mkdir dir1/subdir
   $ touch dir1/subdir/file1
   $ echo "rootglob:f?le1" > dir1/.hgignore
   $ hg status
   ? dir1/file2
   ? dir1/subdir/file1
   ? dir2/file1
   $ rm dir1/subdir/file1
 
   $ echo "regexp:f.le1" > dir1/.hgignore
   $ hg status
   ? dir1/file2
   ? dir2/file1
 
 Check multiple levels of sub-ignores
 
   $ touch dir1/subdir/subfile1 dir1/subdir/subfile3 dir1/subdir/subfile4
   $ echo "subinclude:subdir/.hgignore" >> dir1/.hgignore
   $ echo "glob:subfil*3" >> dir1/subdir/.hgignore
 
   $ hg status
   ? dir1/file2
   ? dir1/subdir/subfile4
   ? dir2/file1
 
 Check include subignore at the same level
 
   $ mv dir1/subdir/.hgignore dir1/.hgignoretwo
   $ echo "regexp:f.le1" > dir1/.hgignore
   $ echo "subinclude:.hgignoretwo" >> dir1/.hgignore
   $ echo "glob:file*2" > dir1/.hgignoretwo
 
   $ hg status | grep file2
   [1]
   $ hg debugignore dir1/file2
   dir1/file2 is ignored
   (ignore rule in dir2/.hgignore, line 1: 'file*2')
 
 #if windows
 
 Windows paths are accepted on input
 
   $ rm dir1/.hgignore
   $ echo "dir1/file*" >> .hgignore
   $ hg debugignore "dir1\file2"
   dir1/file2 is ignored
   (ignore rule in $TESTTMP\ignorerepo\.hgignore, line 4: 'dir1/file*')
   $ hg up -qC .
 
 #endif

tests/test-permissions.t

@@ -1,87 +1,93 b''
 #require unix-permissions no-root reporevlogstore
 
-#testcases dirstate-v1 dirstate-v1-tree
+#testcases dirstate-v1 dirstate-v1-tree dirstate-v2
 
 #if dirstate-v1-tree
 #require rust
   $ echo '[experimental]' >> $HGRCPATH
   $ echo 'dirstate-tree.in-memory=1' >> $HGRCPATH
 #endif
 
+#if dirstate-v2
+#require rust
+  $ echo '[format]' >> $HGRCPATH
+  $ echo 'exp-dirstate-v2=1' >> $HGRCPATH
+#endif
+
   $ hg init t
   $ cd t
 
   $ echo foo > a
   $ hg add a
 
   $ hg commit -m "1"
 
   $ hg verify
   checking changesets
   checking manifests
   crosschecking files in changesets and manifests
   checking files
   checked 1 changesets with 1 changes to 1 files
 
   $ chmod -r .hg/store/data/a.i
 
   $ hg verify
   checking changesets
   checking manifests
   crosschecking files in changesets and manifests
   checking files
   abort: Permission denied: '$TESTTMP/t/.hg/store/data/a.i'
   [255]
 
   $ chmod +r .hg/store/data/a.i
 
   $ hg verify
   checking changesets
   checking manifests
   crosschecking files in changesets and manifests
   checking files
   checked 1 changesets with 1 changes to 1 files
 
   $ chmod -w .hg/store/data/a.i
 
   $ echo barber > a
   $ hg commit -m "2"
   trouble committing a!
   abort: Permission denied: '$TESTTMP/t/.hg/store/data/a.i'
   [255]
 
   $ chmod -w .
 
   $ hg diff --nodates
   diff -r 2a18120dc1c9 a
   --- a/a
   +++ b/a
   @@ -1,1 +1,1 @@
   -foo
   +barber
 
   $ chmod +w .
 
   $ chmod +w .hg/store/data/a.i
   $ mkdir dir
   $ touch dir/a
   $ hg status
   M a
   ? dir/a
   $ chmod -rx dir
 
 #if no-fsmonitor
 
 (fsmonitor makes "hg status" avoid accessing to "dir")
 
   $ hg status
   dir: Permission denied
   M a
 
 #endif
 
 Reenable perm to allow deletion:
 
   $ chmod +rx dir
 
   $ cd ..

tests/test-purge.t

@@ -1,350 +1,356 b''
-#testcases dirstate-v1 dirstate-v1-tree
+#testcases dirstate-v1 dirstate-v1-tree dirstate-v2
 
 #if dirstate-v1-tree
 #require rust
   $ echo '[experimental]' >> $HGRCPATH
   $ echo 'dirstate-tree.in-memory=1' >> $HGRCPATH
 #endif
 
+#if dirstate-v2
+#require rust
+  $ echo '[format]' >> $HGRCPATH
+  $ echo 'exp-dirstate-v2=1' >> $HGRCPATH
+#endif
+
 init
 
   $ hg init t
   $ cd t
 
 setup
 
   $ echo r1 > r1
   $ hg ci -qAmr1 -d'0 0'
   $ mkdir directory
   $ echo r2 > directory/r2
   $ hg ci -qAmr2 -d'1 0'
   $ echo 'ignored' > .hgignore
   $ hg ci -qAmr3 -d'2 0'
 
 purge without the extension
 
   $ hg st
   $ touch foo
   $ hg purge
   permanently delete 1 unkown files? (yN) n
   abort: removal cancelled
   [250]
   $ hg st
   ? foo
   $ hg purge --no-confirm
   $ hg st
 
 now enabling the extension
 
   $ cat <<EOF >> $HGRCPATH
   > [extensions]
   > purge =
   > EOF
 
 delete an empty directory
 
   $ mkdir empty_dir
   $ hg purge -p -v
   empty_dir
   $ hg purge --confirm
   permanently delete at least 1 empty directories? (yN) n
   abort: removal cancelled
   [250]
   $ hg purge -v
   removing directory empty_dir
   $ ls -A
   .hg
   .hgignore
   directory
   r1
 
 delete an untracked directory
 
   $ mkdir untracked_dir
   $ touch untracked_dir/untracked_file1
   $ touch untracked_dir/untracked_file2
   $ hg purge -p
   untracked_dir/untracked_file1
   untracked_dir/untracked_file2
   $ hg purge -v
   removing file untracked_dir/untracked_file1
   removing file untracked_dir/untracked_file2
   removing directory untracked_dir
   $ ls -A
   .hg
   .hgignore
   directory
   r1
 
 delete an untracked file
 
   $ touch untracked_file
   $ touch untracked_file_readonly
   $ "$PYTHON" <<EOF
   > import os
   > import stat
   > f = 'untracked_file_readonly'
   > os.chmod(f, stat.S_IMODE(os.stat(f).st_mode) & ~stat.S_IWRITE)
   > EOF
   $ hg purge -p
   untracked_file
   untracked_file_readonly
   $ hg purge --confirm
   permanently delete 2 unkown files? (yN) n
   abort: removal cancelled
   [250]
   $ hg purge -v
   removing file untracked_file
   removing file untracked_file_readonly
   $ ls -A
   .hg
   .hgignore
   directory
   r1
 
 delete an untracked file in a tracked directory
 
   $ touch directory/untracked_file
   $ hg purge -p
   directory/untracked_file
   $ hg purge -v
   removing file directory/untracked_file
   $ ls -A
   .hg
   .hgignore
   directory
   r1
 
 delete nested directories
 
   $ mkdir -p untracked_directory/nested_directory
   $ hg purge -p
   untracked_directory/nested_directory
   $ hg purge -v
   removing directory untracked_directory/nested_directory
   removing directory untracked_directory
   $ ls -A
   .hg
   .hgignore
   directory
   r1
 
 delete nested directories from a subdir
 
   $ mkdir -p untracked_directory/nested_directory
   $ cd directory
   $ hg purge -p
   untracked_directory/nested_directory
   $ hg purge -v
   removing directory untracked_directory/nested_directory
   removing directory untracked_directory
   $ cd ..
   $ ls -A
   .hg
   .hgignore
   directory
   r1
 
 delete only part of the tree
 
   $ mkdir -p untracked_directory/nested_directory
   $ touch directory/untracked_file
   $ cd directory
   $ hg purge -p ../untracked_directory
   untracked_directory/nested_directory
   $ hg purge --confirm
   permanently delete 1 unkown files? (yN) n
   abort: removal cancelled
   [250]
   $ hg purge -v ../untracked_directory
   removing directory untracked_directory/nested_directory
   removing directory untracked_directory
   $ cd ..
   $ ls -A
   .hg
   .hgignore
   directory
   r1
   $ ls directory/untracked_file
   directory/untracked_file
   $ rm directory/untracked_file
 
 skip ignored files if -i or --all not specified
 
   $ touch ignored
   $ hg purge -p
   $ hg purge --confirm
   $ hg purge -v
   $ touch untracked_file
   $ ls
   directory
   ignored
   r1
   untracked_file
   $ hg purge -p -i
   ignored
   $ hg purge --confirm -i
   permanently delete 1 ignored files? (yN) n
   abort: removal cancelled
   [250]
   $ hg purge -v -i
   removing file ignored
   $ ls -A
   .hg
   .hgignore
   directory
   r1
   untracked_file
   $ touch ignored
   $ hg purge -p --all
   ignored
   untracked_file
   $ hg purge --confirm --all
   permanently delete 1 unkown and 1 ignored files? (yN) n
   abort: removal cancelled
   [250]
   $ hg purge -v --all
   removing file ignored
   removing file untracked_file
   $ ls
   directory
   r1
 
 abort with missing files until we support name mangling filesystems
 
   $ touch untracked_file
   $ rm r1
 
 hide error messages to avoid changing the output when the text changes
 
   $ hg purge -p 2> /dev/null
   untracked_file
   $ hg st
   ! r1
   ? untracked_file
 
   $ hg purge -p
   untracked_file
   $ hg purge -v 2> /dev/null
   removing file untracked_file
   $ hg st
   ! r1
 
   $ hg purge -v
   $ hg revert --all --quiet
   $ hg st -a
 
 tracked file in ignored directory (issue621)
 
   $ echo directory >> .hgignore
   $ hg ci -m 'ignore directory'
   $ touch untracked_file
   $ hg purge -p
   untracked_file
   $ hg purge -v
   removing file untracked_file
 
 skip excluded files
 
   $ touch excluded_file
   $ hg purge -p -X excluded_file
   $ hg purge -v -X excluded_file
   $ ls -A
   .hg
   .hgignore
   directory
   excluded_file
   r1
   $ rm excluded_file
 
 skip files in excluded dirs
 
   $ mkdir excluded_dir
   $ touch excluded_dir/file
   $ hg purge -p -X excluded_dir
   $ hg purge -v -X excluded_dir
   $ ls -A
   .hg
   .hgignore
   directory
   excluded_dir
   r1
   $ ls excluded_dir
   file
   $ rm -R excluded_dir
 
 skip excluded empty dirs
 
   $ mkdir excluded_dir
   $ hg purge -p -X excluded_dir
   $ hg purge -v -X excluded_dir
   $ ls -A
   .hg
   .hgignore
   directory
   excluded_dir
   r1
   $ rmdir excluded_dir
 
 skip patterns
 
   $ mkdir .svn
   $ touch .svn/foo
   $ mkdir directory/.svn
   $ touch directory/.svn/foo
   $ hg purge -p -X .svn -X '*/.svn'
   $ hg purge -p -X re:.*.svn
 
   $ rm -R .svn directory r1
 
 only remove files
 
   $ mkdir -p empty_dir dir
   $ touch untracked_file dir/untracked_file
   $ hg purge -p --files
   dir/untracked_file
   untracked_file
   $ hg purge -v --files
   removing file dir/untracked_file
   removing file untracked_file
   $ ls -A
   .hg
   .hgignore
   dir
   empty_dir
   $ ls dir
 
 only remove dirs
 
   $ mkdir -p empty_dir dir
   $ touch untracked_file dir/untracked_file
   $ hg purge -p --dirs
   empty_dir
   $ hg purge -v --dirs
   removing directory empty_dir
   $ ls -A
   .hg
   .hgignore
   dir
   untracked_file
   $ ls dir
   untracked_file
 
 remove both files and dirs
 
   $ mkdir -p empty_dir dir
   $ touch untracked_file dir/untracked_file
   $ hg purge -p --files --dirs
   dir/untracked_file
   untracked_file
   empty_dir
   $ hg purge -v --files --dirs
   removing file dir/untracked_file
   removing file untracked_file
   removing directory empty_dir
   removing directory dir
   $ ls -A
   .hg
   .hgignore
 
   $ cd ..

tests/test-status.t

@@ -1,871 +1,883 b''
-#testcases dirstate-v1 dirstate-v1-tree
+#testcases dirstate-v1 dirstate-v1-tree dirstate-v2
+
+#if no-rust
+  $ hg init repo0 --config format.exp-dirstate-v2=1
+  abort: dirstate v2 format requested by config but not supported (requires Rust extensions)
+  [255]
+#endif
 
 #if dirstate-v1-tree
 #require rust
   $ echo '[experimental]' >> $HGRCPATH
   $ echo 'dirstate-tree.in-memory=1' >> $HGRCPATH
 #endif
 
+#if dirstate-v2
+#require rust
+  $ echo '[format]' >> $HGRCPATH
+  $ echo 'exp-dirstate-v2=1' >> $HGRCPATH
+#endif
+
   $ hg init repo1
   $ cd repo1
   $ mkdir a b a/1 b/1 b/2
   $ touch in_root a/in_a b/in_b a/1/in_a_1 b/1/in_b_1 b/2/in_b_2
 
 hg status in repo root:
 
   $ hg status
   ? a/1/in_a_1
   ? a/in_a
   ? b/1/in_b_1
   ? b/2/in_b_2
   ? b/in_b
   ? in_root
 
 hg status . in repo root:
 
   $ hg status .
   ? a/1/in_a_1
   ? a/in_a
   ? b/1/in_b_1
   ? b/2/in_b_2
   ? b/in_b
   ? in_root
 
   $ hg status --cwd a
   ? a/1/in_a_1
   ? a/in_a
   ? b/1/in_b_1
   ? b/2/in_b_2
   ? b/in_b
   ? in_root
   $ hg status --cwd a .
   ? 1/in_a_1
   ? in_a
   $ hg status --cwd a ..
   ? 1/in_a_1
   ? in_a
   ? ../b/1/in_b_1
   ? ../b/2/in_b_2
   ? ../b/in_b
   ? ../in_root
 
   $ hg status --cwd b
   ? a/1/in_a_1
   ? a/in_a
   ? b/1/in_b_1
   ? b/2/in_b_2
   ? b/in_b
   ? in_root
   $ hg status --cwd b .
   ? 1/in_b_1
   ? 2/in_b_2
   ? in_b
   $ hg status --cwd b ..
   ? ../a/1/in_a_1
   ? ../a/in_a
   ? 1/in_b_1
   ? 2/in_b_2
   ? in_b
   ? ../in_root
 
   $ hg status --cwd a/1
   ? a/1/in_a_1
   ? a/in_a
   ? b/1/in_b_1
   ? b/2/in_b_2
   ? b/in_b
   ? in_root
   $ hg status --cwd a/1 .
   ? in_a_1
   $ hg status --cwd a/1 ..
   ? in_a_1
   ? ../in_a
 
   $ hg status --cwd b/1
   ? a/1/in_a_1
   ? a/in_a
   ? b/1/in_b_1
   ? b/2/in_b_2
   ? b/in_b
   ? in_root
   $ hg status --cwd b/1 .
   ? in_b_1
   $ hg status --cwd b/1 ..
   ? in_b_1
   ? ../2/in_b_2
   ? ../in_b
 
   $ hg status --cwd b/2
   ? a/1/in_a_1
   ? a/in_a
   ? b/1/in_b_1
   ? b/2/in_b_2
   ? b/in_b
   ? in_root
   $ hg status --cwd b/2 .
   ? in_b_2
   $ hg status --cwd b/2 ..
   ? ../1/in_b_1
   ? in_b_2
   ? ../in_b
 
 combining patterns with root and patterns without a root works
 
   $ hg st a/in_a re:.*b$
   ? a/in_a
   ? b/in_b
 
 tweaking defaults works
   $ hg status --cwd a --config ui.tweakdefaults=yes
   ? 1/in_a_1
   ? in_a
   ? ../b/1/in_b_1
   ? ../b/2/in_b_2
   ? ../b/in_b
   ? ../in_root
   $ HGPLAIN=1 hg status --cwd a --config ui.tweakdefaults=yes
   ? a/1/in_a_1 (glob)
   ? a/in_a (glob)
   ? b/1/in_b_1 (glob)
   ? b/2/in_b_2 (glob)
   ? b/in_b (glob)
   ? in_root
   $ HGPLAINEXCEPT=tweakdefaults hg status --cwd a --config ui.tweakdefaults=yes
   ? 1/in_a_1
   ? in_a
   ? ../b/1/in_b_1
   ? ../b/2/in_b_2
   ? ../b/in_b
   ? ../in_root (glob)
 
 relative paths can be requested
 
   $ hg status --cwd a --config ui.relative-paths=yes
   ? 1/in_a_1
   ? in_a
   ? ../b/1/in_b_1
   ? ../b/2/in_b_2
   ? ../b/in_b
   ? ../in_root
 
   $ hg status --cwd a . --config ui.relative-paths=legacy
   ? 1/in_a_1
   ? in_a
   $ hg status --cwd a . --config ui.relative-paths=no
   ? a/1/in_a_1
   ? a/in_a
 
 commands.status.relative overrides ui.relative-paths
 
   $ cat >> $HGRCPATH <<EOF
   > [ui]
   > relative-paths = False
   > [commands]
   > status.relative = True
   > EOF
   $ hg status --cwd a
   ? 1/in_a_1
   ? in_a
   ? ../b/1/in_b_1
   ? ../b/2/in_b_2
   ? ../b/in_b
   ? ../in_root
   $ HGPLAIN=1 hg status --cwd a
   ? a/1/in_a_1 (glob)
   ? a/in_a (glob)
   ? b/1/in_b_1 (glob)
   ? b/2/in_b_2 (glob)
   ? b/in_b (glob)
   ? in_root
 
 if relative paths are explicitly off, tweakdefaults doesn't change it
   $ cat >> $HGRCPATH <<EOF
   > [commands]
   > status.relative = False
   > EOF
   $ hg status --cwd a --config ui.tweakdefaults=yes
   ? a/1/in_a_1
   ? a/in_a
   ? b/1/in_b_1
   ? b/2/in_b_2
   ? b/in_b
   ? in_root
 
   $ cd ..
 
   $ hg init repo2
   $ cd repo2
   $ touch modified removed deleted ignored
   $ echo "^ignored$" > .hgignore
   $ hg ci -A -m 'initial checkin'
   adding .hgignore
   adding deleted
   adding modified
   adding removed
   $ touch modified added unknown ignored
   $ hg add added
   $ hg remove removed
   $ rm deleted
 
 hg status:
 
   $ hg status
   A added
   R removed
   ! deleted
   ? unknown
 
 hg status modified added removed deleted unknown never-existed ignored:
 
   $ hg status modified added removed deleted unknown never-existed ignored
   never-existed: * (glob)
   A added
   R removed
   ! deleted
   ? unknown
 
   $ hg copy modified copied
 
 hg status -C:
 
   $ hg status -C
   A added
   A copied
     modified
   R removed
   ! deleted
   ? unknown
 
 hg status -A:
 
   $ hg status -A
   A added
   A copied
     modified
   R removed
   ! deleted
   ? unknown
   I ignored
   C .hgignore
   C modified
 
   $ hg status -A -T '{status} {path} {node|shortest}\n'
   A added ffff
   A copied ffff
   R removed ffff
   ! deleted ffff
   ? unknown ffff
   I ignored ffff
   C .hgignore ffff
   C modified ffff
 
   $ hg status -A -Tjson
   [
    {
     "itemtype": "file",
     "path": "added",
     "status": "A"
    },
    {
     "itemtype": "file",
     "path": "copied",
     "source": "modified",
     "status": "A"
    },
    {
     "itemtype": "file",
     "path": "removed",
     "status": "R"
    },
    {
     "itemtype": "file",
     "path": "deleted",
     "status": "!"
    },
    {
     "itemtype": "file",
     "path": "unknown",
     "status": "?"
    },
    {
     "itemtype": "file",
     "path": "ignored",
     "status": "I"
    },
    {
     "itemtype": "file",
     "path": ".hgignore",
     "status": "C"
    },
    {
     "itemtype": "file",
     "path": "modified",
     "status": "C"
    }
   ]
 
   $ hg status -A -Tpickle > pickle
   >>> from __future__ import print_function
   >>> from mercurial import util
   >>> pickle = util.pickle
   >>> data = sorted((x[b'status'].decode(), x[b'path'].decode()) for x in pickle.load(open("pickle", r"rb")))
   >>> for s, p in data: print("%s %s" % (s, p))
   ! deleted
   ? pickle
   ? unknown
   A added
   A copied
   C .hgignore
   C modified
   I ignored
   R removed
   $ rm pickle
 
   $ echo "^ignoreddir$" > .hgignore
   $ mkdir ignoreddir
   $ touch ignoreddir/file
 
 Test templater support:
 
   $ hg status -AT "[{status}]\t{if(source, '{source} -> ')}{path}\n"
   [M]	.hgignore
   [A]	added
   [A]	modified -> copied
   [R]	removed
   [!]	deleted
   [?]	ignored
   [?]	unknown
   [I]	ignoreddir/file
   [C]	modified
   $ hg status -AT default
   M .hgignore
   A added
   A copied
     modified
   R removed
   ! deleted
   ? ignored
   ? unknown
   I ignoreddir/file
   C modified
   $ hg status -T compact
   abort: "status" not in template map
   [255]
 
 hg status ignoreddir/file:
 
   $ hg status ignoreddir/file
 
 hg status -i ignoreddir/file:
 
   $ hg status -i ignoreddir/file
   I ignoreddir/file
   $ cd ..
 
 Check 'status -q' and some combinations
 
   $ hg init repo3
   $ cd repo3
   $ touch modified removed deleted ignored
   $ echo "^ignored$" > .hgignore
   $ hg commit -A -m 'initial checkin'
   adding .hgignore
   adding deleted
   adding modified
   adding removed
   $ touch added unknown ignored
   $ hg add added
   $ echo "test" >> modified
   $ hg remove removed
   $ rm deleted
   $ hg copy modified copied
 
 Specify working directory revision explicitly, that should be the same as
 "hg status"
 
   $ hg status --change "wdir()"
   M modified
   A added
   A copied
   R removed
   ! deleted
   ? unknown
 
 Run status with 2 different flags.
 Check if result is the same or different.
 If result is not as expected, raise error
 
   $ assert() {
   >     hg status $1 > ../a
   >     hg status $2 > ../b
   >     if diff ../a ../b > /dev/null; then
   >         out=0
   >     else
   >         out=1
   >     fi
   >     if [ $3 -eq 0 ]; then
   >         df="same"
   >     else
   >         df="different"
   >     fi
   >     if [ $out -ne $3 ]; then
   >         echo "Error on $1 and $2, should be $df."
   >     fi
   > }
 
 Assert flag1 flag2 [0-same | 1-different]
 
   $ assert "-q" "-mard"      0
   $ assert "-A" "-marduicC"  0
   $ assert "-qA" "-mardcC"   0
   $ assert "-qAui" "-A"      0
   $ assert "-qAu" "-marducC" 0
   $ assert "-qAi" "-mardicC" 0
   $ assert "-qu" "-u"        0
   $ assert "-q" "-u"         1
   $ assert "-m" "-a"         1
   $ assert "-r" "-d"         1
   $ cd ..
 
   $ hg init repo4
   $ cd repo4
   $ touch modified removed deleted
   $ hg ci -q -A -m 'initial checkin'
   $ touch added unknown
   $ hg add added
   $ hg remove removed
   $ rm deleted
   $ echo x > modified
   $ hg copy modified copied
   $ hg ci -m 'test checkin' -d "1000001 0"
   $ rm *
   $ touch unrelated
   $ hg ci -q -A -m 'unrelated checkin' -d "1000002 0"
 
 hg status --change 1:
 
   $ hg status --change 1
   M modified
   A added
   A copied
   R removed
 
 hg status --change 1 unrelated:
 
   $ hg status --change 1 unrelated
 
 hg status -C --change 1 added modified copied removed deleted:
 
   $ hg status -C --change 1 added modified copied removed deleted
   M modified
   A added
   A copied
     modified
   R removed
 
 hg status -A --change 1 and revset:
 
   $ hg status -A --change '1|1'
   M modified
   A added
   A copied
     modified
   R removed
   C deleted
 
   $ cd ..
 
 hg status with --rev and reverted changes:
 
   $ hg init reverted-changes-repo
   $ cd reverted-changes-repo
   $ echo a > file
   $ hg add file
   $ hg ci -m a
   $ echo b > file
   $ hg ci -m b
 
 reverted file should appear clean
 
   $ hg revert -r 0 .
   reverting file
   $ hg status -A --rev 0
   C file
 
 #if execbit
 reverted file with changed flag should appear modified
 
   $ chmod +x file
   $ hg status -A --rev 0
   M file
 
   $ hg revert -r 0 .
   reverting file
 
 reverted and committed file with changed flag should appear modified
 
   $ hg co -C .
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ chmod +x file
   $ hg ci -m 'change flag'
   $ hg status -A --rev 1 --rev 2
   M file
   $ hg diff -r 1 -r 2
 
 #endif
 
   $ cd ..
 
 hg status of binary file starting with '\1\n', a separator for metadata:
 
   $ hg init repo5
   $ cd repo5
   >>> open("010a", r"wb").write(b"\1\nfoo") and None
   $ hg ci -q -A -m 'initial checkin'
   $ hg status -A
   C 010a
 
   >>> open("010a", r"wb").write(b"\1\nbar") and None
   $ hg status -A
   M 010a
   $ hg ci -q -m 'modify 010a'
   $ hg status -A --rev 0:1
   M 010a
 
   $ touch empty
   $ hg ci -q -A -m 'add another file'
   $ hg status -A --rev 1:2 010a
   C 010a
 
   $ cd ..
 
 test "hg status" with "directory pattern" which matches against files
 only known on target revision.
 
   $ hg init repo6
   $ cd repo6
 
   $ echo a > a.txt
   $ hg add a.txt
   $ hg commit -m '#0'
   $ mkdir -p 1/2/3/4/5
   $ echo b > 1/2/3/4/5/b.txt
   $ hg add 1/2/3/4/5/b.txt
   $ hg commit -m '#1'
 
   $ hg update -C 0 > /dev/null
   $ hg status -A
   C a.txt
 
 the directory matching against specified pattern should be removed,
 because directory existence prevents 'dirstate.walk()' from showing
 warning message about such pattern.
 
   $ test ! -d 1
   $ hg status -A --rev 1 1/2/3/4/5/b.txt
   R 1/2/3/4/5/b.txt
   $ hg status -A --rev 1 1/2/3/4/5
   R 1/2/3/4/5/b.txt
   $ hg status -A --rev 1 1/2/3
   R 1/2/3/4/5/b.txt
   $ hg status -A --rev 1 1
   R 1/2/3/4/5/b.txt
 
   $ hg status --config ui.formatdebug=True --rev 1 1
   status = [
       {
           'itemtype': 'file',
           'path': '1/2/3/4/5/b.txt',
           'status': 'R'
       },
   ]
 
 #if windows
   $ hg --config ui.slash=false status -A --rev 1 1
   R 1\2\3\4\5\b.txt
 #endif
 
   $ cd ..
 
 Status after move overwriting a file (issue4458)
 =================================================
 
 
   $ hg init issue4458
   $ cd issue4458
   $ echo a > a
   $ echo b > b
   $ hg commit -Am base
   adding a
   adding b
 
 
 with --force
 
   $ hg mv b --force a
   $ hg st --copies
   M a
     b
   R b
   $ hg revert --all
   reverting a
   undeleting b
   $ rm *.orig
 
 without force
 
   $ hg rm a
   $ hg st --copies
   R a
   $ hg mv b a
   $ hg st --copies
   M a
     b
   R b
 
 using ui.statuscopies setting
   $ hg st --config ui.statuscopies=true
   M a
     b
   R b
   $ hg st --config ui.statuscopies=false
   M a
   R b
   $ hg st --config ui.tweakdefaults=yes
   M a
     b
   R b
 
 using log status template (issue5155)
   $ hg log -Tstatus -r 'wdir()' -C
   changeset:   2147483647:ffffffffffff
   parent:      0:8c55c58b4c0e
   user:        test
   date:        * (glob)
   files:
   M a
     b
   R b
   
   $ hg log -GTstatus -r 'wdir()' -C
   o  changeset:   2147483647:ffffffffffff
   |  parent:      0:8c55c58b4c0e
   ~  user:        test
      date:        * (glob)
      files:
      M a
        b
      R b
   
 
 Other "bug" highlight, the revision status does not report the copy information.
 This is buggy behavior.
 
   $ hg commit -m 'blah'
   $ hg st --copies --change .
   M a
   R b
 
 using log status template, the copy information is displayed correctly.
   $ hg log -Tstatus -r. -C
   changeset:   1:6685fde43d21
   tag:         tip
   user:        test
   date:        * (glob)
   summary:     blah
   files:
   M a
     b
   R b
   
 
   $ cd ..
 
 Make sure .hg doesn't show up even as a symlink
 
   $ hg init repo0
   $ mkdir symlink-repo0
   $ cd symlink-repo0
   $ ln -s ../repo0/.hg
   $ hg status
 
 If the size hasn’t changed but mtime has, status needs to read the contents
 of the file to check whether it has changed
 
   $ echo 1 > a
   $ echo 1 > b
   $ touch -t 200102030000 a b
   $ hg commit -Aqm '#0'
   $ echo 2 > a
   $ touch -t 200102040000 a b
   $ hg status
   M a
 
 Asking specifically for the status of a deleted/removed file
 
   $ rm a
   $ rm b
   $ hg status a
   ! a
   $ hg rm a
   $ hg rm b
   $ hg status a
   R a
   $ hg commit -qm '#1'
   $ hg status a
   a: $ENOENT$
 
 Check using include flag with pattern when status does not need to traverse
 the working directory (issue6483)
 
   $ cd ..
   $ hg init issue6483
   $ cd issue6483
   $ touch a.py b.rs
   $ hg add a.py b.rs
   $ hg st -aI "*.py"
   A a.py
 
 Also check exclude pattern
 
   $ hg st -aX "*.rs"
   A a.py
 
 issue6335
 When a directory containing a tracked file gets symlinked, as of 5.8
 `hg st` only gives the correct answer about clean (or deleted) files
 if also listing unknowns.
 The tree-based dirstate and status algorithm fix this:
 
 #if symlink no-dirstate-v1
 
   $ cd ..
   $ hg init issue6335
   $ cd issue6335
   $ mkdir foo
   $ touch foo/a
   $ hg ci -Ama
   adding foo/a
   $ mv foo bar
   $ ln -s bar foo
   $ hg status
   ! foo/a
   ? bar/a
   ? foo
 
   $ hg status -c  # incorrect output with `dirstate-v1`
   $ hg status -cu
   ? bar/a
   ? foo
   $ hg status -d  # incorrect output with `dirstate-v1`
   ! foo/a
   $ hg status -du
   ! foo/a
   ? bar/a
   ? foo
 
 #endif
 
 
 Create a repo with files in each possible status
 
   $ cd ..
   $ hg init repo7
   $ cd repo7
   $ mkdir subdir
   $ touch clean modified deleted removed
   $ touch subdir/clean subdir/modified subdir/deleted subdir/removed
   $ echo ignored > .hgignore
   $ hg ci -Aqm '#0'
   $ echo 1 > modified
   $ echo 1 > subdir/modified
   $ rm deleted
   $ rm subdir/deleted
   $ hg rm removed
   $ hg rm subdir/removed
   $ touch unknown ignored
   $ touch subdir/unknown subdir/ignored
 
 Check the output
 
   $ hg status
   M modified
   M subdir/modified
   R removed
   R subdir/removed
   ! deleted
   ! subdir/deleted
   ? subdir/unknown
   ? unknown
 
   $ hg status -mard
   M modified
   M subdir/modified
   R removed
   R subdir/removed
   ! deleted
   ! subdir/deleted
 
   $ hg status -A
   M modified
   M subdir/modified
   R removed
   R subdir/removed
   ! deleted
   ! subdir/deleted
   ? subdir/unknown
   ? unknown
   I ignored
   I subdir/ignored
   C .hgignore
   C clean
   C subdir/clean
 
 Note: `hg status some-name` creates a patternmatcher which is not supported
 yet by the Rust implementation of status, but includematcher is supported.
 --include is used below for that reason
 
 Remove a directory that contains tracked files
 
   $ rm -r subdir
   $ hg status --include subdir
   R subdir/removed
   ! subdir/clean
   ! subdir/deleted
   ! subdir/modified
 
 … and replace it by a file
 
   $ touch subdir
   $ hg status --include subdir
   R subdir/removed
   ! subdir/clean
   ! subdir/deleted
   ! subdir/modified
   ? subdir
 
 Replaced a deleted or removed file with a directory
 
   $ mkdir deleted removed
   $ touch deleted/1 removed/1
   $ hg status --include deleted --include removed
   R removed
   ! deleted
   ? deleted/1
   ? removed/1
   $ hg add removed/1
   $ hg status --include deleted --include removed
   A removed/1
   R removed
   ! deleted
   ? deleted/1
 
 Deeply nested files in an ignored directory are still listed on request
 
   $ echo ignored-dir >> .hgignore
   $ mkdir ignored-dir
   $ mkdir ignored-dir/subdir
   $ touch ignored-dir/subdir/1
   $ hg status --ignored
   I ignored
   I ignored-dir/subdir/1

tests/test-symlinks.t

@@ -1,283 +1,289 b''
 #require symlink
 
-#testcases dirstate-v1 dirstate-v1-tree
+#testcases dirstate-v1 dirstate-v1-tree dirstate-v2
 
 #if dirstate-v1-tree
 #require rust
   $ echo '[experimental]' >> $HGRCPATH
   $ echo 'dirstate-tree.in-memory=1' >> $HGRCPATH
 #endif
 
+#if dirstate-v2
+#require rust
+  $ echo '[format]' >> $HGRCPATH
+  $ echo 'exp-dirstate-v2=1' >> $HGRCPATH
+#endif
+
 == tests added in 0.7 ==
 
   $ hg init test-symlinks-0.7; cd test-symlinks-0.7;
   $ touch foo; ln -s foo bar; ln -s nonexistent baz
 
 import with add and addremove -- symlink walking should _not_ screwup.
 
   $ hg add
   adding bar
   adding baz
   adding foo
   $ hg forget bar baz foo
   $ hg addremove
   adding bar
   adding baz
   adding foo
 
 commit -- the symlink should _not_ appear added to dir state
 
   $ hg commit -m 'initial'
 
   $ touch bomb
 
 again, symlink should _not_ show up on dir state
 
   $ hg addremove
   adding bomb
 
 Assert screamed here before, should go by without consequence
 
   $ hg commit -m 'is there a bug?'
   $ cd ..
 
 
 == fifo & ignore ==
 
   $ hg init test; cd test;
 
   $ mkdir dir
   $ touch a.c dir/a.o dir/b.o
 
 test what happens if we want to trick hg
 
   $ hg commit -A -m 0
   adding a.c
   adding dir/a.o
   adding dir/b.o
   $ echo "relglob:*.o" > .hgignore
   $ rm a.c
   $ rm dir/a.o
   $ rm dir/b.o
   $ mkdir dir/a.o
   $ ln -s nonexistent dir/b.o
   $ mkfifo a.c
 
 it should show a.c, dir/a.o and dir/b.o deleted
 
   $ hg status
   M dir/b.o
   ! a.c
   ! dir/a.o
   ? .hgignore
   $ hg status a.c
   a.c: unsupported file type (type is fifo)
   ! a.c
   $ cd ..
 
 
 == symlinks from outside the tree ==
 
 test absolute path through symlink outside repo
 
   $ p=`pwd`
   $ hg init x
   $ ln -s x y
   $ cd x
   $ touch f
   $ hg add f
   $ hg status "$p"/y/f
   A f
 
 try symlink outside repo to file inside
 
   $ ln -s x/f ../z
 
 this should fail
 
   $ hg status ../z && { echo hg mistakenly exited with status 0; exit 1; } || :
   abort: ../z not under root '$TESTTMP/x'
   $ cd ..
 
 
 == cloning symlinks ==
   $ hg init clone; cd clone;
 
 try cloning symlink in a subdir
 1. commit a symlink
 
   $ mkdir -p a/b/c
   $ cd a/b/c
   $ ln -s /path/to/symlink/source demo
   $ cd ../../..
   $ hg stat
   ? a/b/c/demo
   $ hg commit -A -m 'add symlink in a/b/c subdir'
   adding a/b/c/demo
 
 2. clone it
 
   $ cd ..
   $ hg clone clone clonedest
   updating to branch default
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 
 == symlink and git diffs ==
 
 git symlink diff
 
   $ cd clonedest
   $ hg diff --git -r null:tip
   diff --git a/a/b/c/demo b/a/b/c/demo
   new file mode 120000
   --- /dev/null
   +++ b/a/b/c/demo
   @@ -0,0 +1,1 @@
   +/path/to/symlink/source
   \ No newline at end of file
   $ hg export --git tip > ../sl.diff
 
 import git symlink diff
 
   $ hg rm a/b/c/demo
   $ hg commit -m'remove link'
   $ hg import ../sl.diff
   applying ../sl.diff
   $ hg diff --git -r 1:tip
   diff --git a/a/b/c/demo b/a/b/c/demo
   new file mode 120000
   --- /dev/null
   +++ b/a/b/c/demo
   @@ -0,0 +1,1 @@
   +/path/to/symlink/source
   \ No newline at end of file
 
 == symlinks and addremove ==
 
 directory moved and symlinked
 
   $ mkdir foo
   $ touch foo/a
   $ hg ci -Ama
   adding foo/a
   $ mv foo bar
   $ ln -s bar foo
   $ hg status
   ! foo/a
   ? bar/a
   ? foo
 
 now addremove should remove old files
 
   $ hg addremove
   adding bar/a
   adding foo
   removing foo/a
 
 commit and update back
 
   $ hg ci -mb
   $ hg up '.^'
   1 files updated, 0 files merged, 2 files removed, 0 files unresolved
   $ hg up tip
   2 files updated, 0 files merged, 1 files removed, 0 files unresolved
 
   $ cd ..
 
 == root of repository is symlinked ==
 
   $ hg init root
   $ ln -s root link
   $ cd root
   $ echo foo > foo
   $ hg status
   ? foo
   $ hg status ../link
   ? foo
   $ hg add foo
   $ hg cp foo "$TESTTMP/link/bar"
   foo has not been committed yet, so no copy data will be stored for bar.
   $ cd ..
 
 
   $ hg init b
   $ cd b
   $ ln -s nothing dangling
   $ hg commit -m 'commit symlink without adding' dangling
   abort: dangling: file not tracked!
   [10]
   $ hg add dangling
   $ hg commit -m 'add symlink'
 
   $ hg tip -v
   changeset:   0:cabd88b706fc
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   files:       dangling
   description:
   add symlink
   
   
   $ hg manifest --debug
   2564acbe54bbbedfbf608479340b359f04597f80 644 @ dangling
   $ readlink.py dangling
   dangling -> nothing
 
   $ rm dangling
   $ ln -s void dangling
   $ hg commit -m 'change symlink'
   $ readlink.py dangling
   dangling -> void
 
 
 modifying link
 
   $ rm dangling
   $ ln -s empty dangling
   $ readlink.py dangling
   dangling -> empty
 
 
 reverting to rev 0:
 
   $ hg revert -r 0 -a
   reverting dangling
   $ readlink.py dangling
   dangling -> nothing
 
 
 backups:
 
   $ readlink.py *.orig
   dangling.orig -> empty
   $ rm *.orig
   $ hg up -C
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 copies
 
   $ hg cp -v dangling dangling2
   copying dangling to dangling2
   $ hg st -Cmard
   A dangling2
     dangling
   $ readlink.py dangling dangling2
   dangling -> void
   dangling2 -> void
 
 
 Issue995: hg copy -A incorrectly handles symbolic links
 
   $ hg up -C
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ mkdir dir
   $ ln -s dir dirlink
   $ hg ci -qAm 'add dirlink'
   $ mkdir newdir
   $ mv dir newdir/dir
   $ mv dirlink newdir/dirlink
   $ hg mv -A dirlink newdir/dirlink
 
   $ cd ..