dualfroz
af32cf4c58
_assign and _modify create an allocator on every call, so the value they are given is never one that allocator created, and updateObject and updateArrayIndex always take the copying branch. Accumulating into an object or an array with a reduce expression therefore copies the whole accumulated value on every iteration, which is quadratic in the number of elements. The query of #241, [range(20000)] | reduce .[] as $item ({}; .[($item|tostring)] = {}) took between 10 and 21 seconds here over three runs, against 0.03 seconds for jq. Create the allocator once per reduce expression and pass it to the assignment as a third argument, so that the accumulated value is allocated on the first iteration and modified in place afterwards. The query above now takes 0.03 seconds, and the memory allocated by an accumulating reduction grows linearly instead of quadratically: 2.1 MB instead of 545 MB for 4000 elements. This is only correct while the accumulated value, and the values the allocator created inside it, are reachable through the reduction alone. Query#inPlaceUpdate therefore requires the update query to be a single assignment, and its right-hand side to neither observe the input value, which would let the assigned value alias the value it is assigned into, nor yield more than one value, which would run the assignment again against a value it already modified. Everything else keeps copying. A foreach expression is left alone, because it yields every intermediate accumulated value.
9440 lines
201 KiB
YAML
9440 lines
201 KiB
YAML
- name: empty input
|
||
args:
|
||
- '.'
|
||
input: ''
|
||
expected: ''
|
||
|
||
- name: empty args
|
||
input: 'null'
|
||
expected: |
|
||
null
|
||
|
||
- name: missing query
|
||
args:
|
||
- ''
|
||
error: |
|
||
compile error: missing query (try ".")
|
||
exit_code: 3
|
||
|
||
- name: query with comment
|
||
args:
|
||
- '. # comment'
|
||
input: 'null'
|
||
expected: |
|
||
null
|
||
|
||
- name: missing query with comment
|
||
args:
|
||
- '# comment'
|
||
error: |
|
||
compile error: missing query (try ".")
|
||
exit_code: 3
|
||
|
||
- name: query with comment with newline
|
||
args:
|
||
- |
|
||
# comment
|
||
1,
|
||
# comment \
|
||
comment \ 0 \
|
||
comment
|
||
2,
|
||
# comment \
|
||
comment \\
|
||
3, # \
|
||
comment \\\
|
||
comment \\
|
||
4 #
|
||
input: 'null'
|
||
expected: |
|
||
1
|
||
2
|
||
3
|
||
4
|
||
|
||
- name: query with comment with newline in dos format
|
||
args:
|
||
- "1, # \r\n2, # \\\r\ncomment\\\\\r\n3"
|
||
input: 'null'
|
||
expected: |
|
||
1
|
||
2
|
||
3
|
||
|
||
- name: query with comment with newline in mac format
|
||
args:
|
||
- "1, # \r2, # \\\rcomment\\\\\r3"
|
||
input: 'null'
|
||
expected: |
|
||
1
|
||
2
|
||
3
|
||
|
||
- name: number input
|
||
args:
|
||
- '.'
|
||
input: '128 3.14 10.0 6.02e23 5e1000'
|
||
expected: |
|
||
128
|
||
3.14
|
||
10.0
|
||
6.02e23
|
||
5e1000
|
||
|
||
- name: number query
|
||
args:
|
||
- '0, 128, 01000, 3.14, 1.2e3, 1E+3, 1E-9'
|
||
input: '0'
|
||
expected: |
|
||
0
|
||
128
|
||
1000
|
||
3.14
|
||
1200
|
||
1000
|
||
1e-9
|
||
|
||
- name: number literal error
|
||
args:
|
||
- '0..[empty]'
|
||
input: '0'
|
||
error: |
|
||
invalid query: 0..[empty]
|
||
0..[empty]
|
||
^ invalid token "0.."
|
||
exit_code: 3
|
||
|
||
- name: string input
|
||
args:
|
||
- '.'
|
||
input: '"Hello, world! \r\n\t\f\b\"\\\/\uff06"'
|
||
expected: |
|
||
"Hello, world! \r\n\t\f\b\"\\/＆"
|
||
|
||
- name: string query
|
||
args:
|
||
- '" Hello, world! \r\n\t\f\b\"\\\/\uff10 "'
|
||
input: 'null'
|
||
expected: |
|
||
" Hello, world! \r\n\t\f\b\"\\/０ "
|
||
|
||
- name: string query including newlines
|
||
args:
|
||
- "\"a\n\\(\"\nb\nc\n\")\nd\n\""
|
||
input: 'null'
|
||
expected: |
|
||
"a\n\nb\nc\n\nd\n"
|
||
|
||
- name: string query including control characters
|
||
args:
|
||
- "\"\x01\x07\x0f\\n\", \"\x7f\\n\""
|
||
input: 'null'
|
||
expected: |
|
||
"\u0001\u0007\u000f\n"
|
||
"\u007f\n"
|
||
|
||
- name: string query including surrogate pairs
|
||
args:
|
||
- '"\ud83d\ude04" | length, utf8bytelength, explode[]'
|
||
input: 'null'
|
||
expected: |
|
||
1
|
||
4
|
||
128516
|
||
|
||
- name: string query error
|
||
args:
|
||
- '. + "foo'
|
||
input: 'null'
|
||
error: |
|
||
invalid query: . + "foo
|
||
. + "foo
|
||
^ unterminated string literal
|
||
exit_code: 3
|
||
|
||
- name: string query error
|
||
args:
|
||
- '"foo\,bar"'
|
||
input: 'null'
|
||
error: |
|
||
invalid query: "foo\,bar"
|
||
"foo\,bar"
|
||
^ invalid escape sequence "\," in string literal
|
||
exit_code: 3
|
||
|
||
- name: string query error
|
||
args:
|
||
- '"\u"'
|
||
input: 'null'
|
||
error: |
|
||
invalid query: "\u"
|
||
"\u"
|
||
^ invalid escape sequence "\u" in string literal
|
||
exit_code: 3
|
||
|
||
- name: string query error
|
||
args:
|
||
- "\"\n\\u\n\""
|
||
input: 'null'
|
||
error: |
|
||
invalid query: <arg>:2
|
||
2 | \u
|
||
^ invalid escape sequence "\u" in string literal
|
||
exit_code: 3
|
||
|
||
- name: string query error
|
||
args:
|
||
- '"\u'
|
||
input: 'null'
|
||
error: |
|
||
invalid query: "\u
|
||
"\u
|
||
^ invalid escape sequence "\u" in string literal
|
||
exit_code: 3
|
||
|
||
- name: string query error
|
||
args:
|
||
- '"\'
|
||
input: 'null'
|
||
error: |
|
||
invalid query: "\
|
||
"\
|
||
^ unterminated string literal
|
||
exit_code: 3
|
||
|
||
- name: string query error
|
||
args:
|
||
- '"\"'
|
||
input: 'null'
|
||
error: |
|
||
invalid query: "\"
|
||
"\"
|
||
^ unterminated string literal
|
||
exit_code: 3
|
||
|
||
- name: string query error
|
||
args:
|
||
- '"\u````"'
|
||
input: 'null'
|
||
error: |
|
||
invalid query: "\u````"
|
||
"\u````"
|
||
^ invalid escape sequence "\u" in string literal
|
||
exit_code: 3
|
||
|
||
- name: string query error
|
||
args:
|
||
- '"\uAA\uAA"'
|
||
input: 'null'
|
||
error: |
|
||
invalid query: "\uAA\uAA"
|
||
"\uAA\uAA"
|
||
^ invalid escape sequence "\uAA" in string literal
|
||
exit_code: 3
|
||
|
||
- name: string query error
|
||
args:
|
||
- '"\uAA@AA"'
|
||
input: 'null'
|
||
error: |
|
||
invalid query: "\uAA@AA"
|
||
"\uAA@AA"
|
||
^ invalid escape sequence "\uAA" in string literal
|
||
exit_code: 3
|
||
|
||
- name: string query error
|
||
args:
|
||
- '"\uAAGA"'
|
||
input: 'null'
|
||
error: |
|
||
invalid query: "\uAAGA"
|
||
"\uAAGA"
|
||
^ invalid escape sequence "\uAA" in string literal
|
||
exit_code: 3
|
||
|
||
- name: string query error
|
||
args:
|
||
- '"\ufffg"'
|
||
input: 'null'
|
||
error: |
|
||
invalid query: "\ufffg"
|
||
"\ufffg"
|
||
^ invalid escape sequence "\ufff" in string literal
|
||
exit_code: 3
|
||
|
||
- name: string query error
|
||
args:
|
||
- '"0\u00:00"'
|
||
input: 'null'
|
||
error: |
|
||
invalid query: "0\u00:00"
|
||
"0\u00:00"
|
||
^ invalid escape sequence "\u00" in string literal
|
||
exit_code: 3
|
||
|
||
- name: string query error
|
||
args:
|
||
- '"0\u0000\u000/0"'
|
||
input: 'null'
|
||
error: |
|
||
invalid query: "0\u0000\u000/0"
|
||
"0\u0000\u000/0"
|
||
^ invalid escape sequence "\u000" in string literal
|
||
exit_code: 3
|
||
|
||
- name: string query error
|
||
args:
|
||
- '"\(1) \x "'
|
||
input: 'null'
|
||
error: |
|
||
invalid query: "\(1) \x "
|
||
"\(1) \x "
|
||
^ invalid escape sequence "\x" in string literal
|
||
exit_code: 3
|
||
|
||
- name: string query error
|
||
args:
|
||
- '"\a"'
|
||
input: 'null'
|
||
error: |
|
||
invalid query: "\a"
|
||
"\a"
|
||
^ invalid escape sequence "\a" in string literal
|
||
exit_code: 3
|
||
|
||
- name: string query error
|
||
args:
|
||
- '"\u\('
|
||
input: 'null'
|
||
error: |
|
||
invalid query: "\u\(
|
||
"\u\(
|
||
^ invalid escape sequence "\u" in string literal
|
||
exit_code: 3
|
||
|
||
- name: object input
|
||
input: '{"foo": 128}'
|
||
expected: |
|
||
{
|
||
"foo": 128
|
||
}
|
||
|
||
- name: object input and string escape
|
||
input: '{"foo\\u0000\\t\\n\\r\\u001f !\"#$/09:;<>?@AZ[\\\\]^_`az{|}~\\u007f": "<\\t\\n\\r>"}'
|
||
expected: |
|
||
{
|
||
"foo\\u0000\\t\\n\\r\\u001f !\"#$/09:;<>?@AZ[\\\\]^_`az{|}~\\u007f": "<\\t\\n\\r>"
|
||
}
|
||
|
||
- name: object indexing
|
||
args:
|
||
- '.foo'
|
||
input: '{"foo": 128}'
|
||
expected: |
|
||
128
|
||
|
||
- name: object indexing with large number value
|
||
args:
|
||
- '.foo'
|
||
input: '{"foo": 4722366482869645213696}'
|
||
expected: |
|
||
4722366482869645213696
|
||
|
||
- name: object indexing with floating-point number with trailing zeros
|
||
args:
|
||
- '.foo'
|
||
input: '{"foo": 100.000}'
|
||
expected: |
|
||
100.000
|
||
|
||
- name: object indexing by keywords
|
||
args:
|
||
- '.and,.or,.try'
|
||
input: '{"and":1,"or":2,"try":3}'
|
||
expected: |
|
||
1
|
||
2
|
||
3
|
||
|
||
- name: object indexing by brackets
|
||
args:
|
||
- '.["foo"]'
|
||
input: '{"foo": 128}'
|
||
expected: |
|
||
128
|
||
|
||
- name: object indexing by string
|
||
args:
|
||
- '."foo", ."2\(.foo[])3"'
|
||
input: '{"foo":[1,2],"213":3,"223":6}'
|
||
expected: |
|
||
[
|
||
1,
|
||
2
|
||
]
|
||
3
|
||
6
|
||
|
||
- name: object indexing by query
|
||
args:
|
||
- '.c[.a + .b]'
|
||
input: '{ "a": "b", "b": "c", "c": {"bc": 128} }'
|
||
expected: |
|
||
128
|
||
|
||
- name: object nested indexing by query
|
||
args:
|
||
- '.d[.a][.b][.c]'
|
||
input: '{ "a": "b", "b": "c", "c": "d", "d": { "b": { "c": { "d": 128 } } } }'
|
||
expected: |
|
||
128
|
||
|
||
- name: object indexing by iterator after iterator
|
||
args:
|
||
- '.c[][.a[] + .b[]]'
|
||
input: '{ "a": ["a", "b"], "b": ["c", "d"], "c": [{"ac": 1, "bc": 2, "ad": 3, "bd": 4}, {"ac": 5, "bc": 6, "ad": 7, "bd": 8}] }'
|
||
expected: |
|
||
1
|
||
5
|
||
2
|
||
6
|
||
3
|
||
7
|
||
4
|
||
8
|
||
|
||
- name: object indexing by string iterator after iterator
|
||
args:
|
||
- '.c[]."\(.a[])"'
|
||
input: '{ "a": [0,1], "b": [0,2], "c": [{"0":1,"1":2},{"0":3,"1":4}] }'
|
||
expected: |
|
||
1
|
||
3
|
||
2
|
||
4
|
||
|
||
- name: object indexing in object value
|
||
args:
|
||
- '{ message: .[].message }'
|
||
input: '[ {"message": "Hello, world" } ]'
|
||
expected: |
|
||
{
|
||
"message": "Hello, world"
|
||
}
|
||
|
||
- name: object indexing error
|
||
args:
|
||
- '.[.a + .b]'
|
||
input: '{"a": 10, "b": 20}'
|
||
error: |
|
||
expected an array but got: object ({"a":10,"b":20})
|
||
|
||
- name: object indexing value error
|
||
args:
|
||
- '.["foo"]'
|
||
input: '[]'
|
||
error: |
|
||
expected an object but got: array ([])
|
||
|
||
- name: object indexing key error
|
||
args:
|
||
- '.[null]'
|
||
input: '{}'
|
||
error: |
|
||
expected a string for object key but got: null
|
||
|
||
- name: object indexing syntax error
|
||
args:
|
||
- '. a'
|
||
input: '{}'
|
||
error: |
|
||
invalid query: . a
|
||
. a
|
||
^ unexpected token "a"
|
||
exit_code: 3
|
||
|
||
- name: expected object but got number error
|
||
args:
|
||
- '.foo.bar'
|
||
input: '{"foo": 128}'
|
||
error: |
|
||
expected an object but got: number (128)
|
||
|
||
- name: expected object but got string error
|
||
args:
|
||
- '"a"+"☆"*100 | .foo'
|
||
input: '0'
|
||
error: |
|
||
expected an object but got: string ("a☆☆☆☆☆☆☆ ...")
|
||
|
||
- name: expected object error with pipe operator
|
||
args:
|
||
- '.foo|.bar'
|
||
input: '{"foo": 128}'
|
||
error: |
|
||
expected an object but got: number (128)
|
||
|
||
- name: expected object error after iterator
|
||
args:
|
||
- '.[]|.foo|.bar'
|
||
input: '[128]'
|
||
error: |
|
||
expected an object but got: number (128)
|
||
|
||
- name: object indexing against null
|
||
args:
|
||
- '.foo.bar.baz'
|
||
input: 'null'
|
||
expected: |
|
||
null
|
||
|
||
- name: object optional indexing
|
||
args:
|
||
- '.foo?.bar?.baz?'
|
||
input: '{"foo": 128}'
|
||
|
||
- name: object optional indexing error
|
||
args:
|
||
- '.foo.bar.baz?'
|
||
input: '{"foo": 128}'
|
||
error: |
|
||
expected an object but got: number (128)
|
||
|
||
- name: object optional indexing after iterator error
|
||
args:
|
||
- '.[].foo?'
|
||
input: '128'
|
||
error: |
|
||
cannot iterate over: number (128)
|
||
|
||
- name: object optional indexing with optional operator
|
||
args:
|
||
- '.foo??, .'
|
||
input: '0'
|
||
expected: |
|
||
0
|
||
|
||
- name: error after optional operator
|
||
args:
|
||
- '1? | .foo'
|
||
input: 'null'
|
||
error: |
|
||
expected an object but got: number (1)
|
||
|
||
- name: error after optional operator with fork
|
||
args:
|
||
- '(1,2)? | .foo'
|
||
input: 'null'
|
||
error: |
|
||
expected an object but got: number (1)
|
||
|
||
- name: array indexing
|
||
args:
|
||
- '.[-4,-3,-2,-1,0,1,2,3,nan]'
|
||
input: '[0, 1, 2]'
|
||
expected: |
|
||
null
|
||
0
|
||
1
|
||
2
|
||
0
|
||
1
|
||
2
|
||
null
|
||
null
|
||
|
||
- name: array slicing
|
||
args:
|
||
- -c
|
||
- '[.[-4,-3,-2,-1,0,1,2,3:]], [.[:-4,-3,-2,-1,0,1,2,3]], [.[-1,0,1,2,3:-1,0,1,2,3]]'
|
||
input: '[0, 1, 2]'
|
||
expected: |
|
||
[[0,1,2],[0,1,2],[1,2],[2],[0,1,2],[1,2],[2],[]]
|
||
[[],[],[0],[0,1],[],[0],[0,1],[0,1,2]]
|
||
[[],[],[],[],[2],[0,1],[],[0],[0,1],[0,1,2],[1],[],[],[1],[1,2],[],[],[],[],[2],[],[],[],[],[]]
|
||
|
||
- name: array indexing and slicing by floating-point number
|
||
args:
|
||
- -c
|
||
- '[.[-2.8,-1.2,0.3,1.7,2.2]], [.[0.3,1.7:]], [.[:0.3,1.7]], [.[0.3,1.7,2.2:0.3,1.7,2.2]]'
|
||
input: '[0, 1, 2]'
|
||
expected: |
|
||
[1,2,0,1,2]
|
||
[[0,1,2],[1,2]]
|
||
[[0],[0,1]]
|
||
[[0],[0,1],[0,1,2],[],[1],[1,2],[],[],[2]]
|
||
|
||
- name: array indexing and slicing by large number
|
||
args:
|
||
- -c
|
||
- '.[1e300,-1e300], .[-1e300,1e300:], .[:-1e300,1e300], .[-1e300:1e300], .[1e300:-1e300]'
|
||
input: '[0, 1, 2]'
|
||
expected: |
|
||
null
|
||
null
|
||
[0,1,2]
|
||
[]
|
||
[]
|
||
[0,1,2]
|
||
[0,1,2]
|
||
[]
|
||
|
||
- name: array indexing and slicing by large integer
|
||
args:
|
||
- -c
|
||
- '. as $x | 4722366482869645213696 as $y | $x[$y,-$y], $x[-$y,$y:], $x[:-$y,$y], $x[-$y:$y], $x[$y-$y], $x[$y/$y]'
|
||
input: '[0, 1, 2]'
|
||
expected: |
|
||
null
|
||
null
|
||
[0,1,2]
|
||
[]
|
||
[]
|
||
[0,1,2]
|
||
[0,1,2]
|
||
0
|
||
1
|
||
|
||
- name: array indexing and slicing by infinite
|
||
args:
|
||
- -c
|
||
- '.[infinite,-infinite], .[-infinite,infinite:], .[:-infinite,infinite], .[-infinite:infinite], .[infinite:-infinite]'
|
||
input: '[0, 1, 2]'
|
||
expected: |
|
||
null
|
||
null
|
||
[0,1,2]
|
||
[]
|
||
[]
|
||
[0,1,2]
|
||
[0,1,2]
|
||
[]
|
||
|
||
- name: array and string slicing by object
|
||
args:
|
||
- -c
|
||
- '[.[{"start": (null,range(-3;4)), "end": (null,range(-3;4))}]]'
|
||
input: '[0, 1, 2] "abcde"'
|
||
expected: |
|
||
[[0,1,2],[],[0],[0,1],[],[0],[0,1],[0,1,2],[0,1,2],[],[0],[0,1],[],[0],[0,1],[0,1,2],[1,2],[],[],[1],[],[],[1],[1,2],[2],[],[],[],[],[],[],[2],[0,1,2],[],[0],[0,1],[],[0],[0,1],[0,1,2],[1,2],[],[],[1],[],[],[1],[1,2],[2],[],[],[],[],[],[],[2],[],[],[],[],[],[],[],[]]
|
||
["abcde","ab","abc","abcd","","a","ab","abc","cde","","c","cd","","","","c","de","","","d","","","","","e","","","","","","","","abcde","ab","abc","abcd","","a","ab","abc","bcde","b","bc","bcd","","","b","bc","cde","","c","cd","","","","c","de","","","d","","","",""]
|
||
|
||
- name: array slicing by object against null
|
||
args:
|
||
- '.[{"start": 1, "end": 2}]'
|
||
input: 'null'
|
||
expected: |
|
||
null
|
||
|
||
- name: array slicing by object error
|
||
args:
|
||
- '.[{"start": 1}]'
|
||
input: '[]'
|
||
error: |
|
||
expected "start" and "end" for slicing but got: object ({"start":1})
|
||
|
||
- name: array nested indexing by iterator
|
||
args:
|
||
- -c
|
||
- '[.[.[]],.[.[]:],.[:.[]],.[.[]:.[]],.[-.[]],.[--.[]]]'
|
||
input: '[0, 1, 2]'
|
||
expected: |
|
||
[0,1,2,[0,1,2],[1,2],[2],[],[0],[0,1],[],[0],[0,1],[],[],[1],[],[],[],0,2,1,0,1,2]
|
||
|
||
- name: array indexing by iterator
|
||
args:
|
||
- '.c[][.a[] + .b[]]'
|
||
input: '{ "a": [0,1], "b": [0,2], "c": [[1,2,3,4],[5,6,7,8]] }'
|
||
expected: |
|
||
1
|
||
5
|
||
2
|
||
6
|
||
3
|
||
7
|
||
4
|
||
8
|
||
|
||
- name: array slicing by iterator
|
||
args:
|
||
- -c
|
||
- '.c[][.a[] : .b[]]'
|
||
input: '{ "a": [0,1], "b": [0,2], "c": [[1,2,3,4],[5,6,7,8]] }'
|
||
expected: |
|
||
[]
|
||
[]
|
||
[1,2]
|
||
[5,6]
|
||
[]
|
||
[]
|
||
[2]
|
||
[6]
|
||
|
||
- name: expected array but got object error
|
||
args:
|
||
- '.[0:1]'
|
||
input: '{"foo": 128}'
|
||
error: |
|
||
expected an array but got: object ({"foo":128})
|
||
|
||
- name: array indexing against null
|
||
args:
|
||
- '.[0]'
|
||
input: 'null'
|
||
expected: |
|
||
null
|
||
|
||
- name: array slicing against null
|
||
args:
|
||
- '.[0:1]'
|
||
input: 'null'
|
||
expected: |
|
||
null
|
||
|
||
- name: array indexing by array
|
||
args:
|
||
- -c
|
||
- '.[[1],[5,7,9],[],5,[3]]'
|
||
input: '[1,3,5,7,9,8,6,5,4,3,2,1]'
|
||
expected: |
|
||
[0,11]
|
||
[2]
|
||
[]
|
||
8
|
||
[1,9]
|
||
|
||
- name: array indexing not number error
|
||
args:
|
||
- '.[true]'
|
||
input: '[]'
|
||
error: |
|
||
expected a number for indexing an array but got: boolean (true)
|
||
|
||
- name: indexing number literal error
|
||
args:
|
||
- '-1[0]'
|
||
input: 'null'
|
||
error: |
|
||
expected an array but got: number (1)
|
||
|
||
- name: slicing number literal error
|
||
args:
|
||
- '1 - -1[1:]'
|
||
input: 'null'
|
||
error: |
|
||
expected an array but got: number (1)
|
||
|
||
- name: indexing by indexed number literal error
|
||
args:
|
||
- '.[1[0]]'
|
||
input: '[0, 1]'
|
||
error: |
|
||
expected an array but got: number (1)
|
||
|
||
- name: array slicing start error
|
||
args:
|
||
- '.[[]:0]'
|
||
input: '[]'
|
||
error: |
|
||
expected a number for indexing an array but got: array ([])
|
||
|
||
- name: array slicing end error
|
||
args:
|
||
- '.[0:{}]'
|
||
input: '[]'
|
||
error: |
|
||
expected a number for indexing an array but got: object ({})
|
||
|
||
- name: string indexing
|
||
args:
|
||
- '.[-5,-1,0,3,4,6]'
|
||
input: '"１２３４５"'
|
||
expected: |
|
||
"１"
|
||
"５"
|
||
"１"
|
||
"４"
|
||
"５"
|
||
null
|
||
|
||
- name: string slicing
|
||
args:
|
||
- '.[3:], .[:3], .[2:4], .[-4:-2], .[1.5:3.5]'
|
||
input: '"１２３４５"'
|
||
expected: |
|
||
"４５"
|
||
"１２３"
|
||
"３４"
|
||
"２３"
|
||
"２３４"
|
||
|
||
- name: string indexing not number error
|
||
args:
|
||
- '.[null]'
|
||
input: '""'
|
||
error: |
|
||
expected a number for indexing a string but got: null
|
||
|
||
- name: string slicing start error
|
||
args:
|
||
- '.[[]:]'
|
||
input: '""'
|
||
error: |
|
||
expected a number for indexing a string but got: array ([])
|
||
|
||
- name: string slicing end error
|
||
args:
|
||
- '.[:{}]'
|
||
input: '""'
|
||
error: |
|
||
expected a number for indexing a string but got: object ({})
|
||
|
||
- name: array construction
|
||
args:
|
||
- -c
|
||
- '.,[3,[[2]]],[1],[[.],3]|[.,.]'
|
||
input: 'null'
|
||
expected: |
|
||
[null,null]
|
||
[[3,[[2]]],[3,[[2]]]]
|
||
[[1],[1]]
|
||
[[[null],3],[[null],3]]
|
||
|
||
- name: array iterator
|
||
args:
|
||
- '.foo | .[] | .'
|
||
input: '{"foo": [1,2,{"bar":[]},[3,4,5]]}'
|
||
expected: |
|
||
1
|
||
2
|
||
{
|
||
"bar": []
|
||
}
|
||
[
|
||
3,
|
||
4,
|
||
5
|
||
]
|
||
|
||
- name: iterator with optional operator
|
||
args:
|
||
- '.[]?'
|
||
input: '0'
|
||
|
||
- name: iterator with optional operator after indexing error
|
||
args:
|
||
- '.x[]?'
|
||
input: '0'
|
||
error: |
|
||
expected an object but got: number (0)
|
||
|
||
- name: nested iterator
|
||
args:
|
||
- '.[][]'
|
||
input: '[[10]]'
|
||
expected: |
|
||
10
|
||
|
||
- name: nested iterator error
|
||
args:
|
||
- '.[][]'
|
||
input: '[10]'
|
||
error: |
|
||
cannot iterate over: number (10)
|
||
|
||
- name: nested iterator with optional operator
|
||
args:
|
||
- '.[][]?'
|
||
input: '[10]'
|
||
|
||
- name: object iterator
|
||
args:
|
||
- '.[]'
|
||
input: '{"foo": 128}'
|
||
expected: |
|
||
128
|
||
|
||
- name: object optional indexing after iterator
|
||
args:
|
||
- '[.[].name?]'
|
||
input: '[ 1, { "name": 2 }, 3, { "name": 4 } ]'
|
||
expected: |
|
||
[
|
||
2,
|
||
4
|
||
]
|
||
|
||
- name: pipe
|
||
args:
|
||
- '.foo | .bar'
|
||
input: '{"foo": {"bar": {"baz": 128}}}'
|
||
expected: |
|
||
{
|
||
"baz": 128
|
||
}
|
||
|
||
- name: null value
|
||
args:
|
||
- '.[] | null'
|
||
input: '["a", 1, [], {}]'
|
||
expected: |
|
||
null
|
||
null
|
||
null
|
||
null
|
||
|
||
- name: boolean values
|
||
args:
|
||
- '.[] | true, false'
|
||
input: '["a", 1]'
|
||
expected: |
|
||
true
|
||
false
|
||
true
|
||
false
|
||
|
||
- name: empty function
|
||
args:
|
||
- '.[] | empty, empty, . + [empty,.][], [empty,.][] / 1, empty < ., . and empty, empty or .'
|
||
input: '[0, 1]'
|
||
expected: |
|
||
0
|
||
0
|
||
2
|
||
1
|
||
|
||
- name: empty function in array construction
|
||
args:
|
||
- '[empty], [0, empty, 1]'
|
||
input: 'null'
|
||
expected: |
|
||
[]
|
||
[
|
||
0,
|
||
1
|
||
]
|
||
|
||
- name: empty function in function declaration
|
||
args:
|
||
- 'def f: 1,empty,empty,2; f,f'
|
||
input: '[0, 1]'
|
||
expected: |
|
||
1
|
||
2
|
||
1
|
||
2
|
||
|
||
- name: unary operators
|
||
args:
|
||
- -c
|
||
- 'map(-.[]), map(+.[])'
|
||
input: '[[1,2,3,4722366482869645213696]]'
|
||
expected: |
|
||
[-1,-2,-3,-4722366482869645213696]
|
||
[1,2,3,4722366482869645213696]
|
||
|
||
- name: unary operator against string
|
||
args:
|
||
- '(-.)'
|
||
input: '"abcdeabcdeabcdeabcdeabcdeabcdeabcdeabcdeabcdeabcde"'
|
||
error: |
|
||
cannot negate: string ("abcdeabcdeabcdeabcdeabcd ...")
|
||
|
||
- name: unary operator with variable binding
|
||
args:
|
||
- '[-1 as $x | 1, $x]'
|
||
input: 'null'
|
||
expected: |
|
||
[
|
||
1,
|
||
-1
|
||
]
|
||
|
||
- name: unary operator with type function
|
||
args:
|
||
- '., -. | type'
|
||
input: '-100'
|
||
expected: |
|
||
"number"
|
||
"number"
|
||
|
||
- name: arithmetic operator with variable binding
|
||
args:
|
||
- '1 + 2 as $x | -$x'
|
||
input: 'null'
|
||
expected: |
|
||
-3
|
||
|
||
- name: alternative operator with variable binding
|
||
args:
|
||
- 'true // 1 as $x | [$x]'
|
||
input: 'null'
|
||
expected: |
|
||
[
|
||
true
|
||
]
|
||
|
||
- name: object construction
|
||
args:
|
||
- -c
|
||
- '{ foo: .foo.bar, "bar": .foo, "": false }'
|
||
input: '{"foo":{"bar":["a","b"]}}'
|
||
expected: |
|
||
{"":false,"bar":{"bar":["a","b"]},"foo":["a","b"]}
|
||
|
||
- name: object construction shortcuts
|
||
args:
|
||
- '{foo,"bar",qux,quxx:.foo}'
|
||
input: '{"foo": 1, "bar": 2, "baz": 3}'
|
||
expected: |
|
||
{
|
||
"bar": 2,
|
||
"foo": 1,
|
||
"qux": null,
|
||
"quxx": 1
|
||
}
|
||
|
||
- name: object construction with trailing comma
|
||
args:
|
||
- '{foo,bar,}'
|
||
input: '{"foo": 1, "bar": 2, "baz": 3}'
|
||
expected: |
|
||
{
|
||
"bar": 2,
|
||
"foo": 1
|
||
}
|
||
|
||
- name: object construction by keywords
|
||
args:
|
||
- '{as, and, null, module}'
|
||
input: '{"and": 1, "as": 2, "module": 3, "null": 4}'
|
||
expected: |
|
||
{
|
||
"and": 1,
|
||
"as": 2,
|
||
"module": 3,
|
||
"null": 4
|
||
}
|
||
|
||
- name: object construction with duplicate keys
|
||
args:
|
||
- -c
|
||
- '{foo: 1, foo: 2, bar: 3}, {foo, bar, foo: length}'
|
||
input: '{"foo": 1, "bar": 2, "baz": 3}'
|
||
expected: |
|
||
{"bar":3,"foo":2}
|
||
{"bar":2,"foo":3}
|
||
|
||
- name: object construction with pipe in value
|
||
args:
|
||
- '{"bar": {"baz":.} | select(.baz)}'
|
||
input: '{"foo":100}'
|
||
expected: |
|
||
{
|
||
"bar": {
|
||
"baz": {
|
||
"foo": 100
|
||
}
|
||
}
|
||
}
|
||
|
||
- name: object construction with unary operator
|
||
args:
|
||
- '{x:-1}, {x:-.}, {x:-.|abs}'
|
||
input: '1'
|
||
expected: |
|
||
{
|
||
"x": -1
|
||
}
|
||
{
|
||
"x": -1
|
||
}
|
||
{
|
||
"x": 1
|
||
}
|
||
|
||
- name: object construction with binary operators
|
||
args:
|
||
- '{x: 1 + 2, y: false or true, z: null // 3}'
|
||
input: 'null'
|
||
expected: |
|
||
{
|
||
"x": 3,
|
||
"y": true,
|
||
"z": 3
|
||
}
|
||
|
||
- name: object construction with condition
|
||
args:
|
||
- '{x: if true then -. end}'
|
||
input: '1'
|
||
expected: |
|
||
{
|
||
"x": -1
|
||
}
|
||
|
||
- name: empty object
|
||
args:
|
||
- '{}'
|
||
input: '{"foo":{"bar":["a","b"]}}'
|
||
expected: |
|
||
{}
|
||
|
||
- name: unary operators in object values
|
||
args:
|
||
- '{ x: -128, y: +128 }'
|
||
input: '0'
|
||
expected: |
|
||
{
|
||
"x": -128,
|
||
"y": 128
|
||
}
|
||
|
||
- name: iterator in object values
|
||
args:
|
||
- -c
|
||
- '{ foo: .foo[], bar: .bar[] }'
|
||
input: '{"foo":[1,2],"bar":["a","b"]}'
|
||
expected: |
|
||
{"bar":"a","foo":1}
|
||
{"bar":"b","foo":1}
|
||
{"bar":"a","foo":2}
|
||
{"bar":"b","foo":2}
|
||
|
||
- name: iterator in object key
|
||
args:
|
||
- -c
|
||
- '{ (.[]): .. }'
|
||
input: '["a", "b"]'
|
||
expected: |
|
||
{"a":["a","b"]}
|
||
{"a":"a"}
|
||
{"a":"b"}
|
||
{"b":["a","b"]}
|
||
{"b":"a"}
|
||
{"b":"b"}
|
||
|
||
- name: binary operators in object key and value
|
||
args:
|
||
- -c
|
||
- '{ (.[] + .[]): (.[] + .[]) }'
|
||
input: '["foo", "bar"]'
|
||
expected: |
|
||
{"foofoo":"foofoo"}
|
||
{"foofoo":"barfoo"}
|
||
{"foofoo":"foobar"}
|
||
{"foofoo":"barbar"}
|
||
{"barfoo":"foofoo"}
|
||
{"barfoo":"barfoo"}
|
||
{"barfoo":"foobar"}
|
||
{"barfoo":"barbar"}
|
||
{"foobar":"foofoo"}
|
||
{"foobar":"barfoo"}
|
||
{"foobar":"foobar"}
|
||
{"foobar":"barbar"}
|
||
{"barbar":"foofoo"}
|
||
{"barbar":"barfoo"}
|
||
{"barbar":"foobar"}
|
||
{"barbar":"barbar"}
|
||
|
||
- name: error in object key
|
||
args:
|
||
- -c
|
||
- '{ (.[]): .. }'
|
||
input: '["a", 1]'
|
||
expected: |
|
||
{"a":["a",1]}
|
||
{"a":"a"}
|
||
{"a":1}
|
||
error: |
|
||
expected a string for object key but got: number (1)
|
||
|
||
- name: error in object value
|
||
args:
|
||
- -c
|
||
- '.[] | { (.k): .a.b }'
|
||
input: '[{"a":{"b":10},"k":"a"}, {"a":10,"k":"b"}]'
|
||
expected: |
|
||
{"a":10}
|
||
error: |
|
||
expected an object but got: number (10)
|
||
|
||
- name: variable in object keys
|
||
args:
|
||
- -c
|
||
- '. as [$x, $y, $z] | {$x: 1, $y: 2, $z: 3}'
|
||
input: |
|
||
["a","b","c"]
|
||
expected: |
|
||
{"a":1,"b":2,"c":3}
|
||
|
||
- name: pipe in object key
|
||
args:
|
||
- '{ (.foo|.bar): .foo.bar }'
|
||
input: '{"foo":{"bar":"baz"}}'
|
||
expected: |
|
||
{
|
||
"baz": "baz"
|
||
}
|
||
|
||
- name: number in object key
|
||
args:
|
||
- '{ (.foo): .foo }'
|
||
input: '{"foo":10}'
|
||
error: |
|
||
expected a string for object key but got: number (10)
|
||
|
||
- name: null in object key
|
||
args:
|
||
- '{ (.foo): .foo }'
|
||
input: '{}'
|
||
error: |
|
||
expected a string for object key but got: null
|
||
|
||
- name: keyword in object keys
|
||
args:
|
||
- -c
|
||
- '{if:0,and:1,or:2,then:3,else:4,elif:5,end:6,as:7,def:8,reduce:9,foreach:10,try:11,catch:12,label:13,import:14,include:15,module:16}'
|
||
input: 'null'
|
||
expected: |
|
||
{"and":1,"as":7,"catch":12,"def":8,"elif":5,"else":4,"end":6,"foreach":10,"if":0,"import":14,"include":15,"label":13,"module":16,"or":2,"reduce":9,"then":3,"try":11}
|
||
|
||
- name: array
|
||
args:
|
||
- '[.foo, ., false]'
|
||
input: '{"foo": {"bar": 128}}'
|
||
expected: |
|
||
[
|
||
{
|
||
"bar": 128
|
||
},
|
||
{
|
||
"foo": {
|
||
"bar": 128
|
||
}
|
||
},
|
||
false
|
||
]
|
||
|
||
- name: empty array
|
||
args:
|
||
- '[]'
|
||
input: '{"foo": {"bar": 128}}'
|
||
expected: |
|
||
[]
|
||
|
||
- name: pipe in array
|
||
args:
|
||
- '[.foo|.bar]'
|
||
input: '{"foo": {"bar": 128}}'
|
||
expected: |
|
||
[
|
||
128
|
||
]
|
||
|
||
- name: iterator in array
|
||
args:
|
||
- '[.foo|.bar[][]]'
|
||
input: '{"foo": {"bar": [[1],[2],[3]]}}'
|
||
expected: |
|
||
[
|
||
1,
|
||
2,
|
||
3
|
||
]
|
||
|
||
- name: error after iterator
|
||
args:
|
||
- '[ .[] | .foo ]'
|
||
input: '[ [1, 2, 3], 4, 5]'
|
||
error: |
|
||
expected an object but got: array ([1,2,3])
|
||
|
||
- name: function after iterator error
|
||
args:
|
||
- '.[] | .foo | null'
|
||
input: '[1, 2, 3]'
|
||
error: |
|
||
expected an object but got: number (1)
|
||
|
||
- name: multiple iterators in array
|
||
args:
|
||
- -c
|
||
- '[.[],..,.[]]'
|
||
input: '[1, 2, 3]'
|
||
expected: |
|
||
[1,2,3,[1,2,3],1,2,3,1,2,3]
|
||
|
||
- name: recurse
|
||
args:
|
||
- -c
|
||
- '..'
|
||
input: '{"foo":{"bar":["a","b"]}}'
|
||
expected: |
|
||
{"foo":{"bar":["a","b"]}}
|
||
{"bar":["a","b"]}
|
||
["a","b"]
|
||
"a"
|
||
"b"
|
||
|
||
- name: recurse after iterator
|
||
args:
|
||
- '.[] | ..'
|
||
input: '{"foo":[{"bar":128}]}'
|
||
expected: |
|
||
[
|
||
{
|
||
"bar": 128
|
||
}
|
||
]
|
||
{
|
||
"bar": 128
|
||
}
|
||
128
|
||
|
||
- name: recurse and pipe
|
||
args:
|
||
- '.. | .foo?'
|
||
input: '{"foo":{"bar":["a","b"]}}'
|
||
expected: |
|
||
{
|
||
"bar": [
|
||
"a",
|
||
"b"
|
||
]
|
||
}
|
||
null
|
||
|
||
- name: recurse in object value
|
||
args:
|
||
- -c
|
||
- '{ foo: .. }'
|
||
input: '{"foo":[1,2,3]}'
|
||
expected: |
|
||
{"foo":{"foo":[1,2,3]}}
|
||
{"foo":[1,2,3]}
|
||
{"foo":1}
|
||
{"foo":2}
|
||
{"foo":3}
|
||
|
||
- name: abs function
|
||
args:
|
||
- 'abs'
|
||
input: |
|
||
0
|
||
42
|
||
-42
|
||
0.0
|
||
3.14
|
||
-3.14
|
||
4722366482869645213696
|
||
-4722366482869645213696
|
||
expected: |
|
||
0
|
||
42
|
||
42
|
||
0.0
|
||
3.14
|
||
3.14
|
||
4722366482869645213696
|
||
4722366482869645213696
|
||
|
||
- name: abs function with minimum integer
|
||
args:
|
||
- '(-9223372036854775807 - 1) | abs'
|
||
input: 'null'
|
||
expected: |
|
||
9223372036854775808
|
||
|
||
- name: abs function against non-numbers
|
||
args:
|
||
- -c
|
||
- 'abs'
|
||
input: |
|
||
""
|
||
"-42"
|
||
[]
|
||
[1,-2]
|
||
{}
|
||
{"a":-1}
|
||
expected: |
|
||
""
|
||
"-42"
|
||
[]
|
||
[1,-2]
|
||
{}
|
||
{"a":-1}
|
||
|
||
- name: abs function error
|
||
args:
|
||
- 'abs'
|
||
input: 'null true'
|
||
error: |
|
||
cannot negate: null
|
||
cannot negate: boolean (true)
|
||
|
||
- name: length function
|
||
args:
|
||
- 'length'
|
||
input: |
|
||
42
|
||
-42
|
||
{"a":1,"b":2}
|
||
[3,4,5]
|
||
"Hello, world"
|
||
"１２３４５"
|
||
null
|
||
-4722366482869645213696
|
||
expected: |
|
||
42
|
||
42
|
||
2
|
||
3
|
||
12
|
||
5
|
||
0
|
||
4722366482869645213696
|
||
|
||
- name: length function with minimum integer
|
||
args:
|
||
- '(-9223372036854775807 - 1) | length'
|
||
input: 'null'
|
||
expected: |
|
||
9223372036854775808
|
||
|
||
- name: length function error
|
||
args:
|
||
- 'length'
|
||
input: 'false'
|
||
error: |
|
||
length cannot be applied to: boolean (false)
|
||
|
||
- name: keys function
|
||
args:
|
||
- 'keys'
|
||
input: |
|
||
{"a":1,"b":2}
|
||
[3,4,5]
|
||
expected: |
|
||
[
|
||
"a",
|
||
"b"
|
||
]
|
||
[
|
||
0,
|
||
1,
|
||
2
|
||
]
|
||
|
||
- name: utf8bytelength function
|
||
args:
|
||
- 'utf8bytelength'
|
||
input: '"" "☆１２３４５☆"'
|
||
expected: |
|
||
0
|
||
21
|
||
|
||
- name: has function on objects
|
||
args:
|
||
- 'has(.c[])'
|
||
input: |
|
||
{"a":{"b":1},"c":["a","b"]}
|
||
{"c":["b","c"]}
|
||
expected: |
|
||
true
|
||
false
|
||
false
|
||
true
|
||
|
||
- name: has function on arrays
|
||
args:
|
||
- 'has(2, nan, infinite, -infinite)'
|
||
input: |
|
||
[1, 2, 3]
|
||
[1, 3]
|
||
expected: |
|
||
true
|
||
false
|
||
false
|
||
false
|
||
false
|
||
false
|
||
false
|
||
false
|
||
|
||
- name: has function against null
|
||
args:
|
||
- 'has(2, nan, infinite, -infinite)'
|
||
input: 'null'
|
||
expected: |
|
||
false
|
||
false
|
||
false
|
||
false
|
||
|
||
- name: has/0 is not defined
|
||
args:
|
||
- 'has'
|
||
input: '[0]'
|
||
error: |
|
||
function not defined: has/0
|
||
exit_code: 3
|
||
|
||
- name: has/2 is not defined
|
||
args:
|
||
- 'has(1; 2)'
|
||
input: '[0]'
|
||
error: |
|
||
function not defined: has/2
|
||
exit_code: 3
|
||
|
||
- name: has function type error
|
||
args:
|
||
- 'has(0)'
|
||
input: '{}'
|
||
error: |
|
||
has(0) cannot be applied to: object ({})
|
||
|
||
- name: in function for object
|
||
args:
|
||
- 'in({"foo": 42})'
|
||
input: '"foo" "bar"'
|
||
expected: |
|
||
true
|
||
false
|
||
|
||
- name: in function for array
|
||
args:
|
||
- 'in([3, 4])'
|
||
input: '-1 0 1 2'
|
||
expected: |
|
||
false
|
||
true
|
||
true
|
||
false
|
||
|
||
- name: in function for null
|
||
args:
|
||
- 'in(null)'
|
||
input: '0'
|
||
expected: |
|
||
false
|
||
|
||
- name: in function type error
|
||
args:
|
||
- 'in([0,0,0,0,0,0,0,0,0,0,0,0,0,0,0])'
|
||
input: '"x"'
|
||
error: |
|
||
has("x") cannot be applied to: array ([0,0,0,0,0,0,0,0,0,0,0,0, ...])
|
||
|
||
- name: map function
|
||
args:
|
||
- -c
|
||
- 'map(..)'
|
||
input: '[{"a":{"b":1}}, [2,3,4]]'
|
||
expected: |
|
||
[{"a":{"b":1}},{"b":1},1,[2,3,4],2,3,4]
|
||
|
||
- name: to_entries function
|
||
args:
|
||
- -c
|
||
- 'to_entries'
|
||
input: |
|
||
[10, 20]
|
||
{"a": 10, "b": []}
|
||
expected: |
|
||
[{"key":0,"value":10},{"key":1,"value":20}]
|
||
[{"key":"a","value":10},{"key":"b","value":[]}]
|
||
|
||
- name: from_entries function
|
||
args:
|
||
- -c
|
||
- 'from_entries'
|
||
input: |
|
||
[]
|
||
[
|
||
{"key":"a","Key":"b","value":1},
|
||
{"Key":"b","Value":2},
|
||
{"key":null,"name":"c","Name":"d","value":3},
|
||
{"name":false,"Name":"d","value":null,"Value":4},
|
||
{"key":"e"}
|
||
]
|
||
expected: |
|
||
{}
|
||
{"a":1,"b":2,"c":3,"d":null,"e":null}
|
||
|
||
- name: from_entries function missing key
|
||
args:
|
||
- 'from_entries'
|
||
input: '[{"value":1}]'
|
||
error: |
|
||
expected a string for object key but got: null
|
||
|
||
- name: from_entries function key type error
|
||
args:
|
||
- 'from_entries'
|
||
input: '[{"key":{},"value":1}]'
|
||
error: |
|
||
expected a string for object key but got: object ({})
|
||
|
||
- name: with_entries function
|
||
args:
|
||
- -c
|
||
- 'with_entries(.key |= "x" + . | .value += 1)'
|
||
input: '{"a": 1, "b": 2}'
|
||
expected: |
|
||
{"xa":2,"xb":3}
|
||
|
||
- name: add/0 function
|
||
args:
|
||
- -c
|
||
- 'add'
|
||
input: |
|
||
[]
|
||
[1,2,3]
|
||
["a","b","c"]
|
||
[[3],[4,5],[6]]
|
||
[{"a":1}, {"b":2}, {"a":3}]
|
||
{}
|
||
{"a":1,"b":9}
|
||
{"a":"a","b":"b","c":"c"}
|
||
{"a":[1],"b":[2],"c":[3],"d":[4]}
|
||
expected: |
|
||
null
|
||
6
|
||
"abc"
|
||
[3,4,5,6]
|
||
{"a":3,"b":2}
|
||
null
|
||
10
|
||
"abc"
|
||
[1,2,3,4]
|
||
|
||
- name: add/0 function with a variable
|
||
args:
|
||
- '. as $x | [$x, {y:1}] | add, $x'
|
||
input: '{"x":0}'
|
||
expected: |
|
||
{
|
||
"x": 0,
|
||
"y": 1
|
||
}
|
||
{
|
||
"x": 0
|
||
}
|
||
|
||
- name: add/0 function with slicing
|
||
args:
|
||
- -c
|
||
- '[.[:2], [0], .[1:]] | add'
|
||
input: '[1,2,3]'
|
||
expected: |
|
||
[1,2,0,2,3]
|
||
|
||
- name: add/0 function error
|
||
args:
|
||
- 'add'
|
||
input: '[{}, [], {}]'
|
||
error: |
|
||
cannot add: object ({}) and array ([])
|
||
|
||
- name: add/0 function error
|
||
args:
|
||
- 'add'
|
||
input: '["x", null, "y", {}, "z"]'
|
||
error: |
|
||
cannot add: string ("xy") and object ({})
|
||
|
||
- name: add/1 function
|
||
args:
|
||
- 'add(.), add(empty), add(1,2,3), add(range(10))'
|
||
input: 'null'
|
||
expected: |
|
||
null
|
||
null
|
||
6
|
||
45
|
||
|
||
- name: add/1 function with iterator
|
||
args:
|
||
- 'add(.[])'
|
||
input: |
|
||
[1,2,3]
|
||
["a","b","c"]
|
||
expected: |
|
||
6
|
||
"abc"
|
||
|
||
- name: add/1 function with update operator
|
||
args:
|
||
- -c
|
||
- '.y = add(.x[])'
|
||
input: |
|
||
{"x":[1,2,3]}
|
||
{"x":["a","b","c"]}
|
||
expected: |
|
||
{"x":[1,2,3],"y":6}
|
||
{"x":["a","b","c"],"y":"abc"}
|
||
|
||
- name: flatten/0 function
|
||
args:
|
||
- -c
|
||
- 'flatten'
|
||
input: |
|
||
[]
|
||
[0, [[[[[1]]]]]]
|
||
[0, [1, [2]], [1, [[3], 2]]]
|
||
{"x": [1], "y": [[2]], "z": [[[3]]]}
|
||
expected: |
|
||
[]
|
||
[0,1]
|
||
[0,1,2,1,3,2]
|
||
[1,2,3]
|
||
|
||
- name: flatten/0 function error
|
||
args:
|
||
- 'flatten, flatten("")'
|
||
input: '0 [[]]'
|
||
expected: |
|
||
[]
|
||
error: |
|
||
flatten cannot be applied to: number (0)
|
||
flatten cannot be applied to: string ("")
|
||
|
||
- name: flatten/1 function
|
||
args:
|
||
- -c
|
||
- 'flatten(0, 1.5, 2)'
|
||
input: |
|
||
[]
|
||
[0, [[[[[1]]]]]]
|
||
[0, [1, [2]], [1, [[3], 2]]]
|
||
{"x": [1], "y": [[2]], "z": [[[3]]]}
|
||
expected: |
|
||
[]
|
||
[]
|
||
[]
|
||
[0,[[[[[1]]]]]]
|
||
[0,1]
|
||
[0,[[[1]]]]
|
||
[0,[1,[2]],[1,[[3],2]]]
|
||
[0,1,2,1,3,2]
|
||
[0,1,2,1,[3],2]
|
||
[[1],[[2]],[[[3]]]]
|
||
[1,2,3]
|
||
[1,2,[3]]
|
||
|
||
- name: flatten/1 function depth error
|
||
args:
|
||
- 'flatten(-1)'
|
||
input: '[]'
|
||
error: |
|
||
flatten depth should not be negative: -1
|
||
|
||
- name: flatten/1 function depth error with nan
|
||
args:
|
||
- 'flatten(nan)'
|
||
input: '[]'
|
||
error: |
|
||
flatten depth should not be negative: null
|
||
|
||
- name: min, min_by, max, max_by functions
|
||
args:
|
||
- -c
|
||
- '[min, min_by(.[1]), min_by(.[2]), max, max_by(.[1]), max_by(.[2])]'
|
||
input: |
|
||
[]
|
||
[[4,2,"a"],[3,1,"a"],[2,4,"a"],[1,3,"a"]]
|
||
expected: |
|
||
[null,null,null,null,null,null]
|
||
[[1,3,"a"],[3,1,"a"],[4,2,"a"],[4,2,"a"],[2,4,"a"],[1,3,"a"]]
|
||
|
||
- name: sort, sort_by, group_by functions
|
||
args:
|
||
- -c
|
||
- 'sort, sort_by(.a), sort_by(.b), sort_by(.b, .c), group_by(.b), group_by(.c, .a), group_by(.a + .b - .c == 2)'
|
||
input: '[{"a": 1, "b": 4, "c": 5}, {"a": 4, "b": 1, "c": 2}, {"a": 1, "b": 4, "c": 3}, {"a": 3, "b": 2, "c": 1}]'
|
||
expected: |
|
||
[{"a":1,"b":4,"c":3},{"a":1,"b":4,"c":5},{"a":3,"b":2,"c":1},{"a":4,"b":1,"c":2}]
|
||
[{"a":1,"b":4,"c":5},{"a":1,"b":4,"c":3},{"a":3,"b":2,"c":1},{"a":4,"b":1,"c":2}]
|
||
[{"a":4,"b":1,"c":2},{"a":3,"b":2,"c":1},{"a":1,"b":4,"c":5},{"a":1,"b":4,"c":3}]
|
||
[{"a":4,"b":1,"c":2},{"a":3,"b":2,"c":1},{"a":1,"b":4,"c":3},{"a":1,"b":4,"c":5}]
|
||
[[{"a":4,"b":1,"c":2}],[{"a":3,"b":2,"c":1}],[{"a":1,"b":4,"c":5},{"a":1,"b":4,"c":3}]]
|
||
[[{"a":3,"b":2,"c":1}],[{"a":4,"b":1,"c":2}],[{"a":1,"b":4,"c":3}],[{"a":1,"b":4,"c":5}]]
|
||
[[{"a":1,"b":4,"c":5},{"a":4,"b":1,"c":2},{"a":3,"b":2,"c":1}],[{"a":1,"b":4,"c":3}]]
|
||
|
||
- name: unique, unique_by functions
|
||
args:
|
||
- -c
|
||
- 'unique, unique_by(length)'
|
||
input: |
|
||
[7,3,5,1,4,2,5,3,6,1,7,4,3]
|
||
["cat", "dog", "hello", "world", "banana", "apple"]
|
||
expected: |
|
||
[1,2,3,4,5,6,7]
|
||
[1,2,3,4,5,6,7]
|
||
["apple","banana","cat","dog","hello","world"]
|
||
["cat","hello","banana"]
|
||
|
||
- name: min, max, sort, unique functions error
|
||
args:
|
||
- 'try min catch ., try max catch ., try sort catch ., try unique catch .'
|
||
input: '0'
|
||
expected: |
|
||
"min cannot be applied to: number (0)"
|
||
"max cannot be applied to: number (0)"
|
||
"sort cannot be applied to: number (0)"
|
||
"unique cannot be applied to: number (0)"
|
||
|
||
- name: arrays, objects, iterables, booleans, numbers, strings, nulls, values, scalars functions
|
||
args:
|
||
- -c
|
||
- 'map(arrays), map(objects), map(iterables), map(booleans), map(numbers), map(strings), map(nulls), map(values), map(scalars)'
|
||
input: '[null, true, false, 0, 1, "", "foo", [], [2, []], {}, { "foo": [] }, 4722366482869645213696]'
|
||
expected: |
|
||
[[],[2,[]]]
|
||
[{},{"foo":[]}]
|
||
[[],[2,[]],{},{"foo":[]}]
|
||
[true,false]
|
||
[0,1,4722366482869645213696]
|
||
["","foo"]
|
||
[null]
|
||
[true,false,0,1,"","foo",[],[2,[]],{},{"foo":[]},4722366482869645213696]
|
||
[null,true,false,0,1,"","foo",4722366482869645213696]
|
||
|
||
- name: recurse/0 function
|
||
args:
|
||
- -c
|
||
- 'recurse'
|
||
input: '{"a":{"b":[1]}}'
|
||
expected: |
|
||
{"a":{"b":[1]}}
|
||
{"b":[1]}
|
||
[1]
|
||
1
|
||
|
||
- name: recurse/1 function
|
||
args:
|
||
- -c
|
||
- 'recurse(.a[])'
|
||
input: '{"a":[{"a": []}, {"a":[{"a":[]}]}]}'
|
||
expected: |
|
||
{"a":[{"a":[]},{"a":[{"a":[]}]}]}
|
||
{"a":[]}
|
||
{"a":[{"a":[]}]}
|
||
{"a":[]}
|
||
|
||
- name: recurse/2 function
|
||
args:
|
||
- -c
|
||
- '[recurse(. + .; . < 1000)]'
|
||
input: '1'
|
||
expected: |
|
||
[1,2,4,8,16,32,64,128,256,512]
|
||
|
||
- name: while function
|
||
args:
|
||
- -c
|
||
- '[while(.[0]<100; [.[1], .[0]+.[1]]) | .[0]]'
|
||
input: '[0, 1]'
|
||
expected: |
|
||
[0,1,1,2,3,5,8,13,21,34,55,89]
|
||
|
||
- name: until function
|
||
args:
|
||
- '[.,1] | until(.[0]==0; [.[0]-1, .[0]*.[1]]) | .[1]'
|
||
input: '20'
|
||
expected: |
|
||
2432902008176640000
|
||
|
||
- name: repeat function
|
||
args:
|
||
- -c
|
||
- '[limit(.; repeat(1,2,3))]'
|
||
input: '10'
|
||
expected: |
|
||
[1,2,3,1,2,3,1,2,3,1]
|
||
|
||
- name: range function
|
||
args:
|
||
- -c
|
||
- '[range(.)], [range(range(.))], [range(3.5)], [range(3; 5)], [range(1.5; 4)],
|
||
[range(-5; -1.5)], [range(3.5; 5.5)], [range(-5.5; -3.5)], [range(0; 10; 3)],
|
||
[range(0; 10; -1)], [range(5; -5; -3)], [range(0.25; 9.5; 2.25)], [range(-5; -9.5; -1)]'
|
||
input: '5'
|
||
expected: |
|
||
[0,1,2,3,4]
|
||
[0,0,1,0,1,2,0,1,2,3]
|
||
[0,1,2,3]
|
||
[3,4]
|
||
[1.5,2.5,3.5]
|
||
[-5,-4,-3,-2]
|
||
[3.5,4.5]
|
||
[-5.5,-4.5]
|
||
[0,3,6,9]
|
||
[]
|
||
[5,2,-1,-4]
|
||
[0.25,2.5,4.75,7,9.25]
|
||
[-5,-6,-7,-8,-9]
|
||
|
||
- name: range function overflow
|
||
args:
|
||
- 'range(9223372036854775700; 9223372036854775805; 10)'
|
||
input: 'null'
|
||
expected: |
|
||
9223372036854775700
|
||
9223372036854775710
|
||
9223372036854775720
|
||
9223372036854775730
|
||
9223372036854775740
|
||
9223372036854775750
|
||
9223372036854775760
|
||
9223372036854775770
|
||
9223372036854775780
|
||
9223372036854775790
|
||
9223372036854775800
|
||
|
||
- name: range function with large numbers
|
||
args:
|
||
- 'range(0; 20000000000000000000; 2000000000000000000)'
|
||
input: 'null'
|
||
expected: |
|
||
0
|
||
2000000000000000000
|
||
4000000000000000000
|
||
6000000000000000000
|
||
8000000000000000000
|
||
10000000000000000000
|
||
12000000000000000000
|
||
14000000000000000000
|
||
16000000000000000000
|
||
18000000000000000000
|
||
|
||
- name: range function with iterators in arguments
|
||
args:
|
||
- -c
|
||
- '[range(-.; .+1)] | [range(.[]; .[]; .[])] | recurse(.[26:];.[0])[:26] | map(.+3)'
|
||
input: '3'
|
||
expected: |
|
||
[0,0,0,0,1,0,0,0,1,2,0,2,0,0,1,2,3,0,2,0,3,0,1,2,3,4]
|
||
[0,2,4,0,3,0,1,2,3,4,5,0,2,4,0,3,1,1,1,1,1,1,1,2,1,1]
|
||
[1,2,3,1,3,1,1,2,3,4,1,3,1,4,1,2,3,4,5,1,3,5,1,4,2,2]
|
||
[2,1,2,2,2,2,2,2,2,3,2,2,2,3,4,2,4,2,2,3,4,5,2,4,2,5]
|
||
[3,3,1,3,2,1,3,3,3,2,3,3,3,3,3,3,3,4,3,3,3,4,5,3,5,3]
|
||
[4,1,4,2,4,3,2,1,4,4,2,4,3,2,4,4,4,3,4,4,4,4,4,4,4,5]
|
||
[4,4,5,2,5,3,1,5,4,3,2,1,5,2,5,3,5,4,3,2,5,5,3,5,4,3]
|
||
[5,5,5,4,5,5,5,5,5,5,6,3,6,4,2,6,5,4,3,2,1,6,3,6,4,2]
|
||
[6,5,4,3,2,6,3,6,4,6,5,4,3,6,6,4,6,5,4,6,6,6,5,6,6,6]
|
||
|
||
- name: range function error
|
||
args:
|
||
- '(null, "", [], {} | try range(.) catch .), try range(""; 0) catch ., try range(0; 1; []) catch .'
|
||
input: 'null'
|
||
expected: |
|
||
"range cannot be applied to: null"
|
||
"range cannot be applied to: string (\"\")"
|
||
"range cannot be applied to: array ([])"
|
||
"range cannot be applied to: object ({})"
|
||
"range cannot be applied to: string (\"\")"
|
||
"range cannot be applied to: array ([])"
|
||
|
||
- name: toboolean function
|
||
args:
|
||
- 'toboolean'
|
||
input: |
|
||
"true"
|
||
"false"
|
||
true
|
||
false
|
||
expected: |
|
||
true
|
||
false
|
||
true
|
||
false
|
||
|
||
- name: toboolean function error
|
||
args:
|
||
- 'try toboolean catch .'
|
||
input: |
|
||
null
|
||
""
|
||
" true "
|
||
"FALSE"
|
||
[]
|
||
{}
|
||
expected: |
|
||
"toboolean cannot be applied to: null"
|
||
"toboolean cannot be applied to \"\": invalid boolean"
|
||
"toboolean cannot be applied to \" true \": invalid boolean"
|
||
"toboolean cannot be applied to \"FALSE\": invalid boolean"
|
||
"toboolean cannot be applied to: array ([])"
|
||
"toboolean cannot be applied to: object ({})"
|
||
|
||
- name: tonumber function
|
||
args:
|
||
- 'tonumber'
|
||
input: |
|
||
"0"
|
||
"12345"
|
||
"-43210"
|
||
"10000000000000000000"
|
||
"-10000000000000000000"
|
||
"+4.2"
|
||
"05"
|
||
"9."
|
||
"+.123"
|
||
"-.1"
|
||
"1e-2"
|
||
"2.e-2"
|
||
"1e300"
|
||
"-1e300"
|
||
"1e1000"
|
||
"-1e1000"
|
||
3.14
|
||
expected: |
|
||
0
|
||
12345
|
||
-43210
|
||
10000000000000000000
|
||
-10000000000000000000
|
||
4.2
|
||
5
|
||
9
|
||
0.123
|
||
-0.1
|
||
0.01
|
||
0.02
|
||
1e+300
|
||
-1e+300
|
||
1.7976931348623157e+308
|
||
-1.7976931348623157e+308
|
||
3.14
|
||
|
||
- name: tonumber function error
|
||
args:
|
||
- 'try tonumber catch .'
|
||
input: |
|
||
""
|
||
"."
|
||
" "
|
||
"1a"
|
||
".e1"
|
||
"-.e"
|
||
expected: |
|
||
"tonumber cannot be applied to \"\": invalid number"
|
||
"tonumber cannot be applied to \".\": invalid number"
|
||
"tonumber cannot be applied to \" \": invalid number"
|
||
"tonumber cannot be applied to \"1a\": invalid number"
|
||
"tonumber cannot be applied to \".e1\": invalid number"
|
||
"tonumber cannot be applied to \"-.e\": invalid number"
|
||
|
||
- name: tostring function
|
||
args:
|
||
- 'tostring'
|
||
input: |
|
||
null
|
||
false
|
||
true
|
||
3.14
|
||
"foo bar"
|
||
{"foo": "-43210"}
|
||
[1,2,3]
|
||
["<&><>"]
|
||
expected: |
|
||
"null"
|
||
"false"
|
||
"true"
|
||
"3.14"
|
||
"foo bar"
|
||
"{\"foo\":\"-43210\"}"
|
||
"[1,2,3]"
|
||
"[\"<&><>\"]"
|
||
|
||
- name: type function
|
||
args:
|
||
- 'type'
|
||
input: |
|
||
null
|
||
false
|
||
true
|
||
0
|
||
3.14
|
||
4722366482869645213696
|
||
"foo"
|
||
[]
|
||
{}
|
||
expected: |
|
||
"null"
|
||
"boolean"
|
||
"boolean"
|
||
"number"
|
||
"number"
|
||
"number"
|
||
"string"
|
||
"array"
|
||
"object"
|
||
|
||
- name: reverse function
|
||
args:
|
||
- 'reverse'
|
||
input: '[0, 1, 2, 3, 4]'
|
||
expected: |
|
||
[
|
||
4,
|
||
3,
|
||
2,
|
||
1,
|
||
0
|
||
]
|
||
|
||
- name: contains function
|
||
args:
|
||
- -c
|
||
- '.[] as $x | (null,false,true,[],[3,4],[3,1],"foo","ll",{},{"a":1},{"a":""},{"b":[5]},{"a":3,"b":[5]}) as $y | $x | [$x,$y,contains($y)]?'
|
||
input: '[null,false,true,[],[1,2,3],"","hello",{"a":3,"b":[4,5,6]}]'
|
||
expected: |
|
||
[null,null,true]
|
||
[false,false,true]
|
||
[true,true,true]
|
||
[[],[],true]
|
||
[[],[3,4],false]
|
||
[[],[3,1],false]
|
||
[[1,2,3],[],true]
|
||
[[1,2,3],[3,4],false]
|
||
[[1,2,3],[3,1],true]
|
||
["","foo",false]
|
||
["","ll",false]
|
||
["hello","foo",false]
|
||
["hello","ll",true]
|
||
[{"a":3,"b":[4,5,6]},{},true]
|
||
[{"a":3,"b":[4,5,6]},{"a":1},false]
|
||
[{"a":3,"b":[4,5,6]},{"a":""},false]
|
||
[{"a":3,"b":[4,5,6]},{"b":[5]},true]
|
||
[{"a":3,"b":[4,5,6]},{"a":3,"b":[5]},true]
|
||
|
||
- name: contains function against unicode strings
|
||
args:
|
||
- -c
|
||
- '. as $x | ("@", "\u0000@", "\u0000dc", "b\u0000c", "b\u0000cd", "b\u0000cd") as $y | $x | [$x,$y,contains($y)]'
|
||
input: '"ab\u0000cd"'
|
||
expected: |
|
||
["ab\u0000cd","@",false]
|
||
["ab\u0000cd","\u0000@",false]
|
||
["ab\u0000cd","\u0000dc",false]
|
||
["ab\u0000cd","b\u0000c",true]
|
||
["ab\u0000cd","b\u0000cd",true]
|
||
["ab\u0000cd","b\u0000cd",true]
|
||
|
||
- name: contains function error
|
||
args:
|
||
- 'nan | contains([nan])'
|
||
input: '0'
|
||
error: |
|
||
contains([null]) cannot be applied to: number (null)
|
||
|
||
- name: indices, index, rindex functions against null
|
||
args:
|
||
- 'indices(0), index(0), rindex(0)'
|
||
input: 'null'
|
||
expected: |
|
||
null
|
||
null
|
||
null
|
||
|
||
- name: indices, index, rindex functions against array
|
||
args:
|
||
- -c
|
||
- '[indices(0, 1, [1, 2, 1])], [index(0, 1, [1, 2])], [rindex(0, 1, [1, 2])]'
|
||
input: |
|
||
[]
|
||
[0]
|
||
[0, 1, 2, 1, 2, 1, 0, 1, 0]
|
||
expected: |
|
||
[[],[],[]]
|
||
[null,null,null]
|
||
[null,null,null]
|
||
[[0],[],[]]
|
||
[0,null,null]
|
||
[0,null,null]
|
||
[[0,6,8],[1,3,5,7],[1,3]]
|
||
[0,1,1]
|
||
[8,7,3]
|
||
|
||
- name: indices, index, rindex functions against string
|
||
args:
|
||
- -c
|
||
- '[indices("", ",", "x")], [index("", ",", "x")], [rindex("", ",", "x")]'
|
||
input: '"a,bc,def,ghij,klmno"'
|
||
expected: |
|
||
[[],[1,4,8,13],[]]
|
||
[null,1,null]
|
||
[null,13,null]
|
||
|
||
- name: indices, index, rindex functions against multibyte string
|
||
args:
|
||
- -c
|
||
- '[indices("０", "１", "３４")], [index("０", "１", "３４")], [rindex("０", "１", "３４")]'
|
||
input: '"０１２３４０"'
|
||
expected: |
|
||
[[0,5],[1],[3]]
|
||
[0,1,3]
|
||
[5,1,3]
|
||
|
||
- name: indices, index, rindex functions type error
|
||
args:
|
||
- '(try indices([]) catch .), (try index([]) catch .), (try rindex([]) catch .)'
|
||
input: '{}'
|
||
expected: |
|
||
"indices([]) cannot be applied to: object ({})"
|
||
"index([]) cannot be applied to: object ({})"
|
||
"rindex([]) cannot be applied to: object ({})"
|
||
|
||
- name: inside function
|
||
args:
|
||
- -c
|
||
- '.[] as $x | (false,"abc",[],["foobaz","foobar"],{},{"a":10,"b":20,"c":30}) as $y | $x | [$x,$y,inside($y)]?'
|
||
input: '["a",["bar","baz"],{"a":10,"b":20}]'
|
||
expected: |
|
||
["a","abc",true]
|
||
[["bar","baz"],[],false]
|
||
[["bar","baz"],["foobaz","foobar"],true]
|
||
[{"a":10,"b":20},{},false]
|
||
[{"a":10,"b":20},{"a":10,"b":20,"c":30},true]
|
||
|
||
- name: startswith function
|
||
args:
|
||
- 'startswith("foo")'
|
||
input: |
|
||
""
|
||
"fo"
|
||
"foo"
|
||
"fooo"
|
||
"barfoo"
|
||
expected: |
|
||
false
|
||
false
|
||
true
|
||
true
|
||
false
|
||
|
||
- name: startswith function error
|
||
args:
|
||
- '("x" | try startswith({}) catch .), (10 | try startswith("x") catch .)'
|
||
input: '0'
|
||
expected: |
|
||
"startswith({}) cannot be applied to: string (\"x\")"
|
||
"startswith(\"x\") cannot be applied to: number (10)"
|
||
|
||
- name: endswith function
|
||
args:
|
||
- 'endswith("foo")'
|
||
input: |
|
||
""
|
||
"fo"
|
||
"foo"
|
||
"fooo"
|
||
"barfoo"
|
||
expected: |
|
||
false
|
||
false
|
||
true
|
||
false
|
||
true
|
||
|
||
- name: endswith function error
|
||
args:
|
||
- '("x" | try endswith({}) catch .), (10 | try endswith("x") catch .)'
|
||
input: '0'
|
||
expected: |
|
||
"endswith({}) cannot be applied to: string (\"x\")"
|
||
"endswith(\"x\") cannot be applied to: number (10)"
|
||
|
||
- name: combinations/0 function
|
||
args:
|
||
- -c
|
||
- '[combinations]'
|
||
input: '[] [[0]] [[1, 2, 3], [4, 5, 6]]'
|
||
expected: |
|
||
[[]]
|
||
[[0]]
|
||
[[1,4],[1,5],[1,6],[2,4],[2,5],[2,6],[3,4],[3,5],[3,6]]
|
||
|
||
- name: combinations/1 function
|
||
args:
|
||
- -c
|
||
- '[combinations(3)]'
|
||
input: '[] [0] [1, 2]'
|
||
expected: |
|
||
[]
|
||
[[0,0,0]]
|
||
[[1,1,1],[1,1,2],[1,2,1],[1,2,2],[2,1,1],[2,1,2],[2,2,1],[2,2,2]]
|
||
|
||
- name: ltrimstr function
|
||
args:
|
||
- 'ltrimstr("foo")'
|
||
input: |
|
||
""
|
||
"fo"
|
||
"foo"
|
||
"fooo"
|
||
"barfoo"
|
||
expected: |
|
||
""
|
||
"fo"
|
||
""
|
||
"o"
|
||
"barfoo"
|
||
|
||
- name: ltrimstr function error
|
||
args:
|
||
- '("x" | try ltrimstr({}) catch .), (10 | try ltrimstr("x") catch .)'
|
||
input: '0'
|
||
expected: |
|
||
"ltrimstr({}) cannot be applied to: string (\"x\")"
|
||
"ltrimstr(\"x\") cannot be applied to: number (10)"
|
||
|
||
- name: rtrimstr function
|
||
args:
|
||
- 'rtrimstr("foo")'
|
||
input: |
|
||
""
|
||
"fo"
|
||
"foo"
|
||
"fooo"
|
||
"barfoo"
|
||
expected: |
|
||
""
|
||
"fo"
|
||
""
|
||
"fooo"
|
||
"bar"
|
||
|
||
- name: rtrimstr function error
|
||
args:
|
||
- '("x" | try rtrimstr({}) catch .), (10 | try rtrimstr("x") catch .)'
|
||
input: '0'
|
||
expected: |
|
||
"rtrimstr({}) cannot be applied to: string (\"x\")"
|
||
"rtrimstr(\"x\") cannot be applied to: number (10)"
|
||
|
||
- name: trimstr function
|
||
args:
|
||
- 'trimstr("foo")'
|
||
input: |
|
||
""
|
||
"fo"
|
||
"foo"
|
||
"fofoo"
|
||
"foobarfoo"
|
||
"foofoofoo"
|
||
expected: |
|
||
""
|
||
"fo"
|
||
""
|
||
"fo"
|
||
"bar"
|
||
"foo"
|
||
|
||
- name: trimstr function error
|
||
args:
|
||
- '("x" | try trimstr({}) catch .), (10 | try trimstr("x") catch .)'
|
||
input: '0'
|
||
expected: |
|
||
"trimstr({}) cannot be applied to: string (\"x\")"
|
||
"trimstr(\"x\") cannot be applied to: number (10)"
|
||
|
||
- name: ltrim function
|
||
args:
|
||
- 'ltrim'
|
||
input: |
|
||
""
|
||
" \tfoo\n "
|
||
"\t\u000b\u000c\u0085\u00a0f\ro\no\u2000\u2001\u200a\u3000"
|
||
expected: "\"\"\n\"foo\\n \"\n\"f\\ro\\no\u2000\u2001\u200a\u3000\"\n"
|
||
|
||
- name: ltrim function error
|
||
args:
|
||
- 'try ltrim catch .'
|
||
input: '0 [] {}'
|
||
expected: |
|
||
"ltrim cannot be applied to: number (0)"
|
||
"ltrim cannot be applied to: array ([])"
|
||
"ltrim cannot be applied to: object ({})"
|
||
|
||
- name: rtrim function
|
||
args:
|
||
- 'rtrim'
|
||
input: |
|
||
""
|
||
" \tfoo\n "
|
||
"\t\u000b\u000c\u0085\u00a0f\ro\no\u2000\u2001\u200a\u3000"
|
||
expected: "\"\"\n\" \\tfoo\"\n\"\\t\\u000b\\f\u0085\u00a0f\\ro\\no\"\n"
|
||
|
||
- name: rtrim function error
|
||
args:
|
||
- 'try rtrim catch .'
|
||
input: '0 [] {}'
|
||
expected: |
|
||
"rtrim cannot be applied to: number (0)"
|
||
"rtrim cannot be applied to: array ([])"
|
||
"rtrim cannot be applied to: object ({})"
|
||
|
||
- name: trim function
|
||
args:
|
||
- 'trim'
|
||
input: |
|
||
""
|
||
" \tfoo\n "
|
||
"\t\u000b\u000c\u0085\u00a0f\ro\no\u2000\u2001\u200a\u3000"
|
||
expected: |
|
||
""
|
||
"foo"
|
||
"f\ro\no"
|
||
|
||
- name: trim function error
|
||
args:
|
||
- 'try trim catch .'
|
||
input: '0 [] {}'
|
||
expected: |
|
||
"trim cannot be applied to: number (0)"
|
||
"trim cannot be applied to: array ([])"
|
||
"trim cannot be applied to: object ({})"
|
||
|
||
- name: explode function
|
||
args:
|
||
- -c
|
||
- 'explode'
|
||
input: |
|
||
""
|
||
"foo bar"
|
||
"１２３４５"
|
||
"\n\t"
|
||
expected: |
|
||
[]
|
||
[102,111,111,32,98,97,114]
|
||
[65297,65298,65299,65300,65301]
|
||
[10,9]
|
||
|
||
- name: implode function
|
||
args:
|
||
- 'implode'
|
||
input: |
|
||
[]
|
||
[102,111,111,32,98,97,114]
|
||
[65297,65298,65299,65300,65301]
|
||
[10,9]
|
||
expected: |
|
||
""
|
||
"foo bar"
|
||
"１２３４５"
|
||
"\n\t"
|
||
|
||
- name: implode function replacement character
|
||
args:
|
||
- 'implode'
|
||
input: '[-1,0,1114111,1114112]'
|
||
expected: "\"\ufffd\\u0000\U0010ffff\ufffd\"\n"
|
||
|
||
- name: implode function error
|
||
args:
|
||
- 'try implode catch .'
|
||
input: '[[]] [{}]'
|
||
expected: |
|
||
"implode cannot be applied to: array ([[]])"
|
||
"implode cannot be applied to: array ([{}])"
|
||
|
||
- name: split/1 function
|
||
args:
|
||
- 'split(", ","") | join("/")'
|
||
input: |
|
||
"a,b, c, d, e,f"
|
||
", a,b, c, d, e,f, "
|
||
expected: |
|
||
"a,b/c/d/e,f"
|
||
"a/,/b/,/ /c/,/ /d/,/ /e/,/f"
|
||
"/a,b/c/d/e,f/"
|
||
",/ /a/,/b/,/ /c/,/ /d/,/ /e/,/f/,/ "
|
||
|
||
- name: split/1 function against empty string
|
||
args:
|
||
- -c
|
||
- '.[] as $t | .[] as $s | $s | split($t)'
|
||
input: '["abc", "a", "b", ""]'
|
||
expected: |
|
||
["",""]
|
||
["a"]
|
||
["b"]
|
||
[]
|
||
["","bc"]
|
||
["",""]
|
||
["b"]
|
||
[]
|
||
["a","c"]
|
||
["a"]
|
||
["",""]
|
||
[]
|
||
["a","b","c"]
|
||
["a"]
|
||
["b"]
|
||
[]
|
||
|
||
- name: split/1 function error
|
||
args:
|
||
- -c
|
||
- 'try split(",") catch ., try split(1) catch .'
|
||
input: '1 "a"'
|
||
expected: |
|
||
"split(\",\") cannot be applied to: number (1)"
|
||
"split(1) cannot be applied to: number (1)"
|
||
["a"]
|
||
"split(1) cannot be applied to: string (\"a\")"
|
||
|
||
- name: join function
|
||
args:
|
||
- 'join(",")'
|
||
input: '[null, false, true, 0, 1, "", "a", "b", "abc"]'
|
||
expected: |
|
||
",false,true,0,1,,a,b,abc"
|
||
|
||
- name: join function with iterator argument
|
||
args:
|
||
- '. / "" | join(.[])'
|
||
input: '"abcde"'
|
||
expected: |
|
||
"aabacadae"
|
||
"abbbcbdbe"
|
||
"acbcccdce"
|
||
"adbdcddde"
|
||
"aebecedee"
|
||
|
||
- name: join object
|
||
args:
|
||
- 'join(",")'
|
||
input: '{"a": null, "b": false, "c": true, "d": 0, "e": 1, "f": "", "g": "a", "h": "b", "i": "abc"}'
|
||
expected: |
|
||
",false,true,0,1,,a,b,abc"
|
||
|
||
- name: join function error item
|
||
args:
|
||
- 'try join(",") catch .'
|
||
input: '["1","2",[3,4,5]] [[]] [{}]'
|
||
expected: |
|
||
"cannot add: string (\"1,2,\") and array ([3,4,5])"
|
||
"cannot add: string (\"\") and array ([])"
|
||
"cannot add: string (\"\") and object ({})"
|
||
|
||
- name: join function error input
|
||
args:
|
||
- '.[] | try join(",") catch .'
|
||
input: '[null, false, true, 1, "a"]'
|
||
expected: |
|
||
"join(\",\") cannot be applied to: null"
|
||
"join(\",\") cannot be applied to: boolean (false)"
|
||
"join(\",\") cannot be applied to: boolean (true)"
|
||
"join(\",\") cannot be applied to: number (1)"
|
||
"join(\",\") cannot be applied to: string (\"a\")"
|
||
|
||
- name: join function null separator
|
||
args:
|
||
- 'join(null)'
|
||
input: '[] ["a"] ["a","b","c"] ["a",null,"b"] [null,null,null] [null]'
|
||
expected: |
|
||
""
|
||
"a"
|
||
"abc"
|
||
"ab"
|
||
""
|
||
""
|
||
|
||
- name: join function null elements
|
||
args:
|
||
- 'join(",")'
|
||
input: '[null] [null,null,null] ["a",null,"b"]'
|
||
expected: |
|
||
""
|
||
",,"
|
||
"a,,b"
|
||
|
||
- name: join function non-string separator
|
||
args:
|
||
- '.[] | try join(1) catch .'
|
||
input: '[[],[1],[1,2]]'
|
||
expected: |
|
||
""
|
||
"1"
|
||
"cannot add: string (\"1\") and number (1)"
|
||
|
||
- name: ascii_downcase function
|
||
args:
|
||
- 'ascii_downcase'
|
||
input: '"@ABC XYZ[] `abc xyz{} Αα"'
|
||
expected: |
|
||
"@abc xyz[] `abc xyz{} Αα"
|
||
|
||
- name: ascii_upcase function
|
||
args:
|
||
- 'ascii_upcase'
|
||
input: '"@ABC XYZ[] `abc xyz{} Αα"'
|
||
expected: |
|
||
"@ABC XYZ[] `ABC XYZ{} Αα"
|
||
|
||
- name: walk function
|
||
args:
|
||
- -c
|
||
- 'walk(if type == "boolean" then not else . + . end) | .[]'
|
||
input: '[1, ["a", {"b": []}], {"c": [null, false, true]}]'
|
||
expected: |
|
||
2
|
||
["aa",{"b":[]},"aa",{"b":[]}]
|
||
{"c":[null,true,false,null,true,false]}
|
||
2
|
||
["aa",{"b":[]},"aa",{"b":[]}]
|
||
{"c":[null,true,false,null,true,false]}
|
||
|
||
- name: walk function with multiple values
|
||
args:
|
||
- -c
|
||
- 'walk(.,0)'
|
||
input: '[1,2,3] {"x":1,"y":2,"z":3}'
|
||
expected: |
|
||
[1,0,2,0,3,0]
|
||
0
|
||
{"x":1,"y":2,"z":3}
|
||
0
|
||
|
||
- name: transpose function
|
||
args:
|
||
- -c
|
||
- 'transpose'
|
||
input: |
|
||
[]
|
||
[[1,2,3,[]],[4,"foo",{}],[5,6]]
|
||
expected: |
|
||
[]
|
||
[[1,4,5],[2,"foo",6],[3,{},null],[[],null,null]]
|
||
|
||
- name: function not defined
|
||
args:
|
||
- 'abc'
|
||
input: '{}'
|
||
error: |
|
||
function not defined: abc/0
|
||
exit_code: 3
|
||
|
||
- name: variable not defined
|
||
args:
|
||
- '$abc'
|
||
input: '{}'
|
||
error: |
|
||
variable not defined: $abc
|
||
exit_code: 3
|
||
|
||
- name: argument count error
|
||
args:
|
||
- 'map(.;.)'
|
||
input: '{}'
|
||
error: |
|
||
function not defined: map/2
|
||
exit_code: 3
|
||
|
||
- name: function declaration with an argument
|
||
args:
|
||
- 'def f(g): g | g; f(..)'
|
||
input: '[0, 1]'
|
||
expected: |
|
||
[
|
||
0,
|
||
1
|
||
]
|
||
0
|
||
1
|
||
0
|
||
1
|
||
|
||
- name: function nested declaration
|
||
args:
|
||
- -c
|
||
- 'def f: def g: .; g; f'
|
||
input: '[0, 1]'
|
||
expected: |
|
||
[0,1]
|
||
|
||
- name: function declaration with call of another declared function
|
||
args:
|
||
- -c
|
||
- 'def f: .,.; def g: [f,f]; f,g'
|
||
input: '[0, 1]'
|
||
expected: |
|
||
[0,1]
|
||
[0,1]
|
||
[[0,1],[0,1],[0,1],[0,1]]
|
||
|
||
- name: function declaration with update operator
|
||
args:
|
||
- -c
|
||
- 'def f: def f($x): .; f(.x) | .x; f += f'
|
||
input: '{"x": 1}'
|
||
expected: |
|
||
{"x":2}
|
||
|
||
- name: function declaration and recursive call
|
||
args:
|
||
- 'def f(g): if type == "array" then map(f(g * 2)) else g end; f(.)'
|
||
input: '[[[1,2]]]'
|
||
expected: |
|
||
[
|
||
[
|
||
[
|
||
8,
|
||
16
|
||
]
|
||
]
|
||
]
|
||
|
||
- name: function declaration and recursive call
|
||
args:
|
||
- 'def f(g): if . < 1000 then .,(g|f(g|g)) else g end; f(.*2)'
|
||
input: '1'
|
||
expected: |
|
||
1
|
||
2
|
||
8
|
||
128
|
||
2147483648
|
||
|
||
- name: function declaration and recursive call
|
||
args:
|
||
- 'def f: . as $x | $x, ($x + 1 | f); last(limit(100000; f))'
|
||
input: '0'
|
||
expected: |
|
||
99999
|
||
|
||
- name: function declaration and recursive call
|
||
args:
|
||
- 'def f: . as $x | $x, (if $x < 3 then $x + 1 | f else empty end), $x; f'
|
||
input: '0'
|
||
expected: |
|
||
0
|
||
1
|
||
2
|
||
3
|
||
3
|
||
2
|
||
1
|
||
0
|
||
|
||
- name: function declaration and recursive call
|
||
args:
|
||
- 'def f: ., if . < 2 then . + (1,2) | f else empty end; f'
|
||
input: '0'
|
||
expected: |
|
||
0
|
||
1
|
||
2
|
||
3
|
||
2
|
||
|
||
- name: function declaration and recursive call
|
||
args:
|
||
- '100000 as $x | def f: if . == $x then . else . + 1 | f end; f'
|
||
input: '0'
|
||
expected: |
|
||
100000
|
||
|
||
- name: function declaration and recursive call
|
||
args:
|
||
- 'def f: if .a then .a | f end; {}, {a:{}} | f | .,0'
|
||
input: '0'
|
||
expected: |
|
||
{}
|
||
0
|
||
{}
|
||
0
|
||
|
||
- name: function declaration with duplicate function names
|
||
args:
|
||
- 'def f(g): def f: def g: 3; g * 2; g * f; def f: . * 5; f(f)'
|
||
input: '1'
|
||
expected: |
|
||
30
|
||
|
||
- name: function declaration with duplicate function names
|
||
args:
|
||
- '(def f(g): def g: 1; g; f(2)), (def g: 3; def f(g): g; f(4))'
|
||
input: '0'
|
||
expected: |
|
||
1
|
||
4
|
||
|
||
- name: function declaration with duplicate argument names
|
||
args:
|
||
- 'def f(g;g): g; f(1;2)'
|
||
input: 'null'
|
||
expected: |
|
||
2
|
||
|
||
- name: function declaration with duplicate variable names
|
||
args:
|
||
- 'def f($g;$g): $g; f(1;2,3)'
|
||
input: 'null'
|
||
expected: |
|
||
2
|
||
3
|
||
|
||
- name: function declaration with builtin function name conflict
|
||
args:
|
||
- 'def empty: . % 2; range(5) | select(empty > 0)'
|
||
input: 'null'
|
||
expected: |
|
||
1
|
||
3
|
||
|
||
- name: function declaration with builtin function name conflict
|
||
args:
|
||
- 'def select(f): f; null, 0 | numbers, select(.)'
|
||
input: 'null'
|
||
expected: |
|
||
null
|
||
0
|
||
0
|
||
|
||
- name: function declaration with argument name conflict
|
||
args:
|
||
- 'def update: .[1:]; [range(3)] | while(length>0; update)'
|
||
input: 'null'
|
||
expected: |
|
||
[
|
||
0,
|
||
1,
|
||
2
|
||
]
|
||
[
|
||
1,
|
||
2
|
||
]
|
||
[
|
||
2
|
||
]
|
||
|
||
- name: function declaration with argument name conflict
|
||
args:
|
||
- 'def f($keys): with_entries(.key *= $keys); {x: 1} | f(3)'
|
||
input: 'null'
|
||
expected: |
|
||
{
|
||
"xxx": 1
|
||
}
|
||
|
||
- name: function declaration with mixed argument types
|
||
args:
|
||
- -c
|
||
- 'def f0( a; b; c): a*100 + b*10 + c;
|
||
def f1( a;$b; c): a*100 + $b*10 + c;
|
||
def f2($a; b;$c): $a*100 + b*10 + $c;
|
||
def f3($a;$b;$c): $a*100 + $b*10 + $c;
|
||
[f0(.[];.[];.[])], [f1(.[];.[];.[])], [f2(.[];.[];.[])], [f3(.[];.[];.[])]'
|
||
input: '[1,2]'
|
||
expected: |
|
||
[111,211,121,221,112,212,122,222]
|
||
[111,211,112,212,121,221,122,222]
|
||
[111,121,112,122,211,221,212,222]
|
||
[111,112,121,122,211,212,221,222]
|
||
|
||
- name: function declaration with function reference to value argument
|
||
args:
|
||
- -c
|
||
- 'def f($x; $y): [$x, x, $y, y]; f(1,2; 3,4)'
|
||
input: 'null'
|
||
expected: |
|
||
[1,1,2,3,3,4]
|
||
[1,1,2,4,3,4]
|
||
[2,1,2,3,3,4]
|
||
[2,1,2,4,3,4]
|
||
|
||
- name: function declaration inside query
|
||
args:
|
||
- -c
|
||
- '[0, def f: 1, def g: 2; g, 3 as $x | def h: $x + 1; h * g; f, f + 1, 5]'
|
||
input: 'null'
|
||
expected: |
|
||
[0,1,2,8,2,3,9,5]
|
||
|
||
- name: argument count error for custom function
|
||
args:
|
||
- 'def f(g): g | g; f'
|
||
input: '{}'
|
||
error: |
|
||
function not defined: f/0
|
||
exit_code: 3
|
||
|
||
- name: function declaration name error
|
||
args:
|
||
- 'def $f: .; $f'
|
||
input: 'null'
|
||
error: |
|
||
invalid query: def $f: .; $f
|
||
def $f: .; $f
|
||
^ unexpected token "$f"
|
||
exit_code: 3
|
||
|
||
- name: function declaration without query
|
||
args:
|
||
- 'def f: 0;'
|
||
error: |
|
||
compile error: missing query (try ".")
|
||
exit_code: 3
|
||
|
||
- name: add, subtract, multiply, divide, modulo numbers
|
||
args:
|
||
- -c
|
||
- '[.[] + .[]], [.[] - .[]], [.[] * .[]], [.[] / .[]], [.[] % .[]]'
|
||
input: '[-1, 5, 16]'
|
||
expected: |
|
||
[-2,4,15,4,10,21,15,21,32]
|
||
[0,6,17,-6,0,11,-17,-11,0]
|
||
[1,-5,-16,-5,25,80,-16,80,256]
|
||
[1,-5,-16,-0.2,1,3.2,-0.0625,0.3125,1]
|
||
[0,0,0,-1,0,1,-1,5,0]
|
||
|
||
- name: add, subtract, multiply, divide, modulo large numbers
|
||
args:
|
||
- -c
|
||
- '[.[] + .[]], [.[] - .[]], [.[] * .[]], [.[] / .[]], [.[] % .[]]'
|
||
input: '[-1, 47, 9223372036854775807, 557702036893939360447070208]'
|
||
expected: |
|
||
[-2,46,9223372036854775806,557702036893939360447070207,46,94,9223372036854775854,557702036893939360447070255,9223372036854775806,9223372036854775854,18446744073709551614,557702046117311397301846015,557702036893939360447070207,557702036893939360447070255,557702046117311397301846015,1115404073787878720894140416]
|
||
[0,48,9223372036854775808,557702036893939360447070209,-48,0,9223372036854775760,557702036893939360447070161,-9223372036854775808,-9223372036854775760,0,557702027670567323592294401,-557702036893939360447070209,-557702036893939360447070161,-557702027670567323592294401,0]
|
||
[1,-47,-9223372036854775807,-557702036893939360447070208,-47,2209,433498485732174462929,26211995734015149941012299776,-9223372036854775807,433498485732174462929,85070591730234615847396907784232501249,5143893371984510803678792604831111805828857856,-557702036893939360447070208,26211995734015149941012299776,5143893371984510803678792604831111805828857856,311031561955648899562865430629603887429045530881163264]
|
||
[1,-47,-9223372036854775807,-557702036893939360447070208,-0.02127659574468085,1,196241958230952670,1.1866000784977433e+25,-1.0842021724855044e-19,5.095750210681871e-18,1,60466176,-1.7930721672981344e-27,8.427439186301232e-26,1.65381716879202e-8,1]
|
||
[0,0,0,0,-1,0,35,37,-1,47,0,60466176,-1,47,9223372036854775807,0]
|
||
|
||
- name: add, subtract, multiply, divide, modulo operators precedence
|
||
args:
|
||
- -c
|
||
- '[.[] + .[] % .[] * .[] - .[] / .[] % .[] + .[]] | while(length>0; .[32:])[:32]'
|
||
input: '[3, 7]'
|
||
expected: |
|
||
[5,9,8,12,14,18,5,9,5,9,12,16,26,30,5,9,4,8,7,11,13,17,4,8,4,8,11,15,25,29,4,8]
|
||
[6,10,9,13,15,19,6,10,6,10,13,17,27,31,6,10,5,9,8,12,14,18,5,9,5,9,12,16,26,30,5,9]
|
||
[5,9,8,12,14,18,5,9,5,9,12,16,26,30,5,9,4,8,7,11,13,17,4,8,4,8,11,15,25,29,4,8]
|
||
[6,10,9,13,15,19,6,10,6,10,13,17,27,31,6,10,5,9,8,12,14,18,5,9,5,9,12,16,26,30,5,9]
|
||
[9,13,12,16,18,22,9,13,9,13,16,20,30,34,9,13,8,12,11,15,17,21,8,12,8,12,15,19,29,33,8,12]
|
||
[10,14,13,17,19,23,10,14,10,14,17,21,31,35,10,14,9,13,12,16,18,22,9,13,9,13,16,20,30,34,9,13]
|
||
[9,13,12,16,18,22,9,13,9,13,16,20,30,34,9,13,8,12,11,15,17,21,8,12,8,12,15,19,29,33,8,12]
|
||
[10,14,13,17,19,23,10,14,10,14,17,21,31,35,10,14,9,13,12,16,18,22,9,13,9,13,16,20,30,34,9,13]
|
||
|
||
- name: negate, multiply, divide, modulo minimum integer
|
||
args:
|
||
- -c
|
||
- '(-9223372036854775807-1) | -., .*-1, -1*., ./-1, .%-1'
|
||
input: 'null'
|
||
expected: |
|
||
9223372036854775808
|
||
9223372036854775808
|
||
9223372036854775808
|
||
9223372036854775808
|
||
0
|
||
|
||
- name: integer division precision
|
||
args:
|
||
- '72 / (1, -2, 3, -4, 6, -8) * 100000000000000000000'
|
||
input: '0'
|
||
expected: |
|
||
7200000000000000000000
|
||
-3600000000000000000000
|
||
2400000000000000000000
|
||
-1800000000000000000000
|
||
1200000000000000000000
|
||
-900000000000000000000
|
||
|
||
- name: optional and division operator
|
||
args:
|
||
- '1?/1'
|
||
input: '0'
|
||
expected: |
|
||
1
|
||
|
||
- name: optional and division operator parse error
|
||
args:
|
||
- '.?/'
|
||
input: '0'
|
||
error: |
|
||
invalid query: .?/
|
||
.?/
|
||
^ unexpected EOF
|
||
exit_code: 3
|
||
|
||
- name: factorial calculation
|
||
args:
|
||
- -n
|
||
- -r
|
||
- 'def fact($n): if $n < 1 then 1 else $n * fact($n - 1) end; (range(30;51) | "\(.)! = \(fact(.))"), fact(50) / fact(30), fact(50) % (fact(30) + 1), fact(100), fact(1000)*1.0, 1/fact(1000), -1/fact(1000), 1.0/fact(1000)'
|
||
expected: |
|
||
30! = 265252859812191058636308480000000
|
||
31! = 8222838654177922817725562880000000
|
||
32! = 263130836933693530167218012160000000
|
||
33! = 8683317618811886495518194401280000000
|
||
34! = 295232799039604140847618609643520000000
|
||
35! = 10333147966386144929666651337523200000000
|
||
36! = 371993326789901217467999448150835200000000
|
||
37! = 13763753091226345046315979581580902400000000
|
||
38! = 523022617466601111760007224100074291200000000
|
||
39! = 20397882081197443358640281739902897356800000000
|
||
40! = 815915283247897734345611269596115894272000000000
|
||
41! = 33452526613163807108170062053440751665152000000000
|
||
42! = 1405006117752879898543142606244511569936384000000000
|
||
43! = 60415263063373835637355132068513997507264512000000000
|
||
44! = 2658271574788448768043625811014615890319638528000000000
|
||
45! = 119622220865480194561963161495657715064383733760000000000
|
||
46! = 5502622159812088949850305428800254892961651752960000000000
|
||
47! = 258623241511168180642964355153611979969197632389120000000000
|
||
48! = 12413915592536072670862289047373375038521486354677760000000000
|
||
49! = 608281864034267560872252163321295376887552831379210240000000000
|
||
50! = 30414093201713378043612608166064768844377641568960512000000000000
|
||
114660755112113373922453094400000
|
||
150592104700077684713855385600001
|
||
93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000
|
||
1.7976931348623157e+308
|
||
0
|
||
-0
|
||
0
|
||
|
||
- name: negative large numbers
|
||
args:
|
||
- -n
|
||
- 'def f($n): if $n < 1 then 1 else (-$n) * (-f($n - 1)) end; -f(range(30;40))'
|
||
expected: |
|
||
-265252859812191058636308480000000
|
||
-8222838654177922817725562880000000
|
||
-263130836933693530167218012160000000
|
||
-8683317618811886495518194401280000000
|
||
-295232799039604140847618609643520000000
|
||
-10333147966386144929666651337523200000000
|
||
-371993326789901217467999448150835200000000
|
||
-13763753091226345046315979581580902400000000
|
||
-523022617466601111760007224100074291200000000
|
||
-20397882081197443358640281739902897356800000000
|
||
|
||
- name: large number literal
|
||
args:
|
||
- -n
|
||
- |
|
||
100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
|
||
-100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
|
||
100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0,
|
||
-100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0,
|
||
10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
|
||
-10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
|
||
10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0,
|
||
-10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0
|
||
expected: |
|
||
100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
|
||
-100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
|
||
1e+308
|
||
-1e+308
|
||
10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
|
||
-10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
|
||
1.7976931348623157e+308
|
||
-1.7976931348623157e+308
|
||
|
||
- name: zero division
|
||
args:
|
||
- -c
|
||
- '.[] as $x | .[] as $y | [$x, $y, try ($x / $y) catch .]'
|
||
input: '[1, 0]'
|
||
expected: |
|
||
[1,1,1]
|
||
[1,0,"cannot divide number (1) by: number (0)"]
|
||
[0,1,0]
|
||
[0,0,"cannot divide number (0) by: number (0)"]
|
||
|
||
- name: zero modulo
|
||
args:
|
||
- -c
|
||
- '.[] as $x | .[] as $y | [$x, $y, try ($x % $y) catch .]'
|
||
input: '[1, 0]'
|
||
expected: |
|
||
[1,1,0]
|
||
[1,0,"cannot modulo number (1) by: number (0)"]
|
||
[0,1,0]
|
||
[0,0,"cannot modulo number (0) by: number (0)"]
|
||
|
||
- name: modulo with near 0.0
|
||
args:
|
||
- '1 % 0.9'
|
||
input: 'null'
|
||
error: |
|
||
cannot modulo number (1) by: number (0.9)
|
||
|
||
- name: modulo with nan
|
||
args:
|
||
- '(1, nan) % (1, nan) | isnan'
|
||
input: 'null'
|
||
expected: |
|
||
false
|
||
true
|
||
true
|
||
true
|
||
|
||
- name: zero division and modulo for large number
|
||
args:
|
||
- -c
|
||
- '[try (.[] / .[]) catch .], [try (.[] % .[]) catch .]'
|
||
input: '[1267650600228229401496703205376, 0]'
|
||
expected: |
|
||
[1,0,"cannot divide number (12676506002282294014967032 ...) by: number (0)"]
|
||
[0,0,"cannot modulo number (12676506002282294014967032 ...) by: number (0)"]
|
||
|
||
- name: add strings
|
||
args:
|
||
- '.[] + .[] + "c"'
|
||
input: '["a", "b"]'
|
||
expected: |
|
||
"aac"
|
||
"bac"
|
||
"abc"
|
||
"bbc"
|
||
|
||
- name: multiply constant
|
||
args:
|
||
- '3 * .[], 2.5 * .[], .054e2 * .[]'
|
||
input: '[1, 2.5, "abc"]'
|
||
expected: |
|
||
3
|
||
7.5
|
||
"abcabcabc"
|
||
2.5
|
||
6.25
|
||
"abcabc"
|
||
5.4
|
||
13.5
|
||
"abcabcabcabcabc"
|
||
|
||
- name: multiply strings
|
||
args:
|
||
- '(-1.0, -0.5, 0.0, 0.5, 1.0, 1.5, 3.7, 10, nan) * "abc"'
|
||
input: 'null'
|
||
expected: |
|
||
null
|
||
null
|
||
""
|
||
""
|
||
"abc"
|
||
"abc"
|
||
"abcabcabc"
|
||
"abcabcabcabcabcabcabcabcabcabc"
|
||
null
|
||
|
||
- name: multiply strings error
|
||
args:
|
||
- -r
|
||
- '(infinite, 1e300, 720000000) as $n | try ($n * "abc") catch .'
|
||
input: 'null'
|
||
expected: |
|
||
repeat string result too large: "abc" * 1.7976931348623157e+308
|
||
repeat string result too large: "abc" * 1e+300
|
||
repeat string result too large: "abc" * 720000000
|
||
|
||
- name: multiply empty string
|
||
args:
|
||
- '(-9223372036854775808, -1, 0, 0.001, 0.999, 1, 7, 9223372036854775807, 1e300) * ""'
|
||
input: 'null'
|
||
expected: |
|
||
null
|
||
null
|
||
""
|
||
""
|
||
""
|
||
""
|
||
""
|
||
""
|
||
""
|
||
|
||
- name: add objects
|
||
args:
|
||
- -c
|
||
- '.[0] + .[]'
|
||
input: '[{"a": 1}, {"b": 2}, {"a": 3}]'
|
||
expected: |
|
||
{"a":1}
|
||
{"a":1,"b":2}
|
||
{"a":3}
|
||
|
||
- name: multiply objects
|
||
args:
|
||
- -c
|
||
- '.[] * .[]'
|
||
input: '[{"foo": 10, "bar": {"qux": 20}}, {"foo": 20, "bar": {"baz": "quux"}}]'
|
||
expected: |
|
||
{"bar":{"qux":20},"foo":10}
|
||
{"bar":{"baz":"quux","qux":20},"foo":10}
|
||
{"bar":{"baz":"quux","qux":20},"foo":20}
|
||
{"bar":{"baz":"quux"},"foo":20}
|
||
|
||
- name: divide strings
|
||
args:
|
||
- -c
|
||
- '.[] / .[]'
|
||
input: '["abc", "a", "b", ""]'
|
||
expected: |
|
||
["",""]
|
||
["a"]
|
||
["b"]
|
||
[]
|
||
["","bc"]
|
||
["",""]
|
||
["b"]
|
||
[]
|
||
["a","c"]
|
||
["a"]
|
||
["",""]
|
||
[]
|
||
["a","b","c"]
|
||
["a"]
|
||
["b"]
|
||
[]
|
||
|
||
- name: add and subtract arrays
|
||
args:
|
||
- -c
|
||
- '.[] + .[] - .[]'
|
||
input: '[[1, 2], [3, 4]]'
|
||
expected: |
|
||
[]
|
||
[3,4]
|
||
[3,4]
|
||
[3,4,3,4]
|
||
[1,2,1,2]
|
||
[1,2]
|
||
[1,2]
|
||
[]
|
||
|
||
- name: arrays are immutable on addition
|
||
args:
|
||
- -c
|
||
- '. as $v | .[:0] + [6, 7, 8] | ., $v'
|
||
input: |
|
||
[1,2,3,4,5]
|
||
expected: |
|
||
[6,7,8]
|
||
[1,2,3,4,5]
|
||
|
||
- name: arrays are immutable on subtraction
|
||
args:
|
||
- -c
|
||
- '. as $v | . - [2, 3] | ., $v'
|
||
input: |
|
||
[1,2,3,4,5]
|
||
expected: |
|
||
[1,4,5]
|
||
[1,2,3,4,5]
|
||
|
||
- name: subtract arrays
|
||
args:
|
||
- -c
|
||
- '[1,2,3,4,1,4722366482869645213696] - [.,3,4722366482869645213696]'
|
||
input: '1'
|
||
expected: |
|
||
[2,4]
|
||
|
||
- name: subtract arrays with large numbers
|
||
args:
|
||
- -c
|
||
- '. as $x | [$x-$x] - [0]'
|
||
input: '10000000000000'
|
||
expected: |
|
||
[]
|
||
|
||
- name: subtract arrays with nan
|
||
args:
|
||
- -c
|
||
- '[nan,{x:nan}] - [nan,{x:nan}]'
|
||
input: '1'
|
||
expected: |
|
||
[null,{"x":null}]
|
||
|
||
- name: add object
|
||
args:
|
||
- -c
|
||
- '.[] + .[]'
|
||
input: '[{"a":1},{"b":2}]'
|
||
expected: |
|
||
{"a":1}
|
||
{"a":1,"b":2}
|
||
{"a":1,"b":2}
|
||
{"b":2}
|
||
|
||
- name: add null
|
||
args:
|
||
- '.[] + .[]'
|
||
input: '[1, 2, null]'
|
||
expected: |
|
||
2
|
||
3
|
||
1
|
||
3
|
||
4
|
||
2
|
||
1
|
||
2
|
||
null
|
||
|
||
- name: subtract null
|
||
args:
|
||
- '.[] - .[]'
|
||
input: '[1, 2, null]'
|
||
expected: |
|
||
0
|
||
1
|
||
error: |
|
||
cannot subtract: null and number (1)
|
||
|
||
- name: subtract object
|
||
args:
|
||
- '.[] - .[]'
|
||
input: '[{"a":1},{"b":2}]'
|
||
error: |
|
||
cannot subtract: object ({"a":1}) and object ({"a":1})
|
||
|
||
- name: comparison operators
|
||
args:
|
||
- '[.[] > .[], .[] < .[], .[] >= .[], .[] <= .[], .[] == .[], .[] != .[]] | while(length>0; .[120:]) | .[:120] | map(if . then 1 else 0 end) | join("")'
|
||
input: '[null, false, true, 0, 1, "", "a", "b", "abc", [], [1], [2], [3, 4], ["a", "b"], [[]], [[], []], [{}], {}, {"a": ""}, {"a":[1]}, {"b":[1]}, {"b": []}, {"b": [[]]}, {"a": 0, "b": 1}]'
|
||
expected: |
|
||
"011111111111111111111111001111111111111111111111000111111111111111111111000011111111111111111111000001111111111111111111"
|
||
"000000111111111111111111000000011111111111111111000000000111111111111111000000010111111111111111000000000011111111111111"
|
||
"000000000001111111111111000000000000111111111111000000000000011111111111000000000000001111111111000000000000000111111111"
|
||
"000000000000000011111111000000000000000001111111000000000000000000111111000000000000000000011111000000000000000000001111"
|
||
"000000000000000000000010000000000000000000001010000000000000000000000000000000000000000000001110000000000000000000000000"
|
||
"100000000000000000000000110000000000000000000000111000000000000000000000111100000000000000000000111110000000000000000000"
|
||
"111111000000000000000000111111101000000000000000111111100000000000000000111111111000000000000000111111111100000000000000"
|
||
"111111111110000000000000111111111111000000000000111111111111100000000000111111111111110000000000111111111111111000000000"
|
||
"111111111111111100000000111111111111111110000000111111111111111111000000111111111111111111100000111111111111111111110101"
|
||
"111111111111111111110001111111111111111111111101111111111111111111110000111111111111111111111111011111111111111111111111"
|
||
"001111111111111111111111000111111111111111111111000011111111111111111111000001111111111111111111000000111111111111111111"
|
||
"000000010111111111111111000000011111111111111111000000000111111111111111000000000011111111111111000000000001111111111111"
|
||
"000000000000111111111111000000000000011111111111000000000000001111111111000000000000000111111111000000000000000011111111"
|
||
"000000000000000001111111000000000000000000111111000000000000000000011111000000000000000000001010000000000000000000001110"
|
||
"000000000000000000000010000000000000000000001111100000000000000000000000110000000000000000000000111000000000000000000000"
|
||
"111100000000000000000000111110000000000000000000111111000000000000000000111111100000000000000000111111111000000000000000"
|
||
"111111101000000000000000111111111100000000000000111111111110000000000000111111111111000000000000111111111111100000000000"
|
||
"111111111111110000000000111111111111111000000000111111111111111100000000111111111111111110000000111111111111111111000000"
|
||
"111111111111111111100000111111111111111111110000111111111111111111111101111111111111111111110101111111111111111111111111"
|
||
"111111111111111111110001100000000000000000000000010000000000000000000000001000000000000000000000000100000000000000000000"
|
||
"000010000000000000000000000001000000000000000000000000100000000000000000000000010000000000000000000000001000000000000000"
|
||
"000000000100000000000000000000000010000000000000000000000001000000000000000000000000100000000000000000000000010000000000"
|
||
"000000000000001000000000000000000000000100000000000000000000000010000000000000000000000001000000000000000000000000100000"
|
||
"000000000000000000010000000000000000000000001000000000000000000000000100000000000000000000000010000000000000000000000001"
|
||
"011111111111111111111111101111111111111111111111110111111111111111111111111011111111111111111111111101111111111111111111"
|
||
"111110111111111111111111111111011111111111111111111111101111111111111111111111110111111111111111111111111011111111111111"
|
||
"111111111101111111111111111111111110111111111111111111111111011111111111111111111111101111111111111111111111110111111111"
|
||
"111111111111111011111111111111111111111101111111111111111111111110111111111111111111111111011111111111111111111111101111"
|
||
"111111111111111111110111111111111111111111111011111111111111111111111101111111111111111111111110"
|
||
|
||
- name: comparison and arithmetic operators
|
||
args:
|
||
- '[.[] + .[] > .[] - .[], .[] * .[] < .[] / .[] + .[] / .[], .[] == .[] * .[]] | while(length>0; .[120:]) | .[:120] | map(if . then 1 else 0 end) | join("")'
|
||
input: '[1, 2, 3]'
|
||
expected: |
|
||
"111111111111111111011111111111111111111111111111111111111111111111111111111111111100000000110100000111100100100000000100"
|
||
"000000110100000100000000100000000100000000110100000111100100111110100110100000110100000111100100110100000110100000110100"
|
||
"000111100100111110100111110100111100100111100100111110100111100100111100100111100100100000000110100000111100100000000000"
|
||
"100000000100000000000000000100000000100000000100000000110100000111100100100000000100000000110100000100000000100000000100"
|
||
"000000110100000111100100111110100100000000110100000110100000100000000110100000110100000100000000110100000111100100000000"
|
||
"000100000000100000000000000000000000000100000000100000000110100000111100100100000000100000000110100000000000000100000000"
|
||
"100000000100000000110100000111100100100000000100000000110100000100000000100000000100000000100010001010000000001000000"
|
||
|
||
- name: comparison operators with large numbers
|
||
args:
|
||
- '[.[] > .[], .[] < .[], .[] >= .[], .[] <= .[], .[] == .[], .[] != .[]] | while(length>0; .[120:]) | .[:120] | map(if . then 1 else 0 end) | join("")'
|
||
input: '[-9999999999999999999999999999999999, -4722366482869645213697, -2, 0, 47, 4722366482869645213696, 4722366482869645213697, 99999999999999999999999999999999999]'
|
||
expected: |
|
||
"011111110011111100011111000011110000011100000011000000010000000000000000100000001100000011100000111100001111100011111100"
|
||
"111111101111111101111111001111110001111100001111000001110000001100000001100000001100000011100000111100001111100011111100"
|
||
"111111101111111110000000010000000010000000010000000010000000010000000010000000010111111110111111110111111110111111110111"
|
||
"111110111111110111111110"
|
||
|
||
- name: comparison operators associativity error
|
||
args:
|
||
- '. == . == .'
|
||
input: '1'
|
||
error: |
|
||
invalid query: . == . == .
|
||
. == . == .
|
||
^ unexpected token "=="
|
||
exit_code: 3
|
||
|
||
- name: logical operators
|
||
args:
|
||
- '[.[] > .[] and .[] or .[] < .[]] | while(length>0; .[120:]) | .[:120] | map(if . then 1 else 0 end) | join("")'
|
||
input: '[null, false, true, 0, "", [], {}]'
|
||
expected: |
|
||
"000000010000001100000111000011110001111100111111000000001000000110000011100001111000111110011111100000000100000011000001"
|
||
"110000111100011111001111110111110000000100000011000001110000111100011111001111110000000010000001100000111000011110001111"
|
||
"100111111011111000000010000001100000111000011110001111100111111000000001000000110000011100001111000111110011111101111100"
|
||
"000001000000110000011100001111000111110011111100000000100000011000001110000111100011111001111110111110000000100000011000"
|
||
"001110000111100011111001111110000000010000001100000111000011110001111100111111011111000000010000001100000111000011110001"
|
||
"111100111111000000001000000110000011100001111000111110011111101111100000001000000110000011100001111000111110011111100000"
|
||
"000100000011000001110000111100011111001111110000000010000001100000111000011110001111100111111000000001000000110000011100"
|
||
"001111000111110011111101111100000001000000110000011100001111000111110011111100000000100000011000001110000111100011111001"
|
||
"111110111110000000100000011000001110000111100011111001111110000000010000001100000111000011110001111100111111011111000000"
|
||
"010000001100000111000011110001111100111111000000001000000110000011100001111000111110011111101111100000001000000110000011"
|
||
"100001111000111110011111100000000100000011000001110000111100011111001111110111110000000100000011000001110000111100011111"
|
||
"001111110000000010000001100000111000011110001111100111111000000001000000110000011100001111000111110011111100000000100000"
|
||
"011000001110000111100011111001111110000000010000001100000111000011110001111100111111011111000000010000001100000111000011"
|
||
"110001111100111111000000001000000110000011100001111000111110011111101111100000001000000110000011100001111000111110011111"
|
||
"100000000100000011000001110000111100011111001111110111110000000100000011000001110000111100011111001111110000000010000001"
|
||
"100000111000011110001111100111111011111000000010000001100000111000011110001111100111111000000001000000110000011100001111"
|
||
"000111110011111100000000100000011000001110000111100011111001111110000000010000001100000111000011110001111100111111000000"
|
||
"001000000110000011100001111000111110011111100000000100000011000001110000111100011111001111110111110000000100000011000001"
|
||
"110000111100011111001111110000000010000001100000111000011110001111100111111011111000000010000001100000111000011110001111"
|
||
"100111111000000001000000110000011100001111000111110011111101111100000001000000110000011100001111000111110011111100000000"
|
||
"100000011000001110000111100011111001111110000000010000001100000111000011110001111100111111000000001000000110000011100001"
|
||
"111000111110011111100000000100000011000001110000111100011111001111110000000010000001100000111000011110001111100111111000"
|
||
"000001000000110000011100001111000111110011111101111100000001000000110000011100001111000111110011111100000000100000011000"
|
||
"001110000111100011111001111110111110000000100000011000001110000111100011111001111110000000010000001100000111000011110001"
|
||
"111100111111000000001000000110000011100001111000111110011111100000000100000011000001110000111100011111001111110000000010"
|
||
"000001100000111000011110001111100111111000000001000000110000011100001111000111110011111100000000100000011000001110000111"
|
||
"100011111001111110000000010000001100000111000011110001111100111111011111000000010000001100000111000011110001111100111111"
|
||
"000000001000000110000011100001111000111110011111100000000100000011000001110000111100011111001111110000000010000001100000"
|
||
"111000011110001111100111111000000001000000110000011100001111000111110011111100000000100000011000001110000111100011111001"
|
||
"1111100000000100000011000001110000111100011111001111110"
|
||
|
||
- name: alternative operator
|
||
args:
|
||
- -c
|
||
- '[.a // .b, .b // null // .a, .c[] // .d[], .d[] // .c, .c // .a, .e.a // .c[]]'
|
||
input: '{ "a": 5, "b": false, "c": [null,false], "d": [false,3], "e": null }'
|
||
expected: |
|
||
[5,5,false,3,3,[null,false],null,false]
|
||
|
||
- name: optional operator with alternative operator
|
||
args:
|
||
- '.a ?// 1'
|
||
input: 'null'
|
||
expected: |
|
||
1
|
||
|
||
- name: condition
|
||
args:
|
||
- 'if . then . else [.] end'
|
||
input: 'null false true 0'
|
||
expected: |
|
||
[
|
||
null
|
||
]
|
||
[
|
||
false
|
||
]
|
||
true
|
||
0
|
||
|
||
- name: condition with elif clause
|
||
args:
|
||
- 'if . == null then . elif not then [.] elif . == true then [[.]] else [[[.]]] end'
|
||
input: 'null false true 0'
|
||
expected: |
|
||
null
|
||
[
|
||
false
|
||
]
|
||
[
|
||
[
|
||
true
|
||
]
|
||
]
|
||
[
|
||
[
|
||
[
|
||
0
|
||
]
|
||
]
|
||
]
|
||
|
||
- name: condition without else clause
|
||
args:
|
||
- 'map(if . > 2 then . / 2 end)'
|
||
input: '[1, 2, 3, 4, 5]'
|
||
expected: |
|
||
[
|
||
1,
|
||
2,
|
||
1.5,
|
||
2,
|
||
2.5
|
||
]
|
||
|
||
- name: condition precedence
|
||
args:
|
||
- '. + if 1 then 2 else 3 end + 4'
|
||
input: '1'
|
||
expected: |
|
||
7
|
||
|
||
- name: condition with unary operator
|
||
args:
|
||
- '[-if true then -. end]'
|
||
input: '1'
|
||
expected: |
|
||
[
|
||
1
|
||
]
|
||
|
||
- name: condition with optional operator
|
||
args:
|
||
- 'if . then tonumber end ?'
|
||
input: '1'
|
||
expected: |
|
||
1
|
||
|
||
- name: condition with identity in then clause
|
||
args:
|
||
- 'if 0 then . else 0|0 end'
|
||
input: 'null'
|
||
expected: |
|
||
null
|
||
|
||
- name: condition with identity in else clause
|
||
args:
|
||
- 'if 0 then 0|0 else . end'
|
||
input: 'null'
|
||
expected: |
|
||
0
|
||
|
||
- name: condition with suffix
|
||
args:
|
||
- 'if true then [.] end []'
|
||
input: '1'
|
||
expected: |
|
||
1
|
||
|
||
- name: not function
|
||
args:
|
||
- 'not'
|
||
input: |
|
||
true
|
||
false
|
||
expected: |
|
||
false
|
||
true
|
||
|
||
- name: iterator in condition
|
||
args:
|
||
- 'if .. then [] else {} end'
|
||
input: '{ "foo": false }'
|
||
expected: |
|
||
[]
|
||
{}
|
||
|
||
- name: try
|
||
args:
|
||
- 'map(try utf8bytelength)'
|
||
input: '[[], {}, [1,2], "hello", 55, true, false]'
|
||
expected: |
|
||
[
|
||
5
|
||
]
|
||
|
||
- name: try catch
|
||
args:
|
||
- 'map(try utf8bytelength catch .)'
|
||
input: '[[], {}, [1,2], "hello", 55, true, false]'
|
||
expected: |
|
||
[
|
||
"utf8bytelength cannot be applied to: array ([])",
|
||
"utf8bytelength cannot be applied to: object ({})",
|
||
"utf8bytelength cannot be applied to: array ([1,2])",
|
||
5,
|
||
"utf8bytelength cannot be applied to: number (55)",
|
||
"utf8bytelength cannot be applied to: boolean (true)",
|
||
"utf8bytelength cannot be applied to: boolean (false)"
|
||
]
|
||
|
||
- name: try catch with function declaration
|
||
args:
|
||
- 'def f: fromjson; try ({} | f) catch ., 1'
|
||
input: 'null'
|
||
expected: |
|
||
"fromjson cannot be applied to: object ({})"
|
||
1
|
||
|
||
- name: try and comma operator precedence
|
||
args:
|
||
- '1, try error(2), 3'
|
||
input: 'null'
|
||
expected: |
|
||
1
|
||
3
|
||
|
||
- name: try and alternative operator precedence
|
||
args:
|
||
- 'try error(0) // 1'
|
||
input: 'null'
|
||
expected: |
|
||
1
|
||
|
||
- name: try and update operator precedence
|
||
args:
|
||
- 'try error(0) = 1'
|
||
input: 'null'
|
||
expected: |
|
||
null
|
||
|
||
- name: try and arithmetic operator precedence
|
||
args:
|
||
- 'try 0 * error(0)'
|
||
input: 'null'
|
||
error: |
|
||
error: 0
|
||
exit_code: 5
|
||
|
||
- name: try and indexing precedence
|
||
args:
|
||
- 'try 0 .[error(0)]'
|
||
input: 'null'
|
||
|
||
- name: try catch and arithmetic operator precedence
|
||
args:
|
||
- '1 + try 2 catch 3 + 4'
|
||
input: 'null'
|
||
expected: |
|
||
7
|
||
|
||
- name: try and unary operator
|
||
args:
|
||
- '[-try .]'
|
||
input: '1'
|
||
expected: |
|
||
[
|
||
-1
|
||
]
|
||
|
||
- name: reduce iterator
|
||
args:
|
||
- '[range(.)] | reduce .[] as $i (0; . + $i)'
|
||
input: '10'
|
||
expected: |
|
||
45
|
||
|
||
- name: reduce arrays
|
||
args:
|
||
- 'reduce .[] as [$i,$j] (0; . + $i * $j)'
|
||
input: '[[1,2,10], [3,4,10]]'
|
||
expected: |
|
||
14
|
||
|
||
- name: reduce objects
|
||
args:
|
||
- 'reduce .[] as {$i, j:$j} (0; . + $i - $j)'
|
||
input: '[{"i":2, "j":1}, {"i":5, "j":3}, {"i":6, "j":4}]'
|
||
expected: |
|
||
5
|
||
|
||
- name: reduce with destructuring alternative operator
|
||
args:
|
||
- 'reduce .[] as [$i,$j] ?// {$i,$j} (0; . + $i * $j)'
|
||
input: '[[1,2], {"i":3,"j":4}, [5,6]]'
|
||
expected: |
|
||
44
|
||
|
||
- name: reduce with destructuring alternative operator resetting variables
|
||
args:
|
||
- -c
|
||
- 'reduce .[] as [$a] ?// {$b} ?// $c ([]; . + [[$a, $b, $c]])'
|
||
input: '[{"b":1}, [2], 3, [4]]'
|
||
expected: |
|
||
[[null,1,null],[2,null,null],[null,null,3],[4,null,null]]
|
||
|
||
- name: reduce with destructuring alternative operator and error backtrack
|
||
args:
|
||
- -c
|
||
- 'reduce .[] as [$a] ?// $a ([]; . + [if $a == 2 then error else $a end])'
|
||
input: '[[1], [2], [3]]'
|
||
expected: |
|
||
[1,[2],3]
|
||
|
||
- name: reduce null
|
||
args:
|
||
- 'reduce . as $n (.; .)'
|
||
input: 'null'
|
||
expected: |
|
||
null
|
||
|
||
- name: reduce precedence
|
||
args:
|
||
- '. + reduce . as $n (. + [2]; [.]) + .'
|
||
input: '[1]'
|
||
expected: |
|
||
[
|
||
1,
|
||
[
|
||
1,
|
||
2
|
||
],
|
||
1
|
||
]
|
||
|
||
- name: reduce with unary operator
|
||
args:
|
||
- '[-reduce -.[] as $i (0; . + $i)]'
|
||
input: '[1,2,3]'
|
||
expected: |
|
||
[
|
||
6
|
||
]
|
||
|
||
- name: reduce with binary operator
|
||
args:
|
||
- 'reduce .[] / .[] as $i (0; . + $i)'
|
||
input: '[1,2]'
|
||
expected: |
|
||
4.5
|
||
|
||
- name: reduce with select in update
|
||
args:
|
||
- 'reduce range(5) as $x (0; . + $x | select($x != 2))'
|
||
input: 'null'
|
||
expected: |
|
||
8
|
||
|
||
- name: reduce with assignment of multiple paths in update
|
||
args:
|
||
- -c
|
||
- 'reduce (1,2) as $i (.; (.[0], .[.[0]]) = $i),
|
||
reduce (1,2) as $i (.; (.[0], .[.[0]]) |= $i)'
|
||
input: '[0,0,0]'
|
||
expected: |
|
||
[2,2,0]
|
||
[2,2,0]
|
||
|
||
- name: reduce with query in start
|
||
args:
|
||
- 'reduce range(5) as $x (range(3); . + $x)'
|
||
input: 'null'
|
||
expected: |
|
||
10
|
||
11
|
||
12
|
||
|
||
- name: reduce with variable binding
|
||
args:
|
||
- 'reduce .[] as $x (0; . + $x) as $x | $x'
|
||
input: '[1,2,3]'
|
||
expected: |
|
||
6
|
||
|
||
- name: reduce variable scope
|
||
args:
|
||
- -c
|
||
- '. as $x | reduce .[] as $x (.; . + .) | [., $x]'
|
||
input: '[1]'
|
||
expected: |
|
||
[[1,1],[1]]
|
||
|
||
- name: reduce with assignment in update
|
||
args:
|
||
- -c
|
||
- 'reduce range(3) as $i ({}; .[$i|tostring] = {}),
|
||
reduce range(3) as $i ({}; .a[$i|tostring] = $i),
|
||
reduce range(3) as $i ([]; .[$i] = $i),
|
||
reduce range(3) as $i ({}; .[$i|tostring] += 1)'
|
||
input: 'null'
|
||
expected: |
|
||
{"0":{},"1":{},"2":{}}
|
||
{"a":{"0":0,"1":1,"2":2}}
|
||
[0,1,2]
|
||
{"0":1,"1":1,"2":1}
|
||
|
||
- name: reduce with assignment of the accumulated value
|
||
args:
|
||
- -c
|
||
- 'reduce range(3) as $i ({}; .a = .),
|
||
reduce range(3) as $i ({}; .a = {v: .}),
|
||
reduce range(3) as $i ({}; . as $p | .a = $i | .b = $p)'
|
||
input: 'null'
|
||
expected: |
|
||
{"a":{"a":{"a":{}}}}
|
||
{"a":{"v":{"a":{"v":{"a":{"v":{}}}}}}}
|
||
{"a":2,"b":{"a":1,"b":{"a":0,"b":{}}}}
|
||
|
||
- name: reduce with assignment of multiple values
|
||
args:
|
||
- -c
|
||
- 'reduce range(2) as $i ({"k":"k"}; .[.k] = ("x","y")),
|
||
reduce range(2) as $i ({}; (.a = 1), (.b = 2))'
|
||
input: 'null'
|
||
expected: |
|
||
{"k":"y","y":"y"}
|
||
{"b":2}
|
||
|
||
- name: reduce with assignment of a shared value
|
||
args:
|
||
- -c
|
||
- '{"a":1} as $x | reduce range(2) as $i ({}; .[$i|tostring] = $x) |
|
||
[(.["0"].a = 9), $x]'
|
||
input: 'null'
|
||
expected: |
|
||
[{"0":{"a":9},"1":{"a":1}},{"a":1}]
|
||
|
||
- name: reduce with assignment result reused
|
||
args:
|
||
- -c
|
||
- 'reduce range(3) as $i ({}; .[$i|tostring] = $i) as $r |
|
||
[($r | .["0"] = 9), $r]'
|
||
input: 'null'
|
||
expected: |
|
||
[{"0":9,"1":1,"2":2},{"0":0,"1":1,"2":2}]
|
||
|
||
- name: foreach with assignment in update
|
||
args:
|
||
- -c
|
||
- '[foreach range(3) as $i ({}; .[$i|tostring] = $i)]'
|
||
input: 'null'
|
||
expected: |
|
||
[{"0":0},{"0":0,"1":1},{"0":0,"1":1,"2":2}]
|
||
|
||
- name: foreach iterator
|
||
args:
|
||
- 'foreach range(5) as $item (0; $item)'
|
||
input: 'null'
|
||
expected: |
|
||
0
|
||
1
|
||
2
|
||
3
|
||
4
|
||
|
||
- name: foreach arrays
|
||
args:
|
||
- 'foreach .[] as [$i, $j] (0; . + $i - $j)'
|
||
input: '[[2,1], [5,3], [6,4]]'
|
||
expected: |
|
||
1
|
||
3
|
||
5
|
||
|
||
- name: foreach objects
|
||
args:
|
||
- 'foreach .[] as {a:$a} (0; . + $a; -.)'
|
||
input: '[{"a":1}, {"b":2}, {"a":3, "b":4}]'
|
||
expected: |
|
||
-1
|
||
-1
|
||
-4
|
||
|
||
- name: foreach with destructuring alternative operator
|
||
args:
|
||
- 'foreach .[] as [$i,$j] ?// {$i,$j} (0; . + $i * $j)'
|
||
input: '[[1,2], {"i":3,"j":4}, [5,6]]'
|
||
expected: |
|
||
2
|
||
14
|
||
44
|
||
|
||
- name: foreach with destructuring alternative operator resetting variables
|
||
args:
|
||
- -c
|
||
- 'foreach .[] as [$a] ?// {$b} ?// $c (null; [$a, $b, $c])'
|
||
input: '[{"b":1}, [2], 3, [4]]'
|
||
expected: |
|
||
[null,1,null]
|
||
[2,null,null]
|
||
[null,null,3]
|
||
[4,null,null]
|
||
|
||
- name: foreach with destructuring alternative operator and error backtrack in extract
|
||
args:
|
||
- -c
|
||
- 'foreach .[] as {$a} ?// [$a] ?// $a (null; $a; if 1 < . and . < 4 then error else . end)'
|
||
input: '[[1], [2], {"a":3}, 4]'
|
||
expected: |
|
||
1
|
||
[2]
|
||
{"a":3}
|
||
4
|
||
|
||
- name: foreach with iterator in update
|
||
args:
|
||
- 'foreach .[] as $i (1; ., . + $i, range(.))'
|
||
input: '[1, 2, 3]'
|
||
expected: |
|
||
1
|
||
2
|
||
0
|
||
0
|
||
2
|
||
2
|
||
5
|
||
0
|
||
1
|
||
|
||
- name: foreach with select in update
|
||
args:
|
||
- -c
|
||
- 'foreach range(5) as $i (0; . + $i | select($i != 2); [$i, .])'
|
||
input: 'null'
|
||
expected: |
|
||
[0,0]
|
||
[1,1]
|
||
[3,4]
|
||
[4,8]
|
||
|
||
- name: foreach with query in start
|
||
args:
|
||
- -c
|
||
- 'foreach range(3) as $i (range(3); . + $i; [$i, .])'
|
||
input: 'null'
|
||
expected: |
|
||
[0,0]
|
||
[1,1]
|
||
[2,3]
|
||
[0,1]
|
||
[1,2]
|
||
[2,4]
|
||
[0,2]
|
||
[1,3]
|
||
[2,5]
|
||
|
||
- name: foreach with unary operator
|
||
args:
|
||
- '[-foreach -.[] as $i (0; . + $i)]'
|
||
input: '[1,2,3]'
|
||
expected: |
|
||
[
|
||
1,
|
||
3,
|
||
6
|
||
]
|
||
|
||
- name: foreach with binary operator
|
||
args:
|
||
- '[foreach .[] / .[] as $i (0; . + $i)]'
|
||
input: '[1,2]'
|
||
expected: |
|
||
[
|
||
1,
|
||
3,
|
||
3.5,
|
||
4.5
|
||
]
|
||
|
||
- name: foreach with variable binding
|
||
args:
|
||
- '[foreach .[] as $x (0; . + $x) as $x | $x]'
|
||
input: '[1,2,3]'
|
||
expected: |
|
||
[
|
||
1,
|
||
3,
|
||
6
|
||
]
|
||
|
||
- name: foreach variable scope
|
||
args:
|
||
- -c
|
||
- '. as $x | foreach .[] as $x (.; . + .) | [., $x]'
|
||
input: '[1]'
|
||
expected: |
|
||
[[1,1],[1]]
|
||
|
||
- name: label and break syntax
|
||
args:
|
||
- '[(label $x | .[] | if . > 2 then break $x else . end), 0]'
|
||
input: '[1,2,3,2,1]'
|
||
expected: |
|
||
[
|
||
1,
|
||
2,
|
||
0
|
||
]
|
||
|
||
- name: label and break in foreach syntax
|
||
args:
|
||
- '[range(.)] | label $x | foreach .[] as $i (0; if . > 5 then break $x else . + $i end)'
|
||
input: '10'
|
||
expected: |
|
||
0
|
||
1
|
||
3
|
||
6
|
||
|
||
- name: label and break in try catch syntax
|
||
args:
|
||
- 'label $x | (label $y | try break $y catch .), .'
|
||
input: '10'
|
||
expected: |
|
||
10
|
||
|
||
- name: label and break in function argument
|
||
args:
|
||
- 'range(.) | label $out | limit(3; 1, if . > 1 then break $out end, 2)'
|
||
input: '3'
|
||
expected: |
|
||
1
|
||
0
|
||
2
|
||
1
|
||
1
|
||
2
|
||
1
|
||
|
||
- name: label and break in function argument with foreach
|
||
args:
|
||
- 'label $out | last(foreach range(0; 10) as $i ({x: 1}; if .x > 10 then break $out else .x += 1 end))'
|
||
input: '0'
|
||
expected: |
|
||
{
|
||
"x": 11
|
||
}
|
||
|
||
- name: label in recursive call
|
||
args:
|
||
- 'def f: label $x | if . < 5 then ., (. + 1 | f, break $x, .) else . end; f'
|
||
input: '0'
|
||
expected: |
|
||
0
|
||
1
|
||
2
|
||
3
|
||
4
|
||
5
|
||
|
||
- name: duplicate label names
|
||
args:
|
||
- 'label $x | (label $x | break $x), .'
|
||
input: '1'
|
||
expected: |
|
||
1
|
||
|
||
- name: invalid label name
|
||
args:
|
||
- 'label foo | .'
|
||
input: '1'
|
||
error: |
|
||
invalid query: label foo | .
|
||
label foo | .
|
||
^ unexpected token "foo"
|
||
exit_code: 3
|
||
|
||
- name: label not defined error for break without label
|
||
args:
|
||
- 'break $test'
|
||
input: '1'
|
||
error: |
|
||
label not defined: $test
|
||
exit_code: 3
|
||
|
||
- name: label not defined error for break with label in parenthesis
|
||
args:
|
||
- '(label $x | 1) | break $x'
|
||
input: '1'
|
||
error: |
|
||
label not defined: $x
|
||
exit_code: 3
|
||
|
||
- name: invalid break name
|
||
args:
|
||
- 'label $x | break x'
|
||
input: '1'
|
||
error: |
|
||
invalid query: label $x | break x
|
||
label $x | break x
|
||
^ unexpected token "x"
|
||
exit_code: 3
|
||
|
||
- name: invalid break syntax
|
||
args:
|
||
- 'label $x | break'
|
||
input: '0'
|
||
error: |
|
||
invalid query: label $x | break
|
||
label $x | break
|
||
^ unexpected EOF
|
||
exit_code: 3
|
||
|
||
- name: variable and label name conflict
|
||
args:
|
||
- '. as $x | (label $x | break $x), $x'
|
||
input: '0'
|
||
expected: |
|
||
0
|
||
|
||
- name: string interpolation
|
||
args:
|
||
- -c
|
||
- '["\(.foo[])_\(.bar[])_\(.baz[])"]'
|
||
input: '{ "foo": [0, 1], "bar": ["x", "y"], "baz": [{"a": 1}, [1], null] }'
|
||
expected: |
|
||
["0_x_{\"a\":1}","1_x_{\"a\":1}","0_y_{\"a\":1}","1_y_{\"a\":1}","0_x_[1]","1_x_[1]","0_y_[1]","1_y_[1]","0_x_null","1_x_null","0_y_null","1_y_null"]
|
||
|
||
- name: string interpolation in object
|
||
args:
|
||
- -c
|
||
- '[{a:"\(.foo[])"}, {"\(.foo[])": 1}, {"\(.bar[])"}]'
|
||
input: '{ "foo": [0, 1], "bar": ["x", "y"], "x": 10, "y": 20 }'
|
||
expected: |
|
||
[{"a":"0"},{"a":"1"},{"0":1},{"1":1},{"x":10},{"y":20}]
|
||
|
||
- name: string interpolation nested
|
||
args:
|
||
- -c
|
||
- '" \("(") \("x" + "\(1 + 2)") \("\\") \("\("\\")") \(")") "'
|
||
input: '0'
|
||
expected: |
|
||
" ( x3 \\ \\ ) "
|
||
|
||
- name: string interpolation nested deeply
|
||
args:
|
||
- -c
|
||
- '"\("\("\("\("\("\("\("\("\("\("\("\("\("\("\("\("\("\("\("\("\("\("\("\(1+2)")")")")")")")")")")")")")")")")")")")")")")")"'
|
||
input: '0'
|
||
expected: |
|
||
"3"
|
||
|
||
- name: string interpolation multiple lines
|
||
args:
|
||
- -c
|
||
- |
|
||
"\( # "
|
||
"\(
|
||
"\(2 * (4 # "
|
||
+#
|
||
6))"
|
||
)" # "
|
||
# "
|
||
+ (def f: "\("\("(" + "\\\((1 + 2) * 3)\"" + ")")")"; f)
|
||
# "
|
||
# "
|
||
# "
|
||
)"
|
||
input: '0'
|
||
expected: |
|
||
"20(\\9\")"
|
||
|
||
- name: string interpolation parse error
|
||
args:
|
||
- '"\(1 +)"'
|
||
input: '0'
|
||
error: |
|
||
invalid query: "\(1 +)"
|
||
"\(1 +)"
|
||
^ unexpected token ")"
|
||
exit_code: 3
|
||
|
||
- name: tojson function
|
||
args:
|
||
- 'tojson'
|
||
input: |
|
||
null
|
||
false
|
||
true
|
||
4722366482869645213696
|
||
"foo"
|
||
["foo"]
|
||
{"a": [1,2,3]}
|
||
expected: |
|
||
"null"
|
||
"false"
|
||
"true"
|
||
"4722366482869645213696"
|
||
"\"foo\""
|
||
"[\"foo\"]"
|
||
"{\"a\":[1,2,3]}"
|
||
|
||
- name: fromjson function
|
||
args:
|
||
- -c
|
||
- 'fromjson'
|
||
input: |
|
||
"null"
|
||
"false"
|
||
"true"
|
||
"4722366482869645213696"
|
||
"\"foo\""
|
||
"[\"foo\"]"
|
||
"{\"a\":[1,2,3]}"
|
||
expected: |
|
||
null
|
||
false
|
||
true
|
||
4722366482869645213696
|
||
"foo"
|
||
["foo"]
|
||
{"a":[1,2,3]}
|
||
|
||
- name: fromjson function error
|
||
args:
|
||
- 'fromjson'
|
||
input: '"[0"'
|
||
error: |
|
||
fromjson cannot be applied to "[0": unexpected EOF
|
||
|
||
- name: variable definition
|
||
args:
|
||
- -c
|
||
- '.foo.bar as $foo | .foo.bar as $bar | {$foo} + {bar: ($bar / 2)} * { baz: 20 }'
|
||
input: |
|
||
{"foo":{"bar":10}}
|
||
expected: |
|
||
{"bar":5,"baz":20,"foo":10}
|
||
|
||
- name: variable definition
|
||
args:
|
||
- -c
|
||
- '.ys as $ys | .xs[] | {a, b: $ys[.b]}'
|
||
input: |
|
||
{"xs":[{"a":"a0","b":"b0"},{"a":"a1","b":"b1"}],"ys":{"b0":"bb0","b1":"bb1"}}
|
||
expected: |
|
||
{"a":"a0","b":"bb0"}
|
||
{"a":"a1","b":"bb1"}
|
||
|
||
- name: variable name error
|
||
args:
|
||
- '.foo as foo | {$bar}'
|
||
input: 'null'
|
||
error: |
|
||
invalid query: .foo as foo | {$bar}
|
||
.foo as foo | {$bar}
|
||
^ unexpected token "foo"
|
||
exit_code: 3
|
||
|
||
- name: variable name not found error
|
||
args:
|
||
- '.foo as $foo | {$bar}'
|
||
input: |
|
||
{"foo":10}
|
||
error: |
|
||
variable not defined: $bar
|
||
exit_code: 3
|
||
|
||
- name: binding an array
|
||
args:
|
||
- -c
|
||
- '. as [$i, $j] | [$j, $i]'
|
||
input: |
|
||
[]
|
||
[10]
|
||
[20,30]
|
||
expected: |
|
||
[null,null]
|
||
[null,10]
|
||
[30,20]
|
||
|
||
- name: binding an array deeply
|
||
args:
|
||
- -c
|
||
- '. as [$i, [$j], [[$k]]] | [$i, $j, $k]'
|
||
input: |
|
||
[]
|
||
[10]
|
||
[20,[30],[[40]]]
|
||
expected: |
|
||
[null,null,null]
|
||
[10,null,null]
|
||
[20,30,40]
|
||
|
||
- name: binding an array error
|
||
args:
|
||
- '. as [$i, $j] | [$j, $i]'
|
||
input: |
|
||
{"foo":10}
|
||
error: |
|
||
expected an array but got: object ({"foo":10})
|
||
|
||
- name: binding an object
|
||
args:
|
||
- -c
|
||
- '. as {$foo, bar: $bar} | {$bar, $foo}'
|
||
input: |
|
||
{}
|
||
{"foo":10}
|
||
{"foo":20,"bar":30}
|
||
expected: |
|
||
{"bar":null,"foo":null}
|
||
{"bar":null,"foo":10}
|
||
{"bar":30,"foo":20}
|
||
|
||
- name: binding an object deeply
|
||
args:
|
||
- -c
|
||
- '. as {$foo, bar: {"baz": {$qux}, "": $quy}} | {$foo, $qux, $quy}'
|
||
input: |
|
||
{}
|
||
{"foo":10}
|
||
{"foo":20,"bar":{"baz":{"qux":30},"":-1}}
|
||
expected: |
|
||
{"foo":null,"qux":null,"quy":null}
|
||
{"foo":10,"qux":null,"quy":null}
|
||
{"foo":20,"qux":30,"quy":-1}
|
||
|
||
- name: binding an object with expression
|
||
args:
|
||
- -c
|
||
- '. as {as: $foo, ("e"+"x"+"p"): $bar, (.foo): $baz, "\(.qux)": $qux} | [$foo, $bar, $baz, $qux]'
|
||
input: |
|
||
{"as":1,"exp":2,"foo":"bar","bar":3,"qux":"quux","quux":4}
|
||
expected: |
|
||
[1,2,3,4]
|
||
|
||
- name: binding an object error
|
||
args:
|
||
- '. as {$i} | [$i]'
|
||
input: |
|
||
[10]
|
||
error: |
|
||
expected an object but got: array ([10])
|
||
|
||
- name: binding object and array deeply
|
||
args:
|
||
- -c
|
||
- '. as {$a, $b: [$c, $d]} | [$a, $b, $c, $d]'
|
||
input: |
|
||
{"a":1,"b":[2,{"d":3}]}
|
||
expected: |
|
||
[1,[2,{"d":3}],2,{"d":3}]
|
||
|
||
- name: binding variable scope in parenthesis
|
||
args:
|
||
- -c
|
||
- '. as $x | (.foo as $x | [$x]) | .+[$x]'
|
||
input: |
|
||
{"foo": 42}
|
||
expected: |
|
||
[42,{"foo":42}]
|
||
|
||
- name: binding variable scope in array
|
||
args:
|
||
- -c
|
||
- '. as $x | [.foo as $x | $x] | $x'
|
||
input: |
|
||
{"foo":42}
|
||
expected: |
|
||
{"foo":42}
|
||
|
||
- name: binding variable scope in object
|
||
args:
|
||
- -c
|
||
- '. as $x | {bar: (.foo as $x | $x)} | $x'
|
||
input: |
|
||
{"foo":"bar"}
|
||
expected: |
|
||
{"foo":"bar"}
|
||
|
||
- name: binding variable scope in object key
|
||
args:
|
||
- -c
|
||
- '. as $x | {(.foo as $x | $x): $x}'
|
||
input: |
|
||
{"foo":"bar"}
|
||
expected: |
|
||
{"bar":{"foo":"bar"}}
|
||
|
||
- name: binding variable scope in condition
|
||
args:
|
||
- -c
|
||
- '. as $x | if (.foo,.bar) as $x | $x then 1 as $x | $x else 2 as $x | $x end | [., $x]'
|
||
input: |
|
||
{"foo":"bar"}
|
||
expected: |
|
||
[1,{"foo":"bar"}]
|
||
[2,{"foo":"bar"}]
|
||
|
||
- name: binding variable scope in reduce
|
||
args:
|
||
- '[range(.)] | 3 as $x | reduce .[] as $i (.[5] as $x | $x; . + $x + $i)'
|
||
input: '10'
|
||
expected: |
|
||
80
|
||
|
||
- name: binding variable scope in foreach
|
||
args:
|
||
- -c
|
||
- '[2 as $x | foreach range(.) as $item (. as $x | $x; . + $item * $x; . + $x)]'
|
||
input: '5'
|
||
expected: |
|
||
[7,9,13,19,27]
|
||
|
||
- name: binding variable scope error in parenthesis
|
||
args:
|
||
- '(. as $i | $i) | $i'
|
||
input: '0'
|
||
error: |
|
||
variable not defined: $i
|
||
exit_code: 3
|
||
|
||
- name: binding variable scope error in array
|
||
args:
|
||
- '[. as $i | $i] | $i'
|
||
input: '0'
|
||
error: |
|
||
variable not defined: $i
|
||
exit_code: 3
|
||
|
||
- name: binding variable scope error in object
|
||
args:
|
||
- '{x: (. as $i | $i)} | $i'
|
||
input: '0'
|
||
error: |
|
||
variable not defined: $i
|
||
exit_code: 3
|
||
|
||
- name: binding variable scope error in object key
|
||
args:
|
||
- '{(. as $i | $i): $i}'
|
||
input: '"x"'
|
||
error: |
|
||
variable not defined: $i
|
||
exit_code: 3
|
||
|
||
- name: binding variable scope with function declaration
|
||
args:
|
||
- -n
|
||
- -c
|
||
- '"x" as $v | def f: $v; "y" as $v | [., f, $v]'
|
||
input: 'null'
|
||
expected: |
|
||
[null,"x","y"]
|
||
|
||
- name: function scope in parenthesis
|
||
args:
|
||
- 'def f: 1; . | (def f: 2; f) | f, .'
|
||
input: '0'
|
||
expected: |
|
||
1
|
||
2
|
||
|
||
- name: function scope in array
|
||
args:
|
||
- -c
|
||
- 'def f: 1; . | [def f: 2; f] | f, .'
|
||
input: '0'
|
||
expected: |
|
||
1
|
||
[2]
|
||
|
||
- name: function scope in object
|
||
args:
|
||
- -c
|
||
- 'def f: 1; . | {bar: (def f: .foo; f)} | f, .'
|
||
input: |
|
||
{"foo":"bar"}
|
||
expected: |
|
||
1
|
||
{"bar":"bar"}
|
||
|
||
- name: function scope in object key
|
||
args:
|
||
- -c
|
||
- 'def f: 1; . | {(def f: "foo"; f): f}'
|
||
input: '0'
|
||
expected: |
|
||
{"foo":1}
|
||
|
||
- name: function scope error in parenthesis
|
||
args:
|
||
- '(def f: 1; f) | f'
|
||
input: '0'
|
||
error: |
|
||
function not defined: f/0
|
||
exit_code: 3
|
||
|
||
- name: function scope error in array
|
||
args:
|
||
- '[def f: 1; f] | f'
|
||
input: '0'
|
||
error: |
|
||
function not defined: f/0
|
||
exit_code: 3
|
||
|
||
- name: function scope error in object
|
||
args:
|
||
- '{x: (def f: 1; f)} | f'
|
||
input: '0'
|
||
error: |
|
||
function not defined: f/0
|
||
exit_code: 3
|
||
|
||
- name: function scope error in object key
|
||
args:
|
||
- '{(def f: 1; f): f}'
|
||
input: '"x"'
|
||
error: |
|
||
function not defined: f/0
|
||
exit_code: 3
|
||
|
||
- name: first/0, last/0, nth/1 functions
|
||
args:
|
||
- -c
|
||
- '[first, last, nth(-6,-5,-1,0,2,5)]'
|
||
input: '[1,2,3,4,5]'
|
||
expected: |
|
||
[1,5,null,1,5,1,3,null]
|
||
|
||
- name: first/1, last/1, nth/2 functions
|
||
args:
|
||
- -c
|
||
- '[first(.[]), last(.[]), nth(0,3,5;.[]), nth(9;range(infinite))]'
|
||
input: '[1,2,3,4,5]'
|
||
expected: |
|
||
[1,5,1,4,9]
|
||
|
||
- name: first/1, last/1, nth/2 functions on empty
|
||
args:
|
||
- -c
|
||
- '[first(.[]), last(.[]), nth(0;.[])]'
|
||
input: '[]'
|
||
expected: |
|
||
[]
|
||
|
||
- name: first/1 function with optional operator
|
||
args:
|
||
- 'first(.), first(.?), first(.,.), first(.?,.), first(.,.?), first(.?,.?)'
|
||
input: 'null'
|
||
expected: |
|
||
null
|
||
null
|
||
null
|
||
null
|
||
null
|
||
null
|
||
|
||
- name: first/1 function nested
|
||
args:
|
||
- 'first((null, null) | first(null))'
|
||
input: 'null'
|
||
expected: |
|
||
null
|
||
|
||
- name: nth/2 function with negative index
|
||
args:
|
||
- 'nth(-1;.[])'
|
||
input: '[]'
|
||
error: |
|
||
error: nth doesn't support negative index
|
||
|
||
- name: nth/2 function with infinite range
|
||
args:
|
||
- 'nth(range(3); range(infinite))'
|
||
input: 'null'
|
||
expected: |
|
||
0
|
||
1
|
||
2
|
||
|
||
- name: nth/2 function with error
|
||
args:
|
||
- 'nth(1; 0,1,error)'
|
||
input: 'null'
|
||
expected: |
|
||
1
|
||
|
||
- name: all/2 function in first/1 argument
|
||
args:
|
||
- 'first(range(1; 200) | . as $x | select(all(range(1; 7); $x % . == 0)))'
|
||
input: 'null'
|
||
expected: |
|
||
60
|
||
|
||
- name: limit/2 function
|
||
args:
|
||
- -c
|
||
- '[limit(0,3,13; range(infinite))]'
|
||
input: 'null'
|
||
expected: |
|
||
[0,1,2,0,1,2,3,4,5,6,7,8,9,10,11,12]
|
||
|
||
- name: limit/2 function with negative count
|
||
args:
|
||
- 'limit(-1; range(3))'
|
||
input: 'null'
|
||
error: |
|
||
limit doesn't support negative count
|
||
|
||
- name: skip/2 function
|
||
args:
|
||
- -c
|
||
- '[skip(0,3,5,7; range(5))]'
|
||
input: 'null'
|
||
expected: |
|
||
[0,1,2,3,4,3,4]
|
||
|
||
- name: skip/2 function with negative count
|
||
args:
|
||
- 'skip(-1; range(3))'
|
||
input: 'null'
|
||
error: |
|
||
skip doesn't support negative count
|
||
|
||
- name: all/0, any/0 functions
|
||
args:
|
||
- -c
|
||
- '[all, any]'
|
||
input: |
|
||
[]
|
||
[false, false]
|
||
[false, true]
|
||
[true, true]
|
||
expected: |
|
||
[true,false]
|
||
[false,false]
|
||
[false,true]
|
||
[true,true]
|
||
|
||
- name: all/1, any/1 functions
|
||
args:
|
||
- -c
|
||
- '[all(not), any(not)]'
|
||
input: |
|
||
[]
|
||
[false, false]
|
||
[false, true]
|
||
[true, true]
|
||
expected: |
|
||
[true,false]
|
||
[true,true]
|
||
[false,true]
|
||
[false,false]
|
||
|
||
- name: all/2, any/2 functions
|
||
args:
|
||
- -c
|
||
- '[all(range(.); not), any(range(.); not)]'
|
||
input: '0 1'
|
||
expected: |
|
||
[true,false]
|
||
[false,false]
|
||
|
||
- name: isempty function
|
||
args:
|
||
- -c
|
||
- '[isempty(empty), isempty(range(infinite)), isempty(1,error("foo"))]'
|
||
input: 'null'
|
||
expected: |
|
||
[true,false,false]
|
||
|
||
- name: isempty function nested
|
||
args:
|
||
- 'isempty(isempty(empty))'
|
||
input: 'null'
|
||
expected: |
|
||
false
|
||
|
||
- name: first/1 in isempty function
|
||
args:
|
||
- 'isempty(first(null))'
|
||
input: 'null'
|
||
expected: |
|
||
false
|
||
|
||
- name: sin, cos, tan functions
|
||
args:
|
||
- -c
|
||
- 'map(sin), map(cos), map(tan) | map(. * 1000000000 | floor / 1000000000)'
|
||
input: '[0, 1, 2]'
|
||
expected: |
|
||
[0,0.841470984,0.909297426]
|
||
[1,0.540302305,-0.416146837]
|
||
[0,1.557407724,-2.185039864]
|
||
|
||
- name: asin, acos, atan functions
|
||
args:
|
||
- -c
|
||
- 'map(asin), map(acos), map(atan) | map(. * 1000000000 | floor / 1000000000)'
|
||
input: '[0, 1, 2]'
|
||
expected: |
|
||
[0,1.570796326,null]
|
||
[1.570796326,0,null]
|
||
[0,0.785398163,1.107148717]
|
||
|
||
- name: sinh, cosh, tanh functions
|
||
args:
|
||
- -c
|
||
- 'map(sinh), map(cosh), map(tanh) | map(. * 1000000000 | floor / 1000000000)'
|
||
input: '[0, 1, 2]'
|
||
expected: |
|
||
[0,1.175201193,3.626860407]
|
||
[1,1.543080634,3.762195691]
|
||
[0,0.761594155,0.96402758]
|
||
|
||
- name: asinh, acosh, atanh functions
|
||
args:
|
||
- -c
|
||
- 'map(asinh), map(acosh), map(atanh) | map(. * 1000000000 | floor / 1000000000)'
|
||
input: '[0, 1, 2]'
|
||
expected: |
|
||
[0,0.881373587,1.443635475]
|
||
[null,0,1.316957896]
|
||
[0,1.7976931348623157e+308,null]
|
||
|
||
- name: floor, ceil, trunc, fabs functions
|
||
args:
|
||
- -c
|
||
- 'map(floor), map(ceil), map(trunc), map(fabs)'
|
||
input: '[-3.7, -3.3, -2.5, -1.7, -1.0, -0.7, -0.3, 0.0, 0.3, 0.5, 0.7, 1.0, 1.7, 2.5, 3.3, 3.7]'
|
||
expected: |
|
||
[-4,-4,-3,-2,-1,-1,-1,0,0,0,0,1,1,2,3,3]
|
||
[-3,-3,-2,-1,-1,-0,-0,0,1,1,1,1,2,3,4,4]
|
||
[-3,-3,-2,-1,-1,-0,-0,0,0,0,0,1,1,2,3,3]
|
||
[3.7,3.3,2.5,1.7,1,0.7,0.3,0,0.3,0.5,0.7,1,1.7,2.5,3.3,3.7]
|
||
|
||
- name: math functions against large number literals
|
||
args:
|
||
- -c
|
||
- '[floor, ceil, sqrt, exp10]'
|
||
input: |
|
||
1e1000
|
||
-1e1000
|
||
expected: |
|
||
[1.7976931348623157e+308,1.7976931348623157e+308,1.7976931348623157e+308,1.7976931348623157e+308]
|
||
[-1.7976931348623157e+308,-1.7976931348623157e+308,null,0]
|
||
|
||
- name: round, nearbyint, rint functions
|
||
args:
|
||
- -c
|
||
- 'map(round), map(nearbyint), map(rint)'
|
||
input: '[-2.5, -1.7, -1.5, -1.2, -0.7, -0.5, -0.3, 0.0, 0.3, 0.5, 0.7, 1.2, 1.5, 1.7, 2.5]'
|
||
expected: |
|
||
[-3,-2,-2,-1,-1,-1,-0,0,0,1,1,1,2,2,3]
|
||
[-2,-2,-2,-1,-1,-0,-0,0,0,0,1,1,2,2,2]
|
||
[-2,-2,-2,-1,-1,-0,-0,0,0,0,1,1,2,2,2]
|
||
|
||
- name: sqrt and cbrt functions
|
||
args:
|
||
- -c
|
||
- 'map(sqrt), map(cbrt) | map(. * 1000000000 | floor / 1000000000)'
|
||
input: '[-8, -3.375, 0, 0.125, 1, 4, 8, 9, 16.777216]'
|
||
expected: |
|
||
[null,null,0,0.35355339,1,2,2.828427124,3,4.096]
|
||
[-2,-1.5,0,0.5,1,1.587401051,2,2.080083823,2.56]
|
||
|
||
- name: significand function
|
||
args:
|
||
- -c
|
||
- 'map(significand)'
|
||
input: '[0, -0.5, 1, -1.5, 2, 10, 64, 100, 5e-324, -5e-324]'
|
||
expected: |
|
||
[0,-1,1,-1.5,1,1.25,1,1.5625,1,-1]
|
||
|
||
- name: exp, exp10, exp2, expm1 functions
|
||
args:
|
||
- -c
|
||
- 'map(exp), map(exp10), map(exp2), map(expm1) | map(. * 1000000000 | floor / 1000000000)'
|
||
input: '[0, -0.5, 1, -1.5, 2, 10, 20]'
|
||
expected: |
|
||
[1,0.606530659,2.718281828,0.22313016,7.389056098,22026.465794806,485165195.4097903]
|
||
[1,0.316227766,10,0.031622776,100,10000000000,99999999999999980000]
|
||
[1,0.707106781,2,0.35355339,4,1024,1048576]
|
||
[0,-0.393469341,1.718281828,-0.77686984,6.389056098,22025.465794806,485165194.4097903]
|
||
|
||
- name: frexp, modf function
|
||
args:
|
||
- -c
|
||
- 'map(frexp), map(modf)'
|
||
input: '[0, 0.25, -0.5, 1, -1.5, 2, 3.125]'
|
||
expected: |
|
||
[[0,0],[0.5,-1],[-0.5,0],[0.5,1],[-0.75,1],[0.5,2],[0.78125,2]]
|
||
[[0,0],[0.25,0],[-0.5,-0],[0,1],[-0.5,-1],[0,2],[0.125,3]]
|
||
|
||
- name: modf against infinite
|
||
args:
|
||
- -c
|
||
- 'infinite, -infinite | modf'
|
||
input: 'null'
|
||
expected: |
|
||
[0,1.7976931348623157e+308]
|
||
[-0,-1.7976931348623157e+308]
|
||
|
||
- name: log, log10, log1p, log2, logb functions
|
||
args:
|
||
- -c
|
||
- 'map(log), map(log10), map(log1p), map(log2), map(logb) | map(. * 1000000000 | floor / 1000000000)'
|
||
input: '[0, -0.5, 1, 1.5, 2, 10, 64, 100]'
|
||
expected: |
|
||
[-1.7976931348623157e+308,null,0,0.405465108,0.69314718,2.302585092,4.158883083,4.605170185]
|
||
[-1.7976931348623157e+308,null,0,0.176091259,0.301029995,1,1.806179973,2]
|
||
[0,-0.693147181,0.69314718,0.916290731,1.098612288,2.397895272,4.174387269,4.615120516]
|
||
[-1.7976931348623157e+308,null,0,0.5849625,1,3.321928094,6,6.643856189]
|
||
[-1.7976931348623157e+308,-1,0,0,1,3,6,6]
|
||
|
||
- name: gamma, tgamma, lgamma functions
|
||
args:
|
||
- -c
|
||
- 'map(gamma), map(tgamma), map(lgamma) | map(. * 1000000000 | floor / 1000000000)'
|
||
input: '[0, -0.5, 1, -1.5, 2, 10]'
|
||
expected: |
|
||
[1.7976931348623157e+308,-3.544907702,1,2.363271801,1,362880]
|
||
[1.7976931348623157e+308,-3.544907702,1,2.363271801,1,362880]
|
||
[1.7976931348623157e+308,1.265512123,0,0.860047015,0,12.80182748]
|
||
|
||
- name: erf, erfc, j0, j1, y0, y1 functions
|
||
args:
|
||
- -c
|
||
- 'map(erf), map(erfc), map(j0), map(j1), map(y0), map(y1) | map(. * 1000000000 | floor / 1000000000)'
|
||
input: '[0, -0.5, 1, -1.5, 2, 10]'
|
||
expected: |
|
||
[0,-0.520499878,0.842700792,-0.966105147,0.995322265,1]
|
||
[1,1.520499877,0.157299207,1.966105146,0.004677734,0]
|
||
[1,0.938469807,0.765197686,0.511827671,0.223890779,-0.245935765]
|
||
[0,-0.242268458,0.440050585,-0.557936508,0.576724807,0.043472746]
|
||
[-1.7976931348623157e+308,null,0.088256964,null,0.510375672,0.055671167]
|
||
[-1.7976931348623157e+308,null,-0.781212822,null,-0.107032432,0.249015424]
|
||
|
||
- name: fdim/2, fmax/2, fmin/2 functions
|
||
args:
|
||
- -c
|
||
- '[fdim(0.25,0.625; 0.125,0.375)], [fmax(0.1,0.3; 0.2,0.4)], [fmin(0.1,0.3; 0.2,0.4)]'
|
||
input: 'null'
|
||
expected: |
|
||
[0.125,0.5,0,0.25]
|
||
[0.2,0.3,0.4,0.4]
|
||
[0.1,0.2,0.1,0.3]
|
||
|
||
- name: fdim/2, fmax/2, fmin/2 functions with nan
|
||
args:
|
||
- -c
|
||
- '[fdim(1,nan; 1,nan)], [fmax(1,nan; 1,nan)], [fmin(1,nan; 1,nan)]'
|
||
input: 'null'
|
||
expected: |
|
||
[0,null,null,null]
|
||
[1,1,1,null]
|
||
[1,1,1,null]
|
||
|
||
- name: copysign/2, drem/2, fmod/2, remainder/2 functions
|
||
args:
|
||
- -c
|
||
- '[copysign(0,0.5,-1.5; 0,1,-3.5)], [drem(0.5,-0.75,1.125; 0.5,-0.25)],
|
||
[fmod(0.5,-0.75,1.125; 0.5,-0.25)], [remainder(0.5,-0.75,1.125; 0.5,-0.25)]'
|
||
input: 'null'
|
||
expected: |
|
||
[0,0.5,1.5,0,0.5,1.5,-0,-0.5,-1.5]
|
||
[0,0.25,0.125,0,-0,0.125]
|
||
[0,-0.25,0.125,0,-0,0.125]
|
||
[0,0.25,0.125,0,-0,0.125]
|
||
|
||
- name: nextafter/2, nexttoward/2 functions
|
||
args:
|
||
- -c
|
||
- '[nextafter(0,0.5,-0.75; 0.5,-0.25)], [nexttoward(0,0.5,-0.75; 0.5,-0.25)]'
|
||
input: 'null'
|
||
expected: |
|
||
[5e-324,0.5,-0.7499999999999999,-5e-324,0.49999999999999994,-0.7499999999999999]
|
||
[5e-324,0.5,-0.7499999999999999,-5e-324,0.49999999999999994,-0.7499999999999999]
|
||
|
||
- name: atan2/2, hypot/2 functions
|
||
args:
|
||
- -c
|
||
- '[atan2(0,1; 0,1,-3)], [hypot(0,-3.75,12; 0,5,-16)] | map(. * 1000000000 | floor / 1000000000)'
|
||
input: 'null'
|
||
expected: |
|
||
[0,1.570796326,0,0.785398163,3.141592653,2.819842099]
|
||
[0,3.75,12,5,6.25,13,16,16.433578429,20]
|
||
|
||
- name: ldexp/2, scalb/2, scalbln/2 functions
|
||
args:
|
||
- -c
|
||
- '[ldexp(0,0.5,2; 0,0.5,-2,3,10)], [scalb(0,0.5,2; 0,0.5,-2,3,10)], [scalbln(0,0.5,2; 0,0.5,-2,3,10)]'
|
||
input: 'null'
|
||
expected: |
|
||
[0,0.5,2,0,0.5,2,0,0.125,0.5,0,4,16,0,512,2048]
|
||
[0,0.5,2,0,0.5,2,0,0.125,0.5,0,4,16,0,512,2048]
|
||
[0,0.5,2,0,0.5,2,0,0.125,0.5,0,4,16,0,512,2048]
|
||
|
||
- name: jn/2, pow/2, yn/2 functions
|
||
args:
|
||
- -c
|
||
- '[jn(0,0.5,2; 0,0.5,-2,3,10)], [pow(0,0.5,2; 0,0.5,-2,3,10)], [yn(0,0.5,2; 0.5,-2,3,10)] | map(. * 1000000000 | floor / 1000000000)'
|
||
input: 'null'
|
||
expected: |
|
||
[1,1,0,0.938469807,0.938469807,0.030604023,0.223890779,0.223890779,0.352834028,-0.260051955,-0.260051955,0.48609126,-0.245935765,-0.245935765,0.254630313]
|
||
[1,1,1,0,0.707106781,1.414213562,1.7976931348623157e+308,4,0.25,0,0.125,8,0,0.000976562,1024]
|
||
[-0.444518734,-0.444518734,-5.441370838,null,null,null,0.37685001,0.37685001,-0.160400394,0.055671167,0.055671167,-0.005868083]
|
||
|
||
- name: fma/3 function
|
||
args:
|
||
- -c
|
||
- '[fma(1.5,2.5; 3.5,4.5; 5.25,6.75)]'
|
||
input: 'null'
|
||
expected: |
|
||
[10.5,14,12,16.5,12,15.5,13.5,18]
|
||
|
||
- name: infinite function
|
||
args:
|
||
- -c
|
||
- '[infinite, -infinite] | (.[], .[]+.[], .[]-.[], .[]*.[], .[]/.[], .[]%.[]%256, 1/.[], -1/.[], .[]-1e300, .[]+1e300) | [., . == infinite, . == -infinite, contains(infinite)]'
|
||
input: 'null'
|
||
expected: |
|
||
[1.7976931348623157e+308,true,false,true]
|
||
[-1.7976931348623157e+308,false,true,false]
|
||
[1.7976931348623157e+308,true,false,true]
|
||
[null,false,false,false]
|
||
[null,false,false,false]
|
||
[-1.7976931348623157e+308,false,true,false]
|
||
[null,false,false,false]
|
||
[-1.7976931348623157e+308,false,true,false]
|
||
[1.7976931348623157e+308,true,false,true]
|
||
[null,false,false,false]
|
||
[1.7976931348623157e+308,true,false,true]
|
||
[-1.7976931348623157e+308,false,true,false]
|
||
[-1.7976931348623157e+308,false,true,false]
|
||
[1.7976931348623157e+308,true,false,true]
|
||
[null,false,false,false]
|
||
[null,false,false,false]
|
||
[null,false,false,false]
|
||
[null,false,false,false]
|
||
[0,false,false,false]
|
||
[-1,false,false,false]
|
||
[255,false,false,false]
|
||
[0,false,false,false]
|
||
[0,false,false,false]
|
||
[-0,false,false,false]
|
||
[-0,false,false,false]
|
||
[0,false,false,false]
|
||
[1.7976931348623157e+308,true,false,true]
|
||
[-1.7976931348623157e+308,false,true,false]
|
||
[1.7976931348623157e+308,true,false,true]
|
||
[-1.7976931348623157e+308,false,true,false]
|
||
|
||
- name: isfinite and isinfinite functions
|
||
args:
|
||
- -c
|
||
- 'infinite | ., -., 1/., 1/(-.), nan, null, "", {}, [] | [., isfinite, isinfinite]'
|
||
input: 'null'
|
||
expected: |
|
||
[1.7976931348623157e+308,false,true]
|
||
[-1.7976931348623157e+308,false,true]
|
||
[0,true,false]
|
||
[-0,true,false]
|
||
[null,true,false]
|
||
[null,false,false]
|
||
["",false,false]
|
||
[{},false,false]
|
||
[[],false,false]
|
||
|
||
- name: finites function
|
||
args:
|
||
- 'nan, infinite, -infinite | ., -., 1/. | finites'
|
||
input: 'null'
|
||
expected: |
|
||
null
|
||
null
|
||
null
|
||
0
|
||
-0
|
||
|
||
- name: nan and isnan functions
|
||
args:
|
||
- -c
|
||
- 'nan, infinite-infinite, infinite/infinite, 0, null | [., .+1, isnan]'
|
||
input: 'null'
|
||
expected: |
|
||
[null,null,true]
|
||
[null,null,true]
|
||
[null,null,true]
|
||
[0,1,false]
|
||
[null,1,false]
|
||
|
||
- name: nan and comparison
|
||
args:
|
||
- -c
|
||
- 'nan | [.<., .>., .<0, .>0, .==., .!=.], ([., 1, ., 2, .] | [min, max], sort, group_by(.))'
|
||
input: 'null'
|
||
expected: |
|
||
[true,false,true,false,false,true]
|
||
[null,2]
|
||
[null,null,null,1,2]
|
||
[[null],[null],[null],[1],[2]]
|
||
|
||
- name: isnormal function
|
||
args:
|
||
- '0, 2.2250738585072011e-308, 2.2250738585072014e-308, 1, 1.7976931348623157e+308, nan, infinite, "", [], {} | isnormal'
|
||
input: 'null'
|
||
expected: |
|
||
false
|
||
false
|
||
true
|
||
true
|
||
true
|
||
false
|
||
false
|
||
false
|
||
false
|
||
false
|
||
|
||
- name: normals function
|
||
args:
|
||
- '0, 2.2250738585072011e-308, 2.2250738585072014e-308, 1, 1.7976931348623157e+308, nan, infinite | ., -. | normals'
|
||
input: 'null'
|
||
expected: |
|
||
2.2250738585072014e-308
|
||
-2.2250738585072014e-308
|
||
1
|
||
-1
|
||
1.7976931348623157e+308
|
||
-1.7976931348623157e+308
|
||
|
||
- name: normals with nextafter function
|
||
args:
|
||
- '0, 2.2250738585072014e-308, 1.7976931348623157e+308, nan, infinite | nextafter(.; 0, infinite) | normals'
|
||
input: 'null'
|
||
expected: |
|
||
2.225073858507202e-308
|
||
1.7976931348623155e+308
|
||
1.7976931348623157e+308
|
||
|
||
- name: stringify nan and infinite
|
||
args:
|
||
- -c
|
||
- 'nan, infinite, -infinite | [., tostring]'
|
||
input: 'null'
|
||
expected: |
|
||
[null,"null"]
|
||
[1.7976931348623157e+308,"1.7976931348623157e+308"]
|
||
[-1.7976931348623157e+308,"-1.7976931348623157e+308"]
|
||
|
||
- name: truncate_stream function
|
||
args:
|
||
- -c
|
||
- '[truncate_stream([[0],1],[[1,0],2],[[1,0]],[[1]])]'
|
||
input: '0 1 2'
|
||
expected: |
|
||
[[[0],1],[[1,0],2],[[1,0]],[[1]]]
|
||
[[[0],2],[[0]]]
|
||
[]
|
||
|
||
- name: fromstream function
|
||
args:
|
||
- -c
|
||
- 'fromstream(range(5) | truncate_stream({x:[1,{y:[2]},3],z:[4]} | tostream))'
|
||
input: 'null'
|
||
expected: |
|
||
{"x":[1,{"y":[2]},3],"z":[4]}
|
||
[1,{"y":[2]},3]
|
||
[4]
|
||
{"y":[2]}
|
||
[2]
|
||
|
||
- name: tostream function
|
||
args:
|
||
- -c
|
||
- 'tostream'
|
||
input: '[0,[1,{"a":1},{"b":2}]]'
|
||
expected: |
|
||
[[0],0]
|
||
[[1,0],1]
|
||
[[1,1,"a"],1]
|
||
[[1,1,"a"]]
|
||
[[1,2,"b"],2]
|
||
[[1,2,"b"]]
|
||
[[1,2]]
|
||
[[1]]
|
||
|
||
- name: setpath function
|
||
args:
|
||
- -c
|
||
- 'setpath([["a","b",0,1,2],[1,2,"a","b"]][]; 1,2)'
|
||
input: 'null'
|
||
expected: |
|
||
{"a":{"b":[[null,[null,null,1]]]}}
|
||
[null,[null,null,{"a":{"b":1}}]]
|
||
{"a":{"b":[[null,[null,null,2]]]}}
|
||
[null,[null,null,{"a":{"b":2}}]]
|
||
|
||
- name: setpath function deeply
|
||
args:
|
||
- -c
|
||
- 'setpath(["a","b",0,1]; 1,2)'
|
||
input: '{"a":{"b":[]}}'
|
||
expected: |
|
||
{"a":{"b":[[null,1]]}}
|
||
{"a":{"b":[[null,2]]}}
|
||
|
||
- name: setpath function negative index
|
||
args:
|
||
- -c
|
||
- 'setpath(-2,0,2 | [.]; 4,5)'
|
||
input: '[1,2,3]'
|
||
expected: |
|
||
[1,4,3]
|
||
[4,2,3]
|
||
[1,2,4]
|
||
[1,5,3]
|
||
[5,2,3]
|
||
[1,2,5]
|
||
|
||
- name: setpath function empty path
|
||
args:
|
||
- -c
|
||
- 'setpath([]; 10)'
|
||
input: 'null'
|
||
expected: |
|
||
10
|
||
|
||
- name: setpath function error
|
||
args:
|
||
- 'setpath([-1]; 10)'
|
||
input: '[]'
|
||
error: |
|
||
setpath([-1]; 10) cannot be applied to []: array index should not be negative: -1
|
||
|
||
- name: setpath function error
|
||
args:
|
||
- 'setpath(["a","b","c"]; 10)'
|
||
input: '{"a":{"b":[]}}'
|
||
error: |
|
||
setpath(["a","b","c"]; 10) cannot be applied to {"a":{"b":[]}}: expected an object but got: array ([])
|
||
|
||
- name: setpath function error
|
||
args:
|
||
- 'setpath(["a",1]; 10)'
|
||
input: '{"a":{"b":[]}}'
|
||
error: |
|
||
setpath(["a",1]; 10) cannot be applied to {"a":{"b":[]}}: expected an array but got: object ({"b":[]})
|
||
|
||
- name: setpath function error
|
||
args:
|
||
- 'setpath([{}]; 10)'
|
||
input: 'null'
|
||
error: |
|
||
setpath([{}]; 10) cannot be applied to null: expected "start" and "end" for slicing but got: object ({})
|
||
|
||
- name: setpath function error
|
||
args:
|
||
- 'setpath([{start:0}]; 10)'
|
||
input: 'null'
|
||
error: |
|
||
setpath([{"start":0}]; 10) cannot be applied to null: expected "start" and "end" for slicing but got: object ({"start":0})
|
||
|
||
- name: setpath function error
|
||
args:
|
||
- 'setpath([[]]; 10)'
|
||
input: '[]'
|
||
error: |
|
||
setpath([[]]; 10) cannot be applied to []: expected a number for indexing an array but got: array ([])
|
||
|
||
- name: setpath function error
|
||
args:
|
||
- 'setpath([{start:0,end:1}]; 10)'
|
||
input: '[]'
|
||
error: |
|
||
setpath([{"end":1,"start":0}]; 10) cannot be applied to []: expected an array but got: number (10)
|
||
|
||
- name: setpath function error
|
||
args:
|
||
- 'setpath([{start:"x",end:2}]; [9])'
|
||
input: '[1,2,3]'
|
||
error: |
|
||
setpath([{"end":2,"start":"x"}]; [9]) cannot be applied to [1,2,3]: expected a number for indexing an array but got: string ("x")
|
||
|
||
- name: delpaths function
|
||
args:
|
||
- -c
|
||
- 'delpaths([["a",1,"b",1]])'
|
||
input: '{"a":[{},{"b":[1,2,3]}]}'
|
||
expected: |
|
||
{"a":[{},{"b":[1,3]}]}
|
||
|
||
- name: delpaths function against array
|
||
args:
|
||
- -c
|
||
- 'delpaths([[2],[6],[4]])'
|
||
input: '[1,2,3,4,5]'
|
||
expected: |
|
||
[1,2,4]
|
||
|
||
- name: delpaths function not found key
|
||
args:
|
||
- -c
|
||
- 'delpaths([["a","b","c"]])'
|
||
input: '{}'
|
||
expected: |
|
||
{}
|
||
|
||
- name: delpaths function out of index
|
||
args:
|
||
- -c
|
||
- 'delpaths([[2],[-10],[10],[-3]])'
|
||
input: '[1,2,3,4,5]'
|
||
expected: |
|
||
[1,2,4,5]
|
||
|
||
- name: delpaths function with overlapping paths
|
||
args:
|
||
- -c
|
||
- 'delpaths([["x"],["x",0,"y"]], [["x",0],["x",0,"y"]], [["x"],["x",{"start":0}]])'
|
||
input: '{"x":[{"y":0}]}'
|
||
expected: |
|
||
{}
|
||
{"x":[]}
|
||
{}
|
||
|
||
- name: delpaths function against null
|
||
args:
|
||
- 'delpaths([["a"]]), delpaths([["a","b"]]), delpaths([[0]]), delpaths([[-1]]), delpaths([[{start:1,end:2}]])'
|
||
input: 'null'
|
||
expected: |
|
||
null
|
||
null
|
||
null
|
||
null
|
||
null
|
||
|
||
- name: delpaths function error
|
||
args:
|
||
- 'delpaths([{}])'
|
||
input: '[]'
|
||
error: |
|
||
delpaths([{}]) cannot be applied to []: expected an array but got: object ({})
|
||
|
||
- name: delpaths function error
|
||
args:
|
||
- 'delpaths([["x"]])'
|
||
input: '[]'
|
||
error: |
|
||
delpaths([["x"]]) cannot be applied to []: expected an object but got: array ([])
|
||
|
||
- name: delpaths function error
|
||
args:
|
||
- 'delpaths([[{"start":1,"end":{}}]])'
|
||
input: '[1,2,3]'
|
||
error: |
|
||
delpaths([[{"end":{},"start":1}]]) cannot be applied to [1,2,3]: expected a number for indexing an array but got: object ({})
|
||
|
||
- name: getpath function
|
||
args:
|
||
- -c
|
||
- 'getpath(["a",1,"b",2])'
|
||
input: '{"a":[{},{"b":[1,2,3]}]}'
|
||
expected: |
|
||
3
|
||
|
||
- name: getpath function empty path
|
||
args:
|
||
- -c
|
||
- 'getpath([])'
|
||
input: '{"a":[{},{"b":[1,2,3]}]}'
|
||
expected: |
|
||
{"a":[{},{"b":[1,2,3]}]}
|
||
|
||
- name: getpath function against string
|
||
args:
|
||
- -c
|
||
- '[getpath([{"start":1,"end":3}]), getpath([{"start":-2,"end":null}]), getpath([1]), getpath([])]'
|
||
input: '"abcde"'
|
||
expected: |
|
||
["bc","de","b","abcde"]
|
||
|
||
- name: getpath function against string in a container
|
||
args:
|
||
- -c
|
||
- 'getpath(["a",{"start":0,"end":2}]), getpath(["a",1])'
|
||
input: '{"a":"abc"}'
|
||
expected: |
|
||
"ab"
|
||
"b"
|
||
|
||
- name: getpath function against string round trip with path function
|
||
args:
|
||
- -c
|
||
- '[getpath(path(.[1:3])), getpath(path(.[1]))]'
|
||
input: '"abcde"'
|
||
expected: |
|
||
["bc","b"]
|
||
|
||
- name: getpath function against string round trip in a container
|
||
args:
|
||
- -c
|
||
- '. as $d | [path(.a[0:2]), path(.b[1])] | map(. as $p | $d | getpath($p))'
|
||
input: '{"a":"abc","b":"xyz"}'
|
||
expected: |
|
||
["ab","y"]
|
||
|
||
- name: getpath function against string with object key
|
||
args:
|
||
- 'getpath(["k"])'
|
||
input: '"abc"'
|
||
error: |
|
||
getpath(["k"]) cannot be applied to "abc": expected an object but got: string ("abc")
|
||
|
||
- name: getpath function error
|
||
args:
|
||
- 'getpath(["a",1,"b","c"])'
|
||
input: '{"a":[{},{"b":[1,2,3,4,5,6,7]}]}'
|
||
error: |
|
||
getpath(["a",1,"b","c"]) cannot be applied to {"a":[{},{"b":[1,2,3,4,5, ...}: expected an object but got: array ([1,2,3,4,5,6,7])
|
||
|
||
- name: setpath, delpaths, getpath functions
|
||
args:
|
||
- -c
|
||
- '["foo",1] as $p | getpath($p), setpath($p; 2), delpaths([$p]), .'
|
||
input: |
|
||
{"foo":[0,1]}
|
||
{"bar":false}
|
||
expected: |
|
||
1
|
||
{"foo":[0,2]}
|
||
{"foo":[0]}
|
||
{"foo":[0,1]}
|
||
null
|
||
{"bar":false,"foo":[null,2]}
|
||
{"bar":false}
|
||
{"bar":false}
|
||
|
||
- name: setpath to getpath
|
||
args:
|
||
- -c
|
||
- '.[] | try (getpath(["a",0,"b"]) |= 5) catch .'
|
||
input: '[null,{"b":0},{"a":0},{"a":null},{"a":[0,1]},{"a":{"b":1}},{"a":[{}]},{"a":[{"c":3}]}]'
|
||
expected: |
|
||
{"a":[{"b":5}]}
|
||
{"a":[{"b":5}],"b":0}
|
||
"getpath([\"a\",0,\"b\"]) cannot be applied to {\"a\":0}: expected an array but got: number (0)"
|
||
{"a":[{"b":5}]}
|
||
"getpath([\"a\",0,\"b\"]) cannot be applied to {\"a\":[0,1]}: expected an object but got: number (0)"
|
||
"getpath([\"a\",0,\"b\"]) cannot be applied to {\"a\":{\"b\":1}}: expected an array but got: object ({\"b\":1})"
|
||
{"a":[{"b":5}]}
|
||
{"a":[{"b":5,"c":3}]}
|
||
|
||
- name: pick function
|
||
args:
|
||
- -c
|
||
- 'pick(.x, .y[2], .y[0], .z)'
|
||
input: '{"x":1, "y": [1,2,3]}'
|
||
expected: |
|
||
{"x":1,"y":[1,null,3],"z":null}
|
||
|
||
- name: map_values function
|
||
args:
|
||
- -c
|
||
- 'map_values(.*2)'
|
||
input: '[1,2,3]'
|
||
expected: |
|
||
[2,4,6]
|
||
|
||
- name: map_values function with optional operator
|
||
args:
|
||
- -c
|
||
- 'map_values(tonumber? // .)'
|
||
input: '{"x": "1", "y": "1.5", "z": "z"}'
|
||
expected: |
|
||
{"x":1,"y":1.5,"z":"z"}
|
||
|
||
- name: del function
|
||
args:
|
||
- -c
|
||
- 'del(.), del(empty), del((.foo,.bar,.baz) | .[2,3,0]), del(.foo[0], .bar[0], .foo, .baz.bar[0].x), del(.foo[1:][:3][1:], .bar[:2][1:])'
|
||
input: '{"foo": [0,1,2,3,4], "bar": [0,1]}'
|
||
expected: |
|
||
null
|
||
{"bar":[0,1],"foo":[0,1,2,3,4]}
|
||
{"bar":[1],"foo":[1,4]}
|
||
{"bar":[1]}
|
||
{"bar":[0],"foo":[0,1,4]}
|
||
|
||
- name: del function with array slicing
|
||
args:
|
||
- -c
|
||
- 'del(.[1], .[-6], .[2], .[-3:9])'
|
||
input: '[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]'
|
||
expected: |
|
||
[0,3,5,6,9]
|
||
|
||
- name: del function against large array with select
|
||
args:
|
||
- '[range(.)] | (5,7) as $x | del(.[] | select(. % $x == 0)) | add'
|
||
input: '50000'
|
||
expected: |
|
||
1000000000
|
||
1071421429
|
||
|
||
- name: del function against large array with slicing
|
||
args:
|
||
- '[range(.)] | del(.[range(length) | {start:.,end:(.+1)}])'
|
||
input: '50000'
|
||
expected: |
|
||
[]
|
||
|
||
- name: del function against null
|
||
args:
|
||
- 'del(.a), del(.a.b), del(.[0]), del(.[-1]), del(.[1:2])'
|
||
input: 'null'
|
||
expected: |
|
||
null
|
||
null
|
||
null
|
||
null
|
||
null
|
||
|
||
- name: assignment operator against object
|
||
args:
|
||
- -c
|
||
- '.foo.bar = 1'
|
||
input: 'null'
|
||
expected: |
|
||
{"foo":{"bar":1}}
|
||
|
||
- name: assignment operator against array
|
||
args:
|
||
- -c
|
||
- '.[-1,0] = 3'
|
||
input: '[0,1,2]'
|
||
expected: |
|
||
[3,1,3]
|
||
|
||
- name: assignment operator against number
|
||
args:
|
||
- '. = 1'
|
||
input: '0'
|
||
expected: |
|
||
1
|
||
|
||
- name: assignment operator against number error
|
||
args:
|
||
- '.foo = 1'
|
||
input: '0'
|
||
error: |
|
||
expected an object but got: number (0)
|
||
|
||
- name: assignment operator against object with multiple paths
|
||
args:
|
||
- -c
|
||
- '(.foo,.bar,.baz) = 1'
|
||
input: 'null'
|
||
expected: |
|
||
{"bar":1,"baz":1,"foo":1}
|
||
|
||
- name: assignment operator against array with slicing
|
||
args:
|
||
- -c
|
||
- '.[2:4] = ([], [0], [4,3,2]), .[1:-1] = [3,2], .[2:0] = [.[]], .[10:] = [1],
|
||
.[-20:-10] = [1], .[0:5] = [9], .[1:][1:] = [9], .[1:][:3] = [6,7,8],
|
||
.[:4][1:][:3] = [9], .[1:][1:-2] = [9], .[:4][-3:][:5] = [9], (null | .[:1][2:] = [9])'
|
||
input: '[1,2,3,4,5]'
|
||
expected: |
|
||
[1,2,5]
|
||
[1,2,0,5]
|
||
[1,2,4,3,2,5]
|
||
[1,3,2,5]
|
||
[1,2,1,2,3,4,5,3,4,5]
|
||
[1,2,3,4,5,1]
|
||
[1,1,2,3,4,5]
|
||
[9]
|
||
[1,2,9]
|
||
[1,6,7,8,5]
|
||
[1,9,5]
|
||
[1,2,9,4,5]
|
||
[1,9,5]
|
||
[9]
|
||
|
||
- name: assignment operator with object and array indexing
|
||
args:
|
||
- -c
|
||
- '.foo.[0].bar.[1] = 1'
|
||
input: 'null'
|
||
expected: |
|
||
{"foo":[{"bar":[null,1]}]}
|
||
|
||
- name: assignment operator against array with suffix array indexing
|
||
args:
|
||
- -c
|
||
- '.[2][2] = 1'
|
||
input: '[1]'
|
||
expected: |
|
||
[1,null,[null,null,1]]
|
||
|
||
- name: assignment operator against array with suffix object indexing
|
||
args:
|
||
- -c
|
||
- '.[2].foo = 1'
|
||
input: '[1]'
|
||
expected: |
|
||
[1,null,{"foo":1}]
|
||
|
||
- name: assignment operator against object with multiple suffix indexing
|
||
args:
|
||
- -c
|
||
- '.foo[2].bar = 2'
|
||
input: '{"foo":[1], "bar":3}'
|
||
expected: |
|
||
{"bar":3,"foo":[1,null,{"bar":2}]}
|
||
|
||
- name: assignment operator with query and suffix object indexing
|
||
args:
|
||
- -c
|
||
- '(.foo).bar = 1'
|
||
input: 'null'
|
||
expected: |
|
||
{"foo":{"bar":1}}
|
||
|
||
- name: assignment operator with object indexing and iterator suffix
|
||
args:
|
||
- -c
|
||
- '.foo[].bar = 1'
|
||
input: '{"foo":[null,null]}'
|
||
expected: |
|
||
{"foo":[{"bar":1},{"bar":1}]}
|
||
|
||
- name: assignment operator with overlapping paths
|
||
args:
|
||
- -c
|
||
- '[(.x,.x.y,.x.y.z) = {}, (.x.y.z,.x.y,.x) = {}]'
|
||
input: 'null'
|
||
expected: |
|
||
[{"x":{"y":{"z":{}}}},{"x":{}}]
|
||
|
||
- name: assignment operator with query value
|
||
args:
|
||
- -c
|
||
- '.foo = .bar'
|
||
input: '{"bar":42}'
|
||
expected: |
|
||
{"bar":42,"foo":42}
|
||
|
||
- name: assignment operator with multiple paths and query values
|
||
args:
|
||
- -c
|
||
- '(.foo,.bar,.baz) = .bar[]'
|
||
input: '{"bar":[0,1,2]}'
|
||
expected: |
|
||
{"bar":0,"baz":0,"foo":0}
|
||
{"bar":1,"baz":1,"foo":1}
|
||
{"bar":2,"baz":2,"foo":2}
|
||
|
||
- name: assignment operator with overlapping paths and multiple values
|
||
args:
|
||
- -c
|
||
- '.. = ..'
|
||
input: '{"x":{"y":{}}} [[[]]]'
|
||
expected: |
|
||
{"x":{"x":{"y":{}},"y":{"x":{"y":{}}}}}
|
||
{"x":{"y":{"y":{}}},"y":{}}
|
||
{"x":{"y":{}}}
|
||
[[[[[]]]]]
|
||
[[[[]]]]
|
||
[[[]]]
|
||
|
||
- name: assignment operator with overlapping and slicing paths
|
||
args:
|
||
- -c
|
||
- '..[:0] = ..'
|
||
input: '[[[]]]'
|
||
expected: |
|
||
[[[[[]],[]],[]],[[]]]
|
||
[[[[]]],[[]]]
|
||
[[[]]]
|
||
|
||
- name: assignment operator array index negative error
|
||
args:
|
||
- '.[-1,0] = 1'
|
||
input: '[]'
|
||
error: |
|
||
setpath([-1]; 1) cannot be applied to []: array index should not be negative: -1
|
||
|
||
- name: assignment operator array index limit error
|
||
args:
|
||
- '.[999999999] = 1'
|
||
input: '[]'
|
||
error: |
|
||
array index too large: 999999999
|
||
|
||
- name: assignment operator with select
|
||
args:
|
||
- -c
|
||
- '(.[] | select(.k == "b") | .v) = 0'
|
||
input: '[{"k": "a", "v": 1}, {"k": "b", "v": 2}, {"k": "c", "v": 3}]'
|
||
expected: |
|
||
[{"k":"a","v":1},{"k":"b","v":0},{"k":"c","v":3}]
|
||
|
||
- name: assignment operator with fork
|
||
args:
|
||
- -c
|
||
- '[range(3)] | .[] = 0 | [.[] = 1, .[] = 2]'
|
||
input: 'null'
|
||
expected: |
|
||
[[1,1,1],[2,2,2]]
|
||
|
||
- name: assignment operator against large array
|
||
args:
|
||
- '[range(.)] | .[] = 1 | add'
|
||
input: '50000'
|
||
expected: |
|
||
50000
|
||
|
||
- name: assignment operator against large array with select
|
||
args:
|
||
- '[range(.)] | (.[] | select(. % 2 > 0)) = 1 | add'
|
||
input: '50000'
|
||
expected: |
|
||
625000000
|
||
|
||
- name: assignment operator against large array with range
|
||
args:
|
||
- '[range(.)] | .[range(length)] = 1 | add'
|
||
input: '50000'
|
||
expected: |
|
||
50000
|
||
|
||
- name: assignment operator against large array with slicing
|
||
args:
|
||
- '[range(.)] | .[range(length) | {start:.,end:(.+1)}] = [1] | add'
|
||
input: '50000'
|
||
expected: |
|
||
50000
|
||
|
||
- name: assignment operator against large object
|
||
args:
|
||
- '[{key:range(.)|tostring}] | from_entries | .[] = 1 | add'
|
||
input: '50000'
|
||
expected: |
|
||
50000
|
||
|
||
- name: assignment operator constructing large array
|
||
args:
|
||
- '.[range(50000)] = 1 | add'
|
||
input: 'null'
|
||
expected: |
|
||
50000
|
||
|
||
- name: update-assignment operator
|
||
args:
|
||
- -c
|
||
- '.foo |= .+1'
|
||
input: '{"foo": 1}'
|
||
expected: |
|
||
{"foo":2}
|
||
|
||
- name: update-assignment operator deeply
|
||
args:
|
||
- -c
|
||
- '.[0].a |= {"old":., "new":(.+1)}'
|
||
input: '[{"a":1,"b":2}]'
|
||
expected: |
|
||
[{"a":{"new":2,"old":1},"b":2}]
|
||
|
||
- name: update-assignment operator in function
|
||
args:
|
||
- -c
|
||
- 'def inc(x): x |= .+1; inc(.[].a)'
|
||
input: '[{"a":1,"b":2},{"a":2,"b":4},{"a":7,"b":8}]'
|
||
expected: |
|
||
[{"a":2,"b":2},{"a":3,"b":4},{"a":8,"b":8}]
|
||
|
||
- name: update-assignment operator with empty
|
||
args:
|
||
- -c
|
||
- '.foo |= empty'
|
||
input: '{"foo": 42, "bar": 48}'
|
||
expected: |
|
||
{"bar":48}
|
||
|
||
- name: update-assignment operator with repeat
|
||
args:
|
||
- -c
|
||
- '.foo |= repeat(.)'
|
||
input: '{"foo": 42, "bar": 48}'
|
||
expected: |
|
||
{"bar":48,"foo":42}
|
||
|
||
- name: update-assignment operator with same paths
|
||
args:
|
||
- -c
|
||
- '(.foo,.foo,.foo) |= .+1'
|
||
input: '{"foo": 0}'
|
||
expected: |
|
||
{"foo":3}
|
||
|
||
- name: update-assignment operator against array with empty function
|
||
args:
|
||
- -c
|
||
- '(.[] | select(. % 2 > 0)) |= empty'
|
||
input: '[1,2,3,4,5]'
|
||
expected: |
|
||
[2,4]
|
||
|
||
- name: update-assignment operator against array with conditional empty function
|
||
args:
|
||
- -c
|
||
- '[range(.)] | .[] |= if . % 2 == 0 then empty else [., -.] end'
|
||
input: '10'
|
||
expected: |
|
||
[[1,-1],[3,-3],[5,-5],[7,-7],[9,-9]]
|
||
|
||
- name: update-assignment operator with fork
|
||
args:
|
||
- -c
|
||
- '[range(3)] | .[] |= 0 | [.[] |= 1, .[] |= 2]'
|
||
input: 'null'
|
||
expected: |
|
||
[[1,1,1],[2,2,2]]
|
||
|
||
- name: update-assignment operator against large array
|
||
args:
|
||
- '[range(.)] | .[] |= . * 2 | add'
|
||
input: '50000'
|
||
expected: |
|
||
2499950000
|
||
|
||
- name: update-assignment operator against large array with select
|
||
args:
|
||
- '[range(.)] | (.[] | select(. % 2 > 0)) |= (. * 2) | add'
|
||
input: '50000'
|
||
expected: |
|
||
1874975000
|
||
|
||
- name: update-assignment operator against large object
|
||
args:
|
||
- '[range(.) | {key:tostring,value:.}] | from_entries | .[] |= . * 2 | add'
|
||
input: '50000'
|
||
expected: |
|
||
2499950000
|
||
|
||
- name: update-assignment operator against array with overlapping paths
|
||
args:
|
||
- -c
|
||
- '(.[1:3][],.[2:4][],.[2]) |= .+1'
|
||
input: '[1,2,3,4,5]'
|
||
expected: |
|
||
[1,3,6,5,5]
|
||
|
||
- name: update-assignment operator against object with overlapping paths
|
||
args:
|
||
- -c
|
||
- '(.a.b,.a,.a.p.z) |= {p: ., q: .}'
|
||
input: '{"a":{"b":1}}'
|
||
expected: |
|
||
{"a":{"p":{"b":{"p":1,"q":1},"z":{"p":null,"q":null}},"q":{"b":{"p":1,"q":1}}}}
|
||
|
||
- name: update-assignment operator against nested object with overlapping paths
|
||
args:
|
||
- -c
|
||
- '(.a.b.c,.a,.a.p.b.z) |= {p: ., q: .}'
|
||
input: '{"a":{"b":{"c":1}}}'
|
||
expected: |
|
||
{"a":{"p":{"b":{"c":{"p":1,"q":1},"z":{"p":null,"q":null}}},"q":{"b":{"c":{"p":1,"q":1}}}}}
|
||
|
||
- name: update-assignment operator with optional operator
|
||
args:
|
||
- -c
|
||
- '.foo |= .?'
|
||
input: '{"foo": 42}'
|
||
expected: |
|
||
{"foo":42}
|
||
|
||
- name: update-assignment operator with infinite range
|
||
args:
|
||
- -c
|
||
- '[range(.)] | .[] |= range(infinite)'
|
||
input: '5'
|
||
expected: |
|
||
[0,0,0,0,0]
|
||
|
||
- name: update-assignment operator with try catch
|
||
args:
|
||
- -c
|
||
- '. |= try . catch .'
|
||
input: '1'
|
||
expected: |
|
||
1
|
||
|
||
- name: update-assignment operator with alternative operator
|
||
args:
|
||
- -c
|
||
- '.foo |= (fromjson? // "x")'
|
||
input: |
|
||
{"foo": 42}
|
||
{"foo": "42"}
|
||
{"foo": "a"}
|
||
{"foo": "0 a"}
|
||
{"foo": "true"}
|
||
{"foo": "[{}]"}
|
||
{"foo": "[][]"}
|
||
expected: |
|
||
{"foo":"x"}
|
||
{"foo":42}
|
||
{"foo":"x"}
|
||
{"foo":"x"}
|
||
{"foo":true}
|
||
{"foo":[{}]}
|
||
{"foo":"x"}
|
||
|
||
- name: update operators
|
||
args:
|
||
- -c
|
||
- '.[] += 2, .[] -= 2, .[] *= 2, .[] /= 2, .[] %= 2'
|
||
input: '[1,2,3]'
|
||
expected: |
|
||
[3,4,5]
|
||
[-1,0,1]
|
||
[2,4,6]
|
||
[0.5,1,1.5]
|
||
[1,0,1]
|
||
|
||
- name: update operator with query in right hand side
|
||
args:
|
||
- -c
|
||
- '.foo += .foo, .bar //= .foo, .[] /= .foo, .[] = .foo'
|
||
input: '{"foo":2}'
|
||
expected: |
|
||
{"foo":4}
|
||
{"bar":2,"foo":2}
|
||
{"foo":1}
|
||
{"foo":2}
|
||
|
||
- name: update operators associativity error
|
||
args:
|
||
- '. += 1 -= 2'
|
||
input: '1'
|
||
error: |
|
||
invalid query: . += 1 -= 2
|
||
. += 1 -= 2
|
||
^ unexpected token "-="
|
||
exit_code: 3
|
||
|
||
- name: error/0 function
|
||
args:
|
||
- '.foo[] | error'
|
||
input: '{ "foo": ["error message", "bar"] }'
|
||
error: |
|
||
error: error message
|
||
exit_code: 5
|
||
|
||
- name: error/0 function with null
|
||
args:
|
||
- 'error'
|
||
input: 'null'
|
||
error: |
|
||
error: null
|
||
|
||
- name: error/0 function on string and try catch
|
||
args:
|
||
- 'try error catch .'
|
||
input: '"foo"'
|
||
expected: |
|
||
"foo"
|
||
|
||
- name: error/0 function on values and try catch
|
||
args:
|
||
- 'null,1,[],{x:42} | try error catch .'
|
||
input: '0'
|
||
expected: |
|
||
null
|
||
1
|
||
[]
|
||
{
|
||
"x": 42
|
||
}
|
||
|
||
- name: error/1 function
|
||
args:
|
||
- '.foo | error("error message")'
|
||
input: '{ "foo": 1 }'
|
||
error: |
|
||
error: error message
|
||
exit_code: 5
|
||
|
||
- name: error/1 function and try catch
|
||
args:
|
||
- 'try error({ x: 42 }) catch .'
|
||
input: '0'
|
||
expected: |
|
||
{
|
||
"x": 42
|
||
}
|
||
|
||
- name: error/1 function with null
|
||
args:
|
||
- 'error(null)'
|
||
input: '1'
|
||
error: |
|
||
error: null
|
||
|
||
- name: path function identity
|
||
args:
|
||
- 'path(.)'
|
||
input: '{}'
|
||
expected: |
|
||
[]
|
||
|
||
- name: path function deep
|
||
args:
|
||
- -c
|
||
- 'path(.a|.[1,2:3,4].b[5,6])'
|
||
input: '{}'
|
||
expected: |
|
||
["a",{"end":3,"start":1},"b",5]
|
||
["a",{"end":4,"start":1},"b",5]
|
||
["a",{"end":3,"start":2},"b",5]
|
||
["a",{"end":4,"start":2},"b",5]
|
||
["a",{"end":3,"start":1},"b",6]
|
||
["a",{"end":4,"start":1},"b",6]
|
||
["a",{"end":3,"start":2},"b",6]
|
||
["a",{"end":4,"start":2},"b",6]
|
||
|
||
- name: path function select
|
||
args:
|
||
- -c
|
||
- '[path(.[] | select(. > 3))]'
|
||
input: '[1,3,5,7,3,8,9,1]'
|
||
expected: |
|
||
[[2],[3],[5],[6]]
|
||
|
||
- name: path function recurse
|
||
args:
|
||
- -c
|
||
- '[path(..)]'
|
||
input: '{"a":{"b":[0,1,2]},"c":[3,4]}'
|
||
expected: |
|
||
[[],["a"],["a","b"],["a","b",0],["a","b",1],["a","b",2],["c"],["c",0],["c",1]]
|
||
|
||
- name: path function and pattern
|
||
args:
|
||
- -c
|
||
- '(.a as $x | (.b,.c)) = "b"'
|
||
input: '{"a":null,"b":null}'
|
||
expected: |
|
||
{"a":null,"b":"b","c":"b"}
|
||
|
||
- name: path function result
|
||
args:
|
||
- -c
|
||
- '.a[path(.b)[0]]'
|
||
input: '{"a":{"b":0}}'
|
||
expected: |
|
||
0
|
||
|
||
- name: path function with select
|
||
args:
|
||
- -c
|
||
- 'path(.[] | select(.id | startswith("x")) | .id)'
|
||
input: '[{"id": "xy"}, {"id": "yx"}]'
|
||
expected: |
|
||
[0,"id"]
|
||
|
||
- name: path function with getpath
|
||
args:
|
||
- -c
|
||
- '[path(getpath([[0]] | .[0],.[]))]'
|
||
input: 'null'
|
||
expected: |
|
||
[[0],[0]]
|
||
|
||
- name: path function against nan
|
||
args:
|
||
- -c
|
||
- '[nan,{x:nan}] | path(.[1].x)'
|
||
input: 'null'
|
||
expected: |
|
||
[1,"x"]
|
||
|
||
- name: path function nested
|
||
args:
|
||
- -c
|
||
- 'path(.a[path(.b[.a:.b])[0]])'
|
||
input: '{"a":{"b":0}}'
|
||
expected: |
|
||
["a","b"]
|
||
|
||
- name: path function error with arithmetic operator
|
||
args:
|
||
- 'path(. + 1)'
|
||
input: 'null'
|
||
error: |
|
||
invalid path against: number (1)
|
||
|
||
- name: path function error with object indexing
|
||
args:
|
||
- 'path({}.x)'
|
||
input: '{}'
|
||
error: |
|
||
invalid path against: object ({})
|
||
|
||
- name: path function error with array indexing
|
||
args:
|
||
- 'path([0][0 + 0])'
|
||
input: '[0]'
|
||
error: |
|
||
invalid path against: array ([0])
|
||
|
||
- name: path function error with array slicing
|
||
args:
|
||
- 'path([0][0:1])'
|
||
input: '[0]'
|
||
error: |
|
||
invalid path against: array ([0])
|
||
|
||
- name: path function error with getpath function
|
||
args:
|
||
- 'path({} | getpath([]))'
|
||
input: '{}'
|
||
error: |
|
||
invalid path against: object ({})
|
||
|
||
- name: path function with binding array slicing
|
||
args:
|
||
- '.[:1] as $x | path($x.[0])'
|
||
input: '[0]'
|
||
expected: |
|
||
[
|
||
0
|
||
]
|
||
|
||
- name: path function error with binding array slicing
|
||
args:
|
||
- '.[:0] as $x | path($x.[0])'
|
||
input: '[0]'
|
||
error: |
|
||
invalid path against: array ([])
|
||
|
||
- name: path function with function declaration
|
||
args:
|
||
- 'def f($x): .y; path(f(.x))'
|
||
input: 'null'
|
||
expected: |
|
||
[
|
||
"y"
|
||
]
|
||
|
||
- name: path function with assignment operator
|
||
args:
|
||
- 'path(. = .x)'
|
||
input: 'null'
|
||
expected: |
|
||
[]
|
||
|
||
- name: path function iterate error of array
|
||
args:
|
||
- '[.[]][].a = 1'
|
||
input: '[{"a":0}]'
|
||
error: |
|
||
invalid path on iterating against: array ([{"a":0}])
|
||
|
||
- name: path function iterate error of object
|
||
args:
|
||
- '{}[] = 10'
|
||
input: '{}'
|
||
error: |
|
||
invalid path on iterating against: object ({})
|
||
|
||
- name: paths/0 function
|
||
args:
|
||
- -c
|
||
- 'paths'
|
||
input: '[1,[[1,{"a":2},3],{"a":[2]}]]'
|
||
expected: |
|
||
[0]
|
||
[1]
|
||
[1,0]
|
||
[1,0,0]
|
||
[1,0,1]
|
||
[1,0,1,"a"]
|
||
[1,0,2]
|
||
[1,1]
|
||
[1,1,"a"]
|
||
[1,1,"a",0]
|
||
|
||
- name: paths/1 function
|
||
args:
|
||
- -c
|
||
- 'paths(. > 2)'
|
||
input: '[1,[[1,{"a":2},3],{"a":[2]}]]'
|
||
expected: |
|
||
[1]
|
||
[1,0]
|
||
[1,0,1]
|
||
[1,0,2]
|
||
[1,1]
|
||
[1,1,"a"]
|
||
|
||
- name: bsearch function
|
||
args:
|
||
- 'bsearch(0,1,2,3,4,5,6)'
|
||
input: '[1,3,5]'
|
||
expected: |
|
||
-1
|
||
0
|
||
-2
|
||
1
|
||
-3
|
||
2
|
||
-4
|
||
|
||
- name: bsearch function with objects
|
||
args:
|
||
- '[{x:range(.),y:range(.)}] | bsearch({x:1,y:1})'
|
||
input: '3'
|
||
expected: |
|
||
4
|
||
|
||
- name: gmtime, localtime functions
|
||
args:
|
||
- -c
|
||
- 'gmtime, localtime | map(. * 1000000 | floor / 1000000)'
|
||
input: '1500000000 1567890123.456 1600000000.111 -1 -0.5 0.5'
|
||
expected: | # UTC-7 (TZ=Etc/GMT+7)
|
||
[2017,6,14,2,40,0,5,194]
|
||
[2017,6,13,19,40,0,4,193]
|
||
[2019,8,7,21,2,3.456,6,249]
|
||
[2019,8,7,14,2,3.456,6,249]
|
||
[2020,8,13,12,26,40.111,0,256]
|
||
[2020,8,13,5,26,40.111,0,256]
|
||
[1969,11,31,23,59,59,3,364]
|
||
[1969,11,31,16,59,59,3,364]
|
||
[1969,11,31,23,59,59.5,3,364]
|
||
[1969,11,31,16,59,59.5,3,364]
|
||
[1970,0,1,0,0,0.5,4,0]
|
||
[1969,11,31,17,0,0.5,3,364]
|
||
|
||
- name: mktime, strftime, strflocaltime, todate functions
|
||
args:
|
||
- -cr
|
||
- '(.,mktime | .,strftime("%Y-%m-%dT%H:%M:%SZ"),strflocaltime("%Y-%m-%dT%H:%M:%S%z")), todate'
|
||
input: |
|
||
[2017,6,14,2,40,0,5,194]
|
||
[2019,8,7,21,2,3.456,6,249]
|
||
[2020,8,13,12,26,40.111,0,256]
|
||
[2024,7,20]
|
||
[2025]
|
||
[1969,11,31,23,59,59.5,3,364]
|
||
expected: |
|
||
[2017,6,14,2,40,0,5,194]
|
||
2017-07-14T02:40:00Z
|
||
2017-07-14T02:40:00-0700
|
||
1500000000
|
||
2017-07-14T02:40:00Z
|
||
2017-07-13T19:40:00-0700
|
||
2017-07-14T02:40:00Z
|
||
[2019,8,7,21,2,3.456,6,249]
|
||
2019-09-07T21:02:03Z
|
||
2019-09-07T21:02:03-0700
|
||
1567890123.456
|
||
2019-09-07T21:02:03Z
|
||
2019-09-07T14:02:03-0700
|
||
2019-09-07T21:02:03Z
|
||
[2020,8,13,12,26,40.111,0,256]
|
||
2020-09-13T12:26:40Z
|
||
2020-09-13T12:26:40-0700
|
||
1600000000.111
|
||
2020-09-13T12:26:40Z
|
||
2020-09-13T05:26:40-0700
|
||
2020-09-13T12:26:40Z
|
||
[2024,7,20]
|
||
2024-08-20T00:00:00Z
|
||
2024-08-20T00:00:00-0700
|
||
1724112000
|
||
2024-08-20T00:00:00Z
|
||
2024-08-19T17:00:00-0700
|
||
2024-08-20T00:00:00Z
|
||
[2025]
|
||
2024-12-31T00:00:00Z
|
||
2024-12-31T00:00:00-0700
|
||
1735603200
|
||
2024-12-31T00:00:00Z
|
||
2024-12-30T17:00:00-0700
|
||
2024-12-31T00:00:00Z
|
||
[1969,11,31,23,59,59.5,3,364]
|
||
1969-12-31T23:59:59Z
|
||
1969-12-31T23:59:59-0700
|
||
-0.5
|
||
1969-12-31T23:59:59Z
|
||
1969-12-31T16:59:59-0700
|
||
1969-12-31T23:59:59Z
|
||
|
||
- name: date functions with fractional seconds
|
||
args:
|
||
- -r
|
||
- 'mktime, strftime("%Y-%m-%dT%H:%M:%S.%fZ"), strflocaltime("%Y-%m-%dT%H:%M:%S.%f%z")'
|
||
input: |
|
||
[1970,0,1,0,0,-0.5]
|
||
[1970,0,1,0,0,-1.25]
|
||
[1970,0,1,0,0,-60.25]
|
||
[1970,0,1,0,0,-1]
|
||
[1970,0,1,0,0,0]
|
||
[1970,0,1,0,0,0.5]
|
||
[1970,0,1,0,0,60.25]
|
||
expected: | # UTC-7 (TZ=Etc/GMT+7)
|
||
-0.5
|
||
1969-12-31T23:59:59.500000Z
|
||
1969-12-31T23:59:59.500000-0700
|
||
-1.25
|
||
1969-12-31T23:59:58.750000Z
|
||
1969-12-31T23:59:58.750000-0700
|
||
-60.25
|
||
1969-12-31T23:58:59.750000Z
|
||
1969-12-31T23:58:59.750000-0700
|
||
-1
|
||
1969-12-31T23:59:59.000000Z
|
||
1969-12-31T23:59:59.000000-0700
|
||
0
|
||
1970-01-01T00:00:00.000000Z
|
||
1970-01-01T00:00:00.000000-0700
|
||
0.5
|
||
1970-01-01T00:00:00.500000Z
|
||
1970-01-01T00:00:00.500000-0700
|
||
60.25
|
||
1970-01-01T00:01:00.250000Z
|
||
1970-01-01T00:01:00.250000-0700
|
||
|
||
- name: mktime after subtracting fractional seconds
|
||
args:
|
||
- 'gmtime | .[5] -= 0.5 | mktime'
|
||
input: '0 60 86400 -60'
|
||
expected: |
|
||
-0.5
|
||
59.5
|
||
86399.5
|
||
-60.5
|
||
|
||
- name: date functions with non-finite or out of range epoch timestamps
|
||
args:
|
||
- -n
|
||
- '[infinite, -infinite, nan, 1e19, -1e19, 9223372036854775807, -9223372036854775808] | .[] | try gmtime catch .'
|
||
expected: |
|
||
"gmtime cannot be applied to 1.7976931348623157e+308: number of seconds is out of range"
|
||
"gmtime cannot be applied to -1.7976931348623157e+308: number of seconds is out of range"
|
||
"gmtime cannot be applied to null: number of seconds is out of range"
|
||
"gmtime cannot be applied to 10000000000000000000: number of seconds is out of range"
|
||
"gmtime cannot be applied to -10000000000000000000: number of seconds is out of range"
|
||
"gmtime cannot be applied to 9223372036854775807: number of seconds is out of range"
|
||
"gmtime cannot be applied to -9223372036854775808: number of seconds is out of range"
|
||
|
||
- name: date functions with out of range numbers in the array
|
||
args:
|
||
- -n
|
||
- '[[infinite,0,1], [nan,0,1], [1e19,0,1], [0,1e19,1], [2001,0,1,0,0,infinite], [2001,0,1,0,0,nan], [2001,0,1,0,0,1e19], [9223372036854775807,0,1], ["x",0,1]] | .[] | try mktime catch .'
|
||
expected: |
|
||
"mktime cannot be applied to [1.7976931348623157e+308,0,1]: number is out of range"
|
||
"mktime cannot be applied to [null,0,1]: number is out of range"
|
||
"mktime cannot be applied to [10000000000000000000,0,1]: number is out of range"
|
||
"mktime cannot be applied to [0,10000000000000000000,1]: number is out of range"
|
||
"mktime cannot be applied to [2001,0,1,0,0,1.797693134 ...]: number is out of range"
|
||
"mktime cannot be applied to [2001,0,1,0,0,null]: number is out of range"
|
||
"mktime cannot be applied to [2001,0,1,0,0,10000000000 ...]: number is out of range"
|
||
"mktime cannot be applied to [9223372036854775807,0,1]: number is out of range"
|
||
"mktime cannot be applied to [\"x\",0,1]: expected an array of 8 numbers"
|
||
|
||
- name: strftime function with out of range datetime
|
||
args:
|
||
- -n
|
||
- 'try (infinite | todate) catch ., try ([1e19,0,1] | strftime("%Y")) catch .'
|
||
expected: |
|
||
"strftime(\"%Y-%m-%dT%H:%M:%SZ\") cannot be applied to 1.7976931348623157e+308: number of seconds is out of range"
|
||
"strftime(\"%Y\") cannot be applied to [10000000000000000000,0,1]: number is out of range"
|
||
|
||
- name: strptime, fromdate functions
|
||
args:
|
||
- -c
|
||
- 'strptime("%Y-%m-%dT%H:%M:%S%z")? // strptime("%Y-%m-%dT%H:%M:%S.%f%z"), fromdate?'
|
||
input: |
|
||
"2017-07-14T02:40:00Z"
|
||
"2019-09-08T06:02:03+0900"
|
||
"2020-09-13T07:26:40-05:00"
|
||
"1969-12-31T23:59:59.5+0000"
|
||
"2345-01-02T03:04:05.678901+0000"
|
||
expected: |
|
||
[2017,6,14,2,40,0,5,194]
|
||
1500000000
|
||
[2019,8,7,21,2,3,6,249]
|
||
1567890123
|
||
[2020,8,13,12,26,40,0,256]
|
||
1600000000
|
||
[1969,11,31,23,59,59.5,3,364]
|
||
[2345,0,2,3,4,5.678901,2,1]
|
||
|
||
- name: strftime, strptime functions
|
||
args:
|
||
- 'strptime("%c") | strftime("%c")'
|
||
input: |
|
||
"Thu Jul 23 20:41:06 2020"
|
||
expected: |
|
||
"Thu Jul 23 20:41:06 2020"
|
||
|
||
- name: now function
|
||
args:
|
||
- -c
|
||
- 'now | type'
|
||
input: 'null'
|
||
expected: |
|
||
"number"
|
||
|
||
- name: debug/0 function
|
||
args:
|
||
- -c
|
||
- 'recurse(debug|.[]?)'
|
||
input: |
|
||
[{}]
|
||
[1,{"a":[2,"b"]}]
|
||
expected: |
|
||
[{}]
|
||
{}
|
||
[1,{"a":[2,"b"]}]
|
||
1
|
||
{"a":[2,"b"]}
|
||
[2,"b"]
|
||
2
|
||
"b"
|
||
error: |
|
||
["DEBUG:",[{}]]
|
||
["DEBUG:",{}]
|
||
["DEBUG:",[1,{"a":[2,"b"]}]]
|
||
["DEBUG:",1]
|
||
["DEBUG:",{"a":[2,"b"]}]
|
||
["DEBUG:",[2,"b"]]
|
||
["DEBUG:",2]
|
||
["DEBUG:","b"]
|
||
|
||
- name: debug/1 function
|
||
args:
|
||
- 'debug("value: \(.)", [.,.])'
|
||
input: 'null false "test" [] {}'
|
||
expected: |
|
||
null
|
||
false
|
||
"test"
|
||
[]
|
||
{}
|
||
error: |
|
||
["DEBUG:","value: null"]
|
||
["DEBUG:",[null,null]]
|
||
["DEBUG:","value: false"]
|
||
["DEBUG:",[false,false]]
|
||
["DEBUG:","value: test"]
|
||
["DEBUG:",["test","test"]]
|
||
["DEBUG:","value: []"]
|
||
["DEBUG:",[[],[]]]
|
||
["DEBUG:","value: {}"]
|
||
["DEBUG:",[{},{}]]
|
||
|
||
- name: stderr function
|
||
args:
|
||
- -c
|
||
- 'recurse(stderr|.[]?)'
|
||
input: |
|
||
[{}]
|
||
[1,{"a":[2,"b"]}]
|
||
"DEBUG:"
|
||
expected: |
|
||
[{}]
|
||
{}
|
||
[1,{"a":[2,"b"]}]
|
||
1
|
||
{"a":[2,"b"]}
|
||
[2,"b"]
|
||
2
|
||
"b"
|
||
"DEBUG:"
|
||
error: '[{}]{}[1,{"a":[2,"b"]}]1{"a":[2,"b"]}[2,"b"]2bDEBUG:'
|
||
|
||
- name: debug and stderr in builtins
|
||
args:
|
||
- 'builtins | sort[] | select(test("debug|stderr"))'
|
||
input: 'null'
|
||
expected: |
|
||
"debug/0"
|
||
"debug/1"
|
||
"stderr/0"
|
||
|
||
- name: input_filename function with stdin input
|
||
args:
|
||
- 'input_filename'
|
||
input: '0 1 2'
|
||
expected: |
|
||
"<stdin>"
|
||
"<stdin>"
|
||
"<stdin>"
|
||
|
||
- name: input_filename function with null input option
|
||
args:
|
||
- -n
|
||
- 'input_filename'
|
||
input: '0'
|
||
expected: |
|
||
null
|
||
|
||
- name: input_filename function with raw string input option
|
||
args:
|
||
- --raw-input
|
||
- 'input_filename'
|
||
input: |
|
||
1
|
||
2
|
||
3
|
||
expected: |
|
||
"<stdin>"
|
||
"<stdin>"
|
||
"<stdin>"
|
||
|
||
- name: input_filename function with slurp option
|
||
args:
|
||
- --slurp
|
||
- 'input_filename'
|
||
input: |
|
||
1
|
||
2
|
||
3
|
||
expected: |
|
||
"<stdin>"
|
||
|
||
- name: input_filename function with input and slurp option
|
||
args:
|
||
- --raw-input
|
||
- --slurp
|
||
- 'input_filename'
|
||
input: |
|
||
1
|
||
2
|
||
3
|
||
expected: |
|
||
"<stdin>"
|
||
|
||
- name: input_filename function with json file arguments
|
||
args:
|
||
- 'input_filename'
|
||
- 'testdata/1.json'
|
||
- 'testdata/2.json'
|
||
input: '0'
|
||
expected: |
|
||
"testdata/1.json"
|
||
"testdata/2.json"
|
||
|
||
- name: input_filename function with null input option and json file arguments
|
||
args:
|
||
- -n
|
||
- '., inputs, (try input catch .) | input_filename'
|
||
- 'testdata/1.json'
|
||
- 'testdata/2.json'
|
||
input: '0'
|
||
expected: |
|
||
null
|
||
"testdata/1.json"
|
||
"testdata/2.json"
|
||
null
|
||
|
||
- name: input_filename function with hyphen for stdin
|
||
args:
|
||
- 'input_filename'
|
||
- '-'
|
||
- 'testdata/1.json'
|
||
- '-'
|
||
- 'testdata/2.json'
|
||
- '-'
|
||
input: '0'
|
||
expected: |
|
||
"<stdin>"
|
||
"testdata/1.json"
|
||
"testdata/2.json"
|
||
|
||
- name: input_filename function with yaml input option
|
||
args:
|
||
- --yaml-input
|
||
- 'input_filename'
|
||
input: '0'
|
||
expected: |
|
||
"<stdin>"
|
||
|
||
- name: input_filename function with yaml file arguments
|
||
args:
|
||
- --yaml-input
|
||
- 'input_filename'
|
||
- 'testdata/1.yaml'
|
||
input: '0'
|
||
expected: |
|
||
"testdata/1.yaml"
|
||
"testdata/1.yaml"
|
||
"testdata/1.yaml"
|
||
|
||
- name: input_filename in builtins
|
||
args:
|
||
- 'builtins[] | select(test("input_filename"))'
|
||
input: 'null'
|
||
expected: |
|
||
"input_filename/0"
|
||
|
||
- name: halt function
|
||
args:
|
||
- 'def f($n): if $n > 0 then $n, f($n - 1) else halt end; f(.), .'
|
||
input: '3'
|
||
expected: |
|
||
3
|
||
2
|
||
1
|
||
|
||
- name: halt function and raw string input option
|
||
args:
|
||
- -R
|
||
- '., halt, .'
|
||
input: |
|
||
foo
|
||
bar
|
||
baz
|
||
expected: |
|
||
"foo"
|
||
|
||
- name: halt function and json file arguments
|
||
args:
|
||
- 'halt'
|
||
- 'testdata/1.json'
|
||
- 'testdata/2.json'
|
||
|
||
- name: halt_error/0 function
|
||
args:
|
||
- 'halt_error'
|
||
input: '1'
|
||
error: |
|
||
1
|
||
exit_code: 5
|
||
|
||
- name: halt_error/0 function on nan
|
||
args:
|
||
- 'nan | halt_error'
|
||
input: 'null'
|
||
error: |
|
||
null
|
||
exit_code: 5
|
||
|
||
- name: halt_error/0 function on string
|
||
args:
|
||
- 'halt_error'
|
||
input: '"foo\nbar\nbaz\n"'
|
||
error: |
|
||
foo
|
||
bar
|
||
baz
|
||
exit_code: 5
|
||
|
||
- name: halt_error/0 function and try catch
|
||
args:
|
||
- 'range(5) | try halt_error catch .'
|
||
input: 'null'
|
||
error: |
|
||
0
|
||
exit_code: 5
|
||
|
||
- name: halt_error/0 function with null input and try catch
|
||
args:
|
||
- 'try halt_error catch .'
|
||
input: 'null'
|
||
exit_code: 5
|
||
|
||
- name: halt_error/0 function with multiple input values
|
||
args:
|
||
- 'halt_error'
|
||
input: |
|
||
1
|
||
2
|
||
3
|
||
error: |
|
||
1
|
||
exit_code: 5
|
||
|
||
- name: halt_error/0 function and raw string input option
|
||
args:
|
||
- -R
|
||
- 'halt_error'
|
||
input: |
|
||
foo
|
||
bar
|
||
baz
|
||
error: foo
|
||
exit_code: 5
|
||
|
||
- name: halt_error/1 function
|
||
args:
|
||
- 'halt_error(42)'
|
||
input: 'null'
|
||
exit_code: 42
|
||
|
||
- name: halt_error/1 function on string
|
||
args:
|
||
- 'halt_error(42)'
|
||
input: '"foo\nbar\nbaz\n"'
|
||
error: |
|
||
foo
|
||
bar
|
||
baz
|
||
exit_code: 42
|
||
|
||
- name: halt_error/1 function with multiple input values
|
||
args:
|
||
- 'halt_error(.)'
|
||
input: |
|
||
1
|
||
2
|
||
3
|
||
error: |
|
||
1
|
||
exit_code: 1
|
||
|
||
- name: builtins function
|
||
args:
|
||
- 'builtins | length > 100'
|
||
input: 'null'
|
||
expected: |
|
||
true
|
||
|
||
- name: env function
|
||
args:
|
||
- 'env|length > 0'
|
||
input: 'null'
|
||
expected: |
|
||
true
|
||
|
||
- name: env in function
|
||
args:
|
||
- 'def f: env; f|length > 0'
|
||
input: 'null'
|
||
expected: |
|
||
true
|
||
|
||
- name: env in builtins
|
||
args:
|
||
- 'builtins[] | select(test("env"))'
|
||
input: 'null'
|
||
expected: |
|
||
"env/0"
|
||
|
||
- name: $ENV variable
|
||
args:
|
||
- '[$ENV|length > 0, 1 as $ENV | $ENV]'
|
||
input: 'null'
|
||
expected: |
|
||
[
|
||
true,
|
||
1
|
||
]
|
||
|
||
- name: env arguments count error
|
||
args:
|
||
- 'env(0)'
|
||
input: 'null'
|
||
error: |
|
||
function not defined: env/1
|
||
exit_code: 3
|
||
|
||
- name: input function
|
||
args:
|
||
- -n
|
||
- 'input, input'
|
||
input: '1'
|
||
expected: |
|
||
1
|
||
error: |
|
||
break
|
||
|
||
- name: input function with binomial operator
|
||
args:
|
||
- -n
|
||
- 'input + input[0]'
|
||
input: |
|
||
[1]
|
||
2
|
||
expected: |
|
||
3
|
||
|
||
- name: input function in function
|
||
args:
|
||
- -n
|
||
- 'def f: [def f: input; range(3) | f]; f'
|
||
input: '1 2 3'
|
||
expected: |
|
||
[
|
||
1,
|
||
2,
|
||
3
|
||
]
|
||
|
||
- name: input function with files
|
||
args:
|
||
- -n
|
||
- -c
|
||
- 'range(5) | input'
|
||
- 'testdata/1.json'
|
||
- 'testdata/7.json'
|
||
- 'testdata/1.json'
|
||
expected: |
|
||
{"foo":10}
|
||
1
|
||
2
|
||
{"foo":42}
|
||
{"foo":10}
|
||
|
||
- name: input function without null input option
|
||
args:
|
||
- '. + input'
|
||
input: '1 2'
|
||
expected: |
|
||
3
|
||
|
||
- name: input function with stream option
|
||
args:
|
||
- -n
|
||
- -c
|
||
- --stream
|
||
- 'range(5) | input'
|
||
input: '{"a":[1,2,3]}'
|
||
expected: |
|
||
[["a",0],1]
|
||
[["a",1],2]
|
||
[["a",2],3]
|
||
[["a",2]]
|
||
[["a"]]
|
||
|
||
- name: inputs function
|
||
args:
|
||
- -n
|
||
- 'reduce inputs as $x (0; . + $x)'
|
||
input: '1 2 3 4 5'
|
||
expected: |
|
||
15
|
||
|
||
- name: inputs function with stream option
|
||
args:
|
||
- -n
|
||
- -c
|
||
- --stream
|
||
- 'range(5) | input'
|
||
input: '{"a":[1,2,3]}'
|
||
expected: |
|
||
[["a",0],1]
|
||
[["a",1],2]
|
||
[["a",2],3]
|
||
[["a",2]]
|
||
[["a"]]
|
||
|
||
- name: inputs function with stream option and fromstream function
|
||
args:
|
||
- -n
|
||
- -c
|
||
- --stream
|
||
- 'fromstream(inputs)'
|
||
input: 'null [false] {"x":[null]}'
|
||
expected: |
|
||
null
|
||
[false]
|
||
{"x":[null]}
|
||
|
||
- name: inputs function with stream option and truncate_stream function
|
||
args:
|
||
- -n
|
||
- -c
|
||
- --stream
|
||
- 'fromstream(1 | truncate_stream(inputs))'
|
||
input: '{"x":[1,{"y":[2]},3],"z":[4]}'
|
||
expected: |
|
||
[1,{"y":[2]},3]
|
||
[4]
|
||
|
||
- name: inputs function with stream option
|
||
args:
|
||
- -n
|
||
- -c
|
||
- --stream
|
||
- '[inputs][]'
|
||
input: '{"a":1} {"b":2} {"c":3}'
|
||
expected: |
|
||
[["a"],1]
|
||
[["a"]]
|
||
[["b"],2]
|
||
[["b"]]
|
||
[["c"],3]
|
||
[["c"]]
|
||
|
||
- name: inputs function with stream and slurp option
|
||
args:
|
||
- -n
|
||
- -c
|
||
- --stream
|
||
- --slurp
|
||
- 'inputs[]'
|
||
input: '{"a":1} {"b":2} {"c":3}'
|
||
expected: |
|
||
[["a"],1]
|
||
[["a"]]
|
||
[["b"],2]
|
||
[["b"]]
|
||
[["c"],3]
|
||
[["c"]]
|
||
|
||
- name: inputs function with raw input option
|
||
args:
|
||
- -n
|
||
- -R
|
||
- 'inputs'
|
||
input: |
|
||
a b
|
||
c
|
||
d
|
||
1
|
||
expected: |
|
||
"a b"
|
||
"c"
|
||
"d"
|
||
"1"
|
||
|
||
- name: inputs function with raw input and slurp option
|
||
args:
|
||
- -n
|
||
- -R
|
||
- -s
|
||
- 'inputs'
|
||
input: |
|
||
a b
|
||
c
|
||
expected: |
|
||
"a b\nc\n"
|
||
|
||
- name: inputs function with yaml input option
|
||
args:
|
||
- -n
|
||
- --yaml-input
|
||
- 'inputs'
|
||
input: |
|
||
foo: 1
|
||
---
|
||
bar: 2
|
||
---
|
||
baz: 3
|
||
expected: |
|
||
{
|
||
"foo": 1
|
||
}
|
||
{
|
||
"bar": 2
|
||
}
|
||
{
|
||
"baz": 3
|
||
}
|
||
|
||
- name: inputs function with yaml input, slurp option
|
||
args:
|
||
- -n
|
||
- --slurp
|
||
- --yaml-input
|
||
- 'inputs'
|
||
input: |
|
||
foo: 1
|
||
---
|
||
bar: 2
|
||
---
|
||
baz: 3
|
||
expected: |
|
||
[
|
||
{
|
||
"foo": 1
|
||
},
|
||
{
|
||
"bar": 2
|
||
},
|
||
{
|
||
"baz": 3
|
||
}
|
||
]
|
||
|
||
- name: match function
|
||
args:
|
||
- -c
|
||
- '[match("bcd")], [match("☆★"; "g")], (("","g","i","ig") as $flag | [match("bcd"; $flag)]), [match("ABC.?D.?E"; "mg")], [match("A(?<bar>B(C)(.?D))(?<foo>.?E)")], [match("b(?<foo>c)(d)"; "igm")], [match("bc(c(.*))?d")]'
|
||
input: '"abcde☆★abcde☆★ABCDE☆ABC\nD\nE"'
|
||
expected: |
|
||
[{"captures":[],"length":3,"offset":1,"string":"bcd"}]
|
||
[{"captures":[],"length":2,"offset":5,"string":"☆★"},{"captures":[],"length":2,"offset":12,"string":"☆★"}]
|
||
[{"captures":[],"length":3,"offset":1,"string":"bcd"}]
|
||
[{"captures":[],"length":3,"offset":1,"string":"bcd"},{"captures":[],"length":3,"offset":8,"string":"bcd"}]
|
||
[{"captures":[],"length":3,"offset":1,"string":"bcd"}]
|
||
[{"captures":[],"length":3,"offset":1,"string":"bcd"},{"captures":[],"length":3,"offset":8,"string":"bcd"},{"captures":[],"length":3,"offset":15,"string":"BCD"}]
|
||
[{"captures":[],"length":5,"offset":14,"string":"ABCDE"},{"captures":[],"length":7,"offset":20,"string":"ABC\nD\nE"}]
|
||
[{"captures":[{"length":3,"name":"bar","offset":15,"string":"BCD"},{"length":1,"name":null,"offset":16,"string":"C"},{"length":1,"name":null,"offset":17,"string":"D"},{"length":1,"name":"foo","offset":18,"string":"E"}],"length":5,"offset":14,"string":"ABCDE"}]
|
||
[{"captures":[{"length":1,"name":"foo","offset":2,"string":"c"},{"length":1,"name":null,"offset":3,"string":"d"}],"length":3,"offset":1,"string":"bcd"},{"captures":[{"length":1,"name":"foo","offset":9,"string":"c"},{"length":1,"name":null,"offset":10,"string":"d"}],"length":3,"offset":8,"string":"bcd"},{"captures":[{"length":1,"name":"foo","offset":16,"string":"C"},{"length":1,"name":null,"offset":17,"string":"D"}],"length":3,"offset":15,"string":"BCD"}]
|
||
[{"captures":[{"length":0,"name":null,"offset":-1,"string":null},{"length":0,"name":null,"offset":-1,"string":null}],"length":3,"offset":1,"string":"bcd"}]
|
||
|
||
- name: match function type error
|
||
args:
|
||
- 'match("x"; "g")'
|
||
input: '{}'
|
||
error: |
|
||
match("x"; "g") cannot be applied to: object ({})
|
||
|
||
- name: match function flag error
|
||
args:
|
||
- 'match("x"; "a")'
|
||
input: '""'
|
||
error: |
|
||
unsupported regular expression flag: "a"
|
||
|
||
- name: match function regular expression error
|
||
args:
|
||
- 'match("["; "g")'
|
||
input: '""'
|
||
error: |
|
||
invalid regular expression "[": error parsing regexp: missing closing ]: `[`
|
||
|
||
- name: test function
|
||
args:
|
||
- -c
|
||
- '[test("xyz"), test("bcd"), test("efg"), test("efg"; "i"), test("☆★")]'
|
||
input: '"abcde☆★abcde☆★ABCDEFG"'
|
||
expected: |
|
||
[false,true,false,true,true]
|
||
|
||
- name: capture function
|
||
args:
|
||
- -c
|
||
- 'capture("bcd"), capture("b(?<foo>c.?(?<bar>d..))"), [capture("(?<a>b(?<foo>c).?(?<bar>d..))"; "gmi")]'
|
||
input: '"abcdeABCDEabcde"'
|
||
expected: |
|
||
{}
|
||
{"bar":"deA","foo":"cdeA"}
|
||
[{"a":"bcdeA","bar":"deA","foo":"c"},{"a":"BCDEa","bar":"DEa","foo":"C"}]
|
||
|
||
- name: scan function
|
||
args:
|
||
- -c
|
||
- 'scan("abc"), scan("abc"; "i"), scan("(b(c*)(d*))"), scan("(b(c*)(d*))"; "i")'
|
||
input: '"abcdeABCCDDEabcce"'
|
||
expected: |
|
||
"abc"
|
||
"abc"
|
||
"abc"
|
||
"ABC"
|
||
"abc"
|
||
["bcd","c","d"]
|
||
["bcc","cc",""]
|
||
["bcd","c","d"]
|
||
["BCCDD","CC","DD"]
|
||
["bcc","cc",""]
|
||
|
||
- name: split/2 function
|
||
args:
|
||
- -c
|
||
- 'split("a"), split("a+"), split("a+"; ""), split("a+"; "i"), split(""; "")'
|
||
input: '"abaacaAad"'
|
||
expected: |
|
||
["","b","","c","A","d"]
|
||
["abaacaAad"]
|
||
["","b","c","A","d"]
|
||
["","b","c","d"]
|
||
["","a","b","a","a","c","a","A","a","d",""]
|
||
|
||
- name: splits function
|
||
args:
|
||
- -c
|
||
- '[splits("a")], [splits("a+")], [splits("a+"; "")], [splits("a+"; "i")], [splits(""; "")]'
|
||
input: '"abaacaAad"'
|
||
expected: |
|
||
["","b","","c","A","d"]
|
||
["","b","c","A","d"]
|
||
["","b","c","A","d"]
|
||
["","b","c","d"]
|
||
["","a","b","a","a","c","a","A","a","d",""]
|
||
|
||
- name: sub function
|
||
args:
|
||
- 'sub("a"; "b"), sub("aaa"; "b"), sub("a"; "b","c"), sub("a(?<a>.)"; "\(.a)b\(.a)"; "ig"), sub("(?<foo>★)"; "\(.foo)☆\(.foo)"), sub("^"; "b"), sub("a"; empty)'
|
||
input: '"abc☆★☆ABC"'
|
||
expected: |
|
||
"bbc☆★☆ABC"
|
||
"abc☆★☆ABC"
|
||
"bbc☆★☆ABC"
|
||
"cbc☆★☆ABC"
|
||
"bbbc☆★☆BbBC"
|
||
"abc☆★☆★☆ABC"
|
||
"babc☆★☆ABC"
|
||
"abc☆★☆ABC"
|
||
|
||
- name: gsub function
|
||
args:
|
||
- 'gsub("a"; "b"), gsub("a.c"; "b"), gsub("a"; "b","c"), gsub("a(?<a>..)"; "\(.a+.a)"; "i"), gsub("(?<foo>★)"; "\(.foo)☆\(.foo)"), gsub("^"; "a"), gsub("a"; empty)'
|
||
input: '"abcABC☆★☆ABCabc"'
|
||
expected: |
|
||
"bbcABC☆★☆ABCbbc"
|
||
"bABC☆★☆ABCb"
|
||
"bbcABC☆★☆ABCbbc"
|
||
"cbcABC☆★☆ABCcbc"
|
||
"bcbcBCBC☆★☆BCBCbcbc"
|
||
"abcABC☆★☆★☆ABCabc"
|
||
"aabcABC☆★☆ABCabc"
|
||
"abcABC☆★☆ABCabc"
|
||
|
||
- name: match function with empty matches
|
||
args:
|
||
- -c
|
||
- '[match("a*"; "g").offset], [scan("[a-z]*")], gsub("[0-9]*"; "#"), split("-*"; ""), [splits("\\s*")]'
|
||
input: '"a1b-c d"'
|
||
expected: |
|
||
[0,1,2,3,4,5,6,7]
|
||
["a","","b","","c","","d",""]
|
||
"#a##b#-#c# #d#"
|
||
["","a","1","b","","c"," ","d",""]
|
||
["","a","1","b","-","c","","d",""]
|
||
|
||
- name: match function with empty matches and assertions
|
||
args:
|
||
- -c
|
||
- 'gsub("(?m)^a*"; "#"), gsub("\\ba*"; "#"), gsub("(^|-)a*"; "#"), gsub("[a-z]*\\b"; "#")'
|
||
input: '"a-a b"'
|
||
expected: |
|
||
"#-a b"
|
||
"##-## #b#"
|
||
"## b"
|
||
"##-## ##"
|
||
|
||
- name: match function with empty matches and captures
|
||
args:
|
||
- -c
|
||
- '[scan("(x)?a*")], [match("(a|)"; "g") | [.offset, .captures[0].offset]], [scan("[^a]*"; "i")]'
|
||
input: '"1a-A"'
|
||
expected: |
|
||
[[null],[null],[null],[null],[null]]
|
||
[[0,0],[1,1],[2,2],[3,3],[4,4]]
|
||
["1","","-","",""]
|
||
|
||
- name: match function with empty matches against multibyte characters
|
||
args:
|
||
- -c
|
||
- '[scan("[☆★]*")], [match("[☆★]*"; "g").offset], gsub("[☆★]*"; "#")'
|
||
input: '"☆★1☆★"'
|
||
expected: |
|
||
["☆★","","☆★",""]
|
||
[0,2,3,5]
|
||
"##1##"
|
||
|
||
- name: INDEX function
|
||
args:
|
||
- -c
|
||
- 'INDEX(range(5); .*2)'
|
||
input: 'null'
|
||
expected: |
|
||
{"0":0,"2":1,"4":2,"6":3,"8":4}
|
||
|
||
- name: JOIN function
|
||
args:
|
||
- -c
|
||
- '[range(5)] | JOIN(map(.*3); .*2)'
|
||
input: 'null'
|
||
expected: |
|
||
[[0,0],[1,6],[2,12],[3,null],[4,null]]
|
||
|
||
- name: IN function
|
||
args:
|
||
- -c
|
||
- '[range(5; 13)|IN(range(0; 10; 3))]'
|
||
input: 'null'
|
||
expected: |
|
||
[false,true,false,false,true,false,false,false]
|
||
|
||
- name: format function
|
||
args:
|
||
- 'format("html","uri","csv","tsv","sh","base64")'
|
||
input: '[1,2,3]'
|
||
expected: |
|
||
"[1,2,3]"
|
||
"%5B1%2C2%2C3%5D"
|
||
"1,2,3"
|
||
"1\t2\t3"
|
||
"1 2 3"
|
||
"WzEsMiwzXQ=="
|
||
|
||
- name: format function error
|
||
args:
|
||
- -n
|
||
- 'format("t")'
|
||
error: |
|
||
format not defined: @t
|
||
|
||
- name: format strings @text
|
||
args:
|
||
- -n
|
||
- '@text'
|
||
expected: |
|
||
"null"
|
||
|
||
- name: format strings @json
|
||
args:
|
||
- '@json'
|
||
input: '{"a":42}'
|
||
expected: |
|
||
"{\"a\":42}"
|
||
|
||
- name: format strings @json with string interpolation
|
||
args:
|
||
- '@json "0\(.)1\(. + .)2\([2])3"'
|
||
input: '[1]'
|
||
expected: |
|
||
"0[1]1[1,1]2[2]3"
|
||
|
||
- name: format strings @html
|
||
args:
|
||
- '@html'
|
||
input: |
|
||
{"foo": "<div>&'\"</div>"}
|
||
expected: |
|
||
"{"foo":"<div>&'\\"</div>"}"
|
||
|
||
- name: format strings @html with string interpolation
|
||
args:
|
||
- '@html "x\(.)x\(.+.)x\("<>")x"'
|
||
input: |
|
||
["<>"]
|
||
expected: |
|
||
"x["<>"]x["<>","<>"]x<>x"
|
||
|
||
- name: format strings @uri
|
||
args:
|
||
- '@uri'
|
||
input: |
|
||
[1, {"foo": "<div>&'\"()+</div>"}]
|
||
expected: |
|
||
"%5B1%2C%7B%22foo%22%3A%22%3Cdiv%3E%26%27%5C%22%28%29%2B%3C%2Fdiv%3E%22%7D%5D"
|
||
|
||
- name: format strings @uri with string interpolation
|
||
args:
|
||
- '@uri "q=\(.)&q=\(. + .)"'
|
||
input: |
|
||
["<>", "{&}"]
|
||
expected: |
|
||
"q=%5B%22%3C%3E%22%2C%22%7B%26%7D%22%5D&q=%5B%22%3C%3E%22%2C%22%7B%26%7D%22%2C%22%3C%3E%22%2C%22%7B%26%7D%22%5D"
|
||
|
||
- name: format strings @urid
|
||
args:
|
||
- '@urid'
|
||
input: |
|
||
"%5B1%2C%7B%22foo%22%3A%22%3Cdiv%3E%26%27%5C%22%28%29%2B%3C%2Fdiv%3E%22%7D%5D"
|
||
expected: |
|
||
"[1,{\"foo\":\"<div>&'\\\"()+</div>\"}]"
|
||
|
||
- name: format strings @urid error
|
||
args:
|
||
- '@urid'
|
||
input: |
|
||
"%5B1%2C%"
|
||
error: |
|
||
@urid cannot be applied to "%5B1%2C%": invalid URL escape "%"
|
||
|
||
- name: format strings @csv
|
||
args:
|
||
- '@csv'
|
||
input: |
|
||
[1, "foo", null, "foo,\n\"bar\"\tbaz\u0000\\0"]
|
||
expected: |
|
||
"1,\"foo\",,\"foo,\n\"\"bar\"\"\tbaz\\0\\0\""
|
||
|
||
- name: format strings @csv with string interpolation
|
||
args:
|
||
- '@csv "\(.),\(. + .),\([nan])"'
|
||
input: |
|
||
[1, "foo", null, 2]
|
||
expected: |
|
||
"1,\"foo\",,2,1,\"foo\",,2,1,\"foo\",,2,"
|
||
|
||
- name: format strings @csv error
|
||
args:
|
||
- '@csv'
|
||
input: 'null'
|
||
error: |
|
||
@csv cannot be applied to: null
|
||
|
||
- name: format strings @csv row error
|
||
args:
|
||
- '@csv'
|
||
input: |
|
||
[1, "foo", null, {"foo":1}]
|
||
error: |
|
||
@csv cannot format an array including: object ({"foo":1})
|
||
|
||
- name: format strings @tsv
|
||
args:
|
||
- '@tsv'
|
||
input: |
|
||
[1, "foo", null, "foo,\n\"bar\"\tbaz\u0000\\0"]
|
||
expected: |
|
||
"1\tfoo\t\tfoo,\\n\"bar\"\\tbaz\\0\\\\0"
|
||
|
||
- name: format strings @tsv with string interpolation
|
||
args:
|
||
- '@tsv "\(.),\(. + .),\([nan])"'
|
||
input: |
|
||
[1, "foo", null, 2]
|
||
expected: |
|
||
"1\tfoo\t\t2,1\tfoo\t\t2\t1\tfoo\t\t2,"
|
||
|
||
- name: format strings @tsv error
|
||
args:
|
||
- '@tsv'
|
||
input: '0'
|
||
error: |
|
||
@tsv cannot be applied to: number (0)
|
||
|
||
- name: format strings @tsv row error
|
||
args:
|
||
- '@tsv'
|
||
input: |
|
||
[1, "foo", null, ["foo"]]
|
||
error: |
|
||
@tsv cannot format an array including: array (["foo"])
|
||
|
||
- name: format strings @sh
|
||
args:
|
||
- '@sh'
|
||
input: |
|
||
null
|
||
true
|
||
[1, "f'o'o\u0000\\0", null, false]
|
||
expected: |
|
||
"null"
|
||
"true"
|
||
"1 'f'\\''o'\\''o\\0\\0' null false"
|
||
|
||
- name: format strings @sh error
|
||
args:
|
||
- '@sh'
|
||
input: |
|
||
[{"foo": "<>"}]
|
||
error: |
|
||
@sh cannot format an array including: object ({"foo":"<>"})
|
||
|
||
- name: format strings @base64
|
||
args:
|
||
- '@base64'
|
||
input: '{"foo":"bar"}'
|
||
expected: |
|
||
"eyJmb28iOiJiYXIifQ=="
|
||
|
||
- name: format strings @base64 with string interpolation
|
||
args:
|
||
- '@base64 "\(.),\(. + .),\(. + . + .)"'
|
||
input: '[1,2]'
|
||
expected: |
|
||
"WzEsMl0=,WzEsMiwxLDJd,WzEsMiwxLDIsMSwyXQ=="
|
||
|
||
- name: format strings @base64d
|
||
args:
|
||
- -R
|
||
- '@base64d'
|
||
input: 'eyJmb28iOiJiYXIifQ=='
|
||
expected: |
|
||
"{\"foo\":\"bar\"}"
|
||
|
||
- name: format strings @base64d without padding
|
||
args:
|
||
- -R
|
||
- '@base64d'
|
||
input: 'eyJmb28iOiJiYXIifQ'
|
||
expected: |
|
||
"{\"foo\":\"bar\"}"
|
||
|
||
- name: format strings @base64d with trailing characters after padding
|
||
args:
|
||
- -R
|
||
- '@base64d'
|
||
input: 'eyJmb28iOiJiYXIifQ=x=y'
|
||
expected: |
|
||
"{\"foo\":\"bar\"}"
|
||
|
||
- name: format strings @base64d error
|
||
args:
|
||
- '@base64d'
|
||
input: |
|
||
":"
|
||
error: |
|
||
@base64d cannot be applied to ":": illegal base64 data at input byte 0
|
||
|
||
- name: format strings not defined error
|
||
args:
|
||
- -n
|
||
- '@foo'
|
||
error: |
|
||
format not defined: @foo
|
||
exit_code: 5
|
||
|
||
- name: format strings not defined error with numeric characters
|
||
args:
|
||
- -n
|
||
- '@0'
|
||
error: |
|
||
format not defined: @0
|
||
exit_code: 5
|
||
|
||
- name: format strings not defined error with optional operator
|
||
args:
|
||
- -n
|
||
- '@foo?, @bar"\(0|debug)"?, 1'
|
||
expected: |
|
||
1
|
||
error: |
|
||
["DEBUG:",0]
|
||
|
||
- name: destructuring alternative operator
|
||
args:
|
||
- '. as {$a} ?// [$a] ?// $a | $a'
|
||
input: '[1] [2] {"a":3} 4'
|
||
expected: |
|
||
1
|
||
2
|
||
3
|
||
4
|
||
|
||
- name: destructuring alternative operator with error backtrack
|
||
args:
|
||
- -c
|
||
- '. as {$a} ?// [$a] ?// $a | if 1 < $a and $a < 4 then $a|error else $a end'
|
||
input: '[1] [2] {"a":3} 4'
|
||
expected: |
|
||
1
|
||
[2]
|
||
{"a":3}
|
||
4
|
||
|
||
- name: destructuring alternative operator with break
|
||
args:
|
||
- -c
|
||
- 'label $out | . as {$a} ?// [$a] ?// $a | {$a}, break $out'
|
||
input: '[1] [2] {"a":3} 4'
|
||
expected: |
|
||
{"a":1}
|
||
{"a":2}
|
||
{"a":3}
|
||
{"a":4}
|
||
|
||
- name: destructuring alternative operator with break in try
|
||
args:
|
||
- -c
|
||
- 'first((. as {$a} ?// [$a] ?// $a | {$a})?)'
|
||
input: '[1] [2] {"a":3} 4'
|
||
expected: |
|
||
{"a":1}
|
||
{"a":2}
|
||
{"a":3}
|
||
{"a":4}
|
||
|
||
- name: destructuring alternative operator with halt
|
||
args:
|
||
- -c
|
||
- 'label $out | . as {$a} ?// [$a] ?// $a | {$a}, halt'
|
||
input: '[1] [2] {"a":3} 4'
|
||
expected: |
|
||
{"a":1}
|
||
|
||
- name: destructuring alternative operator with halt_error
|
||
args:
|
||
- -c
|
||
- '. as {$a} ?// [$a] ?// $a | {$a}, halt_error'
|
||
input: '[1]'
|
||
expected: |
|
||
{"a":1}
|
||
error: |
|
||
[1]
|
||
exit_code: 5
|
||
|
||
- name: destructuring alternative operator with halt_error in try
|
||
args:
|
||
- -c
|
||
- 'try (. as {$a} ?// [$a] ?// $a | {$a}, halt_error)'
|
||
input: '[1]'
|
||
expected: |
|
||
{"a":1}
|
||
error: |
|
||
[1]
|
||
exit_code: 5
|
||
|
||
- name: destructuring alternative operator resets variables of later alternatives
|
||
args:
|
||
- -c
|
||
- '.[] as [$a] ?// {$b} ?// $c | [$a, $b, $c]'
|
||
input: '[{"b":1}, [2], 3, [4]]'
|
||
expected: |
|
||
[null,1,null]
|
||
[2,null,null]
|
||
[null,null,3]
|
||
[4,null,null]
|
||
|
||
- name: destructuring alternative operator with multiple variables
|
||
args:
|
||
- -c
|
||
- '. as {$a, b: [$c, {$d}]} ?// [$a, {$b}, $e] ?// $f | [$a, $b, $c, $d, $e, $f]'
|
||
input: '{"a":1,"b":[2,{"d":3}]} [4,{"b":5,"c":6},7,8,9] "foo"'
|
||
expected: |
|
||
[1,null,2,3,null,null]
|
||
[4,5,null,null,7,null]
|
||
[null,null,null,null,null,"foo"]
|
||
|
||
- name: destructuring alternative operator with array pattern against string
|
||
args:
|
||
- '. as [$a] ?// $a | $a'
|
||
input: 'null "" "abc" [] ["abc"]'
|
||
expected: |
|
||
null
|
||
""
|
||
"abc"
|
||
null
|
||
"abc"
|
||
|
||
- name: compact output option
|
||
args:
|
||
- -c
|
||
- '.'
|
||
input: '{ "foo": ["hello", "world"] }'
|
||
expected: |
|
||
{"foo":["hello","world"]}
|
||
|
||
- name: compact output long option
|
||
args:
|
||
- --compact-output
|
||
- '.'
|
||
input: '{ "foo": ["hello", "world"] }'
|
||
expected: |
|
||
{"foo":["hello","world"]}
|
||
|
||
- name: compact output long option with value
|
||
args:
|
||
- --compact-output=1
|
||
- '.'
|
||
input: '0'
|
||
error: |
|
||
boolean flag `--compact-output' cannot have an argument
|
||
exit_code: 2
|
||
|
||
- name: raw string output short option
|
||
args:
|
||
- -r
|
||
- '.foo[]'
|
||
input: '{ "foo": ["hello", "world", "multiple\nline"] }'
|
||
expected: |
|
||
hello
|
||
world
|
||
multiple
|
||
line
|
||
|
||
- name: raw string output long option
|
||
args:
|
||
- --raw-output
|
||
- '.foo[]'
|
||
input: '{ "foo": ["hello", "world", "multiple\nline"] }'
|
||
expected: |
|
||
hello
|
||
world
|
||
multiple
|
||
line
|
||
|
||
- name: raw string output option against non-string
|
||
args:
|
||
- -r
|
||
- '.'
|
||
input: '{ "foo": "multiple\nline" }'
|
||
expected: |
|
||
{
|
||
"foo": "multiple\nline"
|
||
}
|
||
|
||
- name: raw string output with nul delimiter option
|
||
args:
|
||
- --raw-output0
|
||
- '.[]'
|
||
input: '["foo",[{},{}],1,[2,3]]'
|
||
expected: "foo\x00[\n {},\n {}\n]\x001\x00[\n 2,\n 3\n]\x00"
|
||
|
||
- name: raw string output with nul delimiter option error with string containing nul character
|
||
args:
|
||
- --raw-output0
|
||
- '"foo","bar","b\u0000a\u0000z","qux"'
|
||
input: 'null'
|
||
expected: "foo\x00bar\x00"
|
||
error: |
|
||
cannot output a string containing NUL character: "b\x00a\x00z"
|
||
|
||
- name: raw string output without and with nul delimiter options
|
||
args:
|
||
- --raw-output
|
||
- --raw-output0
|
||
- '.[]'
|
||
input: '["foo",1,2,3]'
|
||
expected: "foo\x001\x002\x003\x00"
|
||
|
||
- name: raw string output with nul delimiter option with compact output option
|
||
args:
|
||
- --raw-output0
|
||
- --compact-output
|
||
- '.[]'
|
||
input: '["foo",[{},{}],1,[2,3]]'
|
||
expected: "foo\x00[{},{}]\x001\x00[2,3]\x00"
|
||
|
||
- name: join output option
|
||
args:
|
||
- -j
|
||
- '.[]'
|
||
input: '["foo",1,2,3]'
|
||
expected: "foo123"
|
||
|
||
- name: join output long option
|
||
args:
|
||
- --join-output
|
||
- '.[]'
|
||
input: '["foo",[{},{}],1,[2,3]]'
|
||
expected: "foo[\n {},\n {}\n]1[\n 2,\n 3\n]"
|
||
|
||
- name: join output option with raw string output with nul delimiter option
|
||
args:
|
||
- --raw-output0
|
||
- --join-output
|
||
- '.[]'
|
||
input: '["foo",1,2,3]'
|
||
expected: "foo\x001\x002\x003\x00"
|
||
|
||
- name: color output option
|
||
args:
|
||
- -C
|
||
- '., null, nan, infinite'
|
||
input: '{"x":"foo","y":128,"z":[null,false,true,3.14,"foo",{}]}'
|
||
expected:
|
||
"{\n\
|
||
\ \e[34;1m\"x\"\e[0m: \e[32m\"foo\"\e[0m,\n\
|
||
\ \e[34;1m\"y\"\e[0m: \e[36m128\e[0m,\n\
|
||
\ \e[34;1m\"z\"\e[0m: [\n\
|
||
\ \e[90mnull\e[0m,\n\
|
||
\ \e[33mfalse\e[0m,\n\
|
||
\ \e[33mtrue\e[0m,\n\
|
||
\ \e[36m3.14\e[0m,\n\
|
||
\ \e[32m\"foo\"\e[0m,\n\
|
||
\ {}\n\
|
||
\ ]\n\
|
||
}\n\
|
||
\e[90mnull\e[0m\n\
|
||
\e[90mnull\e[0m\n\
|
||
\e[36m1.7976931348623157e+308\e[0m\n"
|
||
|
||
- name: color output option configured by environment variable
|
||
args:
|
||
- -C
|
||
- '., null, nan, infinite'
|
||
input: |
|
||
{ "x": "foo", "y": 128, "z": [null, false, true, 3.14, "foo", {}] }
|
||
env:
|
||
- GOJQ_COLORS=31:32:33:34:35:36:41:42
|
||
expected:
|
||
"\e[42m{\e[0m\n\
|
||
\ \e[36m\"x\"\e[0m\e[42m:\e[0m \e[35m\"foo\"\e[0m\e[42m,\e[0m\n\
|
||
\ \e[36m\"y\"\e[0m\e[42m:\e[0m \e[34m128\e[0m\e[42m,\e[0m\n\
|
||
\ \e[36m\"z\"\e[0m\e[42m:\e[0m \e[41m[\e[0m\n\
|
||
\ \e[31mnull\e[0m\e[41m,\e[0m\n\
|
||
\ \e[32mfalse\e[0m\e[41m,\e[0m\n\
|
||
\ \e[33mtrue\e[0m\e[41m,\e[0m\n\
|
||
\ \e[34m3.14\e[0m\e[41m,\e[0m\n\
|
||
\ \e[35m\"foo\"\e[0m\e[41m,\e[0m\n\
|
||
\ \e[42m{\e[0m\e[42m}\e[0m\n\
|
||
\ \e[41m]\e[0m\n\
|
||
\e[42m}\e[0m\n\
|
||
\e[31mnull\e[0m\n\
|
||
\e[31mnull\e[0m\n\
|
||
\e[34m1.7976931348623157e+308\e[0m\n"
|
||
|
||
- name: color output option configured by environment variable with fewer colors
|
||
args:
|
||
- -C
|
||
- '.'
|
||
input: |
|
||
{ "foo": [null, false, true, 3.14, "bar"] }
|
||
env:
|
||
- GOJQ_COLORS=31;1:::32;2
|
||
expected:
|
||
"{\n\
|
||
\ \"foo\": [\n\
|
||
\ \e[31;1mnull\e[0m,\n\
|
||
\ false,\n\
|
||
\ true,\n\
|
||
\ \e[32;2m3.14\e[0m,\n\
|
||
\ \"bar\"\n\
|
||
\ ]\n\
|
||
}\n"
|
||
|
||
- name: invalid colors environment variable
|
||
args:
|
||
- -C
|
||
- '.'
|
||
input: |
|
||
0
|
||
env:
|
||
- GOJQ_COLORS=30:31;;:32
|
||
error: |
|
||
invalid color: "31;;"
|
||
|
||
- name: color output long option
|
||
args:
|
||
- --color-output
|
||
- '.'
|
||
input: '{"foo":42}'
|
||
expected:
|
||
"{\n\
|
||
\ \e[34;1m\"foo\"\e[0m: \e[36m42\e[0m\n\
|
||
}\n"
|
||
|
||
- name: color output with compact output option
|
||
args:
|
||
- -C
|
||
- -c
|
||
- '.'
|
||
input: '{"x":42,"y":3.14,"z":[10000000000000000000]}'
|
||
expected:
|
||
"{\
|
||
\e[34;1m\"x\"\e[0m:\e[36m42\e[0m,\
|
||
\e[34;1m\"y\"\e[0m:\e[36m3.14\e[0m,\
|
||
\e[34;1m\"z\"\e[0m:[\e[36m10000000000000000000\e[0m]\
|
||
}\n"
|
||
|
||
- name: monochrome output option
|
||
args:
|
||
- -C
|
||
- -M
|
||
- '.'
|
||
input: '{"foo":42}'
|
||
expected: |
|
||
{
|
||
"foo": 42
|
||
}
|
||
|
||
- name: monochrome output long option
|
||
args:
|
||
- -C
|
||
- --monochrome-output
|
||
- '.'
|
||
input: '{"foo":42}'
|
||
expected: |
|
||
{
|
||
"foo": 42
|
||
}
|
||
|
||
- name: NO_COLOR environment variable
|
||
args:
|
||
- '.'
|
||
input: '{"foo":42}'
|
||
env:
|
||
- NO_COLOR=1
|
||
expected: |
|
||
{
|
||
"foo": 42
|
||
}
|
||
|
||
- name: NO_COLOR environment variable with color output option
|
||
args:
|
||
- --color-output
|
||
- '.'
|
||
input: '{"foo":42}'
|
||
env:
|
||
- NO_COLOR=1
|
||
expected:
|
||
"{\n\
|
||
\ \e[34;1m\"foo\"\e[0m: \e[36m42\e[0m\n\
|
||
}\n"
|
||
|
||
- name: indent option
|
||
args:
|
||
- --indent
|
||
- '1'
|
||
- '.'
|
||
input: '{ "foo": ["hello", "world"] }'
|
||
expected: |
|
||
{
|
||
"foo": [
|
||
"hello",
|
||
"world"
|
||
]
|
||
}
|
||
|
||
- name: indent option with value 0
|
||
args:
|
||
- --indent
|
||
- '0'
|
||
- '.'
|
||
input: '{ "foo": ["hello", "world"] }'
|
||
expected: |
|
||
{
|
||
"foo": [
|
||
"hello",
|
||
"world"
|
||
]
|
||
}
|
||
|
||
- name: indent option with deeply nested array
|
||
args:
|
||
- --indent
|
||
- '7'
|
||
- '.'
|
||
input: '{ "foo": ["hello", ["world", [[[[[[[[[]]]]]]]]]]] }'
|
||
expected: |
|
||
{
|
||
"foo": [
|
||
"hello",
|
||
[
|
||
"world",
|
||
[
|
||
[
|
||
[
|
||
[
|
||
[
|
||
[
|
||
[
|
||
[
|
||
[]
|
||
]
|
||
]
|
||
]
|
||
]
|
||
]
|
||
]
|
||
]
|
||
]
|
||
]
|
||
]
|
||
}
|
||
|
||
- name: indent option too many indentation count error
|
||
args:
|
||
- --indent=10
|
||
- '.'
|
||
input: '{ "foo": { "baz": ["hello", "world"] } }'
|
||
error: |
|
||
too many indentation count: 10
|
||
|
||
- name: indent option negative indentation count error
|
||
args:
|
||
- --indent
|
||
- -1
|
||
- '.'
|
||
input: '{ "foo": { "baz": ["hello", "world"] } }'
|
||
error: |
|
||
negative indentation count: -1
|
||
|
||
- name: indent option without argument
|
||
args:
|
||
- --indent
|
||
input: '0'
|
||
error: |
|
||
expected argument for flag `--indent'
|
||
exit_code: 2
|
||
|
||
- name: indent option parse error
|
||
args:
|
||
- --indent=foo
|
||
input: '0'
|
||
error: |
|
||
invalid argument for flag `--indent': strconv.Atoi: parsing "foo": invalid syntax
|
||
exit_code: 2
|
||
|
||
- name: tab option
|
||
args:
|
||
- --tab
|
||
- '.'
|
||
input: '{ "foo": { "baz": ["hello", ["world", [[[[[[[[[[[[[[[[]]]]]]]]]]]]]]]]]] } }'
|
||
expected: |
|
||
{
|
||
"foo": {
|
||
"baz": [
|
||
"hello",
|
||
[
|
||
"world",
|
||
[
|
||
[
|
||
[
|
||
[
|
||
[
|
||
[
|
||
[
|
||
[
|
||
[
|
||
[
|
||
[
|
||
[
|
||
[
|
||
[
|
||
[
|
||
[]
|
||
]
|
||
]
|
||
]
|
||
]
|
||
]
|
||
]
|
||
]
|
||
]
|
||
]
|
||
]
|
||
]
|
||
]
|
||
]
|
||
]
|
||
]
|
||
]
|
||
]
|
||
}
|
||
}
|
||
|
||
- name: raw string input option
|
||
args:
|
||
- -R
|
||
- '.'
|
||
input: "null\nfalse\r\nfoo\nbar"
|
||
expected: |
|
||
"null"
|
||
"false\r"
|
||
"foo"
|
||
"bar"
|
||
|
||
- name: raw string input long option
|
||
args:
|
||
- --raw-input
|
||
- '.'
|
||
input: "null\nfalse\r\nfoo\nbar\n"
|
||
expected: |
|
||
"null"
|
||
"false\r"
|
||
"foo"
|
||
"bar"
|
||
|
||
- name: raw string input option error
|
||
args:
|
||
- -R
|
||
- '. / 2'
|
||
input: |
|
||
{
|
||
"foo": "bar"
|
||
}
|
||
error: |
|
||
cannot divide: string ("{") and number (2)
|
||
cannot divide: string (" \"foo\": \"bar\"") and number (2)
|
||
cannot divide: string ("}") and number (2)
|
||
|
||
- name: null input value option
|
||
args:
|
||
- -n
|
||
- '[.]'
|
||
expected: |
|
||
[
|
||
null
|
||
]
|
||
|
||
- name: null input value long option
|
||
args:
|
||
- --null-input
|
||
- '[.]'
|
||
expected: |
|
||
[
|
||
null
|
||
]
|
||
|
||
- name: null input value option with compact output option
|
||
args:
|
||
- -n
|
||
- -c
|
||
- '[.,.]'
|
||
expected: |
|
||
[null,null]
|
||
|
||
- name: null input value option with raw string input option
|
||
args:
|
||
- -n
|
||
- -R
|
||
- '.'
|
||
input: 'foo'
|
||
expected: |
|
||
null
|
||
|
||
- name: slurp option
|
||
args:
|
||
- -s
|
||
- '.'
|
||
input: |
|
||
null
|
||
false
|
||
[]
|
||
{ "foo": "bar" }
|
||
expected: |
|
||
[
|
||
null,
|
||
false,
|
||
[],
|
||
{
|
||
"foo": "bar"
|
||
}
|
||
]
|
||
|
||
- name: slurp long option
|
||
args:
|
||
- --slurp
|
||
- --compact-output
|
||
- '.'
|
||
input: |
|
||
null
|
||
false
|
||
expected: |
|
||
[null,false]
|
||
|
||
- name: slurp option with raw string input option
|
||
args:
|
||
- -s
|
||
- -R
|
||
- '.'
|
||
input: "null\nfalse\r\nfoo\nbar"
|
||
expected: |
|
||
"null\nfalse\r\nfoo\nbar"
|
||
|
||
- name: slurp option with null input option
|
||
args:
|
||
- -s
|
||
- -n
|
||
- '.'
|
||
expected: |
|
||
null
|
||
|
||
- name: slurp option with multiple json files
|
||
args:
|
||
- -s
|
||
- '.'
|
||
- 'testdata/1.json'
|
||
- 'testdata/2.json'
|
||
expected: |
|
||
[
|
||
{
|
||
"foo": 10
|
||
},
|
||
[
|
||
{
|
||
"bar": []
|
||
}
|
||
]
|
||
]
|
||
|
||
- name: slurp and raw input option with multiple json files
|
||
args:
|
||
- -R
|
||
- -s
|
||
- '.'
|
||
- 'testdata/1.json'
|
||
- 'testdata/2.json'
|
||
expected: |
|
||
"{\"foo\":10}\n[{\n\"bar\"\n:\n[]\n}]\n"
|
||
|
||
- name: stream option
|
||
args:
|
||
- -c
|
||
- --stream
|
||
- '.'
|
||
input: |
|
||
1
|
||
2
|
||
[]
|
||
{}
|
||
[3]
|
||
{"x":1,"y":2}
|
||
[1,2,{"x":{"y":[3,[{}],{"z":{}}]}}]
|
||
{"a":"b","c":[1,[2,{}]],"d":null,"e":1.234,"x":{"y":{"z":[1,2],"q":2},"w":3},"z":[{}]}
|
||
expected: |
|
||
[[],1]
|
||
[[],2]
|
||
[[],[]]
|
||
[[],{}]
|
||
[[0],3]
|
||
[[0]]
|
||
[["x"],1]
|
||
[["y"],2]
|
||
[["y"]]
|
||
[[0],1]
|
||
[[1],2]
|
||
[[2,"x","y",0],3]
|
||
[[2,"x","y",1,0],{}]
|
||
[[2,"x","y",1,0]]
|
||
[[2,"x","y",2,"z"],{}]
|
||
[[2,"x","y",2,"z"]]
|
||
[[2,"x","y",2]]
|
||
[[2,"x","y"]]
|
||
[[2,"x"]]
|
||
[[2]]
|
||
[["a"],"b"]
|
||
[["c",0],1]
|
||
[["c",1,0],2]
|
||
[["c",1,1],{}]
|
||
[["c",1,1]]
|
||
[["c",1]]
|
||
[["d"],null]
|
||
[["e"],1.234]
|
||
[["x","y","z",0],1]
|
||
[["x","y","z",1],2]
|
||
[["x","y","z",1]]
|
||
[["x","y","q"],2]
|
||
[["x","y","q"]]
|
||
[["x","w"],3]
|
||
[["x","w"]]
|
||
[["z",0],{}]
|
||
[["z",0]]
|
||
[["z"]]
|
||
|
||
- name: stream option with empty input
|
||
args:
|
||
- --stream
|
||
- '.'
|
||
input: ''
|
||
expected: ''
|
||
|
||
- name: stream option with null input option
|
||
args:
|
||
- -n
|
||
- --stream
|
||
- '.'
|
||
input: '1'
|
||
expected: |
|
||
null
|
||
|
||
- name: stream option with raw input option
|
||
args:
|
||
- -R
|
||
- --stream
|
||
- '.'
|
||
input: |
|
||
1
|
||
2
|
||
3
|
||
expected: |
|
||
"1"
|
||
"2"
|
||
"3"
|
||
|
||
- name: stream option with slurp option
|
||
args:
|
||
- -c
|
||
- --stream
|
||
- --slurp
|
||
- '.[]'
|
||
input: '{"a":1} {"b":2} {"c":3}'
|
||
expected: |
|
||
[["a"],1]
|
||
[["a"]]
|
||
[["b"],2]
|
||
[["b"]]
|
||
[["c"],3]
|
||
[["c"]]
|
||
|
||
- name: stream option with unterminated input after a comma
|
||
args:
|
||
- -c
|
||
- --stream
|
||
- '.'
|
||
input: '{"a":1,'
|
||
expected: |
|
||
[["a"],1]
|
||
error: |
|
||
invalid json: <stdin>
|
||
{"a":1,
|
||
^ unexpected EOF
|
||
|
||
- name: stream option with unterminated input after a value
|
||
args:
|
||
- -c
|
||
- --stream
|
||
- '.'
|
||
input: '[1,[2,3'
|
||
expected: |
|
||
[[0],1]
|
||
[[1,0],2]
|
||
[[1,1],3]
|
||
error: |
|
||
invalid json: <stdin>
|
||
[1,[2,3
|
||
^ unexpected EOF
|
||
|
||
- name: yaml input option
|
||
args:
|
||
- --yaml-input
|
||
- '.'
|
||
input: |
|
||
foo:
|
||
bar: 42
|
||
baz: |
|
||
a
|
||
b
|
||
qux: 100
|
||
---
|
||
foo: 1
|
||
---
|
||
bar
|
||
expected: |
|
||
{
|
||
"foo": {
|
||
"bar": 42,
|
||
"baz": "a\nb\n"
|
||
},
|
||
"qux": 100
|
||
}
|
||
{
|
||
"foo": 1
|
||
}
|
||
"bar"
|
||
|
||
- name: yaml file input
|
||
args:
|
||
- --yaml-input
|
||
- '.'
|
||
- 'testdata/1.yaml'
|
||
expected: |
|
||
{
|
||
"foo": {
|
||
"bar": 42,
|
||
"baz": "a\nb\n"
|
||
},
|
||
"qux": 100
|
||
}
|
||
{
|
||
"foo": 1
|
||
}
|
||
"bar"
|
||
|
||
- name: yaml input option with non-string keys
|
||
args:
|
||
- --yaml-input
|
||
- '.'
|
||
input: |
|
||
foo:
|
||
- 42.10: bar
|
||
expected: |
|
||
{
|
||
"foo": [
|
||
{
|
||
"42.10": "bar"
|
||
}
|
||
]
|
||
}
|
||
|
||
- name: yaml input option with timestamps
|
||
args:
|
||
- --yaml-input
|
||
- '.'
|
||
input: |
|
||
foo: 2021-01-02
|
||
bar: 2021-01-02t10:11:12Z
|
||
baz: "2021-01-02"
|
||
qux: !!timestamp 2021-01-02
|
||
expected: |
|
||
{
|
||
"bar": "2021-01-02t10:11:12Z",
|
||
"baz": "2021-01-02",
|
||
"foo": "2021-01-02",
|
||
"qux": "2021-01-02"
|
||
}
|
||
|
||
- name: yaml input option with large numbers
|
||
args:
|
||
- --yaml-input
|
||
- '.[] + 1'
|
||
input: |
|
||
- 9223372036854775807
|
||
- 18446744073709551615
|
||
- 18446744073709551616
|
||
- 99999999999999999999999
|
||
- 0b111111111111111111111111111111111111111111111111111111111111111
|
||
- 0o777777777777777777777
|
||
- 0x7FFFFFFFFFFFFFFF
|
||
expected: |
|
||
9223372036854775808
|
||
18446744073709551616
|
||
18446744073709551617
|
||
100000000000000000000000
|
||
9223372036854775808
|
||
9223372036854775808
|
||
9223372036854775808
|
||
|
||
- name: yaml input option with slurp option
|
||
args:
|
||
- --yaml-input
|
||
- --slurp
|
||
- '.'
|
||
input: |
|
||
foo:
|
||
bar: 42
|
||
baz: |
|
||
a
|
||
b
|
||
qux: 100
|
||
---
|
||
foo: 1
|
||
---
|
||
bar
|
||
expected: |
|
||
[
|
||
{
|
||
"foo": {
|
||
"bar": 42,
|
||
"baz": "a\nb\n"
|
||
},
|
||
"qux": 100
|
||
},
|
||
{
|
||
"foo": 1
|
||
},
|
||
"bar"
|
||
]
|
||
|
||
- name: yaml input option with hyphen for stdin
|
||
args:
|
||
- --yaml-input
|
||
- '.'
|
||
- '-'
|
||
input: |
|
||
foo: 1
|
||
expected: |
|
||
{
|
||
"foo": 1
|
||
}
|
||
|
||
- name: yaml input option error
|
||
args:
|
||
- --yaml-input
|
||
- '.'
|
||
input: |
|
||
foo: 10
|
||
10
|
||
bar:
|
||
error: |
|
||
invalid yaml: <stdin>:2
|
||
2 | 10
|
||
^ could not find expected ':'
|
||
|
||
- name: yaml input option error
|
||
args:
|
||
- --yaml-input
|
||
- '.'
|
||
input: |
|
||
foo: 10
|
||
bar: ]
|
||
baz:
|
||
error: |
|
||
invalid yaml: <stdin>:2
|
||
2 | bar: ]
|
||
^ did not find expected node content
|
||
|
||
- name: yaml input option error with multibyte characters
|
||
args:
|
||
- --yaml-input
|
||
- '.'
|
||
input: |
|
||
{１２３: 4, １２３: 5}
|
||
error: |
|
||
invalid yaml: <stdin>:1
|
||
1 | {１２３: 4, １２３: 5}
|
||
^ mapping key "１２３" already defined at line 1
|
||
|
||
- name: yaml input option multiple errors
|
||
args:
|
||
- --yaml-input
|
||
- '.'
|
||
input: |
|
||
foo: 1
|
||
bar: 2
|
||
foo: 3
|
||
bar: 4
|
||
error: |
|
||
invalid yaml: <stdin>:3
|
||
3 | foo: 3
|
||
^ mapping key "foo" already defined at line 1
|
||
|
||
- name: yaml file input error
|
||
args:
|
||
- --yaml-input
|
||
- '.'
|
||
- 'testdata/2.yaml'
|
||
error: |
|
||
invalid yaml: testdata/2.yaml:5
|
||
5 | a: b: c
|
||
^ mapping values are not allowed in this context
|
||
|
||
- name: yaml file input error in dos format
|
||
args:
|
||
- --yaml-input
|
||
- '.'
|
||
- 'testdata/3.yaml'
|
||
error: |
|
||
invalid yaml: testdata/3.yaml:5
|
||
5 | a: b: c
|
||
^ mapping values are not allowed in this context
|
||
|
||
- name: yaml file input error in mac format
|
||
args:
|
||
- --yaml-input
|
||
- '.'
|
||
- 'testdata/4.yaml'
|
||
error: |
|
||
invalid yaml: testdata/4.yaml:5
|
||
5 | a: b: c
|
||
^ mapping values are not allowed in this context
|
||
|
||
- name: yaml output option
|
||
args:
|
||
- --yaml-output
|
||
- '.'
|
||
input: '{"foo": 128, "bar": {"baz": [1,"qux", []]}}'
|
||
expected: |
|
||
bar:
|
||
baz:
|
||
- 1
|
||
- qux
|
||
- []
|
||
foo: 128
|
||
|
||
- name: yaml output option with multiple values
|
||
args:
|
||
- --yaml-output
|
||
- '..'
|
||
input: '{"foo": 128, "bar": [1,2,"foo"]}'
|
||
expected: |
|
||
bar:
|
||
- 1
|
||
- 2
|
||
- foo
|
||
foo: 128
|
||
---
|
||
- 1
|
||
- 2
|
||
- foo
|
||
---
|
||
1
|
||
---
|
||
2
|
||
---
|
||
foo
|
||
---
|
||
128
|
||
|
||
- name: yaml input and output option
|
||
args:
|
||
- --yaml-input
|
||
- --yaml-output
|
||
- '.'
|
||
input: |
|
||
foo: 42
|
||
---
|
||
foo:
|
||
bar: 42
|
||
baz: |
|
||
a
|
||
b
|
||
qux: 100
|
||
---
|
||
foo: 1
|
||
---
|
||
bar
|
||
expected: |
|
||
foo: 42
|
||
---
|
||
foo:
|
||
bar: 42
|
||
baz: |
|
||
a
|
||
b
|
||
qux: 100
|
||
---
|
||
foo: 1
|
||
---
|
||
bar
|
||
|
||
- name: yaml output with indent option
|
||
args:
|
||
- --yaml-output
|
||
- --indent
|
||
- '8'
|
||
- '.'
|
||
input: '{ "foo": { "baz": ["hello", "world"] } }'
|
||
expected: |
|
||
foo:
|
||
baz:
|
||
- hello
|
||
- world
|
||
|
||
- name: yaml output with indent option error
|
||
args:
|
||
- --yaml-output
|
||
- --indent
|
||
- '10'
|
||
- '.'
|
||
input: '{ "foo": { "baz": ["hello", "world"] } }'
|
||
error: |
|
||
too many indentation count: 10
|
||
|
||
- name: yaml output with tab option error
|
||
args:
|
||
- --yaml-output
|
||
- --tab
|
||
- '.'
|
||
input: '{"foo": 128, "bar": {"baz": [1,"qux", []]}}'
|
||
error: |
|
||
cannot use tabs for YAML output
|
||
|
||
- name: source query from file
|
||
args:
|
||
- -f
|
||
- testdata/1.jq
|
||
input: '{"foo":{"bar":42}}'
|
||
expected: |
|
||
42
|
||
|
||
- name: source query from file short option in clumped options
|
||
args:
|
||
- -cfr
|
||
- testdata/1.jq
|
||
input: '{"foo":{"bar":42}}'
|
||
expected: |
|
||
42
|
||
|
||
- name: source query from file long option
|
||
args:
|
||
- --from-file
|
||
- testdata/1.jq
|
||
input: '{"foo":{"bar":42}}'
|
||
expected: |
|
||
42
|
||
|
||
- name: source query from file with --args
|
||
args:
|
||
- --args
|
||
- --compact-output
|
||
- --null-input
|
||
- --from-file
|
||
- testdata/14.jq
|
||
- 1
|
||
- 2
|
||
- 3
|
||
expected: |
|
||
{"named":{},"positional":["1","2","3"]}
|
||
|
||
- name: invalid query
|
||
args:
|
||
- '>abc'
|
||
input: '{}'
|
||
error: |
|
||
invalid query: >abc
|
||
>abc
|
||
^ unexpected token ">"
|
||
exit_code: 3
|
||
|
||
- name: invalid query
|
||
args:
|
||
- '.abc['
|
||
input: '{}'
|
||
error: |
|
||
invalid query: .abc[
|
||
.abc[
|
||
^ unexpected EOF
|
||
exit_code: 3
|
||
|
||
- name: invalid query
|
||
args:
|
||
- '[ .[] | { .id } ]'
|
||
input: '{}'
|
||
error: |
|
||
invalid query: [ .[] | { .id } ]
|
||
[ .[] | { .id } ]
|
||
^ unexpected token ".id"
|
||
exit_code: 3
|
||
|
||
- name: invalid query
|
||
args:
|
||
- 'if 0then. else. end'
|
||
input: '{}'
|
||
error: |
|
||
invalid query: if 0then. else. end
|
||
if 0then. else. end
|
||
^ invalid token "0t"
|
||
exit_code: 3
|
||
|
||
- name: invalid query
|
||
args:
|
||
- '.foo & .bar'
|
||
input: '{}'
|
||
error: |
|
||
invalid query: .foo & .bar
|
||
.foo & .bar
|
||
^ unexpected token "&"
|
||
exit_code: 3
|
||
|
||
- name: invalid query
|
||
args:
|
||
- 'foo☆'
|
||
input: '{}'
|
||
error: |
|
||
invalid query: foo☆
|
||
foo☆
|
||
^ unexpected token "☆"
|
||
exit_code: 3
|
||
|
||
- name: invalid query
|
||
args:
|
||
- "\\/"
|
||
input: '{}'
|
||
error: |
|
||
invalid query: \/
|
||
\/
|
||
^ unexpected token "\\"
|
||
exit_code: 3
|
||
|
||
- name: invalid query
|
||
args:
|
||
- "{\n[]}"
|
||
input: '{}'
|
||
error: |
|
||
invalid query: <arg>:2
|
||
2 | []}
|
||
^ unexpected token "["
|
||
exit_code: 3
|
||
|
||
- name: invalid multiple line query
|
||
args:
|
||
- |
|
||
[
|
||
.[]
|
||
| { id } }
|
||
]
|
||
input: '{}'
|
||
error: |
|
||
invalid query: <arg>:3
|
||
3 | | { id } }
|
||
^ unexpected token "}"
|
||
exit_code: 3
|
||
|
||
- name: invalid multiple line query in file
|
||
args:
|
||
- -f
|
||
- testdata/10.jq
|
||
error: |
|
||
invalid query: testdata/10.jq:5
|
||
5 | bar ]
|
||
^ unexpected token "]"
|
||
exit_code: 3
|
||
|
||
- name: invalid multiple line query in dos format
|
||
args:
|
||
- -f
|
||
- testdata/11.jq
|
||
error: |
|
||
invalid query: testdata/11.jq:5
|
||
5 | bar ]
|
||
^ unexpected token "]"
|
||
exit_code: 3
|
||
|
||
- name: invalid multiple line query in mac format
|
||
args:
|
||
- -f
|
||
- testdata/12.jq
|
||
error: |
|
||
invalid query: testdata/12.jq:5
|
||
5 | bar ]
|
||
^ unexpected token "]"
|
||
exit_code: 3
|
||
|
||
- name: invalid query in file
|
||
args:
|
||
- -f
|
||
- testdata/2.jq
|
||
error: |
|
||
invalid query: testdata/2.jq:3
|
||
3 | bar, []
|
||
^ unexpected token "["
|
||
exit_code: 3
|
||
|
||
- name: query file not found
|
||
args:
|
||
- -f
|
||
- testdata/3.jq
|
||
error: 'open testdata/3.jq:'
|
||
|
||
- name: query file not specified
|
||
args:
|
||
- -f
|
||
error: |
|
||
expected a query file for flag `-f'
|
||
|
||
- name: invalid json unexpected eof error
|
||
input: '{'
|
||
error: |
|
||
invalid json: <stdin>
|
||
{
|
||
^ unexpected EOF
|
||
|
||
- name: invalid json unexpected eof error with multibyte characters
|
||
input: '{ "１２３４５":'
|
||
error: |
|
||
invalid json: <stdin>
|
||
{ "１２３４５":
|
||
^ unexpected EOF
|
||
|
||
- name: invalid json unexpected eof error with multiple lines
|
||
input: |
|
||
[0
|
||
,[
|
||
error: |
|
||
invalid json: <stdin>:2
|
||
2 | ,[
|
||
^ unexpected EOF
|
||
|
||
- name: invalid json invalid character with multibyte characters
|
||
input: |
|
||
{
|
||
"１２３４５" 100
|
||
}
|
||
error: |
|
||
invalid json: <stdin>:2
|
||
2 | "１２３４５" 100
|
||
^ invalid character '1' after object key
|
||
|
||
- name: invalid json string literal
|
||
input: |
|
||
{
|
||
"１２３": n
|
||
}
|
||
error: |
|
||
invalid json: <stdin>:2
|
||
2 | "１２３": n
|
||
^ invalid character '\n' in literal null (expecting 'u')
|
||
|
||
- name: multiple json in input
|
||
input: '{}[]{"foo":10}{"bar":[]}'
|
||
expected: |
|
||
{}
|
||
[]
|
||
{
|
||
"foo": 10
|
||
}
|
||
{
|
||
"bar": []
|
||
}
|
||
|
||
- name: hyphen for stdin
|
||
args:
|
||
- '.'
|
||
- '-'
|
||
input: '{}'
|
||
expected: |
|
||
{}
|
||
|
||
- name: json file arguments
|
||
args:
|
||
- '.'
|
||
- 'testdata/1.json'
|
||
- 'testdata/2.json'
|
||
expected: |
|
||
{
|
||
"foo": 10
|
||
}
|
||
[
|
||
{
|
||
"bar": []
|
||
}
|
||
]
|
||
|
||
- name: json file error json
|
||
args:
|
||
- '.'
|
||
- 'testdata/3.json'
|
||
error: |
|
||
invalid json: testdata/3.json
|
||
{
|
||
^ unexpected EOF
|
||
|
||
- name: json file error json
|
||
args:
|
||
- '.'
|
||
- 'testdata/4.json'
|
||
error: |
|
||
invalid json: testdata/4.json:3
|
||
3 | bar
|
||
^ invalid character 'b' looking for beginning of value
|
||
|
||
- name: json file error json
|
||
args:
|
||
- '.'
|
||
- 'testdata/8.json'
|
||
error: |
|
||
invalid json: testdata/8.json
|
||
[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, , 1, 1, 1, 1, 1, 1, 1
|
||
^ invalid character ',' looking for beginning of value
|
||
|
||
- name: json file error json
|
||
args:
|
||
- '.'
|
||
- 'testdata/9.json'
|
||
error: |
|
||
invalid json: testdata/9.json:3
|
||
3 | ０", "０", "０", "０", "０", "０", "０", , "０", "０"]
|
||
^ invalid character ',' looking for beginning of value
|
||
|
||
- name: json file error json with multibyte character in the error line
|
||
args:
|
||
- '.'
|
||
- 'testdata/5.json'
|
||
error: | # file contents is read by inputReader so the entire error line is shown unlike the following input json test
|
||
invalid json: testdata/5.json:3
|
||
3 | "abcde": :★★★★★★★★★★★★★★★
|
||
^ invalid character ':' looking for beginning of value
|
||
|
||
- name: json input error json with multibyte character in the error line
|
||
args:
|
||
- '.'
|
||
input: |
|
||
{
|
||
"a": "This is a test for multibyte character in the error line of JSON. Since the first buffer size of JSON decoder is 512 (see encoding/json/stream.go) and the decoder stops reading bytes on encountering an error, the error line can be an invalid UTF-8 string even if the complete input is a valid UTF-8 string. Note that the error happens before 512 bytes and the corresponding line continues beyond 512 bytes with a multibyte character at the boundary.",
|
||
"abcde": :★★★★★★★★★★★★★★★
|
||
error: |
|
||
invalid json: <stdin>:3
|
||
3 | "abcde": :★★★★★★★★★★★★
|
||
^ invalid character ':' looking for beginning of value
|
||
|
||
- name: json file not found error
|
||
args:
|
||
- '.'
|
||
- 'testdata/1.json'
|
||
- 'testdata/6.json'
|
||
- 'testdata/2.json'
|
||
expected: |
|
||
{
|
||
"foo": 10
|
||
}
|
||
[
|
||
{
|
||
"bar": []
|
||
}
|
||
]
|
||
error: 'open testdata/6.json:'
|
||
|
||
- name: module directory option
|
||
args:
|
||
- -c
|
||
- -L
|
||
- 'testdata'
|
||
- 'include "4"; 1 | f | g'
|
||
input: '0'
|
||
expected: |
|
||
{"foo":[1,2,3,4,[1,2,{"foo":42}]]}
|
||
|
||
- name: module directory option
|
||
args:
|
||
- -c
|
||
- -L
|
||
- 'testdata'
|
||
- 'import "4" as m1; 1 | m1::f | m1::g'
|
||
input: '0'
|
||
expected: |
|
||
{"foo":[1,2,3,4,[1,2,{"foo":42}]]}
|
||
|
||
- name: module directory option
|
||
args:
|
||
- -c
|
||
- -L
|
||
- 'testdata'
|
||
- 'include "m1"; include "m3"; [f, g]'
|
||
input: '0'
|
||
expected: |
|
||
[42,43,44,45]
|
||
|
||
- name: module directory option
|
||
args:
|
||
- -c
|
||
- --library-path
|
||
- 'testdata'
|
||
- 'import "7" as $foo; $foo, $foo::foo'
|
||
input: '0'
|
||
expected: |
|
||
[1,2,{"foo":42}]
|
||
[1,2,{"foo":42}]
|
||
|
||
- name: module directory option
|
||
args:
|
||
- -c
|
||
- --library-path
|
||
- 'testdata'
|
||
- 'import "m1" as $x; $x, $x::x, $x[1].m1*100000000000000000000'
|
||
input: '0'
|
||
expected: |
|
||
[42,{"m1":42}]
|
||
[42,{"m1":42}]
|
||
4200000000000000000000
|
||
|
||
- name: module directory option with argjson
|
||
args:
|
||
- -c
|
||
- -L
|
||
- 'testdata'
|
||
- --argjson
|
||
- 'x'
|
||
- '{}'
|
||
- 'import "m1" as $x; $x'
|
||
input: '0'
|
||
expected: |
|
||
[42,{"m1":42}]
|
||
|
||
- name: module directory option parse error
|
||
args:
|
||
- 'include "m"; f'
|
||
input: '0'
|
||
error: 'compile error: module not found: "m"'
|
||
exit_code: 3
|
||
|
||
- name: module directory option function error
|
||
args:
|
||
- -L
|
||
- 'testdata'
|
||
- 'include "5"; i'
|
||
input: '0'
|
||
error: |
|
||
function not defined: i/0
|
||
exit_code: 3
|
||
|
||
- name: module directory option variable error
|
||
args:
|
||
- -L
|
||
- 'testdata'
|
||
- 'include "4"; $x'
|
||
input: '0'
|
||
error: 'compile error: variable not defined: $x'
|
||
exit_code: 3
|
||
|
||
- name: module directory option variable name conflict
|
||
args:
|
||
- -c
|
||
- -L
|
||
- 'testdata'
|
||
- 'include "6"; include "13"; . as $x | $x, g, h'
|
||
input: '1'
|
||
expected: |
|
||
1
|
||
[1,2,{"foo":42}]
|
||
[[{"foo":10}],[1,2,{"foo":42}]]
|
||
|
||
- name: module directory option json parse error
|
||
args:
|
||
- -Ltestdata
|
||
- 'import "4" as $x; $x'
|
||
input: '0'
|
||
error: |
|
||
compile error: invalid json: testdata/4.json:3
|
||
3 | bar
|
||
^ invalid character 'b' looking for beginning of value
|
||
exit_code: 3
|
||
|
||
- name: module directory option with same alias name
|
||
args:
|
||
- -c
|
||
- -L=testdata
|
||
- 'include "4"; import "6" as bar; bar::g'
|
||
input: '1'
|
||
expected: |
|
||
[1,2,{"foo":42}]
|
||
|
||
- name: module directory option without argument
|
||
args:
|
||
- -c
|
||
- -L
|
||
input: '0'
|
||
error: |
|
||
expected argument for flag `-L'
|
||
exit_code: 2
|
||
|
||
- name: search directory in query
|
||
args:
|
||
- 'include "m2" { search: "testdata/m2" }; g'
|
||
input: '0'
|
||
expected: |
|
||
0
|
||
43
|
||
44
|
||
|
||
- name: empty module
|
||
args:
|
||
- -L
|
||
- 'testdata'
|
||
- 'include "8"; .'
|
||
input: '0'
|
||
expected: |
|
||
0
|
||
|
||
- name: invalid query in a module
|
||
args:
|
||
- -L
|
||
- 'testdata'
|
||
- 'include "7"; .'
|
||
input: '0'
|
||
error: |
|
||
invalid query: testdata/7.jq:1
|
||
1 | def f: 1 +
|
||
^ unexpected EOF
|
||
exit_code: 3
|
||
|
||
- name: module directive
|
||
args:
|
||
- -c
|
||
- -L
|
||
- 'testdata'
|
||
- 'include "9"; f(2)'
|
||
input: '3'
|
||
expected: |
|
||
6
|
||
|
||
- name: module in query
|
||
args:
|
||
- -n
|
||
- 'module {}; .'
|
||
expected: |
|
||
null
|
||
|
||
- name: modulemeta function
|
||
args:
|
||
- -c
|
||
- -L
|
||
- 'testdata'
|
||
- 'tostring | modulemeta | .defs |= sort'
|
||
input: '4 5 6 8 9'
|
||
expected: |
|
||
{"defs":["f/0","g/0"],"deps":[{"is_data":false,"relpath":"5"},{"as":"bar","is_data":false,"relpath":"6"}]}
|
||
{"defs":["h/0"],"deps":[{"as":"foo","is_data":false,"relpath":"6","test":"foo"}]}
|
||
{"defs":["g/0","i/0"],"deps":[{"as":"x","is_data":true,"relpath":"7"}]}
|
||
{"defs":[],"deps":[]}
|
||
{"defs":["f/1"],"deps":[],"description":"This is a description","name":"sample-module","x":[[],{},{"y":10,"z":20}],"y":{"z":[128,"",false,true,null,[[]]]}}
|
||
|
||
- name: modulemeta function error
|
||
args:
|
||
- -c
|
||
- -L
|
||
- 'testdata'
|
||
- '"3" | modulemeta'
|
||
input: '0'
|
||
error: |
|
||
module not found: "3"
|
||
|
||
- name: arg option
|
||
args:
|
||
- --arg
|
||
- 'foo'
|
||
- 'value 1'
|
||
- --arg
|
||
- 'bar'
|
||
- '42'
|
||
- '{ $foo, $bar }'
|
||
input: '123'
|
||
expected: |
|
||
{
|
||
"bar": "42",
|
||
"foo": "value 1"
|
||
}
|
||
|
||
- name: arg option with function declaration
|
||
args:
|
||
- -n
|
||
- --arg
|
||
- 'foo'
|
||
- 'bar'
|
||
- 'def f: $foo; "baz" as $foo | ., f, $foo'
|
||
expected: |
|
||
null
|
||
"bar"
|
||
"baz"
|
||
|
||
- name: arg option arguments count error
|
||
args:
|
||
- --arg
|
||
error: |
|
||
expected 2 arguments for flag `--arg'
|
||
exit_code: 2
|
||
|
||
- name: arg option arguments count error
|
||
args:
|
||
- --arg
|
||
- 'foo'
|
||
error: |
|
||
expected 2 arguments for flag `--arg'
|
||
exit_code: 2
|
||
|
||
- name: arg option variable name error
|
||
args:
|
||
- --arg
|
||
- 'f.oo'
|
||
- '10'
|
||
- '.'
|
||
error: |
|
||
invalid variable name: $f.oo
|
||
exit_code: 3
|
||
|
||
- name: argjson option
|
||
args:
|
||
- --argjson
|
||
- 'foo'
|
||
- '{ "foo": 42 }'
|
||
- --argjson
|
||
- 'bar'
|
||
- '10'
|
||
- '{ $foo, $bar }'
|
||
input: '123'
|
||
expected: |
|
||
{
|
||
"bar": 10,
|
||
"foo": {
|
||
"foo": 42
|
||
}
|
||
}
|
||
|
||
- name: argjson option with big integer
|
||
args:
|
||
- --argjson
|
||
- 'foo'
|
||
- '10000000000000000000000000000000'
|
||
- '$foo * 2'
|
||
input: '0'
|
||
expected: |
|
||
20000000000000000000000000000000
|
||
|
||
- name: arg and argjson options
|
||
args:
|
||
- --arg
|
||
- 'x'
|
||
- '1'
|
||
- --argjson
|
||
- 'x'
|
||
- '1'
|
||
- --argjson
|
||
- 'y'
|
||
- '2'
|
||
- --arg
|
||
- 'y'
|
||
- '2'
|
||
- '{ $x, $y }'
|
||
input: '0'
|
||
expected: |
|
||
{
|
||
"x": "1",
|
||
"y": 2
|
||
}
|
||
|
||
- name: argjson option error
|
||
args:
|
||
- --argjson
|
||
- '0x'
|
||
- '0'
|
||
- '.'
|
||
error: |
|
||
invalid variable name: $0x
|
||
exit_code: 3
|
||
|
||
- name: argjson option parse error
|
||
args:
|
||
- --argjson
|
||
- 'foo'
|
||
- '{ foo }'
|
||
- '.'
|
||
error: |
|
||
invalid json: $foo
|
||
{ foo }
|
||
^ invalid character 'f' looking for beginning of object key string
|
||
|
||
- name: slurpfile option
|
||
args:
|
||
- --slurpfile
|
||
- 'foo'
|
||
- 'testdata/7.json'
|
||
- '{ $foo }'
|
||
input: 'null'
|
||
expected: |
|
||
{
|
||
"foo": [
|
||
1,
|
||
2,
|
||
{
|
||
"foo": 42
|
||
}
|
||
]
|
||
}
|
||
|
||
- name: slurpfile option invalid json error
|
||
args:
|
||
- --slurpfile
|
||
- 'foo'
|
||
- 'testdata/1.jq'
|
||
- '{ $foo }'
|
||
input: 'null'
|
||
error: |
|
||
invalid json: testdata/1.jq
|
||
.foo.bar
|
||
^ invalid character '.' looking for beginning of value
|
||
|
||
- name: slurpfile option invalid file error
|
||
args:
|
||
- --slurpfile
|
||
- 'foo'
|
||
- '-'
|
||
- '{ $foo }'
|
||
input: 'null'
|
||
error: 'open -:'
|
||
|
||
- name: rawfile option
|
||
args:
|
||
- --rawfile
|
||
- 'foo'
|
||
- 'testdata/7.json'
|
||
- '{ $foo }'
|
||
input: 'null'
|
||
expected: |
|
||
{
|
||
"foo": "1\n2\n{ \"foo\": 42 }\n"
|
||
}
|
||
|
||
- name: rawfile option error
|
||
args:
|
||
- --rawfile
|
||
- 'foo'
|
||
- 'testdata/6.json'
|
||
- '{ $foo }'
|
||
input: 'null'
|
||
error: 'open testdata/6.json:'
|
||
|
||
- name: $ARGS variable
|
||
args:
|
||
- --arg
|
||
- 'a'
|
||
- '1'
|
||
- --argjson
|
||
- 'b'
|
||
- '1'
|
||
- --slurpfile
|
||
- 'c'
|
||
- 'testdata/1.json'
|
||
- --rawfile
|
||
- 'd'
|
||
- 'testdata/1.json'
|
||
- '$ARGS | ., .named.a'
|
||
input: 'null'
|
||
expected: |
|
||
{
|
||
"named": {
|
||
"a": "1",
|
||
"b": 1,
|
||
"c": [
|
||
{
|
||
"foo": 10
|
||
}
|
||
],
|
||
"d": "{\"foo\":10}\n"
|
||
},
|
||
"positional": []
|
||
}
|
||
"1"
|
||
|
||
- name: $ARGS variable with args option
|
||
args:
|
||
- --arg
|
||
- 'foo'
|
||
- 'value'
|
||
- '$ARGS | ., .positional[]'
|
||
- --args
|
||
- '1'
|
||
- '"bar"'
|
||
- '{"x":1}'
|
||
input: '0'
|
||
expected: |
|
||
{
|
||
"named": {
|
||
"foo": "value"
|
||
},
|
||
"positional": [
|
||
"1",
|
||
"\"bar\"",
|
||
"{\"x\":1}"
|
||
]
|
||
}
|
||
"1"
|
||
"\"bar\""
|
||
"{\"x\":1}"
|
||
|
||
- name: args option without argument
|
||
args:
|
||
- '$ARGS'
|
||
- --args
|
||
input: '0'
|
||
expected: |
|
||
{
|
||
"named": {},
|
||
"positional": []
|
||
}
|
||
|
||
- name: query and options after args option
|
||
args:
|
||
- --args
|
||
- '$ARGS'
|
||
- 1
|
||
- -n
|
||
- 2
|
||
- -c
|
||
- --
|
||
- 3
|
||
- --
|
||
- -c
|
||
input: '0'
|
||
expected: |
|
||
{"named":{},"positional":["1","2","3","--","-c"]}
|
||
|
||
- name: double dash with args option
|
||
args:
|
||
- -c
|
||
- --args
|
||
- --
|
||
- $ARGS
|
||
- --
|
||
- 0
|
||
input: '0'
|
||
expected: |
|
||
{"named":{},"positional":["--","0"]}
|
||
|
||
- name: $ARGS variable with jsonargs option
|
||
args:
|
||
- '$ARGS | ., .positional[]'
|
||
- --arg
|
||
- 'foo'
|
||
- 'value'
|
||
- --jsonargs
|
||
- '1'
|
||
- '"bar"'
|
||
- '{"x":1}'
|
||
input: '0'
|
||
expected: |
|
||
{
|
||
"named": {
|
||
"foo": "value"
|
||
},
|
||
"positional": [
|
||
1,
|
||
"bar",
|
||
{
|
||
"x": 1
|
||
}
|
||
]
|
||
}
|
||
1
|
||
"bar"
|
||
{
|
||
"x": 1
|
||
}
|
||
|
||
- name: jsonargs option without argument
|
||
args:
|
||
- '$ARGS'
|
||
- --jsonargs
|
||
input: '0'
|
||
expected: |
|
||
{
|
||
"named": {},
|
||
"positional": []
|
||
}
|
||
|
||
- name: jsonargs option parse error
|
||
args:
|
||
- '$ARGS'
|
||
- --jsonargs
|
||
- '1'
|
||
- '"bar"'
|
||
- '{"x":}'
|
||
input: '0'
|
||
error: |
|
||
invalid json: --jsonargs
|
||
{"x":}
|
||
^ invalid character '}' looking for beginning of value
|
||
|
||
- name: args with jsonargs option
|
||
args:
|
||
- -c
|
||
- '$ARGS'
|
||
- --args
|
||
- 1
|
||
- 2
|
||
- --jsonargs
|
||
- 1
|
||
- 2
|
||
- --args
|
||
- 1
|
||
- 2
|
||
input: '0'
|
||
expected: |
|
||
{"named":{},"positional":["1","2",1,2,"1","2"]}
|
||
|
||
- name: args with jsonargs option
|
||
args:
|
||
- -c
|
||
- '$ARGS'
|
||
- --args
|
||
- 1
|
||
- 2
|
||
- --jsonargs
|
||
- 1
|
||
- 2
|
||
- --args
|
||
- 1
|
||
- 2
|
||
- --jsonargs
|
||
- 1
|
||
- 2
|
||
input: '0'
|
||
expected: |
|
||
{"named":{},"positional":["1","2",1,2,"1","2",1,2]}
|
||
|
||
- name: exit status option with null result
|
||
args:
|
||
- -e
|
||
- '.'
|
||
input: 'null'
|
||
expected: |
|
||
null
|
||
exit_code: 1
|
||
|
||
- name: exit status option with empty function
|
||
args:
|
||
- -e
|
||
- 'empty'
|
||
input: 'null'
|
||
exit_code: 4
|
||
|
||
- name: exit status long option with false result
|
||
args:
|
||
- --exit-status
|
||
- '.'
|
||
input: 'false'
|
||
expected: |
|
||
false
|
||
exit_code: 1
|
||
|
||
- name: exit status long option with true result
|
||
args:
|
||
- --exit-status
|
||
- 'not'
|
||
input: 'false'
|
||
expected: |
|
||
true
|
||
|
||
- name: exit status long option with multiple results
|
||
args:
|
||
- --exit-status
|
||
- '1,not,2'
|
||
input: 'false'
|
||
expected: |
|
||
1
|
||
true
|
||
2
|
||
|
||
- name: exit status long option with error function
|
||
args:
|
||
- --exit-status
|
||
- 'error'
|
||
input: 'false'
|
||
error: |
|
||
error: false
|
||
exit_code: 5
|
||
|
||
- name: exit status long option with error function
|
||
args:
|
||
- --exit-status
|
||
- 'error'
|
||
input: 'null'
|
||
error: |
|
||
error: null
|
||
|
||
- name: exit status long option with halt function
|
||
args:
|
||
- --exit-status
|
||
- 'halt'
|
||
input: 'false'
|
||
exit_code: 0
|
||
|
||
- name: exit status long option with halt_error function
|
||
args:
|
||
- --exit-status
|
||
- 'halt_error(0)'
|
||
input: 'null'
|
||
exit_code: 0
|
||
|
||
- name: exit status long option with halt_error function
|
||
args:
|
||
- --exit-status
|
||
- 'halt_error(42)'
|
||
input: 'null'
|
||
exit_code: 42
|
||
|
||
- name: query with leading hyphen
|
||
args:
|
||
- '-.'
|
||
input: '1'
|
||
expected: |
|
||
-1
|
||
|
||
- name: query with leading hyphen
|
||
args:
|
||
- '-j0'
|
||
input: '0 1 2'
|
||
expected: |
|
||
-1
|
||
-0.7651976865579666
|
||
-0.22389077914123567
|
||
|
||
- name: query with leading hyphen after a flag
|
||
args:
|
||
- -r
|
||
- '-.'
|
||
input: '1'
|
||
expected: |
|
||
-1
|
||
|
||
- name: double dash
|
||
args:
|
||
- '--'
|
||
- '.'
|
||
input: '1'
|
||
expected: |
|
||
1
|
||
|
||
- name: double dash with query with leading hyphen
|
||
args:
|
||
- '--'
|
||
- '-j'
|
||
input: 'null'
|
||
error: |
|
||
compile error: function not defined: j/0
|
||
exit_code: 3
|
||
|
||
- name: double double dash
|
||
args:
|
||
- '--'
|
||
- '--'
|
||
- '.'
|
||
input: '1'
|
||
error: |
|
||
invalid query: --
|
||
--
|
||
^ unexpected EOF
|
||
exit_code: 3
|
||
|
||
- name: short clumped options
|
||
args:
|
||
- -cRr
|
||
- '.'
|
||
input: 'foo'
|
||
expected: |
|
||
foo
|
||
|
||
- name: invalid short option error
|
||
args:
|
||
- -q
|
||
- '.'
|
||
error: |
|
||
unknown flag `q'
|
||
exit_code: 2
|
||
|
||
- name: invalid short option error in clumped options
|
||
args:
|
||
- -nqe
|
||
- '.'
|
||
error: |
|
||
unknown flag `q'
|
||
exit_code: 2
|
||
|
||
- name: invalid long option error
|
||
args:
|
||
- --qqq
|
||
- '.'
|
||
error: |
|
||
unknown flag `--qqq'
|
||
exit_code: 2
|