view tests/test-fileset.t @ 43198:c16fe77e340a

pathcopies: give up any optimization based on `introrev`

Between 8a0136f69027 and d98fb3f42f33, we sped up the search for the
introduction revision during path copies. However, further checking show that
finding the introduction revision is still expensive and that we are better off
without it. So we simply drop it and only rely on the linkrev optimisation.

I ran `perfpathcopies` on 6989 pair of revision in the pypy
repository (`hg perfhelper-pathcopies`. The result is massively in favor of
dropping this condition. The result of the copy tracing are unchanged.

Attempt to use a smaller changes preserving linkrev usage were unsuccessful, it
can return wrong result. The following changesets broke test-mv-cp-st-diff.t

    -        if not f.isintroducedafter(limit):
    +        if limit >= 0 and f.linkrev() < limit:
                 return None


Here are various numbers (before this changeset/after this changesets)

            source       destination  before      after    saved-time  ratio
worth cases e66f24650daf 695dfb0f493b 1.062843 1.246369 -0.183526 1.172675
            c979853a3b6a 8d60fe293e79 1.036985 1.196414 -0.159429 1.153743
            22349fa2fc33 fbb1c9fd86c0 0.879926 1.038682 -0.158756 1.180420
            682b98f3e672 a4878080a536 0.909952 1.063801 -0.153849 1.169074
            5adabc9b9848 920958a93997 0.993622 1.147452 -0.153830 1.154817
worse  1%   dbfbfcf077e9 aea8f2fd3593 1.016595 1.082999 -0.066404 1.065320
worse  5%   c95f1ced15f2 7d29d5e39734 0.453694 0.471156 -0.017462 1.038488
worse 10%   3e144ed1d5b7 2aef0e942480 0.035140 0.037535 -0.002395 1.068156
worse 25%   321fc60db035 801748ba582a 0.009267 0.009325 -0.000058 1.006259
median      2088ce763fc2 e6991321d78b 0.000665 0.000651 0.000014 0.978947
best 25%    915631a97de6 385b31354be6 0.040743 0.040363 0.000380 0.990673
best 10%    ad495c36a765 19c10384d3e7 0.431658 0.411490 0.020168 0.953278
best  5%    d13ae7d283ae 813c99f810ac 1.141404 1.075346 0.066058 0.942126
best  1%    81593cb4a496 99ae11866969 1.833297 0.063823 1.769474 0.034813
best cases  c3b14617fbd7 743a0fcaa4eb 1101.811740 2.735970 1099.075770 0.002483
            c3b14617fbd7 9ba6ab77fd29 1116.753953 2.800729 1113.953224 0.002508
            058b99d6e81f 57e249b7a3ea 1246.128485 3.042762 1243.085723 0.002442
            9a8c361aab49 0354a250d371 1253.111894 3.085796 1250.026098 0.002463
            442dbbc53c68 3ec1002a818c 1261.786294 3.138607 1258.647687 0.002487


As one can see, the average case is not really impacted. However, the worth case
we get after this changeset are much better than the one we had before it. We
have 30 pairs where improvements are above 10 minutes.

This reflect in the combined time for all pairs
before: 26256s
after:   1300s (-95%)

If we remove these pathological 30 cases, we still see a significant improvements:
before:  1631s
after:   1245s (-24%)

  $ fileset() {
  >   hg debugfileset --all-files "$@"
  > }

  $ hg init repo
  $ cd repo
  $ echo a > a1
  $ echo a > a2
  $ echo b > b1
  $ echo b > b2
  $ hg ci -Am addfiles
  adding a1
  adding a2
  adding b1
  adding b2

Test operators and basic patterns

  $ fileset -v a1
  (symbol 'a1')
  * matcher:
  <patternmatcher patterns='a1$'>
  a1
  $ fileset -v 'a*'
  (symbol 'a*')
  * matcher:
  <patternmatcher patterns='a[^/]*$'>
  a1
  a2
  $ fileset -v '"re:a\d"'
  (string 're:a\\d')
  * matcher:
  <patternmatcher patterns='a\\d'>
  a1
  a2
  $ fileset -v '!re:"a\d"'
  (not
    (kindpat
      (symbol 're')
      (string 'a\\d')))
  * matcher:
  <predicatenmatcher
    pred=<not
      <patternmatcher patterns='a\\d'>>>
  b1
  b2
  $ fileset -v 'path:a1 or glob:b?'
  (or
    (kindpat
      (symbol 'path')
      (symbol 'a1'))
    (kindpat
      (symbol 'glob')
      (symbol 'b?')))
  * matcher:
  <patternmatcher patterns='a1(?:/|$)|b.$'>
  a1
  b1
  b2
  $ fileset -v --no-show-matcher 'a1 or a2'
  (or
    (symbol 'a1')
    (symbol 'a2'))
  a1
  a2
  $ fileset 'a1 | a2'
  a1
  a2
  $ fileset 'a* and "*1"'
  a1
  $ fileset 'a* & "*1"'
  a1
  $ fileset 'not (r"a*")'
  b1
  b2
  $ fileset '! ("a*")'
  b1
  b2
  $ fileset 'a* - a1'
  a2
  $ fileset 'a_b'
  $ fileset '"\xy"'
  hg: parse error: invalid \x escape* (glob)
  [255]

Test invalid syntax

  $ fileset -v '"added"()'
  (func
    (string 'added')
    None)
  hg: parse error: not a symbol
  [255]
  $ fileset -v '()()'
  (func
    (group
      None)
    None)
  hg: parse error: not a symbol
  [255]
  $ fileset -v -- '-x'
  (negate
    (symbol 'x'))
  hg: parse error: can't use negate operator in this context
  [255]
  $ fileset -v -- '-()'
  (negate
    (group
      None))
  hg: parse error: can't use negate operator in this context
  [255]
  $ fileset -p parsed 'a, b, c'
  * parsed:
  (list
    (symbol 'a')
    (symbol 'b')
    (symbol 'c'))
  hg: parse error: can't use a list in this context
  (see 'hg help "filesets.x or y"')
  [255]

  $ fileset '"path":.'
  hg: parse error: not a symbol
  [255]
  $ fileset 'path:foo bar'
  hg: parse error at 9: invalid token
  [255]
  $ fileset 'foo:bar:baz'
  hg: parse error: not a symbol
  [255]
  $ fileset 'foo:bar()'
  hg: parse error: pattern must be a string
  [255]
  $ fileset 'foo:bar'
  hg: parse error: invalid pattern kind: foo
  [255]

Show parsed tree at stages:

  $ fileset -p unknown a
  abort: invalid stage name: unknown
  [255]

  $ fileset -p parsed 'path:a1 or glob:b?'
  * parsed:
  (or
    (kindpat
      (symbol 'path')
      (symbol 'a1'))
    (kindpat
      (symbol 'glob')
      (symbol 'b?')))
  a1
  b1
  b2

  $ fileset -p all -s 'a1 or a2 or (grep("b") & clean())'
  * parsed:
  (or
    (symbol 'a1')
    (symbol 'a2')
    (group
      (and
        (func
          (symbol 'grep')
          (string 'b'))
        (func
          (symbol 'clean')
          None))))
  * analyzed:
  (or
    (symbol 'a1')
    (symbol 'a2')
    (and
      (func
        (symbol 'grep')
        (string 'b'))
      (withstatus
        (func
          (symbol 'clean')
          None)
        (string 'clean'))))
  * optimized:
  (or
    (patterns
      (symbol 'a1')
      (symbol 'a2'))
    (and
      (withstatus
        (func
          (symbol 'clean')
          None)
        (string 'clean'))
      (func
        (symbol 'grep')
        (string 'b'))))
  * matcher:
  <unionmatcher matchers=[
    <patternmatcher patterns='a1$|a2$'>,
    <intersectionmatcher
      m1=<predicatenmatcher pred=clean>,
      m2=<predicatenmatcher pred=grep('b')>>]>
  a1
  a2
  b1
  b2

Union of basic patterns:

  $ fileset -p optimized -s -r. 'a1 or a2 or path:b1'
  * optimized:
  (patterns
    (symbol 'a1')
    (symbol 'a2')
    (kindpat
      (symbol 'path')
      (symbol 'b1')))
  * matcher:
  <patternmatcher patterns='a1$|a2$|b1(?:/|$)'>
  a1
  a2
  b1

OR expression should be reordered by weight:

  $ fileset -p optimized -s -r. 'grep("a") or a1 or grep("b") or b2'
  * optimized:
  (or
    (patterns
      (symbol 'a1')
      (symbol 'b2'))
    (func
      (symbol 'grep')
      (string 'a'))
    (func
      (symbol 'grep')
      (string 'b')))
  * matcher:
  <unionmatcher matchers=[
    <patternmatcher patterns='a1$|b2$'>,
    <predicatenmatcher pred=grep('a')>,
    <predicatenmatcher pred=grep('b')>]>
  a1
  a2
  b1
  b2

Use differencematcher for 'x and not y':

  $ fileset -p optimized -s 'a* and not a1'
  * optimized:
  (minus
    (symbol 'a*')
    (symbol 'a1'))
  * matcher:
  <differencematcher
    m1=<patternmatcher patterns='a[^/]*$'>,
    m2=<patternmatcher patterns='a1$'>>
  a2

  $ fileset -p optimized -s '!binary() and a*'
  * optimized:
  (minus
    (symbol 'a*')
    (func
      (symbol 'binary')
      None))
  * matcher:
  <differencematcher
    m1=<patternmatcher patterns='a[^/]*$'>,
    m2=<predicatenmatcher pred=binary>>
  a1
  a2

'x - y' is rewritten to 'x and not y' first so the operands can be reordered:

  $ fileset -p analyzed -p optimized -s 'a* - a1'
  * analyzed:
  (and
    (symbol 'a*')
    (not
      (symbol 'a1')))
  * optimized:
  (minus
    (symbol 'a*')
    (symbol 'a1'))
  * matcher:
  <differencematcher
    m1=<patternmatcher patterns='a[^/]*$'>,
    m2=<patternmatcher patterns='a1$'>>
  a2

  $ fileset -p analyzed -p optimized -s 'binary() - a*'
  * analyzed:
  (and
    (func
      (symbol 'binary')
      None)
    (not
      (symbol 'a*')))
  * optimized:
  (and
    (not
      (symbol 'a*'))
    (func
      (symbol 'binary')
      None))
  * matcher:
  <intersectionmatcher
    m1=<predicatenmatcher
      pred=<not
        <patternmatcher patterns='a[^/]*$'>>>,
    m2=<predicatenmatcher pred=binary>>

Test files status

  $ rm a1
  $ hg rm a2
  $ echo b >> b2
  $ hg cp b1 c1
  $ echo c > c2
  $ echo c > c3
  $ cat > .hgignore <<EOF
  > \.hgignore
  > 2$
  > EOF
  $ fileset 'modified()'
  b2
  $ fileset 'added()'
  c1
  $ fileset 'removed()'
  a2
  $ fileset 'deleted()'
  a1
  $ fileset 'missing()'
  a1
  $ fileset 'unknown()'
  c3
  $ fileset 'ignored()'
  .hgignore
  c2
  $ fileset 'hgignore()'
  .hgignore
  a2
  b2
  c2
  $ fileset 'clean()'
  b1
  $ fileset 'copied()'
  c1

Test files status in different revisions

  $ hg status -m
  M b2
  $ fileset -r0 'revs("wdir()", modified())' --traceback
  b2
  $ hg status -a
  A c1
  $ fileset -r0 'revs("wdir()", added())'
  c1
  $ hg status --change 0 -a
  A a1
  A a2
  A b1
  A b2
  $ hg status -mru
  M b2
  R a2
  ? c3
  $ fileset -r0 'added() and revs("wdir()", modified() or removed() or unknown())'
  a2
  b2
  $ fileset -r0 'added() or revs("wdir()", added())'
  a1
  a2
  b1
  b2
  c1

Test insertion of status hints

  $ fileset -p optimized 'added()'
  * optimized:
  (withstatus
    (func
      (symbol 'added')
      None)
    (string 'added'))
  c1

  $ fileset -p optimized 'a* & removed()'
  * optimized:
  (and
    (symbol 'a*')
    (withstatus
      (func
        (symbol 'removed')
        None)
      (string 'removed')))
  a2

  $ fileset -p optimized 'a* - removed()'
  * optimized:
  (minus
    (symbol 'a*')
    (withstatus
      (func
        (symbol 'removed')
        None)
      (string 'removed')))
  a1

  $ fileset -p analyzed -p optimized '(added() + removed()) - a*'
  * analyzed:
  (and
    (withstatus
      (or
        (func
          (symbol 'added')
          None)
        (func
          (symbol 'removed')
          None))
      (string 'added removed'))
    (not
      (symbol 'a*')))
  * optimized:
  (and
    (not
      (symbol 'a*'))
    (withstatus
      (or
        (func
          (symbol 'added')
          None)
        (func
          (symbol 'removed')
          None))
      (string 'added removed')))
  c1

  $ fileset -p optimized 'a* + b* + added() + unknown()'
  * optimized:
  (withstatus
    (or
      (patterns
        (symbol 'a*')
        (symbol 'b*'))
      (func
        (symbol 'added')
        None)
      (func
        (symbol 'unknown')
        None))
    (string 'added unknown'))
  a1
  a2
  b1
  b2
  c1
  c3

  $ fileset -p analyzed -p optimized 'removed() & missing() & a*'
  * analyzed:
  (and
    (withstatus
      (and
        (func
          (symbol 'removed')
          None)
        (func
          (symbol 'missing')
          None))
      (string 'removed missing'))
    (symbol 'a*'))
  * optimized:
  (and
    (symbol 'a*')
    (withstatus
      (and
        (func
          (symbol 'removed')
          None)
        (func
          (symbol 'missing')
          None))
      (string 'removed missing')))

  $ fileset -p optimized 'clean() & revs(0, added())'
  * optimized:
  (and
    (withstatus
      (func
        (symbol 'clean')
        None)
      (string 'clean'))
    (func
      (symbol 'revs')
      (list
        (symbol '0')
        (withstatus
          (func
            (symbol 'added')
            None)
          (string 'added')))))
  b1

  $ fileset -p optimized 'clean() & status(null, 0, b* & added())'
  * optimized:
  (and
    (withstatus
      (func
        (symbol 'clean')
        None)
      (string 'clean'))
    (func
      (symbol 'status')
      (list
        (symbol 'null')
        (symbol '0')
        (and
          (symbol 'b*')
          (withstatus
            (func
              (symbol 'added')
              None)
            (string 'added'))))))
  b1

Test files properties

  >>> open('bin', 'wb').write(b'\0a') and None
  $ fileset 'binary()'
  bin
  $ fileset 'binary() and unknown()'
  bin
  $ echo '^bin$' >> .hgignore
  $ fileset 'binary() and ignored()'
  bin
  $ hg add bin
  $ fileset 'binary()'
  bin

  $ fileset -p optimized -s 'binary() and b*'
  * optimized:
  (and
    (symbol 'b*')
    (func
      (symbol 'binary')
      None))
  * matcher:
  <intersectionmatcher
    m1=<patternmatcher patterns='b[^/]*$'>,
    m2=<predicatenmatcher pred=binary>>
  bin

  $ fileset 'grep("b{1}")'
  .hgignore
  b1
  b2
  c1
  $ fileset 'grep("missingparens(")'
  hg: parse error: invalid match pattern: (unbalanced parenthesis|missing \)).* (re)
  [255]

#if execbit
  $ chmod +x b2
  $ fileset 'exec()'
  b2
#endif

#if symlink
  $ ln -s b2 b2link
  $ fileset 'symlink() and unknown()'
  b2link
  $ hg add b2link
#endif

#if no-windows
  $ echo foo > con.xml
  $ fileset 'not portable()'
  con.xml
  $ hg --config ui.portablefilenames=ignore add con.xml
#endif

  >>> open('1k', 'wb').write(b' '*1024) and None
  >>> open('2k', 'wb').write(b' '*2048) and None
  $ hg add 1k 2k
  $ fileset 'size("bar")'
  hg: parse error: couldn't parse size: bar
  [255]
  $ fileset '(1k, 2k)'
  hg: parse error: can't use a list in this context
  (see 'hg help "filesets.x or y"')
  [255]
  $ fileset 'size(1k)'
  1k
  $ fileset '(1k or 2k) and size("< 2k")'
  1k
  $ fileset '(1k or 2k) and size("<=2k")'
  1k
  2k
  $ fileset '(1k or 2k) and size("> 1k")'
  2k
  $ fileset '(1k or 2k) and size(">=1K")'
  1k
  2k
  $ fileset '(1k or 2k) and size(".5KB - 1.5kB")'
  1k
  $ fileset 'size("1M")'
  $ fileset 'size("1 GB")'

Test merge states

  $ hg ci -m manychanges
  $ hg file -r . 'set:copied() & modified()'
  [1]
  $ hg up -C 0
  * files updated, 0 files merged, * files removed, 0 files unresolved (glob)
  $ echo c >> b2
  $ hg ci -m diverging b2
  created new head
  $ fileset 'resolved()'
  $ fileset 'unresolved()'
  $ hg merge
  merging b2
  warning: conflicts while merging b2! (edit, then use 'hg resolve --mark')
  * files updated, 0 files merged, 1 files removed, 1 files unresolved (glob)
  use 'hg resolve' to retry unresolved file merges or 'hg merge --abort' to abandon
  [1]
  $ fileset 'resolved()'
  $ fileset 'unresolved()'
  b2
  $ echo e > b2
  $ hg resolve -m b2
  (no more unresolved files)
  $ fileset 'resolved()'
  b2
  $ fileset 'unresolved()'
  $ hg ci -m merge

Test subrepo predicate

  $ hg init sub
  $ echo a > sub/suba
  $ hg -R sub add sub/suba
  $ hg -R sub ci -m sub
  $ echo 'sub = sub' > .hgsub
  $ hg init sub2
  $ echo b > sub2/b
  $ hg -R sub2 ci -Am sub2
  adding b
  $ echo 'sub2 = sub2' >> .hgsub
  $ fileset 'subrepo()'
  $ hg add .hgsub
  $ fileset 'subrepo()'
  sub
  sub2
  $ fileset 'subrepo("sub")'
  sub
  $ fileset 'subrepo("glob:*")'
  sub
  sub2
  $ hg ci -m subrepo

Test that .hgsubstate is updated as appropriate during a conversion.  The
saverev property is enough to alter the hashes of the subrepo.

  $ hg init ../converted
  $ hg --config extensions.convert= convert --config convert.hg.saverev=True  \
  >      sub ../converted/sub
  initializing destination ../converted/sub repository
  scanning source...
  sorting...
  converting...
  0 sub
  $ hg clone -U sub2 ../converted/sub2
  $ hg --config extensions.convert= convert --config convert.hg.saverev=True  \
  >      . ../converted
  scanning source...
  sorting...
  converting...
  4 addfiles
  3 manychanges
  2 diverging
  1 merge
  0 subrepo
  no ".hgsubstate" updates will be made for "sub2"
  $ hg up -q -R ../converted -r tip
  $ hg --cwd ../converted cat sub/suba sub2/b -r tip
  a
  b
  $ oldnode=`hg log -r tip -T "{node}\n"`
  $ newnode=`hg log -R ../converted -r tip -T "{node}\n"`
  $ [ "$oldnode" != "$newnode" ] || echo "nothing changed"

Test with a revision

  $ hg log -G --template '{rev} {desc}\n'
  @  4 subrepo
  |
  o    3 merge
  |\
  | o  2 diverging
  | |
  o |  1 manychanges
  |/
  o  0 addfiles
  
  $ echo unknown > unknown
  $ fileset -r1 'modified()'
  b2
  $ fileset -r1 'added() and c1'
  c1
  $ fileset -r1 'removed()'
  a2
  $ fileset -r1 'deleted()'
  $ fileset -r1 'unknown()'
  $ fileset -r1 'ignored()'
  $ fileset -r1 'hgignore()'
  .hgignore
  a2
  b2
  bin
  c2
  sub2
  $ fileset -r1 'binary()'
  bin
  $ fileset -r1 'size(1k)'
  1k
  $ fileset -r3 'resolved()'
  $ fileset -r3 'unresolved()'

#if execbit
  $ fileset -r1 'exec()'
  b2
#endif

#if symlink
  $ fileset -r1 'symlink()'
  b2link
#endif

#if no-windows
  $ fileset -r1 'not portable()'
  con.xml
  $ hg forget 'con.xml'
#endif

  $ fileset -r4 'subrepo("re:su.*")'
  sub
  sub2
  $ fileset -r4 'subrepo(re:su.*)'
  sub
  sub2
  $ fileset -r4 'subrepo("sub")'
  sub
  $ fileset -r4 'b2 or c1'
  b2
  c1

  >>> open('dos', 'wb').write(b"dos\r\n") and None
  >>> open('mixed', 'wb').write(b"dos\r\nunix\n") and None
  >>> open('mac', 'wb').write(b"mac\r") and None
  $ hg add dos mixed mac

(remove a1, to examine safety of 'eol' on removed files)
  $ rm a1

  $ fileset 'eol(dos)'
  dos
  mixed
  $ fileset 'eol(unix)'
  .hgignore
  .hgsub
  .hgsubstate
  b1
  b2
  b2.orig
  c1
  c2
  c3
  con.xml (no-windows !)
  mixed
  unknown
  $ fileset 'eol(mac)'
  mac

Test safety of 'encoding' on removed files

  $ fileset 'encoding("ascii")'
  .hgignore
  .hgsub
  .hgsubstate
  1k
  2k
  b1
  b2
  b2.orig
  b2link (symlink !)
  bin
  c1
  c2
  c3
  con.xml (no-windows !)
  dos
  mac
  mixed
  unknown

Test 'revs(...)'
================

small reminder of the repository state

  $ hg log -G
  @  changeset:   4:* (glob)
  |  tag:         tip
  |  user:        test
  |  date:        Thu Jan 01 00:00:00 1970 +0000
  |  summary:     subrepo
  |
  o    changeset:   3:* (glob)
  |\   parent:      2:55b05bdebf36
  | |  parent:      1:* (glob)
  | |  user:        test
  | |  date:        Thu Jan 01 00:00:00 1970 +0000
  | |  summary:     merge
  | |
  | o  changeset:   2:55b05bdebf36
  | |  parent:      0:8a9576c51c1f
  | |  user:        test
  | |  date:        Thu Jan 01 00:00:00 1970 +0000
  | |  summary:     diverging
  | |
  o |  changeset:   1:* (glob)
  |/   user:        test
  |    date:        Thu Jan 01 00:00:00 1970 +0000
  |    summary:     manychanges
  |
  o  changeset:   0:8a9576c51c1f
     user:        test
     date:        Thu Jan 01 00:00:00 1970 +0000
     summary:     addfiles
  
  $ hg status --change 0
  A a1
  A a2
  A b1
  A b2
  $ hg status --change 1
  M b2
  A 1k
  A 2k
  A b2link (no-windows !)
  A bin
  A c1
  A con.xml (no-windows !)
  R a2
  $ hg status --change 2
  M b2
  $ hg status --change 3
  M b2
  A 1k
  A 2k
  A b2link (no-windows !)
  A bin
  A c1
  A con.xml (no-windows !)
  R a2
  $ hg status --change 4
  A .hgsub
  A .hgsubstate
  $ hg status
  A dos
  A mac
  A mixed
  R con.xml (no-windows !)
  ! a1
  ? b2.orig
  ? c3
  ? unknown

Test files at -r0 should be filtered by files at wdir
-----------------------------------------------------

  $ fileset -r0 'tracked() and revs("wdir()", tracked())'
  a1
  b1
  b2

Test that "revs()" work at all
------------------------------

  $ fileset "revs('2', modified())"
  b2

Test that "revs()" work for file missing in the working copy/current context
----------------------------------------------------------------------------

(a2 not in working copy)

  $ fileset "revs('0', added())"
  a1
  a2
  b1
  b2

(none of the file exist in "0")

  $ fileset -r 0 "revs('4', added())"
  .hgsub
  .hgsubstate

Call with empty revset
--------------------------

  $ fileset "revs('2-2', modified())"

Call with revset matching multiple revs
---------------------------------------

  $ fileset "revs('0+4', added())"
  .hgsub
  .hgsubstate
  a1
  a2
  b1
  b2

overlapping set

  $ fileset "revs('1+2', modified())"
  b2

test 'status(...)'
=================

Simple case
-----------

  $ fileset "status(3, 4, added())"
  .hgsub
  .hgsubstate

use rev to restrict matched file
-----------------------------------------

  $ hg status --removed --rev 0 --rev 1
  R a2
  $ fileset "status(0, 1, removed())"
  a2
  $ fileset "tracked() and status(0, 1, removed())"
  $ fileset -r 4 "status(0, 1, removed())"
  a2
  $ fileset -r 4 "tracked() and status(0, 1, removed())"
  $ fileset "revs('4', tracked() and status(0, 1, removed()))"
  $ fileset "revs('0', tracked() and status(0, 1, removed()))"
  a2

check wdir()
------------

  $ hg status --removed  --rev 4
  R con.xml (no-windows !)
  $ fileset "status(4, 'wdir()', removed())"
  con.xml (no-windows !)

  $ hg status --removed --rev 2
  R a2
  $ fileset "status('2', 'wdir()', removed())"
  a2

test backward status
--------------------

  $ hg status --removed --rev 0 --rev 4
  R a2
  $ hg status --added --rev 4 --rev 0
  A a2
  $ fileset "status(4, 0, added())"
  a2

test cross branch status
------------------------

  $ hg status --added --rev 1 --rev 2
  A a2
  $ fileset "status(1, 2, added())"
  a2

test with multi revs revset
---------------------------
  $ hg status --added --rev 0:1 --rev 3:4
  A .hgsub
  A .hgsubstate
  A 1k
  A 2k
  A b2link (no-windows !)
  A bin
  A c1
  A con.xml (no-windows !)
  $ fileset "status('0:1', '3:4', added())"
  .hgsub
  .hgsubstate
  1k
  2k
  b2link (no-windows !)
  bin
  c1
  con.xml (no-windows !)

tests with empty value
----------------------

Fully empty revset

  $ fileset "status('', '4', added())"
  hg: parse error: first argument to status must be a revision
  [255]
  $ fileset "status('2', '', added())"
  hg: parse error: second argument to status must be a revision
  [255]

Empty revset will error at the revset layer

  $ fileset "status(' ', '4', added())"
  hg: parse error at 1: not a prefix: end
  ( 
    ^ here)
  [255]
  $ fileset "status('2', ' ', added())"
  hg: parse error at 1: not a prefix: end
  ( 
    ^ here)
  [255]