filter_test.go

package test

import (
	"testing"
)

func Test_Filter(t *testing.T) {
	batchTest(t, filterTests)
}

func Benchmark_Filter(b *testing.B) {
	batchBenchmark(b, filterTests)
}

var filterTests []testData = []testData{
	{
		selector:      `$[?(@.key)]`,
		data:          `{"key": 42, "another": {"key": 1}}`,
		expected:      []interface{}{map[string]interface{}{"key": float64(1)}},
		consensus:     consensusNone,
		expectedError: "",
	},
	{
		selector: `$..*[?(@.id>2)]`,
		data:     `[ { "complext": { "one": [ { "name": "first", "id": 1 }, { "name": "next", "id": 2 }, { "name": "another", "id": 3 }, { "name": "more", "id": 4 } ], "more": { "name": "next to last", "id": 5 } } }, { "name": "last", "id": 6 } ]`,
		expected: []interface{}{
			[]interface{}{},
			[]interface{}{},
			[]interface{}{map[string]interface{}{"id": float64(5), "name": "next to last"}},
			[]interface{}{map[string]interface{}{"id": float64(3), "name": "another"}, map[string]interface{}{"id": float64(4), "name": "more"}},
			[]interface{}{},
			[]interface{}{},
			[]interface{}{},
			[]interface{}{},
			[]interface{}{},
		},
		consensus:     consensusNone,
		expectedError: "",
	},
	{
		selector: `$..[?(@.id==2)]`,
		data:     `{"id": 2, "more": [{"id": 2}, {"more": {"id": 2}}, {"id": {"id": 2}}, [{"id": 2}]]}`,
		expected: []interface{}{
			map[string]interface{}{"id": float64(2)},
			map[string]interface{}{"id": float64(2)},
			map[string]interface{}{"id": float64(2)},
			map[string]interface{}{"id": float64(2)},
		},
		consensus:     consensusNone,
		expectedError: "",
	},
	{
		selector: `$[?(@.key+50==100)]`,
		data:     `[{"key": 60}, {"key": 50}, {"key": 10}, {"key": -50}, {"key+50": 100}]`,
		expected: []interface{}{
			map[string]interface{}{"key": float64(50)},
		},
		consensus:     consensusNone,
		expectedError: "",
	},
	{
		selector:      `$[?(@.key>42 && @.key<44)]`,
		data:          `[ {"key": 42}, {"key": 43}, {"key": 44} ]`,
		expected:      []interface{}{map[string]interface{}{"key": float64(43)}},
		consensus:     []interface{}{map[string]interface{}{"key": float64(43)}},
		expectedError: "",
	},
	{
		selector:      `$[?(@.key>0 && false)]`,
		data:          `[ {"key": 1}, {"key": 3}, {"key": "nice"}, {"key": true}, {"key": null}, {"key": false}, {"key": {}}, {"key": []}, {"key": -1}, {"key": 0}, {"key": ""} ]`,
		expected:      []interface{}{},
		consensus:     consensusNone,
		expectedError: "",
	},
	{
		selector:      `$[?(@.key>0 && true)]`,
		data:          `[ {"key": 1}, {"key": 3}, {"key": "nice"}, {"key": true}, {"key": null}, {"key": false}, {"key": {}}, {"key": []}, {"key": -1}, {"key": 0}, {"key": ""} ]`,
		expected:      []interface{}{map[string]interface{}{"key": float64(1)}, map[string]interface{}{"key": float64(3)}},
		consensus:     consensusNone,
		expectedError: "",
	},
	{
		selector:      `$[?(@.key>43 || @.key<43)]`,
		data:          `[ {"key": 42}, {"key": 43}, {"key": 44} ]`,
		expected:      []interface{}{map[string]interface{}{"key": float64(42)}, map[string]interface{}{"key": float64(44)}},
		consensus:     []interface{}{map[string]interface{}{"key": float64(42)}, map[string]interface{}{"key": float64(44)}},
		expectedError: "",
	},
	{
		selector:      `$[?(@.key>0 || false)]`,
		data:          `[ {"key": 1}, {"key": 3}, {"key": "nice"}, {"key": true}, {"key": null}, {"key": false}, {"key": {}}, {"key": []}, {"key": -1}, {"key": 0}, {"key": ""} ]`,
		expected:      []interface{}{map[string]interface{}{"key": float64(1)}, map[string]interface{}{"key": float64(3)}},
		consensus:     consensusNone,
		expectedError: "",
	},
	{
		selector:      `$[?(@.key>0 || true)]`,
		data:          `[ {"key": 1}, {"key": 3}, {"key": "nice"}, {"key": true}, {"key": null}, {"key": false}, {"key": {}}, {"key": []}, {"key": -1}, {"key": 0}, {"key": ""} ]`,
		expected:      []interface{}{map[string]interface{}{"key": float64(1)}, map[string]interface{}{"key": float64(3)}, map[string]interface{}{"key": float64(-1)}, map[string]interface{}{"key": float64(0)}},
		consensus:     consensusNone,
		expectedError: "",
	},
	{
		selector:      `$[?(@['key']==42)]`,
		data:          `[ {"key": 0}, {"key": 42}, {"key": -1}, {"key": 41}, {"key": 43}, {"key": 42.0001}, {"key": 41.9999}, {"key": 100}, {"some": "value"} ]`,
		expected:      []interface{}{map[string]interface{}{"key": float64(42)}},
		consensus:     []interface{}{map[string]interface{}{"key": float64(42)}},
		expectedError: "",
	},
	{
		selector:      `$[?(@['@key']==42)]`,
		data:          `[ {"@key": 0}, {"@key": 42}, {"key": 42}, {"@key": 43}, {"some": "value"} ]`,
		expected:      []interface{}{map[string]interface{}{"@key": float64(42)}},
		consensus:     []interface{}{map[string]interface{}{"@key": float64(42)}},
		expectedError: "",
	},
	{
		selector:      `$[?(@[-1]==2)]`,
		data:          `[[2, 3], ["a"], [0, 2], [2]]`,
		expected:      []interface{}{[]interface{}{float64(0), float64(2)}, []interface{}{float64(2)}},
		consensus:     consensusNone,
		expectedError: "",
	},
	{
		selector:      `$[?(@[1]=='b')]`,
		data:          `[["a", "b"], ["x", "y"]]`,
		expected:      []interface{}{[]interface{}{"a", "b"}},
		consensus:     []interface{}{[]interface{}{"a", "b"}},
		expectedError: "",
	},
	{
		selector:      `$[?(@[1]=='b')]`,
		data:          `{"1": ["a", "b"], "2": ["x", "y"]}`,
		expected:      []interface{}{[]interface{}{"a", "b"}},
		consensus:     consensusNone,
		expectedError: "",
	},
	{
		selector:      `$[?(@)]`,
		data:          `[ "some value", null, "value", 0, 1, -1, "", [], {}, false, true ]`,
		expected:      []interface{}{"some value", "value", float64(1), float64(-1), true},
		consensus:     consensusNone,
		expectedError: "",
	},
	{
		selector:      `$[?(@.a && (@.b || @.c))]`,
		data:          `[ { "a": true }, { "a": true, "b": true }, { "a": true, "b": true, "c": true }, { "b": true, "c": true }, { "a": true, "c": true }, { "c": true }, { "b": true } ]`,
		expected:      []interface{}{map[string]interface{}{"a": true, "b": true, "c": true}},
		consensus:     consensusNone,
		expectedError: "",
	},
	{
		selector:      `[?(@.a && @.b || @.c)]`,
		data:          `[ { "a": true, "b": true }, { "a": true, "b": true, "c": true }, { "b": true, "c": true }, { "a": true, "c": true }, { "a": true }, { "b": true }, { "c": true }, { "d": true }, {} ]`,
		expected:      nil,
		consensus:     consensusNone,
		expectedError: "invalid JSONPath selector '[?(@.a && @.b || @.c)]' unexpected token '[' at index 0",
	},
	{
		selector:      `$[?(@.key/10==5)]`,
		data:          `[{"key": 60}, {"key": 50}, {"key": 10}, {"key": -50}, {"key/10": 5}]`,
		expected:      []interface{}{map[string]interface{}{"key": float64(50)}},
		consensus:     consensusNone,
		expectedError: "",
	},
	{
		selector:      `$[?(@.key-dash == 'value')]`,
		data:          `[ { "key-dash": "value" } ]`,
		expected:      []interface{}{},
		consensus:     consensusNone,
		expectedError: "",
	},
	{
		selector:      `$[?(@.2 == 'second')]`,
		data:          `[{"a": "first", "2": "second", "b": "third"}]`,
		expected:      []interface{}{map[string]interface{}{"2": "second", "a": "first", "b": "third"}},
		consensus:     consensusNone,
		expectedError: "",
	},
	{
		selector:      `$[?(@.2 == 'third')]`,
		data:          `[["first", "second", "third", "forth", "fifth"]] `,
		expected:      []interface{}{},
		consensus:     consensusNone,
		expectedError: "",
	},
	{
		selector:      `$[?()]`,
		data:          `[1, {"key": 42}, "value", null]`,
		expected:      nil,
		consensus:     nil,
		expectedError: "invalid expression. is empty",
	},
	{
		selector: `$[?(@.key==42)]`,
		data:     `[ {"key": 0}, {"key": 42}, {"key": -1}, {"key": 1}, {"key": 41}, {"key": 43}, {"key": 42.0001}, {"key": 41.9999}, {"key": 100}, {"key": "some"}, {"key": "42"}, {"key": null}, {"key": 420}, {"key": ""}, {"key": {}}, {"key": []}, {"key": [42]}, {"key": {"key": 42}}, {"key": {"some": 42}}, {"some": "value"} ]`,
		expected: []interface{}{
			map[string]interface{}{"key": float64(42)},
		},
		consensus:     consensusNone,
		expectedError: "",
	},
	{
		selector:      `$[?(@==42)]`,
		data:          `[ 0, 42, -1, 41, 43, 42.0001, 41.9999, null, 100 ]`,
		expected:      []interface{}{float64(42)},
		consensus:     []interface{}{float64(42)},
		expectedError: "",
	},
	{
		selector:      `$[?(@.key==43)]`,
		data:          `[{"key": 42}]`,
		expected:      []interface{}{},
		consensus:     []interface{}{},
		expectedError: "",
	},
	{
		selector:      `$[?(@.key==42)]`,
		data:          `{ "a": {"key": 0}, "b": {"key": 42}, "c": {"key": -1}, "d": {"key": 41}, "e": {"key": 43}, "f": {"key": 42.0001}, "g": {"key": 41.9999}, "h": {"key": 100}, "i": {"some": "value"} }`,
		expected:      []interface{}{map[string]interface{}{"key": float64(42)}},
		consensus:     consensusNone,
		expectedError: "",
	},
	{
		selector:      `$[?(@.id==2)]`,
		data:          `{"id": 2}`,
		expected:      []interface{}{},
		consensus:     consensusNone,
		expectedError: "",
	},
	{
		selector:      `$[?(@.d==["v1","v2"])]`,
		data:          `[ { "d": [ "v1", "v2" ] }, { "d": [ "a", "b" ] }, { "d": "v1" }, { "d": "v2" }, { "d": {} }, { "d": [] }, { "d": null }, { "d": -1 }, { "d": 0 }, { "d": 1 }, { "d": "['v1','v2']" }, { "d": "['v1', 'v2']" }, { "d": "v1,v2" }, { "d": "[\"v1\", \"v2\"]" }, { "d": "[\"v1\",\"v2\"]" } ]`,
		expected:      []interface{}{map[string]interface{}{"d": []interface{}{"v1", "v2"}}},
		consensus:     consensusNone,
		expectedError: "",
	},
	{
		selector: `$[?(@[0:1]==[1])]`,
		data:     `[[1, 2, 3], [1], [2, 3], 1, 2]`,
		expected: []interface{}{
			[]interface{}{float64(1), float64(2), float64(3)},
			[]interface{}{float64(1)},
		},
		consensus:     consensusNone,
		expectedError: "",
	},
	{
		selector:      `$[?(@.*==[1,2])]`,
		data:          `[[1,2], [2,3], [1], [2], [1, 2, 3], 1, 2, 3]`,
		expected:      []interface{}{[]interface{}{float64(1), float64(2)}},
		consensus:     consensusNone,
		expectedError: "",
	},
	{
		// TODO : better array comparison, this fails due to single quotes
		selector:      `$[?(@.d==['v1','v2'])]`,
		data:          `[ { "d": [ "v1", "v2" ] }, { "d": [ "a", "b" ] }, { "d": "v1" }, { "d": "v2" }, { "d": {} }, { "d": [] }, { "d": null }, { "d": -1 }, { "d": 0 }, { "d": 1 }, { "d": "['v1','v2']" }, { "d": "['v1', 'v2']" }, { "d": "v1,v2" }, { "d": "[\"v1\", \"v2\"]" }, { "d": "[\"v1\",\"v2\"]" } ]`,
		expected:      []interface{}{},
		consensus:     consensusNone,
		expectedError: "",
	},
	{
		selector:      `$[?((@.key<44)==false)]`,
		data:          `[{"key": 42}, {"key": 43}, {"key": 44}]`,
		expected:      []interface{}{map[string]interface{}{"key": float64(44)}},
		consensus:     consensusNone,
		expectedError: "",
	},
	{
		selector:      `$[?(@.key==false)]`,
		data:          `[ { "some": "some value" }, { "key": true }, { "key": false }, { "key": null }, { "key": "value" }, { "key": "" }, { "key": 0 }, { "key": 1 }, { "key": -1 }, { "key": 42 }, { "key": {} }, { "key": [] } ]`,
		expected:      []interface{}{map[string]interface{}{"key": false}},
		consensus:     consensusNone,
		expectedError: "",
	},
	{
		selector: `$[?(@.key==null)]`,
		data:     `[ { "some": "some value" }, { "key": true }, { "key": false }, { "key": null }, { "key": "value" }, { "key": "" }, { "key": 0 }, { "key": 1 }, { "key": -1 }, { "key": 42 }, { "key": {} }, { "key": [] } ]`,
		expected: []interface{}{
			map[string]interface{}{"key": nil},
		},
		consensus:     consensusNone,
		expectedError: "",
	},
	{
		// array compared to a single digit, always will be empty
		selector:      `$[?(@[0:1]==1)]`,
		data:          `[[1, 2, 3], [1], [2, 3], 1, 2]`,
		expected:      []interface{}{},
		consensus:     consensusNone,
		expectedError: "",
	},
	{
		// array compared to a single digit, always will be empty
		selector:      `$[?(@[*]==2)]`,
		data:          `[[1,2], [2,3], [1], [2], [1, 2, 3], 1, 2, 3]`,
		expected:      []interface{}{},
		consensus:     consensusNone,
		expectedError: "",
	},
	{
		// array compared to a single digit, always will be empty
		selector:      `$[?(@.*==2)]`,
		data:          `[[1,2], [2,3], [1], [2], [1, 2, 3], 1, 2, 3]`,
		expected:      []interface{}{},
		consensus:     consensusNone,
		expectedError: "",
	},
	{
		selector: `$[?(@.key==-0.123e2)]`,
		data:     `[{"key": -12.3}, {"key": -0.123}, {"key": -12}, {"key": 12.3}, {"key": 2}, {"key": "-0.123e2"}]`,
		expected: []interface{}{
			map[string]interface{}{"key": float64(-12.3)},
		},
		consensus:     consensusNone,
		expectedError: "",
	},
	{
		selector: `$[?(@.key==010)]`,
		data:     `[{"key": "010"}, {"key": "10"}, {"key": 10}, {"key": 0}, {"key": 8}]`,
		expected: []interface{}{
			map[string]interface{}{"key": float64(10)},
		},
		consensus:     consensusNone,
		expectedError: "",
	},
	{
		selector: `$[?(@.d=={"k":"v"})]`,
		data:     `[ { "d": { "k": "v" } }, { "d": { "a": "b" } }, { "d": "k" }, { "d": "v" }, { "d": {} }, { "d": [] }, { "d": null }, { "d": -1 }, { "d": 0 }, { "d": 1 }, { "d": "[object Object]" }, { "d": "{\"k\": \"v\"}" }, { "d": "{\"k\":\"v\"}" }, "v" ]`,
		expected: []interface{}{
			map[string]interface{}{"d": map[string]interface{}{"k": "v"}},
		},
		consensus:     consensusNone,
		expectedError: "",
	},
	{
		selector:      `$[?(@.key=="value")]`,
		data:          `[ {"key": "some"}, {"key": "value"}, {"key": null}, {"key": 0}, {"key": 1}, {"key": -1}, {"key": ""}, {"key": {}}, {"key": []}, {"key": "valuemore"}, {"key": "morevalue"}, {"key": ["value"]}, {"key": {"some": "value"}}, {"key": {"key": "value"}}, {"some": "value"} ]`,
		expected:      []interface{}{map[string]interface{}{"key": "value"}},
		consensus:     []interface{}{map[string]interface{}{"key": "value"}},
		expectedError: "",
	},
	{
		selector:      `$[?(@.key=="Motörhead")]`,
		data:          `[ {"key": "something"}, {"key": "Mot\u00f6rhead"}, {"key": "mot\u00f6rhead"}, {"key": "Motorhead"}, {"key": "Motoo\u0308rhead"}, {"key": "motoo\u0308rhead"} ]`,
		expected:      []interface{}{map[string]interface{}{"key": "Mot\u00f6rhead"}},
		consensus:     []interface{}{map[string]interface{}{"key": "Mot\u00f6rhead"}},
		expectedError: "",
	},
	{
		selector:      `$[?(@.key=="hi@example.com")]`,
		data:          `[ {"key": "some"}, {"key": "value"}, {"key": "hi@example.com"} ]`,
		expected:      []interface{}{map[string]interface{}{"key": "hi@example.com"}},
		consensus:     []interface{}{map[string]interface{}{"key": "hi@example.com"}},
		expectedError: "",
	},
	{
		selector:      `$[?(@.key=="some.value")]`,
		data:          `[ {"key": "some"}, {"key": "value"}, {"key": "some.value"} ]`,
		expected:      []interface{}{map[string]interface{}{"key": "some.value"}},
		consensus:     []interface{}{map[string]interface{}{"key": "some.value"}},
		expectedError: "",
	},
	{
		selector:      `$[?(@.key=='value')]`,
		data:          `[ {"key": "some"}, {"key": "value"} ]`,
		expected:      []interface{}{map[string]interface{}{"key": "value"}},
		consensus:     []interface{}{map[string]interface{}{"key": "value"}},
		expectedError: "",
	},
	{
		selector:      `$[?(@.key=="Mot\u00f6rhead")]`,
		data:          `[ {"key": "something"}, {"key": "Mot\u00f6rhead"}, {"key": "mot\u00f6rhead"}, {"key": "Motorhead"}, {"key": "Motoo\u0308rhead"}, {"key": "motoo\u0308rhead"} ]`,
		expected:      []interface{}{},
		consensus:     consensusNone,
		expectedError: "",
	},
	{
		selector:      `$[?(@.key==true)]`,
		data:          `[ { "some": "some value" }, { "key": true }, { "key": false }, { "key": null }, { "key": "value" }, { "key": "" }, { "key": 0 }, { "key": 1 }, { "key": -1 }, { "key": 42 }, { "key": {} }, { "key": [] } ]`,
		expected:      []interface{}{map[string]interface{}{"key": true}},
		consensus:     consensusNone,
		expectedError: "",
	},
	{
		selector: `$[?(@.key1==@.key2)]`,
		data:     `[ {"key1": 10, "key2": 10}, {"key1": 42, "key2": 50}, {"key1": 10}, {"key2": 10}, {}, {"key1": null, "key2": null}, {"key1": null}, {"key2": null}, {"key1": 0, "key2": 0}, {"key1": 0}, {"key2": 0}, {"key1": -1, "key2": -1}, {"key1": "", "key2": ""}, {"key1": false, "key2": false}, {"key1": false}, {"key2": false}, {"key1": true, "key2": true}, {"key1": [], "key2": []}, {"key1": {}, "key2": {}}, {"key1": {"a": 1, "b": 2}, "key2": {"b": 2, "a": 1}} ]`,
		expected: []interface{}{
			map[string]interface{}{"key1": float64(10), "key2": float64(10)},
			map[string]interface{}{"key1": nil, "key2": nil},
			map[string]interface{}{"key1": float64(0), "key2": float64(0)},
			map[string]interface{}{"key1": float64(-1), "key2": float64(-1)},
			map[string]interface{}{"key1": "", "key2": ""},
			map[string]interface{}{"key1": false, "key2": false},
			map[string]interface{}{"key1": true, "key2": true},
			map[string]interface{}{"key1": []interface{}{}, "key2": []interface{}{}},
			map[string]interface{}{"key1": map[string]interface{}{}, "key2": map[string]interface{}{}},
			map[string]interface{}{
				"key1": map[string]interface{}{
					"a": float64(1),
					"b": float64(2),
				}, "key2": map[string]interface{}{
					"a": float64(1),
					"b": float64(2),
				},
			},
		},
		consensus:     consensusNone,
		expectedError: "",
	},
	{
		selector:      `$.items[?(@.key==$.value)]`,
		data:          `{"value": 42, "items": [{"key": 10}, {"key": 42}, {"key": 50}]}`,
		expected:      []interface{}{map[string]interface{}{"key": float64(42)}},
		consensus:     consensusNone,
		expectedError: "",
	},
	{
		selector: `$[?(@.key>42)]`,
		data:     `[ {"key": 0}, {"key": 42}, {"key": -1}, {"key": 41}, {"key": 43}, {"key": 42.0001}, {"key": 41.9999}, {"key": 100}, {"key": "43"}, {"key": "42"}, {"key": "41"}, {"key": "value"}, {"some": "value"} ]`,
		expected: []interface{}{
			map[string]interface{}{"key": float64(43)},
			map[string]interface{}{"key": float64(42.0001)},
			map[string]interface{}{"key": float64(100)},
		},
		consensus:     consensusNone,
		expectedError: "",
	},
	{
		selector: `$[?(@.key>=42)]`,
		data:     `[ {"key": 0}, {"key": 42}, {"key": -1}, {"key": 41}, {"key": 43}, {"key": 42.0001}, {"key": 41.9999}, {"key": 100}, {"key": "43"}, {"key": "42"}, {"key": "41"}, {"key": "value"}, {"some": "value"} ]`,
		expected: []interface{}{
			map[string]interface{}{"key": float64(42)},
			map[string]interface{}{"key": float64(43)},
			map[string]interface{}{"key": float64(42.0001)},
			map[string]interface{}{"key": float64(100)},
		},
		consensus:     consensusNone,
		expectedError: "",
	},
	{
		selector: `$[?(@.d in [2, 3])]`,
		data:     `[{"d": 1}, {"d": 2}, {"d": 1}, {"d": 3}, {"d": 4}]`,
		expected: []interface{}{
			map[string]interface{}{"d": float64(2)},
			map[string]interface{}{"d": float64(3)},
		},
		consensus:     nil,
		expectedError: "",
	},
	{
		selector: `$[?(2 in @.d)]`,
		data:     `[{"d": [1, 2, 3]}, {"d": [2]}, {"d": [1]}, {"d": [3, 4]}, {"d": [4, 2]}]`,
		expected: []interface{}{
			map[string]interface{}{"d": []interface{}{float64(1), float64(2), float64(3)}},
			map[string]interface{}{"d": []interface{}{float64(2)}},
			map[string]interface{}{"d": []interface{}{float64(4), float64(2)}},
		},
		consensus:     nil,
		expectedError: "",
	},
	{
		selector: `$[?(@.key<42)]`,
		data:     `[ {"key": 0}, {"key": 42}, {"key": -1}, {"key": 41}, {"key": 43}, {"key": 42.0001}, {"key": 41.9999}, {"key": 100}, {"key": "43"}, {"key": "42"}, {"key": "41"}, {"key": "value"}, {"some": "value"} ]`,
		expected: []interface{}{
			map[string]interface{}{"key": float64(0)},
			map[string]interface{}{"key": float64(-1)},
			map[string]interface{}{"key": float64(41)},
			map[string]interface{}{"key": float64(41.9999)},
		},
		consensus:     consensusNone,
		expectedError: "",
	},
	{
		selector: `$[?(@.key<=42)]`,
		data:     `[ {"key": 0}, {"key": 42}, {"key": -1}, {"key": 41}, {"key": 43}, {"key": 42.0001}, {"key": 41.9999}, {"key": 100}, {"key": "43"}, {"key": "42"}, {"key": "41"}, {"key": "value"}, {"some": "value"} ]`,
		expected: []interface{}{
			map[string]interface{}{"key": float64(0)},
			map[string]interface{}{"key": float64(42)},
			map[string]interface{}{"key": float64(-1)},
			map[string]interface{}{"key": float64(41)},
			map[string]interface{}{"key": float64(41.9999)},
		},
		consensus:     consensusNone,
		expectedError: "",
	},
	{
		selector:      `$[?(@.key*2==100)]`,
		data:          `[{"key": 60}, {"key": 50}, {"key": 10}, {"key": -50}, {"key*2": 100}]`,
		expected:      []interface{}{map[string]interface{}{"key": float64(50)}},
		consensus:     consensusNone,
		expectedError: "",
	},
	{
		selector: `$[?(!(@.key==42))]`,
		data:     `[ {"key": 0}, {"key": 42}, {"key": -1}, {"key": 41}, {"key": 43}, {"key": 42.0001}, {"key": 41.9999}, {"key": 100}, {"key": "43"}, {"key": "42"}, {"key": "41"}, {"key": "value"}, {"some": "value"} ]`,
		expected: []interface{}{
			map[string]interface{}{"key": float64(0)},
			map[string]interface{}{"key": float64(-1)},
			map[string]interface{}{"key": float64(41)},
			map[string]interface{}{"key": float64(43)},
			map[string]interface{}{"key": float64(42.0001)},
			map[string]interface{}{"key": float64(41.9999)},
			map[string]interface{}{"key": float64(100)},
			map[string]interface{}{"key": "43"},
			map[string]interface{}{"key": "42"},
			map[string]interface{}{"key": "41"},
			map[string]interface{}{"key": "value"},
			// map[string]interface{}{"some": "value"}, // TODO : it should include this
		},
		consensus:     consensusNone,
		expectedError: "",
	},
	{
		// TODO : should include those without key fields
		selector: `$[?(!(@.key<42))]`,
		data:     `[ {"key": 0}, {"key": 42}, {"key": -1}, {"key": 41}, {"key": 43}, {"key": 42.0001}, {"key": 41.9999}, {"key": 100}, {"key": "43"}, {"key": "42"}, {"key": "41"}, {"key": "value"}, {"some": "value"} ]`,
		expected: []interface{}{
			map[string]interface{}{"key": float64(42)},
			map[string]interface{}{"key": float64(43)},
			map[string]interface{}{"key": float64(42.0001)},
			map[string]interface{}{"key": float64(100)},
		},
		consensus:     consensusNone,
		expectedError: "",
	},
	{
		// TODO : this should also include {some: some value} and the null and empty
		selector: `$[?(!@.key)]`,
		data:     `[ { "some": "some value" }, { "key": true }, { "key": false }, { "key": null }, { "key": "value" }, { "key": "" }, { "key": 0 }, { "key": 1 }, { "key": -1 }, { "key": 42 }, { "key": {} }, { "key": [] } ]`,
		expected: []interface{}{
			map[string]interface{}{"key": false},
			map[string]interface{}{"key": nil},
			map[string]interface{}{"key": float64(0)},
		},
		consensus:     consensusNone,
		expectedError: "",
	},
	{
		selector: `$[?(@.key!=42)]`,
		data:     `[ {"key": 0}, {"key": 42}, {"key": -1}, {"key": 1}, {"key": 41}, {"key": 43}, {"key": 42.0001}, {"key": 41.9999}, {"key": 100}, {"key": "some"}, {"key": "42"}, {"key": null}, {"key": 420}, {"key": ""}, {"key": {}}, {"key": []}, {"key": [42]}, {"key": {"key": 42}}, {"key": {"some": 42}}, {"some": "value"} ]`,
		expected: []interface{}{
			map[string]interface{}{"key": float64(0)},
			map[string]interface{}{"key": float64(-1)},
			map[string]interface{}{"key": float64(1)},
			map[string]interface{}{"key": float64(41)},
			map[string]interface{}{"key": float64(43)},
			map[string]interface{}{"key": float64(42.0001)},
			map[string]interface{}{"key": float64(41.9999)},
			map[string]interface{}{"key": float64(100)},
			map[string]interface{}{"key": "some"},
			map[string]interface{}{"key": "42"},
			map[string]interface{}{"key": nil},
			map[string]interface{}{"key": float64(420)},
			map[string]interface{}{"key": ""},
			map[string]interface{}{"key": map[string]interface{}{}},
			map[string]interface{}{"key": []interface{}{}},
			map[string]interface{}{"key": []interface{}{float64(42)}},
			map[string]interface{}{"key": map[string]interface{}{"key": float64(42)}},
			map[string]interface{}{"key": map[string]interface{}{"some": float64(42)}},
		},
		consensus:     consensusNone,
		expectedError: "",
	},
	{
		selector:      `$[*].bookmarks[?(@.page == 45)]^^^`,
		data:          `[ { "title": "Sayings of the Century", "bookmarks": [{ "page": 40 }] }, { "title": "Sword of Honour", "bookmarks": [ { "page": 35 }, { "page": 45 } ] }, { "title": "Moby Dick", "bookmarks": [ { "page": 3035 }, { "page": 45 } ] } ]`,
		expected:      []interface{}{[]interface{}{}, []interface{}{}, []interface{}{}},
		consensus:     nil,
		expectedError: "",
	},
	{
		selector:      `$[?(@.name=~/hello.*/)]`, // TODO : need better regex support
		data:          `[ {"name": "hullo world"}, {"name": "hello world"}, {"name": "yes hello world"}, {"name": "HELLO WORLD"}, {"name": "good bye"} ]`,
		expected:      []interface{}{},
		consensus:     consensusNone,
		expectedError: "",
	},
	{
		selector:      `$[?(@.name=~/@.pattern/)]`,
		data:          `[ {"name": "hullo world"}, {"name": "hello world"}, {"name": "yes hello world"}, {"name": "HELLO WORLD"}, {"name": "good bye"}, {"pattern": "hello.*"} ]`,
		expected:      []interface{}{},
		consensus:     consensusNone,
		expectedError: "",
	},
	{
		selector:      `$[?(@[*]>=4)]`,
		data:          `[[1,2],[3,4],[5,6]]`,
		expected:      []interface{}{},
		consensus:     consensusNone,
		expectedError: "",
	},
	{
		selector:      `$.x[?(@[*]>=$.y[*])]`,
		data:          `{"x":[[1,2],[3,4],[5,6]],"y":[3,4,5]}`,
		expected:      []interface{}{},
		consensus:     consensusNone,
		expectedError: "",
	},
	{
		selector:      `$[?(@.key=42)]`,
		data:          `[ {"key": 0}, {"key": 42}, {"key": -1}, {"key": 1}, {"key": 41}, {"key": 43}, {"key": 42.0001}, {"key": 41.9999}, {"key": 100}, {"key": "some"}, {"key": "42"}, {"key": null}, {"key": 420}, {"key": ""}, {"key": {}}, {"key": []}, {"key": [42]}, {"key": {"key": 42}}, {"key": {"some": 42}}, {"some": "value"} ]`,
		expected:      []interface{}{},
		consensus:     nil,
		expectedError: "",
	},
	{
		selector: `$[?(@.a[?(@.price>10)])]`,
		data:     `[ { "a": [{"price": 1}, {"price": 3}] }, { "a": [{"price": 11}] }, { "a": [{"price": 8}, {"price": 12}, {"price": 3}] }, { "a": [] } ]`,
		expected: []interface{}{
			map[string]interface{}{
				"a": []interface{}{
					map[string]interface{}{"price": float64(11)},
				},
			}, map[string]interface{}{
				"a": []interface{}{
					map[string]interface{}{"price": float64(8)},
					map[string]interface{}{"price": float64(12)},
					map[string]interface{}{"price": float64(3)},
				},
			},
		},
		consensus:     consensusNone,
		expectedError: "",
	},
	{
		selector:      `$[?(@.address.city=='Berlin')]`,
		data:          `[ { "address": { "city": "Berlin" } }, { "address": { "city": "London" } } ]`,
		expected:      []interface{}{map[string]interface{}{"address": map[string]interface{}{"city": "Berlin"}}},
		consensus:     []interface{}{map[string]interface{}{"address": map[string]interface{}{"city": "Berlin"}}},
		expectedError: "",
	},
	{
		selector:      `$[?(@.key-50==-100)]`,
		data:          `[{"key": 60}, {"key": 50}, {"key": 10}, {"key": -50}, {"key-50": -100}]`,
		expected:      []interface{}{map[string]interface{}{"key": float64(-50)}},
		consensus:     consensusNone,
		expectedError: "",
	},
	{
		selector:      `$[?(1==1)]`,
		data:          `[1, 3, "nice", true, null, false, {}, [], -1, 0, ""]`,
		expected:      []interface{}{float64(1), float64(3), "nice", true, interface{}(nil), false, map[string]interface{}{}, []interface{}{}, float64(-1), float64(0), ""},
		consensus:     consensusNone,
		expectedError: "",
	},
	{
		selector:      `$[?(@.key===42)]`,
		data:          `[ {"key": 0}, {"key": 42}, {"key": -1}, {"key": 1}, {"key": 41}, {"key": 43}, {"key": 42.0001}, {"key": 41.9999}, {"key": 100}, {"key": "some"}, {"key": "42"}, {"key": null}, {"key": 420}, {"key": ""}, {"key": {}}, {"key": []}, {"key": [42]}, {"key": {"key": 42}}, {"key": {"some": 42}}, {"some": "value"} ]`,
		expected:      []interface{}{},
		consensus:     consensusNone,
		expectedError: "",
	},
	{
		selector: `$[?(@.key)]`,
		data:     `[ { "some": "some value" }, { "key": true }, { "key": false }, { "key": null }, { "key": "value" }, { "key": "" }, { "key": 0 }, { "key": 1 }, { "key": -1 }, { "key": 42 }, { "key": {} }, { "key": [] } ]`,
		expected: []interface{}{
			map[string]interface{}{"key": true},
			map[string]interface{}{"key": "value"},
			map[string]interface{}{"key": float64(1)},
			map[string]interface{}{"key": float64(-1)},
			map[string]interface{}{"key": float64(42)},
		},
		consensus:     consensusNone,
		expectedError: "",
	},
	{
		selector:      `$.*[?(@.key)]`,
		data:          `[ { "some": "some value" }, { "key": "value" } ]`,
		expected:      []interface{}{[]interface{}{}, []interface{}{}},
		consensus:     consensusNone,
		expectedError: "",
	},
	{
		selector: `$..[?(@.id)]`,
		data:     `{"id": 2, "more": [{"id": 2}, {"more": {"id": 2}}, {"id": {"id": 2}}, [{"id": 2}]]}`,
		expected: []interface{}{
			map[string]interface{}{"id": float64(2)},
			map[string]interface{}{"id": map[string]interface{}{"id": float64(2)}},
			map[string]interface{}{"id": float64(2)},
			map[string]interface{}{"id": float64(2)},
			map[string]interface{}{"id": float64(2)},
		},
		consensus:     consensusNone,
		expectedError: "",
	},
	{
		selector:      `$[?(false)]`,
		data:          `[1, 3, "nice", true, null, false, {}, [], -1, 0, ""]`,
		expected:      []interface{}{},
		consensus:     consensusNone,
		expectedError: "",
	},
	{
		selector: `$[?(@..child)]`,
		data:     `[{"key": [{"child": 1}, {"child": 2}]}, {"key": [{"child": 2}]}, {"key": [{}]}, {"key": [{"something": 42}]}, {}]`,
		expected: []interface{}{
			map[string]interface{}{
				"key": []interface{}{
					map[string]interface{}{"child": float64(1)},
					map[string]interface{}{"child": float64(2)},
				},
			},
			map[string]interface{}{
				"key": []interface{}{
					map[string]interface{}{"child": float64(2)},
				},
			},
		},
		consensus:     consensusNone,
		expectedError: "",
	},
	{
		selector:      `$[?(null)]`,
		data:          `[1, 3, "nice", true, null, false, {}, [], -1, 0, ""]`,
		expected:      []interface{}{},
		consensus:     consensusNone,
		expectedError: "",
	},
	{
		selector:      `$[?(true)]`,
		data:          `[1, 3, "nice", true, null, false, {}, [], -1, 0, ""]`,
		expected:      []interface{}{float64(1), float64(3), "nice", true, interface{}(nil), false, map[string]interface{}{}, []interface{}{}, float64(-1), float64(0), ""},
		consensus:     consensusNone,
		expectedError: "",
	},
	{
		selector:      `$[?@.key==42]`,
		data:          `[ {"key": 0}, {"key": 42}, {"key": -1}, {"key": 1}, {"key": 41}, {"key": 43}, {"key": 42.0001}, {"key": 41.9999}, {"key": 100}, {"key": "some"}, {"key": "42"}, {"key": null}, {"key": 420}, {"key": ""}, {"key": {}}, {"key": []}, {"key": [42]}, {"key": {"key": 42}}, {"key": {"some": 42}}, {"some": "value"} ]`,
		expected:      nil,
		consensus:     consensusNone,
		expectedError: "invalid JSONPath selector '$[?@.key==42]' invalid token. '[?@.key==42]' does not match any token format",
	},
	{
		selector: `$[?(@.key)]`,
		data:     `[ { "some": "some value" }, { "key": true }, { "key": false }, { "key": null }, { "key": "value" }, { "key": "" }, { "key": 0 }, { "key": 1 }, { "key": -1 }, { "key": 42 }, { "key": {} }, { "key": [] } ]`,
		expected: []interface{}{
			map[string]interface{}{"key": true},
			map[string]interface{}{"key": "value"},
			map[string]interface{}{"key": float64(1)},
			map[string]interface{}{"key": float64(-1)},
			map[string]interface{}{"key": float64(42)},
		},
		consensus:     consensusNone,
		expectedError: "",
	},
}