tests/test-revset.t

32816:1b25c648d5b7

  $ try 0:1
  (range
    ('symbol', '0')
    ('symbol', '1'))
  * set:
  <spanset+ 0:1>
  0
  1
  $ try --optimize :
  (rangeall
    None)
  * optimized:
  (rangeall
    None
    define)
  * set:
  <spanset+ 0:9>
  0
  1
  2
  3
  4

  3
  $ try '+a+b+c+:'
  (rangepost
    ('symbol', '+a+b+c+'))
  * set:
  <spanset+ 3:9>
  3
  4
  5
  6
  7

  9
  $ try ':+a+b+c+'
  (rangepre
    ('symbol', '+a+b+c+'))
  * set:
  <spanset+ 0:3>
  0
  1
  2
  3
  $ try -- '-a-b-c-:+a+b+c+'
  (range
    ('symbol', '-a-b-c-')
    ('symbol', '+a+b+c+'))
  * set:
  <spanset- 3:4>
  4
  3
  $ log '-a-b-c-:+a+b+c+'
  4
  3

  * analyzed:
  (rangeall
    None
    define)
  * set:
  <spanset+ 0:9>
  0
  1
  2
  3
  4

  * analyzed:
  (rangepre
    ('symbol', '1')
    define)
  * set:
  <spanset+ 0:1>
  0
  1
  $ try -p analyzed ':(1|2)'
  * analyzed:
  (rangepre

        ('symbol', '1')
        ('symbol', '2'))
      define)
    define)
  * set:
  <spanset+ 0:2>
  0
  1
  2
  $ try -p analyzed ':(1&2)'
  * analyzed:

  (range
    (parentpost
      ('symbol', '1'))
    ('symbol', '2'))
  * set:
  <spanset+ 0:2>
  0
  1
  2

  $ try '1^::2'

  $ try '9^:'
  (rangepost
    (parentpost
      ('symbol', '9')))
  * set:
  <spanset+ 8:9>
  8
  9

 x^:y should be resolved before omitting group operators

    (range
      (parentpost
        ('symbol', '1'))
      ('symbol', '2')))
  * set:
  <spanset+ 0:2>
  0
  1
  2

  $ try '(3^:4)^:2'

          (parentpost
            ('symbol', '3'))
          ('symbol', '4'))))
    ('symbol', '2'))
  * set:
  <spanset+ 0:2>
  0
  1
  2

  $ try '(3^::4)^::2'

      (group
        (rangepost
          (parentpost
            ('symbol', '9'))))))
  * set:
  <spanset+ 4:9>
  4
  5
  6
  7
  8

  (range
    (parentpost
      ('symbol', '1'))
    ('symbol', '2'))
  * set:
  <spanset+ 0:2>
  0
  1
  2

  $ try 'A:2' --config 'revsetalias.A=1^'

  (range
    (parentpost
      ('symbol', '1'))
    ('symbol', '2'))
  * set:
  <spanset+ 0:2>
  0
  1
  2

 but not beyond the boundary of alias expansion, because the resolution should

  (func
    ('symbol', 'grep')
    ('string', '\x08issue\\d+'))
  * set:
  <filteredset
    <fullreposet+ 0:9>,
    <grep '\x08issue\\d+'>>
  $ try 'grep(r"\bissue\d+")'
  (func
    ('symbol', 'grep')
    ('string', '\\bissue\\d+'))
  * set:
  <filteredset
    <fullreposet+ 0:9>,
    <grep '\\bissue\\d+'>>
  6
  $ try 'grep(r"\")'
  hg: parse error at 7: unterminated string
  [255]

  $ hg debugrevspec -s 'first(4:0, 3) & 3:'
  * set:
  <filteredset
    <baseset
      <limit n=3, offset=0,
        <spanset- 0:4>>>,
    <spanset+ 3:9>>
  4
  3

  $ hg debugrevspec -s '3: & first(4:0, 3)'
  * set:
  <filteredset
    <spanset+ 3:9>,
    <baseset
      <limit n=3, offset=0,
        <spanset- 0:4>>>>
  3
  4

  $ hg debugrevspec -s 'last(4:0, 3) & :1'
  * set:
  <filteredset
    <baseset
      <last n=3,
        <spanset+ 0:4>>>,
    <spanset+ 0:1>>
  1
  0

  $ hg debugrevspec -s ':1 & last(4:0, 3)'
  * set:
  <filteredset
    <spanset+ 0:1>,
    <baseset
      <last n=3,
        <spanset+ 0:4>>>>
  0
  1

Test matching

      any)
    define)
  * set:
  <filteredset
    <filteredset
      <spanset- 0:3>,
      <spanset+ 0:3>>,
    <not
      <spanset+ 1:2>>>
  3
  0

 'a + b', which is optimized to '_list(a b)', should take the ordering of
 the left expression:

      ('string', '0\x001\x002')
      follow)
    define)
  * set:
  <filteredset
    <spanset- 0:2>,
    <baseset [0, 1, 2]>>
  2
  1
  0

          follow))
      follow)
    define)
  * set:
  <filteredset
    <spanset- 0:2>,
    <addset
      <baseset [2]>,
      <spanset+ 0:1>>>
  2
  1
  0

 '_intlist(a b)' should behave like 'a + b':

      ('symbol', '0')
      define)
    define)
  * set:
  <filteredset
    <spanset- 0:2>,
    <baseset+ [0, 1, 2]>>
  2
  1
  0

      follow)
    define)
  * set:
  <filteredset
    <baseset [0, 2, 1]>,
    <spanset- 0:2>>
  0
  2
  1

 '_hexlist(a b)' should behave like 'a + b':

      ('string', '*') (glob)
      follow)
    define)
  * set:
  <filteredset
    <spanset- 0:2>,
    <baseset [0, 1, 2]>>
  2
  1
  0

      ('string', '0\x001')
      any)
    define)
  * set:
  <filteredset
    <spanset- 0:2>,
    <not
      <baseset [0, 1]>>>
  2

  $ try -p optimized '2:0 & not (0:2 & (0 + 1))'

        any)
      any)
    define)
  * set:
  <filteredset
    <spanset- 0:2>,
    <not
      <baseset [0, 1]>>>
  2

 because 'present()' does nothing other than suppressing an error, the

        follow)
      follow)
    define)
  * set:
  <filteredset
    <spanset- 0:2>,
    <baseset [0, 1, 2]>>
  2
  1
  0

        define)
      follow)
    define)
  * set:
  <filteredset
    <spanset+ 0:2>,
    <spanset+ 0:9>>
  0
  1
  2

 'sort()' should take effect only if it is the outermost expression:

        ('string', '-rev'))
      follow)
    define)
  * set:
  <filteredset
    <spanset+ 0:2>,
    <spanset+ 0:9>>
  0
  1
  2

 invalid argument passed to noop sort():

  * set:
  <filteredset
    <baseset
      <limit n=1, offset=0,
        <baseset [1, 0, 2]>>>,
    <spanset- 0:2>>
  1

  $ try --optimize '2:0 & not last(0 + 2 + 1)'
  (and
    (range

        define)
      any)
    define)
  * set:
  <filteredset
    <spanset- 0:2>,
    <not
      <baseset
        <last n=1,
          <baseset [1, 2, 0]>>>>>
  2

        define)
      follow)
    define)
  * set:
  <filteredset
    <spanset- 0:2>,
    <baseset [1]>>
  1

 'A & B' can be rewritten as 'B & A' by weight, but that's fine as long as
 the ordering rule is determined before the rewrite; in this example,

          follow))
      follow)
    define)
  * set:
  <filteredset
    <spanset+ 0:2>,
    <addset
      <baseset [2]>,
      <filteredset
        <fullreposet+ 0:9>,
        <contains 'a'>>>>
  0
  1
  2

      define)
    define)
  * set:
  <addset
    <filteredset
      <spanset- 0:2>,
      <contains 'a'>>,
    <baseset [2]>>
  1
  0
  2

        define))
    define)
  * set:
  <addset
    <baseset [0, 1]>,
    <spanset+ 2:3>>
  0
  1
  2
  3

        define))
    define)
  * set:
  <addset
    <addset
      <spanset+ 0:1>,
      <baseset [2]>>,
    <addset
      <spanset+ 3:4>,
      <baseset [5, 6]>>>
  0
  1
  2
  3

        ('symbol', '4')
        ('symbol', '5'))))
  * set:
  <addset
    <addset
      <spanset+ 0:1>,
      <spanset+ 1:2>>,
    <addset
      <spanset+ 2:3>,
      <addset
        <spanset+ 3:4>,
        <spanset+ 4:5>>>>
  0
  1
  2
  3
  4

  (func
    ('symbol', 'merge')
    None)
  * set:
  <filteredset
    <fullreposet+ 0:9>,
    <merge>>
  6

  $ HGPLAIN=1
  $ export HGPLAIN

  (func
    ('symbol', 'merge')
    None)
  * set:
  <filteredset
    <fullreposet+ 0:9>,
    <merge>>
  6

  $ unset HGPLAIN
  $ unset HGPLAINEXCEPT

      ('symbol', 'merge')
      None))
  * set:
  <addset+
    <filteredset
      <fullreposet+ 0:9>,
      <merge>>,
    <generatorset+>>
  6
  7

      ('symbol', '2')
      ('symbol', '5')))
  * set:
  <baseset
    <max
      <fullreposet+ 0:9>,
      <spanset+ 2:5>>>
  5

test chained `or` operations are flattened at parsing phase

  $ echo 'chainedorops($1, $2, $3) = $1|$2|$3' >> .hg/hgrc

      (range
        ('symbol', '2')
        ('symbol', '3'))))
  * set:
  <addset
    <spanset+ 0:1>,
    <addset
      <spanset+ 1:2>,
      <spanset+ 2:3>>>
  0
  1
  2
  3

      ('symbol', 'all')
      None))
  * set:
  <filteredset
    <baseset [0]>,
    <spanset+ 0:9>>
  0

test unknown reference:

  $ try "unknownref(0)" --config 'revsetalias.unknownref($1)=$1:$2'

        ('string', '$1'))))
  * set:
  <addset
    <baseset [9]>,
    <filteredset
      <fullreposet+ 0:9>,
      <desc '$1'>>>
  9

  $ try 'd(2:5)'
  (func

      ('symbol', '2')))
  * set:
  <filteredset
    <baseset
      <max
        <fullreposet+ 0:9>,
        <baseset [1, 2]>>>,
    <not
      <baseset [2]>>>
  $ try 'min(1 or 2) and not 1'
  (and

      ('symbol', '1')))
  * set:
  <filteredset
    <baseset
      <min
        <fullreposet+ 0:9>,
        <baseset [1, 2]>>>,
    <not
      <baseset [1]>>>
  $ try 'last(1 or 2, 1) and not 2'
  (and

32817:e962c70c0aad

  $ try 0:1
  (range
    ('symbol', '0')
    ('symbol', '1'))
  * set:
  <spanset+ 0:2>
  0
  1
  $ try --optimize :
  (rangeall
    None)
  * optimized:
  (rangeall
    None
    define)
  * set:
  <spanset+ 0:10>
  0
  1
  2
  3
  4

  3
  $ try '+a+b+c+:'
  (rangepost
    ('symbol', '+a+b+c+'))
  * set:
  <spanset+ 3:10>
  3
  4
  5
  6
  7

  9
  $ try ':+a+b+c+'
  (rangepre
    ('symbol', '+a+b+c+'))
  * set:
  <spanset+ 0:4>
  0
  1
  2
  3
  $ try -- '-a-b-c-:+a+b+c+'
  (range
    ('symbol', '-a-b-c-')
    ('symbol', '+a+b+c+'))
  * set:
  <spanset- 3:5>
  4
  3
  $ log '-a-b-c-:+a+b+c+'
  4
  3

  * analyzed:
  (rangeall
    None
    define)
  * set:
  <spanset+ 0:10>
  0
  1
  2
  3
  4

  * analyzed:
  (rangepre
    ('symbol', '1')
    define)
  * set:
  <spanset+ 0:2>
  0
  1
  $ try -p analyzed ':(1|2)'
  * analyzed:
  (rangepre

        ('symbol', '1')
        ('symbol', '2'))
      define)
    define)
  * set:
  <spanset+ 0:3>
  0
  1
  2
  $ try -p analyzed ':(1&2)'
  * analyzed:

  (range
    (parentpost
      ('symbol', '1'))
    ('symbol', '2'))
  * set:
  <spanset+ 0:3>
  0
  1
  2

  $ try '1^::2'

  $ try '9^:'
  (rangepost
    (parentpost
      ('symbol', '9')))
  * set:
  <spanset+ 8:10>
  8
  9

 x^:y should be resolved before omitting group operators

    (range
      (parentpost
        ('symbol', '1'))
      ('symbol', '2')))
  * set:
  <spanset+ 0:3>
  0
  1
  2

  $ try '(3^:4)^:2'

          (parentpost
            ('symbol', '3'))
          ('symbol', '4'))))
    ('symbol', '2'))
  * set:
  <spanset+ 0:3>
  0
  1
  2

  $ try '(3^::4)^::2'

      (group
        (rangepost
          (parentpost
            ('symbol', '9'))))))
  * set:
  <spanset+ 4:10>
  4
  5
  6
  7
  8

  (range
    (parentpost
      ('symbol', '1'))
    ('symbol', '2'))
  * set:
  <spanset+ 0:3>
  0
  1
  2

  $ try 'A:2' --config 'revsetalias.A=1^'

  (range
    (parentpost
      ('symbol', '1'))
    ('symbol', '2'))
  * set:
  <spanset+ 0:3>
  0
  1
  2

 but not beyond the boundary of alias expansion, because the resolution should

  (func
    ('symbol', 'grep')
    ('string', '\x08issue\\d+'))
  * set:
  <filteredset
    <fullreposet+ 0:10>,
    <grep '\x08issue\\d+'>>
  $ try 'grep(r"\bissue\d+")'
  (func
    ('symbol', 'grep')
    ('string', '\\bissue\\d+'))
  * set:
  <filteredset
    <fullreposet+ 0:10>,
    <grep '\\bissue\\d+'>>
  6
  $ try 'grep(r"\")'
  hg: parse error at 7: unterminated string
  [255]

  $ hg debugrevspec -s 'first(4:0, 3) & 3:'
  * set:
  <filteredset
    <baseset
      <limit n=3, offset=0,
        <spanset- 0:5>>>,
    <spanset+ 3:10>>
  4
  3

  $ hg debugrevspec -s '3: & first(4:0, 3)'
  * set:
  <filteredset
    <spanset+ 3:10>,
    <baseset
      <limit n=3, offset=0,
        <spanset- 0:5>>>>
  3
  4

  $ hg debugrevspec -s 'last(4:0, 3) & :1'
  * set:
  <filteredset
    <baseset
      <last n=3,
        <spanset+ 0:5>>>,
    <spanset+ 0:2>>
  1
  0

  $ hg debugrevspec -s ':1 & last(4:0, 3)'
  * set:
  <filteredset
    <spanset+ 0:2>,
    <baseset
      <last n=3,
        <spanset+ 0:5>>>>
  0
  1

Test matching

      any)
    define)
  * set:
  <filteredset
    <filteredset
      <spanset- 0:4>,
      <spanset+ 0:4>>,
    <not
      <spanset+ 1:3>>>
  3
  0

 'a + b', which is optimized to '_list(a b)', should take the ordering of
 the left expression:

      ('string', '0\x001\x002')
      follow)
    define)
  * set:
  <filteredset
    <spanset- 0:3>,
    <baseset [0, 1, 2]>>
  2
  1
  0

          follow))
      follow)
    define)
  * set:
  <filteredset
    <spanset- 0:3>,
    <addset
      <baseset [2]>,
      <spanset+ 0:2>>>
  2
  1
  0

 '_intlist(a b)' should behave like 'a + b':

      ('symbol', '0')
      define)
    define)
  * set:
  <filteredset
    <spanset- 0:3>,
    <baseset+ [0, 1, 2]>>
  2
  1
  0

      follow)
    define)
  * set:
  <filteredset
    <baseset [0, 2, 1]>,
    <spanset- 0:3>>
  0
  2
  1

 '_hexlist(a b)' should behave like 'a + b':

      ('string', '*') (glob)
      follow)
    define)
  * set:
  <filteredset
    <spanset- 0:3>,
    <baseset [0, 1, 2]>>
  2
  1
  0

      ('string', '0\x001')
      any)
    define)
  * set:
  <filteredset
    <spanset- 0:3>,
    <not
      <baseset [0, 1]>>>
  2

  $ try -p optimized '2:0 & not (0:2 & (0 + 1))'

        any)
      any)
    define)
  * set:
  <filteredset
    <spanset- 0:3>,
    <not
      <baseset [0, 1]>>>
  2

 because 'present()' does nothing other than suppressing an error, the

        follow)
      follow)
    define)
  * set:
  <filteredset
    <spanset- 0:3>,
    <baseset [0, 1, 2]>>
  2
  1
  0

        define)
      follow)
    define)
  * set:
  <filteredset
    <spanset+ 0:3>,
    <spanset+ 0:10>>
  0
  1
  2

 'sort()' should take effect only if it is the outermost expression:

        ('string', '-rev'))
      follow)
    define)
  * set:
  <filteredset
    <spanset+ 0:3>,
    <spanset+ 0:10>>
  0
  1
  2

 invalid argument passed to noop sort():

  * set:
  <filteredset
    <baseset
      <limit n=1, offset=0,
        <baseset [1, 0, 2]>>>,
    <spanset- 0:3>>
  1

  $ try --optimize '2:0 & not last(0 + 2 + 1)'
  (and
    (range

        define)
      any)
    define)
  * set:
  <filteredset
    <spanset- 0:3>,
    <not
      <baseset
        <last n=1,
          <baseset [1, 2, 0]>>>>>
  2

        define)
      follow)
    define)
  * set:
  <filteredset
    <spanset- 0:3>,
    <baseset [1]>>
  1

 'A & B' can be rewritten as 'B & A' by weight, but that's fine as long as
 the ordering rule is determined before the rewrite; in this example,

          follow))
      follow)
    define)
  * set:
  <filteredset
    <spanset+ 0:3>,
    <addset
      <baseset [2]>,
      <filteredset
        <fullreposet+ 0:10>,
        <contains 'a'>>>>
  0
  1
  2

      define)
    define)
  * set:
  <addset
    <filteredset
      <spanset- 0:3>,
      <contains 'a'>>,
    <baseset [2]>>
  1
  0
  2

        define))
    define)
  * set:
  <addset
    <baseset [0, 1]>,
    <spanset+ 2:4>>
  0
  1
  2
  3

        define))
    define)
  * set:
  <addset
    <addset
      <spanset+ 0:2>,
      <baseset [2]>>,
    <addset
      <spanset+ 3:5>,
      <baseset [5, 6]>>>
  0
  1
  2
  3

        ('symbol', '4')
        ('symbol', '5'))))
  * set:
  <addset
    <addset
      <spanset+ 0:2>,
      <spanset+ 1:3>>,
    <addset
      <spanset+ 2:4>,
      <addset
        <spanset+ 3:5>,
        <spanset+ 4:6>>>>
  0
  1
  2
  3
  4

  (func
    ('symbol', 'merge')
    None)
  * set:
  <filteredset
    <fullreposet+ 0:10>,
    <merge>>
  6

  $ HGPLAIN=1
  $ export HGPLAIN

  (func
    ('symbol', 'merge')
    None)
  * set:
  <filteredset
    <fullreposet+ 0:10>,
    <merge>>
  6

  $ unset HGPLAIN
  $ unset HGPLAINEXCEPT

      ('symbol', 'merge')
      None))
  * set:
  <addset+
    <filteredset
      <fullreposet+ 0:10>,
      <merge>>,
    <generatorset+>>
  6
  7

      ('symbol', '2')
      ('symbol', '5')))
  * set:
  <baseset
    <max
      <fullreposet+ 0:10>,
      <spanset+ 2:6>>>
  5

test chained `or` operations are flattened at parsing phase

  $ echo 'chainedorops($1, $2, $3) = $1|$2|$3' >> .hg/hgrc

      (range
        ('symbol', '2')
        ('symbol', '3'))))
  * set:
  <addset
    <spanset+ 0:2>,
    <addset
      <spanset+ 1:3>,
      <spanset+ 2:4>>>
  0
  1
  2
  3

      ('symbol', 'all')
      None))
  * set:
  <filteredset
    <baseset [0]>,
    <spanset+ 0:10>>
  0

test unknown reference:

  $ try "unknownref(0)" --config 'revsetalias.unknownref($1)=$1:$2'

        ('string', '$1'))))
  * set:
  <addset
    <baseset [9]>,
    <filteredset
      <fullreposet+ 0:10>,
      <desc '$1'>>>
  9

  $ try 'd(2:5)'
  (func

      ('symbol', '2')))
  * set:
  <filteredset
    <baseset
      <max
        <fullreposet+ 0:10>,
        <baseset [1, 2]>>>,
    <not
      <baseset [2]>>>
  $ try 'min(1 or 2) and not 1'
  (and

      ('symbol', '1')))
  * set:
  <filteredset
    <baseset
      <min
        <fullreposet+ 0:10>,
        <baseset [1, 2]>>>,
    <not
      <baseset [1]>>>
  $ try 'last(1 or 2, 1) and not 2'
  (and