test-revset.t
2739 lines
| 46.7 KiB
| text/troff
|
Tads3Lexer
/ tests / test-revset.t
|
r12105 | $ HGENCODING=utf-8 | ||
$ export HGENCODING | ||||
|
r24940 | $ cat > testrevset.py << EOF | ||
> import mercurial.revset | ||||
> | ||||
> baseset = mercurial.revset.baseset | ||||
> | ||||
> def r3232(repo, subset, x): | ||||
> """"simple revset that return [3,2,3,2] | ||||
> | ||||
> revisions duplicated on purpose. | ||||
> """ | ||||
> if 3 not in subset: | ||||
> if 2 in subset: | ||||
> return baseset([2,2]) | ||||
> return baseset() | ||||
> return baseset([3,3,2,2]) | ||||
> | ||||
> mercurial.revset.symbols['r3232'] = r3232 | ||||
> EOF | ||||
$ cat >> $HGRCPATH << EOF | ||||
> [extensions] | ||||
|
r33377 | > drawdag=$TESTDIR/drawdag.py | ||
|
r24940 | > testrevset=$TESTTMP/testrevset.py | ||
> EOF | ||||
|
r12105 | |||
$ try() { | ||||
|
r14098 | > hg debugrevspec --debug "$@" | ||
|
r12105 | > } | ||
$ log() { | ||||
> hg log --template '{rev}\n' -r "$1" | ||||
> } | ||||
|
r29390 | extension to build '_intlist()' and '_hexlist()', which is necessary because | ||
these predicates use '\0' as a separator: | ||||
$ cat <<EOF > debugrevlistspec.py | ||||
> from __future__ import absolute_import | ||||
> from mercurial import ( | ||||
> node as nodemod, | ||||
|
r32337 | > registrar, | ||
|
r29390 | > revset, | ||
|
r31024 | > revsetlang, | ||
|
r30881 | > smartset, | ||
|
r29390 | > ) | ||
> cmdtable = {} | ||||
|
r32337 | > command = registrar.command(cmdtable) | ||
|
r33097 | > @command(b'debugrevlistspec', | ||
|
r29390 | > [('', 'optimize', None, 'print parsed tree after optimizing'), | ||
> ('', 'bin', None, 'unhexlify arguments')]) | ||||
> def debugrevlistspec(ui, repo, fmt, *args, **opts): | ||||
> if opts['bin']: | ||||
> args = map(nodemod.bin, args) | ||||
|
r31024 | > expr = revsetlang.formatspec(fmt, list(args)) | ||
|
r29390 | > if ui.verbose: | ||
|
r31024 | > tree = revsetlang.parse(expr, lookup=repo.__contains__) | ||
> ui.note(revsetlang.prettyformat(tree), "\n") | ||||
|
r29390 | > if opts["optimize"]: | ||
|
r31024 | > opttree = revsetlang.optimize(revsetlang.analyze(tree)) | ||
> ui.note("* optimized:\n", revsetlang.prettyformat(opttree), | ||||
> "\n") | ||||
|
r29390 | > func = revset.match(ui, expr, repo) | ||
> revs = func(repo) | ||||
> if ui.verbose: | ||||
|
r30881 | > ui.note("* set:\n", smartset.prettyformat(revs), "\n") | ||
|
r29390 | > for c in revs: | ||
> ui.write("%s\n" % c) | ||||
> EOF | ||||
$ cat <<EOF >> $HGRCPATH | ||||
> [extensions] | ||||
> debugrevlistspec = $TESTTMP/debugrevlistspec.py | ||||
> EOF | ||||
$ trylist() { | ||||
> hg debugrevlistspec --debug "$@" | ||||
> } | ||||
|
r12105 | $ hg init repo | ||
$ cd repo | ||||
$ echo a > a | ||||
$ hg branch a | ||||
marked working directory as branch a | ||||
|
r15615 | (branches are permanent and global, did you want a bookmark?) | ||
|
r12105 | $ hg ci -Aqm0 | ||
$ echo b > b | ||||
$ hg branch b | ||||
marked working directory as branch b | ||||
$ hg ci -Aqm1 | ||||
$ rm a | ||||
$ hg branch a-b-c- | ||||
marked working directory as branch a-b-c- | ||||
$ hg ci -Aqm2 -u Bob | ||||
|
r16661 | $ hg log -r "extra('branch', 'a-b-c-')" --template '{rev}\n' | ||
2 | ||||
$ hg log -r "extra('branch')" --template '{rev}\n' | ||||
0 | ||||
1 | ||||
2 | ||||
|
r16824 | $ hg log -r "extra('branch', 're:a')" --template '{rev} {branch}\n' | ||
0 a | ||||
2 a-b-c- | ||||
|
r16661 | |||
|
r12105 | $ hg co 1 | ||
1 files updated, 0 files merged, 0 files removed, 0 files unresolved | ||||
$ hg branch +a+b+c+ | ||||
marked working directory as branch +a+b+c+ | ||||
$ hg ci -Aqm3 | ||||
$ hg co 2 # interleave | ||||
0 files updated, 0 files merged, 1 files removed, 0 files unresolved | ||||
$ echo bb > b | ||||
$ hg branch -- -a-b-c- | ||||
marked working directory as branch -a-b-c- | ||||
$ hg ci -Aqm4 -d "May 12 2005" | ||||
$ hg co 3 | ||||
2 files updated, 0 files merged, 0 files removed, 0 files unresolved | ||||
|
r16851 | $ hg branch !a/b/c/ | ||
marked working directory as branch !a/b/c/ | ||||
|
r12105 | $ hg ci -Aqm"5 bug" | ||
$ hg merge 4 | ||||
1 files updated, 0 files merged, 1 files removed, 0 files unresolved | ||||
(branch merge, don't forget to commit) | ||||
$ hg branch _a_b_c_ | ||||
marked working directory as branch _a_b_c_ | ||||
$ hg ci -Aqm"6 issue619" | ||||
$ hg branch .a.b.c. | ||||
marked working directory as branch .a.b.c. | ||||
$ hg ci -Aqm7 | ||||
$ hg branch all | ||||
marked working directory as branch all | ||||
$ hg co 4 | ||||
0 files updated, 0 files merged, 0 files removed, 0 files unresolved | ||||
$ hg branch é | ||||
|
r12942 | marked working directory as branch \xc3\xa9 (esc) | ||
|
r12105 | $ hg ci -Aqm9 | ||
$ hg tag -r6 1.0 | ||||
|
r24904 | $ hg bookmark -r6 xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx | ||
|
r12105 | |||
$ hg clone --quiet -U -r 7 . ../remote1 | ||||
$ hg clone --quiet -U -r 8 . ../remote2 | ||||
$ echo "[paths]" >> .hg/hgrc | ||||
$ echo "default = ../remote1" >> .hg/hgrc | ||||
|
r24458 | trivial | ||
$ try 0:1 | ||||
(range | ||||
|
r34075 | (symbol '0') | ||
(symbol '1')) | ||||
|
r24458 | * set: | ||
|
r32817 | <spanset+ 0:2> | ||
|
r24458 | 0 | ||
1 | ||||
|
r25819 | $ try --optimize : | ||
(rangeall | ||||
None) | ||||
* optimized: | ||||
|
r30803 | (rangeall | ||
|
r34013 | None) | ||
|
r25819 | * set: | ||
|
r32817 | <spanset+ 0:10> | ||
|
r25819 | 0 | ||
1 | ||||
2 | ||||
3 | ||||
4 | ||||
5 | ||||
6 | ||||
7 | ||||
8 | ||||
9 | ||||
|
r24458 | $ try 3::6 | ||
(dagrange | ||||
|
r34075 | (symbol '3') | ||
(symbol '6')) | ||||
|
r24458 | * set: | ||
|
r26061 | <baseset+ [3, 5, 6]> | ||
|
r24458 | 3 | ||
5 | ||||
6 | ||||
$ try '0|1|2' | ||||
(or | ||||
|
r29929 | (list | ||
|
r34075 | (symbol '0') | ||
(symbol '1') | ||||
(symbol '2'))) | ||||
|
r24458 | * set: | ||
|
r25343 | <baseset [0, 1, 2]> | ||
|
r24458 | 0 | ||
1 | ||||
2 | ||||
|
r12105 | names that should work without quoting | ||
$ try a | ||||
|
r34075 | (symbol 'a') | ||
|
r24458 | * set: | ||
<baseset [0]> | ||||
|
r12105 | 0 | ||
$ try b-a | ||||
|
r16218 | (minus | ||
|
r34075 | (symbol 'b') | ||
(symbol 'a')) | ||||
|
r24458 | * set: | ||
<filteredset | ||||
|
r28423 | <baseset [1]>, | ||
<not | ||||
<baseset [0]>>> | ||||
|
r12105 | 1 | ||
$ try _a_b_c_ | ||||
|
r34075 | (symbol '_a_b_c_') | ||
|
r24458 | * set: | ||
<baseset [6]> | ||||
|
r12105 | 6 | ||
$ try _a_b_c_-a | ||||
|
r16218 | (minus | ||
|
r34075 | (symbol '_a_b_c_') | ||
(symbol 'a')) | ||||
|
r24458 | * set: | ||
<filteredset | ||||
|
r28423 | <baseset [6]>, | ||
<not | ||||
<baseset [0]>>> | ||||
|
r12105 | 6 | ||
$ try .a.b.c. | ||||
|
r34075 | (symbol '.a.b.c.') | ||
|
r24458 | * set: | ||
<baseset [7]> | ||||
|
r12105 | 7 | ||
$ try .a.b.c.-a | ||||
|
r16218 | (minus | ||
|
r34075 | (symbol '.a.b.c.') | ||
(symbol 'a')) | ||||
|
r24458 | * set: | ||
<filteredset | ||||
|
r28423 | <baseset [7]>, | ||
<not | ||||
<baseset [0]>>> | ||||
|
r12105 | 7 | ||
|
r25901 | |||
names that should be caught by fallback mechanism | ||||
$ try -- '-a-b-c-' | ||||
|
r34075 | (symbol '-a-b-c-') | ||
|
r25901 | * set: | ||
<baseset [4]> | ||||
4 | ||||
$ log -a-b-c- | ||||
|
r12105 | 4 | ||
|
r25902 | $ try '+a+b+c+' | ||
|
r34075 | (symbol '+a+b+c+') | ||
|
r25902 | * set: | ||
<baseset [3]> | ||||
3 | ||||
$ try '+a+b+c+:' | ||||
(rangepost | ||||
|
r34075 | (symbol '+a+b+c+')) | ||
|
r25902 | * set: | ||
|
r32817 | <spanset+ 3:10> | ||
|
r25902 | 3 | ||
|
r12105 | 4 | ||
|
r25902 | 5 | ||
6 | ||||
7 | ||||
8 | ||||
9 | ||||
$ try ':+a+b+c+' | ||||
(rangepre | ||||
|
r34075 | (symbol '+a+b+c+')) | ||
|
r25902 | * set: | ||
|
r32817 | <spanset+ 0:4> | ||
|
r25902 | 0 | ||
1 | ||||
2 | ||||
3 | ||||
$ try -- '-a-b-c-:+a+b+c+' | ||||
(range | ||||
|
r34075 | (symbol '-a-b-c-') | ||
(symbol '+a+b+c+')) | ||||
|
r25902 | * set: | ||
|
r32817 | <spanset- 3:5> | ||
|
r25902 | 4 | ||
3 | ||||
$ log '-a-b-c-:+a+b+c+' | ||||
4 | ||||
3 | ||||
|
r20781 | |||
|
r12105 | $ try -- -a-b-c--a # complains | ||
|
r16218 | (minus | ||
(minus | ||||
(minus | ||||
(negate | ||||
|
r34075 | (symbol 'a')) | ||
(symbol 'b')) | ||||
(symbol 'c')) | ||||
|
r16218 | (negate | ||
|
r34075 | (symbol 'a'))) | ||
|
r12105 | abort: unknown revision '-a'! | ||
|
r12316 | [255] | ||
|
r12105 | $ try é | ||
|
r34075 | (symbol '\xc3\xa9') | ||
|
r24458 | * set: | ||
<baseset [9]> | ||||
|
r12105 | 9 | ||
|
r20781 | no quoting needed | ||
$ log ::a-b-c- | ||||
0 | ||||
1 | ||||
2 | ||||
|
r12105 | quoting needed | ||
$ try '"-a-b-c-"-a' | ||||
|
r16218 | (minus | ||
|
r34075 | (string '-a-b-c-') | ||
(symbol 'a')) | ||||
|
r24458 | * set: | ||
<filteredset | ||||
|
r28423 | <baseset [4]>, | ||
<not | ||||
<baseset [0]>>> | ||||
|
r12105 | 4 | ||
$ log '1 or 2' | ||||
1 | ||||
2 | ||||
$ log '1|2' | ||||
1 | ||||
2 | ||||
$ log '1 and 2' | ||||
$ log '1&2' | ||||
$ try '1&2|3' # precedence - and is higher | ||||
|
r16218 | (or | ||
|
r29929 | (list | ||
(and | ||||
|
r34075 | (symbol '1') | ||
(symbol '2')) | ||||
(symbol '3'))) | ||||
|
r24458 | * set: | ||
<addset | ||||
<baseset []>, | ||||
<baseset [3]>> | ||||
|
r12105 | 3 | ||
$ try '1|2&3' | ||||
|
r16218 | (or | ||
|
r29929 | (list | ||
|
r34075 | (symbol '1') | ||
|
r29929 | (and | ||
|
r34075 | (symbol '2') | ||
(symbol '3')))) | ||||
|
r24458 | * set: | ||
<addset | ||||
<baseset [1]>, | ||||
<baseset []>> | ||||
|
r12105 | 1 | ||
$ try '1&2&3' # associativity | ||||
|
r16218 | (and | ||
(and | ||||
|
r34075 | (symbol '1') | ||
(symbol '2')) | ||||
(symbol '3')) | ||||
|
r24458 | * set: | ||
<baseset []> | ||||
|
r12105 | $ try '1|(2|3)' | ||
|
r16218 | (or | ||
|
r29929 | (list | ||
|
r34075 | (symbol '1') | ||
|
r29929 | (group | ||
(or | ||||
(list | ||||
|
r34075 | (symbol '2') | ||
(symbol '3')))))) | ||||
|
r24458 | * set: | ||
<addset | ||||
<baseset [1]>, | ||||
|
r25343 | <baseset [2, 3]>> | ||
|
r12105 | 1 | ||
2 | ||||
3 | ||||
$ log '1.0' # tag | ||||
6 | ||||
$ log 'a' # branch | ||||
0 | ||||
$ log '2785f51ee' | ||||
0 | ||||
$ log 'date(2005)' | ||||
4 | ||||
$ log 'date(this is a test)' | ||||
hg: parse error at 10: unexpected token: symbol | ||||
|
r12316 | [255] | ||
|
r12105 | $ log 'date()' | ||
|
r12736 | hg: parse error: date requires a string | ||
|
r12316 | [255] | ||
|
r12105 | $ log 'date' | ||
|
r24932 | abort: unknown revision 'date'! | ||
|
r12316 | [255] | ||
|
r12105 | $ log 'date(' | ||
hg: parse error at 5: not a prefix: end | ||||
|
r12316 | [255] | ||
|
r26232 | $ log 'date("\xy")' | ||
hg: parse error: invalid \x escape | ||||
[255] | ||||
|
r12105 | $ log 'date(tip)' | ||
|
r32462 | hg: parse error: invalid date: 'tip' | ||
|
r12316 | [255] | ||
|
r24932 | $ log '0:date' | ||
abort: unknown revision 'date'! | ||||
[255] | ||||
$ log '::"date"' | ||||
|
r12105 | abort: unknown revision 'date'! | ||
|
r12316 | [255] | ||
|
r24932 | $ hg book date -r 4 | ||
$ log '0:date' | ||||
0 | ||||
1 | ||||
2 | ||||
3 | ||||
4 | ||||
$ log '::date' | ||||
0 | ||||
1 | ||||
2 | ||||
4 | ||||
$ log '::"date"' | ||||
0 | ||||
1 | ||||
2 | ||||
4 | ||||
|
r12105 | $ log 'date(2005) and 1::' | ||
4 | ||||
|
r24932 | $ hg book -d date | ||
|
r29441 | function name should be a symbol | ||
$ log '"date"(2005)' | ||||
hg: parse error: not a symbol | ||||
[255] | ||||
|
r25704 | keyword arguments | ||
|
r25706 | $ log 'extra(branch, value=a)' | ||
0 | ||||
$ log 'extra(branch, a, b)' | ||||
|
r31920 | hg: parse error: extra takes at most 2 positional arguments | ||
|
r25706 | [255] | ||
$ log 'extra(a, label=b)' | ||||
hg: parse error: extra got multiple values for keyword argument 'label' | ||||
[255] | ||||
$ log 'extra(label=branch, default)' | ||||
hg: parse error: extra got an invalid argument | ||||
[255] | ||||
$ log 'extra(branch, foo+bar=baz)' | ||||
hg: parse error: extra got an invalid argument | ||||
[255] | ||||
$ log 'extra(unknown=branch)' | ||||
hg: parse error: extra got an unexpected keyword argument 'unknown' | ||||
[255] | ||||
|
r25704 | $ try 'foo=bar|baz' | ||
(keyvalue | ||||
|
r34075 | (symbol 'foo') | ||
|
r25704 | (or | ||
|
r29929 | (list | ||
|
r34075 | (symbol 'bar') | ||
(symbol 'baz')))) | ||||
|
r25704 | hg: parse error: can't use a key-value pair in this context | ||
[255] | ||||
|
r29766 | right-hand side should be optimized recursively | ||
$ try --optimize 'foo=(not public())' | ||||
(keyvalue | ||||
|
r34075 | (symbol 'foo') | ||
|
r29766 | (group | ||
(not | ||||
(func | ||||
|
r34075 | (symbol 'public') | ||
|
r29766 | None)))) | ||
* optimized: | ||||
(keyvalue | ||||
|
r34075 | (symbol 'foo') | ||
|
r29766 | (func | ||
|
r34075 | (symbol '_notpublic') | ||
|
r34013 | None)) | ||
|
r29766 | hg: parse error: can't use a key-value pair in this context | ||
[255] | ||||
|
r33416 | relation-subscript operator has the highest binding strength (as function call): | ||
$ hg debugrevspec -p parsed 'tip:tip^#generations[-1]' | ||||
* parsed: | ||||
(range | ||||
|
r34075 | (symbol 'tip') | ||
|
r33416 | (relsubscript | ||
(parentpost | ||||
|
r34075 | (symbol 'tip')) | ||
(symbol 'generations') | ||||
|
r33416 | (negate | ||
|
r34075 | (symbol '1')))) | ||
|
r33417 | 9 | ||
8 | ||||
7 | ||||
6 | ||||
5 | ||||
4 | ||||
|
r33416 | |||
$ hg debugrevspec -p parsed --no-show-revs 'not public()#generations[0]' | ||||
* parsed: | ||||
(not | ||||
(relsubscript | ||||
(func | ||||
|
r34075 | (symbol 'public') | ||
|
r33416 | None) | ||
|
r34075 | (symbol 'generations') | ||
(symbol '0'))) | ||||
|
r33416 | |||
left-hand side of relation-subscript operator should be optimized recursively: | ||||
$ hg debugrevspec -p analyzed -p optimized --no-show-revs \ | ||||
> '(not public())#generations[0]' | ||||
* analyzed: | ||||
(relsubscript | ||||
(not | ||||
(func | ||||
|
r34075 | (symbol 'public') | ||
|
r34013 | None)) | ||
|
r34075 | (symbol 'generations') | ||
(symbol '0')) | ||||
|
r33416 | * optimized: | ||
(relsubscript | ||||
(func | ||||
|
r34075 | (symbol '_notpublic') | ||
|
r34013 | None) | ||
|
r34075 | (symbol 'generations') | ||
(symbol '0')) | ||||
|
r33416 | |||
resolution of subscript and relation-subscript ternary operators: | ||||
$ hg debugrevspec -p analyzed 'tip[0]' | ||||
* analyzed: | ||||
(subscript | ||||
|
r34075 | (symbol 'tip') | ||
(symbol '0')) | ||||
|
r33416 | hg: parse error: can't use a subscript in this context | ||
[255] | ||||
$ hg debugrevspec -p analyzed 'tip#rel[0]' | ||||
* analyzed: | ||||
(relsubscript | ||||
|
r34075 | (symbol 'tip') | ||
(symbol 'rel') | ||||
(symbol '0')) | ||||
|
r33417 | hg: parse error: unknown identifier: rel | ||
|
r33416 | [255] | ||
$ hg debugrevspec -p analyzed '(tip#rel)[0]' | ||||
* analyzed: | ||||
(subscript | ||||
(relation | ||||
|
r34075 | (symbol 'tip') | ||
(symbol 'rel')) | ||||
(symbol '0')) | ||||
|
r33416 | hg: parse error: can't use a subscript in this context | ||
[255] | ||||
$ hg debugrevspec -p analyzed 'tip#rel[0][1]' | ||||
* analyzed: | ||||
(subscript | ||||
(relsubscript | ||||
|
r34075 | (symbol 'tip') | ||
(symbol 'rel') | ||||
(symbol '0')) | ||||
(symbol '1')) | ||||
|
r33416 | hg: parse error: can't use a subscript in this context | ||
[255] | ||||
$ hg debugrevspec -p analyzed 'tip#rel0#rel1[1]' | ||||
* analyzed: | ||||
(relsubscript | ||||
(relation | ||||
|
r34075 | (symbol 'tip') | ||
(symbol 'rel0')) | ||||
(symbol 'rel1') | ||||
(symbol '1')) | ||||
|
r33417 | hg: parse error: unknown identifier: rel1 | ||
|
r33416 | [255] | ||
$ hg debugrevspec -p analyzed 'tip#rel0[0]#rel1[1]' | ||||
* analyzed: | ||||
(relsubscript | ||||
(relsubscript | ||||
|
r34075 | (symbol 'tip') | ||
(symbol 'rel0') | ||||
(symbol '0')) | ||||
(symbol 'rel1') | ||||
(symbol '1')) | ||||
|
r33417 | hg: parse error: unknown identifier: rel1 | ||
|
r33416 | [255] | ||
parse errors of relation, subscript and relation-subscript operators: | ||||
$ hg debugrevspec '[0]' | ||||
hg: parse error at 0: not a prefix: [ | ||||
[255] | ||||
$ hg debugrevspec '.#' | ||||
hg: parse error at 2: not a prefix: end | ||||
[255] | ||||
$ hg debugrevspec '#rel' | ||||
hg: parse error at 0: not a prefix: # | ||||
[255] | ||||
$ hg debugrevspec '.#rel[0' | ||||
hg: parse error at 7: unexpected token: end | ||||
[255] | ||||
$ hg debugrevspec '.]' | ||||
hg: parse error at 1: invalid token | ||||
[255] | ||||
|
r33417 | $ hg debugrevspec '.#generations[a]' | ||
hg: parse error: relation subscript must be an integer | ||||
[255] | ||||
$ hg debugrevspec '.#generations[1-2]' | ||||
hg: parse error: relation subscript must be an integer | ||||
[255] | ||||
|
r29913 | parsed tree at stages: | ||
$ hg debugrevspec -p all '()' | ||||
* parsed: | ||||
(group | ||||
None) | ||||
* expanded: | ||||
(group | ||||
None) | ||||
* concatenated: | ||||
(group | ||||
None) | ||||
* analyzed: | ||||
None | ||||
* optimized: | ||||
None | ||||
hg: parse error: missing argument | ||||
[255] | ||||
|
r29923 | $ hg debugrevspec --no-optimized -p all '()' | ||
* parsed: | ||||
(group | ||||
None) | ||||
* expanded: | ||||
(group | ||||
None) | ||||
* concatenated: | ||||
(group | ||||
None) | ||||
* analyzed: | ||||
None | ||||
hg: parse error: missing argument | ||||
[255] | ||||
|
r29913 | $ hg debugrevspec -p parsed -p analyzed -p optimized '(0|1)-1' | ||
* parsed: | ||||
(minus | ||||
(group | ||||
(or | ||||
|
r29929 | (list | ||
|
r34075 | (symbol '0') | ||
(symbol '1')))) | ||||
(symbol '1')) | ||||
|
r29913 | * analyzed: | ||
(and | ||||
(or | ||||
|
r29929 | (list | ||
|
r34075 | (symbol '0') | ||
(symbol '1'))) | ||||
|
r29913 | (not | ||
|
r34075 | (symbol '1'))) | ||
|
r29913 | * optimized: | ||
(difference | ||||
(func | ||||
|
r34075 | (symbol '_list') | ||
(string '0\x001')) | ||||
(symbol '1')) | ||||
|
r29913 | 0 | ||
$ hg debugrevspec -p unknown '0' | ||||
abort: invalid stage name: unknown | ||||
[255] | ||||
$ hg debugrevspec -p all --optimize '0' | ||||
abort: cannot use --optimize with --show-stage | ||||
[255] | ||||
|
r29924 | verify optimized tree: | ||
$ hg debugrevspec --verify '0|1' | ||||
$ hg debugrevspec --verify -v -p analyzed -p optimized 'r3232() & 2' | ||||
* analyzed: | ||||
(and | ||||
(func | ||||
|
r34075 | (symbol 'r3232') | ||
|
r34013 | None) | ||
|
r34075 | (symbol '2')) | ||
|
r29924 | * optimized: | ||
|
r34022 | (andsmally | ||
|
r29924 | (func | ||
|
r34075 | (symbol 'r3232') | ||
|
r34022 | None) | ||
|
r34075 | (symbol '2')) | ||
|
r29924 | * analyzed set: | ||
<baseset [2]> | ||||
* optimized set: | ||||
<baseset [2, 2]> | ||||
--- analyzed | ||||
+++ optimized | ||||
2 | ||||
+2 | ||||
[1] | ||||
$ hg debugrevspec --no-optimized --verify-optimized '0' | ||||
abort: cannot use --verify-optimized with --no-optimized | ||||
[255] | ||||
|
r24932 | Test that symbols only get parsed as functions if there's an opening | ||
parenthesis. | ||||
$ hg book only -r 9 | ||||
$ log 'only(only)' # Outer "only" is a function, inner "only" is the bookmark | ||||
8 | ||||
9 | ||||
|
r12105 | |||
|
r30044 | ':y' behaves like '0:y', but can't be rewritten as such since the revision '0' | ||
may be hidden (issue5385) | ||||
$ try -p parsed -p analyzed ':' | ||||
* parsed: | ||||
(rangeall | ||||
None) | ||||
* analyzed: | ||||
|
r30803 | (rangeall | ||
|
r34013 | None) | ||
|
r30044 | * set: | ||
|
r32817 | <spanset+ 0:10> | ||
|
r30044 | 0 | ||
1 | ||||
2 | ||||
3 | ||||
4 | ||||
5 | ||||
6 | ||||
7 | ||||
8 | ||||
9 | ||||
$ try -p analyzed ':1' | ||||
* analyzed: | ||||
(rangepre | ||||
|
r34075 | (symbol '1')) | ||
|
r30044 | * set: | ||
|
r32817 | <spanset+ 0:2> | ||
|
r30044 | 0 | ||
1 | ||||
$ try -p analyzed ':(1|2)' | ||||
* analyzed: | ||||
(rangepre | ||||
(or | ||||
(list | ||||
|
r34075 | (symbol '1') | ||
(symbol '2')))) | ||||
|
r30044 | * set: | ||
|
r32817 | <spanset+ 0:3> | ||
|
r30044 | 0 | ||
1 | ||||
2 | ||||
$ try -p analyzed ':(1&2)' | ||||
* analyzed: | ||||
(rangepre | ||||
(and | ||||
|
r34075 | (symbol '1') | ||
(symbol '2'))) | ||||
|
r30044 | * set: | ||
<baseset []> | ||||
|
r29768 | infix/suffix resolution of ^ operator (issue2884): | ||
x^:y means (x^):y | ||||
|
r29769 | $ try '1^:2' | ||
|
r29768 | (range | ||
(parentpost | ||||
|
r34075 | (symbol '1')) | ||
(symbol '2')) | ||||
|
r29768 | * set: | ||
|
r32817 | <spanset+ 0:3> | ||
|
r29768 | 0 | ||
1 | ||||
2 | ||||
|
r29769 | $ try '1^::2' | ||
|
r29768 | (dagrange | ||
(parentpost | ||||
|
r34075 | (symbol '1')) | ||
(symbol '2')) | ||||
|
r29768 | * set: | ||
<baseset+ [0, 1, 2]> | ||||
0 | ||||
1 | ||||
2 | ||||
|
r29770 | $ try '9^:' | ||
(rangepost | ||||
(parentpost | ||||
|
r34075 | (symbol '9'))) | ||
|
r29770 | * set: | ||
|
r32817 | <spanset+ 8:10> | ||
|
r29770 | 8 | ||
9 | ||||
|
r29768 | x^:y should be resolved before omitting group operators | ||
|
r29769 | $ try '1^(:2)' | ||
|
r29768 | (parent | ||
|
r34075 | (symbol '1') | ||
|
r29768 | (group | ||
(rangepre | ||||
|
r34075 | (symbol '2')))) | ||
|
r29768 | hg: parse error: ^ expects a number 0, 1, or 2 | ||
[255] | ||||
x^:y should be resolved recursively | ||||
|
r29769 | $ try 'sort(1^:2)' | ||
|
r29768 | (func | ||
|
r34075 | (symbol 'sort') | ||
|
r29768 | (range | ||
(parentpost | ||||
|
r34075 | (symbol '1')) | ||
(symbol '2'))) | ||||
|
r29768 | * set: | ||
|
r32817 | <spanset+ 0:3> | ||
|
r29768 | 0 | ||
1 | ||||
2 | ||||
|
r29769 | $ try '(3^:4)^:2' | ||
|
r29768 | (range | ||
(parentpost | ||||
|
r29769 | (group | ||
(range | ||||
(parentpost | ||||
|
r34075 | (symbol '3')) | ||
(symbol '4')))) | ||||
(symbol '2')) | ||||
|
r29768 | * set: | ||
|
r32817 | <spanset+ 0:3> | ||
|
r29768 | 0 | ||
1 | ||||
2 | ||||
|
r29769 | $ try '(3^::4)^::2' | ||
|
r29768 | (dagrange | ||
(parentpost | ||||
|
r29769 | (group | ||
(dagrange | ||||
(parentpost | ||||
|
r34075 | (symbol '3')) | ||
(symbol '4')))) | ||||
(symbol '2')) | ||||
|
r29768 | * set: | ||
<baseset+ [0, 1, 2]> | ||||
0 | ||||
1 | ||||
2 | ||||
|
r29770 | $ try '(9^:)^:' | ||
(rangepost | ||||
(parentpost | ||||
(group | ||||
(rangepost | ||||
(parentpost | ||||
|
r34075 | (symbol '9')))))) | ||
|
r29770 | * set: | ||
|
r32817 | <spanset+ 4:10> | ||
|
r29770 | 4 | ||
5 | ||||
6 | ||||
7 | ||||
8 | ||||
9 | ||||
|
r29768 | x^ in alias should also be resolved | ||
|
r29769 | $ try 'A' --config 'revsetalias.A=1^:2' | ||
|
r34075 | (symbol 'A') | ||
|
r29768 | * expanded: | ||
(range | ||||
(parentpost | ||||
|
r34075 | (symbol '1')) | ||
(symbol '2')) | ||||
|
r29768 | * set: | ||
|
r32817 | <spanset+ 0:3> | ||
|
r29768 | 0 | ||
1 | ||||
2 | ||||
|
r29769 | $ try 'A:2' --config 'revsetalias.A=1^' | ||
|
r29768 | (range | ||
|
r34075 | (symbol 'A') | ||
(symbol '2')) | ||||
|
r29768 | * expanded: | ||
(range | ||||
(parentpost | ||||
|
r34075 | (symbol '1')) | ||
(symbol '2')) | ||||
|
r29768 | * set: | ||
|
r32817 | <spanset+ 0:3> | ||
|
r29768 | 0 | ||
1 | ||||
2 | ||||
but not beyond the boundary of alias expansion, because the resolution should | ||||
be made at the parsing stage | ||||
|
r29769 | $ try '1^A' --config 'revsetalias.A=:2' | ||
|
r29768 | (parent | ||
|
r34075 | (symbol '1') | ||
(symbol 'A')) | ||||
|
r29768 | * expanded: | ||
(parent | ||||
|
r34075 | (symbol '1') | ||
|
r29768 | (rangepre | ||
|
r34075 | (symbol '2'))) | ||
|
r29769 | hg: parse error: ^ expects a number 0, 1, or 2 | ||
[255] | ||||
|
r29768 | |||
|
r18536 | ancestor can accept 0 or more arguments | ||
$ log 'ancestor()' | ||||
|
r12105 | $ log 'ancestor(1)' | ||
|
r18536 | 1 | ||
|
r12105 | $ log 'ancestor(4,5)' | ||
1 | ||||
$ log 'ancestor(4,5) and 4' | ||||
|
r18536 | $ log 'ancestor(0,0,1,3)' | ||
0 | ||||
$ log 'ancestor(3,1,5,3,5,1)' | ||||
1 | ||||
$ log 'ancestor(0,1,3,5)' | ||||
0 | ||||
$ log 'ancestor(1,2,3,4,5)' | ||||
1 | ||||
|
r24940 | |||
test ancestors | ||||
|
r33002 | $ hg log -G -T '{rev}\n' --config experimental.graphshorten=True | ||
@ 9 | ||||
o 8 | ||||
| o 7 | ||||
| o 6 | ||||
|/| | ||||
| o 5 | ||||
o | 4 | ||||
| o 3 | ||||
o | 2 | ||||
|/ | ||||
o 1 | ||||
o 0 | ||||
|
r12105 | $ log 'ancestors(5)' | ||
0 | ||||
1 | ||||
3 | ||||
5 | ||||
|
r18536 | $ log 'ancestor(ancestors(5))' | ||
0 | ||||
|
r24940 | $ log '::r3232()' | ||
0 | ||||
1 | ||||
2 | ||||
3 | ||||
|
r33002 | test ancestors with depth limit | ||
(depth=0 selects the node itself) | ||||
$ log 'reverse(ancestors(9, depth=0))' | ||||
9 | ||||
(interleaved: '4' would be missing if heap queue were higher depth first) | ||||
$ log 'reverse(ancestors(8:9, depth=1))' | ||||
9 | ||||
8 | ||||
4 | ||||
(interleaved: '2' would be missing if heap queue were higher depth first) | ||||
$ log 'reverse(ancestors(7+8, depth=2))' | ||||
8 | ||||
7 | ||||
6 | ||||
5 | ||||
4 | ||||
2 | ||||
(walk example above by separate queries) | ||||
$ log 'reverse(ancestors(8, depth=2)) + reverse(ancestors(7, depth=2))' | ||||
8 | ||||
4 | ||||
2 | ||||
7 | ||||
6 | ||||
5 | ||||
|
r33003 | (walk 2nd and 3rd ancestors) | ||
$ log 'reverse(ancestors(7, depth=3, startdepth=2))' | ||||
5 | ||||
4 | ||||
3 | ||||
2 | ||||
(interleaved: '4' would be missing if higher-depth ancestors weren't scanned) | ||||
$ log 'reverse(ancestors(7+8, depth=2, startdepth=2))' | ||||
5 | ||||
4 | ||||
2 | ||||
(note that 'ancestors(x, depth=y, startdepth=z)' does not identical to | ||||
'ancestors(x, depth=y) - ancestors(x, depth=z-1)' because a node may have | ||||
multiple depths) | ||||
$ log 'reverse(ancestors(7+8, depth=2) - ancestors(7+8, depth=1))' | ||||
5 | ||||
2 | ||||
|
r33002 | test bad arguments passed to ancestors() | ||
$ log 'ancestors(., depth=-1)' | ||||
hg: parse error: negative depth | ||||
[255] | ||||
$ log 'ancestors(., depth=foo)' | ||||
hg: parse error: ancestors expects an integer depth | ||||
[255] | ||||
|
r33074 | test descendants | ||
$ hg log -G -T '{rev}\n' --config experimental.graphshorten=True | ||||
@ 9 | ||||
o 8 | ||||
| o 7 | ||||
| o 6 | ||||
|/| | ||||
| o 5 | ||||
o | 4 | ||||
| o 3 | ||||
o | 2 | ||||
|/ | ||||
o 1 | ||||
o 0 | ||||
(null is ultimate root and has optimized path) | ||||
$ log 'null:4 & descendants(null)' | ||||
-1 | ||||
0 | ||||
1 | ||||
2 | ||||
3 | ||||
4 | ||||
(including merge) | ||||
$ log ':8 & descendants(2)' | ||||
2 | ||||
4 | ||||
6 | ||||
7 | ||||
8 | ||||
(multiple roots) | ||||
$ log ':8 & descendants(2+5)' | ||||
2 | ||||
4 | ||||
5 | ||||
6 | ||||
7 | ||||
8 | ||||
|
r33080 | test descendants with depth limit | ||
(depth=0 selects the node itself) | ||||
$ log 'descendants(0, depth=0)' | ||||
0 | ||||
$ log 'null: & descendants(null, depth=0)' | ||||
-1 | ||||
(p2 = null should be ignored) | ||||
$ log 'null: & descendants(null, depth=2)' | ||||
-1 | ||||
0 | ||||
1 | ||||
(multiple paths: depth(6) = (2, 3)) | ||||
$ log 'descendants(1+3, depth=2)' | ||||
1 | ||||
2 | ||||
3 | ||||
4 | ||||
5 | ||||
6 | ||||
(multiple paths: depth(5) = (1, 2), depth(6) = (2, 3)) | ||||
$ log 'descendants(3+1, depth=2, startdepth=2)' | ||||
4 | ||||
5 | ||||
6 | ||||
(multiple depths: depth(6) = (0, 2, 4), search for depth=2) | ||||
$ log 'descendants(0+3+6, depth=3, startdepth=1)' | ||||
1 | ||||
2 | ||||
3 | ||||
4 | ||||
5 | ||||
6 | ||||
7 | ||||
(multiple depths: depth(6) = (0, 4), no match) | ||||
$ log 'descendants(0+6, depth=3, startdepth=1)' | ||||
1 | ||||
2 | ||||
3 | ||||
4 | ||||
5 | ||||
7 | ||||
|
r33417 | test ancestors/descendants relation subscript: | ||
$ log 'tip#generations[0]' | ||||
9 | ||||
$ log '.#generations[-1]' | ||||
8 | ||||
$ log '.#g[(-1)]' | ||||
8 | ||||
$ hg debugrevspec -p parsed 'roots(:)#g[2]' | ||||
* parsed: | ||||
(relsubscript | ||||
(func | ||||
|
r34075 | (symbol 'roots') | ||
|
r33417 | (rangeall | ||
None)) | ||||
|
r34075 | (symbol 'g') | ||
(symbol '2')) | ||||
|
r33417 | 2 | ||
3 | ||||
|
r33002 | test author | ||
|
r12105 | $ log 'author(bob)' | ||
2 | ||||
|
r16823 | $ log 'author("re:bob|test")' | ||
0 | ||||
1 | ||||
2 | ||||
3 | ||||
4 | ||||
5 | ||||
6 | ||||
7 | ||||
8 | ||||
9 | ||||
|
r30782 | $ log 'author(r"re:\S")' | ||
0 | ||||
1 | ||||
2 | ||||
3 | ||||
4 | ||||
5 | ||||
6 | ||||
7 | ||||
8 | ||||
9 | ||||
|
r12105 | $ log 'branch(é)' | ||
8 | ||||
9 | ||||
|
r16821 | $ log 'branch(a)' | ||
0 | ||||
$ hg log -r 'branch("re:a")' --template '{rev} {branch}\n' | ||||
0 a | ||||
2 a-b-c- | ||||
3 +a+b+c+ | ||||
4 -a-b-c- | ||||
|
r16851 | 5 !a/b/c/ | ||
|
r16821 | 6 _a_b_c_ | ||
7 .a.b.c. | ||||
|
r12105 | $ log 'children(ancestor(4,5))' | ||
2 | ||||
3 | ||||
|
r30699 | |||
$ log 'children(4)' | ||||
6 | ||||
8 | ||||
$ log 'children(null)' | ||||
0 | ||||
|
r12105 | $ log 'closed()' | ||
$ log 'contains(a)' | ||||
0 | ||||
1 | ||||
3 | ||||
5 | ||||
|
r20286 | $ log 'contains("../repo/a")' | ||
0 | ||||
1 | ||||
3 | ||||
5 | ||||
|
r14650 | $ log 'desc(B)' | ||
5 | ||||
|
r30783 | $ hg log -r 'desc(r"re:S?u")' --template "{rev} {desc|firstline}\n" | ||
5 5 bug | ||||
6 6 issue619 | ||||
|
r12105 | $ log 'descendants(2 or 3)' | ||
2 | ||||
3 | ||||
4 | ||||
5 | ||||
6 | ||||
7 | ||||
8 | ||||
9 | ||||
|
r16411 | $ log 'file("b*")' | ||
|
r12105 | 1 | ||
4 | ||||
|
r20288 | $ log 'filelog("b")' | ||
1 | ||||
4 | ||||
$ log 'filelog("../repo/b")' | ||||
1 | ||||
4 | ||||
|
r12105 | $ log 'follow()' | ||
0 | ||||
1 | ||||
2 | ||||
4 | ||||
8 | ||||
9 | ||||
$ log 'grep("issue\d+")' | ||||
6 | ||||
|
r12321 | $ try 'grep("(")' # invalid regular expression | ||
|
r16218 | (func | ||
|
r34075 | (symbol 'grep') | ||
(string '(')) | ||||
|
r12321 | hg: parse error: invalid match pattern: unbalanced parenthesis | ||
[255] | ||||
|
r12408 | $ try 'grep("\bissue\d+")' | ||
|
r16218 | (func | ||
|
r34075 | (symbol 'grep') | ||
(string '\x08issue\\d+')) | ||||
|
r24458 | * set: | ||
<filteredset | ||||
|
r32817 | <fullreposet+ 0:10>, | ||
|
r28424 | <grep '\x08issue\\d+'>> | ||
|
r12408 | $ try 'grep(r"\bissue\d+")' | ||
|
r16218 | (func | ||
|
r34075 | (symbol 'grep') | ||
(string '\\bissue\\d+')) | ||||
|
r24458 | * set: | ||
<filteredset | ||||
|
r32817 | <fullreposet+ 0:10>, | ||
|
r28424 | <grep '\\bissue\\d+'>> | ||
|
r12408 | 6 | ||
$ try 'grep(r"\")' | ||||
hg: parse error at 7: unterminated string | ||||
[255] | ||||
|
r12105 | $ log 'head()' | ||
0 | ||||
1 | ||||
2 | ||||
3 | ||||
4 | ||||
5 | ||||
6 | ||||
7 | ||||
9 | ||||
$ log 'heads(6::)' | ||||
7 | ||||
$ log 'keyword(issue)' | ||||
6 | ||||
|
r19706 | $ log 'keyword("test a")' | ||
|
r32797 | |||
Test first (=limit) and last | ||||
|
r12105 | $ log 'limit(head(), 1)' | ||
0 | ||||
|
r26638 | $ log 'limit(author("re:bob|test"), 3, 5)' | ||
5 | ||||
6 | ||||
7 | ||||
$ log 'limit(author("re:bob|test"), offset=6)' | ||||
6 | ||||
$ log 'limit(author("re:bob|test"), offset=10)' | ||||
$ log 'limit(all(), 1, -1)' | ||||
hg: parse error: negative offset | ||||
[255] | ||||
|
r32798 | $ log 'limit(all(), -1)' | ||
hg: parse error: negative number to select | ||||
[255] | ||||
$ log 'limit(all(), 0)' | ||||
$ log 'last(all(), -1)' | ||||
hg: parse error: negative number to select | ||||
[255] | ||||
|
r32797 | $ log 'last(all(), 0)' | ||
$ log 'last(all(), 1)' | ||||
9 | ||||
$ log 'last(all(), 2)' | ||||
8 | ||||
9 | ||||
|
r32819 | Test smartset.slice() by first/last() | ||
(using unoptimized set, filteredset as example) | ||||
$ hg debugrevspec --no-show-revs -s '0:7 & branch("re:")' | ||||
* set: | ||||
<filteredset | ||||
<spanset+ 0:8>, | ||||
<branch 're:'>> | ||||
$ log 'limit(0:7 & branch("re:"), 3, 4)' | ||||
4 | ||||
5 | ||||
6 | ||||
$ log 'limit(7:0 & branch("re:"), 3, 4)' | ||||
3 | ||||
2 | ||||
1 | ||||
$ log 'last(0:7 & branch("re:"), 2)' | ||||
6 | ||||
7 | ||||
|
r32820 | (using baseset) | ||
$ hg debugrevspec --no-show-revs -s 0+1+2+3+4+5+6+7 | ||||
* set: | ||||
<baseset [0, 1, 2, 3, 4, 5, 6, 7]> | ||||
$ hg debugrevspec --no-show-revs -s 0::7 | ||||
* set: | ||||
<baseset+ [0, 1, 2, 3, 4, 5, 6, 7]> | ||||
$ log 'limit(0+1+2+3+4+5+6+7, 3, 4)' | ||||
4 | ||||
5 | ||||
6 | ||||
$ log 'limit(sort(0::7, rev), 3, 4)' | ||||
4 | ||||
5 | ||||
6 | ||||
$ log 'limit(sort(0::7, -rev), 3, 4)' | ||||
3 | ||||
2 | ||||
1 | ||||
$ log 'last(sort(0::7, rev), 2)' | ||||
6 | ||||
7 | ||||
$ hg debugrevspec -s 'limit(sort(0::7, rev), 3, 6)' | ||||
* set: | ||||
<baseset+ [6, 7]> | ||||
6 | ||||
7 | ||||
$ hg debugrevspec -s 'limit(sort(0::7, rev), 3, 9)' | ||||
* set: | ||||
<baseset+ []> | ||||
$ hg debugrevspec -s 'limit(sort(0::7, -rev), 3, 6)' | ||||
* set: | ||||
<baseset- [0, 1]> | ||||
1 | ||||
0 | ||||
$ hg debugrevspec -s 'limit(sort(0::7, -rev), 3, 9)' | ||||
* set: | ||||
<baseset- []> | ||||
$ hg debugrevspec -s 'limit(0::7, 0)' | ||||
* set: | ||||
<baseset+ []> | ||||
|
r32821 | (using spanset) | ||
$ hg debugrevspec --no-show-revs -s 0:7 | ||||
* set: | ||||
<spanset+ 0:8> | ||||
$ log 'limit(0:7, 3, 4)' | ||||
4 | ||||
5 | ||||
6 | ||||
$ log 'limit(7:0, 3, 4)' | ||||
3 | ||||
2 | ||||
1 | ||||
$ log 'limit(0:7, 3, 6)' | ||||
6 | ||||
7 | ||||
$ log 'limit(7:0, 3, 6)' | ||||
1 | ||||
0 | ||||
$ log 'last(0:7, 2)' | ||||
6 | ||||
7 | ||||
$ hg debugrevspec -s 'limit(0:7, 3, 6)' | ||||
* set: | ||||
<spanset+ 6:8> | ||||
6 | ||||
7 | ||||
$ hg debugrevspec -s 'limit(0:7, 3, 9)' | ||||
* set: | ||||
<spanset+ 8:8> | ||||
$ hg debugrevspec -s 'limit(7:0, 3, 6)' | ||||
* set: | ||||
<spanset- 0:2> | ||||
1 | ||||
0 | ||||
$ hg debugrevspec -s 'limit(7:0, 3, 9)' | ||||
* set: | ||||
<spanset- 0:0> | ||||
$ hg debugrevspec -s 'limit(0:7, 0)' | ||||
* set: | ||||
<spanset+ 0:0> | ||||
|
r32799 | Test order of first/last revisions | ||
$ hg debugrevspec -s 'first(4:0, 3) & 3:' | ||||
* set: | ||||
<filteredset | ||||
|
r32821 | <spanset- 2:5>, | ||
|
r32817 | <spanset+ 3:10>> | ||
|
r32799 | 4 | ||
3 | ||||
$ hg debugrevspec -s '3: & first(4:0, 3)' | ||||
* set: | ||||
<filteredset | ||||
|
r32817 | <spanset+ 3:10>, | ||
|
r32821 | <spanset- 2:5>> | ||
|
r32800 | 3 | ||
|
r32799 | 4 | ||
$ hg debugrevspec -s 'last(4:0, 3) & :1' | ||||
* set: | ||||
<filteredset | ||||
|
r32821 | <spanset- 0:3>, | ||
|
r32817 | <spanset+ 0:2>> | ||
|
r32799 | 1 | ||
0 | ||||
$ hg debugrevspec -s ':1 & last(4:0, 3)' | ||||
* set: | ||||
<filteredset | ||||
|
r32817 | <spanset+ 0:2>, | ||
|
r32821 | <spanset+ 0:3>> | ||
|
r32800 | 0 | ||
|
r32799 | 1 | ||
|
r33109 | Test scmutil.revsingle() should return the last revision | ||
$ hg debugrevspec -s 'last(0::)' | ||||
* set: | ||||
<baseset slice=0:1 | ||||
|
r35517 | <generatorsetasc->> | ||
|
r33109 | 9 | ||
$ hg identify -r '0::' --num | ||||
9 | ||||
|
r32797 | Test matching | ||
|
r16447 | $ log 'matching(6)' | ||
6 | ||||
$ log 'matching(6:7, "phase parents user date branch summary files description substate")' | ||||
6 | ||||
7 | ||||
|
r20863 | |||
Testing min and max | ||||
max: simple | ||||
|
r12105 | $ log 'max(contains(a))' | ||
5 | ||||
|
r20863 | |||
max: simple on unordered set) | ||||
$ log 'max((4+0+2+5+7) and contains(a))' | ||||
5 | ||||
max: no result | ||||
$ log 'max(contains(stringthatdoesnotappearanywhere))' | ||||
max: no result on unordered set | ||||
$ log 'max((4+0+2+5+7) and contains(stringthatdoesnotappearanywhere))' | ||||
min: simple | ||||
|
r12105 | $ log 'min(contains(a))' | ||
0 | ||||
|
r20863 | |||
min: simple on unordered set | ||||
$ log 'min((4+0+2+5+7) and contains(a))' | ||||
0 | ||||
min: empty | ||||
$ log 'min(contains(stringthatdoesnotappearanywhere))' | ||||
min: empty on unordered set | ||||
$ log 'min((4+0+2+5+7) and contains(stringthatdoesnotappearanywhere))' | ||||
|
r12105 | $ log 'merge()' | ||
6 | ||||
|
r17753 | $ log 'branchpoint()' | ||
1 | ||||
4 | ||||
|
r12105 | $ log 'modifies(b)' | ||
4 | ||||
|
r16521 | $ log 'modifies("path:b")' | ||
4 | ||||
$ log 'modifies("*")' | ||||
4 | ||||
6 | ||||
$ log 'modifies("set:modified()")' | ||||
4 | ||||
|
r12716 | $ log 'id(5)' | ||
2 | ||||
|
r20613 | $ log 'only(9)' | ||
8 | ||||
9 | ||||
$ log 'only(8)' | ||||
8 | ||||
$ log 'only(9, 5)' | ||||
2 | ||||
4 | ||||
8 | ||||
9 | ||||
$ log 'only(7 + 9, 5 + 2)' | ||||
4 | ||||
6 | ||||
7 | ||||
8 | ||||
9 | ||||
|
r21925 | |||
Test empty set input | ||||
$ log 'only(p2())' | ||||
$ log 'only(p1(), p2())' | ||||
0 | ||||
1 | ||||
2 | ||||
4 | ||||
8 | ||||
9 | ||||
|
r23062 | |||
|
r23765 | Test '%' operator | ||
$ log '9%' | ||||
8 | ||||
9 | ||||
$ log '9%5' | ||||
2 | ||||
4 | ||||
8 | ||||
9 | ||||
$ log '(7 + 9)%(5 + 2)' | ||||
4 | ||||
6 | ||||
7 | ||||
8 | ||||
9 | ||||
|
r30332 | Test operand of '%' is optimized recursively (issue4670) | ||
|
r25094 | |||
$ try --optimize '8:9-8%' | ||||
(onlypost | ||||
(minus | ||||
(range | ||||
|
r34075 | (symbol '8') | ||
(symbol '9')) | ||||
(symbol '8'))) | ||||
|
r25094 | * optimized: | ||
(func | ||||
|
r34075 | (symbol 'only') | ||
|
r28217 | (difference | ||
|
r25094 | (range | ||
|
r34075 | (symbol '8') | ||
(symbol '9')) | ||||
(symbol '8'))) | ||||
|
r25094 | * set: | ||
<baseset+ [8, 9]> | ||||
8 | ||||
9 | ||||
|
r25105 | $ try --optimize '(9)%(5)' | ||
(only | ||||
(group | ||||
|
r34075 | (symbol '9')) | ||
|
r25105 | (group | ||
|
r34075 | (symbol '5'))) | ||
|
r25105 | * optimized: | ||
(func | ||||
|
r34075 | (symbol 'only') | ||
|
r25105 | (list | ||
|
r34075 | (symbol '9') | ||
(symbol '5'))) | ||||
|
r25105 | * set: | ||
|
r28785 | <baseset+ [2, 4, 8, 9]> | ||
|
r25105 | 2 | ||
4 | ||||
8 | ||||
9 | ||||
|
r25094 | |||
|
r23765 | Test the order of operations | ||
$ log '7 + 9%5 + 2' | ||||
7 | ||||
2 | ||||
4 | ||||
8 | ||||
9 | ||||
|
r23062 | Test explicit numeric revision | ||
|
r23954 | $ log 'rev(-2)' | ||
|
r23062 | $ log 'rev(-1)' | ||
|
r23954 | -1 | ||
|
r23062 | $ log 'rev(0)' | ||
0 | ||||
$ log 'rev(9)' | ||||
9 | ||||
$ log 'rev(10)' | ||||
$ log 'rev(tip)' | ||||
hg: parse error: rev expects a number | ||||
[255] | ||||
|
r24904 | Test hexadecimal revision | ||
$ log 'id(2)' | ||||
abort: 00changelog.i@2: ambiguous identifier! | ||||
[255] | ||||
$ log 'id(23268)' | ||||
4 | ||||
$ log 'id(2785f51eece)' | ||||
0 | ||||
$ log 'id(d5d0dcbdc4d9ff5dbb2d336f32f0bb561c1a532c)' | ||||
8 | ||||
$ log 'id(d5d0dcbdc4a)' | ||||
$ log 'id(d5d0dcbdc4w)' | ||||
$ log 'id(d5d0dcbdc4d9ff5dbb2d336f32f0bb561c1a532d)' | ||||
$ log 'id(d5d0dcbdc4d9ff5dbb2d336f32f0bb561c1a532q)' | ||||
$ log 'id(1.0)' | ||||
$ log 'id(xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx)' | ||||
|
r23956 | Test null revision | ||
|
r24204 | $ log '(null)' | ||
-1 | ||||
$ log '(null:0)' | ||||
-1 | ||||
0 | ||||
$ log '(0:null)' | ||||
0 | ||||
-1 | ||||
$ log 'null::0' | ||||
-1 | ||||
0 | ||||
$ log 'null:tip - 0:' | ||||
-1 | ||||
$ log 'null: and null::' | head -1 | ||||
-1 | ||||
$ log 'null: or 0:' | head -2 | ||||
-1 | ||||
0 | ||||
|
r23956 | $ log 'ancestors(null)' | ||
-1 | ||||
|
r24204 | $ log 'reverse(null:)' | tail -2 | ||
0 | ||||
-1 | ||||
|
r32799 | $ log 'first(null:)' | ||
-1 | ||||
$ log 'min(null:)' | ||||
|
r25265 | BROKEN: should be '-1' | ||
|
r24202 | $ log 'tip:null and all()' | tail -2 | ||
1 | ||||
0 | ||||
|
r23956 | |||
|
r24419 | Test working-directory revision | ||
$ hg debugrevspec 'wdir()' | ||||
|
r25765 | 2147483647 | ||
|
r32403 | $ hg debugrevspec 'wdir()^' | ||
9 | ||||
$ hg up 7 | ||||
0 files updated, 0 files merged, 1 files removed, 0 files unresolved | ||||
$ hg debugrevspec 'wdir()^' | ||||
7 | ||||
|
r32437 | $ hg debugrevspec 'wdir()^0' | ||
2147483647 | ||||
|
r32441 | $ hg debugrevspec 'wdir()~3' | ||
5 | ||||
|
r32442 | $ hg debugrevspec 'ancestors(wdir())' | ||
0 | ||||
1 | ||||
2 | ||||
3 | ||||
4 | ||||
5 | ||||
6 | ||||
7 | ||||
2147483647 | ||||
|
r32437 | $ hg debugrevspec 'wdir()~0' | ||
2147483647 | ||||
$ hg debugrevspec 'p1(wdir())' | ||||
7 | ||||
|
r32440 | $ hg debugrevspec 'p2(wdir())' | ||
|
r32437 | $ hg debugrevspec 'parents(wdir())' | ||
7 | ||||
|
r32436 | $ hg debugrevspec 'wdir()^1' | ||
7 | ||||
$ hg debugrevspec 'wdir()^2' | ||||
$ hg debugrevspec 'wdir()^3' | ||||
hg: parse error: ^ expects a number 0, 1, or 2 | ||||
[255] | ||||
|
r32403 | For tests consistency | ||
$ hg up 9 | ||||
1 files updated, 0 files merged, 0 files removed, 0 files unresolved | ||||
|
r24419 | $ hg debugrevspec 'tip or wdir()' | ||
9 | ||||
|
r25765 | 2147483647 | ||
|
r24419 | $ hg debugrevspec '0:tip and wdir()' | ||
|
r25766 | $ log '0:wdir()' | tail -3 | ||
8 | ||||
9 | ||||
2147483647 | ||||
$ log 'wdir():0' | head -3 | ||||
2147483647 | ||||
9 | ||||
8 | ||||
$ log 'wdir():wdir()' | ||||
2147483647 | ||||
|
r25765 | $ log '(all() + wdir()) & min(. + wdir())' | ||
9 | ||||
$ log '(all() + wdir()) & max(. + wdir())' | ||||
2147483647 | ||||
|
r32799 | $ log 'first(wdir() + .)' | ||
|
r25765 | 2147483647 | ||
|
r32799 | $ log 'last(. + wdir())' | ||
|
r25765 | 2147483647 | ||
|
r24419 | |||
|
r32659 | Test working-directory integer revision and node id | ||
(BUG: '0:wdir()' is still needed to populate wdir revision) | ||||
$ hg debugrevspec '0:wdir() & 2147483647' | ||||
2147483647 | ||||
$ hg debugrevspec '0:wdir() & rev(2147483647)' | ||||
2147483647 | ||||
$ hg debugrevspec '0:wdir() & ffffffffffffffffffffffffffffffffffffffff' | ||||
2147483647 | ||||
|
r32684 | $ hg debugrevspec '0:wdir() & ffffffffffff' | ||
2147483647 | ||||
|
r32659 | $ hg debugrevspec '0:wdir() & id(ffffffffffffffffffffffffffffffffffffffff)' | ||
2147483647 | ||||
$ hg debugrevspec '0:wdir() & id(ffffffffffff)' | ||||
|
r32684 | 2147483647 | ||
$ cd .. | ||||
Test short 'ff...' hash collision | ||||
(BUG: '0:wdir()' is still needed to populate wdir revision) | ||||
$ hg init wdir-hashcollision | ||||
$ cd wdir-hashcollision | ||||
$ cat <<EOF >> .hg/hgrc | ||||
> [experimental] | ||||
|
r34867 | > evolution.createmarkers=True | ||
|
r32684 | > EOF | ||
$ echo 0 > a | ||||
$ hg ci -qAm 0 | ||||
$ for i in 2463 2961 6726 78127; do | ||||
> hg up -q 0 | ||||
> echo $i > a | ||||
> hg ci -qm $i | ||||
> done | ||||
$ hg up -q null | ||||
$ hg log -r '0:wdir()' -T '{rev}:{node} {shortest(node, 3)}\n' | ||||
0:b4e73ffab476aa0ee32ed81ca51e07169844bc6a b4e | ||||
1:fffbae3886c8fbb2114296380d276fd37715d571 fffba | ||||
2:fffb6093b00943f91034b9bdad069402c834e572 fffb6 | ||||
3:fff48a9b9de34a4d64120c29548214c67980ade3 fff4 | ||||
4:ffff85cff0ff78504fcdc3c0bc10de0c65379249 ffff8 | ||||
2147483647:ffffffffffffffffffffffffffffffffffffffff fffff | ||||
$ hg debugobsolete fffbae3886c8fbb2114296380d276fd37715d571 | ||||
|
r33542 | obsoleted 1 changesets | ||
|
r32684 | |||
$ hg debugrevspec '0:wdir() & fff' | ||||
abort: 00changelog.i@fff: ambiguous identifier! | ||||
[255] | ||||
$ hg debugrevspec '0:wdir() & ffff' | ||||
abort: 00changelog.i@ffff: ambiguous identifier! | ||||
[255] | ||||
$ hg debugrevspec '0:wdir() & fffb' | ||||
abort: 00changelog.i@fffb: ambiguous identifier! | ||||
[255] | ||||
BROKEN should be '2' (node lookup uses unfiltered repo since dc25ed84bee8) | ||||
$ hg debugrevspec '0:wdir() & id(fffb)' | ||||
2 | ||||
$ hg debugrevspec '0:wdir() & ffff8' | ||||
4 | ||||
$ hg debugrevspec '0:wdir() & fffff' | ||||
2147483647 | ||||
$ cd .. | ||||
|
r32659 | |||
|
r32683 | Test branch() with wdir() | ||
|
r32684 | $ cd repo | ||
|
r32683 | $ log '0:wdir() & branch("literal:é")' | ||
8 | ||||
9 | ||||
2147483647 | ||||
$ log '0:wdir() & branch("re:é")' | ||||
8 | ||||
9 | ||||
2147483647 | ||||
$ log '0:wdir() & branch("re:^a")' | ||||
0 | ||||
2 | ||||
$ log '0:wdir() & branch(8)' | ||||
8 | ||||
9 | ||||
2147483647 | ||||
branch(wdir()) returns all revisions belonging to the working branch. The wdir | ||||
itself isn't returned unless it is explicitly populated. | ||||
$ log 'branch(wdir())' | ||||
8 | ||||
9 | ||||
$ log '0:wdir() & branch(wdir())' | ||||
8 | ||||
9 | ||||
2147483647 | ||||
|
r12105 | $ log 'outgoing()' | ||
8 | ||||
9 | ||||
$ log 'outgoing("../remote1")' | ||||
8 | ||||
9 | ||||
$ log 'outgoing("../remote2")' | ||||
3 | ||||
5 | ||||
6 | ||||
7 | ||||
9 | ||||
$ log 'p1(merge())' | ||||
5 | ||||
$ log 'p2(merge())' | ||||
4 | ||||
$ log 'parents(merge())' | ||||
4 | ||||
5 | ||||
|
r17753 | $ log 'p1(branchpoint())' | ||
0 | ||||
2 | ||||
$ log 'p2(branchpoint())' | ||||
$ log 'parents(branchpoint())' | ||||
0 | ||||
2 | ||||
|
r12105 | $ log 'removes(a)' | ||
2 | ||||
6 | ||||
$ log 'roots(all())' | ||||
0 | ||||
$ log 'reverse(2 or 3 or 4 or 5)' | ||||
5 | ||||
4 | ||||
3 | ||||
2 | ||||
|
r17100 | $ log 'reverse(all())' | ||
9 | ||||
8 | ||||
7 | ||||
6 | ||||
5 | ||||
4 | ||||
3 | ||||
2 | ||||
1 | ||||
0 | ||||
|
r23826 | $ log 'reverse(all()) & filelog(b)' | ||
4 | ||||
1 | ||||
|
r12716 | $ log 'rev(5)' | ||
5 | ||||
|
r12105 | $ log 'sort(limit(reverse(all()), 3))' | ||
7 | ||||
8 | ||||
9 | ||||
$ log 'sort(2 or 3 or 4 or 5, date)' | ||||
2 | ||||
3 | ||||
5 | ||||
4 | ||||
$ log 'tagged()' | ||||
6 | ||||
|
r12715 | $ log 'tag()' | ||
6 | ||||
$ log 'tag(1.0)' | ||||
6 | ||||
$ log 'tag(tip)' | ||||
9 | ||||
|
r16820 | |||
|
r29139 | Test order of revisions in compound expression | ||
---------------------------------------------- | ||||
|
r29390 | The general rule is that only the outermost (= leftmost) predicate can | ||
enforce its ordering requirement. The other predicates should take the | ||||
ordering defined by it. | ||||
|
r29139 | 'A & B' should follow the order of 'A': | ||
$ log '2:0 & 0::2' | ||||
2 | ||||
1 | ||||
0 | ||||
|
r29408 | 'head()' combines sets in right order: | ||
|
r29390 | |||
$ log '2:0 & head()' | ||||
|
r29408 | 2 | ||
|
r29390 | 1 | ||
|
r29408 | 0 | ||
|
r29390 | |||
|
r29944 | 'x:y' takes ordering parameter into account: | ||
$ try -p optimized '3:0 & 0:3 & not 2:1' | ||||
* optimized: | ||||
(difference | ||||
(and | ||||
(range | ||||
|
r34075 | (symbol '3') | ||
(symbol '0')) | ||||
|
r29944 | (range | ||
|
r34075 | (symbol '0') | ||
(symbol '3'))) | ||||
|
r29944 | (range | ||
|
r34075 | (symbol '2') | ||
(symbol '1'))) | ||||
|
r29944 | * set: | ||
<filteredset | ||||
<filteredset | ||||
|
r32817 | <spanset- 0:4>, | ||
<spanset+ 0:4>>, | ||||
|
r29944 | <not | ||
|
r32817 | <spanset+ 1:3>>> | ||
|
r29944 | 3 | ||
0 | ||||
|
r29390 | 'a + b', which is optimized to '_list(a b)', should take the ordering of | ||
the left expression: | ||||
$ try --optimize '2:0 & (0 + 1 + 2)' | ||||
(and | ||||
(range | ||||
|
r34075 | (symbol '2') | ||
(symbol '0')) | ||||
|
r29390 | (group | ||
(or | ||||
|
r29929 | (list | ||
|
r34075 | (symbol '0') | ||
(symbol '1') | ||||
(symbol '2'))))) | ||||
|
r29390 | * optimized: | ||
(and | ||||
(range | ||||
|
r34075 | (symbol '2') | ||
(symbol '0')) | ||||
|
r29390 | (func | ||
|
r34075 | (symbol '_list') | ||
(string '0\x001\x002'))) | ||||
|
r29390 | * set: | ||
|
r29935 | <filteredset | ||
|
r32817 | <spanset- 0:3>, | ||
|
r29935 | <baseset [0, 1, 2]>> | ||
2 | ||||
|
r29390 | 1 | ||
|
r29935 | 0 | ||
|
r29390 | |||
'A + B' should take the ordering of the left expression: | ||||
$ try --optimize '2:0 & (0:1 + 2)' | ||||
(and | ||||
(range | ||||
|
r34075 | (symbol '2') | ||
(symbol '0')) | ||||
|
r29390 | (group | ||
(or | ||||
|
r29929 | (list | ||
(range | ||||
|
r34075 | (symbol '0') | ||
(symbol '1')) | ||||
(symbol '2'))))) | ||||
|
r29390 | * optimized: | ||
(and | ||||
(range | ||||
|
r34075 | (symbol '2') | ||
(symbol '0')) | ||||
|
r29390 | (or | ||
|
r29929 | (list | ||
(range | ||||
|
r34075 | (symbol '0') | ||
(symbol '1')) | ||||
(symbol '2')))) | ||||
|
r29390 | * set: | ||
|
r29934 | <filteredset | ||
|
r32817 | <spanset- 0:3>, | ||
|
r29934 | <addset | ||
|
r34012 | <spanset+ 0:2>, | ||
<baseset [2]>>> | ||||
|
r29934 | 2 | ||
1 | ||||
|
r29390 | 0 | ||
'_intlist(a b)' should behave like 'a + b': | ||||
$ trylist --optimize '2:0 & %ld' 0 1 2 | ||||
(and | ||||
(range | ||||
|
r34075 | (symbol '2') | ||
(symbol '0')) | ||||
|
r29390 | (func | ||
|
r34075 | (symbol '_intlist') | ||
(string '0\x001\x002'))) | ||||
|
r29390 | * optimized: | ||
|
r34022 | (andsmally | ||
(range | ||||
|
r34075 | (symbol '2') | ||
(symbol '0')) | ||||
|
r29390 | (func | ||
|
r34075 | (symbol '_intlist') | ||
(string '0\x001\x002'))) | ||||
|
r29390 | * set: | ||
<filteredset | ||||
|
r32817 | <spanset- 0:3>, | ||
|
r29935 | <baseset+ [0, 1, 2]>> | ||
|
r29390 | 2 | ||
1 | ||||
0 | ||||
$ trylist --optimize '%ld & 2:0' 0 2 1 | ||||
(and | ||||
(func | ||||
|
r34075 | (symbol '_intlist') | ||
(string '0\x002\x001')) | ||||
|
r29390 | (range | ||
|
r34075 | (symbol '2') | ||
(symbol '0'))) | ||||
|
r29390 | * optimized: | ||
(and | ||||
(func | ||||
|
r34075 | (symbol '_intlist') | ||
(string '0\x002\x001')) | ||||
|
r29390 | (range | ||
|
r34075 | (symbol '2') | ||
(symbol '0'))) | ||||
|
r29390 | * set: | ||
<filteredset | ||||
|
r29944 | <baseset [0, 2, 1]>, | ||
|
r32817 | <spanset- 0:3>> | ||
|
r29944 | 0 | ||
|
r29390 | 2 | ||
1 | ||||
'_hexlist(a b)' should behave like 'a + b': | ||||
$ trylist --optimize --bin '2:0 & %ln' `hg log -T '{node} ' -r0:2` | ||||
(and | ||||
(range | ||||
|
r34075 | (symbol '2') | ||
(symbol '0')) | ||||
|
r29390 | (func | ||
|
r34075 | (symbol '_hexlist') | ||
(string '*'))) (glob) | ||||
|
r29390 | * optimized: | ||
(and | ||||
(range | ||||
|
r34075 | (symbol '2') | ||
(symbol '0')) | ||||
|
r29390 | (func | ||
|
r34075 | (symbol '_hexlist') | ||
(string '*'))) (glob) | ||||
|
r29390 | * set: | ||
|
r29935 | <filteredset | ||
|
r32817 | <spanset- 0:3>, | ||
|
r29935 | <baseset [0, 1, 2]>> | ||
2 | ||||
|
r29390 | 1 | ||
|
r29935 | 0 | ||
|
r29390 | |||
$ trylist --optimize --bin '%ln & 2:0' `hg log -T '{node} ' -r0+2+1` | ||||
(and | ||||
(func | ||||
|
r34075 | (symbol '_hexlist') | ||
(string '*')) (glob) | ||||
|
r29390 | (range | ||
|
r34075 | (symbol '2') | ||
(symbol '0'))) | ||||
|
r29390 | * optimized: | ||
|
r34022 | (andsmally | ||
(func | ||||
|
r34075 | (symbol '_hexlist') | ||
(string '*')) (glob) | ||||
|
r29390 | (range | ||
|
r34075 | (symbol '2') | ||
(symbol '0'))) | ||||
|
r29390 | * set: | ||
<baseset [0, 2, 1]> | ||||
0 | ||||
2 | ||||
1 | ||||
|
r29935 | '_list' should not go through the slow follow-order path if order doesn't | ||
matter: | ||||
$ try -p optimized '2:0 & not (0 + 1)' | ||||
* optimized: | ||||
(difference | ||||
(range | ||||
|
r34075 | (symbol '2') | ||
(symbol '0')) | ||||
|
r29935 | (func | ||
|
r34075 | (symbol '_list') | ||
(string '0\x001'))) | ||||
|
r29935 | * set: | ||
<filteredset | ||||
|
r32817 | <spanset- 0:3>, | ||
|
r29935 | <not | ||
<baseset [0, 1]>>> | ||||
2 | ||||
$ try -p optimized '2:0 & not (0:2 & (0 + 1))' | ||||
* optimized: | ||||
(difference | ||||
(range | ||||
|
r34075 | (symbol '2') | ||
(symbol '0')) | ||||
|
r29935 | (and | ||
(range | ||||
|
r34075 | (symbol '0') | ||
(symbol '2')) | ||||
|
r29935 | (func | ||
|
r34075 | (symbol '_list') | ||
(string '0\x001')))) | ||||
|
r29935 | * set: | ||
<filteredset | ||||
|
r32817 | <spanset- 0:3>, | ||
|
r29935 | <not | ||
<baseset [0, 1]>>> | ||||
2 | ||||
|
r29943 | because 'present()' does nothing other than suppressing an error, the | ||
ordering requirement should be forwarded to the nested expression | ||||
$ try -p optimized 'present(2 + 0 + 1)' | ||||
* optimized: | ||||
(func | ||||
|
r34075 | (symbol 'present') | ||
|
r29943 | (func | ||
|
r34075 | (symbol '_list') | ||
(string '2\x000\x001'))) | ||||
|
r29943 | * set: | ||
<baseset [2, 0, 1]> | ||||
2 | ||||
0 | ||||
1 | ||||
|
r29390 | |||
$ try --optimize '2:0 & present(0 + 1 + 2)' | ||||
(and | ||||
(range | ||||
|
r34075 | (symbol '2') | ||
(symbol '0')) | ||||
|
r29390 | (func | ||
|
r34075 | (symbol 'present') | ||
|
r29390 | (or | ||
|
r29929 | (list | ||
|
r34075 | (symbol '0') | ||
(symbol '1') | ||||
(symbol '2'))))) | ||||
|
r29390 | * optimized: | ||
(and | ||||
(range | ||||
|
r34075 | (symbol '2') | ||
(symbol '0')) | ||||
|
r29390 | (func | ||
|
r34075 | (symbol 'present') | ||
|
r29390 | (func | ||
|
r34075 | (symbol '_list') | ||
(string '0\x001\x002')))) | ||||
|
r29390 | * set: | ||
|
r29943 | <filteredset | ||
|
r32817 | <spanset- 0:3>, | ||
|
r29943 | <baseset [0, 1, 2]>> | ||
2 | ||||
|
r29390 | 1 | ||
|
r29943 | 0 | ||
|
r29390 | |||
'reverse()' should take effect only if it is the outermost expression: | ||||
$ try --optimize '0:2 & reverse(all())' | ||||
(and | ||||
(range | ||||
|
r34075 | (symbol '0') | ||
(symbol '2')) | ||||
|
r29390 | (func | ||
|
r34075 | (symbol 'reverse') | ||
|
r29390 | (func | ||
|
r34075 | (symbol 'all') | ||
|
r29390 | None))) | ||
* optimized: | ||||
(and | ||||
(range | ||||
|
r34075 | (symbol '0') | ||
(symbol '2')) | ||||
|
r29390 | (func | ||
|
r34075 | (symbol 'reverse') | ||
|
r29390 | (func | ||
|
r34075 | (symbol 'all') | ||
|
r34013 | None))) | ||
|
r29390 | * set: | ||
<filteredset | ||||
|
r32817 | <spanset+ 0:3>, | ||
<spanset+ 0:10>> | ||||
|
r29945 | 0 | ||
1 | ||||
|
r29390 | 2 | ||
'sort()' should take effect only if it is the outermost expression: | ||||
$ try --optimize '0:2 & sort(all(), -rev)' | ||||
(and | ||||
(range | ||||
|
r34075 | (symbol '0') | ||
(symbol '2')) | ||||
|
r29390 | (func | ||
|
r34075 | (symbol 'sort') | ||
|
r29390 | (list | ||
(func | ||||
|
r34075 | (symbol 'all') | ||
|
r29390 | None) | ||
(negate | ||||
|
r34075 | (symbol 'rev'))))) | ||
|
r29390 | * optimized: | ||
(and | ||||
(range | ||||
|
r34075 | (symbol '0') | ||
(symbol '2')) | ||||
|
r29390 | (func | ||
|
r34075 | (symbol 'sort') | ||
|
r29390 | (list | ||
(func | ||||
|
r34075 | (symbol 'all') | ||
|
r34013 | None) | ||
|
r34075 | (string '-rev')))) | ||
|
r29390 | * set: | ||
<filteredset | ||||
|
r32817 | <spanset+ 0:3>, | ||
<spanset+ 0:10>> | ||||
|
r29946 | 0 | ||
1 | ||||
|
r29390 | 2 | ||
|
r29946 | |||
invalid argument passed to noop sort(): | ||||
$ log '0:2 & sort()' | ||||
hg: parse error: sort requires one or two arguments | ||||
[255] | ||||
$ log '0:2 & sort(all(), -invalid)' | ||||
hg: parse error: unknown sort key '-invalid' | ||||
[255] | ||||
|
r29390 | |||
for 'A & f(B)', 'B' should not be affected by the order of 'A': | ||||
$ try --optimize '2:0 & first(1 + 0 + 2)' | ||||
(and | ||||
(range | ||||
|
r34075 | (symbol '2') | ||
(symbol '0')) | ||||
|
r29390 | (func | ||
|
r34075 | (symbol 'first') | ||
|
r29390 | (or | ||
|
r29929 | (list | ||
|
r34075 | (symbol '1') | ||
(symbol '0') | ||||
(symbol '2'))))) | ||||
|
r29390 | * optimized: | ||
(and | ||||
(range | ||||
|
r34075 | (symbol '2') | ||
(symbol '0')) | ||||
|
r29390 | (func | ||
|
r34075 | (symbol 'first') | ||
|
r29390 | (func | ||
|
r34075 | (symbol '_list') | ||
(string '1\x000\x002')))) | ||||
|
r29390 | * set: | ||
|
r32799 | <filteredset | ||
|
r32820 | <baseset [1]>, | ||
|
r32817 | <spanset- 0:3>> | ||
|
r29390 | 1 | ||
$ try --optimize '2:0 & not last(0 + 2 + 1)' | ||||
(and | ||||
(range | ||||
|
r34075 | (symbol '2') | ||
(symbol '0')) | ||||
|
r29390 | (not | ||
(func | ||||
|
r34075 | (symbol 'last') | ||
|
r29390 | (or | ||
|
r29929 | (list | ||
|
r34075 | (symbol '0') | ||
(symbol '2') | ||||
(symbol '1')))))) | ||||
|
r29390 | * optimized: | ||
(difference | ||||
(range | ||||
|
r34075 | (symbol '2') | ||
(symbol '0')) | ||||
|
r29390 | (func | ||
|
r34075 | (symbol 'last') | ||
|
r29390 | (func | ||
|
r34075 | (symbol '_list') | ||
(string '0\x002\x001')))) | ||||
|
r29390 | * set: | ||
<filteredset | ||||
|
r32817 | <spanset- 0:3>, | ||
|
r29390 | <not | ||
|
r32820 | <baseset [1]>>> | ||
|
r29390 | 2 | ||
0 | ||||
for 'A & (op)(B)', 'B' should not be affected by the order of 'A': | ||||
$ try --optimize '2:0 & (1 + 0 + 2):(0 + 2 + 1)' | ||||
(and | ||||
(range | ||||
|
r34075 | (symbol '2') | ||
(symbol '0')) | ||||
|
r29390 | (range | ||
(group | ||||
(or | ||||
|
r29929 | (list | ||
|
r34075 | (symbol '1') | ||
(symbol '0') | ||||
(symbol '2')))) | ||||
|
r29390 | (group | ||
(or | ||||
|
r29929 | (list | ||
|
r34075 | (symbol '0') | ||
(symbol '2') | ||||
(symbol '1')))))) | ||||
|
r29390 | * optimized: | ||
(and | ||||
(range | ||||
|
r34075 | (symbol '2') | ||
(symbol '0')) | ||||
|
r29390 | (range | ||
(func | ||||
|
r34075 | (symbol '_list') | ||
(string '1\x000\x002')) | ||||
|
r29390 | (func | ||
|
r34075 | (symbol '_list') | ||
(string '0\x002\x001')))) | ||||
|
r29390 | * set: | ||
<filteredset | ||||
|
r32817 | <spanset- 0:3>, | ||
|
r29944 | <baseset [1]>> | ||
|
r29390 | 1 | ||
|
r34013 | 'A & B' can be rewritten as 'flipand(B, A)' by weight. | ||
|
r29390 | |||
$ try --optimize 'contains("glob:*") & (2 + 0 + 1)' | ||||
(and | ||||
(func | ||||
|
r34075 | (symbol 'contains') | ||
(string 'glob:*')) | ||||
|
r29390 | (group | ||
(or | ||||
|
r29929 | (list | ||
|
r34075 | (symbol '2') | ||
(symbol '0') | ||||
(symbol '1'))))) | ||||
|
r29390 | * optimized: | ||
|
r34022 | (andsmally | ||
(func | ||||
|
r34075 | (symbol 'contains') | ||
(string 'glob:*')) | ||||
|
r29390 | (func | ||
|
r34075 | (symbol '_list') | ||
(string '2\x000\x001'))) | ||||
|
r29390 | * set: | ||
<filteredset | ||||
|
r29935 | <baseset+ [0, 1, 2]>, | ||
|
r29390 | <contains 'glob:*'>> | ||
0 | ||||
1 | ||||
|
r29935 | 2 | ||
and in this example, 'A & B' is rewritten as 'B & A', but 'A' overrides | ||||
the order appropriately: | ||||
|
r29390 | |||
$ try --optimize 'reverse(contains("glob:*")) & (0 + 2 + 1)' | ||||
(and | ||||
(func | ||||
|
r34075 | (symbol 'reverse') | ||
|
r29390 | (func | ||
|
r34075 | (symbol 'contains') | ||
(string 'glob:*'))) | ||||
|
r29390 | (group | ||
(or | ||||
|
r29929 | (list | ||
|
r34075 | (symbol '0') | ||
(symbol '2') | ||||
(symbol '1'))))) | ||||
|
r29390 | * optimized: | ||
|
r34022 | (andsmally | ||
|
r29390 | (func | ||
|
r34075 | (symbol 'reverse') | ||
|
r29390 | (func | ||
|
r34075 | (symbol 'contains') | ||
(string 'glob:*'))) | ||||
|
r34022 | (func | ||
|
r34075 | (symbol '_list') | ||
(string '0\x002\x001'))) | ||||
|
r29390 | * set: | ||
<filteredset | ||||
|
r29935 | <baseset- [0, 1, 2]>, | ||
|
r29390 | <contains 'glob:*'>> | ||
|
r29935 | 2 | ||
|
r29390 | 1 | ||
0 | ||||
|
r20717 | test sort revset | ||
-------------------------------------------- | ||||
test when adding two unordered revsets | ||||
$ log 'sort(keyword(issue) or modifies(b))' | ||||
4 | ||||
6 | ||||
test when sorting a reversed collection in the same way it is | ||||
$ log 'sort(reverse(all()), -rev)' | ||||
9 | ||||
8 | ||||
7 | ||||
6 | ||||
5 | ||||
4 | ||||
3 | ||||
2 | ||||
1 | ||||
0 | ||||
test when sorting a reversed collection | ||||
$ log 'sort(reverse(all()), rev)' | ||||
0 | ||||
1 | ||||
2 | ||||
3 | ||||
4 | ||||
5 | ||||
6 | ||||
7 | ||||
8 | ||||
9 | ||||
test sorting two sorted collections in different orders | ||||
$ log 'sort(outgoing() or reverse(removes(a)), rev)' | ||||
2 | ||||
6 | ||||
8 | ||||
9 | ||||
test sorting two sorted collections in different orders backwards | ||||
$ log 'sort(outgoing() or reverse(removes(a)), -rev)' | ||||
9 | ||||
8 | ||||
6 | ||||
2 | ||||
|
r29362 | test empty sort key which is noop | ||
$ log 'sort(0 + 2 + 1, "")' | ||||
0 | ||||
2 | ||||
1 | ||||
|
r29264 | test invalid sort keys | ||
$ log 'sort(all(), -invalid)' | ||||
hg: parse error: unknown sort key '-invalid' | ||||
[255] | ||||
|
r29001 | $ cd .. | ||
test sorting by multiple keys including variable-length strings | ||||
$ hg init sorting | ||||
$ cd sorting | ||||
$ cat <<EOF >> .hg/hgrc | ||||
> [ui] | ||||
> logtemplate = '{rev} {branch|p5}{desc|p5}{author|p5}{date|hgdate}\n' | ||||
> [templatealias] | ||||
> p5(s) = pad(s, 5) | ||||
> EOF | ||||
$ hg branch -qf b12 | ||||
$ hg ci -m m111 -u u112 -d '111 10800' | ||||
$ hg branch -qf b11 | ||||
$ hg ci -m m12 -u u111 -d '112 7200' | ||||
$ hg branch -qf b111 | ||||
$ hg ci -m m11 -u u12 -d '111 3600' | ||||
$ hg branch -qf b112 | ||||
$ hg ci -m m111 -u u11 -d '120 0' | ||||
$ hg branch -qf b111 | ||||
$ hg ci -m m112 -u u111 -d '110 14400' | ||||
created new head | ||||
compare revisions (has fast path): | ||||
$ hg log -r 'sort(all(), rev)' | ||||
0 b12 m111 u112 111 10800 | ||||
1 b11 m12 u111 112 7200 | ||||
2 b111 m11 u12 111 3600 | ||||
3 b112 m111 u11 120 0 | ||||
4 b111 m112 u111 110 14400 | ||||
$ hg log -r 'sort(all(), -rev)' | ||||
4 b111 m112 u111 110 14400 | ||||
3 b112 m111 u11 120 0 | ||||
2 b111 m11 u12 111 3600 | ||||
1 b11 m12 u111 112 7200 | ||||
0 b12 m111 u112 111 10800 | ||||
compare variable-length strings (issue5218): | ||||
$ hg log -r 'sort(all(), branch)' | ||||
1 b11 m12 u111 112 7200 | ||||
2 b111 m11 u12 111 3600 | ||||
4 b111 m112 u111 110 14400 | ||||
3 b112 m111 u11 120 0 | ||||
0 b12 m111 u112 111 10800 | ||||
$ hg log -r 'sort(all(), -branch)' | ||||
0 b12 m111 u112 111 10800 | ||||
3 b112 m111 u11 120 0 | ||||
2 b111 m11 u12 111 3600 | ||||
4 b111 m112 u111 110 14400 | ||||
1 b11 m12 u111 112 7200 | ||||
$ hg log -r 'sort(all(), desc)' | ||||
2 b111 m11 u12 111 3600 | ||||
0 b12 m111 u112 111 10800 | ||||
3 b112 m111 u11 120 0 | ||||
4 b111 m112 u111 110 14400 | ||||
1 b11 m12 u111 112 7200 | ||||
$ hg log -r 'sort(all(), -desc)' | ||||
1 b11 m12 u111 112 7200 | ||||
4 b111 m112 u111 110 14400 | ||||
0 b12 m111 u112 111 10800 | ||||
3 b112 m111 u11 120 0 | ||||
2 b111 m11 u12 111 3600 | ||||
$ hg log -r 'sort(all(), user)' | ||||
3 b112 m111 u11 120 0 | ||||
1 b11 m12 u111 112 7200 | ||||
4 b111 m112 u111 110 14400 | ||||
0 b12 m111 u112 111 10800 | ||||
2 b111 m11 u12 111 3600 | ||||
$ hg log -r 'sort(all(), -user)' | ||||
2 b111 m11 u12 111 3600 | ||||
0 b12 m111 u112 111 10800 | ||||
1 b11 m12 u111 112 7200 | ||||
4 b111 m112 u111 110 14400 | ||||
3 b112 m111 u11 120 0 | ||||
compare dates (tz offset should have no effect): | ||||
$ hg log -r 'sort(all(), date)' | ||||
4 b111 m112 u111 110 14400 | ||||
0 b12 m111 u112 111 10800 | ||||
2 b111 m11 u12 111 3600 | ||||
1 b11 m12 u111 112 7200 | ||||
3 b112 m111 u11 120 0 | ||||
$ hg log -r 'sort(all(), -date)' | ||||
3 b112 m111 u11 120 0 | ||||
1 b11 m12 u111 112 7200 | ||||
0 b12 m111 u112 111 10800 | ||||
2 b111 m11 u12 111 3600 | ||||
4 b111 m112 u111 110 14400 | ||||
be aware that 'sort(x, -k)' is not exactly the same as 'reverse(sort(x, k))' | ||||
because '-k' reverses the comparison, not the list itself: | ||||
$ hg log -r 'sort(0 + 2, date)' | ||||
0 b12 m111 u112 111 10800 | ||||
2 b111 m11 u12 111 3600 | ||||
$ hg log -r 'sort(0 + 2, -date)' | ||||
0 b12 m111 u112 111 10800 | ||||
2 b111 m11 u12 111 3600 | ||||
$ hg log -r 'reverse(sort(0 + 2, date))' | ||||
2 b111 m11 u12 111 3600 | ||||
0 b12 m111 u112 111 10800 | ||||
sort by multiple keys: | ||||
$ hg log -r 'sort(all(), "branch -rev")' | ||||
1 b11 m12 u111 112 7200 | ||||
4 b111 m112 u111 110 14400 | ||||
2 b111 m11 u12 111 3600 | ||||
3 b112 m111 u11 120 0 | ||||
0 b12 m111 u112 111 10800 | ||||
$ hg log -r 'sort(all(), "-desc -date")' | ||||
1 b11 m12 u111 112 7200 | ||||
4 b111 m112 u111 110 14400 | ||||
3 b112 m111 u11 120 0 | ||||
0 b12 m111 u112 111 10800 | ||||
2 b111 m11 u12 111 3600 | ||||
$ hg log -r 'sort(all(), "user -branch date rev")' | ||||
3 b112 m111 u11 120 0 | ||||
4 b111 m112 u111 110 14400 | ||||
1 b11 m12 u111 112 7200 | ||||
0 b12 m111 u112 111 10800 | ||||
2 b111 m11 u12 111 3600 | ||||
|
r29348 | toposort prioritises graph branches | ||
$ hg up 2 | ||||
0 files updated, 0 files merged, 0 files removed, 0 files unresolved | ||||
$ touch a | ||||
$ hg addremove | ||||
adding a | ||||
$ hg ci -m 't1' -u 'tu' -d '130 0' | ||||
created new head | ||||
$ echo 'a' >> a | ||||
$ hg ci -m 't2' -u 'tu' -d '130 0' | ||||
$ hg book book1 | ||||
$ hg up 4 | ||||
0 files updated, 0 files merged, 1 files removed, 0 files unresolved | ||||
(leaving bookmark book1) | ||||
$ touch a | ||||
$ hg addremove | ||||
adding a | ||||
$ hg ci -m 't3' -u 'tu' -d '130 0' | ||||
$ hg log -r 'sort(all(), topo)' | ||||
7 b111 t3 tu 130 0 | ||||
4 b111 m112 u111 110 14400 | ||||
3 b112 m111 u11 120 0 | ||||
6 b111 t2 tu 130 0 | ||||
5 b111 t1 tu 130 0 | ||||
2 b111 m11 u12 111 3600 | ||||
1 b11 m12 u111 112 7200 | ||||
0 b12 m111 u112 111 10800 | ||||
$ hg log -r 'sort(all(), -topo)' | ||||
0 b12 m111 u112 111 10800 | ||||
1 b11 m12 u111 112 7200 | ||||
2 b111 m11 u12 111 3600 | ||||
5 b111 t1 tu 130 0 | ||||
6 b111 t2 tu 130 0 | ||||
3 b112 m111 u11 120 0 | ||||
4 b111 m112 u111 110 14400 | ||||
7 b111 t3 tu 130 0 | ||||
$ hg log -r 'sort(all(), topo, topo.firstbranch=book1)' | ||||
6 b111 t2 tu 130 0 | ||||
5 b111 t1 tu 130 0 | ||||
7 b111 t3 tu 130 0 | ||||
4 b111 m112 u111 110 14400 | ||||
3 b112 m111 u11 120 0 | ||||
2 b111 m11 u12 111 3600 | ||||
1 b11 m12 u111 112 7200 | ||||
0 b12 m111 u112 111 10800 | ||||
topographical sorting can't be combined with other sort keys, and you can't | ||||
use the topo.firstbranch option when topo sort is not active: | ||||
$ hg log -r 'sort(all(), "topo user")' | ||||
hg: parse error: topo sort order cannot be combined with other sort keys | ||||
[255] | ||||
$ hg log -r 'sort(all(), user, topo.firstbranch=book1)' | ||||
hg: parse error: topo.firstbranch can only be used when using the topo sort key | ||||
[255] | ||||
|
r29766 | topo.firstbranch should accept any kind of expressions: | ||
$ hg log -r 'sort(0, topo, topo.firstbranch=(book1))' | ||||
0 b12 m111 u112 111 10800 | ||||
|
r29001 | $ cd .. | ||
$ cd repo | ||||