@port-labs/jq-node-bindings 0.0.1

package/deps/jq/tests/jqtest

@@ -0,0 +1,5 @@
+#!/bin/sh
+
+. "${0%/*}/setup"
+
+$VALGRIND $Q $JQ -L "$mods" --run-tests $JQTESTDIR/jq.test

package/deps/jq/tests/mantest

@@ -0,0 +1,7 @@
+#!/bin/sh
+
+. "${0%/*}/setup"
+
+# We set PAGER because there's a mantest for `env` that uses it.
+(cd $JQBASEDIR/docs && rake mantests) |
+    env PAGER=less $VALGRIND $Q $JQ -L "$mods" --run-tests

package/deps/jq/tests/modules/.jq

@@ -0,0 +1,5 @@
+def foo: "baz";
+def f: "wat";
+def f: "foo";
+def g: "bar";
+def fg: f+g;

package/deps/jq/tests/modules/a.jq

@@ -0,0 +1,2 @@
+module {version:1.7};
+def a: "a";

package/deps/jq/tests/modules/b/b.jq

@@ -0,0 +1,2 @@
+def a: "b";
+def b: "c";

package/deps/jq/tests/modules/c/c.jq

@@ -0,0 +1,16 @@
+module {whatever:null};
+import "a" as foo;
+import "d" as d {search:"./"};
+import "d" as d2{search:"./"};
+import "e" as e {search:"./../lib/jq"};
+import "f" as f {search:"./../lib/jq"};
+import "data" as $d;
+def a: 0;
+def c:
+  if $d::d[0] != {this:"is a test",that:"is too"} then error("data import is busted")
+  elif d2::meh != d::meh then error("import twice doesn't work")
+  elif foo::a != "a" then error("foo::a didn't work as expected")
+  elif d::meh != "meh" then error("d::meh didn't work as expected")
+  elif e::bah != "bah" then error("e::bah didn't work as expected")
+  elif f::f != "f is here" then error("f::f didn't work as expected")
+  else foo::a + "c" + d::meh + e::bah end;

package/deps/jq/tests/modules/c/d.jq

@@ -0,0 +1 @@
+def meh: "meh";

package/deps/jq/tests/modules/data.json

@@ -0,0 +1,4 @@
+{
+  "this": "is a test",
+  "that": "is too"
+}

package/deps/jq/tests/modules/lib/jq/e/e.jq

@@ -0,0 +1 @@
+def bah: "bah";

package/deps/jq/tests/modules/lib/jq/f.jq

@@ -0,0 +1 @@
+def f: "f is here";

package/deps/jq/tests/modules/syntaxerror/syntaxerror.jq

@@ -0,0 +1 @@
+wat;

package/deps/jq/tests/modules/test_bind_order.jq

@@ -0,0 +1,4 @@
+import "test_bind_order0" as t;
+import "test_bind_order1" as t;
+import "test_bind_order2" as t;
+def check: if [t::sym0,t::sym1,t::sym2] == [0,1,2] then true else false end;

package/deps/jq/tests/modules/test_bind_order0.jq

@@ -0,0 +1 @@
+def sym0: 0;

package/deps/jq/tests/modules/test_bind_order1.jq

@@ -0,0 +1,2 @@
+def sym0: 1;
+def sym1: 1;

package/deps/jq/tests/modules/test_bind_order2.jq

@@ -0,0 +1,2 @@
+def sym1: 2;
+def sym2: 2;

package/deps/jq/tests/onig.supp

@@ -0,0 +1,21 @@
+{
+	onig node recycling
+	Memcheck:Leak
+	...
+	fun:onig_parse_make_tree
+	...
+}
+{
+	onig unicode case insensitivity 1
+	Memcheck:Leak
+	...
+	fun:setup_tree
+	...
+}
+{
+	onig unicode case insensitivity 2
+	Memcheck:Leak
+	...
+	fun:onig*unicode*
+	...
+}

package/deps/jq/tests/onig.test

@@ -0,0 +1,85 @@
+# match builtin
+[match("( )*"; "g")]
+"abc"
+[{"offset":0, "length":0, "string":"", "captures":[]},{"offset":1, "length":0, "string":"", "captures":[]},{"offset":2, "length":0, "string":"", "captures":[]}]
+
+[match("( )*"; "gn")]
+"abc"
+[]
+
+[match("a"; "gi")]
+"āáàä"
+[]
+
+[match(["(bar)"])]
+"foo bar"
+[{"offset": 4, "length": 3, "string": "bar", "captures":[{"offset": 4, "length": 3, "string": "bar", "name": null}]}]
+
+# offsets account for combining codepoints and multi-byte UTF-8
+[match("bar")]
+"ā bar with a combining codepoint U+0304"
+[{"offset": 3, "length": 3, "string": "bar", "captures":[]}]
+
+# matches with combining codepoints still count them in their length
+[match("bār")]
+"a bār"
+[{"offset": 2, "length": 4, "string": "bār", "captures":[]}]
+
+[match(".+?\\b")]
+"ā two-codepoint grapheme"
+[{"offset": 0, "length": 2, "string": "ā", "captures":[]}]
+
+[match(["foo (?<bar123>bar)? foo", "ig"])]
+"foo bar foo foo  foo"
+[{"offset": 0, "length": 11, "string": "foo bar foo", "captures":[{"offset": 4, "length": 3, "string": "bar", "name": "bar123"}]},{"offset":12, "length": 8, "string": "foo  foo", "captures":[{"offset": -1, "length": 0, "string": null, "name": "bar123"}]}]
+
+#test builtin
+[test("( )*"; "gn")]
+"abc"
+[false]
+
+[test("ā")]
+"ā"
+[true]
+
+capture("(?<a>[a-z]+)-(?<n>[0-9]+)")
+"xyzzy-14"
+{"a":"xyzzy","n":"14"}
+
+
+# jq-coded utilities built on match:
+#
+# The second element in these tests' inputs tests the case where the
+# fromstring matches both the head and tail of the string
+[.[] | sub(", "; ":")]
+["a,b, c, d, e,f", ", a,b, c, d, e,f, "]
+["a,b:c, d, e,f",":a,b, c, d, e,f, "]
+
+sub("^(?<head>.)"; "Head=\(.head) Tail=")
+"abcdef"
+"Head=a Tail=bcdef"
+
+[.[] | gsub(", "; ":")]
+["a,b, c, d, e,f",", a,b, c, d, e,f, "]
+["a,b:c:d:e,f",":a,b:c:d:e,f:"]
+
+gsub("(?<d>\\d)"; ":\(.d);")
+"a1b2"
+"a:1;b:2;"
+
+[.[] | scan(", ")]
+["a,b, c, d, e,f",", a,b, c, d, e,f, "]
+[", ",", ",", ",", ",", ",", ",", ",", "]
+
+[.[]|[[sub(", *";":")], [gsub(", *";":")], [scan(", *")]]]
+["a,b, c, d, e,f",", a,b, c, d, e,f, "]
+[[["a:b, c, d, e,f"],["a:b:c:d:e:f"],[",",", ",", ",", ",","]],[[":a,b, c, d, e,f, "],[":a:b:c:d:e:f:"],[", ",",",", ",", ",", ",",",", "]]]
+
+[.[]|[[sub(", +";":")], [gsub(", +";":")], [scan(", +")]]]
+["a,b, c, d, e,f",", a,b, c, d, e,f, "]
+[[["a,b:c, d, e,f"],["a,b:c:d:e,f"],[", ",", ",", "]],[[":a,b, c, d, e,f, "],[":a,b:c:d:e,f:"],[", ",", ",", ",", ",", "]]]
+
+# reference to named captures
+gsub("(?<x>.)[^a]*"; "+\(.x)-")
+"Abcabc"
+"+A-+a-"

package/deps/jq/tests/onigtest

@@ -0,0 +1,5 @@
+#!/bin/sh
+
+. "${0%/*}/setup"
+
+$VALGRIND $Q $JQ -L "$mods" --run-tests $JQTESTDIR/onig.test

package/deps/jq/tests/setup

@@ -0,0 +1,36 @@
+#!/bin/sh
+
+# This is meant to be included by each test's shell script driver.
+
+set -eu
+
+JQTESTDIR=$(cd "$(dirname "$0")" && pwd)
+JQBASEDIR=$JQTESTDIR/..
+JQ=$JQBASEDIR/jq
+
+if [ -z "${NO_VALGRIND-}" ] && which valgrind > /dev/null; then
+    VALGRIND="valgrind --error-exitcode=1 --leak-check=full \
+                       --suppressions=$JQTESTDIR/onig.supp"
+    Q=-q
+else
+    VALGRIND=
+    Q=
+fi
+
+mods=$JQTESTDIR/modules
+
+clean=true
+d=
+clean () {
+    if ! $clean; then
+        echo "See temp files in $d!"
+    elif [ -n "$d" ]; then
+        rm -rf "$d"
+    fi
+}
+trap clean EXIT
+d=`mktemp -d -t jqXXXXX || true`
+if [ -z "$d" ]; then
+    echo "Your OS does not support mktemp(1) -d" 1>&2
+    exit 1
+fi

package/deps/jq/tests/shtest

@@ -0,0 +1,205 @@
+#!/bin/sh
+
+. "${0%/*}/setup"
+
+if [ -f "$JQBASEDIR/.libs/libinject_errors.so" ]; then
+  # Do some simple error injection tests to check that we're handling
+  # I/O errors correctly.
+  (
+  libinject=$JQBASEDIR/.libs/libinject_errors.so
+  cd $d
+  LD_PRELOAD=$libinject $JQ . /dev/null
+  touch fail_read
+  LD_PRELOAD=$libinject $JQ . fail_read && exit 2
+  touch fail_close
+  LD_PRELOAD=$libinject $JQ . fail_close && exit 2
+  true
+  )
+fi
+
+printf 'a\0b\nc\0d\ne' > $d/input
+$VALGRIND $Q $JQ -Rse '. == "a\u0000b\nc\u0000d\ne"' $d/input
+$VALGRIND $Q $JQ -Rne '[inputs] == ["a\u0000b", "c\u0000d", "e"]' $d/input
+
+## Test constant folding
+
+## XXX If we add a builtin to list the program's disassembly then we can
+## move all of these into tests/all.test
+
+# String constant folding (addition only)
+n=`$VALGRIND $Q $JQ -n --debug-dump-disasm '"foo"' | wc -l`
+if [ $n -ne 5 ]; then
+    echo "Constant expression folding for strings didn't work"
+    exit 1
+fi
+
+# Numeric constant folding (not all ops yet)
+n=`$VALGRIND $Q $JQ -n --debug-dump-disasm '1+1' | wc -l`
+if [ $n -ne 5 ]; then
+    echo "Constant expression folding for strings didn't work"
+    exit 1
+fi
+n=`$VALGRIND $Q $JQ -n --debug-dump-disasm '1-1' | wc -l`
+if [ $n -ne 5 ]; then
+    echo "Constant expression folding for strings didn't work"
+    exit 1
+fi
+n=`$VALGRIND $Q $JQ -n --debug-dump-disasm '2*3' | wc -l`
+if [ $n -ne 5 ]; then
+    echo "Constant expression folding for strings didn't work"
+    exit 1
+fi
+n=`$VALGRIND $Q $JQ -n --debug-dump-disasm '9/3' | wc -l`
+if [ $n -ne 5 ]; then
+    echo "Constant expression folding for strings didn't work"
+    exit 1
+fi
+n=`$VALGRIND $Q $JQ -n --debug-dump-disasm '9==3' | wc -l`
+if [ $n -ne 5 ]; then
+    echo "Constant expression folding for strings didn't work"
+    exit 1
+fi
+n=`$VALGRIND $Q $JQ -n --debug-dump-disasm '9!=3' | wc -l`
+if [ $n -ne 5 ]; then
+    echo "Constant expression folding for strings didn't work"
+    exit 1
+fi
+n=`$VALGRIND $Q $JQ -n --debug-dump-disasm '9<=3' | wc -l`
+if [ $n -ne 5 ]; then
+    echo "Constant expression folding for strings didn't work"
+    exit 1
+fi
+n=`$VALGRIND $Q $JQ -n --debug-dump-disasm '9>=3' | wc -l`
+if [ $n -ne 5 ]; then
+    echo "Constant expression folding for strings didn't work"
+    exit 1
+fi
+
+## Test JSON sequence support
+
+cat > $d/expected <<EOF
+ignoring parse error: Truncated value at line 2, column 5
+ignoring parse error: Truncated value at line 2, column 25
+ignoring parse error: Truncated value at line 2, column 41
+EOF
+printf '1\0362 3\n[0,1\036[4,5]true"ab"{"c":4\036{}{"d":5,"e":6"\036false\n'|$VALGRIND $Q $JQ -ces --seq '. == [2,3,[4,5],true,"ab",{},false]' > /dev/null 2> $d/out
+cmp $d/out $d/expected
+
+cat > $d/expected <<EOF
+ignoring parse error: Truncated value at line 2, column 5
+ignoring parse error: Truncated value at line 2, column 25
+ignoring parse error: Truncated value at line 3, column 1
+EOF
+printf '1\0362 3\n[0,1\036[4,5]true"ab"{"c":4\036{}{"d":5,"e":6"false\n\036null'|$VALGRIND $Q $JQ -ces --seq '. == [2,3,[4,5],true,"ab",{},null]' > /dev/null 2> $d/out
+cmp $d/out $d/expected
+
+# Note that here jq sees no inputs at all but it still succeeds because
+# --seq ignores parse errors
+cat > $d/expected <<EOF
+ignoring parse error: Unfinished abandoned text at EOF at line 1, column 4
+EOF
+printf '"foo' | $JQ -ce --seq . > $d/out 2>&1
+cmp $d/out $d/expected
+
+# Numeric values truncated by EOF are ignored
+cat > $d/expected <<EOF
+ignoring parse error: Unfinished abandoned text at EOF at line 1, column 1
+EOF
+printf '1' | $JQ -ce --seq . > $d/out 2>&1
+cmp $d/out $d/expected
+
+cat > $d/expected <<EOF
+EOF
+printf '1\n' | $JQ -cen --seq '[inputs] == []' >/dev/null 2> $d/out
+cmp $d/out $d/expected
+
+## Test streaming parser
+
+## If we add an option to stream to the `import ... as $symbol;` directive
+## then we can move these tests into tests/all.test.
+$VALGRIND $Q $JQ -c '. as $d|path(..) as $p|$d|getpath($p)|scalars_or_empty|[$p,.]' < "$JQTESTDIR/torture/input0.json" > $d/out0
+$VALGRIND $Q $JQ --stream -c '.|select(length==2)' < "$JQTESTDIR/torture/input0.json" > $d/out1
+diff $d/out0 $d/out1
+
+## XXX This test can be moved to tests/all.test _now_
+clean=false
+if which seq > /dev/null 2>&1; then
+    # XXX We should try every prefix of input0.json, but that makes this
+    # test very, very slow when run with valgrind, and the whole point
+    # is to run it with valgrind.
+    #
+    #len=`wc -c < "$JQTESTDIR/torture/input0.json"`
+    if [ -z "$VALGRIND" ]; then
+        start=1
+        end=`wc -c < "$JQTESTDIR/torture/input0.json"`
+    else
+        start=120
+        end=151
+    fi
+    for i in `seq $start $end`; do
+        dd "if=tests/torture/input0.json" bs=$i count=1 2>/dev/null |
+            $VALGRIND $JQ -c . > $d/out0 2>$d/err || true
+        if [ -n "$VALGRIND" ]; then
+            grep '^==[0-9][0-9]*== ERROR SUMMARY: 0 errors' $d/err > /dev/null
+        else
+            tail -1 $d/err | egrep -i 'assert|abort|core' && false
+        fi
+
+        dd "if=tests/torture/input0.json" bs=$i count=1 2>/dev/null |
+            $VALGRIND $JQ -cn --stream 'fromstream(inputs)' > $d/out1 2>$d/err || true
+        if [ -n "$VALGRIND" ]; then
+            grep '^==[0-9][0-9]*== ERROR SUMMARY: 0 errors' $d/err > /dev/null
+        else
+            tail -1 $d/err | egrep -i 'assert|abort|core' && false
+        fi
+
+        diff $d/out0 $d/out1
+    done
+else
+    echo "Not doing torture tests"
+fi
+
+## Fuzz parser
+
+## XXX With a `urandom` builtin we could move this test into tests/all.test
+clean=false
+if dd if=/dev/urandom bs=16 count=1024 > $d/rand 2>/dev/null; then
+    # Have a /dev/urandom, good
+    $VALGRIND $Q $JQ --seq . $d/rand >/dev/null 2>&1
+    $VALGRIND $Q $JQ --seq --stream . $d/rand >/dev/null 2>&1
+    dd if=/dev/urandom bs=16 count=1024 > $d/rand 2>/dev/null
+    $VALGRIND $Q $JQ --seq . $d/rand >/dev/null 2>&1
+    $VALGRIND $Q $JQ --seq --stream . $d/rand >/dev/null 2>&1
+    dd if=/dev/urandom bs=16 count=1024 > $d/rand 2>/dev/null
+    $VALGRIND $Q $JQ --seq . $d/rand >/dev/null 2>&1
+    $VALGRIND $Q $JQ --seq --stream . $d/rand >/dev/null 2>&1
+fi
+clean=true
+
+## Test library/module system
+
+# Check handling of ~/.jq; these can't move into jq_test.c yet because
+# they depend on $HOME
+if [ "`HOME="$mods" $VALGRIND $Q $JQ -nr fg`" != foobar ]; then
+    echo "Bug #479 appears to be back" 1>&2
+    exit 1
+fi
+
+if [ `HOME="$mods" $VALGRIND $Q $JQ --debug-dump-disasm -n fg | grep '^[a-z]' | wc -l` -gt 3 ]; then
+    echo "Binding too many defs into program" 1>&2
+    exit 1
+fi
+
+cd "$JQBASEDIR" # so that relative library paths are guaranteed correct
+if ! $VALGRIND $Q $JQ -L ./tests/modules -ne 'import "test_bind_order" as check; check::check==true'; then
+    echo "Issue #817 regression?" 1>&2
+    exit 1
+fi
+
+cd "$JQBASEDIR"
+if ! $VALGRIND $Q $JQ -L tests/modules -ne 'import "test_bind_order" as check; check::check==true'; then
+    echo "Issue #817 regression?" 1>&2
+    exit 1
+fi
+
+exit 0

package/deps/jq/tests/torture/input0.json

@@ -0,0 +1,7 @@
+0 12 true false null [] {} [{}] [[]]
+[0,01,[12,22,[34,[45,56],7]],[]]
+{"a":[1]}
+{"a":[{}]}
+{"a":[{},[],[[]]]}
+{"a":[{"b":[]}]}
+{"a":[{"b":[]},{},[2]]}