pax_global_header00006660000000000000000000000064137312442170014516gustar00rootroot0000000000000052 comment=3d4fd11601ddca248480565884e34e393313cd62 go-jmespath-0.4.0/000077500000000000000000000000001373124421700137355ustar00rootroot00000000000000go-jmespath-0.4.0/.gitignore000066400000000000000000000000611373124421700157220ustar00rootroot00000000000000/jpgo jmespath-fuzz.zip cpu.out go-jmespath.test go-jmespath-0.4.0/.travis.yml000066400000000000000000000004341373124421700160470ustar00rootroot00000000000000language: go sudo: false go: - 1.5.x - 1.6.x - 1.7.x - 1.8.x - 1.9.x - 1.10.x - 1.11.x - 1.12.x - 1.13.x - 1.14.x - 1.15.x - tip allow_failures: - go: tip script: make build matrix: include: - language: go go: 1.15.x script: make test go-jmespath-0.4.0/LICENSE000066400000000000000000000010571373124421700147450ustar00rootroot00000000000000Copyright 2015 James Saryerwinnie Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. go-jmespath-0.4.0/Makefile000066400000000000000000000022421373124421700153750ustar00rootroot00000000000000 CMD = jpgo SRC_PKGS=./ ./cmd/... ./fuzz/... help: @echo "Please use \`make ' where is one of" @echo " test to run all the tests" @echo " build to build the library and jp executable" @echo " generate to run codegen" generate: go generate ${SRC_PKGS} build: rm -f $(CMD) go build ${SRC_PKGS} rm -f cmd/$(CMD)/$(CMD) && cd cmd/$(CMD)/ && go build ./... mv cmd/$(CMD)/$(CMD) . test: test-internal-testify echo "making tests ${SRC_PKGS}" go test -v ${SRC_PKGS} check: go vet ${SRC_PKGS} @echo "golint ${SRC_PKGS}" @lint=`golint ${SRC_PKGS}`; \ lint=`echo "$$lint" | grep -v "astnodetype_string.go" | grep -v "toktype_string.go"`; \ echo "$$lint"; \ if [ "$$lint" != "" ]; then exit 1; fi htmlc: go test -coverprofile="/tmp/jpcov" && go tool cover -html="/tmp/jpcov" && unlink /tmp/jpcov buildfuzz: go-fuzz-build github.com/jmespath/go-jmespath/fuzz fuzz: buildfuzz go-fuzz -bin=./jmespath-fuzz.zip -workdir=fuzz/testdata bench: go test -bench . -cpuprofile cpu.out pprof-cpu: go tool pprof ./go-jmespath.test ./cpu.out test-internal-testify: cd internal/testify && go test ./... go-jmespath-0.4.0/README.md000066400000000000000000000055771373124421700152320ustar00rootroot00000000000000# go-jmespath - A JMESPath implementation in Go [![Build Status](https://img.shields.io/travis/jmespath/go-jmespath.svg)](https://travis-ci.org/jmespath/go-jmespath) go-jmespath is a GO implementation of JMESPath, which is a query language for JSON. It will take a JSON document and transform it into another JSON document through a JMESPath expression. Using go-jmespath is really easy. There's a single function you use, `jmespath.search`: ```go > import "github.com/jmespath/go-jmespath" > > var jsondata = []byte(`{"foo": {"bar": {"baz": [0, 1, 2, 3, 4]}}}`) // your data > var data interface{} > err := json.Unmarshal(jsondata, &data) > result, err := jmespath.Search("foo.bar.baz[2]", data) result = 2 ``` In the example we gave the ``search`` function input data of `{"foo": {"bar": {"baz": [0, 1, 2, 3, 4]}}}` as well as the JMESPath expression `foo.bar.baz[2]`, and the `search` function evaluated the expression against the input data to produce the result ``2``. The JMESPath language can do a lot more than select an element from a list. Here are a few more examples: ```go > var jsondata = []byte(`{"foo": {"bar": {"baz": [0, 1, 2, 3, 4]}}}`) // your data > var data interface{} > err := json.Unmarshal(jsondata, &data) > result, err := jmespath.search("foo.bar", data) result = { "baz": [ 0, 1, 2, 3, 4 ] } > var jsondata = []byte(`{"foo": [{"first": "a", "last": "b"}, {"first": "c", "last": "d"}]}`) // your data > var data interface{} > err := json.Unmarshal(jsondata, &data) > result, err := jmespath.search({"foo[*].first", data) result [ 'a', 'c' ] > var jsondata = []byte(`{"foo": [{"age": 20}, {"age": 25}, {"age": 30}, {"age": 35}, {"age": 40}]}`) // your data > var data interface{} > err := json.Unmarshal(jsondata, &data) > result, err := jmespath.search("foo[?age > `30`]") result = [ { age: 35 }, { age: 40 } ] ``` You can also pre-compile your query. This is usefull if you are going to run multiple searches with it: ```go > var jsondata = []byte(`{"foo": "bar"}`) > var data interface{} > err := json.Unmarshal(jsondata, &data) > precompiled, err := Compile("foo") > if err != nil{ > // ... handle the error > } > result, err := precompiled.Search(data) result = "bar" ``` ## More Resources The example above only show a small amount of what a JMESPath expression can do. If you want to take a tour of the language, the *best* place to go is the [JMESPath Tutorial](http://jmespath.org/tutorial.html). One of the best things about JMESPath is that it is implemented in many different programming languages including python, ruby, php, lua, etc. To see a complete list of libraries, check out the [JMESPath libraries page](http://jmespath.org/libraries.html). And finally, the full JMESPath specification can be found on the [JMESPath site](http://jmespath.org/specification.html). go-jmespath-0.4.0/api.go000066400000000000000000000027021373124421700150360ustar00rootroot00000000000000package jmespath import "strconv" // JMESPath is the representation of a compiled JMES path query. A JMESPath is // safe for concurrent use by multiple goroutines. type JMESPath struct { ast ASTNode intr *treeInterpreter } // Compile parses a JMESPath expression and returns, if successful, a JMESPath // object that can be used to match against data. func Compile(expression string) (*JMESPath, error) { parser := NewParser() ast, err := parser.Parse(expression) if err != nil { return nil, err } jmespath := &JMESPath{ast: ast, intr: newInterpreter()} return jmespath, nil } // MustCompile is like Compile but panics if the expression cannot be parsed. // It simplifies safe initialization of global variables holding compiled // JMESPaths. func MustCompile(expression string) *JMESPath { jmespath, err := Compile(expression) if err != nil { panic(`jmespath: Compile(` + strconv.Quote(expression) + `): ` + err.Error()) } return jmespath } // Search evaluates a JMESPath expression against input data and returns the result. func (jp *JMESPath) Search(data interface{}) (interface{}, error) { return jp.intr.Execute(jp.ast, data) } // Search evaluates a JMESPath expression against input data and returns the result. func Search(expression string, data interface{}) (interface{}, error) { intr := newInterpreter() parser := NewParser() ast, err := parser.Parse(expression) if err != nil { return nil, err } return intr.Execute(ast, data) } go-jmespath-0.4.0/api_test.go000066400000000000000000000017511373124421700161000ustar00rootroot00000000000000package jmespath import ( "encoding/json" "testing" "github.com/jmespath/go-jmespath/internal/testify/assert" ) func TestValidUncompiledExpressionSearches(t *testing.T) { assert := assert.New(t) var j = []byte(`{"foo": {"bar": {"baz": [0, 1, 2, 3, 4]}}}`) var d interface{} err := json.Unmarshal(j, &d) assert.Nil(err) result, err := Search("foo.bar.baz[2]", d) assert.Nil(err) assert.Equal(2.0, result) } func TestValidPrecompiledExpressionSearches(t *testing.T) { assert := assert.New(t) data := make(map[string]interface{}) data["foo"] = "bar" precompiled, err := Compile("foo") assert.Nil(err) result, err := precompiled.Search(data) assert.Nil(err) assert.Equal("bar", result) } func TestInvalidPrecompileErrors(t *testing.T) { assert := assert.New(t) _, err := Compile("not a valid expression") assert.NotNil(err) } func TestInvalidMustCompilePanics(t *testing.T) { defer func() { r := recover() assert.NotNil(t, r) }() MustCompile("not a valid expression") } go-jmespath-0.4.0/astnodetype_string.go000066400000000000000000000014311373124421700202100ustar00rootroot00000000000000// generated by stringer -type astNodeType; DO NOT EDIT package jmespath import "fmt" const _astNodeType_name = "ASTEmptyASTComparatorASTCurrentNodeASTExpRefASTFunctionExpressionASTFieldASTFilterProjectionASTFlattenASTIdentityASTIndexASTIndexExpressionASTKeyValPairASTLiteralASTMultiSelectHashASTMultiSelectListASTOrExpressionASTAndExpressionASTNotExpressionASTPipeASTProjectionASTSubexpressionASTSliceASTValueProjection" var _astNodeType_index = [...]uint16{0, 8, 21, 35, 44, 65, 73, 92, 102, 113, 121, 139, 152, 162, 180, 198, 213, 229, 245, 252, 265, 281, 289, 307} func (i astNodeType) String() string { if i < 0 || i >= astNodeType(len(_astNodeType_index)-1) { return fmt.Sprintf("astNodeType(%d)", i) } return _astNodeType_name[_astNodeType_index[i]:_astNodeType_index[i+1]] } go-jmespath-0.4.0/cmd/000077500000000000000000000000001373124421700145005ustar00rootroot00000000000000go-jmespath-0.4.0/cmd/jpgo/000077500000000000000000000000001373124421700154375ustar00rootroot00000000000000go-jmespath-0.4.0/cmd/jpgo/main.go000066400000000000000000000042201373124421700167100ustar00rootroot00000000000000/*Basic command line interface for debug and testing purposes. Examples: Only print the AST for the expression: jp.go -ast "foo.bar.baz" Evaluate the JMESPath expression against JSON data from a file: jp.go -input /tmp/data.json "foo.bar.baz" This program can also be used as an executable to the jp-compliance runner (github.com/jmespath/jmespath.test). */ package main import ( "flag" "fmt" "io/ioutil" "os" ) import ( "encoding/json" "github.com/jmespath/go-jmespath" ) func errMsg(msg string, a ...interface{}) int { fmt.Fprintf(os.Stderr, msg, a...) fmt.Fprintln(os.Stderr) return 1 } func run() int { astOnly := flag.Bool("ast", false, "Print the AST for the input expression and exit.") inputFile := flag.String("input", "", "Filename containing JSON data to search. If not provided, data is read from stdin.") flag.Parse() args := flag.Args() if len(args) != 1 { fmt.Fprintf(os.Stderr, "Usage:\n\n") flag.PrintDefaults() return errMsg("\nError: expected a single argument (the JMESPath expression).") } expression := args[0] parser := jmespath.NewParser() parsed, err := parser.Parse(expression) if err != nil { if syntaxError, ok := err.(jmespath.SyntaxError); ok { return errMsg("%s\n%s\n", syntaxError, syntaxError.HighlightLocation()) } return errMsg("%s", err) } if *astOnly { fmt.Println("") fmt.Printf("%s\n", parsed) return 0 } var inputData []byte if *inputFile != "" { inputData, err = ioutil.ReadFile(*inputFile) if err != nil { return errMsg("Error loading file %s: %s", *inputFile, err) } } else { // If an input data file is not provided then we read the // data from stdin. inputData, err = ioutil.ReadAll(os.Stdin) if err != nil { return errMsg("Error reading from stdin: %s", err) } } var data interface{} json.Unmarshal(inputData, &data) result, err := jmespath.Search(expression, data) if err != nil { return errMsg("Error executing expression: %s", err) } toJSON, err := json.MarshalIndent(result, "", " ") if err != nil { return errMsg("Error serializing result to JSON: %s", err) } fmt.Println(string(toJSON)) return 0 } func main() { os.Exit(run()) } go-jmespath-0.4.0/compliance/000077500000000000000000000000001373124421700160475ustar00rootroot00000000000000go-jmespath-0.4.0/compliance/basic.json000066400000000000000000000037671373124421700200400ustar00rootroot00000000000000[{ "given": {"foo": {"bar": {"baz": "correct"}}}, "cases": [ { "expression": "foo", "result": {"bar": {"baz": "correct"}} }, { "expression": "foo.bar", "result": {"baz": "correct"} }, { "expression": "foo.bar.baz", "result": "correct" }, { "expression": "foo\n.\nbar\n.baz", "result": "correct" }, { "expression": "foo.bar.baz.bad", "result": null }, { "expression": "foo.bar.bad", "result": null }, { "expression": "foo.bad", "result": null }, { "expression": "bad", "result": null }, { "expression": "bad.morebad.morebad", "result": null } ] }, { "given": {"foo": {"bar": ["one", "two", "three"]}}, "cases": [ { "expression": "foo", "result": {"bar": ["one", "two", "three"]} }, { "expression": "foo.bar", "result": ["one", "two", "three"] } ] }, { "given": ["one", "two", "three"], "cases": [ { "expression": "one", "result": null }, { "expression": "two", "result": null }, { "expression": "three", "result": null }, { "expression": "one.two", "result": null } ] }, { "given": {"foo": {"1": ["one", "two", "three"], "-1": "bar"}}, "cases": [ { "expression": "foo.\"1\"", "result": ["one", "two", "three"] }, { "expression": "foo.\"1\"[0]", "result": "one" }, { "expression": "foo.\"-1\"", "result": "bar" } ] } ] go-jmespath-0.4.0/compliance/boolean.json000066400000000000000000000115761373124421700203730ustar00rootroot00000000000000[ { "given": { "outer": { "foo": "foo", "bar": "bar", "baz": "baz" } }, "cases": [ { "expression": "outer.foo || outer.bar", "result": "foo" }, { "expression": "outer.foo||outer.bar", "result": "foo" }, { "expression": "outer.bar || outer.baz", "result": "bar" }, { "expression": "outer.bar||outer.baz", "result": "bar" }, { "expression": "outer.bad || outer.foo", "result": "foo" }, { "expression": "outer.bad||outer.foo", "result": "foo" }, { "expression": "outer.foo || outer.bad", "result": "foo" }, { "expression": "outer.foo||outer.bad", "result": "foo" }, { "expression": "outer.bad || outer.alsobad", "result": null }, { "expression": "outer.bad||outer.alsobad", "result": null } ] }, { "given": { "outer": { "foo": "foo", "bool": false, "empty_list": [], "empty_string": "" } }, "cases": [ { "expression": "outer.empty_string || outer.foo", "result": "foo" }, { "expression": "outer.nokey || outer.bool || outer.empty_list || outer.empty_string || outer.foo", "result": "foo" } ] }, { "given": { "True": true, "False": false, "Number": 5, "EmptyList": [], "Zero": 0 }, "cases": [ { "expression": "True && False", "result": false }, { "expression": "False && True", "result": false }, { "expression": "True && True", "result": true }, { "expression": "False && False", "result": false }, { "expression": "True && Number", "result": 5 }, { "expression": "Number && True", "result": true }, { "expression": "Number && False", "result": false }, { "expression": "Number && EmptyList", "result": [] }, { "expression": "Number && True", "result": true }, { "expression": "EmptyList && True", "result": [] }, { "expression": "EmptyList && False", "result": [] }, { "expression": "True || False", "result": true }, { "expression": "True || True", "result": true }, { "expression": "False || True", "result": true }, { "expression": "False || False", "result": false }, { "expression": "Number || EmptyList", "result": 5 }, { "expression": "Number || True", "result": 5 }, { "expression": "Number || True && False", "result": 5 }, { "expression": "(Number || True) && False", "result": false }, { "expression": "Number || (True && False)", "result": 5 }, { "expression": "!True", "result": false }, { "expression": "!False", "result": true }, { "expression": "!Number", "result": false }, { "expression": "!EmptyList", "result": true }, { "expression": "True && !False", "result": true }, { "expression": "True && !EmptyList", "result": true }, { "expression": "!False && !EmptyList", "result": true }, { "expression": "!(True && False)", "result": true }, { "expression": "!Zero", "result": false }, { "expression": "!!Zero", "result": true } ] }, { "given": { "one": 1, "two": 2, "three": 3 }, "cases": [ { "expression": "one < two", "result": true }, { "expression": "one <= two", "result": true }, { "expression": "one == one", "result": true }, { "expression": "one == two", "result": false }, { "expression": "one > two", "result": false }, { "expression": "one >= two", "result": false }, { "expression": "one != two", "result": true }, { "expression": "one < two && three > one", "result": true }, { "expression": "one < two || three > one", "result": true }, { "expression": "one < two || three < one", "result": true }, { "expression": "two < one || three < one", "result": false } ] } ] go-jmespath-0.4.0/compliance/current.json000066400000000000000000000011161373124421700204230ustar00rootroot00000000000000[ { "given": { "foo": [{"name": "a"}, {"name": "b"}], "bar": {"baz": "qux"} }, "cases": [ { "expression": "@", "result": { "foo": [{"name": "a"}, {"name": "b"}], "bar": {"baz": "qux"} } }, { "expression": "@.bar", "result": {"baz": "qux"} }, { "expression": "@.foo[0]", "result": {"name": "a"} } ] } ] go-jmespath-0.4.0/compliance/escape.json000066400000000000000000000021201373124421700201750ustar00rootroot00000000000000[{ "given": { "foo.bar": "dot", "foo bar": "space", "foo\nbar": "newline", "foo\"bar": "doublequote", "c:\\\\windows\\path": "windows", "/unix/path": "unix", "\"\"\"": "threequotes", "bar": {"baz": "qux"} }, "cases": [ { "expression": "\"foo.bar\"", "result": "dot" }, { "expression": "\"foo bar\"", "result": "space" }, { "expression": "\"foo\\nbar\"", "result": "newline" }, { "expression": "\"foo\\\"bar\"", "result": "doublequote" }, { "expression": "\"c:\\\\\\\\windows\\\\path\"", "result": "windows" }, { "expression": "\"/unix/path\"", "result": "unix" }, { "expression": "\"\\\"\\\"\\\"\"", "result": "threequotes" }, { "expression": "\"bar\".\"baz\"", "result": "qux" } ] }] go-jmespath-0.4.0/compliance/filters.json000066400000000000000000000313221373124421700204130ustar00rootroot00000000000000[ { "given": {"foo": [{"name": "a"}, {"name": "b"}]}, "cases": [ { "comment": "Matching a literal", "expression": "foo[?name == 'a']", "result": [{"name": "a"}] } ] }, { "given": {"foo": [0, 1], "bar": [2, 3]}, "cases": [ { "comment": "Matching a literal", "expression": "*[?[0] == `0`]", "result": [[], []] } ] }, { "given": {"foo": [{"first": "foo", "last": "bar"}, {"first": "foo", "last": "foo"}, {"first": "foo", "last": "baz"}]}, "cases": [ { "comment": "Matching an expression", "expression": "foo[?first == last]", "result": [{"first": "foo", "last": "foo"}] }, { "comment": "Verify projection created from filter", "expression": "foo[?first == last].first", "result": ["foo"] } ] }, { "given": {"foo": [{"age": 20}, {"age": 25}, {"age": 30}]}, "cases": [ { "comment": "Greater than with a number", "expression": "foo[?age > `25`]", "result": [{"age": 30}] }, { "expression": "foo[?age >= `25`]", "result": [{"age": 25}, {"age": 30}] }, { "comment": "Greater than with a number", "expression": "foo[?age > `30`]", "result": [] }, { "comment": "Greater than with a number", "expression": "foo[?age < `25`]", "result": [{"age": 20}] }, { "comment": "Greater than with a number", "expression": "foo[?age <= `25`]", "result": [{"age": 20}, {"age": 25}] }, { "comment": "Greater than with a number", "expression": "foo[?age < `20`]", "result": [] }, { "expression": "foo[?age == `20`]", "result": [{"age": 20}] }, { "expression": "foo[?age != `20`]", "result": [{"age": 25}, {"age": 30}] } ] }, { "given": {"foo": [{"top": {"name": "a"}}, {"top": {"name": "b"}}]}, "cases": [ { "comment": "Filter with subexpression", "expression": "foo[?top.name == 'a']", "result": [{"top": {"name": "a"}}] } ] }, { "given": {"foo": [{"top": {"first": "foo", "last": "bar"}}, {"top": {"first": "foo", "last": "foo"}}, {"top": {"first": "foo", "last": "baz"}}]}, "cases": [ { "comment": "Matching an expression", "expression": "foo[?top.first == top.last]", "result": [{"top": {"first": "foo", "last": "foo"}}] }, { "comment": "Matching a JSON array", "expression": "foo[?top == `{\"first\": \"foo\", \"last\": \"bar\"}`]", "result": [{"top": {"first": "foo", "last": "bar"}}] } ] }, { "given": {"foo": [ {"key": true}, {"key": false}, {"key": 0}, {"key": 1}, {"key": [0]}, {"key": {"bar": [0]}}, {"key": null}, {"key": [1]}, {"key": {"a":2}} ]}, "cases": [ { "expression": "foo[?key == `true`]", "result": [{"key": true}] }, { "expression": "foo[?key == `false`]", "result": [{"key": false}] }, { "expression": "foo[?key == `0`]", "result": [{"key": 0}] }, { "expression": "foo[?key == `1`]", "result": [{"key": 1}] }, { "expression": "foo[?key == `[0]`]", "result": [{"key": [0]}] }, { "expression": "foo[?key == `{\"bar\": [0]}`]", "result": [{"key": {"bar": [0]}}] }, { "expression": "foo[?key == `null`]", "result": [{"key": null}] }, { "expression": "foo[?key == `[1]`]", "result": [{"key": [1]}] }, { "expression": "foo[?key == `{\"a\":2}`]", "result": [{"key": {"a":2}}] }, { "expression": "foo[?`true` == key]", "result": [{"key": true}] }, { "expression": "foo[?`false` == key]", "result": [{"key": false}] }, { "expression": "foo[?`0` == key]", "result": [{"key": 0}] }, { "expression": "foo[?`1` == key]", "result": [{"key": 1}] }, { "expression": "foo[?`[0]` == key]", "result": [{"key": [0]}] }, { "expression": "foo[?`{\"bar\": [0]}` == key]", "result": [{"key": {"bar": [0]}}] }, { "expression": "foo[?`null` == key]", "result": [{"key": null}] }, { "expression": "foo[?`[1]` == key]", "result": [{"key": [1]}] }, { "expression": "foo[?`{\"a\":2}` == key]", "result": [{"key": {"a":2}}] }, { "expression": "foo[?key != `true`]", "result": [{"key": false}, {"key": 0}, {"key": 1}, {"key": [0]}, {"key": {"bar": [0]}}, {"key": null}, {"key": [1]}, {"key": {"a":2}}] }, { "expression": "foo[?key != `false`]", "result": [{"key": true}, {"key": 0}, {"key": 1}, {"key": [0]}, {"key": {"bar": [0]}}, {"key": null}, {"key": [1]}, {"key": {"a":2}}] }, { "expression": "foo[?key != `0`]", "result": [{"key": true}, {"key": false}, {"key": 1}, {"key": [0]}, {"key": {"bar": [0]}}, {"key": null}, {"key": [1]}, {"key": {"a":2}}] }, { "expression": "foo[?key != `1`]", "result": [{"key": true}, {"key": false}, {"key": 0}, {"key": [0]}, {"key": {"bar": [0]}}, {"key": null}, {"key": [1]}, {"key": {"a":2}}] }, { "expression": "foo[?key != `null`]", "result": [{"key": true}, {"key": false}, {"key": 0}, {"key": 1}, {"key": [0]}, {"key": {"bar": [0]}}, {"key": [1]}, {"key": {"a":2}}] }, { "expression": "foo[?key != `[1]`]", "result": [{"key": true}, {"key": false}, {"key": 0}, {"key": 1}, {"key": [0]}, {"key": {"bar": [0]}}, {"key": null}, {"key": {"a":2}}] }, { "expression": "foo[?key != `{\"a\":2}`]", "result": [{"key": true}, {"key": false}, {"key": 0}, {"key": 1}, {"key": [0]}, {"key": {"bar": [0]}}, {"key": null}, {"key": [1]}] }, { "expression": "foo[?`true` != key]", "result": [{"key": false}, {"key": 0}, {"key": 1}, {"key": [0]}, {"key": {"bar": [0]}}, {"key": null}, {"key": [1]}, {"key": {"a":2}}] }, { "expression": "foo[?`false` != key]", "result": [{"key": true}, {"key": 0}, {"key": 1}, {"key": [0]}, {"key": {"bar": [0]}}, {"key": null}, {"key": [1]}, {"key": {"a":2}}] }, { "expression": "foo[?`0` != key]", "result": [{"key": true}, {"key": false}, {"key": 1}, {"key": [0]}, {"key": {"bar": [0]}}, {"key": null}, {"key": [1]}, {"key": {"a":2}}] }, { "expression": "foo[?`1` != key]", "result": [{"key": true}, {"key": false}, {"key": 0}, {"key": [0]}, {"key": {"bar": [0]}}, {"key": null}, {"key": [1]}, {"key": {"a":2}}] }, { "expression": "foo[?`null` != key]", "result": [{"key": true}, {"key": false}, {"key": 0}, {"key": 1}, {"key": [0]}, {"key": {"bar": [0]}}, {"key": [1]}, {"key": {"a":2}}] }, { "expression": "foo[?`[1]` != key]", "result": [{"key": true}, {"key": false}, {"key": 0}, {"key": 1}, {"key": [0]}, {"key": {"bar": [0]}}, {"key": null}, {"key": {"a":2}}] }, { "expression": "foo[?`{\"a\":2}` != key]", "result": [{"key": true}, {"key": false}, {"key": 0}, {"key": 1}, {"key": [0]}, {"key": {"bar": [0]}}, {"key": null}, {"key": [1]}] } ] }, { "given": {"reservations": [ {"instances": [ {"foo": 1, "bar": 2}, {"foo": 1, "bar": 3}, {"foo": 1, "bar": 2}, {"foo": 2, "bar": 1}]}]}, "cases": [ { "expression": "reservations[].instances[?bar==`1`]", "result": [[{"foo": 2, "bar": 1}]] }, { "expression": "reservations[*].instances[?bar==`1`]", "result": [[{"foo": 2, "bar": 1}]] }, { "expression": "reservations[].instances[?bar==`1`][]", "result": [{"foo": 2, "bar": 1}] } ] }, { "given": { "baz": "other", "foo": [ {"bar": 1}, {"bar": 2}, {"bar": 3}, {"bar": 4}, {"bar": 1, "baz": 2} ] }, "cases": [ { "expression": "foo[?bar==`1`].bar[0]", "result": [] } ] }, { "given": { "foo": [ {"a": 1, "b": {"c": "x"}}, {"a": 1, "b": {"c": "y"}}, {"a": 1, "b": {"c": "z"}}, {"a": 2, "b": {"c": "z"}}, {"a": 1, "baz": 2} ] }, "cases": [ { "expression": "foo[?a==`1`].b.c", "result": ["x", "y", "z"] } ] }, { "given": {"foo": [{"name": "a"}, {"name": "b"}, {"name": "c"}]}, "cases": [ { "comment": "Filter with or expression", "expression": "foo[?name == 'a' || name == 'b']", "result": [{"name": "a"}, {"name": "b"}] }, { "expression": "foo[?name == 'a' || name == 'e']", "result": [{"name": "a"}] }, { "expression": "foo[?name == 'a' || name == 'b' || name == 'c']", "result": [{"name": "a"}, {"name": "b"}, {"name": "c"}] } ] }, { "given": {"foo": [{"a": 1, "b": 2}, {"a": 1, "b": 3}]}, "cases": [ { "comment": "Filter with and expression", "expression": "foo[?a == `1` && b == `2`]", "result": [{"a": 1, "b": 2}] }, { "expression": "foo[?a == `1` && b == `4`]", "result": [] } ] }, { "given": {"foo": [{"a": 1, "b": 2, "c": 3}, {"a": 3, "b": 4}]}, "cases": [ { "comment": "Filter with Or and And expressions", "expression": "foo[?c == `3` || a == `1` && b == `4`]", "result": [{"a": 1, "b": 2, "c": 3}] }, { "expression": "foo[?b == `2` || a == `3` && b == `4`]", "result": [{"a": 1, "b": 2, "c": 3}, {"a": 3, "b": 4}] }, { "expression": "foo[?a == `3` && b == `4` || b == `2`]", "result": [{"a": 1, "b": 2, "c": 3}, {"a": 3, "b": 4}] }, { "expression": "foo[?(a == `3` && b == `4`) || b == `2`]", "result": [{"a": 1, "b": 2, "c": 3}, {"a": 3, "b": 4}] }, { "expression": "foo[?((a == `3` && b == `4`)) || b == `2`]", "result": [{"a": 1, "b": 2, "c": 3}, {"a": 3, "b": 4}] }, { "expression": "foo[?a == `3` && (b == `4` || b == `2`)]", "result": [{"a": 3, "b": 4}] }, { "expression": "foo[?a == `3` && ((b == `4` || b == `2`))]", "result": [{"a": 3, "b": 4}] } ] }, { "given": {"foo": [{"a": 1, "b": 2, "c": 3}, {"a": 3, "b": 4}]}, "cases": [ { "comment": "Verify precedence of or/and expressions", "expression": "foo[?a == `1` || b ==`2` && c == `5`]", "result": [{"a": 1, "b": 2, "c": 3}] }, { "comment": "Parentheses can alter precedence", "expression": "foo[?(a == `1` || b ==`2`) && c == `5`]", "result": [] }, { "comment": "Not expressions combined with and/or", "expression": "foo[?!(a == `1` || b ==`2`)]", "result": [{"a": 3, "b": 4}] } ] }, { "given": { "foo": [ {"key": true}, {"key": false}, {"key": []}, {"key": {}}, {"key": [0]}, {"key": {"a": "b"}}, {"key": 0}, {"key": 1}, {"key": null}, {"notkey": true} ] }, "cases": [ { "comment": "Unary filter expression", "expression": "foo[?key]", "result": [ {"key": true}, {"key": [0]}, {"key": {"a": "b"}}, {"key": 0}, {"key": 1} ] }, { "comment": "Unary not filter expression", "expression": "foo[?!key]", "result": [ {"key": false}, {"key": []}, {"key": {}}, {"key": null}, {"notkey": true} ] }, { "comment": "Equality with null RHS", "expression": "foo[?key == `null`]", "result": [ {"key": null}, {"notkey": true} ] } ] }, { "given": { "foo": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] }, "cases": [ { "comment": "Using @ in a filter expression", "expression": "foo[?@ < `5`]", "result": [0, 1, 2, 3, 4] }, { "comment": "Using @ in a filter expression", "expression": "foo[?`5` > @]", "result": [0, 1, 2, 3, 4] }, { "comment": "Using @ in a filter expression", "expression": "foo[?@ == @]", "result": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] } ] } ] go-jmespath-0.4.0/compliance/functions.json000066400000000000000000000432141373124421700207560ustar00rootroot00000000000000[{ "given": { "foo": -1, "zero": 0, "numbers": [-1, 3, 4, 5], "array": [-1, 3, 4, 5, "a", "100"], "strings": ["a", "b", "c"], "decimals": [1.01, 1.2, -1.5], "str": "Str", "false": false, "empty_list": [], "empty_hash": {}, "objects": {"foo": "bar", "bar": "baz"}, "null_key": null }, "cases": [ { "expression": "abs(foo)", "result": 1 }, { "expression": "abs(foo)", "result": 1 }, { "expression": "abs(str)", "error": "invalid-type" }, { "expression": "abs(array[1])", "result": 3 }, { "expression": "abs(array[1])", "result": 3 }, { "expression": "abs(`false`)", "error": "invalid-type" }, { "expression": "abs(`-24`)", "result": 24 }, { "expression": "abs(`-24`)", "result": 24 }, { "expression": "abs(`1`, `2`)", "error": "invalid-arity" }, { "expression": "abs()", "error": "invalid-arity" }, { "expression": "unknown_function(`1`, `2`)", "error": "unknown-function" }, { "expression": "avg(numbers)", "result": 2.75 }, { "expression": "avg(array)", "error": "invalid-type" }, { "expression": "avg('abc')", "error": "invalid-type" }, { "expression": "avg(foo)", "error": "invalid-type" }, { "expression": "avg(@)", "error": "invalid-type" }, { "expression": "avg(strings)", "error": "invalid-type" }, { "expression": "ceil(`1.2`)", "result": 2 }, { "expression": "ceil(decimals[0])", "result": 2 }, { "expression": "ceil(decimals[1])", "result": 2 }, { "expression": "ceil(decimals[2])", "result": -1 }, { "expression": "ceil('string')", "error": "invalid-type" }, { "expression": "contains('abc', 'a')", "result": true }, { "expression": "contains('abc', 'd')", "result": false }, { "expression": "contains(`false`, 'd')", "error": "invalid-type" }, { "expression": "contains(strings, 'a')", "result": true }, { "expression": "contains(decimals, `1.2`)", "result": true }, { "expression": "contains(decimals, `false`)", "result": false }, { "expression": "ends_with(str, 'r')", "result": true }, { "expression": "ends_with(str, 'tr')", "result": true }, { "expression": "ends_with(str, 'Str')", "result": true }, { "expression": "ends_with(str, 'SStr')", "result": false }, { "expression": "ends_with(str, 'foo')", "result": false }, { "expression": "ends_with(str, `0`)", "error": "invalid-type" }, { "expression": "floor(`1.2`)", "result": 1 }, { "expression": "floor('string')", "error": "invalid-type" }, { "expression": "floor(decimals[0])", "result": 1 }, { "expression": "floor(foo)", "result": -1 }, { "expression": "floor(str)", "error": "invalid-type" }, { "expression": "length('abc')", "result": 3 }, { "expression": "length('✓foo')", "result": 4 }, { "expression": "length('')", "result": 0 }, { "expression": "length(@)", "result": 12 }, { "expression": "length(strings[0])", "result": 1 }, { "expression": "length(str)", "result": 3 }, { "expression": "length(array)", "result": 6 }, { "expression": "length(objects)", "result": 2 }, { "expression": "length(`false`)", "error": "invalid-type" }, { "expression": "length(foo)", "error": "invalid-type" }, { "expression": "length(strings[0])", "result": 1 }, { "expression": "max(numbers)", "result": 5 }, { "expression": "max(decimals)", "result": 1.2 }, { "expression": "max(strings)", "result": "c" }, { "expression": "max(abc)", "error": "invalid-type" }, { "expression": "max(array)", "error": "invalid-type" }, { "expression": "max(decimals)", "result": 1.2 }, { "expression": "max(empty_list)", "result": null }, { "expression": "merge(`{}`)", "result": {} }, { "expression": "merge(`{}`, `{}`)", "result": {} }, { "expression": "merge(`{\"a\": 1}`, `{\"b\": 2}`)", "result": {"a": 1, "b": 2} }, { "expression": "merge(`{\"a\": 1}`, `{\"a\": 2}`)", "result": {"a": 2} }, { "expression": "merge(`{\"a\": 1, \"b\": 2}`, `{\"a\": 2, \"c\": 3}`, `{\"d\": 4}`)", "result": {"a": 2, "b": 2, "c": 3, "d": 4} }, { "expression": "min(numbers)", "result": -1 }, { "expression": "min(decimals)", "result": -1.5 }, { "expression": "min(abc)", "error": "invalid-type" }, { "expression": "min(array)", "error": "invalid-type" }, { "expression": "min(empty_list)", "result": null }, { "expression": "min(decimals)", "result": -1.5 }, { "expression": "min(strings)", "result": "a" }, { "expression": "type('abc')", "result": "string" }, { "expression": "type(`1.0`)", "result": "number" }, { "expression": "type(`2`)", "result": "number" }, { "expression": "type(`true`)", "result": "boolean" }, { "expression": "type(`false`)", "result": "boolean" }, { "expression": "type(`null`)", "result": "null" }, { "expression": "type(`[0]`)", "result": "array" }, { "expression": "type(`{\"a\": \"b\"}`)", "result": "object" }, { "expression": "type(@)", "result": "object" }, { "expression": "sort(keys(objects))", "result": ["bar", "foo"] }, { "expression": "keys(foo)", "error": "invalid-type" }, { "expression": "keys(strings)", "error": "invalid-type" }, { "expression": "keys(`false`)", "error": "invalid-type" }, { "expression": "sort(values(objects))", "result": ["bar", "baz"] }, { "expression": "keys(empty_hash)", "result": [] }, { "expression": "values(foo)", "error": "invalid-type" }, { "expression": "join(', ', strings)", "result": "a, b, c" }, { "expression": "join(', ', strings)", "result": "a, b, c" }, { "expression": "join(',', `[\"a\", \"b\"]`)", "result": "a,b" }, { "expression": "join(',', `[\"a\", 0]`)", "error": "invalid-type" }, { "expression": "join(', ', str)", "error": "invalid-type" }, { "expression": "join('|', strings)", "result": "a|b|c" }, { "expression": "join(`2`, strings)", "error": "invalid-type" }, { "expression": "join('|', decimals)", "error": "invalid-type" }, { "expression": "join('|', decimals[].to_string(@))", "result": "1.01|1.2|-1.5" }, { "expression": "join('|', empty_list)", "result": "" }, { "expression": "reverse(numbers)", "result": [5, 4, 3, -1] }, { "expression": "reverse(array)", "result": ["100", "a", 5, 4, 3, -1] }, { "expression": "reverse(`[]`)", "result": [] }, { "expression": "reverse('')", "result": "" }, { "expression": "reverse('hello world')", "result": "dlrow olleh" }, { "expression": "starts_with(str, 'S')", "result": true }, { "expression": "starts_with(str, 'St')", "result": true }, { "expression": "starts_with(str, 'Str')", "result": true }, { "expression": "starts_with(str, 'String')", "result": false }, { "expression": "starts_with(str, `0`)", "error": "invalid-type" }, { "expression": "sum(numbers)", "result": 11 }, { "expression": "sum(decimals)", "result": 0.71 }, { "expression": "sum(array)", "error": "invalid-type" }, { "expression": "sum(array[].to_number(@))", "result": 111 }, { "expression": "sum(`[]`)", "result": 0 }, { "expression": "to_array('foo')", "result": ["foo"] }, { "expression": "to_array(`0`)", "result": [0] }, { "expression": "to_array(objects)", "result": [{"foo": "bar", "bar": "baz"}] }, { "expression": "to_array(`[1, 2, 3]`)", "result": [1, 2, 3] }, { "expression": "to_array(false)", "result": [false] }, { "expression": "to_string('foo')", "result": "foo" }, { "expression": "to_string(`1.2`)", "result": "1.2" }, { "expression": "to_string(`[0, 1]`)", "result": "[0,1]" }, { "expression": "to_number('1.0')", "result": 1.0 }, { "expression": "to_number('1.1')", "result": 1.1 }, { "expression": "to_number('4')", "result": 4 }, { "expression": "to_number('notanumber')", "result": null }, { "expression": "to_number(`false`)", "result": null }, { "expression": "to_number(`null`)", "result": null }, { "expression": "to_number(`[0]`)", "result": null }, { "expression": "to_number(`{\"foo\": 0}`)", "result": null }, { "expression": "\"to_string\"(`1.0`)", "error": "syntax" }, { "expression": "sort(numbers)", "result": [-1, 3, 4, 5] }, { "expression": "sort(strings)", "result": ["a", "b", "c"] }, { "expression": "sort(decimals)", "result": [-1.5, 1.01, 1.2] }, { "expression": "sort(array)", "error": "invalid-type" }, { "expression": "sort(abc)", "error": "invalid-type" }, { "expression": "sort(empty_list)", "result": [] }, { "expression": "sort(@)", "error": "invalid-type" }, { "expression": "not_null(unknown_key, str)", "result": "Str" }, { "expression": "not_null(unknown_key, foo.bar, empty_list, str)", "result": [] }, { "expression": "not_null(unknown_key, null_key, empty_list, str)", "result": [] }, { "expression": "not_null(all, expressions, are_null)", "result": null }, { "expression": "not_null()", "error": "invalid-arity" }, { "description": "function projection on single arg function", "expression": "numbers[].to_string(@)", "result": ["-1", "3", "4", "5"] }, { "description": "function projection on single arg function", "expression": "array[].to_number(@)", "result": [-1, 3, 4, 5, 100] } ] }, { "given": { "foo": [ {"b": "b", "a": "a"}, {"c": "c", "b": "b"}, {"d": "d", "c": "c"}, {"e": "e", "d": "d"}, {"f": "f", "e": "e"} ] }, "cases": [ { "description": "function projection on variadic function", "expression": "foo[].not_null(f, e, d, c, b, a)", "result": ["b", "c", "d", "e", "f"] } ] }, { "given": { "people": [ {"age": 20, "age_str": "20", "bool": true, "name": "a", "extra": "foo"}, {"age": 40, "age_str": "40", "bool": false, "name": "b", "extra": "bar"}, {"age": 30, "age_str": "30", "bool": true, "name": "c"}, {"age": 50, "age_str": "50", "bool": false, "name": "d"}, {"age": 10, "age_str": "10", "bool": true, "name": 3} ] }, "cases": [ { "description": "sort by field expression", "expression": "sort_by(people, &age)", "result": [ {"age": 10, "age_str": "10", "bool": true, "name": 3}, {"age": 20, "age_str": "20", "bool": true, "name": "a", "extra": "foo"}, {"age": 30, "age_str": "30", "bool": true, "name": "c"}, {"age": 40, "age_str": "40", "bool": false, "name": "b", "extra": "bar"}, {"age": 50, "age_str": "50", "bool": false, "name": "d"} ] }, { "expression": "sort_by(people, &age_str)", "result": [ {"age": 10, "age_str": "10", "bool": true, "name": 3}, {"age": 20, "age_str": "20", "bool": true, "name": "a", "extra": "foo"}, {"age": 30, "age_str": "30", "bool": true, "name": "c"}, {"age": 40, "age_str": "40", "bool": false, "name": "b", "extra": "bar"}, {"age": 50, "age_str": "50", "bool": false, "name": "d"} ] }, { "description": "sort by function expression", "expression": "sort_by(people, &to_number(age_str))", "result": [ {"age": 10, "age_str": "10", "bool": true, "name": 3}, {"age": 20, "age_str": "20", "bool": true, "name": "a", "extra": "foo"}, {"age": 30, "age_str": "30", "bool": true, "name": "c"}, {"age": 40, "age_str": "40", "bool": false, "name": "b", "extra": "bar"}, {"age": 50, "age_str": "50", "bool": false, "name": "d"} ] }, { "description": "function projection on sort_by function", "expression": "sort_by(people, &age)[].name", "result": [3, "a", "c", "b", "d"] }, { "expression": "sort_by(people, &extra)", "error": "invalid-type" }, { "expression": "sort_by(people, &bool)", "error": "invalid-type" }, { "expression": "sort_by(people, &name)", "error": "invalid-type" }, { "expression": "sort_by(people, name)", "error": "invalid-type" }, { "expression": "sort_by(people, &age)[].extra", "result": ["foo", "bar"] }, { "expression": "sort_by(`[]`, &age)", "result": [] }, { "expression": "max_by(people, &age)", "result": {"age": 50, "age_str": "50", "bool": false, "name": "d"} }, { "expression": "max_by(people, &age_str)", "result": {"age": 50, "age_str": "50", "bool": false, "name": "d"} }, { "expression": "max_by(people, &bool)", "error": "invalid-type" }, { "expression": "max_by(people, &extra)", "error": "invalid-type" }, { "expression": "max_by(people, &to_number(age_str))", "result": {"age": 50, "age_str": "50", "bool": false, "name": "d"} }, { "expression": "min_by(people, &age)", "result": {"age": 10, "age_str": "10", "bool": true, "name": 3} }, { "expression": "min_by(people, &age_str)", "result": {"age": 10, "age_str": "10", "bool": true, "name": 3} }, { "expression": "min_by(people, &bool)", "error": "invalid-type" }, { "expression": "min_by(people, &extra)", "error": "invalid-type" }, { "expression": "min_by(people, &to_number(age_str))", "result": {"age": 10, "age_str": "10", "bool": true, "name": 3} } ] }, { "given": { "people": [ {"age": 10, "order": "1"}, {"age": 10, "order": "2"}, {"age": 10, "order": "3"}, {"age": 10, "order": "4"}, {"age": 10, "order": "5"}, {"age": 10, "order": "6"}, {"age": 10, "order": "7"}, {"age": 10, "order": "8"}, {"age": 10, "order": "9"}, {"age": 10, "order": "10"}, {"age": 10, "order": "11"} ] }, "cases": [ { "description": "stable sort order", "expression": "sort_by(people, &age)", "result": [ {"age": 10, "order": "1"}, {"age": 10, "order": "2"}, {"age": 10, "order": "3"}, {"age": 10, "order": "4"}, {"age": 10, "order": "5"}, {"age": 10, "order": "6"}, {"age": 10, "order": "7"}, {"age": 10, "order": "8"}, {"age": 10, "order": "9"}, {"age": 10, "order": "10"}, {"age": 10, "order": "11"} ] } ] }, { "given": { "people": [ {"a": 10, "b": 1, "c": "z"}, {"a": 10, "b": 2, "c": null}, {"a": 10, "b": 3}, {"a": 10, "b": 4, "c": "z"}, {"a": 10, "b": 5, "c": null}, {"a": 10, "b": 6}, {"a": 10, "b": 7, "c": "z"}, {"a": 10, "b": 8, "c": null}, {"a": 10, "b": 9} ], "empty": [] }, "cases": [ { "expression": "map(&a, people)", "result": [10, 10, 10, 10, 10, 10, 10, 10, 10] }, { "expression": "map(&c, people)", "result": ["z", null, null, "z", null, null, "z", null, null] }, { "expression": "map(&a, badkey)", "error": "invalid-type" }, { "expression": "map(&foo, empty)", "result": [] } ] }, { "given": { "array": [ { "foo": {"bar": "yes1"} }, { "foo": {"bar": "yes2"} }, { "foo1": {"bar": "no"} } ]}, "cases": [ { "expression": "map(&foo.bar, array)", "result": ["yes1", "yes2", null] }, { "expression": "map(&foo1.bar, array)", "result": [null, null, "no"] }, { "expression": "map(&foo.bar.baz, array)", "result": [null, null, null] } ] }, { "given": { "array": [[1, 2, 3, [4]], [5, 6, 7, [8, 9]]] }, "cases": [ { "expression": "map(&[], array)", "result": [[1, 2, 3, 4], [5, 6, 7, 8, 9]] } ] } ] go-jmespath-0.4.0/compliance/identifiers.json000066400000000000000000000602321373124421700212520ustar00rootroot00000000000000[ { "given": { "__L": true }, "cases": [ { "expression": "__L", "result": true } ] }, { "given": { "!\r": true }, "cases": [ { "expression": "\"!\\r\"", "result": true } ] }, { "given": { "Y_1623": true }, "cases": [ { "expression": "Y_1623", "result": true } ] }, { "given": { "x": true }, "cases": [ { "expression": "x", "result": true } ] }, { "given": { "\tF\uCebb": true }, "cases": [ { "expression": "\"\\tF\\uCebb\"", "result": true } ] }, { "given": { " \t": true }, "cases": [ { "expression": "\" \\t\"", "result": true } ] }, { "given": { " ": true }, "cases": [ { "expression": "\" \"", "result": true } ] }, { "given": { "v2": true }, "cases": [ { "expression": "v2", "result": true } ] }, { "given": { "\t": true }, "cases": [ { "expression": "\"\\t\"", "result": true } ] }, { "given": { "_X": true }, "cases": [ { "expression": "_X", "result": true } ] }, { "given": { "\t4\ud9da\udd15": true }, "cases": [ { "expression": "\"\\t4\\ud9da\\udd15\"", "result": true } ] }, { "given": { "v24_W": true }, "cases": [ { "expression": "v24_W", "result": true } ] }, { "given": { "H": true }, "cases": [ { "expression": "\"H\"", "result": true } ] }, { "given": { "\f": true }, "cases": [ { "expression": "\"\\f\"", "result": true } ] }, { "given": { "E4": true }, "cases": [ { "expression": "\"E4\"", "result": true } ] }, { "given": { "!": true }, "cases": [ { "expression": "\"!\"", "result": true } ] }, { "given": { "tM": true }, "cases": [ { "expression": "tM", "result": true } ] }, { "given": { " [": true }, "cases": [ { "expression": "\" [\"", "result": true } ] }, { "given": { "R!": true }, "cases": [ { "expression": "\"R!\"", "result": true } ] }, { "given": { "_6W": true }, "cases": [ { "expression": "_6W", "result": true } ] }, { "given": { "\uaBA1\r": true }, "cases": [ { "expression": "\"\\uaBA1\\r\"", "result": true } ] }, { "given": { "tL7": true }, "cases": [ { "expression": "tL7", "result": true } ] }, { "given": { "<": true }, "cases": [ { "expression": "\">\"", "result": true } ] }, { "given": { "hvu": true }, "cases": [ { "expression": "hvu", "result": true } ] }, { "given": { "; !": true }, "cases": [ { "expression": "\"; !\"", "result": true } ] }, { "given": { "hU": true }, "cases": [ { "expression": "hU", "result": true } ] }, { "given": { "!I\n\/": true }, "cases": [ { "expression": "\"!I\\n\\/\"", "result": true } ] }, { "given": { "\uEEbF": true }, "cases": [ { "expression": "\"\\uEEbF\"", "result": true } ] }, { "given": { "U)\t": true }, "cases": [ { "expression": "\"U)\\t\"", "result": true } ] }, { "given": { "fa0_9": true }, "cases": [ { "expression": "fa0_9", "result": true } ] }, { "given": { "/": true }, "cases": [ { "expression": "\"/\"", "result": true } ] }, { "given": { "Gy": true }, "cases": [ { "expression": "Gy", "result": true } ] }, { "given": { "\b": true }, "cases": [ { "expression": "\"\\b\"", "result": true } ] }, { "given": { "<": true }, "cases": [ { "expression": "\"<\"", "result": true } ] }, { "given": { "\t": true }, "cases": [ { "expression": "\"\\t\"", "result": true } ] }, { "given": { "\t&\\\r": true }, "cases": [ { "expression": "\"\\t&\\\\\\r\"", "result": true } ] }, { "given": { "#": true }, "cases": [ { "expression": "\"#\"", "result": true } ] }, { "given": { "B__": true }, "cases": [ { "expression": "B__", "result": true } ] }, { "given": { "\nS \n": true }, "cases": [ { "expression": "\"\\nS \\n\"", "result": true } ] }, { "given": { "Bp": true }, "cases": [ { "expression": "Bp", "result": true } ] }, { "given": { ",\t;": true }, "cases": [ { "expression": "\",\\t;\"", "result": true } ] }, { "given": { "B_q": true }, "cases": [ { "expression": "B_q", "result": true } ] }, { "given": { "\/+\t\n\b!Z": true }, "cases": [ { "expression": "\"\\/+\\t\\n\\b!Z\"", "result": true } ] }, { "given": { "\udadd\udfc7\\ueFAc": true }, "cases": [ { "expression": "\"\udadd\udfc7\\\\ueFAc\"", "result": true } ] }, { "given": { ":\f": true }, "cases": [ { "expression": "\":\\f\"", "result": true } ] }, { "given": { "\/": true }, "cases": [ { "expression": "\"\\/\"", "result": true } ] }, { "given": { "_BW_6Hg_Gl": true }, "cases": [ { "expression": "_BW_6Hg_Gl", "result": true } ] }, { "given": { "\udbcf\udc02": true }, "cases": [ { "expression": "\"\udbcf\udc02\"", "result": true } ] }, { "given": { "zs1DC": true }, "cases": [ { "expression": "zs1DC", "result": true } ] }, { "given": { "__434": true }, "cases": [ { "expression": "__434", "result": true } ] }, { "given": { "\udb94\udd41": true }, "cases": [ { "expression": "\"\udb94\udd41\"", "result": true } ] }, { "given": { "Z_5": true }, "cases": [ { "expression": "Z_5", "result": true } ] }, { "given": { "z_M_": true }, "cases": [ { "expression": "z_M_", "result": true } ] }, { "given": { "YU_2": true }, "cases": [ { "expression": "YU_2", "result": true } ] }, { "given": { "_0": true }, "cases": [ { "expression": "_0", "result": true } ] }, { "given": { "\b+": true }, "cases": [ { "expression": "\"\\b+\"", "result": true } ] }, { "given": { "\"": true }, "cases": [ { "expression": "\"\\\"\"", "result": true } ] }, { "given": { "D7": true }, "cases": [ { "expression": "D7", "result": true } ] }, { "given": { "_62L": true }, "cases": [ { "expression": "_62L", "result": true } ] }, { "given": { "\tK\t": true }, "cases": [ { "expression": "\"\\tK\\t\"", "result": true } ] }, { "given": { "\n\\\f": true }, "cases": [ { "expression": "\"\\n\\\\\\f\"", "result": true } ] }, { "given": { "I_": true }, "cases": [ { "expression": "I_", "result": true } ] }, { "given": { "W_a0_": true }, "cases": [ { "expression": "W_a0_", "result": true } ] }, { "given": { "BQ": true }, "cases": [ { "expression": "BQ", "result": true } ] }, { "given": { "\tX$\uABBb": true }, "cases": [ { "expression": "\"\\tX$\\uABBb\"", "result": true } ] }, { "given": { "Z9": true }, "cases": [ { "expression": "Z9", "result": true } ] }, { "given": { "\b%\"\uda38\udd0f": true }, "cases": [ { "expression": "\"\\b%\\\"\uda38\udd0f\"", "result": true } ] }, { "given": { "_F": true }, "cases": [ { "expression": "_F", "result": true } ] }, { "given": { "!,": true }, "cases": [ { "expression": "\"!,\"", "result": true } ] }, { "given": { "\"!": true }, "cases": [ { "expression": "\"\\\"!\"", "result": true } ] }, { "given": { "Hh": true }, "cases": [ { "expression": "Hh", "result": true } ] }, { "given": { "&": true }, "cases": [ { "expression": "\"&\"", "result": true } ] }, { "given": { "9\r\\R": true }, "cases": [ { "expression": "\"9\\r\\\\R\"", "result": true } ] }, { "given": { "M_k": true }, "cases": [ { "expression": "M_k", "result": true } ] }, { "given": { "!\b\n\udb06\ude52\"\"": true }, "cases": [ { "expression": "\"!\\b\\n\udb06\ude52\\\"\\\"\"", "result": true } ] }, { "given": { "6": true }, "cases": [ { "expression": "\"6\"", "result": true } ] }, { "given": { "_7": true }, "cases": [ { "expression": "_7", "result": true } ] }, { "given": { "0": true }, "cases": [ { "expression": "\"0\"", "result": true } ] }, { "given": { "\\8\\": true }, "cases": [ { "expression": "\"\\\\8\\\\\"", "result": true } ] }, { "given": { "b7eo": true }, "cases": [ { "expression": "b7eo", "result": true } ] }, { "given": { "xIUo9": true }, "cases": [ { "expression": "xIUo9", "result": true } ] }, { "given": { "5": true }, "cases": [ { "expression": "\"5\"", "result": true } ] }, { "given": { "?": true }, "cases": [ { "expression": "\"?\"", "result": true } ] }, { "given": { "sU": true }, "cases": [ { "expression": "sU", "result": true } ] }, { "given": { "VH2&H\\\/": true }, "cases": [ { "expression": "\"VH2&H\\\\\\/\"", "result": true } ] }, { "given": { "_C": true }, "cases": [ { "expression": "_C", "result": true } ] }, { "given": { "_": true }, "cases": [ { "expression": "_", "result": true } ] }, { "given": { "<\t": true }, "cases": [ { "expression": "\"<\\t\"", "result": true } ] }, { "given": { "\uD834\uDD1E": true }, "cases": [ { "expression": "\"\\uD834\\uDD1E\"", "result": true } ] } ] go-jmespath-0.4.0/compliance/indices.json000066400000000000000000000211371373124421700203640ustar00rootroot00000000000000[{ "given": {"foo": {"bar": ["zero", "one", "two"]}}, "cases": [ { "expression": "foo.bar[0]", "result": "zero" }, { "expression": "foo.bar[1]", "result": "one" }, { "expression": "foo.bar[2]", "result": "two" }, { "expression": "foo.bar[3]", "result": null }, { "expression": "foo.bar[-1]", "result": "two" }, { "expression": "foo.bar[-2]", "result": "one" }, { "expression": "foo.bar[-3]", "result": "zero" }, { "expression": "foo.bar[-4]", "result": null } ] }, { "given": {"foo": [{"bar": "one"}, {"bar": "two"}, {"bar": "three"}, {"notbar": "four"}]}, "cases": [ { "expression": "foo.bar", "result": null }, { "expression": "foo[0].bar", "result": "one" }, { "expression": "foo[1].bar", "result": "two" }, { "expression": "foo[2].bar", "result": "three" }, { "expression": "foo[3].notbar", "result": "four" }, { "expression": "foo[3].bar", "result": null }, { "expression": "foo[0]", "result": {"bar": "one"} }, { "expression": "foo[1]", "result": {"bar": "two"} }, { "expression": "foo[2]", "result": {"bar": "three"} }, { "expression": "foo[3]", "result": {"notbar": "four"} }, { "expression": "foo[4]", "result": null } ] }, { "given": [ "one", "two", "three" ], "cases": [ { "expression": "[0]", "result": "one" }, { "expression": "[1]", "result": "two" }, { "expression": "[2]", "result": "three" }, { "expression": "[-1]", "result": "three" }, { "expression": "[-2]", "result": "two" }, { "expression": "[-3]", "result": "one" } ] }, { "given": {"reservations": [ {"instances": [{"foo": 1}, {"foo": 2}]} ]}, "cases": [ { "expression": "reservations[].instances[].foo", "result": [1, 2] }, { "expression": "reservations[].instances[].bar", "result": [] }, { "expression": "reservations[].notinstances[].foo", "result": [] }, { "expression": "reservations[].notinstances[].foo", "result": [] } ] }, { "given": {"reservations": [{ "instances": [ {"foo": [{"bar": 1}, {"bar": 2}, {"notbar": 3}, {"bar": 4}]}, {"foo": [{"bar": 5}, {"bar": 6}, {"notbar": [7]}, {"bar": 8}]}, {"foo": "bar"}, {"notfoo": [{"bar": 20}, {"bar": 21}, {"notbar": [7]}, {"bar": 22}]}, {"bar": [{"baz": [1]}, {"baz": [2]}, {"baz": [3]}, {"baz": [4]}]}, {"baz": [{"baz": [1, 2]}, {"baz": []}, {"baz": []}, {"baz": [3, 4]}]}, {"qux": [{"baz": []}, {"baz": [1, 2, 3]}, {"baz": [4]}, {"baz": []}]} ], "otherkey": {"foo": [{"bar": 1}, {"bar": 2}, {"notbar": 3}, {"bar": 4}]} }, { "instances": [ {"a": [{"bar": 1}, {"bar": 2}, {"notbar": 3}, {"bar": 4}]}, {"b": [{"bar": 5}, {"bar": 6}, {"notbar": [7]}, {"bar": 8}]}, {"c": "bar"}, {"notfoo": [{"bar": 23}, {"bar": 24}, {"notbar": [7]}, {"bar": 25}]}, {"qux": [{"baz": []}, {"baz": [1, 2, 3]}, {"baz": [4]}, {"baz": []}]} ], "otherkey": {"foo": [{"bar": 1}, {"bar": 2}, {"notbar": 3}, {"bar": 4}]} } ]}, "cases": [ { "expression": "reservations[].instances[].foo[].bar", "result": [1, 2, 4, 5, 6, 8] }, { "expression": "reservations[].instances[].foo[].baz", "result": [] }, { "expression": "reservations[].instances[].notfoo[].bar", "result": [20, 21, 22, 23, 24, 25] }, { "expression": "reservations[].instances[].notfoo[].notbar", "result": [[7], [7]] }, { "expression": "reservations[].notinstances[].foo", "result": [] }, { "expression": "reservations[].instances[].foo[].notbar", "result": [3, [7]] }, { "expression": "reservations[].instances[].bar[].baz", "result": [[1], [2], [3], [4]] }, { "expression": "reservations[].instances[].baz[].baz", "result": [[1, 2], [], [], [3, 4]] }, { "expression": "reservations[].instances[].qux[].baz", "result": [[], [1, 2, 3], [4], [], [], [1, 2, 3], [4], []] }, { "expression": "reservations[].instances[].qux[].baz[]", "result": [1, 2, 3, 4, 1, 2, 3, 4] } ] }, { "given": { "foo": [ [["one", "two"], ["three", "four"]], [["five", "six"], ["seven", "eight"]], [["nine"], ["ten"]] ] }, "cases": [ { "expression": "foo[]", "result": [["one", "two"], ["three", "four"], ["five", "six"], ["seven", "eight"], ["nine"], ["ten"]] }, { "expression": "foo[][0]", "result": ["one", "three", "five", "seven", "nine", "ten"] }, { "expression": "foo[][1]", "result": ["two", "four", "six", "eight"] }, { "expression": "foo[][0][0]", "result": [] }, { "expression": "foo[][2][2]", "result": [] }, { "expression": "foo[][0][0][100]", "result": [] } ] }, { "given": { "foo": [{ "bar": [ { "qux": 2, "baz": 1 }, { "qux": 4, "baz": 3 } ] }, { "bar": [ { "qux": 6, "baz": 5 }, { "qux": 8, "baz": 7 } ] } ] }, "cases": [ { "expression": "foo", "result": [{"bar": [{"qux": 2, "baz": 1}, {"qux": 4, "baz": 3}]}, {"bar": [{"qux": 6, "baz": 5}, {"qux": 8, "baz": 7}]}] }, { "expression": "foo[]", "result": [{"bar": [{"qux": 2, "baz": 1}, {"qux": 4, "baz": 3}]}, {"bar": [{"qux": 6, "baz": 5}, {"qux": 8, "baz": 7}]}] }, { "expression": "foo[].bar", "result": [[{"qux": 2, "baz": 1}, {"qux": 4, "baz": 3}], [{"qux": 6, "baz": 5}, {"qux": 8, "baz": 7}]] }, { "expression": "foo[].bar[]", "result": [{"qux": 2, "baz": 1}, {"qux": 4, "baz": 3}, {"qux": 6, "baz": 5}, {"qux": 8, "baz": 7}] }, { "expression": "foo[].bar[].baz", "result": [1, 3, 5, 7] } ] }, { "given": { "string": "string", "hash": {"foo": "bar", "bar": "baz"}, "number": 23, "nullvalue": null }, "cases": [ { "expression": "string[]", "result": null }, { "expression": "hash[]", "result": null }, { "expression": "number[]", "result": null }, { "expression": "nullvalue[]", "result": null }, { "expression": "string[].foo", "result": null }, { "expression": "hash[].foo", "result": null }, { "expression": "number[].foo", "result": null }, { "expression": "nullvalue[].foo", "result": null }, { "expression": "nullvalue[].foo[].bar", "result": null } ] } ] go-jmespath-0.4.0/compliance/literal.json000066400000000000000000000111451373124421700204000ustar00rootroot00000000000000[ { "given": { "foo": [{"name": "a"}, {"name": "b"}], "bar": {"baz": "qux"} }, "cases": [ { "expression": "`\"foo\"`", "result": "foo" }, { "comment": "Interpret escaped unicode.", "expression": "`\"\\u03a6\"`", "result": "Φ" }, { "expression": "`\"✓\"`", "result": "✓" }, { "expression": "`[1, 2, 3]`", "result": [1, 2, 3] }, { "expression": "`{\"a\": \"b\"}`", "result": {"a": "b"} }, { "expression": "`true`", "result": true }, { "expression": "`false`", "result": false }, { "expression": "`null`", "result": null }, { "expression": "`0`", "result": 0 }, { "expression": "`1`", "result": 1 }, { "expression": "`2`", "result": 2 }, { "expression": "`3`", "result": 3 }, { "expression": "`4`", "result": 4 }, { "expression": "`5`", "result": 5 }, { "expression": "`6`", "result": 6 }, { "expression": "`7`", "result": 7 }, { "expression": "`8`", "result": 8 }, { "expression": "`9`", "result": 9 }, { "comment": "Escaping a backtick in quotes", "expression": "`\"foo\\`bar\"`", "result": "foo`bar" }, { "comment": "Double quote in literal", "expression": "`\"foo\\\"bar\"`", "result": "foo\"bar" }, { "expression": "`\"1\\`\"`", "result": "1`" }, { "comment": "Multiple literal expressions with escapes", "expression": "`\"\\\\\"`.{a:`\"b\"`}", "result": {"a": "b"} }, { "comment": "literal . identifier", "expression": "`{\"a\": \"b\"}`.a", "result": "b" }, { "comment": "literal . identifier . identifier", "expression": "`{\"a\": {\"b\": \"c\"}}`.a.b", "result": "c" }, { "comment": "literal . identifier bracket-expr", "expression": "`[0, 1, 2]`[1]", "result": 1 } ] }, { "comment": "Literals", "given": {"type": "object"}, "cases": [ { "comment": "Literal with leading whitespace", "expression": "` {\"foo\": true}`", "result": {"foo": true} }, { "comment": "Literal with trailing whitespace", "expression": "`{\"foo\": true} `", "result": {"foo": true} }, { "comment": "Literal on RHS of subexpr not allowed", "expression": "foo.`\"bar\"`", "error": "syntax" } ] }, { "comment": "Raw String Literals", "given": {}, "cases": [ { "expression": "'foo'", "result": "foo" }, { "expression": "' foo '", "result": " foo " }, { "expression": "'0'", "result": "0" }, { "expression": "'newline\n'", "result": "newline\n" }, { "expression": "'\n'", "result": "\n" }, { "expression": "'✓'", "result": "✓" }, { "expression": "'𝄞'", "result": "𝄞" }, { "expression": "' [foo] '", "result": " [foo] " }, { "expression": "'[foo]'", "result": "[foo]" }, { "comment": "Do not interpret escaped unicode.", "expression": "'\\u03a6'", "result": "\\u03a6" } ] } ] go-jmespath-0.4.0/compliance/multiselect.json000066400000000000000000000240331373124421700212760ustar00rootroot00000000000000[{ "given": { "foo": { "bar": "bar", "baz": "baz", "qux": "qux", "nested": { "one": { "a": "first", "b": "second", "c": "third" }, "two": { "a": "first", "b": "second", "c": "third" }, "three": { "a": "first", "b": "second", "c": {"inner": "third"} } } }, "bar": 1, "baz": 2, "qux\"": 3 }, "cases": [ { "expression": "foo.{bar: bar}", "result": {"bar": "bar"} }, { "expression": "foo.{\"bar\": bar}", "result": {"bar": "bar"} }, { "expression": "foo.{\"foo.bar\": bar}", "result": {"foo.bar": "bar"} }, { "expression": "foo.{bar: bar, baz: baz}", "result": {"bar": "bar", "baz": "baz"} }, { "expression": "foo.{\"bar\": bar, \"baz\": baz}", "result": {"bar": "bar", "baz": "baz"} }, { "expression": "{\"baz\": baz, \"qux\\\"\": \"qux\\\"\"}", "result": {"baz": 2, "qux\"": 3} }, { "expression": "foo.{bar:bar,baz:baz}", "result": {"bar": "bar", "baz": "baz"} }, { "expression": "foo.{bar: bar,qux: qux}", "result": {"bar": "bar", "qux": "qux"} }, { "expression": "foo.{bar: bar, noexist: noexist}", "result": {"bar": "bar", "noexist": null} }, { "expression": "foo.{noexist: noexist, alsonoexist: alsonoexist}", "result": {"noexist": null, "alsonoexist": null} }, { "expression": "foo.badkey.{nokey: nokey, alsonokey: alsonokey}", "result": null }, { "expression": "foo.nested.*.{a: a,b: b}", "result": [{"a": "first", "b": "second"}, {"a": "first", "b": "second"}, {"a": "first", "b": "second"}] }, { "expression": "foo.nested.three.{a: a, cinner: c.inner}", "result": {"a": "first", "cinner": "third"} }, { "expression": "foo.nested.three.{a: a, c: c.inner.bad.key}", "result": {"a": "first", "c": null} }, { "expression": "foo.{a: nested.one.a, b: nested.two.b}", "result": {"a": "first", "b": "second"} }, { "expression": "{bar: bar, baz: baz}", "result": {"bar": 1, "baz": 2} }, { "expression": "{bar: bar}", "result": {"bar": 1} }, { "expression": "{otherkey: bar}", "result": {"otherkey": 1} }, { "expression": "{no: no, exist: exist}", "result": {"no": null, "exist": null} }, { "expression": "foo.[bar]", "result": ["bar"] }, { "expression": "foo.[bar,baz]", "result": ["bar", "baz"] }, { "expression": "foo.[bar,qux]", "result": ["bar", "qux"] }, { "expression": "foo.[bar,noexist]", "result": ["bar", null] }, { "expression": "foo.[noexist,alsonoexist]", "result": [null, null] } ] }, { "given": { "foo": {"bar": 1, "baz": [2, 3, 4]} }, "cases": [ { "expression": "foo.{bar:bar,baz:baz}", "result": {"bar": 1, "baz": [2, 3, 4]} }, { "expression": "foo.[bar,baz[0]]", "result": [1, 2] }, { "expression": "foo.[bar,baz[1]]", "result": [1, 3] }, { "expression": "foo.[bar,baz[2]]", "result": [1, 4] }, { "expression": "foo.[bar,baz[3]]", "result": [1, null] }, { "expression": "foo.[bar[0],baz[3]]", "result": [null, null] } ] }, { "given": { "foo": {"bar": 1, "baz": 2} }, "cases": [ { "expression": "foo.{bar: bar, baz: baz}", "result": {"bar": 1, "baz": 2} }, { "expression": "foo.[bar,baz]", "result": [1, 2] } ] }, { "given": { "foo": { "bar": {"baz": [{"common": "first", "one": 1}, {"common": "second", "two": 2}]}, "ignoreme": 1, "includeme": true } }, "cases": [ { "expression": "foo.{bar: bar.baz[1],includeme: includeme}", "result": {"bar": {"common": "second", "two": 2}, "includeme": true} }, { "expression": "foo.{\"bar.baz.two\": bar.baz[1].two, includeme: includeme}", "result": {"bar.baz.two": 2, "includeme": true} }, { "expression": "foo.[includeme, bar.baz[*].common]", "result": [true, ["first", "second"]] }, { "expression": "foo.[includeme, bar.baz[*].none]", "result": [true, []] }, { "expression": "foo.[includeme, bar.baz[].common]", "result": [true, ["first", "second"]] } ] }, { "given": { "reservations": [{ "instances": [ {"id": "id1", "name": "first"}, {"id": "id2", "name": "second"} ]}, { "instances": [ {"id": "id3", "name": "third"}, {"id": "id4", "name": "fourth"} ]} ]}, "cases": [ { "expression": "reservations[*].instances[*].{id: id, name: name}", "result": [[{"id": "id1", "name": "first"}, {"id": "id2", "name": "second"}], [{"id": "id3", "name": "third"}, {"id": "id4", "name": "fourth"}]] }, { "expression": "reservations[].instances[].{id: id, name: name}", "result": [{"id": "id1", "name": "first"}, {"id": "id2", "name": "second"}, {"id": "id3", "name": "third"}, {"id": "id4", "name": "fourth"}] }, { "expression": "reservations[].instances[].[id, name]", "result": [["id1", "first"], ["id2", "second"], ["id3", "third"], ["id4", "fourth"]] } ] }, { "given": { "foo": [{ "bar": [ { "qux": 2, "baz": 1 }, { "qux": 4, "baz": 3 } ] }, { "bar": [ { "qux": 6, "baz": 5 }, { "qux": 8, "baz": 7 } ] } ] }, "cases": [ { "expression": "foo", "result": [{"bar": [{"qux": 2, "baz": 1}, {"qux": 4, "baz": 3}]}, {"bar": [{"qux": 6, "baz": 5}, {"qux": 8, "baz": 7}]}] }, { "expression": "foo[]", "result": [{"bar": [{"qux": 2, "baz": 1}, {"qux": 4, "baz": 3}]}, {"bar": [{"qux": 6, "baz": 5}, {"qux": 8, "baz": 7}]}] }, { "expression": "foo[].bar", "result": [[{"qux": 2, "baz": 1}, {"qux": 4, "baz": 3}], [{"qux": 6, "baz": 5}, {"qux": 8, "baz": 7}]] }, { "expression": "foo[].bar[]", "result": [{"qux": 2, "baz": 1}, {"qux": 4, "baz": 3}, {"qux": 6, "baz": 5}, {"qux": 8, "baz": 7}] }, { "expression": "foo[].bar[].[baz, qux]", "result": [[1, 2], [3, 4], [5, 6], [7, 8]] }, { "expression": "foo[].bar[].[baz]", "result": [[1], [3], [5], [7]] }, { "expression": "foo[].bar[].[baz, qux][]", "result": [1, 2, 3, 4, 5, 6, 7, 8] } ] }, { "given": { "foo": { "baz": [ { "bar": "abc" }, { "bar": "def" } ], "qux": ["zero"] } }, "cases": [ { "expression": "foo.[baz[*].bar, qux[0]]", "result": [["abc", "def"], "zero"] } ] }, { "given": { "foo": { "baz": [ { "bar": "a", "bam": "b", "boo": "c" }, { "bar": "d", "bam": "e", "boo": "f" } ], "qux": ["zero"] } }, "cases": [ { "expression": "foo.[baz[*].[bar, boo], qux[0]]", "result": [[["a", "c" ], ["d", "f" ]], "zero"] } ] }, { "given": { "foo": { "baz": [ { "bar": "a", "bam": "b", "boo": "c" }, { "bar": "d", "bam": "e", "boo": "f" } ], "qux": ["zero"] } }, "cases": [ { "expression": "foo.[baz[*].not_there || baz[*].bar, qux[0]]", "result": [["a", "d"], "zero"] } ] }, { "given": {"type": "object"}, "cases": [ { "comment": "Nested multiselect", "expression": "[[*],*]", "result": [null, ["object"]] } ] }, { "given": [], "cases": [ { "comment": "Nested multiselect", "expression": "[[*]]", "result": [[]] } ] } ] go-jmespath-0.4.0/compliance/ormatch.json000066400000000000000000000027731373124421700204100ustar00rootroot00000000000000[{ "given": {"outer": {"foo": "foo", "bar": "bar", "baz": "baz"}}, "cases": [ { "expression": "outer.foo || outer.bar", "result": "foo" }, { "expression": "outer.foo||outer.bar", "result": "foo" }, { "expression": "outer.bar || outer.baz", "result": "bar" }, { "expression": "outer.bar||outer.baz", "result": "bar" }, { "expression": "outer.bad || outer.foo", "result": "foo" }, { "expression": "outer.bad||outer.foo", "result": "foo" }, { "expression": "outer.foo || outer.bad", "result": "foo" }, { "expression": "outer.foo||outer.bad", "result": "foo" }, { "expression": "outer.bad || outer.alsobad", "result": null }, { "expression": "outer.bad||outer.alsobad", "result": null } ] }, { "given": {"outer": {"foo": "foo", "bool": false, "empty_list": [], "empty_string": ""}}, "cases": [ { "expression": "outer.empty_string || outer.foo", "result": "foo" }, { "expression": "outer.nokey || outer.bool || outer.empty_list || outer.empty_string || outer.foo", "result": "foo" } ] }] go-jmespath-0.4.0/compliance/pipe.json000066400000000000000000000044511373124421700177030ustar00rootroot00000000000000[{ "given": { "foo": { "bar": { "baz": "subkey" }, "other": { "baz": "subkey" }, "other2": { "baz": "subkey" }, "other3": { "notbaz": ["a", "b", "c"] }, "other4": { "notbaz": ["a", "b", "c"] } } }, "cases": [ { "expression": "foo.*.baz | [0]", "result": "subkey" }, { "expression": "foo.*.baz | [1]", "result": "subkey" }, { "expression": "foo.*.baz | [2]", "result": "subkey" }, { "expression": "foo.bar.* | [0]", "result": "subkey" }, { "expression": "foo.*.notbaz | [*]", "result": [["a", "b", "c"], ["a", "b", "c"]] }, { "expression": "{\"a\": foo.bar, \"b\": foo.other} | *.baz", "result": ["subkey", "subkey"] } ] }, { "given": { "foo": { "bar": { "baz": "one" }, "other": { "baz": "two" }, "other2": { "baz": "three" }, "other3": { "notbaz": ["a", "b", "c"] }, "other4": { "notbaz": ["d", "e", "f"] } } }, "cases": [ { "expression": "foo | bar", "result": {"baz": "one"} }, { "expression": "foo | bar | baz", "result": "one" }, { "expression": "foo|bar| baz", "result": "one" }, { "expression": "not_there | [0]", "result": null }, { "expression": "not_there | [0]", "result": null }, { "expression": "[foo.bar, foo.other] | [0]", "result": {"baz": "one"} }, { "expression": "{\"a\": foo.bar, \"b\": foo.other} | a", "result": {"baz": "one"} }, { "expression": "{\"a\": foo.bar, \"b\": foo.other} | b", "result": {"baz": "two"} }, { "expression": "foo.bam || foo.bar | baz", "result": "one" }, { "expression": "foo | not_there || bar", "result": {"baz": "one"} } ] }, { "given": { "foo": [{ "bar": [{ "baz": "one" }, { "baz": "two" }] }, { "bar": [{ "baz": "three" }, { "baz": "four" }] }] }, "cases": [ { "expression": "foo[*].bar[*] | [0][0]", "result": {"baz": "one"} } ] }] go-jmespath-0.4.0/compliance/slice.json000066400000000000000000000070671373124421700200530ustar00rootroot00000000000000[{ "given": { "foo": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9], "bar": { "baz": 1 } }, "cases": [ { "expression": "bar[0:10]", "result": null }, { "expression": "foo[0:10:1]", "result": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] }, { "expression": "foo[0:10]", "result": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] }, { "expression": "foo[0:10:]", "result": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] }, { "expression": "foo[0::1]", "result": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] }, { "expression": "foo[0::]", "result": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] }, { "expression": "foo[0:]", "result": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] }, { "expression": "foo[:10:1]", "result": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] }, { "expression": "foo[::1]", "result": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] }, { "expression": "foo[:10:]", "result": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] }, { "expression": "foo[::]", "result": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] }, { "expression": "foo[:]", "result": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] }, { "expression": "foo[1:9]", "result": [1, 2, 3, 4, 5, 6, 7, 8] }, { "expression": "foo[0:10:2]", "result": [0, 2, 4, 6, 8] }, { "expression": "foo[5:]", "result": [5, 6, 7, 8, 9] }, { "expression": "foo[5::2]", "result": [5, 7, 9] }, { "expression": "foo[::2]", "result": [0, 2, 4, 6, 8] }, { "expression": "foo[::-1]", "result": [9, 8, 7, 6, 5, 4, 3, 2, 1, 0] }, { "expression": "foo[1::2]", "result": [1, 3, 5, 7, 9] }, { "expression": "foo[10:0:-1]", "result": [9, 8, 7, 6, 5, 4, 3, 2, 1] }, { "expression": "foo[10:5:-1]", "result": [9, 8, 7, 6] }, { "expression": "foo[8:2:-2]", "result": [8, 6, 4] }, { "expression": "foo[0:20]", "result": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] }, { "expression": "foo[10:-20:-1]", "result": [9, 8, 7, 6, 5, 4, 3, 2, 1, 0] }, { "expression": "foo[10:-20]", "result": [] }, { "expression": "foo[-4:-1]", "result": [6, 7, 8] }, { "expression": "foo[:-5:-1]", "result": [9, 8, 7, 6] }, { "expression": "foo[8:2:0]", "error": "invalid-value" }, { "expression": "foo[8:2:0:1]", "error": "syntax" }, { "expression": "foo[8:2&]", "error": "syntax" }, { "expression": "foo[2:a:3]", "error": "syntax" } ] }, { "given": { "foo": [{"a": 1}, {"a": 2}, {"a": 3}], "bar": [{"a": {"b": 1}}, {"a": {"b": 2}}, {"a": {"b": 3}}], "baz": 50 }, "cases": [ { "expression": "foo[:2].a", "result": [1, 2] }, { "expression": "foo[:2].b", "result": [] }, { "expression": "foo[:2].a.b", "result": [] }, { "expression": "bar[::-1].a.b", "result": [3, 2, 1] }, { "expression": "bar[:2].a.b", "result": [1, 2] }, { "expression": "baz[:2].a", "result": null } ] }, { "given": [{"a": 1}, {"a": 2}, {"a": 3}], "cases": [ { "expression": "[:]", "result": [{"a": 1}, {"a": 2}, {"a": 3}] }, { "expression": "[:2].a", "result": [1, 2] }, { "expression": "[::-1].a", "result": [3, 2, 1] }, { "expression": "[:2].b", "result": [] } ] }] go-jmespath-0.4.0/compliance/syntax.json000066400000000000000000000322101373124421700202660ustar00rootroot00000000000000[{ "comment": "Dot syntax", "given": {"type": "object"}, "cases": [ { "expression": "foo.bar", "result": null }, { "expression": "foo.1", "error": "syntax" }, { "expression": "foo.-11", "error": "syntax" }, { "expression": "foo", "result": null }, { "expression": "foo.", "error": "syntax" }, { "expression": "foo.", "error": "syntax" }, { "expression": ".foo", "error": "syntax" }, { "expression": "foo..bar", "error": "syntax" }, { "expression": "foo.bar.", "error": "syntax" }, { "expression": "foo[.]", "error": "syntax" } ] }, { "comment": "Simple token errors", "given": {"type": "object"}, "cases": [ { "expression": ".", "error": "syntax" }, { "expression": ":", "error": "syntax" }, { "expression": ",", "error": "syntax" }, { "expression": "]", "error": "syntax" }, { "expression": "[", "error": "syntax" }, { "expression": "}", "error": "syntax" }, { "expression": "{", "error": "syntax" }, { "expression": ")", "error": "syntax" }, { "expression": "(", "error": "syntax" }, { "expression": "((&", "error": "syntax" }, { "expression": "a[", "error": "syntax" }, { "expression": "a]", "error": "syntax" }, { "expression": "a][", "error": "syntax" }, { "expression": "!", "error": "syntax" } ] }, { "comment": "Boolean syntax errors", "given": {"type": "object"}, "cases": [ { "expression": "![!(!", "error": "syntax" } ] }, { "comment": "Wildcard syntax", "given": {"type": "object"}, "cases": [ { "expression": "*", "result": ["object"] }, { "expression": "*.*", "result": [] }, { "expression": "*.foo", "result": [] }, { "expression": "*[0]", "result": [] }, { "expression": ".*", "error": "syntax" }, { "expression": "*foo", "error": "syntax" }, { "expression": "*0", "error": "syntax" }, { "expression": "foo[*]bar", "error": "syntax" }, { "expression": "foo[*]*", "error": "syntax" } ] }, { "comment": "Flatten syntax", "given": {"type": "object"}, "cases": [ { "expression": "[]", "result": null } ] }, { "comment": "Simple bracket syntax", "given": {"type": "object"}, "cases": [ { "expression": "[0]", "result": null }, { "expression": "[*]", "result": null }, { "expression": "*.[0]", "error": "syntax" }, { "expression": "*.[\"0\"]", "result": [[null]] }, { "expression": "[*].bar", "result": null }, { "expression": "[*][0]", "result": null }, { "expression": "foo[#]", "error": "syntax" } ] }, { "comment": "Multi-select list syntax", "given": {"type": "object"}, "cases": [ { "expression": "foo[0]", "result": null }, { "comment": "Valid multi-select of a list", "expression": "foo[0, 1]", "error": "syntax" }, { "expression": "foo.[0]", "error": "syntax" }, { "expression": "foo.[*]", "result": null }, { "comment": "Multi-select of a list with trailing comma", "expression": "foo[0, ]", "error": "syntax" }, { "comment": "Multi-select of a list with trailing comma and no close", "expression": "foo[0,", "error": "syntax" }, { "comment": "Multi-select of a list with trailing comma and no close", "expression": "foo.[a", "error": "syntax" }, { "comment": "Multi-select of a list with extra comma", "expression": "foo[0,, 1]", "error": "syntax" }, { "comment": "Multi-select of a list using an identifier index", "expression": "foo[abc]", "error": "syntax" }, { "comment": "Multi-select of a list using identifier indices", "expression": "foo[abc, def]", "error": "syntax" }, { "comment": "Multi-select of a list using an identifier index", "expression": "foo[abc, 1]", "error": "syntax" }, { "comment": "Multi-select of a list using an identifier index with trailing comma", "expression": "foo[abc, ]", "error": "syntax" }, { "comment": "Valid multi-select of a hash using an identifier index", "expression": "foo.[abc]", "result": null }, { "comment": "Valid multi-select of a hash", "expression": "foo.[abc, def]", "result": null }, { "comment": "Multi-select of a hash using a numeric index", "expression": "foo.[abc, 1]", "error": "syntax" }, { "comment": "Multi-select of a hash with a trailing comma", "expression": "foo.[abc, ]", "error": "syntax" }, { "comment": "Multi-select of a hash with extra commas", "expression": "foo.[abc,, def]", "error": "syntax" }, { "comment": "Multi-select of a hash using number indices", "expression": "foo.[0, 1]", "error": "syntax" } ] }, { "comment": "Multi-select hash syntax", "given": {"type": "object"}, "cases": [ { "comment": "No key or value", "expression": "a{}", "error": "syntax" }, { "comment": "No closing token", "expression": "a{", "error": "syntax" }, { "comment": "Not a key value pair", "expression": "a{foo}", "error": "syntax" }, { "comment": "Missing value and closing character", "expression": "a{foo:", "error": "syntax" }, { "comment": "Missing closing character", "expression": "a{foo: 0", "error": "syntax" }, { "comment": "Missing value", "expression": "a{foo:}", "error": "syntax" }, { "comment": "Trailing comma and no closing character", "expression": "a{foo: 0, ", "error": "syntax" }, { "comment": "Missing value with trailing comma", "expression": "a{foo: ,}", "error": "syntax" }, { "comment": "Accessing Array using an identifier", "expression": "a{foo: bar}", "error": "syntax" }, { "expression": "a{foo: 0}", "error": "syntax" }, { "comment": "Missing key-value pair", "expression": "a.{}", "error": "syntax" }, { "comment": "Not a key-value pair", "expression": "a.{foo}", "error": "syntax" }, { "comment": "Missing value", "expression": "a.{foo:}", "error": "syntax" }, { "comment": "Missing value with trailing comma", "expression": "a.{foo: ,}", "error": "syntax" }, { "comment": "Valid multi-select hash extraction", "expression": "a.{foo: bar}", "result": null }, { "comment": "Valid multi-select hash extraction", "expression": "a.{foo: bar, baz: bam}", "result": null }, { "comment": "Trailing comma", "expression": "a.{foo: bar, }", "error": "syntax" }, { "comment": "Missing key in second key-value pair", "expression": "a.{foo: bar, baz}", "error": "syntax" }, { "comment": "Missing value in second key-value pair", "expression": "a.{foo: bar, baz:}", "error": "syntax" }, { "comment": "Trailing comma", "expression": "a.{foo: bar, baz: bam, }", "error": "syntax" }, { "comment": "Nested multi select", "expression": "{\"\\\\\":{\" \":*}}", "result": {"\\": {" ": ["object"]}} } ] }, { "comment": "Or expressions", "given": {"type": "object"}, "cases": [ { "expression": "foo || bar", "result": null }, { "expression": "foo ||", "error": "syntax" }, { "expression": "foo.|| bar", "error": "syntax" }, { "expression": " || foo", "error": "syntax" }, { "expression": "foo || || foo", "error": "syntax" }, { "expression": "foo.[a || b]", "result": null }, { "expression": "foo.[a ||]", "error": "syntax" }, { "expression": "\"foo", "error": "syntax" } ] }, { "comment": "Filter expressions", "given": {"type": "object"}, "cases": [ { "expression": "foo[?bar==`\"baz\"`]", "result": null }, { "expression": "foo[? bar == `\"baz\"` ]", "result": null }, { "expression": "foo[ ?bar==`\"baz\"`]", "error": "syntax" }, { "expression": "foo[?bar==]", "error": "syntax" }, { "expression": "foo[?==]", "error": "syntax" }, { "expression": "foo[?==bar]", "error": "syntax" }, { "expression": "foo[?bar==baz?]", "error": "syntax" }, { "expression": "foo[?a.b.c==d.e.f]", "result": null }, { "expression": "foo[?bar==`[0, 1, 2]`]", "result": null }, { "expression": "foo[?bar==`[\"a\", \"b\", \"c\"]`]", "result": null }, { "comment": "Literal char not escaped", "expression": "foo[?bar==`[\"foo`bar\"]`]", "error": "syntax" }, { "comment": "Literal char escaped", "expression": "foo[?bar==`[\"foo\\`bar\"]`]", "result": null }, { "comment": "Unknown comparator", "expression": "foo[?bar<>baz]", "error": "syntax" }, { "comment": "Unknown comparator", "expression": "foo[?bar^baz]", "error": "syntax" }, { "expression": "foo[bar==baz]", "error": "syntax" }, { "comment": "Quoted identifier in filter expression no spaces", "expression": "[?\"\\\\\">`\"foo\"`]", "result": null }, { "comment": "Quoted identifier in filter expression with spaces", "expression": "[?\"\\\\\" > `\"foo\"`]", "result": null } ] }, { "comment": "Filter expression errors", "given": {"type": "object"}, "cases": [ { "expression": "bar.`\"anything\"`", "error": "syntax" }, { "expression": "bar.baz.noexists.`\"literal\"`", "error": "syntax" }, { "comment": "Literal wildcard projection", "expression": "foo[*].`\"literal\"`", "error": "syntax" }, { "expression": "foo[*].name.`\"literal\"`", "error": "syntax" }, { "expression": "foo[].name.`\"literal\"`", "error": "syntax" }, { "expression": "foo[].name.`\"literal\"`.`\"subliteral\"`", "error": "syntax" }, { "comment": "Projecting a literal onto an empty list", "expression": "foo[*].name.noexist.`\"literal\"`", "error": "syntax" }, { "expression": "foo[].name.noexist.`\"literal\"`", "error": "syntax" }, { "expression": "twolen[*].`\"foo\"`", "error": "syntax" }, { "comment": "Two level projection of a literal", "expression": "twolen[*].threelen[*].`\"bar\"`", "error": "syntax" }, { "comment": "Two level flattened projection of a literal", "expression": "twolen[].threelen[].`\"bar\"`", "error": "syntax" } ] }, { "comment": "Identifiers", "given": {"type": "object"}, "cases": [ { "expression": "foo", "result": null }, { "expression": "\"foo\"", "result": null }, { "expression": "\"\\\\\"", "result": null } ] }, { "comment": "Combined syntax", "given": [], "cases": [ { "expression": "*||*|*|*", "result": null }, { "expression": "*[]||[*]", "result": [] }, { "expression": "[*.*]", "result": [null] } ] } ] go-jmespath-0.4.0/compliance/unicode.json000066400000000000000000000014731373124421700203750ustar00rootroot00000000000000[ { "given": {"foo": [{"✓": "✓"}, {"✓": "✗"}]}, "cases": [ { "expression": "foo[].\"✓\"", "result": ["✓", "✗"] } ] }, { "given": {"☯": true}, "cases": [ { "expression": "\"☯\"", "result": true } ] }, { "given": {"♪♫•*¨*•.¸¸❤¸¸.•*¨*•♫♪": true}, "cases": [ { "expression": "\"♪♫•*¨*•.¸¸❤¸¸.•*¨*•♫♪\"", "result": true } ] }, { "given": {"☃": true}, "cases": [ { "expression": "\"☃\"", "result": true } ] } ] go-jmespath-0.4.0/compliance/wildcard.json000066400000000000000000000243311373124421700205360ustar00rootroot00000000000000[{ "given": { "foo": { "bar": { "baz": "val" }, "other": { "baz": "val" }, "other2": { "baz": "val" }, "other3": { "notbaz": ["a", "b", "c"] }, "other4": { "notbaz": ["a", "b", "c"] }, "other5": { "other": { "a": 1, "b": 1, "c": 1 } } } }, "cases": [ { "expression": "foo.*.baz", "result": ["val", "val", "val"] }, { "expression": "foo.bar.*", "result": ["val"] }, { "expression": "foo.*.notbaz", "result": [["a", "b", "c"], ["a", "b", "c"]] }, { "expression": "foo.*.notbaz[0]", "result": ["a", "a"] }, { "expression": "foo.*.notbaz[-1]", "result": ["c", "c"] } ] }, { "given": { "foo": { "first-1": { "second-1": "val" }, "first-2": { "second-1": "val" }, "first-3": { "second-1": "val" } } }, "cases": [ { "expression": "foo.*", "result": [{"second-1": "val"}, {"second-1": "val"}, {"second-1": "val"}] }, { "expression": "foo.*.*", "result": [["val"], ["val"], ["val"]] }, { "expression": "foo.*.*.*", "result": [[], [], []] }, { "expression": "foo.*.*.*.*", "result": [[], [], []] } ] }, { "given": { "foo": { "bar": "one" }, "other": { "bar": "one" }, "nomatch": { "notbar": "three" } }, "cases": [ { "expression": "*.bar", "result": ["one", "one"] } ] }, { "given": { "top1": { "sub1": {"foo": "one"} }, "top2": { "sub1": {"foo": "one"} } }, "cases": [ { "expression": "*", "result": [{"sub1": {"foo": "one"}}, {"sub1": {"foo": "one"}}] }, { "expression": "*.sub1", "result": [{"foo": "one"}, {"foo": "one"}] }, { "expression": "*.*", "result": [[{"foo": "one"}], [{"foo": "one"}]] }, { "expression": "*.*.foo[]", "result": ["one", "one"] }, { "expression": "*.sub1.foo", "result": ["one", "one"] } ] }, { "given": {"foo": [{"bar": "one"}, {"bar": "two"}, {"bar": "three"}, {"notbar": "four"}]}, "cases": [ { "expression": "foo[*].bar", "result": ["one", "two", "three"] }, { "expression": "foo[*].notbar", "result": ["four"] } ] }, { "given": [{"bar": "one"}, {"bar": "two"}, {"bar": "three"}, {"notbar": "four"}], "cases": [ { "expression": "[*]", "result": [{"bar": "one"}, {"bar": "two"}, {"bar": "three"}, {"notbar": "four"}] }, { "expression": "[*].bar", "result": ["one", "two", "three"] }, { "expression": "[*].notbar", "result": ["four"] } ] }, { "given": { "foo": { "bar": [ {"baz": ["one", "two", "three"]}, {"baz": ["four", "five", "six"]}, {"baz": ["seven", "eight", "nine"]} ] } }, "cases": [ { "expression": "foo.bar[*].baz", "result": [["one", "two", "three"], ["four", "five", "six"], ["seven", "eight", "nine"]] }, { "expression": "foo.bar[*].baz[0]", "result": ["one", "four", "seven"] }, { "expression": "foo.bar[*].baz[1]", "result": ["two", "five", "eight"] }, { "expression": "foo.bar[*].baz[2]", "result": ["three", "six", "nine"] }, { "expression": "foo.bar[*].baz[3]", "result": [] } ] }, { "given": { "foo": { "bar": [["one", "two"], ["three", "four"]] } }, "cases": [ { "expression": "foo.bar[*]", "result": [["one", "two"], ["three", "four"]] }, { "expression": "foo.bar[0]", "result": ["one", "two"] }, { "expression": "foo.bar[0][0]", "result": "one" }, { "expression": "foo.bar[0][0][0]", "result": null }, { "expression": "foo.bar[0][0][0][0]", "result": null }, { "expression": "foo[0][0]", "result": null } ] }, { "given": { "foo": [ {"bar": [{"kind": "basic"}, {"kind": "intermediate"}]}, {"bar": [{"kind": "advanced"}, {"kind": "expert"}]}, {"bar": "string"} ] }, "cases": [ { "expression": "foo[*].bar[*].kind", "result": [["basic", "intermediate"], ["advanced", "expert"]] }, { "expression": "foo[*].bar[0].kind", "result": ["basic", "advanced"] } ] }, { "given": { "foo": [ {"bar": {"kind": "basic"}}, {"bar": {"kind": "intermediate"}}, {"bar": {"kind": "advanced"}}, {"bar": {"kind": "expert"}}, {"bar": "string"} ] }, "cases": [ { "expression": "foo[*].bar.kind", "result": ["basic", "intermediate", "advanced", "expert"] } ] }, { "given": { "foo": [{"bar": ["one", "two"]}, {"bar": ["three", "four"]}, {"bar": ["five"]}] }, "cases": [ { "expression": "foo[*].bar[0]", "result": ["one", "three", "five"] }, { "expression": "foo[*].bar[1]", "result": ["two", "four"] }, { "expression": "foo[*].bar[2]", "result": [] } ] }, { "given": { "foo": [{"bar": []}, {"bar": []}, {"bar": []}] }, "cases": [ { "expression": "foo[*].bar[0]", "result": [] } ] }, { "given": { "foo": [["one", "two"], ["three", "four"], ["five"]] }, "cases": [ { "expression": "foo[*][0]", "result": ["one", "three", "five"] }, { "expression": "foo[*][1]", "result": ["two", "four"] } ] }, { "given": { "foo": [ [ ["one", "two"], ["three", "four"] ], [ ["five", "six"], ["seven", "eight"] ], [ ["nine"], ["ten"] ] ] }, "cases": [ { "expression": "foo[*][0]", "result": [["one", "two"], ["five", "six"], ["nine"]] }, { "expression": "foo[*][1]", "result": [["three", "four"], ["seven", "eight"], ["ten"]] }, { "expression": "foo[*][0][0]", "result": ["one", "five", "nine"] }, { "expression": "foo[*][1][0]", "result": ["three", "seven", "ten"] }, { "expression": "foo[*][0][1]", "result": ["two", "six"] }, { "expression": "foo[*][1][1]", "result": ["four", "eight"] }, { "expression": "foo[*][2]", "result": [] }, { "expression": "foo[*][2][2]", "result": [] }, { "expression": "bar[*]", "result": null }, { "expression": "bar[*].baz[*]", "result": null } ] }, { "given": { "string": "string", "hash": {"foo": "bar", "bar": "baz"}, "number": 23, "nullvalue": null }, "cases": [ { "expression": "string[*]", "result": null }, { "expression": "hash[*]", "result": null }, { "expression": "number[*]", "result": null }, { "expression": "nullvalue[*]", "result": null }, { "expression": "string[*].foo", "result": null }, { "expression": "hash[*].foo", "result": null }, { "expression": "number[*].foo", "result": null }, { "expression": "nullvalue[*].foo", "result": null }, { "expression": "nullvalue[*].foo[*].bar", "result": null } ] }, { "given": { "string": "string", "hash": {"foo": "val", "bar": "val"}, "number": 23, "array": [1, 2, 3], "nullvalue": null }, "cases": [ { "expression": "string.*", "result": null }, { "expression": "hash.*", "result": ["val", "val"] }, { "expression": "number.*", "result": null }, { "expression": "array.*", "result": null }, { "expression": "nullvalue.*", "result": null } ] }, { "given": { "a": [0, 1, 2], "b": [0, 1, 2] }, "cases": [ { "expression": "*[0]", "result": [0, 0] } ] } ] go-jmespath-0.4.0/compliance_test.go000066400000000000000000000062751373124421700174470ustar00rootroot00000000000000package jmespath import ( "encoding/json" "fmt" "io/ioutil" "os" "path/filepath" "testing" "github.com/jmespath/go-jmespath/internal/testify/assert" ) type TestSuite struct { Given interface{} TestCases []TestCase `json:"cases"` Comment string } type TestCase struct { Comment string Expression string Result interface{} Error string } var whiteListed = []string{ "compliance/basic.json", "compliance/current.json", "compliance/escape.json", "compliance/filters.json", "compliance/functions.json", "compliance/identifiers.json", "compliance/indices.json", "compliance/literal.json", "compliance/multiselect.json", "compliance/ormatch.json", "compliance/pipe.json", "compliance/slice.json", "compliance/syntax.json", "compliance/unicode.json", "compliance/wildcard.json", "compliance/boolean.json", } func allowed(path string) bool { for _, el := range whiteListed { if el == path { return true } } return false } func TestCompliance(t *testing.T) { assert := assert.New(t) var complianceFiles []string err := filepath.Walk("compliance", func(path string, _ os.FileInfo, _ error) error { //if strings.HasSuffix(path, ".json") { if allowed(path) { complianceFiles = append(complianceFiles, path) } return nil }) if assert.Nil(err) { for _, filename := range complianceFiles { runComplianceTest(assert, filename) } } } func runComplianceTest(assert *assert.Assertions, filename string) { var testSuites []TestSuite data, err := ioutil.ReadFile(filename) if assert.Nil(err) { err := json.Unmarshal(data, &testSuites) if assert.Nil(err) { for _, testsuite := range testSuites { runTestSuite(assert, testsuite, filename) } } } } func runTestSuite(assert *assert.Assertions, testsuite TestSuite, filename string) { for _, testcase := range testsuite.TestCases { if testcase.Error != "" { // This is a test case that verifies we error out properly. runSyntaxTestCase(assert, testsuite.Given, testcase, filename) } else { runTestCase(assert, testsuite.Given, testcase, filename) } } } func runSyntaxTestCase(assert *assert.Assertions, given interface{}, testcase TestCase, filename string) { // Anything with an .Error means that we expect that JMESPath should return // an error when we try to evaluate the expression. _, err := Search(testcase.Expression, given) assert.NotNil(err, fmt.Sprintf("Expression: %s", testcase.Expression)) } func runTestCase(assert *assert.Assertions, given interface{}, testcase TestCase, filename string) { lexer := NewLexer() var err error _, err = lexer.tokenize(testcase.Expression) if err != nil { errMsg := fmt.Sprintf("(%s) Could not lex expression: %s -- %s", filename, testcase.Expression, err.Error()) assert.Fail(errMsg) return } parser := NewParser() _, err = parser.Parse(testcase.Expression) if err != nil { errMsg := fmt.Sprintf("(%s) Could not parse expression: %s -- %s", filename, testcase.Expression, err.Error()) assert.Fail(errMsg) return } actual, err := Search(testcase.Expression, given) if assert.Nil(err, fmt.Sprintf("Expression: %s", testcase.Expression)) { assert.Equal(testcase.Result, actual, fmt.Sprintf("Expression: %s", testcase.Expression)) } } go-jmespath-0.4.0/functions.go000066400000000000000000000441441373124421700163030ustar00rootroot00000000000000package jmespath import ( "encoding/json" "errors" "fmt" "math" "reflect" "sort" "strconv" "strings" "unicode/utf8" ) type jpFunction func(arguments []interface{}) (interface{}, error) type jpType string const ( jpUnknown jpType = "unknown" jpNumber jpType = "number" jpString jpType = "string" jpArray jpType = "array" jpObject jpType = "object" jpArrayNumber jpType = "array[number]" jpArrayString jpType = "array[string]" jpExpref jpType = "expref" jpAny jpType = "any" ) type functionEntry struct { name string arguments []argSpec handler jpFunction hasExpRef bool } type argSpec struct { types []jpType variadic bool } type byExprString struct { intr *treeInterpreter node ASTNode items []interface{} hasError bool } func (a *byExprString) Len() int { return len(a.items) } func (a *byExprString) Swap(i, j int) { a.items[i], a.items[j] = a.items[j], a.items[i] } func (a *byExprString) Less(i, j int) bool { first, err := a.intr.Execute(a.node, a.items[i]) if err != nil { a.hasError = true // Return a dummy value. return true } ith, ok := first.(string) if !ok { a.hasError = true return true } second, err := a.intr.Execute(a.node, a.items[j]) if err != nil { a.hasError = true // Return a dummy value. return true } jth, ok := second.(string) if !ok { a.hasError = true return true } return ith < jth } type byExprFloat struct { intr *treeInterpreter node ASTNode items []interface{} hasError bool } func (a *byExprFloat) Len() int { return len(a.items) } func (a *byExprFloat) Swap(i, j int) { a.items[i], a.items[j] = a.items[j], a.items[i] } func (a *byExprFloat) Less(i, j int) bool { first, err := a.intr.Execute(a.node, a.items[i]) if err != nil { a.hasError = true // Return a dummy value. return true } ith, ok := first.(float64) if !ok { a.hasError = true return true } second, err := a.intr.Execute(a.node, a.items[j]) if err != nil { a.hasError = true // Return a dummy value. return true } jth, ok := second.(float64) if !ok { a.hasError = true return true } return ith < jth } type functionCaller struct { functionTable map[string]functionEntry } func newFunctionCaller() *functionCaller { caller := &functionCaller{} caller.functionTable = map[string]functionEntry{ "length": { name: "length", arguments: []argSpec{ {types: []jpType{jpString, jpArray, jpObject}}, }, handler: jpfLength, }, "starts_with": { name: "starts_with", arguments: []argSpec{ {types: []jpType{jpString}}, {types: []jpType{jpString}}, }, handler: jpfStartsWith, }, "abs": { name: "abs", arguments: []argSpec{ {types: []jpType{jpNumber}}, }, handler: jpfAbs, }, "avg": { name: "avg", arguments: []argSpec{ {types: []jpType{jpArrayNumber}}, }, handler: jpfAvg, }, "ceil": { name: "ceil", arguments: []argSpec{ {types: []jpType{jpNumber}}, }, handler: jpfCeil, }, "contains": { name: "contains", arguments: []argSpec{ {types: []jpType{jpArray, jpString}}, {types: []jpType{jpAny}}, }, handler: jpfContains, }, "ends_with": { name: "ends_with", arguments: []argSpec{ {types: []jpType{jpString}}, {types: []jpType{jpString}}, }, handler: jpfEndsWith, }, "floor": { name: "floor", arguments: []argSpec{ {types: []jpType{jpNumber}}, }, handler: jpfFloor, }, "map": { name: "amp", arguments: []argSpec{ {types: []jpType{jpExpref}}, {types: []jpType{jpArray}}, }, handler: jpfMap, hasExpRef: true, }, "max": { name: "max", arguments: []argSpec{ {types: []jpType{jpArrayNumber, jpArrayString}}, }, handler: jpfMax, }, "merge": { name: "merge", arguments: []argSpec{ {types: []jpType{jpObject}, variadic: true}, }, handler: jpfMerge, }, "max_by": { name: "max_by", arguments: []argSpec{ {types: []jpType{jpArray}}, {types: []jpType{jpExpref}}, }, handler: jpfMaxBy, hasExpRef: true, }, "sum": { name: "sum", arguments: []argSpec{ {types: []jpType{jpArrayNumber}}, }, handler: jpfSum, }, "min": { name: "min", arguments: []argSpec{ {types: []jpType{jpArrayNumber, jpArrayString}}, }, handler: jpfMin, }, "min_by": { name: "min_by", arguments: []argSpec{ {types: []jpType{jpArray}}, {types: []jpType{jpExpref}}, }, handler: jpfMinBy, hasExpRef: true, }, "type": { name: "type", arguments: []argSpec{ {types: []jpType{jpAny}}, }, handler: jpfType, }, "keys": { name: "keys", arguments: []argSpec{ {types: []jpType{jpObject}}, }, handler: jpfKeys, }, "values": { name: "values", arguments: []argSpec{ {types: []jpType{jpObject}}, }, handler: jpfValues, }, "sort": { name: "sort", arguments: []argSpec{ {types: []jpType{jpArrayString, jpArrayNumber}}, }, handler: jpfSort, }, "sort_by": { name: "sort_by", arguments: []argSpec{ {types: []jpType{jpArray}}, {types: []jpType{jpExpref}}, }, handler: jpfSortBy, hasExpRef: true, }, "join": { name: "join", arguments: []argSpec{ {types: []jpType{jpString}}, {types: []jpType{jpArrayString}}, }, handler: jpfJoin, }, "reverse": { name: "reverse", arguments: []argSpec{ {types: []jpType{jpArray, jpString}}, }, handler: jpfReverse, }, "to_array": { name: "to_array", arguments: []argSpec{ {types: []jpType{jpAny}}, }, handler: jpfToArray, }, "to_string": { name: "to_string", arguments: []argSpec{ {types: []jpType{jpAny}}, }, handler: jpfToString, }, "to_number": { name: "to_number", arguments: []argSpec{ {types: []jpType{jpAny}}, }, handler: jpfToNumber, }, "not_null": { name: "not_null", arguments: []argSpec{ {types: []jpType{jpAny}, variadic: true}, }, handler: jpfNotNull, }, } return caller } func (e *functionEntry) resolveArgs(arguments []interface{}) ([]interface{}, error) { if len(e.arguments) == 0 { return arguments, nil } if !e.arguments[len(e.arguments)-1].variadic { if len(e.arguments) != len(arguments) { return nil, errors.New("incorrect number of args") } for i, spec := range e.arguments { userArg := arguments[i] err := spec.typeCheck(userArg) if err != nil { return nil, err } } return arguments, nil } if len(arguments) < len(e.arguments) { return nil, errors.New("Invalid arity.") } return arguments, nil } func (a *argSpec) typeCheck(arg interface{}) error { for _, t := range a.types { switch t { case jpNumber: if _, ok := arg.(float64); ok { return nil } case jpString: if _, ok := arg.(string); ok { return nil } case jpArray: if isSliceType(arg) { return nil } case jpObject: if _, ok := arg.(map[string]interface{}); ok { return nil } case jpArrayNumber: if _, ok := toArrayNum(arg); ok { return nil } case jpArrayString: if _, ok := toArrayStr(arg); ok { return nil } case jpAny: return nil case jpExpref: if _, ok := arg.(expRef); ok { return nil } } } return fmt.Errorf("Invalid type for: %v, expected: %#v", arg, a.types) } func (f *functionCaller) CallFunction(name string, arguments []interface{}, intr *treeInterpreter) (interface{}, error) { entry, ok := f.functionTable[name] if !ok { return nil, errors.New("unknown function: " + name) } resolvedArgs, err := entry.resolveArgs(arguments) if err != nil { return nil, err } if entry.hasExpRef { var extra []interface{} extra = append(extra, intr) resolvedArgs = append(extra, resolvedArgs...) } return entry.handler(resolvedArgs) } func jpfAbs(arguments []interface{}) (interface{}, error) { num := arguments[0].(float64) return math.Abs(num), nil } func jpfLength(arguments []interface{}) (interface{}, error) { arg := arguments[0] if c, ok := arg.(string); ok { return float64(utf8.RuneCountInString(c)), nil } else if isSliceType(arg) { v := reflect.ValueOf(arg) return float64(v.Len()), nil } else if c, ok := arg.(map[string]interface{}); ok { return float64(len(c)), nil } return nil, errors.New("could not compute length()") } func jpfStartsWith(arguments []interface{}) (interface{}, error) { search := arguments[0].(string) prefix := arguments[1].(string) return strings.HasPrefix(search, prefix), nil } func jpfAvg(arguments []interface{}) (interface{}, error) { // We've already type checked the value so we can safely use // type assertions. args := arguments[0].([]interface{}) length := float64(len(args)) numerator := 0.0 for _, n := range args { numerator += n.(float64) } return numerator / length, nil } func jpfCeil(arguments []interface{}) (interface{}, error) { val := arguments[0].(float64) return math.Ceil(val), nil } func jpfContains(arguments []interface{}) (interface{}, error) { search := arguments[0] el := arguments[1] if searchStr, ok := search.(string); ok { if elStr, ok := el.(string); ok { return strings.Index(searchStr, elStr) != -1, nil } return false, nil } // Otherwise this is a generic contains for []interface{} general := search.([]interface{}) for _, item := range general { if item == el { return true, nil } } return false, nil } func jpfEndsWith(arguments []interface{}) (interface{}, error) { search := arguments[0].(string) suffix := arguments[1].(string) return strings.HasSuffix(search, suffix), nil } func jpfFloor(arguments []interface{}) (interface{}, error) { val := arguments[0].(float64) return math.Floor(val), nil } func jpfMap(arguments []interface{}) (interface{}, error) { intr := arguments[0].(*treeInterpreter) exp := arguments[1].(expRef) node := exp.ref arr := arguments[2].([]interface{}) mapped := make([]interface{}, 0, len(arr)) for _, value := range arr { current, err := intr.Execute(node, value) if err != nil { return nil, err } mapped = append(mapped, current) } return mapped, nil } func jpfMax(arguments []interface{}) (interface{}, error) { if items, ok := toArrayNum(arguments[0]); ok { if len(items) == 0 { return nil, nil } if len(items) == 1 { return items[0], nil } best := items[0] for _, item := range items[1:] { if item > best { best = item } } return best, nil } // Otherwise we're dealing with a max() of strings. items, _ := toArrayStr(arguments[0]) if len(items) == 0 { return nil, nil } if len(items) == 1 { return items[0], nil } best := items[0] for _, item := range items[1:] { if item > best { best = item } } return best, nil } func jpfMerge(arguments []interface{}) (interface{}, error) { final := make(map[string]interface{}) for _, m := range arguments { mapped := m.(map[string]interface{}) for key, value := range mapped { final[key] = value } } return final, nil } func jpfMaxBy(arguments []interface{}) (interface{}, error) { intr := arguments[0].(*treeInterpreter) arr := arguments[1].([]interface{}) exp := arguments[2].(expRef) node := exp.ref if len(arr) == 0 { return nil, nil } else if len(arr) == 1 { return arr[0], nil } start, err := intr.Execute(node, arr[0]) if err != nil { return nil, err } switch t := start.(type) { case float64: bestVal := t bestItem := arr[0] for _, item := range arr[1:] { result, err := intr.Execute(node, item) if err != nil { return nil, err } current, ok := result.(float64) if !ok { return nil, errors.New("invalid type, must be number") } if current > bestVal { bestVal = current bestItem = item } } return bestItem, nil case string: bestVal := t bestItem := arr[0] for _, item := range arr[1:] { result, err := intr.Execute(node, item) if err != nil { return nil, err } current, ok := result.(string) if !ok { return nil, errors.New("invalid type, must be string") } if current > bestVal { bestVal = current bestItem = item } } return bestItem, nil default: return nil, errors.New("invalid type, must be number of string") } } func jpfSum(arguments []interface{}) (interface{}, error) { items, _ := toArrayNum(arguments[0]) sum := 0.0 for _, item := range items { sum += item } return sum, nil } func jpfMin(arguments []interface{}) (interface{}, error) { if items, ok := toArrayNum(arguments[0]); ok { if len(items) == 0 { return nil, nil } if len(items) == 1 { return items[0], nil } best := items[0] for _, item := range items[1:] { if item < best { best = item } } return best, nil } items, _ := toArrayStr(arguments[0]) if len(items) == 0 { return nil, nil } if len(items) == 1 { return items[0], nil } best := items[0] for _, item := range items[1:] { if item < best { best = item } } return best, nil } func jpfMinBy(arguments []interface{}) (interface{}, error) { intr := arguments[0].(*treeInterpreter) arr := arguments[1].([]interface{}) exp := arguments[2].(expRef) node := exp.ref if len(arr) == 0 { return nil, nil } else if len(arr) == 1 { return arr[0], nil } start, err := intr.Execute(node, arr[0]) if err != nil { return nil, err } if t, ok := start.(float64); ok { bestVal := t bestItem := arr[0] for _, item := range arr[1:] { result, err := intr.Execute(node, item) if err != nil { return nil, err } current, ok := result.(float64) if !ok { return nil, errors.New("invalid type, must be number") } if current < bestVal { bestVal = current bestItem = item } } return bestItem, nil } else if t, ok := start.(string); ok { bestVal := t bestItem := arr[0] for _, item := range arr[1:] { result, err := intr.Execute(node, item) if err != nil { return nil, err } current, ok := result.(string) if !ok { return nil, errors.New("invalid type, must be string") } if current < bestVal { bestVal = current bestItem = item } } return bestItem, nil } else { return nil, errors.New("invalid type, must be number of string") } } func jpfType(arguments []interface{}) (interface{}, error) { arg := arguments[0] if _, ok := arg.(float64); ok { return "number", nil } if _, ok := arg.(string); ok { return "string", nil } if _, ok := arg.([]interface{}); ok { return "array", nil } if _, ok := arg.(map[string]interface{}); ok { return "object", nil } if arg == nil { return "null", nil } if arg == true || arg == false { return "boolean", nil } return nil, errors.New("unknown type") } func jpfKeys(arguments []interface{}) (interface{}, error) { arg := arguments[0].(map[string]interface{}) collected := make([]interface{}, 0, len(arg)) for key := range arg { collected = append(collected, key) } return collected, nil } func jpfValues(arguments []interface{}) (interface{}, error) { arg := arguments[0].(map[string]interface{}) collected := make([]interface{}, 0, len(arg)) for _, value := range arg { collected = append(collected, value) } return collected, nil } func jpfSort(arguments []interface{}) (interface{}, error) { if items, ok := toArrayNum(arguments[0]); ok { d := sort.Float64Slice(items) sort.Stable(d) final := make([]interface{}, len(d)) for i, val := range d { final[i] = val } return final, nil } // Otherwise we're dealing with sort()'ing strings. items, _ := toArrayStr(arguments[0]) d := sort.StringSlice(items) sort.Stable(d) final := make([]interface{}, len(d)) for i, val := range d { final[i] = val } return final, nil } func jpfSortBy(arguments []interface{}) (interface{}, error) { intr := arguments[0].(*treeInterpreter) arr := arguments[1].([]interface{}) exp := arguments[2].(expRef) node := exp.ref if len(arr) == 0 { return arr, nil } else if len(arr) == 1 { return arr, nil } start, err := intr.Execute(node, arr[0]) if err != nil { return nil, err } if _, ok := start.(float64); ok { sortable := &byExprFloat{intr, node, arr, false} sort.Stable(sortable) if sortable.hasError { return nil, errors.New("error in sort_by comparison") } return arr, nil } else if _, ok := start.(string); ok { sortable := &byExprString{intr, node, arr, false} sort.Stable(sortable) if sortable.hasError { return nil, errors.New("error in sort_by comparison") } return arr, nil } else { return nil, errors.New("invalid type, must be number of string") } } func jpfJoin(arguments []interface{}) (interface{}, error) { sep := arguments[0].(string) // We can't just do arguments[1].([]string), we have to // manually convert each item to a string. arrayStr := []string{} for _, item := range arguments[1].([]interface{}) { arrayStr = append(arrayStr, item.(string)) } return strings.Join(arrayStr, sep), nil } func jpfReverse(arguments []interface{}) (interface{}, error) { if s, ok := arguments[0].(string); ok { r := []rune(s) for i, j := 0, len(r)-1; i < len(r)/2; i, j = i+1, j-1 { r[i], r[j] = r[j], r[i] } return string(r), nil } items := arguments[0].([]interface{}) length := len(items) reversed := make([]interface{}, length) for i, item := range items { reversed[length-(i+1)] = item } return reversed, nil } func jpfToArray(arguments []interface{}) (interface{}, error) { if _, ok := arguments[0].([]interface{}); ok { return arguments[0], nil } return arguments[:1:1], nil } func jpfToString(arguments []interface{}) (interface{}, error) { if v, ok := arguments[0].(string); ok { return v, nil } result, err := json.Marshal(arguments[0]) if err != nil { return nil, err } return string(result), nil } func jpfToNumber(arguments []interface{}) (interface{}, error) { arg := arguments[0] if v, ok := arg.(float64); ok { return v, nil } if v, ok := arg.(string); ok { conv, err := strconv.ParseFloat(v, 64) if err != nil { return nil, nil } return conv, nil } if _, ok := arg.([]interface{}); ok { return nil, nil } if _, ok := arg.(map[string]interface{}); ok { return nil, nil } if arg == nil { return nil, nil } if arg == true || arg == false { return nil, nil } return nil, errors.New("unknown type") } func jpfNotNull(arguments []interface{}) (interface{}, error) { for _, arg := range arguments { if arg != nil { return arg, nil } } return nil, nil } go-jmespath-0.4.0/fuzz/000077500000000000000000000000001373124421700147335ustar00rootroot00000000000000go-jmespath-0.4.0/fuzz/jmespath.go000066400000000000000000000003541373124421700170770ustar00rootroot00000000000000package jmespath import "github.com/jmespath/go-jmespath" // Fuzz will fuzz test the JMESPath parser. func Fuzz(data []byte) int { p := jmespath.NewParser() _, err := p.Parse(string(data)) if err != nil { return 1 } return 0 } go-jmespath-0.4.0/fuzz/testdata/000077500000000000000000000000001373124421700165445ustar00rootroot00000000000000go-jmespath-0.4.0/fuzz/testdata/expr-1000066400000000000000000000000031373124421700175740ustar00rootroot00000000000000foogo-jmespath-0.4.0/fuzz/testdata/expr-10000066400000000000000000000000071373124421700176600ustar00rootroot00000000000000foo.bargo-jmespath-0.4.0/fuzz/testdata/expr-100000066400000000000000000000000261373124421700177410ustar00rootroot00000000000000ends_with(str, 'SStr')go-jmespath-0.4.0/fuzz/testdata/expr-101000066400000000000000000000000251373124421700177410ustar00rootroot00000000000000ends_with(str, 'foo')go-jmespath-0.4.0/fuzz/testdata/expr-102000066400000000000000000000000141373124421700177400ustar00rootroot00000000000000floor(`1.2`)go-jmespath-0.4.0/fuzz/testdata/expr-103000066400000000000000000000000221373124421700177400ustar00rootroot00000000000000floor(decimals[0])go-jmespath-0.4.0/fuzz/testdata/expr-104000066400000000000000000000000121373124421700177400ustar00rootroot00000000000000floor(foo)go-jmespath-0.4.0/fuzz/testdata/expr-105000066400000000000000000000000151373124421700177440ustar00rootroot00000000000000length('abc')go-jmespath-0.4.0/fuzz/testdata/expr-106000066400000000000000000000000121373124421700177420ustar00rootroot00000000000000length('')go-jmespath-0.4.0/fuzz/testdata/expr-107000066400000000000000000000000111373124421700177420ustar00rootroot00000000000000length(@)go-jmespath-0.4.0/fuzz/testdata/expr-108000066400000000000000000000000221373124421700177450ustar00rootroot00000000000000length(strings[0])go-jmespath-0.4.0/fuzz/testdata/expr-109000066400000000000000000000000131373124421700177460ustar00rootroot00000000000000length(str)go-jmespath-0.4.0/fuzz/testdata/expr-110000066400000000000000000000000151373124421700177400ustar00rootroot00000000000000length(array)go-jmespath-0.4.0/fuzz/testdata/expr-112000066400000000000000000000000221373124421700177400ustar00rootroot00000000000000length(strings[0])go-jmespath-0.4.0/fuzz/testdata/expr-115000066400000000000000000000000141373124421700177440ustar00rootroot00000000000000max(strings)go-jmespath-0.4.0/fuzz/testdata/expr-118000066400000000000000000000000131373124421700177460ustar00rootroot00000000000000merge(`{}`)go-jmespath-0.4.0/fuzz/testdata/expr-119000066400000000000000000000000211373124421700177460ustar00rootroot00000000000000merge(`{}`, `{}`)go-jmespath-0.4.0/fuzz/testdata/expr-12000066400000000000000000000000031373124421700176560ustar00rootroot00000000000000twogo-jmespath-0.4.0/fuzz/testdata/expr-120000066400000000000000000000000351373124421700177430ustar00rootroot00000000000000merge(`{"a": 1}`, `{"b": 2}`)go-jmespath-0.4.0/fuzz/testdata/expr-121000066400000000000000000000000351373124421700177440ustar00rootroot00000000000000merge(`{"a": 1}`, `{"a": 2}`)go-jmespath-0.4.0/fuzz/testdata/expr-122000066400000000000000000000000711373124421700177450ustar00rootroot00000000000000merge(`{"a": 1, "b": 2}`, `{"a": 2, "c": 3}`, `{"d": 4}`)go-jmespath-0.4.0/fuzz/testdata/expr-123000066400000000000000000000000141373124421700177430ustar00rootroot00000000000000min(numbers)go-jmespath-0.4.0/fuzz/testdata/expr-126000066400000000000000000000000151373124421700177470ustar00rootroot00000000000000min(decimals)go-jmespath-0.4.0/fuzz/testdata/expr-128000066400000000000000000000000131373124421700177470ustar00rootroot00000000000000type('abc')go-jmespath-0.4.0/fuzz/testdata/expr-129000066400000000000000000000000131373124421700177500ustar00rootroot00000000000000type(`1.0`)go-jmespath-0.4.0/fuzz/testdata/expr-13000066400000000000000000000000051373124421700176610ustar00rootroot00000000000000threego-jmespath-0.4.0/fuzz/testdata/expr-130000066400000000000000000000000111373124421700177360ustar00rootroot00000000000000type(`2`)go-jmespath-0.4.0/fuzz/testdata/expr-131000066400000000000000000000000141373124421700177420ustar00rootroot00000000000000type(`true`)go-jmespath-0.4.0/fuzz/testdata/expr-132000066400000000000000000000000151373124421700177440ustar00rootroot00000000000000type(`false`)go-jmespath-0.4.0/fuzz/testdata/expr-133000066400000000000000000000000141373124421700177440ustar00rootroot00000000000000type(`null`)go-jmespath-0.4.0/fuzz/testdata/expr-134000066400000000000000000000000131373124421700177440ustar00rootroot00000000000000type(`[0]`)go-jmespath-0.4.0/fuzz/testdata/expr-135000066400000000000000000000000221373124421700177450ustar00rootroot00000000000000type(`{"a": "b"}`)go-jmespath-0.4.0/fuzz/testdata/expr-136000066400000000000000000000000071373124421700177510ustar00rootroot00000000000000type(@)go-jmespath-0.4.0/fuzz/testdata/expr-137000066400000000000000000000000151373124421700177510ustar00rootroot00000000000000keys(objects)go-jmespath-0.4.0/fuzz/testdata/expr-138000066400000000000000000000000171373124421700177540ustar00rootroot00000000000000values(objects)go-jmespath-0.4.0/fuzz/testdata/expr-139000066400000000000000000000000201373124421700177470ustar00rootroot00000000000000keys(empty_hash)go-jmespath-0.4.0/fuzz/testdata/expr-14000066400000000000000000000000071373124421700176640ustar00rootroot00000000000000one.twogo-jmespath-0.4.0/fuzz/testdata/expr-140000066400000000000000000000000231373124421700177420ustar00rootroot00000000000000join(', ', strings)go-jmespath-0.4.0/fuzz/testdata/expr-141000066400000000000000000000000231373124421700177430ustar00rootroot00000000000000join(', ', strings)go-jmespath-0.4.0/fuzz/testdata/expr-142000066400000000000000000000000271373124421700177500ustar00rootroot00000000000000join(',', `["a", "b"]`)go-jmespath-0.4.0/fuzz/testdata/expr-143000066400000000000000000000000221373124421700177440ustar00rootroot00000000000000join('|', strings)go-jmespath-0.4.0/fuzz/testdata/expr-144000066400000000000000000000000421373124421700177470ustar00rootroot00000000000000join('|', decimals[].to_string(@))go-jmespath-0.4.0/fuzz/testdata/expr-145000066400000000000000000000000251373124421700177510ustar00rootroot00000000000000join('|', empty_list)go-jmespath-0.4.0/fuzz/testdata/expr-146000066400000000000000000000000201373124421700177450ustar00rootroot00000000000000reverse(numbers)go-jmespath-0.4.0/fuzz/testdata/expr-147000066400000000000000000000000161373124421700177530ustar00rootroot00000000000000reverse(array)go-jmespath-0.4.0/fuzz/testdata/expr-148000066400000000000000000000000151373124421700177530ustar00rootroot00000000000000reverse(`[]`)go-jmespath-0.4.0/fuzz/testdata/expr-149000066400000000000000000000000131373124421700177520ustar00rootroot00000000000000reverse('')go-jmespath-0.4.0/fuzz/testdata/expr-15000066400000000000000000000000071373124421700176650ustar00rootroot00000000000000foo."1"go-jmespath-0.4.0/fuzz/testdata/expr-150000066400000000000000000000000261373124421700177460ustar00rootroot00000000000000reverse('hello world')go-jmespath-0.4.0/fuzz/testdata/expr-151000066400000000000000000000000251373124421700177460ustar00rootroot00000000000000starts_with(str, 'S')go-jmespath-0.4.0/fuzz/testdata/expr-152000066400000000000000000000000261373124421700177500ustar00rootroot00000000000000starts_with(str, 'St')go-jmespath-0.4.0/fuzz/testdata/expr-153000066400000000000000000000000271373124421700177520ustar00rootroot00000000000000starts_with(str, 'Str')go-jmespath-0.4.0/fuzz/testdata/expr-155000066400000000000000000000000141373124421700177500ustar00rootroot00000000000000sum(numbers)go-jmespath-0.4.0/fuzz/testdata/expr-156000066400000000000000000000000151373124421700177520ustar00rootroot00000000000000sum(decimals)go-jmespath-0.4.0/fuzz/testdata/expr-157000066400000000000000000000000311373124421700177510ustar00rootroot00000000000000sum(array[].to_number(@))go-jmespath-0.4.0/fuzz/testdata/expr-158000066400000000000000000000000111373124421700177500ustar00rootroot00000000000000sum(`[]`)go-jmespath-0.4.0/fuzz/testdata/expr-159000066400000000000000000000000171373124421700177570ustar00rootroot00000000000000to_array('foo')go-jmespath-0.4.0/fuzz/testdata/expr-16000066400000000000000000000000121373124421700176620ustar00rootroot00000000000000foo."1"[0]go-jmespath-0.4.0/fuzz/testdata/expr-160000066400000000000000000000000151373124421700177450ustar00rootroot00000000000000to_array(`0`)go-jmespath-0.4.0/fuzz/testdata/expr-161000066400000000000000000000000211373124421700177430ustar00rootroot00000000000000to_array(objects)go-jmespath-0.4.0/fuzz/testdata/expr-162000066400000000000000000000000251373124421700177500ustar00rootroot00000000000000to_array(`[1, 2, 3]`)go-jmespath-0.4.0/fuzz/testdata/expr-163000066400000000000000000000000171373124421700177520ustar00rootroot00000000000000to_array(false)go-jmespath-0.4.0/fuzz/testdata/expr-164000066400000000000000000000000201373124421700177450ustar00rootroot00000000000000to_string('foo')go-jmespath-0.4.0/fuzz/testdata/expr-165000066400000000000000000000000201373124421700177460ustar00rootroot00000000000000to_string(`1.2`)go-jmespath-0.4.0/fuzz/testdata/expr-166000066400000000000000000000000231373124421700177520ustar00rootroot00000000000000to_string(`[0, 1]`)go-jmespath-0.4.0/fuzz/testdata/expr-167000066400000000000000000000000201373124421700177500ustar00rootroot00000000000000to_number('1.0')go-jmespath-0.4.0/fuzz/testdata/expr-168000066400000000000000000000000201373124421700177510ustar00rootroot00000000000000to_number('1.1')go-jmespath-0.4.0/fuzz/testdata/expr-169000066400000000000000000000000161373124421700177570ustar00rootroot00000000000000to_number('4')go-jmespath-0.4.0/fuzz/testdata/expr-17000066400000000000000000000000101373124421700176610ustar00rootroot00000000000000foo."-1"go-jmespath-0.4.0/fuzz/testdata/expr-170000066400000000000000000000000271373124421700177510ustar00rootroot00000000000000to_number('notanumber')go-jmespath-0.4.0/fuzz/testdata/expr-171000066400000000000000000000000221373124421700177450ustar00rootroot00000000000000to_number(`false`)go-jmespath-0.4.0/fuzz/testdata/expr-172000066400000000000000000000000211373124421700177450ustar00rootroot00000000000000to_number(`null`)go-jmespath-0.4.0/fuzz/testdata/expr-173000066400000000000000000000000201373124421700177450ustar00rootroot00000000000000to_number(`[0]`)go-jmespath-0.4.0/fuzz/testdata/expr-174000066400000000000000000000000271373124421700177550ustar00rootroot00000000000000to_number(`{"foo": 0}`)go-jmespath-0.4.0/fuzz/testdata/expr-175000066400000000000000000000000151373124421700177530ustar00rootroot00000000000000sort(numbers)go-jmespath-0.4.0/fuzz/testdata/expr-178000066400000000000000000000000201373124421700177520ustar00rootroot00000000000000sort(empty_list)go-jmespath-0.4.0/fuzz/testdata/expr-179000066400000000000000000000000321373124421700177560ustar00rootroot00000000000000not_null(unknown_key, str)go-jmespath-0.4.0/fuzz/testdata/expr-18000066400000000000000000000000011373124421700176620ustar00rootroot00000000000000@go-jmespath-0.4.0/fuzz/testdata/expr-180000066400000000000000000000000571373124421700177550ustar00rootroot00000000000000not_null(unknown_key, foo.bar, empty_list, str)go-jmespath-0.4.0/fuzz/testdata/expr-181000066400000000000000000000000601373124421700177500ustar00rootroot00000000000000not_null(unknown_key, null_key, empty_list, str)go-jmespath-0.4.0/fuzz/testdata/expr-182000066400000000000000000000000441373124421700177530ustar00rootroot00000000000000not_null(all, expressions, are_null)go-jmespath-0.4.0/fuzz/testdata/expr-183000066400000000000000000000000261373124421700177540ustar00rootroot00000000000000numbers[].to_string(@)go-jmespath-0.4.0/fuzz/testdata/expr-184000066400000000000000000000000241373124421700177530ustar00rootroot00000000000000array[].to_number(@)go-jmespath-0.4.0/fuzz/testdata/expr-185000066400000000000000000000000401373124421700177520ustar00rootroot00000000000000foo[].not_null(f, e, d, c, b, a)go-jmespath-0.4.0/fuzz/testdata/expr-186000066400000000000000000000000251373124421700177560ustar00rootroot00000000000000sort_by(people, &age)go-jmespath-0.4.0/fuzz/testdata/expr-187000066400000000000000000000000441373124421700177600ustar00rootroot00000000000000sort_by(people, &to_number(age_str))go-jmespath-0.4.0/fuzz/testdata/expr-188000066400000000000000000000000341373124421700177600ustar00rootroot00000000000000sort_by(people, &age)[].namego-jmespath-0.4.0/fuzz/testdata/expr-189000066400000000000000000000000351373124421700177620ustar00rootroot00000000000000sort_by(people, &age)[].extrago-jmespath-0.4.0/fuzz/testdata/expr-19000066400000000000000000000000051373124421700176670ustar00rootroot00000000000000@.bargo-jmespath-0.4.0/fuzz/testdata/expr-190000066400000000000000000000000231373124421700177470ustar00rootroot00000000000000sort_by(`[]`, &age)go-jmespath-0.4.0/fuzz/testdata/expr-191000066400000000000000000000000241373124421700177510ustar00rootroot00000000000000max_by(people, &age)go-jmespath-0.4.0/fuzz/testdata/expr-192000066400000000000000000000000301373124421700177470ustar00rootroot00000000000000max_by(people, &age_str)go-jmespath-0.4.0/fuzz/testdata/expr-193000066400000000000000000000000431373124421700177540ustar00rootroot00000000000000max_by(people, &to_number(age_str))go-jmespath-0.4.0/fuzz/testdata/expr-194000066400000000000000000000000241373124421700177540ustar00rootroot00000000000000min_by(people, &age)go-jmespath-0.4.0/fuzz/testdata/expr-195000066400000000000000000000000301373124421700177520ustar00rootroot00000000000000min_by(people, &age_str)go-jmespath-0.4.0/fuzz/testdata/expr-196000066400000000000000000000000431373124421700177570ustar00rootroot00000000000000min_by(people, &to_number(age_str))go-jmespath-0.4.0/fuzz/testdata/expr-198000066400000000000000000000000031373124421700177550ustar00rootroot00000000000000__Lgo-jmespath-0.4.0/fuzz/testdata/expr-199000066400000000000000000000000051373124421700177600ustar00rootroot00000000000000"!\r"go-jmespath-0.4.0/fuzz/testdata/expr-2000066400000000000000000000000071373124421700176010ustar00rootroot00000000000000foo.bargo-jmespath-0.4.0/fuzz/testdata/expr-20000066400000000000000000000000101373124421700176530ustar00rootroot00000000000000@.foo[0]go-jmespath-0.4.0/fuzz/testdata/expr-200000066400000000000000000000000061373124421700177400ustar00rootroot00000000000000Y_1623go-jmespath-0.4.0/fuzz/testdata/expr-201000066400000000000000000000000011373124421700177340ustar00rootroot00000000000000xgo-jmespath-0.4.0/fuzz/testdata/expr-202000066400000000000000000000000131373124421700177400ustar00rootroot00000000000000"\tF\uCebb"go-jmespath-0.4.0/fuzz/testdata/expr-203000066400000000000000000000000051373124421700177420ustar00rootroot00000000000000" \t"go-jmespath-0.4.0/fuzz/testdata/expr-204000066400000000000000000000000031373124421700177410ustar00rootroot00000000000000" "go-jmespath-0.4.0/fuzz/testdata/expr-205000066400000000000000000000000021373124421700177410ustar00rootroot00000000000000v2go-jmespath-0.4.0/fuzz/testdata/expr-206000066400000000000000000000000041373124421700177440ustar00rootroot00000000000000"\t"go-jmespath-0.4.0/fuzz/testdata/expr-207000066400000000000000000000000021373124421700177430ustar00rootroot00000000000000_Xgo-jmespath-0.4.0/fuzz/testdata/expr-208000066400000000000000000000000211373124421700177450ustar00rootroot00000000000000"\t4\ud9da\udd15"go-jmespath-0.4.0/fuzz/testdata/expr-209000066400000000000000000000000051373124421700177500ustar00rootroot00000000000000v24_Wgo-jmespath-0.4.0/fuzz/testdata/expr-21000066400000000000000000000000111373124421700176550ustar00rootroot00000000000000"foo.bar"go-jmespath-0.4.0/fuzz/testdata/expr-210000066400000000000000000000000031373124421700177360ustar00rootroot00000000000000"H"go-jmespath-0.4.0/fuzz/testdata/expr-211000066400000000000000000000000041373124421700177400ustar00rootroot00000000000000"\f"go-jmespath-0.4.0/fuzz/testdata/expr-212000066400000000000000000000000041373124421700177410ustar00rootroot00000000000000"E4"go-jmespath-0.4.0/fuzz/testdata/expr-213000066400000000000000000000000031373124421700177410ustar00rootroot00000000000000"!"go-jmespath-0.4.0/fuzz/testdata/expr-214000066400000000000000000000000021373124421700177410ustar00rootroot00000000000000tMgo-jmespath-0.4.0/fuzz/testdata/expr-215000066400000000000000000000000041373124421700177440ustar00rootroot00000000000000" ["go-jmespath-0.4.0/fuzz/testdata/expr-216000066400000000000000000000000041373124421700177450ustar00rootroot00000000000000"R!"go-jmespath-0.4.0/fuzz/testdata/expr-217000066400000000000000000000000031373124421700177450ustar00rootroot00000000000000_6Wgo-jmespath-0.4.0/fuzz/testdata/expr-218000066400000000000000000000000121373124421700177460ustar00rootroot00000000000000"\uaBA1\r"go-jmespath-0.4.0/fuzz/testdata/expr-219000066400000000000000000000000031373124421700177470ustar00rootroot00000000000000tL7go-jmespath-0.4.0/fuzz/testdata/expr-22000066400000000000000000000000111373124421700176560ustar00rootroot00000000000000"foo bar"go-jmespath-0.4.0/fuzz/testdata/expr-220000066400000000000000000000000071373124421700177430ustar00rootroot00000000000000"<"go-jmespath-0.4.0/fuzz/testdata/expr-257000066400000000000000000000000031373124421700177510ustar00rootroot00000000000000hvugo-jmespath-0.4.0/fuzz/testdata/expr-258000066400000000000000000000000051373124421700177540ustar00rootroot00000000000000"; !"go-jmespath-0.4.0/fuzz/testdata/expr-259000066400000000000000000000000021373124421700177520ustar00rootroot00000000000000hUgo-jmespath-0.4.0/fuzz/testdata/expr-26000066400000000000000000000000141373124421700176650ustar00rootroot00000000000000"/unix/path"go-jmespath-0.4.0/fuzz/testdata/expr-260000066400000000000000000000000101373124421700177410ustar00rootroot00000000000000"!I\n\/"go-jmespath-0.4.0/fuzz/testdata/expr-261000066400000000000000000000000101373124421700177420ustar00rootroot00000000000000"\uEEbF"go-jmespath-0.4.0/fuzz/testdata/expr-262000066400000000000000000000000061373124421700177500ustar00rootroot00000000000000"U)\t"go-jmespath-0.4.0/fuzz/testdata/expr-263000066400000000000000000000000051373124421700177500ustar00rootroot00000000000000fa0_9go-jmespath-0.4.0/fuzz/testdata/expr-264000066400000000000000000000000031373124421700177470ustar00rootroot00000000000000"/"go-jmespath-0.4.0/fuzz/testdata/expr-265000066400000000000000000000000021373124421700177470ustar00rootroot00000000000000Gygo-jmespath-0.4.0/fuzz/testdata/expr-266000066400000000000000000000000041373124421700177520ustar00rootroot00000000000000"\b"go-jmespath-0.4.0/fuzz/testdata/expr-267000066400000000000000000000000031373124421700177520ustar00rootroot00000000000000"<"go-jmespath-0.4.0/fuzz/testdata/expr-268000066400000000000000000000000041373124421700177540ustar00rootroot00000000000000"\t"go-jmespath-0.4.0/fuzz/testdata/expr-269000066400000000000000000000000111373124421700177530ustar00rootroot00000000000000"\t&\\\r"go-jmespath-0.4.0/fuzz/testdata/expr-27000066400000000000000000000000101373124421700176620ustar00rootroot00000000000000"\"\"\""go-jmespath-0.4.0/fuzz/testdata/expr-270000066400000000000000000000000031373124421700177440ustar00rootroot00000000000000"#"go-jmespath-0.4.0/fuzz/testdata/expr-271000066400000000000000000000000031373124421700177450ustar00rootroot00000000000000B__go-jmespath-0.4.0/fuzz/testdata/expr-272000066400000000000000000000000101373124421700177440ustar00rootroot00000000000000"\nS \n"go-jmespath-0.4.0/fuzz/testdata/expr-273000066400000000000000000000000021373124421700177460ustar00rootroot00000000000000Bpgo-jmespath-0.4.0/fuzz/testdata/expr-274000066400000000000000000000000061373124421700177530ustar00rootroot00000000000000",\t;"go-jmespath-0.4.0/fuzz/testdata/expr-275000066400000000000000000000000031373124421700177510ustar00rootroot00000000000000B_qgo-jmespath-0.4.0/fuzz/testdata/expr-276000066400000000000000000000000151373124421700177550ustar00rootroot00000000000000"\/+\t\n\b!Z"go-jmespath-0.4.0/fuzz/testdata/expr-277000066400000000000000000000000151373124421700177560ustar00rootroot00000000000000"󇟇\\ueFAc"go-jmespath-0.4.0/fuzz/testdata/expr-278000066400000000000000000000000051373124421700177560ustar00rootroot00000000000000":\f"go-jmespath-0.4.0/fuzz/testdata/expr-279000066400000000000000000000000041373124421700177560ustar00rootroot00000000000000"\/"go-jmespath-0.4.0/fuzz/testdata/expr-28000066400000000000000000000000131373124421700176660ustar00rootroot00000000000000"bar"."baz"go-jmespath-0.4.0/fuzz/testdata/expr-280000066400000000000000000000000121373124421700177450ustar00rootroot00000000000000_BW_6Hg_Glgo-jmespath-0.4.0/fuzz/testdata/expr-281000066400000000000000000000000061373124421700177510ustar00rootroot00000000000000"􃰂"go-jmespath-0.4.0/fuzz/testdata/expr-282000066400000000000000000000000051373124421700177510ustar00rootroot00000000000000zs1DCgo-jmespath-0.4.0/fuzz/testdata/expr-283000066400000000000000000000000051373124421700177520ustar00rootroot00000000000000__434go-jmespath-0.4.0/fuzz/testdata/expr-284000066400000000000000000000000061373124421700177540ustar00rootroot00000000000000"󵅁"go-jmespath-0.4.0/fuzz/testdata/expr-285000066400000000000000000000000031373124421700177520ustar00rootroot00000000000000Z_5go-jmespath-0.4.0/fuzz/testdata/expr-286000066400000000000000000000000041373124421700177540ustar00rootroot00000000000000z_M_go-jmespath-0.4.0/fuzz/testdata/expr-287000066400000000000000000000000041373124421700177550ustar00rootroot00000000000000YU_2go-jmespath-0.4.0/fuzz/testdata/expr-288000066400000000000000000000000021373124421700177540ustar00rootroot00000000000000_0go-jmespath-0.4.0/fuzz/testdata/expr-289000066400000000000000000000000051373124421700177600ustar00rootroot00000000000000"\b+"go-jmespath-0.4.0/fuzz/testdata/expr-29000066400000000000000000000000211373124421700176660ustar00rootroot00000000000000foo[?name == 'a']go-jmespath-0.4.0/fuzz/testdata/expr-290000066400000000000000000000000041373124421700177470ustar00rootroot00000000000000"\""go-jmespath-0.4.0/fuzz/testdata/expr-291000066400000000000000000000000021373124421700177460ustar00rootroot00000000000000D7go-jmespath-0.4.0/fuzz/testdata/expr-292000066400000000000000000000000041373124421700177510ustar00rootroot00000000000000_62Lgo-jmespath-0.4.0/fuzz/testdata/expr-293000066400000000000000000000000071373124421700177550ustar00rootroot00000000000000"\tK\t"go-jmespath-0.4.0/fuzz/testdata/expr-294000066400000000000000000000000101373124421700177500ustar00rootroot00000000000000"\n\\\f"go-jmespath-0.4.0/fuzz/testdata/expr-295000066400000000000000000000000021373124421700177520ustar00rootroot00000000000000I_go-jmespath-0.4.0/fuzz/testdata/expr-296000066400000000000000000000000051373124421700177560ustar00rootroot00000000000000W_a0_go-jmespath-0.4.0/fuzz/testdata/expr-297000066400000000000000000000000021373124421700177540ustar00rootroot00000000000000BQgo-jmespath-0.4.0/fuzz/testdata/expr-298000066400000000000000000000000141373124421700177600ustar00rootroot00000000000000"\tX$\uABBb"go-jmespath-0.4.0/fuzz/testdata/expr-299000066400000000000000000000000021373124421700177560ustar00rootroot00000000000000Z9go-jmespath-0.4.0/fuzz/testdata/expr-3000066400000000000000000000000131373124421700175770ustar00rootroot00000000000000foo.bar.bazgo-jmespath-0.4.0/fuzz/testdata/expr-30000066400000000000000000000000161373124421700176620ustar00rootroot00000000000000*[?[0] == `0`]go-jmespath-0.4.0/fuzz/testdata/expr-300000066400000000000000000000000131373124421700177370ustar00rootroot00000000000000"\b%\"򞄏"go-jmespath-0.4.0/fuzz/testdata/expr-301000066400000000000000000000000021373124421700177360ustar00rootroot00000000000000_Fgo-jmespath-0.4.0/fuzz/testdata/expr-302000066400000000000000000000000041373124421700177410ustar00rootroot00000000000000"!,"go-jmespath-0.4.0/fuzz/testdata/expr-303000066400000000000000000000000051373124421700177430ustar00rootroot00000000000000"\"!"go-jmespath-0.4.0/fuzz/testdata/expr-304000066400000000000000000000000021373124421700177410ustar00rootroot00000000000000Hhgo-jmespath-0.4.0/fuzz/testdata/expr-305000066400000000000000000000000031373124421700177430ustar00rootroot00000000000000"&"go-jmespath-0.4.0/fuzz/testdata/expr-306000066400000000000000000000000101373124421700177420ustar00rootroot00000000000000"9\r\\R"go-jmespath-0.4.0/fuzz/testdata/expr-307000066400000000000000000000000031373124421700177450ustar00rootroot00000000000000M_kgo-jmespath-0.4.0/fuzz/testdata/expr-308000066400000000000000000000000171373124421700177530ustar00rootroot00000000000000"!\b\n󑩒\"\""go-jmespath-0.4.0/fuzz/testdata/expr-309000066400000000000000000000000031373124421700177470ustar00rootroot00000000000000"6"go-jmespath-0.4.0/fuzz/testdata/expr-31000066400000000000000000000000231373124421700176610ustar00rootroot00000000000000foo[?first == last]go-jmespath-0.4.0/fuzz/testdata/expr-310000066400000000000000000000000021373124421700177360ustar00rootroot00000000000000_7go-jmespath-0.4.0/fuzz/testdata/expr-311000066400000000000000000000000031373124421700177400ustar00rootroot00000000000000"0"go-jmespath-0.4.0/fuzz/testdata/expr-312000066400000000000000000000000071373124421700177450ustar00rootroot00000000000000"\\8\\"go-jmespath-0.4.0/fuzz/testdata/expr-313000066400000000000000000000000041373124421700177430ustar00rootroot00000000000000b7eogo-jmespath-0.4.0/fuzz/testdata/expr-314000066400000000000000000000000051373124421700177450ustar00rootroot00000000000000xIUo9go-jmespath-0.4.0/fuzz/testdata/expr-315000066400000000000000000000000031373124421700177440ustar00rootroot00000000000000"5"go-jmespath-0.4.0/fuzz/testdata/expr-316000066400000000000000000000000031373124421700177450ustar00rootroot00000000000000"?"go-jmespath-0.4.0/fuzz/testdata/expr-317000066400000000000000000000000021373124421700177450ustar00rootroot00000000000000sUgo-jmespath-0.4.0/fuzz/testdata/expr-318000066400000000000000000000000131373124421700177500ustar00rootroot00000000000000"VH2&H\\\/"go-jmespath-0.4.0/fuzz/testdata/expr-319000066400000000000000000000000021373124421700177470ustar00rootroot00000000000000_Cgo-jmespath-0.4.0/fuzz/testdata/expr-32000066400000000000000000000000311373124421700176610ustar00rootroot00000000000000foo[?first == last].firstgo-jmespath-0.4.0/fuzz/testdata/expr-320000066400000000000000000000000011373124421700177360ustar00rootroot00000000000000_go-jmespath-0.4.0/fuzz/testdata/expr-321000066400000000000000000000000051373124421700177430ustar00rootroot00000000000000"<\t"go-jmespath-0.4.0/fuzz/testdata/expr-322000066400000000000000000000000161373124421700177460ustar00rootroot00000000000000"\uD834\uDD1E"go-jmespath-0.4.0/fuzz/testdata/expr-323000066400000000000000000000000121373124421700177430ustar00rootroot00000000000000foo.bar[0]go-jmespath-0.4.0/fuzz/testdata/expr-324000066400000000000000000000000121373124421700177440ustar00rootroot00000000000000foo.bar[1]go-jmespath-0.4.0/fuzz/testdata/expr-325000066400000000000000000000000121373124421700177450ustar00rootroot00000000000000foo.bar[2]go-jmespath-0.4.0/fuzz/testdata/expr-326000066400000000000000000000000121373124421700177460ustar00rootroot00000000000000foo.bar[3]go-jmespath-0.4.0/fuzz/testdata/expr-327000066400000000000000000000000131373124421700177500ustar00rootroot00000000000000foo.bar[-1]go-jmespath-0.4.0/fuzz/testdata/expr-328000066400000000000000000000000131373124421700177510ustar00rootroot00000000000000foo.bar[-2]go-jmespath-0.4.0/fuzz/testdata/expr-329000066400000000000000000000000131373124421700177520ustar00rootroot00000000000000foo.bar[-3]go-jmespath-0.4.0/fuzz/testdata/expr-33000066400000000000000000000000201373124421700176600ustar00rootroot00000000000000foo[?age > `25`]go-jmespath-0.4.0/fuzz/testdata/expr-330000066400000000000000000000000131373124421700177420ustar00rootroot00000000000000foo.bar[-4]go-jmespath-0.4.0/fuzz/testdata/expr-331000066400000000000000000000000071373124421700177460ustar00rootroot00000000000000foo.bargo-jmespath-0.4.0/fuzz/testdata/expr-332000066400000000000000000000000121373124421700177430ustar00rootroot00000000000000foo[0].bargo-jmespath-0.4.0/fuzz/testdata/expr-333000066400000000000000000000000121373124421700177440ustar00rootroot00000000000000foo[1].bargo-jmespath-0.4.0/fuzz/testdata/expr-334000066400000000000000000000000121373124421700177450ustar00rootroot00000000000000foo[2].bargo-jmespath-0.4.0/fuzz/testdata/expr-335000066400000000000000000000000151373124421700177510ustar00rootroot00000000000000foo[3].notbargo-jmespath-0.4.0/fuzz/testdata/expr-336000066400000000000000000000000121373124421700177470ustar00rootroot00000000000000foo[3].bargo-jmespath-0.4.0/fuzz/testdata/expr-337000066400000000000000000000000061373124421700177530ustar00rootroot00000000000000foo[0]go-jmespath-0.4.0/fuzz/testdata/expr-338000066400000000000000000000000061373124421700177540ustar00rootroot00000000000000foo[1]go-jmespath-0.4.0/fuzz/testdata/expr-339000066400000000000000000000000061373124421700177550ustar00rootroot00000000000000foo[2]go-jmespath-0.4.0/fuzz/testdata/expr-34000066400000000000000000000000211373124421700176620ustar00rootroot00000000000000foo[?age >= `25`]go-jmespath-0.4.0/fuzz/testdata/expr-340000066400000000000000000000000061373124421700177450ustar00rootroot00000000000000foo[3]go-jmespath-0.4.0/fuzz/testdata/expr-341000066400000000000000000000000061373124421700177460ustar00rootroot00000000000000foo[4]go-jmespath-0.4.0/fuzz/testdata/expr-342000066400000000000000000000000031373124421700177440ustar00rootroot00000000000000[0]go-jmespath-0.4.0/fuzz/testdata/expr-343000066400000000000000000000000031373124421700177450ustar00rootroot00000000000000[1]go-jmespath-0.4.0/fuzz/testdata/expr-344000066400000000000000000000000031373124421700177460ustar00rootroot00000000000000[2]go-jmespath-0.4.0/fuzz/testdata/expr-345000066400000000000000000000000041373124421700177500ustar00rootroot00000000000000[-1]go-jmespath-0.4.0/fuzz/testdata/expr-346000066400000000000000000000000041373124421700177510ustar00rootroot00000000000000[-2]go-jmespath-0.4.0/fuzz/testdata/expr-347000066400000000000000000000000041373124421700177520ustar00rootroot00000000000000[-3]go-jmespath-0.4.0/fuzz/testdata/expr-348000066400000000000000000000000361373124421700177600ustar00rootroot00000000000000reservations[].instances[].foogo-jmespath-0.4.0/fuzz/testdata/expr-349000066400000000000000000000000361373124421700177610ustar00rootroot00000000000000reservations[].instances[].bargo-jmespath-0.4.0/fuzz/testdata/expr-35000066400000000000000000000000201373124421700176620ustar00rootroot00000000000000foo[?age > `30`]go-jmespath-0.4.0/fuzz/testdata/expr-350000066400000000000000000000000411373124421700177450ustar00rootroot00000000000000reservations[].notinstances[].foogo-jmespath-0.4.0/fuzz/testdata/expr-351000066400000000000000000000000411373124421700177460ustar00rootroot00000000000000reservations[].notinstances[].foogo-jmespath-0.4.0/fuzz/testdata/expr-352000066400000000000000000000000441373124421700177520ustar00rootroot00000000000000reservations[].instances[].foo[].bargo-jmespath-0.4.0/fuzz/testdata/expr-353000066400000000000000000000000441373124421700177530ustar00rootroot00000000000000reservations[].instances[].foo[].bazgo-jmespath-0.4.0/fuzz/testdata/expr-354000066400000000000000000000000471373124421700177570ustar00rootroot00000000000000reservations[].instances[].notfoo[].bargo-jmespath-0.4.0/fuzz/testdata/expr-355000066400000000000000000000000521373124421700177540ustar00rootroot00000000000000reservations[].instances[].notfoo[].notbargo-jmespath-0.4.0/fuzz/testdata/expr-356000066400000000000000000000000411373124421700177530ustar00rootroot00000000000000reservations[].notinstances[].foogo-jmespath-0.4.0/fuzz/testdata/expr-357000066400000000000000000000000471373124421700177620ustar00rootroot00000000000000reservations[].instances[].foo[].notbargo-jmespath-0.4.0/fuzz/testdata/expr-358000066400000000000000000000000441373124421700177600ustar00rootroot00000000000000reservations[].instances[].bar[].bazgo-jmespath-0.4.0/fuzz/testdata/expr-359000066400000000000000000000000441373124421700177610ustar00rootroot00000000000000reservations[].instances[].baz[].bazgo-jmespath-0.4.0/fuzz/testdata/expr-36000066400000000000000000000000201373124421700176630ustar00rootroot00000000000000foo[?age < `25`]go-jmespath-0.4.0/fuzz/testdata/expr-360000066400000000000000000000000441373124421700177510ustar00rootroot00000000000000reservations[].instances[].qux[].bazgo-jmespath-0.4.0/fuzz/testdata/expr-361000066400000000000000000000000461373124421700177540ustar00rootroot00000000000000reservations[].instances[].qux[].baz[]go-jmespath-0.4.0/fuzz/testdata/expr-362000066400000000000000000000000051373124421700177500ustar00rootroot00000000000000foo[]go-jmespath-0.4.0/fuzz/testdata/expr-363000066400000000000000000000000101373124421700177450ustar00rootroot00000000000000foo[][0]go-jmespath-0.4.0/fuzz/testdata/expr-364000066400000000000000000000000101373124421700177460ustar00rootroot00000000000000foo[][1]go-jmespath-0.4.0/fuzz/testdata/expr-365000066400000000000000000000000131373124421700177520ustar00rootroot00000000000000foo[][0][0]go-jmespath-0.4.0/fuzz/testdata/expr-366000066400000000000000000000000131373124421700177530ustar00rootroot00000000000000foo[][2][2]go-jmespath-0.4.0/fuzz/testdata/expr-367000066400000000000000000000000201373124421700177520ustar00rootroot00000000000000foo[][0][0][100]go-jmespath-0.4.0/fuzz/testdata/expr-368000066400000000000000000000000031373124421700177540ustar00rootroot00000000000000foogo-jmespath-0.4.0/fuzz/testdata/expr-369000066400000000000000000000000051373124421700177570ustar00rootroot00000000000000foo[]go-jmespath-0.4.0/fuzz/testdata/expr-37000066400000000000000000000000211373124421700176650ustar00rootroot00000000000000foo[?age <= `25`]go-jmespath-0.4.0/fuzz/testdata/expr-370000066400000000000000000000000111373124421700177440ustar00rootroot00000000000000foo[].bargo-jmespath-0.4.0/fuzz/testdata/expr-371000066400000000000000000000000131373124421700177470ustar00rootroot00000000000000foo[].bar[]go-jmespath-0.4.0/fuzz/testdata/expr-372000066400000000000000000000000171373124421700177540ustar00rootroot00000000000000foo[].bar[].bazgo-jmespath-0.4.0/fuzz/testdata/expr-373000066400000000000000000000000101373124421700177460ustar00rootroot00000000000000string[]go-jmespath-0.4.0/fuzz/testdata/expr-374000066400000000000000000000000061373124421700177540ustar00rootroot00000000000000hash[]go-jmespath-0.4.0/fuzz/testdata/expr-375000066400000000000000000000000101373124421700177500ustar00rootroot00000000000000number[]go-jmespath-0.4.0/fuzz/testdata/expr-376000066400000000000000000000000131373124421700177540ustar00rootroot00000000000000nullvalue[]go-jmespath-0.4.0/fuzz/testdata/expr-377000066400000000000000000000000141373124421700177560ustar00rootroot00000000000000string[].foogo-jmespath-0.4.0/fuzz/testdata/expr-378000066400000000000000000000000121373124421700177550ustar00rootroot00000000000000hash[].foogo-jmespath-0.4.0/fuzz/testdata/expr-379000066400000000000000000000000141373124421700177600ustar00rootroot00000000000000number[].foogo-jmespath-0.4.0/fuzz/testdata/expr-38000066400000000000000000000000201373124421700176650ustar00rootroot00000000000000foo[?age < `20`]go-jmespath-0.4.0/fuzz/testdata/expr-380000066400000000000000000000000171373124421700177530ustar00rootroot00000000000000nullvalue[].foogo-jmespath-0.4.0/fuzz/testdata/expr-381000066400000000000000000000000251373124421700177530ustar00rootroot00000000000000nullvalue[].foo[].bargo-jmespath-0.4.0/fuzz/testdata/expr-382000066400000000000000000000000071373124421700177540ustar00rootroot00000000000000`"foo"`go-jmespath-0.4.0/fuzz/testdata/expr-383000066400000000000000000000000121373124421700177510ustar00rootroot00000000000000`"\u03a6"`go-jmespath-0.4.0/fuzz/testdata/expr-384000066400000000000000000000000071373124421700177560ustar00rootroot00000000000000`"✓"`go-jmespath-0.4.0/fuzz/testdata/expr-385000066400000000000000000000000131373124421700177540ustar00rootroot00000000000000`[1, 2, 3]`go-jmespath-0.4.0/fuzz/testdata/expr-386000066400000000000000000000000141373124421700177560ustar00rootroot00000000000000`{"a": "b"}`go-jmespath-0.4.0/fuzz/testdata/expr-387000066400000000000000000000000061373124421700177600ustar00rootroot00000000000000`true`go-jmespath-0.4.0/fuzz/testdata/expr-388000066400000000000000000000000071373124421700177620ustar00rootroot00000000000000`false`go-jmespath-0.4.0/fuzz/testdata/expr-389000066400000000000000000000000061373124421700177620ustar00rootroot00000000000000`null`go-jmespath-0.4.0/fuzz/testdata/expr-39000066400000000000000000000000211373124421700176670ustar00rootroot00000000000000foo[?age == `20`]go-jmespath-0.4.0/fuzz/testdata/expr-390000066400000000000000000000000031373124421700177470ustar00rootroot00000000000000`0`go-jmespath-0.4.0/fuzz/testdata/expr-391000066400000000000000000000000031373124421700177500ustar00rootroot00000000000000`1`go-jmespath-0.4.0/fuzz/testdata/expr-392000066400000000000000000000000031373124421700177510ustar00rootroot00000000000000`2`go-jmespath-0.4.0/fuzz/testdata/expr-393000066400000000000000000000000031373124421700177520ustar00rootroot00000000000000`3`go-jmespath-0.4.0/fuzz/testdata/expr-394000066400000000000000000000000031373124421700177530ustar00rootroot00000000000000`4`go-jmespath-0.4.0/fuzz/testdata/expr-395000066400000000000000000000000031373124421700177540ustar00rootroot00000000000000`5`go-jmespath-0.4.0/fuzz/testdata/expr-396000066400000000000000000000000031373124421700177550ustar00rootroot00000000000000`6`go-jmespath-0.4.0/fuzz/testdata/expr-397000066400000000000000000000000031373124421700177560ustar00rootroot00000000000000`7`go-jmespath-0.4.0/fuzz/testdata/expr-398000066400000000000000000000000031373124421700177570ustar00rootroot00000000000000`8`go-jmespath-0.4.0/fuzz/testdata/expr-399000066400000000000000000000000031373124421700177600ustar00rootroot00000000000000`9`go-jmespath-0.4.0/fuzz/testdata/expr-4000066400000000000000000000000171373124421700176040ustar00rootroot00000000000000foo.bar.baz.badgo-jmespath-0.4.0/fuzz/testdata/expr-40000066400000000000000000000000211373124421700176570ustar00rootroot00000000000000foo[?age != `20`]go-jmespath-0.4.0/fuzz/testdata/expr-400000066400000000000000000000000141373124421700177410ustar00rootroot00000000000000`"foo\`bar"`go-jmespath-0.4.0/fuzz/testdata/expr-401000066400000000000000000000000141373124421700177420ustar00rootroot00000000000000`"foo\"bar"`go-jmespath-0.4.0/fuzz/testdata/expr-402000066400000000000000000000000071373124421700177450ustar00rootroot00000000000000`"1\`"`go-jmespath-0.4.0/fuzz/testdata/expr-403000066400000000000000000000000201373124421700177410ustar00rootroot00000000000000`"\\"`.{a:`"b"`}go-jmespath-0.4.0/fuzz/testdata/expr-404000066400000000000000000000000161373124421700177470ustar00rootroot00000000000000`{"a": "b"}`.ago-jmespath-0.4.0/fuzz/testdata/expr-405000066400000000000000000000000271373124421700177520ustar00rootroot00000000000000`{"a": {"b": "c"}}`.a.bgo-jmespath-0.4.0/fuzz/testdata/expr-406000066400000000000000000000000161373124421700177510ustar00rootroot00000000000000`[0, 1, 2]`[1]go-jmespath-0.4.0/fuzz/testdata/expr-407000066400000000000000000000000211373124421700177460ustar00rootroot00000000000000` {"foo": true}`go-jmespath-0.4.0/fuzz/testdata/expr-408000066400000000000000000000000221373124421700177500ustar00rootroot00000000000000`{"foo": true} `go-jmespath-0.4.0/fuzz/testdata/expr-409000066400000000000000000000000051373124421700177520ustar00rootroot00000000000000'foo'go-jmespath-0.4.0/fuzz/testdata/expr-41000066400000000000000000000000251373124421700176640ustar00rootroot00000000000000foo[?top.name == 'a']go-jmespath-0.4.0/fuzz/testdata/expr-410000066400000000000000000000000111373124421700177370ustar00rootroot00000000000000' foo 'go-jmespath-0.4.0/fuzz/testdata/expr-411000066400000000000000000000000031373124421700177410ustar00rootroot00000000000000'0'go-jmespath-0.4.0/fuzz/testdata/expr-412000066400000000000000000000000121373124421700177420ustar00rootroot00000000000000'newline 'go-jmespath-0.4.0/fuzz/testdata/expr-413000066400000000000000000000000031373124421700177430ustar00rootroot00000000000000' 'go-jmespath-0.4.0/fuzz/testdata/expr-414000066400000000000000000000000051373124421700177460ustar00rootroot00000000000000'✓'go-jmespath-0.4.0/fuzz/testdata/expr-415000066400000000000000000000000061373124421700177500ustar00rootroot00000000000000'𝄞'go-jmespath-0.4.0/fuzz/testdata/expr-416000066400000000000000000000000131373124421700177470ustar00rootroot00000000000000' [foo] 'go-jmespath-0.4.0/fuzz/testdata/expr-417000066400000000000000000000000071373124421700177530ustar00rootroot00000000000000'[foo]'go-jmespath-0.4.0/fuzz/testdata/expr-418000066400000000000000000000000101373124421700177460ustar00rootroot00000000000000'\u03a6'go-jmespath-0.4.0/fuzz/testdata/expr-419000066400000000000000000000000161373124421700177550ustar00rootroot00000000000000foo.{bar: bar}go-jmespath-0.4.0/fuzz/testdata/expr-42000066400000000000000000000000331373124421700176640ustar00rootroot00000000000000foo[?top.first == top.last]go-jmespath-0.4.0/fuzz/testdata/expr-420000066400000000000000000000000201373124421700177400ustar00rootroot00000000000000foo.{"bar": bar}go-jmespath-0.4.0/fuzz/testdata/expr-421000066400000000000000000000000241373124421700177450ustar00rootroot00000000000000foo.{"foo.bar": bar}go-jmespath-0.4.0/fuzz/testdata/expr-422000066400000000000000000000000301373124421700177430ustar00rootroot00000000000000foo.{bar: bar, baz: baz}go-jmespath-0.4.0/fuzz/testdata/expr-423000066400000000000000000000000341373124421700177500ustar00rootroot00000000000000foo.{"bar": bar, "baz": baz}go-jmespath-0.4.0/fuzz/testdata/expr-424000066400000000000000000000000361373124421700177530ustar00rootroot00000000000000{"baz": baz, "qux\"": "qux\""}go-jmespath-0.4.0/fuzz/testdata/expr-425000066400000000000000000000000251373124421700177520ustar00rootroot00000000000000foo.{bar:bar,baz:baz}go-jmespath-0.4.0/fuzz/testdata/expr-426000066400000000000000000000000271373124421700177550ustar00rootroot00000000000000foo.{bar: bar,qux: qux}go-jmespath-0.4.0/fuzz/testdata/expr-427000066400000000000000000000000401373124421700177510ustar00rootroot00000000000000foo.{bar: bar, noexist: noexist}go-jmespath-0.4.0/fuzz/testdata/expr-428000066400000000000000000000000601373124421700177540ustar00rootroot00000000000000foo.{noexist: noexist, alsonoexist: alsonoexist}go-jmespath-0.4.0/fuzz/testdata/expr-429000066400000000000000000000000571373124421700177630ustar00rootroot00000000000000foo.badkey.{nokey: nokey, alsonokey: alsonokey}go-jmespath-0.4.0/fuzz/testdata/expr-43000066400000000000000000000000561373124421700176720ustar00rootroot00000000000000foo[?top == `{"first": "foo", "last": "bar"}`]go-jmespath-0.4.0/fuzz/testdata/expr-430000066400000000000000000000000301373124421700177420ustar00rootroot00000000000000foo.nested.*.{a: a,b: b}go-jmespath-0.4.0/fuzz/testdata/expr-431000066400000000000000000000000501373124421700177450ustar00rootroot00000000000000foo.nested.three.{a: a, cinner: c.inner}go-jmespath-0.4.0/fuzz/testdata/expr-432000066400000000000000000000000531373124421700177510ustar00rootroot00000000000000foo.nested.three.{a: a, c: c.inner.bad.key}go-jmespath-0.4.0/fuzz/testdata/expr-433000066400000000000000000000000461373124421700177540ustar00rootroot00000000000000foo.{a: nested.one.a, b: nested.two.b}go-jmespath-0.4.0/fuzz/testdata/expr-434000066400000000000000000000000241373124421700177510ustar00rootroot00000000000000{bar: bar, baz: baz}go-jmespath-0.4.0/fuzz/testdata/expr-435000066400000000000000000000000121373124421700177470ustar00rootroot00000000000000{bar: bar}go-jmespath-0.4.0/fuzz/testdata/expr-436000066400000000000000000000000171373124421700177550ustar00rootroot00000000000000{otherkey: bar}go-jmespath-0.4.0/fuzz/testdata/expr-437000066400000000000000000000000261373124421700177560ustar00rootroot00000000000000{no: no, exist: exist}go-jmespath-0.4.0/fuzz/testdata/expr-438000066400000000000000000000000111373124421700177510ustar00rootroot00000000000000foo.[bar]go-jmespath-0.4.0/fuzz/testdata/expr-439000066400000000000000000000000151373124421700177560ustar00rootroot00000000000000foo.[bar,baz]go-jmespath-0.4.0/fuzz/testdata/expr-44000066400000000000000000000000231373124421700176650ustar00rootroot00000000000000foo[?key == `true`]go-jmespath-0.4.0/fuzz/testdata/expr-440000066400000000000000000000000151373124421700177460ustar00rootroot00000000000000foo.[bar,qux]go-jmespath-0.4.0/fuzz/testdata/expr-441000066400000000000000000000000211373124421700177440ustar00rootroot00000000000000foo.[bar,noexist]go-jmespath-0.4.0/fuzz/testdata/expr-442000066400000000000000000000000311373124421700177460ustar00rootroot00000000000000foo.[noexist,alsonoexist]go-jmespath-0.4.0/fuzz/testdata/expr-443000066400000000000000000000000251373124421700177520ustar00rootroot00000000000000foo.{bar:bar,baz:baz}go-jmespath-0.4.0/fuzz/testdata/expr-444000066400000000000000000000000201373124421700177460ustar00rootroot00000000000000foo.[bar,baz[0]]go-jmespath-0.4.0/fuzz/testdata/expr-445000066400000000000000000000000201373124421700177470ustar00rootroot00000000000000foo.[bar,baz[1]]go-jmespath-0.4.0/fuzz/testdata/expr-446000066400000000000000000000000201373124421700177500ustar00rootroot00000000000000foo.[bar,baz[2]]go-jmespath-0.4.0/fuzz/testdata/expr-447000066400000000000000000000000201373124421700177510ustar00rootroot00000000000000foo.[bar,baz[3]]go-jmespath-0.4.0/fuzz/testdata/expr-448000066400000000000000000000000231373124421700177550ustar00rootroot00000000000000foo.[bar[0],baz[3]]go-jmespath-0.4.0/fuzz/testdata/expr-449000066400000000000000000000000301373124421700177540ustar00rootroot00000000000000foo.{bar: bar, baz: baz}go-jmespath-0.4.0/fuzz/testdata/expr-45000066400000000000000000000000241373124421700176670ustar00rootroot00000000000000foo[?key == `false`]go-jmespath-0.4.0/fuzz/testdata/expr-450000066400000000000000000000000151373124421700177470ustar00rootroot00000000000000foo.[bar,baz]go-jmespath-0.4.0/fuzz/testdata/expr-451000066400000000000000000000000521373124421700177510ustar00rootroot00000000000000foo.{bar: bar.baz[1],includeme: includeme}go-jmespath-0.4.0/fuzz/testdata/expr-452000066400000000000000000000000711373124421700177530ustar00rootroot00000000000000foo.{"bar.baz.two": bar.baz[1].two, includeme: includeme}go-jmespath-0.4.0/fuzz/testdata/expr-453000066400000000000000000000000421373124421700177520ustar00rootroot00000000000000foo.[includeme, bar.baz[*].common]go-jmespath-0.4.0/fuzz/testdata/expr-454000066400000000000000000000000401373124421700177510ustar00rootroot00000000000000foo.[includeme, bar.baz[*].none]go-jmespath-0.4.0/fuzz/testdata/expr-455000066400000000000000000000000411373124421700177530ustar00rootroot00000000000000foo.[includeme, bar.baz[].common]go-jmespath-0.4.0/fuzz/testdata/expr-456000066400000000000000000000000611373124421700177560ustar00rootroot00000000000000reservations[*].instances[*].{id: id, name: name}go-jmespath-0.4.0/fuzz/testdata/expr-457000066400000000000000000000000571373124421700177640ustar00rootroot00000000000000reservations[].instances[].{id: id, name: name}go-jmespath-0.4.0/fuzz/testdata/expr-458000066400000000000000000000000451373124421700177620ustar00rootroot00000000000000reservations[].instances[].[id, name]go-jmespath-0.4.0/fuzz/testdata/expr-459000066400000000000000000000000031373124421700177550ustar00rootroot00000000000000foogo-jmespath-0.4.0/fuzz/testdata/expr-46000066400000000000000000000000201373124421700176640ustar00rootroot00000000000000foo[?key == `0`]go-jmespath-0.4.0/fuzz/testdata/expr-460000066400000000000000000000000051373124421700177470ustar00rootroot00000000000000foo[]go-jmespath-0.4.0/fuzz/testdata/expr-461000066400000000000000000000000111373124421700177450ustar00rootroot00000000000000foo[].bargo-jmespath-0.4.0/fuzz/testdata/expr-462000066400000000000000000000000131373124421700177500ustar00rootroot00000000000000foo[].bar[]go-jmespath-0.4.0/fuzz/testdata/expr-463000066400000000000000000000000261373124421700177550ustar00rootroot00000000000000foo[].bar[].[baz, qux]go-jmespath-0.4.0/fuzz/testdata/expr-464000066400000000000000000000000211373124421700177510ustar00rootroot00000000000000foo[].bar[].[baz]go-jmespath-0.4.0/fuzz/testdata/expr-465000066400000000000000000000000301373124421700177520ustar00rootroot00000000000000foo[].bar[].[baz, qux][]go-jmespath-0.4.0/fuzz/testdata/expr-466000066400000000000000000000000301373124421700177530ustar00rootroot00000000000000foo.[baz[*].bar, qux[0]]go-jmespath-0.4.0/fuzz/testdata/expr-467000066400000000000000000000000371373124421700177630ustar00rootroot00000000000000foo.[baz[*].[bar, boo], qux[0]]go-jmespath-0.4.0/fuzz/testdata/expr-468000066400000000000000000000000541373124421700177630ustar00rootroot00000000000000foo.[baz[*].not_there || baz[*].bar, qux[0]]go-jmespath-0.4.0/fuzz/testdata/expr-469000066400000000000000000000000071373124421700177620ustar00rootroot00000000000000[[*],*]go-jmespath-0.4.0/fuzz/testdata/expr-47000066400000000000000000000000201373124421700176650ustar00rootroot00000000000000foo[?key == `1`]go-jmespath-0.4.0/fuzz/testdata/expr-470000066400000000000000000000000051373124421700177500ustar00rootroot00000000000000[[*]]go-jmespath-0.4.0/fuzz/testdata/expr-471000066400000000000000000000000261373124421700177540ustar00rootroot00000000000000outer.foo || outer.bargo-jmespath-0.4.0/fuzz/testdata/expr-472000066400000000000000000000000241373124421700177530ustar00rootroot00000000000000outer.foo||outer.bargo-jmespath-0.4.0/fuzz/testdata/expr-473000066400000000000000000000000261373124421700177560ustar00rootroot00000000000000outer.bar || outer.bazgo-jmespath-0.4.0/fuzz/testdata/expr-474000066400000000000000000000000241373124421700177550ustar00rootroot00000000000000outer.bar||outer.bazgo-jmespath-0.4.0/fuzz/testdata/expr-475000066400000000000000000000000261373124421700177600ustar00rootroot00000000000000outer.bad || outer.foogo-jmespath-0.4.0/fuzz/testdata/expr-476000066400000000000000000000000241373124421700177570ustar00rootroot00000000000000outer.bad||outer.foogo-jmespath-0.4.0/fuzz/testdata/expr-477000066400000000000000000000000261373124421700177620ustar00rootroot00000000000000outer.foo || outer.badgo-jmespath-0.4.0/fuzz/testdata/expr-478000066400000000000000000000000241373124421700177610ustar00rootroot00000000000000outer.foo||outer.badgo-jmespath-0.4.0/fuzz/testdata/expr-479000066400000000000000000000000321373124421700177610ustar00rootroot00000000000000outer.bad || outer.alsobadgo-jmespath-0.4.0/fuzz/testdata/expr-48000066400000000000000000000000221373124421700176700ustar00rootroot00000000000000foo[?key == `[0]`]go-jmespath-0.4.0/fuzz/testdata/expr-480000066400000000000000000000000301373124421700177470ustar00rootroot00000000000000outer.bad||outer.alsobadgo-jmespath-0.4.0/fuzz/testdata/expr-481000066400000000000000000000000371373124421700177570ustar00rootroot00000000000000outer.empty_string || outer.foogo-jmespath-0.4.0/fuzz/testdata/expr-482000066400000000000000000000001201373124421700177510ustar00rootroot00000000000000outer.nokey || outer.bool || outer.empty_list || outer.empty_string || outer.foogo-jmespath-0.4.0/fuzz/testdata/expr-483000066400000000000000000000000171373124421700177570ustar00rootroot00000000000000foo.*.baz | [0]go-jmespath-0.4.0/fuzz/testdata/expr-484000066400000000000000000000000171373124421700177600ustar00rootroot00000000000000foo.*.baz | [1]go-jmespath-0.4.0/fuzz/testdata/expr-485000066400000000000000000000000171373124421700177610ustar00rootroot00000000000000foo.*.baz | [2]go-jmespath-0.4.0/fuzz/testdata/expr-486000066400000000000000000000000171373124421700177620ustar00rootroot00000000000000foo.bar.* | [0]go-jmespath-0.4.0/fuzz/testdata/expr-487000066400000000000000000000000221373124421700177570ustar00rootroot00000000000000foo.*.notbaz | [*]go-jmespath-0.4.0/fuzz/testdata/expr-488000066400000000000000000000000111373124421700177560ustar00rootroot00000000000000foo | bargo-jmespath-0.4.0/fuzz/testdata/expr-489000066400000000000000000000000171373124421700177650ustar00rootroot00000000000000foo | bar | bazgo-jmespath-0.4.0/fuzz/testdata/expr-49000066400000000000000000000000331373124421700176730ustar00rootroot00000000000000foo[?key == `{"bar": [0]}`]go-jmespath-0.4.0/fuzz/testdata/expr-490000066400000000000000000000000141373124421700177520ustar00rootroot00000000000000foo|bar| bazgo-jmespath-0.4.0/fuzz/testdata/expr-491000066400000000000000000000000171373124421700177560ustar00rootroot00000000000000not_there | [0]go-jmespath-0.4.0/fuzz/testdata/expr-492000066400000000000000000000000171373124421700177570ustar00rootroot00000000000000not_there | [0]go-jmespath-0.4.0/fuzz/testdata/expr-493000066400000000000000000000000321373124421700177550ustar00rootroot00000000000000[foo.bar, foo.other] | [0]go-jmespath-0.4.0/fuzz/testdata/expr-494000066400000000000000000000000421373124421700177570ustar00rootroot00000000000000{"a": foo.bar, "b": foo.other} | ago-jmespath-0.4.0/fuzz/testdata/expr-495000066400000000000000000000000421373124421700177600ustar00rootroot00000000000000{"a": foo.bar, "b": foo.other} | bgo-jmespath-0.4.0/fuzz/testdata/expr-496000066400000000000000000000000461373124421700177650ustar00rootroot00000000000000{"a": foo.bar, "b": foo.other} | *.bazgo-jmespath-0.4.0/fuzz/testdata/expr-497000066400000000000000000000000301373124421700177570ustar00rootroot00000000000000foo.bam || foo.bar | bazgo-jmespath-0.4.0/fuzz/testdata/expr-498000066400000000000000000000000261373124421700177650ustar00rootroot00000000000000foo | not_there || bargo-jmespath-0.4.0/fuzz/testdata/expr-499000066400000000000000000000000261373124421700177660ustar00rootroot00000000000000foo[*].bar[*] | [0][0]go-jmespath-0.4.0/fuzz/testdata/expr-5000066400000000000000000000000131373124421700176010ustar00rootroot00000000000000foo.bar.badgo-jmespath-0.4.0/fuzz/testdata/expr-50000066400000000000000000000000231373124421700176620ustar00rootroot00000000000000foo[?key == `null`]go-jmespath-0.4.0/fuzz/testdata/expr-500000066400000000000000000000000111373124421700177370ustar00rootroot00000000000000bar[0:10]go-jmespath-0.4.0/fuzz/testdata/expr-501000066400000000000000000000000131373124421700177420ustar00rootroot00000000000000foo[0:10:1]go-jmespath-0.4.0/fuzz/testdata/expr-502000066400000000000000000000000111373124421700177410ustar00rootroot00000000000000foo[0:10]go-jmespath-0.4.0/fuzz/testdata/expr-503000066400000000000000000000000121373124421700177430ustar00rootroot00000000000000foo[0:10:]go-jmespath-0.4.0/fuzz/testdata/expr-504000066400000000000000000000000111373124421700177430ustar00rootroot00000000000000foo[0::1]go-jmespath-0.4.0/fuzz/testdata/expr-505000066400000000000000000000000101373124421700177430ustar00rootroot00000000000000foo[0::]go-jmespath-0.4.0/fuzz/testdata/expr-506000066400000000000000000000000071373124421700177520ustar00rootroot00000000000000foo[0:]go-jmespath-0.4.0/fuzz/testdata/expr-507000066400000000000000000000000121373124421700177470ustar00rootroot00000000000000foo[:10:1]go-jmespath-0.4.0/fuzz/testdata/expr-508000066400000000000000000000000101373124421700177460ustar00rootroot00000000000000foo[::1]go-jmespath-0.4.0/fuzz/testdata/expr-509000066400000000000000000000000111373124421700177500ustar00rootroot00000000000000foo[:10:]go-jmespath-0.4.0/fuzz/testdata/expr-51000066400000000000000000000000221373124421700176620ustar00rootroot00000000000000foo[?key == `[1]`]go-jmespath-0.4.0/fuzz/testdata/expr-510000066400000000000000000000000071373124421700177450ustar00rootroot00000000000000foo[::]go-jmespath-0.4.0/fuzz/testdata/expr-511000066400000000000000000000000061373124421700177450ustar00rootroot00000000000000foo[:]go-jmespath-0.4.0/fuzz/testdata/expr-512000066400000000000000000000000101373124421700177410ustar00rootroot00000000000000foo[1:9]go-jmespath-0.4.0/fuzz/testdata/expr-513000066400000000000000000000000131373124421700177450ustar00rootroot00000000000000foo[0:10:2]go-jmespath-0.4.0/fuzz/testdata/expr-514000066400000000000000000000000071373124421700177510ustar00rootroot00000000000000foo[5:]go-jmespath-0.4.0/fuzz/testdata/expr-515000066400000000000000000000000111373124421700177450ustar00rootroot00000000000000foo[5::2]go-jmespath-0.4.0/fuzz/testdata/expr-516000066400000000000000000000000101373124421700177450ustar00rootroot00000000000000foo[::2]go-jmespath-0.4.0/fuzz/testdata/expr-517000066400000000000000000000000111373124421700177470ustar00rootroot00000000000000foo[::-1]go-jmespath-0.4.0/fuzz/testdata/expr-518000066400000000000000000000000111373124421700177500ustar00rootroot00000000000000foo[1::2]go-jmespath-0.4.0/fuzz/testdata/expr-519000066400000000000000000000000141373124421700177540ustar00rootroot00000000000000foo[10:0:-1]go-jmespath-0.4.0/fuzz/testdata/expr-52000066400000000000000000000000261373124421700176670ustar00rootroot00000000000000foo[?key == `{"a":2}`]go-jmespath-0.4.0/fuzz/testdata/expr-520000066400000000000000000000000141373124421700177440ustar00rootroot00000000000000foo[10:5:-1]go-jmespath-0.4.0/fuzz/testdata/expr-521000066400000000000000000000000131373124421700177440ustar00rootroot00000000000000foo[8:2:-2]go-jmespath-0.4.0/fuzz/testdata/expr-522000066400000000000000000000000111373124421700177430ustar00rootroot00000000000000foo[0:20]go-jmespath-0.4.0/fuzz/testdata/expr-523000066400000000000000000000000161373124421700177510ustar00rootroot00000000000000foo[10:-20:-1]go-jmespath-0.4.0/fuzz/testdata/expr-524000066400000000000000000000000131373124421700177470ustar00rootroot00000000000000foo[10:-20]go-jmespath-0.4.0/fuzz/testdata/expr-525000066400000000000000000000000121373124421700177470ustar00rootroot00000000000000foo[-4:-1]go-jmespath-0.4.0/fuzz/testdata/expr-526000066400000000000000000000000131373124421700177510ustar00rootroot00000000000000foo[:-5:-1]go-jmespath-0.4.0/fuzz/testdata/expr-527000066400000000000000000000000111373124421700177500ustar00rootroot00000000000000foo[:2].ago-jmespath-0.4.0/fuzz/testdata/expr-528000066400000000000000000000000111373124421700177510ustar00rootroot00000000000000foo[:2].bgo-jmespath-0.4.0/fuzz/testdata/expr-529000066400000000000000000000000131373124421700177540ustar00rootroot00000000000000foo[:2].a.bgo-jmespath-0.4.0/fuzz/testdata/expr-53000066400000000000000000000000231373124421700176650ustar00rootroot00000000000000foo[?`true` == key]go-jmespath-0.4.0/fuzz/testdata/expr-530000066400000000000000000000000151373124421700177460ustar00rootroot00000000000000bar[::-1].a.bgo-jmespath-0.4.0/fuzz/testdata/expr-531000066400000000000000000000000131373124421700177450ustar00rootroot00000000000000bar[:2].a.bgo-jmespath-0.4.0/fuzz/testdata/expr-532000066400000000000000000000000111373124421700177440ustar00rootroot00000000000000baz[:2].ago-jmespath-0.4.0/fuzz/testdata/expr-533000066400000000000000000000000031373124421700177460ustar00rootroot00000000000000[:]go-jmespath-0.4.0/fuzz/testdata/expr-534000066400000000000000000000000061373124421700177520ustar00rootroot00000000000000[:2].ago-jmespath-0.4.0/fuzz/testdata/expr-535000066400000000000000000000000101373124421700177460ustar00rootroot00000000000000[::-1].ago-jmespath-0.4.0/fuzz/testdata/expr-536000066400000000000000000000000061373124421700177540ustar00rootroot00000000000000[:2].bgo-jmespath-0.4.0/fuzz/testdata/expr-537000066400000000000000000000000071373124421700177560ustar00rootroot00000000000000foo.bargo-jmespath-0.4.0/fuzz/testdata/expr-538000066400000000000000000000000031373124421700177530ustar00rootroot00000000000000foogo-jmespath-0.4.0/fuzz/testdata/expr-539000066400000000000000000000000011373124421700177520ustar00rootroot00000000000000*go-jmespath-0.4.0/fuzz/testdata/expr-54000066400000000000000000000000241373124421700176670ustar00rootroot00000000000000foo[?`false` == key]go-jmespath-0.4.0/fuzz/testdata/expr-540000066400000000000000000000000031373124421700177440ustar00rootroot00000000000000*.*go-jmespath-0.4.0/fuzz/testdata/expr-541000066400000000000000000000000051373124421700177470ustar00rootroot00000000000000*.foogo-jmespath-0.4.0/fuzz/testdata/expr-542000066400000000000000000000000041373124421700177470ustar00rootroot00000000000000*[0]go-jmespath-0.4.0/fuzz/testdata/expr-543000066400000000000000000000000021373124421700177460ustar00rootroot00000000000000[]go-jmespath-0.4.0/fuzz/testdata/expr-544000066400000000000000000000000031373124421700177500ustar00rootroot00000000000000[0]go-jmespath-0.4.0/fuzz/testdata/expr-545000066400000000000000000000000031373124421700177510ustar00rootroot00000000000000[*]go-jmespath-0.4.0/fuzz/testdata/expr-546000066400000000000000000000000071373124421700177560ustar00rootroot00000000000000*.["0"]go-jmespath-0.4.0/fuzz/testdata/expr-547000066400000000000000000000000071373124421700177570ustar00rootroot00000000000000[*].bargo-jmespath-0.4.0/fuzz/testdata/expr-548000066400000000000000000000000061373124421700177570ustar00rootroot00000000000000[*][0]go-jmespath-0.4.0/fuzz/testdata/expr-549000066400000000000000000000000061373124421700177600ustar00rootroot00000000000000foo[0]go-jmespath-0.4.0/fuzz/testdata/expr-55000066400000000000000000000000201373124421700176640ustar00rootroot00000000000000foo[?`0` == key]go-jmespath-0.4.0/fuzz/testdata/expr-550000066400000000000000000000000071373124421700177510ustar00rootroot00000000000000foo.[*]go-jmespath-0.4.0/fuzz/testdata/expr-551000066400000000000000000000000111373124421700177450ustar00rootroot00000000000000foo.[abc]go-jmespath-0.4.0/fuzz/testdata/expr-552000066400000000000000000000000161373124421700177530ustar00rootroot00000000000000foo.[abc, def]go-jmespath-0.4.0/fuzz/testdata/expr-553000066400000000000000000000000141373124421700177520ustar00rootroot00000000000000a.{foo: bar}go-jmespath-0.4.0/fuzz/testdata/expr-554000066400000000000000000000000261373124421700177560ustar00rootroot00000000000000a.{foo: bar, baz: bam}go-jmespath-0.4.0/fuzz/testdata/expr-555000066400000000000000000000000161373124421700177560ustar00rootroot00000000000000{"\\":{" ":*}}go-jmespath-0.4.0/fuzz/testdata/expr-556000066400000000000000000000000121373124421700177530ustar00rootroot00000000000000foo || bargo-jmespath-0.4.0/fuzz/testdata/expr-557000066400000000000000000000000141373124421700177560ustar00rootroot00000000000000foo.[a || b]go-jmespath-0.4.0/fuzz/testdata/expr-558000066400000000000000000000000221373124421700177560ustar00rootroot00000000000000foo[?bar==`"baz"`]go-jmespath-0.4.0/fuzz/testdata/expr-559000066400000000000000000000000261373124421700177630ustar00rootroot00000000000000foo[? bar == `"baz"` ]go-jmespath-0.4.0/fuzz/testdata/expr-56000066400000000000000000000000201373124421700176650ustar00rootroot00000000000000foo[?`1` == key]go-jmespath-0.4.0/fuzz/testdata/expr-560000066400000000000000000000000221373124421700177470ustar00rootroot00000000000000foo[?a.b.c==d.e.f]go-jmespath-0.4.0/fuzz/testdata/expr-561000066400000000000000000000000261373124421700177540ustar00rootroot00000000000000foo[?bar==`[0, 1, 2]`]go-jmespath-0.4.0/fuzz/testdata/expr-562000066400000000000000000000000341373124421700177540ustar00rootroot00000000000000foo[?bar==`["a", "b", "c"]`]go-jmespath-0.4.0/fuzz/testdata/expr-563000066400000000000000000000000311373124421700177520ustar00rootroot00000000000000foo[?bar==`["foo\`bar"]`]go-jmespath-0.4.0/fuzz/testdata/expr-564000066400000000000000000000000171373124421700177570ustar00rootroot00000000000000[?"\\">`"foo"`]go-jmespath-0.4.0/fuzz/testdata/expr-565000066400000000000000000000000211373124421700177530ustar00rootroot00000000000000[?"\\" > `"foo"`]go-jmespath-0.4.0/fuzz/testdata/expr-566000066400000000000000000000000031373124421700177540ustar00rootroot00000000000000foogo-jmespath-0.4.0/fuzz/testdata/expr-567000066400000000000000000000000051373124421700177570ustar00rootroot00000000000000"foo"go-jmespath-0.4.0/fuzz/testdata/expr-568000066400000000000000000000000041373124421700177570ustar00rootroot00000000000000"\\"go-jmespath-0.4.0/fuzz/testdata/expr-569000066400000000000000000000000101373124421700177550ustar00rootroot00000000000000*||*|*|*go-jmespath-0.4.0/fuzz/testdata/expr-57000066400000000000000000000000221373124421700176700ustar00rootroot00000000000000foo[?`[0]` == key]go-jmespath-0.4.0/fuzz/testdata/expr-570000066400000000000000000000000101373124421700177450ustar00rootroot00000000000000*[]||[*]go-jmespath-0.4.0/fuzz/testdata/expr-571000066400000000000000000000000051373124421700177520ustar00rootroot00000000000000[*.*]go-jmespath-0.4.0/fuzz/testdata/expr-572000066400000000000000000000000131373124421700177520ustar00rootroot00000000000000foo[]."✓"go-jmespath-0.4.0/fuzz/testdata/expr-573000066400000000000000000000000051373124421700177540ustar00rootroot00000000000000"☯"go-jmespath-0.4.0/fuzz/testdata/expr-574000066400000000000000000000000571373124421700177640ustar00rootroot00000000000000"♪♫•*¨*•.¸¸❤¸¸.•*¨*•♫♪"go-jmespath-0.4.0/fuzz/testdata/expr-575000066400000000000000000000000051373124421700177560ustar00rootroot00000000000000"☃"go-jmespath-0.4.0/fuzz/testdata/expr-576000066400000000000000000000000111373124421700177540ustar00rootroot00000000000000foo.*.bazgo-jmespath-0.4.0/fuzz/testdata/expr-577000066400000000000000000000000111373124421700177550ustar00rootroot00000000000000foo.bar.*go-jmespath-0.4.0/fuzz/testdata/expr-578000066400000000000000000000000141373124421700177610ustar00rootroot00000000000000foo.*.notbazgo-jmespath-0.4.0/fuzz/testdata/expr-579000066400000000000000000000000171373124421700177650ustar00rootroot00000000000000foo.*.notbaz[0]go-jmespath-0.4.0/fuzz/testdata/expr-58000066400000000000000000000000331373124421700176730ustar00rootroot00000000000000foo[?`{"bar": [0]}` == key]go-jmespath-0.4.0/fuzz/testdata/expr-580000066400000000000000000000000201373124421700177470ustar00rootroot00000000000000foo.*.notbaz[-1]go-jmespath-0.4.0/fuzz/testdata/expr-581000066400000000000000000000000051373124421700177530ustar00rootroot00000000000000foo.*go-jmespath-0.4.0/fuzz/testdata/expr-582000066400000000000000000000000071373124421700177560ustar00rootroot00000000000000foo.*.*go-jmespath-0.4.0/fuzz/testdata/expr-583000066400000000000000000000000111373124421700177520ustar00rootroot00000000000000foo.*.*.*go-jmespath-0.4.0/fuzz/testdata/expr-584000066400000000000000000000000131373124421700177550ustar00rootroot00000000000000foo.*.*.*.*go-jmespath-0.4.0/fuzz/testdata/expr-585000066400000000000000000000000051373124421700177570ustar00rootroot00000000000000*.bargo-jmespath-0.4.0/fuzz/testdata/expr-586000066400000000000000000000000011373124421700177540ustar00rootroot00000000000000*go-jmespath-0.4.0/fuzz/testdata/expr-587000066400000000000000000000000061373124421700177620ustar00rootroot00000000000000*.sub1go-jmespath-0.4.0/fuzz/testdata/expr-588000066400000000000000000000000031373124421700177600ustar00rootroot00000000000000*.*go-jmespath-0.4.0/fuzz/testdata/expr-589000066400000000000000000000000071373124421700177650ustar00rootroot00000000000000*.*.foogo-jmespath-0.4.0/fuzz/testdata/expr-59000066400000000000000000000000231373124421700176730ustar00rootroot00000000000000foo[?`null` == key]go-jmespath-0.4.0/fuzz/testdata/expr-590000066400000000000000000000000121373124421700177510ustar00rootroot00000000000000*.sub1.foogo-jmespath-0.4.0/fuzz/testdata/expr-591000066400000000000000000000000121373124421700177520ustar00rootroot00000000000000foo[*].bargo-jmespath-0.4.0/fuzz/testdata/expr-592000066400000000000000000000000151373124421700177560ustar00rootroot00000000000000foo[*].notbargo-jmespath-0.4.0/fuzz/testdata/expr-593000066400000000000000000000000031373124421700177540ustar00rootroot00000000000000[*]go-jmespath-0.4.0/fuzz/testdata/expr-594000066400000000000000000000000071373124421700177610ustar00rootroot00000000000000[*].bargo-jmespath-0.4.0/fuzz/testdata/expr-595000066400000000000000000000000121373124421700177560ustar00rootroot00000000000000[*].notbargo-jmespath-0.4.0/fuzz/testdata/expr-596000066400000000000000000000000161373124421700177630ustar00rootroot00000000000000foo.bar[*].bazgo-jmespath-0.4.0/fuzz/testdata/expr-597000066400000000000000000000000211373124421700177600ustar00rootroot00000000000000foo.bar[*].baz[0]go-jmespath-0.4.0/fuzz/testdata/expr-598000066400000000000000000000000211373124421700177610ustar00rootroot00000000000000foo.bar[*].baz[1]go-jmespath-0.4.0/fuzz/testdata/expr-599000066400000000000000000000000211373124421700177620ustar00rootroot00000000000000foo.bar[*].baz[2]go-jmespath-0.4.0/fuzz/testdata/expr-6000066400000000000000000000000071373124421700176050ustar00rootroot00000000000000foo.badgo-jmespath-0.4.0/fuzz/testdata/expr-60000066400000000000000000000000221373124421700176620ustar00rootroot00000000000000foo[?`[1]` == key]go-jmespath-0.4.0/fuzz/testdata/expr-600000066400000000000000000000000211373124421700177410ustar00rootroot00000000000000foo.bar[*].baz[3]go-jmespath-0.4.0/fuzz/testdata/expr-601000066400000000000000000000000121373124421700177420ustar00rootroot00000000000000foo.bar[*]go-jmespath-0.4.0/fuzz/testdata/expr-602000066400000000000000000000000121373124421700177430ustar00rootroot00000000000000foo.bar[0]go-jmespath-0.4.0/fuzz/testdata/expr-603000066400000000000000000000000151373124421700177470ustar00rootroot00000000000000foo.bar[0][0]go-jmespath-0.4.0/fuzz/testdata/expr-604000066400000000000000000000000201373124421700177440ustar00rootroot00000000000000foo.bar[0][0][0]go-jmespath-0.4.0/fuzz/testdata/expr-605000066400000000000000000000000231373124421700177500ustar00rootroot00000000000000foo.bar[0][0][0][0]go-jmespath-0.4.0/fuzz/testdata/expr-606000066400000000000000000000000111373124421700177460ustar00rootroot00000000000000foo[0][0]go-jmespath-0.4.0/fuzz/testdata/expr-607000066400000000000000000000000221373124421700177510ustar00rootroot00000000000000foo[*].bar[*].kindgo-jmespath-0.4.0/fuzz/testdata/expr-608000066400000000000000000000000221373124421700177520ustar00rootroot00000000000000foo[*].bar[0].kindgo-jmespath-0.4.0/fuzz/testdata/expr-609000066400000000000000000000000171373124421700177570ustar00rootroot00000000000000foo[*].bar.kindgo-jmespath-0.4.0/fuzz/testdata/expr-61000066400000000000000000000000261373124421700176670ustar00rootroot00000000000000foo[?`{"a":2}` == key]go-jmespath-0.4.0/fuzz/testdata/expr-610000066400000000000000000000000151373124421700177450ustar00rootroot00000000000000foo[*].bar[0]go-jmespath-0.4.0/fuzz/testdata/expr-611000066400000000000000000000000151373124421700177460ustar00rootroot00000000000000foo[*].bar[1]go-jmespath-0.4.0/fuzz/testdata/expr-612000066400000000000000000000000151373124421700177470ustar00rootroot00000000000000foo[*].bar[2]go-jmespath-0.4.0/fuzz/testdata/expr-613000066400000000000000000000000151373124421700177500ustar00rootroot00000000000000foo[*].bar[0]go-jmespath-0.4.0/fuzz/testdata/expr-614000066400000000000000000000000111373124421700177450ustar00rootroot00000000000000foo[*][0]go-jmespath-0.4.0/fuzz/testdata/expr-615000066400000000000000000000000111373124421700177460ustar00rootroot00000000000000foo[*][1]go-jmespath-0.4.0/fuzz/testdata/expr-616000066400000000000000000000000111373124421700177470ustar00rootroot00000000000000foo[*][0]go-jmespath-0.4.0/fuzz/testdata/expr-617000066400000000000000000000000111373124421700177500ustar00rootroot00000000000000foo[*][1]go-jmespath-0.4.0/fuzz/testdata/expr-618000066400000000000000000000000141373124421700177540ustar00rootroot00000000000000foo[*][0][0]go-jmespath-0.4.0/fuzz/testdata/expr-619000066400000000000000000000000141373124421700177550ustar00rootroot00000000000000foo[*][1][0]go-jmespath-0.4.0/fuzz/testdata/expr-62000066400000000000000000000000231373124421700176650ustar00rootroot00000000000000foo[?key != `true`]go-jmespath-0.4.0/fuzz/testdata/expr-620000066400000000000000000000000141373124421700177450ustar00rootroot00000000000000foo[*][0][1]go-jmespath-0.4.0/fuzz/testdata/expr-621000066400000000000000000000000141373124421700177460ustar00rootroot00000000000000foo[*][1][1]go-jmespath-0.4.0/fuzz/testdata/expr-622000066400000000000000000000000111373124421700177440ustar00rootroot00000000000000foo[*][2]go-jmespath-0.4.0/fuzz/testdata/expr-623000066400000000000000000000000141373124421700177500ustar00rootroot00000000000000foo[*][2][2]go-jmespath-0.4.0/fuzz/testdata/expr-624000066400000000000000000000000061373124421700177520ustar00rootroot00000000000000bar[*]go-jmespath-0.4.0/fuzz/testdata/expr-625000066400000000000000000000000151373124421700177530ustar00rootroot00000000000000bar[*].baz[*]go-jmespath-0.4.0/fuzz/testdata/expr-626000066400000000000000000000000111373124421700177500ustar00rootroot00000000000000string[*]go-jmespath-0.4.0/fuzz/testdata/expr-627000066400000000000000000000000071373124421700177560ustar00rootroot00000000000000hash[*]go-jmespath-0.4.0/fuzz/testdata/expr-628000066400000000000000000000000111373124421700177520ustar00rootroot00000000000000number[*]go-jmespath-0.4.0/fuzz/testdata/expr-629000066400000000000000000000000141373124421700177560ustar00rootroot00000000000000nullvalue[*]go-jmespath-0.4.0/fuzz/testdata/expr-63000066400000000000000000000000241373124421700176670ustar00rootroot00000000000000foo[?key != `false`]go-jmespath-0.4.0/fuzz/testdata/expr-630000066400000000000000000000000151373124421700177470ustar00rootroot00000000000000string[*].foogo-jmespath-0.4.0/fuzz/testdata/expr-631000066400000000000000000000000131373124421700177460ustar00rootroot00000000000000hash[*].foogo-jmespath-0.4.0/fuzz/testdata/expr-632000066400000000000000000000000151373124421700177510ustar00rootroot00000000000000number[*].foogo-jmespath-0.4.0/fuzz/testdata/expr-633000066400000000000000000000000201373124421700177460ustar00rootroot00000000000000nullvalue[*].foogo-jmespath-0.4.0/fuzz/testdata/expr-634000066400000000000000000000000271373124421700177560ustar00rootroot00000000000000nullvalue[*].foo[*].bargo-jmespath-0.4.0/fuzz/testdata/expr-635000066400000000000000000000000101373124421700177470ustar00rootroot00000000000000string.*go-jmespath-0.4.0/fuzz/testdata/expr-636000066400000000000000000000000061373124421700177550ustar00rootroot00000000000000hash.*go-jmespath-0.4.0/fuzz/testdata/expr-637000066400000000000000000000000101373124421700177510ustar00rootroot00000000000000number.*go-jmespath-0.4.0/fuzz/testdata/expr-638000066400000000000000000000000071373124421700177600ustar00rootroot00000000000000array.*go-jmespath-0.4.0/fuzz/testdata/expr-639000066400000000000000000000000131373124421700177560ustar00rootroot00000000000000nullvalue.*go-jmespath-0.4.0/fuzz/testdata/expr-64000066400000000000000000000000201373124421700176640ustar00rootroot00000000000000foo[?key != `0`]go-jmespath-0.4.0/fuzz/testdata/expr-640000066400000000000000000000000041373124421700177460ustar00rootroot00000000000000*[0]go-jmespath-0.4.0/fuzz/testdata/expr-641000066400000000000000000000000051373124421700177500ustar00rootroot00000000000000`foo`go-jmespath-0.4.0/fuzz/testdata/expr-642000066400000000000000000000000141373124421700177510ustar00rootroot00000000000000`foo\"quote`go-jmespath-0.4.0/fuzz/testdata/expr-643000066400000000000000000000000051373124421700177520ustar00rootroot00000000000000`✓`go-jmespath-0.4.0/fuzz/testdata/expr-644000066400000000000000000000000121373124421700177510ustar00rootroot00000000000000`foo\"bar`go-jmespath-0.4.0/fuzz/testdata/expr-645000066400000000000000000000000051373124421700177540ustar00rootroot00000000000000`1\``go-jmespath-0.4.0/fuzz/testdata/expr-646000066400000000000000000000000141373124421700177550ustar00rootroot00000000000000`\\`.{a:`b`}go-jmespath-0.4.0/fuzz/testdata/expr-647000066400000000000000000000000051373124421700177560ustar00rootroot00000000000000`foo`go-jmespath-0.4.0/fuzz/testdata/expr-648000066400000000000000000000000131373124421700177560ustar00rootroot00000000000000` foo`go-jmespath-0.4.0/fuzz/testdata/expr-649000066400000000000000000000000051373124421700177600ustar00rootroot00000000000000`foo`go-jmespath-0.4.0/fuzz/testdata/expr-65000066400000000000000000000000201373124421700176650ustar00rootroot00000000000000foo[?key != `1`]go-jmespath-0.4.0/fuzz/testdata/expr-650000066400000000000000000000000141373124421700177500ustar00rootroot00000000000000`foo\"quote`go-jmespath-0.4.0/fuzz/testdata/expr-651000066400000000000000000000000051373124421700177510ustar00rootroot00000000000000`✓`go-jmespath-0.4.0/fuzz/testdata/expr-652000066400000000000000000000000121373124421700177500ustar00rootroot00000000000000`foo\"bar`go-jmespath-0.4.0/fuzz/testdata/expr-653000066400000000000000000000000051373124421700177530ustar00rootroot00000000000000`1\``go-jmespath-0.4.0/fuzz/testdata/expr-654000066400000000000000000000000141373124421700177540ustar00rootroot00000000000000`\\`.{a:`b`}go-jmespath-0.4.0/fuzz/testdata/expr-655000066400000000000000000000000051373124421700177550ustar00rootroot00000000000000`foo`go-jmespath-0.4.0/fuzz/testdata/expr-656000066400000000000000000000000131373124421700177550ustar00rootroot00000000000000` foo`go-jmespath-0.4.0/fuzz/testdata/expr-66000066400000000000000000000000231373124421700176710ustar00rootroot00000000000000foo[?key != `null`]go-jmespath-0.4.0/fuzz/testdata/expr-67000066400000000000000000000000221373124421700176710ustar00rootroot00000000000000foo[?key != `[1]`]go-jmespath-0.4.0/fuzz/testdata/expr-68000066400000000000000000000000261373124421700176760ustar00rootroot00000000000000foo[?key != `{"a":2}`]go-jmespath-0.4.0/fuzz/testdata/expr-69000066400000000000000000000000231373124421700176740ustar00rootroot00000000000000foo[?`true` != key]go-jmespath-0.4.0/fuzz/testdata/expr-7000066400000000000000000000000031373124421700176020ustar00rootroot00000000000000badgo-jmespath-0.4.0/fuzz/testdata/expr-70000066400000000000000000000000241373124421700176650ustar00rootroot00000000000000foo[?`false` != key]go-jmespath-0.4.0/fuzz/testdata/expr-71000066400000000000000000000000201373124421700176620ustar00rootroot00000000000000foo[?`0` != key]go-jmespath-0.4.0/fuzz/testdata/expr-72000066400000000000000000000000201373124421700176630ustar00rootroot00000000000000foo[?`1` != key]go-jmespath-0.4.0/fuzz/testdata/expr-73000066400000000000000000000000231373124421700176670ustar00rootroot00000000000000foo[?`null` != key]go-jmespath-0.4.0/fuzz/testdata/expr-74000066400000000000000000000000221373124421700176670ustar00rootroot00000000000000foo[?`[1]` != key]go-jmespath-0.4.0/fuzz/testdata/expr-75000066400000000000000000000000261373124421700176740ustar00rootroot00000000000000foo[?`{"a":2}` != key]go-jmespath-0.4.0/fuzz/testdata/expr-76000066400000000000000000000000431373124421700176740ustar00rootroot00000000000000reservations[].instances[?bar==`1`]go-jmespath-0.4.0/fuzz/testdata/expr-77000066400000000000000000000000441373124421700176760ustar00rootroot00000000000000reservations[*].instances[?bar==`1`]go-jmespath-0.4.0/fuzz/testdata/expr-78000066400000000000000000000000451373124421700177000ustar00rootroot00000000000000reservations[].instances[?bar==`1`][]go-jmespath-0.4.0/fuzz/testdata/expr-79000066400000000000000000000000251373124421700176770ustar00rootroot00000000000000foo[?bar==`1`].bar[0]go-jmespath-0.4.0/fuzz/testdata/expr-8000066400000000000000000000000231373124421700176050ustar00rootroot00000000000000bad.morebad.morebadgo-jmespath-0.4.0/fuzz/testdata/expr-80000066400000000000000000000000201373124421700176620ustar00rootroot00000000000000foo[?a==`1`].b.cgo-jmespath-0.4.0/fuzz/testdata/expr-81000066400000000000000000000000101373124421700176620ustar00rootroot00000000000000abs(foo)go-jmespath-0.4.0/fuzz/testdata/expr-82000066400000000000000000000000101373124421700176630ustar00rootroot00000000000000abs(foo)go-jmespath-0.4.0/fuzz/testdata/expr-83000066400000000000000000000000151373124421700176710ustar00rootroot00000000000000abs(array[1])go-jmespath-0.4.0/fuzz/testdata/expr-84000066400000000000000000000000151373124421700176720ustar00rootroot00000000000000abs(array[1])go-jmespath-0.4.0/fuzz/testdata/expr-85000066400000000000000000000000121373124421700176700ustar00rootroot00000000000000abs(`-24`)go-jmespath-0.4.0/fuzz/testdata/expr-86000066400000000000000000000000121373124421700176710ustar00rootroot00000000000000abs(`-24`)go-jmespath-0.4.0/fuzz/testdata/expr-87000066400000000000000000000000141373124421700176740ustar00rootroot00000000000000avg(numbers)go-jmespath-0.4.0/fuzz/testdata/expr-88000066400000000000000000000000131373124421700176740ustar00rootroot00000000000000ceil(`1.2`)go-jmespath-0.4.0/fuzz/testdata/expr-89000066400000000000000000000000211373124421700176740ustar00rootroot00000000000000ceil(decimals[0])go-jmespath-0.4.0/fuzz/testdata/expr-9000066400000000000000000000000031373124421700176040ustar00rootroot00000000000000foogo-jmespath-0.4.0/fuzz/testdata/expr-90000066400000000000000000000000211373124421700176640ustar00rootroot00000000000000ceil(decimals[1])go-jmespath-0.4.0/fuzz/testdata/expr-91000066400000000000000000000000211373124421700176650ustar00rootroot00000000000000ceil(decimals[2])go-jmespath-0.4.0/fuzz/testdata/expr-92000066400000000000000000000000241373124421700176710ustar00rootroot00000000000000contains('abc', 'a')go-jmespath-0.4.0/fuzz/testdata/expr-93000066400000000000000000000000241373124421700176720ustar00rootroot00000000000000contains('abc', 'd')go-jmespath-0.4.0/fuzz/testdata/expr-94000066400000000000000000000000261373124421700176750ustar00rootroot00000000000000contains(strings, 'a')go-jmespath-0.4.0/fuzz/testdata/expr-95000066400000000000000000000000311373124421700176720ustar00rootroot00000000000000contains(decimals, `1.2`)go-jmespath-0.4.0/fuzz/testdata/expr-96000066400000000000000000000000331373124421700176750ustar00rootroot00000000000000contains(decimals, `false`)go-jmespath-0.4.0/fuzz/testdata/expr-97000066400000000000000000000000231373124421700176750ustar00rootroot00000000000000ends_with(str, 'r')go-jmespath-0.4.0/fuzz/testdata/expr-98000066400000000000000000000000241373124421700176770ustar00rootroot00000000000000ends_with(str, 'tr')go-jmespath-0.4.0/go.mod000066400000000000000000000001611373124421700150410ustar00rootroot00000000000000module github.com/jmespath/go-jmespath go 1.14 require github.com/jmespath/go-jmespath/internal/testify v1.5.1 go-jmespath-0.4.0/go.sum000066400000000000000000000017621373124421700150760ustar00rootroot00000000000000github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/jmespath/go-jmespath/internal/testify v1.5.1 h1:shLQSRRSCCPj3f2gpwzGwWFoC7ycTf1rcQZHOlsJ6N8= github.com/jmespath/go-jmespath/internal/testify v1.5.1/go.mod h1:L3OGu8Wl2/fWfCI6z80xFu9LTZmf1ZRjMHUOPmWr69U= github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= gopkg.in/yaml.v2 v2.2.8 h1:obN1ZagJSUGI0Ek/LBmuj4SNLPfIny3KsKFopxRdj10= gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= go-jmespath-0.4.0/internal/000077500000000000000000000000001373124421700155515ustar00rootroot00000000000000go-jmespath-0.4.0/internal/testify/000077500000000000000000000000001373124421700172405ustar00rootroot00000000000000go-jmespath-0.4.0/internal/testify/.gitignore000066400000000000000000000004071373124421700212310ustar00rootroot00000000000000# Compiled Object files, Static and Dynamic libs (Shared Objects) *.o *.a *.so # Folders _obj _test # Architecture specific extensions/prefixes *.[568vq] [568vq].out *.cgo1.go *.cgo2.c _cgo_defun.c _cgo_gotypes.go _cgo_export.* _testmain.go *.exe .DS_Store go-jmespath-0.4.0/internal/testify/.travis.gofmt.sh000077500000000000000000000004261373124421700223020ustar00rootroot00000000000000#!/bin/bash if [ -n "$(gofmt -l .)" ]; then echo "Go code is not formatted:" gofmt -d . exit 1 fi go generate ./... if [ -n "$(git status -s -uno)" ]; then echo "Go generate output does not match commit." echo "Did you forget to run go generate ./... ?" exit 1 fi go-jmespath-0.4.0/internal/testify/.travis.gogenerate.sh000077500000000000000000000007071373124421700233100ustar00rootroot00000000000000#!/bin/bash # If GOMOD is defined we are running with Go Modules enabled, either # automatically or via the GO111MODULE=on environment variable. Codegen only # works with modules, so skip generation if modules is not in use. if [[ -z "$(go env GOMOD)" ]]; then echo "Skipping go generate because modules not enabled and required" exit 0 fi go generate ./... if [ -n "$(git diff)" ]; then echo "Go generate had not been run" git diff exit 1 fi go-jmespath-0.4.0/internal/testify/.travis.govet.sh000077500000000000000000000000421373124421700223040ustar00rootroot00000000000000#!/bin/bash set -e go vet ./... go-jmespath-0.4.0/internal/testify/.travis.yml000066400000000000000000000007641373124421700213600ustar00rootroot00000000000000language: go sudo: false matrix: include: - go: "1.8.x" - go: "1.9.x" - go: "1.10.x" - go: "1.11.x" env: GO111MODULE=off - go: "1.11.x" env: GO111MODULE=on - go: "1.12.x" env: GO111MODULE=off - go: "1.12.x" env: GO111MODULE=on - go: "1.13.x" env: GO111MODULE=off - go: "1.13.x" env: GO111MODULE=on - go: master script: - ./.travis.gogenerate.sh - ./.travis.gofmt.sh - ./.travis.govet.sh - go test -v -race ./... go-jmespath-0.4.0/internal/testify/CONTRIBUTING.md000066400000000000000000000050061373124421700214720ustar00rootroot00000000000000# Contributing to Testify So you'd like to contribute to Testify? First of all, thank you! Testify is widely used, so each contribution has a significant impact within the Golang community! Below you'll find everything you need to know to get up to speed on the project. ## Philosophy The Testify maintainers generally attempt to follow widely accepted practices within the Golang community. That being said, the first priority is always to make sure that the package is useful to the community. A few general guidelines are listed here: *Keep it simple (whenever practical)* - Try not to expand the API unless the new surface area provides meaningful benefits. For example, don't add functions because they might be useful to someone, someday. Add what is useful to specific users, today. *Ease of use is paramount* - This means good documentation and package organization. It also means that we should try hard to use meaningful, descriptive function names, avoid breaking the API unnecessarily, and try not to surprise the user. *Quality isn't an afterthought* - Testify is a testing library, so it seems reasonable that we should have a decent test suite. This is doubly important because a bug in Testify doesn't just mean a bug in our users' code, it means a bug in our users' tests, which means a potentially unnoticed and hard-to-find bug in our users' code. ## Pull Requests We welcome pull requests! Please include the following in the description: * Motivation, why your change is important or helpful * Example usage (if applicable) * Whether you intend to add / change behavior or fix a bug Please be aware that the maintainers may ask for changes. This isn't a commentary on the quality of your idea or your code. Testify is the result of many contributions from many individuals, so we need to enforce certain practices and patterns to keep the package easy for others to understand. Essentially, we recognize that there are often many good ways to do a given thing, but we have to pick one and stick with it. See `MAINTAINERS.md` for a list of users who can approve / merge your changes. ## Issues If you find a bug or think of a useful feature you'd like to see added to Testify, the best thing you can do is make the necessary changes and open a pull request (see above). If that isn't an option, or if you'd like to discuss your change before you write the code, open an issue! Please provide enough context in the issue description that other members of the community can easily understand what it is that you'd like to see. go-jmespath-0.4.0/internal/testify/LICENSE000066400000000000000000000021001373124421700202360ustar00rootroot00000000000000MIT License Copyright (c) 2012-2018 Mat Ryer and Tyler Bunnell Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. go-jmespath-0.4.0/internal/testify/MAINTAINERS.md000066400000000000000000000002531373124421700213340ustar00rootroot00000000000000# Testify Maintainers The individuals listed below are active in the project and have the ability to approve and merge pull requests. * @glesica * @boyan-soubachov go-jmespath-0.4.0/internal/testify/README.md000066400000000000000000000260361373124421700205260ustar00rootroot00000000000000Testify - Thou Shalt Write Tests ================================ [![Build Status](https://travis-ci.org/stretchr/testify.svg)](https://travis-ci.org/stretchr/testify) [![Go Report Card](https://goreportcard.com/badge/github.com/jmespath/go-jmespath/internal/testify)](https://goreportcard.com/report/github.com/jmespath/go-jmespath/internal/testify) [![GoDoc](https://godoc.org/github.com/jmespath/go-jmespath/internal/testify?status.svg)](https://godoc.org/github.com/jmespath/go-jmespath/internal/testify) Go code (golang) set of packages that provide many tools for testifying that your code will behave as you intend. Features include: * [Easy assertions](#assert-package) * [Mocking](#mock-package) * [Testing suite interfaces and functions](#suite-package) Get started: * Install testify with [one line of code](#installation), or [update it with another](#staying-up-to-date) * For an introduction to writing test code in Go, see http://golang.org/doc/code.html#Testing * Check out the API Documentation http://godoc.org/github.com/jmespath/go-jmespath/internal/testify * To make your testing life easier, check out our other project, [gorc](http://github.com/stretchr/gorc) * A little about [Test-Driven Development (TDD)](http://en.wikipedia.org/wiki/Test-driven_development) [`assert`](http://godoc.org/github.com/jmespath/go-jmespath/internal/testify/assert "API documentation") package ------------------------------------------------------------------------------------------- The `assert` package provides some helpful methods that allow you to write better test code in Go. * Prints friendly, easy to read failure descriptions * Allows for very readable code * Optionally annotate each assertion with a message See it in action: ```go package yours import ( "testing" "github.com/jmespath/go-jmespath/internal/testify/assert" ) func TestSomething(t *testing.T) { // assert equality assert.Equal(t, 123, 123, "they should be equal") // assert inequality assert.NotEqual(t, 123, 456, "they should not be equal") // assert for nil (good for errors) assert.Nil(t, object) // assert for not nil (good when you expect something) if assert.NotNil(t, object) { // now we know that object isn't nil, we are safe to make // further assertions without causing any errors assert.Equal(t, "Something", object.Value) } } ``` * Every assert func takes the `testing.T` object as the first argument. This is how it writes the errors out through the normal `go test` capabilities. * Every assert func returns a bool indicating whether the assertion was successful or not, this is useful for if you want to go on making further assertions under certain conditions. if you assert many times, use the below: ```go package yours import ( "testing" "github.com/jmespath/go-jmespath/internal/testify/assert" ) func TestSomething(t *testing.T) { assert := assert.New(t) // assert equality assert.Equal(123, 123, "they should be equal") // assert inequality assert.NotEqual(123, 456, "they should not be equal") // assert for nil (good for errors) assert.Nil(object) // assert for not nil (good when you expect something) if assert.NotNil(object) { // now we know that object isn't nil, we are safe to make // further assertions without causing any errors assert.Equal("Something", object.Value) } } ``` [`require`](http://godoc.org/github.com/jmespath/go-jmespath/internal/testify/require "API documentation") package --------------------------------------------------------------------------------------------- The `require` package provides same global functions as the `assert` package, but instead of returning a boolean result they terminate current test. See [t.FailNow](http://golang.org/pkg/testing/#T.FailNow) for details. [`mock`](http://godoc.org/github.com/jmespath/go-jmespath/internal/testify/mock "API documentation") package ---------------------------------------------------------------------------------------- The `mock` package provides a mechanism for easily writing mock objects that can be used in place of real objects when writing test code. An example test function that tests a piece of code that relies on an external object `testObj`, can setup expectations (testify) and assert that they indeed happened: ```go package yours import ( "testing" "github.com/jmespath/go-jmespath/internal/testify/mock" ) /* Test objects */ // MyMockedObject is a mocked object that implements an interface // that describes an object that the code I am testing relies on. type MyMockedObject struct{ mock.Mock } // DoSomething is a method on MyMockedObject that implements some interface // and just records the activity, and returns what the Mock object tells it to. // // In the real object, this method would do something useful, but since this // is a mocked object - we're just going to stub it out. // // NOTE: This method is not being tested here, code that uses this object is. func (m *MyMockedObject) DoSomething(number int) (bool, error) { args := m.Called(number) return args.Bool(0), args.Error(1) } /* Actual test functions */ // TestSomething is an example of how to use our test object to // make assertions about some target code we are testing. func TestSomething(t *testing.T) { // create an instance of our test object testObj := new(MyMockedObject) // setup expectations testObj.On("DoSomething", 123).Return(true, nil) // call the code we are testing targetFuncThatDoesSomethingWithObj(testObj) // assert that the expectations were met testObj.AssertExpectations(t) } // TestSomethingElse is a second example of how to use our test object to // make assertions about some target code we are testing. // This time using a placeholder. Placeholders might be used when the // data being passed in is normally dynamically generated and cannot be // predicted beforehand (eg. containing hashes that are time sensitive) func TestSomethingElse(t *testing.T) { // create an instance of our test object testObj := new(MyMockedObject) // setup expectations with a placeholder in the argument list testObj.On("DoSomething", mock.Anything).Return(true, nil) // call the code we are testing targetFuncThatDoesSomethingWithObj(testObj) // assert that the expectations were met testObj.AssertExpectations(t) } ``` For more information on how to write mock code, check out the [API documentation for the `mock` package](http://godoc.org/github.com/jmespath/go-jmespath/internal/testify/mock). You can use the [mockery tool](http://github.com/vektra/mockery) to autogenerate the mock code against an interface as well, making using mocks much quicker. [`suite`](http://godoc.org/github.com/jmespath/go-jmespath/internal/testify/suite "API documentation") package ----------------------------------------------------------------------------------------- The `suite` package provides functionality that you might be used to from more common object oriented languages. With it, you can build a testing suite as a struct, build setup/teardown methods and testing methods on your struct, and run them with 'go test' as per normal. An example suite is shown below: ```go // Basic imports import ( "testing" "github.com/jmespath/go-jmespath/internal/testify/assert" "github.com/jmespath/go-jmespath/internal/testify/suite" ) // Define the suite, and absorb the built-in basic suite // functionality from testify - including a T() method which // returns the current testing context type ExampleTestSuite struct { suite.Suite VariableThatShouldStartAtFive int } // Make sure that VariableThatShouldStartAtFive is set to five // before each test func (suite *ExampleTestSuite) SetupTest() { suite.VariableThatShouldStartAtFive = 5 } // All methods that begin with "Test" are run as tests within a // suite. func (suite *ExampleTestSuite) TestExample() { assert.Equal(suite.T(), 5, suite.VariableThatShouldStartAtFive) } // In order for 'go test' to run this suite, we need to create // a normal test function and pass our suite to suite.Run func TestExampleTestSuite(t *testing.T) { suite.Run(t, new(ExampleTestSuite)) } ``` For a more complete example, using all of the functionality provided by the suite package, look at our [example testing suite](https://github.com/jmespath/go-jmespath/internal/testify/blob/master/suite/suite_test.go) For more information on writing suites, check out the [API documentation for the `suite` package](http://godoc.org/github.com/jmespath/go-jmespath/internal/testify/suite). `Suite` object has assertion methods: ```go // Basic imports import ( "testing" "github.com/jmespath/go-jmespath/internal/testify/suite" ) // Define the suite, and absorb the built-in basic suite // functionality from testify - including assertion methods. type ExampleTestSuite struct { suite.Suite VariableThatShouldStartAtFive int } // Make sure that VariableThatShouldStartAtFive is set to five // before each test func (suite *ExampleTestSuite) SetupTest() { suite.VariableThatShouldStartAtFive = 5 } // All methods that begin with "Test" are run as tests within a // suite. func (suite *ExampleTestSuite) TestExample() { suite.Equal(suite.VariableThatShouldStartAtFive, 5) } // In order for 'go test' to run this suite, we need to create // a normal test function and pass our suite to suite.Run func TestExampleTestSuite(t *testing.T) { suite.Run(t, new(ExampleTestSuite)) } ``` ------ Installation ============ To install Testify, use `go get`: go get github.com/jmespath/go-jmespath/internal/testify This will then make the following packages available to you: github.com/jmespath/go-jmespath/internal/testify/assert github.com/jmespath/go-jmespath/internal/testify/require github.com/jmespath/go-jmespath/internal/testify/mock github.com/jmespath/go-jmespath/internal/testify/suite github.com/jmespath/go-jmespath/internal/testify/http (deprecated) Import the `testify/assert` package into your code using this template: ```go package yours import ( "testing" "github.com/jmespath/go-jmespath/internal/testify/assert" ) func TestSomething(t *testing.T) { assert.True(t, true, "True is true!") } ``` ------ Staying up to date ================== To update Testify to the latest version, use `go get -u github.com/jmespath/go-jmespath/internal/testify`. ------ Supported go versions ================== We support the three major Go versions, which are 1.11, 1.12, and 1.13 at the moment. ------ Contributing ============ Please feel free to submit issues, fork the repository and send pull requests! When submitting an issue, we ask that you please include a complete test function that demonstrates the issue. Extra credit for those using Testify to write the test code that demonstrates it. Code generation is used. Look for `CODE GENERATED AUTOMATICALLY` at the top of some files. Run `go generate ./...` to update generated files. We also chat on the [Gophers Slack](https://gophers.slack.com) group in the `#testify` and `#testify-dev` channels. ------ License ======= This project is licensed under the terms of the MIT license. go-jmespath-0.4.0/internal/testify/_codegen/000077500000000000000000000000001373124421700210035ustar00rootroot00000000000000go-jmespath-0.4.0/internal/testify/_codegen/.gitignore000066400000000000000000000000111373124421700227630ustar00rootroot00000000000000_codegen go-jmespath-0.4.0/internal/testify/_codegen/go.mod000066400000000000000000000002271373124421700221120ustar00rootroot00000000000000module github.com/jmespath/go-jmespath/internal/testify/_codegen go 1.11 require github.com/ernesto-jimenez/gogen v0.0.0-20180125220232-d7d4131e6607 go-jmespath-0.4.0/internal/testify/_codegen/go.sum000066400000000000000000000003571373124421700221430ustar00rootroot00000000000000github.com/ernesto-jimenez/gogen v0.0.0-20180125220232-d7d4131e6607 h1:cTavhURetDkezJCvxFggiyLeP40Mrk/TtVg2+ycw1Es= github.com/ernesto-jimenez/gogen v0.0.0-20180125220232-d7d4131e6607/go.mod h1:Cg4fM0vhYWOZdgM7RIOSTRNIc8/VT7CXClC3Ni86lu4= go-jmespath-0.4.0/internal/testify/_codegen/main.go000066400000000000000000000166121373124421700222640ustar00rootroot00000000000000// This program reads all assertion functions from the assert package and // automatically generates the corresponding requires and forwarded assertions package main import ( "bytes" "flag" "fmt" "go/ast" "go/build" "go/doc" "go/format" "go/importer" "go/parser" "go/token" "go/types" "io" "io/ioutil" "log" "os" "path" "regexp" "strings" "text/template" "github.com/ernesto-jimenez/gogen/imports" ) var ( pkg = flag.String("assert-path", "github.com/jmespath/go-jmespath/internal/testify/assert", "Path to the assert package") includeF = flag.Bool("include-format-funcs", false, "include format functions such as Errorf and Equalf") outputPkg = flag.String("output-package", "", "package for the resulting code") tmplFile = flag.String("template", "", "What file to load the function template from") out = flag.String("out", "", "What file to write the source code to") ) func main() { flag.Parse() scope, docs, err := parsePackageSource(*pkg) if err != nil { log.Fatal(err) } importer, funcs, err := analyzeCode(scope, docs) if err != nil { log.Fatal(err) } if err := generateCode(importer, funcs); err != nil { log.Fatal(err) } } func generateCode(importer imports.Importer, funcs []testFunc) error { buff := bytes.NewBuffer(nil) tmplHead, tmplFunc, err := parseTemplates() if err != nil { return err } // Generate header if err := tmplHead.Execute(buff, struct { Name string Imports map[string]string }{ *outputPkg, importer.Imports(), }); err != nil { return err } // Generate funcs for _, fn := range funcs { buff.Write([]byte("\n\n")) if err := tmplFunc.Execute(buff, &fn); err != nil { return err } } code, err := format.Source(buff.Bytes()) if err != nil { return err } // Write file output, err := outputFile() if err != nil { return err } defer output.Close() _, err = io.Copy(output, bytes.NewReader(code)) return err } func parseTemplates() (*template.Template, *template.Template, error) { tmplHead, err := template.New("header").Parse(headerTemplate) if err != nil { return nil, nil, err } if *tmplFile != "" { f, err := ioutil.ReadFile(*tmplFile) if err != nil { return nil, nil, err } funcTemplate = string(f) } tmpl, err := template.New("function").Parse(funcTemplate) if err != nil { return nil, nil, err } return tmplHead, tmpl, nil } func outputFile() (*os.File, error) { filename := *out if filename == "-" || (filename == "" && *tmplFile == "") { return os.Stdout, nil } if filename == "" { filename = strings.TrimSuffix(strings.TrimSuffix(*tmplFile, ".tmpl"), ".go") + ".go" } return os.Create(filename) } // analyzeCode takes the types scope and the docs and returns the import // information and information about all the assertion functions. func analyzeCode(scope *types.Scope, docs *doc.Package) (imports.Importer, []testFunc, error) { testingT := scope.Lookup("TestingT").Type().Underlying().(*types.Interface) importer := imports.New(*outputPkg) var funcs []testFunc // Go through all the top level functions for _, fdocs := range docs.Funcs { // Find the function obj := scope.Lookup(fdocs.Name) fn, ok := obj.(*types.Func) if !ok { continue } // Check function signature has at least two arguments sig := fn.Type().(*types.Signature) if sig.Params().Len() < 2 { continue } // Check first argument is of type testingT first, ok := sig.Params().At(0).Type().(*types.Named) if !ok { continue } firstType, ok := first.Underlying().(*types.Interface) if !ok { continue } if !types.Implements(firstType, testingT) { continue } // Skip functions ending with f if strings.HasSuffix(fdocs.Name, "f") && !*includeF { continue } funcs = append(funcs, testFunc{*outputPkg, fdocs, fn}) importer.AddImportsFrom(sig.Params()) } return importer, funcs, nil } // parsePackageSource returns the types scope and the package documentation from the package func parsePackageSource(pkg string) (*types.Scope, *doc.Package, error) { pd, err := build.Import(pkg, ".", 0) if err != nil { return nil, nil, err } fset := token.NewFileSet() files := make(map[string]*ast.File) fileList := make([]*ast.File, len(pd.GoFiles)) for i, fname := range pd.GoFiles { src, err := ioutil.ReadFile(path.Join(pd.Dir, fname)) if err != nil { return nil, nil, err } f, err := parser.ParseFile(fset, fname, src, parser.ParseComments|parser.AllErrors) if err != nil { return nil, nil, err } files[fname] = f fileList[i] = f } cfg := types.Config{ Importer: importer.For("source", nil), } info := types.Info{ Defs: make(map[*ast.Ident]types.Object), } tp, err := cfg.Check(pkg, fset, fileList, &info) if err != nil { return nil, nil, err } scope := tp.Scope() ap, _ := ast.NewPackage(fset, files, nil, nil) docs := doc.New(ap, pkg, 0) return scope, docs, nil } type testFunc struct { CurrentPkg string DocInfo *doc.Func TypeInfo *types.Func } func (f *testFunc) Qualifier(p *types.Package) string { if p == nil || p.Name() == f.CurrentPkg { return "" } return p.Name() } func (f *testFunc) Params() string { sig := f.TypeInfo.Type().(*types.Signature) params := sig.Params() p := "" comma := "" to := params.Len() var i int if sig.Variadic() { to-- } for i = 1; i < to; i++ { param := params.At(i) p += fmt.Sprintf("%s%s %s", comma, param.Name(), types.TypeString(param.Type(), f.Qualifier)) comma = ", " } if sig.Variadic() { param := params.At(params.Len() - 1) p += fmt.Sprintf("%s%s ...%s", comma, param.Name(), types.TypeString(param.Type().(*types.Slice).Elem(), f.Qualifier)) } return p } func (f *testFunc) ForwardedParams() string { sig := f.TypeInfo.Type().(*types.Signature) params := sig.Params() p := "" comma := "" to := params.Len() var i int if sig.Variadic() { to-- } for i = 1; i < to; i++ { param := params.At(i) p += fmt.Sprintf("%s%s", comma, param.Name()) comma = ", " } if sig.Variadic() { param := params.At(params.Len() - 1) p += fmt.Sprintf("%s%s...", comma, param.Name()) } return p } func (f *testFunc) ParamsFormat() string { return strings.Replace(f.Params(), "msgAndArgs", "msg string, args", 1) } func (f *testFunc) ForwardedParamsFormat() string { return strings.Replace(f.ForwardedParams(), "msgAndArgs", "append([]interface{}{msg}, args...)", 1) } func (f *testFunc) Comment() string { return "// " + strings.Replace(strings.TrimSpace(f.DocInfo.Doc), "\n", "\n// ", -1) } func (f *testFunc) CommentFormat() string { search := fmt.Sprintf("%s", f.DocInfo.Name) replace := fmt.Sprintf("%sf", f.DocInfo.Name) comment := strings.Replace(f.Comment(), search, replace, -1) exp := regexp.MustCompile(replace + `\(((\(\)|[^)])+)\)`) return exp.ReplaceAllString(comment, replace+`($1, "error message %s", "formatted")`) } func (f *testFunc) CommentWithoutT(receiver string) string { search := fmt.Sprintf("assert.%s(t, ", f.DocInfo.Name) replace := fmt.Sprintf("%s.%s(", receiver, f.DocInfo.Name) return strings.Replace(f.Comment(), search, replace, -1) } var headerTemplate = `/* * CODE GENERATED AUTOMATICALLY WITH github.com/jmespath/go-jmespath/internal/testify/_codegen * THIS FILE MUST NOT BE EDITED BY HAND */ package {{.Name}} import ( {{range $path, $name := .Imports}} {{$name}} "{{$path}}"{{end}} ) ` var funcTemplate = `{{.Comment}} func (fwd *AssertionsForwarder) {{.DocInfo.Name}}({{.Params}}) bool { return assert.{{.DocInfo.Name}}({{.ForwardedParams}}) }` go-jmespath-0.4.0/internal/testify/assert/000077500000000000000000000000001373124421700205415ustar00rootroot00000000000000go-jmespath-0.4.0/internal/testify/assert/assertion_format.go000066400000000000000000000607211373124421700244550ustar00rootroot00000000000000/* * CODE GENERATED AUTOMATICALLY WITH github.com/jmespath/go-jmespath/internal/testify/_codegen * THIS FILE MUST NOT BE EDITED BY HAND */ package assert import ( http "net/http" url "net/url" time "time" ) // Conditionf uses a Comparison to assert a complex condition. func Conditionf(t TestingT, comp Comparison, msg string, args ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() } return Condition(t, comp, append([]interface{}{msg}, args...)...) } // Containsf asserts that the specified string, list(array, slice...) or map contains the // specified substring or element. // // assert.Containsf(t, "Hello World", "World", "error message %s", "formatted") // assert.Containsf(t, ["Hello", "World"], "World", "error message %s", "formatted") // assert.Containsf(t, {"Hello": "World"}, "Hello", "error message %s", "formatted") func Containsf(t TestingT, s interface{}, contains interface{}, msg string, args ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() } return Contains(t, s, contains, append([]interface{}{msg}, args...)...) } // DirExistsf checks whether a directory exists in the given path. It also fails // if the path is a file rather a directory or there is an error checking whether it exists. func DirExistsf(t TestingT, path string, msg string, args ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() } return DirExists(t, path, append([]interface{}{msg}, args...)...) } // ElementsMatchf asserts that the specified listA(array, slice...) is equal to specified // listB(array, slice...) ignoring the order of the elements. If there are duplicate elements, // the number of appearances of each of them in both lists should match. // // assert.ElementsMatchf(t, [1, 3, 2, 3], [1, 3, 3, 2], "error message %s", "formatted") func ElementsMatchf(t TestingT, listA interface{}, listB interface{}, msg string, args ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() } return ElementsMatch(t, listA, listB, append([]interface{}{msg}, args...)...) } // Emptyf asserts that the specified object is empty. I.e. nil, "", false, 0 or either // a slice or a channel with len == 0. // // assert.Emptyf(t, obj, "error message %s", "formatted") func Emptyf(t TestingT, object interface{}, msg string, args ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() } return Empty(t, object, append([]interface{}{msg}, args...)...) } // Equalf asserts that two objects are equal. // // assert.Equalf(t, 123, 123, "error message %s", "formatted") // // Pointer variable equality is determined based on the equality of the // referenced values (as opposed to the memory addresses). Function equality // cannot be determined and will always fail. func Equalf(t TestingT, expected interface{}, actual interface{}, msg string, args ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() } return Equal(t, expected, actual, append([]interface{}{msg}, args...)...) } // EqualErrorf asserts that a function returned an error (i.e. not `nil`) // and that it is equal to the provided error. // // actualObj, err := SomeFunction() // assert.EqualErrorf(t, err, expectedErrorString, "error message %s", "formatted") func EqualErrorf(t TestingT, theError error, errString string, msg string, args ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() } return EqualError(t, theError, errString, append([]interface{}{msg}, args...)...) } // EqualValuesf asserts that two objects are equal or convertable to the same types // and equal. // // assert.EqualValuesf(t, uint32(123, "error message %s", "formatted"), int32(123)) func EqualValuesf(t TestingT, expected interface{}, actual interface{}, msg string, args ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() } return EqualValues(t, expected, actual, append([]interface{}{msg}, args...)...) } // Errorf asserts that a function returned an error (i.e. not `nil`). // // actualObj, err := SomeFunction() // if assert.Errorf(t, err, "error message %s", "formatted") { // assert.Equal(t, expectedErrorf, err) // } func Errorf(t TestingT, err error, msg string, args ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() } return Error(t, err, append([]interface{}{msg}, args...)...) } // Eventuallyf asserts that given condition will be met in waitFor time, // periodically checking target function each tick. // // assert.Eventuallyf(t, func() bool { return true; }, time.Second, 10*time.Millisecond, "error message %s", "formatted") func Eventuallyf(t TestingT, condition func() bool, waitFor time.Duration, tick time.Duration, msg string, args ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() } return Eventually(t, condition, waitFor, tick, append([]interface{}{msg}, args...)...) } // Exactlyf asserts that two objects are equal in value and type. // // assert.Exactlyf(t, int32(123, "error message %s", "formatted"), int64(123)) func Exactlyf(t TestingT, expected interface{}, actual interface{}, msg string, args ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() } return Exactly(t, expected, actual, append([]interface{}{msg}, args...)...) } // Failf reports a failure through func Failf(t TestingT, failureMessage string, msg string, args ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() } return Fail(t, failureMessage, append([]interface{}{msg}, args...)...) } // FailNowf fails test func FailNowf(t TestingT, failureMessage string, msg string, args ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() } return FailNow(t, failureMessage, append([]interface{}{msg}, args...)...) } // Falsef asserts that the specified value is false. // // assert.Falsef(t, myBool, "error message %s", "formatted") func Falsef(t TestingT, value bool, msg string, args ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() } return False(t, value, append([]interface{}{msg}, args...)...) } // FileExistsf checks whether a file exists in the given path. It also fails if // the path points to a directory or there is an error when trying to check the file. func FileExistsf(t TestingT, path string, msg string, args ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() } return FileExists(t, path, append([]interface{}{msg}, args...)...) } // Greaterf asserts that the first element is greater than the second // // assert.Greaterf(t, 2, 1, "error message %s", "formatted") // assert.Greaterf(t, float64(2, "error message %s", "formatted"), float64(1)) // assert.Greaterf(t, "b", "a", "error message %s", "formatted") func Greaterf(t TestingT, e1 interface{}, e2 interface{}, msg string, args ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() } return Greater(t, e1, e2, append([]interface{}{msg}, args...)...) } // GreaterOrEqualf asserts that the first element is greater than or equal to the second // // assert.GreaterOrEqualf(t, 2, 1, "error message %s", "formatted") // assert.GreaterOrEqualf(t, 2, 2, "error message %s", "formatted") // assert.GreaterOrEqualf(t, "b", "a", "error message %s", "formatted") // assert.GreaterOrEqualf(t, "b", "b", "error message %s", "formatted") func GreaterOrEqualf(t TestingT, e1 interface{}, e2 interface{}, msg string, args ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() } return GreaterOrEqual(t, e1, e2, append([]interface{}{msg}, args...)...) } // HTTPBodyContainsf asserts that a specified handler returns a // body that contains a string. // // assert.HTTPBodyContainsf(t, myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky", "error message %s", "formatted") // // Returns whether the assertion was successful (true) or not (false). func HTTPBodyContainsf(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msg string, args ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() } return HTTPBodyContains(t, handler, method, url, values, str, append([]interface{}{msg}, args...)...) } // HTTPBodyNotContainsf asserts that a specified handler returns a // body that does not contain a string. // // assert.HTTPBodyNotContainsf(t, myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky", "error message %s", "formatted") // // Returns whether the assertion was successful (true) or not (false). func HTTPBodyNotContainsf(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msg string, args ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() } return HTTPBodyNotContains(t, handler, method, url, values, str, append([]interface{}{msg}, args...)...) } // HTTPErrorf asserts that a specified handler returns an error status code. // // assert.HTTPErrorf(t, myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}} // // Returns whether the assertion was successful (true, "error message %s", "formatted") or not (false). func HTTPErrorf(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, msg string, args ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() } return HTTPError(t, handler, method, url, values, append([]interface{}{msg}, args...)...) } // HTTPRedirectf asserts that a specified handler returns a redirect status code. // // assert.HTTPRedirectf(t, myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}} // // Returns whether the assertion was successful (true, "error message %s", "formatted") or not (false). func HTTPRedirectf(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, msg string, args ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() } return HTTPRedirect(t, handler, method, url, values, append([]interface{}{msg}, args...)...) } // HTTPSuccessf asserts that a specified handler returns a success status code. // // assert.HTTPSuccessf(t, myHandler, "POST", "http://www.google.com", nil, "error message %s", "formatted") // // Returns whether the assertion was successful (true) or not (false). func HTTPSuccessf(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, msg string, args ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() } return HTTPSuccess(t, handler, method, url, values, append([]interface{}{msg}, args...)...) } // Implementsf asserts that an object is implemented by the specified interface. // // assert.Implementsf(t, (*MyInterface, "error message %s", "formatted")(nil), new(MyObject)) func Implementsf(t TestingT, interfaceObject interface{}, object interface{}, msg string, args ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() } return Implements(t, interfaceObject, object, append([]interface{}{msg}, args...)...) } // InDeltaf asserts that the two numerals are within delta of each other. // // assert.InDeltaf(t, math.Pi, 22/7.0, 0.01, "error message %s", "formatted") func InDeltaf(t TestingT, expected interface{}, actual interface{}, delta float64, msg string, args ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() } return InDelta(t, expected, actual, delta, append([]interface{}{msg}, args...)...) } // InDeltaMapValuesf is the same as InDelta, but it compares all values between two maps. Both maps must have exactly the same keys. func InDeltaMapValuesf(t TestingT, expected interface{}, actual interface{}, delta float64, msg string, args ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() } return InDeltaMapValues(t, expected, actual, delta, append([]interface{}{msg}, args...)...) } // InDeltaSlicef is the same as InDelta, except it compares two slices. func InDeltaSlicef(t TestingT, expected interface{}, actual interface{}, delta float64, msg string, args ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() } return InDeltaSlice(t, expected, actual, delta, append([]interface{}{msg}, args...)...) } // InEpsilonf asserts that expected and actual have a relative error less than epsilon func InEpsilonf(t TestingT, expected interface{}, actual interface{}, epsilon float64, msg string, args ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() } return InEpsilon(t, expected, actual, epsilon, append([]interface{}{msg}, args...)...) } // InEpsilonSlicef is the same as InEpsilon, except it compares each value from two slices. func InEpsilonSlicef(t TestingT, expected interface{}, actual interface{}, epsilon float64, msg string, args ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() } return InEpsilonSlice(t, expected, actual, epsilon, append([]interface{}{msg}, args...)...) } // IsTypef asserts that the specified objects are of the same type. func IsTypef(t TestingT, expectedType interface{}, object interface{}, msg string, args ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() } return IsType(t, expectedType, object, append([]interface{}{msg}, args...)...) } // JSONEqf asserts that two JSON strings are equivalent. // // assert.JSONEqf(t, `{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`, "error message %s", "formatted") func JSONEqf(t TestingT, expected string, actual string, msg string, args ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() } return JSONEq(t, expected, actual, append([]interface{}{msg}, args...)...) } // Lenf asserts that the specified object has specific length. // Lenf also fails if the object has a type that len() not accept. // // assert.Lenf(t, mySlice, 3, "error message %s", "formatted") func Lenf(t TestingT, object interface{}, length int, msg string, args ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() } return Len(t, object, length, append([]interface{}{msg}, args...)...) } // Lessf asserts that the first element is less than the second // // assert.Lessf(t, 1, 2, "error message %s", "formatted") // assert.Lessf(t, float64(1, "error message %s", "formatted"), float64(2)) // assert.Lessf(t, "a", "b", "error message %s", "formatted") func Lessf(t TestingT, e1 interface{}, e2 interface{}, msg string, args ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() } return Less(t, e1, e2, append([]interface{}{msg}, args...)...) } // LessOrEqualf asserts that the first element is less than or equal to the second // // assert.LessOrEqualf(t, 1, 2, "error message %s", "formatted") // assert.LessOrEqualf(t, 2, 2, "error message %s", "formatted") // assert.LessOrEqualf(t, "a", "b", "error message %s", "formatted") // assert.LessOrEqualf(t, "b", "b", "error message %s", "formatted") func LessOrEqualf(t TestingT, e1 interface{}, e2 interface{}, msg string, args ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() } return LessOrEqual(t, e1, e2, append([]interface{}{msg}, args...)...) } // Neverf asserts that the given condition doesn't satisfy in waitFor time, // periodically checking the target function each tick. // // assert.Neverf(t, func() bool { return false; }, time.Second, 10*time.Millisecond, "error message %s", "formatted") func Neverf(t TestingT, condition func() bool, waitFor time.Duration, tick time.Duration, msg string, args ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() } return Never(t, condition, waitFor, tick, append([]interface{}{msg}, args...)...) } // Nilf asserts that the specified object is nil. // // assert.Nilf(t, err, "error message %s", "formatted") func Nilf(t TestingT, object interface{}, msg string, args ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() } return Nil(t, object, append([]interface{}{msg}, args...)...) } // NoDirExistsf checks whether a directory does not exist in the given path. // It fails if the path points to an existing _directory_ only. func NoDirExistsf(t TestingT, path string, msg string, args ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() } return NoDirExists(t, path, append([]interface{}{msg}, args...)...) } // NoErrorf asserts that a function returned no error (i.e. `nil`). // // actualObj, err := SomeFunction() // if assert.NoErrorf(t, err, "error message %s", "formatted") { // assert.Equal(t, expectedObj, actualObj) // } func NoErrorf(t TestingT, err error, msg string, args ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() } return NoError(t, err, append([]interface{}{msg}, args...)...) } // NoFileExistsf checks whether a file does not exist in a given path. It fails // if the path points to an existing _file_ only. func NoFileExistsf(t TestingT, path string, msg string, args ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() } return NoFileExists(t, path, append([]interface{}{msg}, args...)...) } // NotContainsf asserts that the specified string, list(array, slice...) or map does NOT contain the // specified substring or element. // // assert.NotContainsf(t, "Hello World", "Earth", "error message %s", "formatted") // assert.NotContainsf(t, ["Hello", "World"], "Earth", "error message %s", "formatted") // assert.NotContainsf(t, {"Hello": "World"}, "Earth", "error message %s", "formatted") func NotContainsf(t TestingT, s interface{}, contains interface{}, msg string, args ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() } return NotContains(t, s, contains, append([]interface{}{msg}, args...)...) } // NotEmptyf asserts that the specified object is NOT empty. I.e. not nil, "", false, 0 or either // a slice or a channel with len == 0. // // if assert.NotEmptyf(t, obj, "error message %s", "formatted") { // assert.Equal(t, "two", obj[1]) // } func NotEmptyf(t TestingT, object interface{}, msg string, args ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() } return NotEmpty(t, object, append([]interface{}{msg}, args...)...) } // NotEqualf asserts that the specified values are NOT equal. // // assert.NotEqualf(t, obj1, obj2, "error message %s", "formatted") // // Pointer variable equality is determined based on the equality of the // referenced values (as opposed to the memory addresses). func NotEqualf(t TestingT, expected interface{}, actual interface{}, msg string, args ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() } return NotEqual(t, expected, actual, append([]interface{}{msg}, args...)...) } // NotNilf asserts that the specified object is not nil. // // assert.NotNilf(t, err, "error message %s", "formatted") func NotNilf(t TestingT, object interface{}, msg string, args ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() } return NotNil(t, object, append([]interface{}{msg}, args...)...) } // NotPanicsf asserts that the code inside the specified PanicTestFunc does NOT panic. // // assert.NotPanicsf(t, func(){ RemainCalm() }, "error message %s", "formatted") func NotPanicsf(t TestingT, f PanicTestFunc, msg string, args ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() } return NotPanics(t, f, append([]interface{}{msg}, args...)...) } // NotRegexpf asserts that a specified regexp does not match a string. // // assert.NotRegexpf(t, regexp.MustCompile("starts", "error message %s", "formatted"), "it's starting") // assert.NotRegexpf(t, "^start", "it's not starting", "error message %s", "formatted") func NotRegexpf(t TestingT, rx interface{}, str interface{}, msg string, args ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() } return NotRegexp(t, rx, str, append([]interface{}{msg}, args...)...) } // NotSamef asserts that two pointers do not reference the same object. // // assert.NotSamef(t, ptr1, ptr2, "error message %s", "formatted") // // Both arguments must be pointer variables. Pointer variable sameness is // determined based on the equality of both type and value. func NotSamef(t TestingT, expected interface{}, actual interface{}, msg string, args ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() } return NotSame(t, expected, actual, append([]interface{}{msg}, args...)...) } // NotSubsetf asserts that the specified list(array, slice...) contains not all // elements given in the specified subset(array, slice...). // // assert.NotSubsetf(t, [1, 3, 4], [1, 2], "But [1, 3, 4] does not contain [1, 2]", "error message %s", "formatted") func NotSubsetf(t TestingT, list interface{}, subset interface{}, msg string, args ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() } return NotSubset(t, list, subset, append([]interface{}{msg}, args...)...) } // NotZerof asserts that i is not the zero value for its type. func NotZerof(t TestingT, i interface{}, msg string, args ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() } return NotZero(t, i, append([]interface{}{msg}, args...)...) } // Panicsf asserts that the code inside the specified PanicTestFunc panics. // // assert.Panicsf(t, func(){ GoCrazy() }, "error message %s", "formatted") func Panicsf(t TestingT, f PanicTestFunc, msg string, args ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() } return Panics(t, f, append([]interface{}{msg}, args...)...) } // PanicsWithErrorf asserts that the code inside the specified PanicTestFunc // panics, and that the recovered panic value is an error that satisfies the // EqualError comparison. // // assert.PanicsWithErrorf(t, "crazy error", func(){ GoCrazy() }, "error message %s", "formatted") func PanicsWithErrorf(t TestingT, errString string, f PanicTestFunc, msg string, args ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() } return PanicsWithError(t, errString, f, append([]interface{}{msg}, args...)...) } // PanicsWithValuef asserts that the code inside the specified PanicTestFunc panics, and that // the recovered panic value equals the expected panic value. // // assert.PanicsWithValuef(t, "crazy error", func(){ GoCrazy() }, "error message %s", "formatted") func PanicsWithValuef(t TestingT, expected interface{}, f PanicTestFunc, msg string, args ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() } return PanicsWithValue(t, expected, f, append([]interface{}{msg}, args...)...) } // Regexpf asserts that a specified regexp matches a string. // // assert.Regexpf(t, regexp.MustCompile("start", "error message %s", "formatted"), "it's starting") // assert.Regexpf(t, "start...$", "it's not starting", "error message %s", "formatted") func Regexpf(t TestingT, rx interface{}, str interface{}, msg string, args ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() } return Regexp(t, rx, str, append([]interface{}{msg}, args...)...) } // Samef asserts that two pointers reference the same object. // // assert.Samef(t, ptr1, ptr2, "error message %s", "formatted") // // Both arguments must be pointer variables. Pointer variable sameness is // determined based on the equality of both type and value. func Samef(t TestingT, expected interface{}, actual interface{}, msg string, args ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() } return Same(t, expected, actual, append([]interface{}{msg}, args...)...) } // Subsetf asserts that the specified list(array, slice...) contains all // elements given in the specified subset(array, slice...). // // assert.Subsetf(t, [1, 2, 3], [1, 2], "But [1, 2, 3] does contain [1, 2]", "error message %s", "formatted") func Subsetf(t TestingT, list interface{}, subset interface{}, msg string, args ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() } return Subset(t, list, subset, append([]interface{}{msg}, args...)...) } // Truef asserts that the specified value is true. // // assert.Truef(t, myBool, "error message %s", "formatted") func Truef(t TestingT, value bool, msg string, args ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() } return True(t, value, append([]interface{}{msg}, args...)...) } // WithinDurationf asserts that the two times are within duration delta of each other. // // assert.WithinDurationf(t, time.Now(), time.Now(), 10*time.Second, "error message %s", "formatted") func WithinDurationf(t TestingT, expected time.Time, actual time.Time, delta time.Duration, msg string, args ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() } return WithinDuration(t, expected, actual, delta, append([]interface{}{msg}, args...)...) } // YAMLEqf asserts that two YAML strings are equivalent. func YAMLEqf(t TestingT, expected string, actual string, msg string, args ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() } return YAMLEq(t, expected, actual, append([]interface{}{msg}, args...)...) } // Zerof asserts that i is the zero value for its type. func Zerof(t TestingT, i interface{}, msg string, args ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() } return Zero(t, i, append([]interface{}{msg}, args...)...) } go-jmespath-0.4.0/internal/testify/assert/assertion_format.go.tmpl000066400000000000000000000002701373124421700254210ustar00rootroot00000000000000{{.CommentFormat}} func {{.DocInfo.Name}}f(t TestingT, {{.ParamsFormat}}) bool { if h, ok := t.(tHelper); ok { h.Helper() } return {{.DocInfo.Name}}(t, {{.ForwardedParamsFormat}}) } go-jmespath-0.4.0/internal/testify/assert/assertion_forward.go000066400000000000000000001270351373124421700246330ustar00rootroot00000000000000/* * CODE GENERATED AUTOMATICALLY WITH github.com/jmespath/go-jmespath/internal/testify/_codegen * THIS FILE MUST NOT BE EDITED BY HAND */ package assert import ( http "net/http" url "net/url" time "time" ) // Condition uses a Comparison to assert a complex condition. func (a *Assertions) Condition(comp Comparison, msgAndArgs ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() } return Condition(a.t, comp, msgAndArgs...) } // Conditionf uses a Comparison to assert a complex condition. func (a *Assertions) Conditionf(comp Comparison, msg string, args ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() } return Conditionf(a.t, comp, msg, args...) } // Contains asserts that the specified string, list(array, slice...) or map contains the // specified substring or element. // // a.Contains("Hello World", "World") // a.Contains(["Hello", "World"], "World") // a.Contains({"Hello": "World"}, "Hello") func (a *Assertions) Contains(s interface{}, contains interface{}, msgAndArgs ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() } return Contains(a.t, s, contains, msgAndArgs...) } // Containsf asserts that the specified string, list(array, slice...) or map contains the // specified substring or element. // // a.Containsf("Hello World", "World", "error message %s", "formatted") // a.Containsf(["Hello", "World"], "World", "error message %s", "formatted") // a.Containsf({"Hello": "World"}, "Hello", "error message %s", "formatted") func (a *Assertions) Containsf(s interface{}, contains interface{}, msg string, args ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() } return Containsf(a.t, s, contains, msg, args...) } // DirExists checks whether a directory exists in the given path. It also fails // if the path is a file rather a directory or there is an error checking whether it exists. func (a *Assertions) DirExists(path string, msgAndArgs ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() } return DirExists(a.t, path, msgAndArgs...) } // DirExistsf checks whether a directory exists in the given path. It also fails // if the path is a file rather a directory or there is an error checking whether it exists. func (a *Assertions) DirExistsf(path string, msg string, args ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() } return DirExistsf(a.t, path, msg, args...) } // ElementsMatch asserts that the specified listA(array, slice...) is equal to specified // listB(array, slice...) ignoring the order of the elements. If there are duplicate elements, // the number of appearances of each of them in both lists should match. // // a.ElementsMatch([1, 3, 2, 3], [1, 3, 3, 2]) func (a *Assertions) ElementsMatch(listA interface{}, listB interface{}, msgAndArgs ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() } return ElementsMatch(a.t, listA, listB, msgAndArgs...) } // ElementsMatchf asserts that the specified listA(array, slice...) is equal to specified // listB(array, slice...) ignoring the order of the elements. If there are duplicate elements, // the number of appearances of each of them in both lists should match. // // a.ElementsMatchf([1, 3, 2, 3], [1, 3, 3, 2], "error message %s", "formatted") func (a *Assertions) ElementsMatchf(listA interface{}, listB interface{}, msg string, args ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() } return ElementsMatchf(a.t, listA, listB, msg, args...) } // Empty asserts that the specified object is empty. I.e. nil, "", false, 0 or either // a slice or a channel with len == 0. // // a.Empty(obj) func (a *Assertions) Empty(object interface{}, msgAndArgs ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() } return Empty(a.t, object, msgAndArgs...) } // Emptyf asserts that the specified object is empty. I.e. nil, "", false, 0 or either // a slice or a channel with len == 0. // // a.Emptyf(obj, "error message %s", "formatted") func (a *Assertions) Emptyf(object interface{}, msg string, args ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() } return Emptyf(a.t, object, msg, args...) } // Equal asserts that two objects are equal. // // a.Equal(123, 123) // // Pointer variable equality is determined based on the equality of the // referenced values (as opposed to the memory addresses). Function equality // cannot be determined and will always fail. func (a *Assertions) Equal(expected interface{}, actual interface{}, msgAndArgs ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() } return Equal(a.t, expected, actual, msgAndArgs...) } // EqualError asserts that a function returned an error (i.e. not `nil`) // and that it is equal to the provided error. // // actualObj, err := SomeFunction() // a.EqualError(err, expectedErrorString) func (a *Assertions) EqualError(theError error, errString string, msgAndArgs ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() } return EqualError(a.t, theError, errString, msgAndArgs...) } // EqualErrorf asserts that a function returned an error (i.e. not `nil`) // and that it is equal to the provided error. // // actualObj, err := SomeFunction() // a.EqualErrorf(err, expectedErrorString, "error message %s", "formatted") func (a *Assertions) EqualErrorf(theError error, errString string, msg string, args ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() } return EqualErrorf(a.t, theError, errString, msg, args...) } // EqualValues asserts that two objects are equal or convertable to the same types // and equal. // // a.EqualValues(uint32(123), int32(123)) func (a *Assertions) EqualValues(expected interface{}, actual interface{}, msgAndArgs ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() } return EqualValues(a.t, expected, actual, msgAndArgs...) } // EqualValuesf asserts that two objects are equal or convertable to the same types // and equal. // // a.EqualValuesf(uint32(123, "error message %s", "formatted"), int32(123)) func (a *Assertions) EqualValuesf(expected interface{}, actual interface{}, msg string, args ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() } return EqualValuesf(a.t, expected, actual, msg, args...) } // Equalf asserts that two objects are equal. // // a.Equalf(123, 123, "error message %s", "formatted") // // Pointer variable equality is determined based on the equality of the // referenced values (as opposed to the memory addresses). Function equality // cannot be determined and will always fail. func (a *Assertions) Equalf(expected interface{}, actual interface{}, msg string, args ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() } return Equalf(a.t, expected, actual, msg, args...) } // Error asserts that a function returned an error (i.e. not `nil`). // // actualObj, err := SomeFunction() // if a.Error(err) { // assert.Equal(t, expectedError, err) // } func (a *Assertions) Error(err error, msgAndArgs ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() } return Error(a.t, err, msgAndArgs...) } // Errorf asserts that a function returned an error (i.e. not `nil`). // // actualObj, err := SomeFunction() // if a.Errorf(err, "error message %s", "formatted") { // assert.Equal(t, expectedErrorf, err) // } func (a *Assertions) Errorf(err error, msg string, args ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() } return Errorf(a.t, err, msg, args...) } // Eventually asserts that given condition will be met in waitFor time, // periodically checking target function each tick. // // a.Eventually(func() bool { return true; }, time.Second, 10*time.Millisecond) func (a *Assertions) Eventually(condition func() bool, waitFor time.Duration, tick time.Duration, msgAndArgs ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() } return Eventually(a.t, condition, waitFor, tick, msgAndArgs...) } // Eventuallyf asserts that given condition will be met in waitFor time, // periodically checking target function each tick. // // a.Eventuallyf(func() bool { return true; }, time.Second, 10*time.Millisecond, "error message %s", "formatted") func (a *Assertions) Eventuallyf(condition func() bool, waitFor time.Duration, tick time.Duration, msg string, args ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() } return Eventuallyf(a.t, condition, waitFor, tick, msg, args...) } // Exactly asserts that two objects are equal in value and type. // // a.Exactly(int32(123), int64(123)) func (a *Assertions) Exactly(expected interface{}, actual interface{}, msgAndArgs ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() } return Exactly(a.t, expected, actual, msgAndArgs...) } // Exactlyf asserts that two objects are equal in value and type. // // a.Exactlyf(int32(123, "error message %s", "formatted"), int64(123)) func (a *Assertions) Exactlyf(expected interface{}, actual interface{}, msg string, args ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() } return Exactlyf(a.t, expected, actual, msg, args...) } // Fail reports a failure through func (a *Assertions) Fail(failureMessage string, msgAndArgs ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() } return Fail(a.t, failureMessage, msgAndArgs...) } // FailNow fails test func (a *Assertions) FailNow(failureMessage string, msgAndArgs ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() } return FailNow(a.t, failureMessage, msgAndArgs...) } // FailNowf fails test func (a *Assertions) FailNowf(failureMessage string, msg string, args ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() } return FailNowf(a.t, failureMessage, msg, args...) } // Failf reports a failure through func (a *Assertions) Failf(failureMessage string, msg string, args ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() } return Failf(a.t, failureMessage, msg, args...) } // False asserts that the specified value is false. // // a.False(myBool) func (a *Assertions) False(value bool, msgAndArgs ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() } return False(a.t, value, msgAndArgs...) } // Falsef asserts that the specified value is false. // // a.Falsef(myBool, "error message %s", "formatted") func (a *Assertions) Falsef(value bool, msg string, args ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() } return Falsef(a.t, value, msg, args...) } // FileExists checks whether a file exists in the given path. It also fails if // the path points to a directory or there is an error when trying to check the file. func (a *Assertions) FileExists(path string, msgAndArgs ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() } return FileExists(a.t, path, msgAndArgs...) } // FileExistsf checks whether a file exists in the given path. It also fails if // the path points to a directory or there is an error when trying to check the file. func (a *Assertions) FileExistsf(path string, msg string, args ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() } return FileExistsf(a.t, path, msg, args...) } // Greater asserts that the first element is greater than the second // // a.Greater(2, 1) // a.Greater(float64(2), float64(1)) // a.Greater("b", "a") func (a *Assertions) Greater(e1 interface{}, e2 interface{}, msgAndArgs ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() } return Greater(a.t, e1, e2, msgAndArgs...) } // GreaterOrEqual asserts that the first element is greater than or equal to the second // // a.GreaterOrEqual(2, 1) // a.GreaterOrEqual(2, 2) // a.GreaterOrEqual("b", "a") // a.GreaterOrEqual("b", "b") func (a *Assertions) GreaterOrEqual(e1 interface{}, e2 interface{}, msgAndArgs ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() } return GreaterOrEqual(a.t, e1, e2, msgAndArgs...) } // GreaterOrEqualf asserts that the first element is greater than or equal to the second // // a.GreaterOrEqualf(2, 1, "error message %s", "formatted") // a.GreaterOrEqualf(2, 2, "error message %s", "formatted") // a.GreaterOrEqualf("b", "a", "error message %s", "formatted") // a.GreaterOrEqualf("b", "b", "error message %s", "formatted") func (a *Assertions) GreaterOrEqualf(e1 interface{}, e2 interface{}, msg string, args ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() } return GreaterOrEqualf(a.t, e1, e2, msg, args...) } // Greaterf asserts that the first element is greater than the second // // a.Greaterf(2, 1, "error message %s", "formatted") // a.Greaterf(float64(2, "error message %s", "formatted"), float64(1)) // a.Greaterf("b", "a", "error message %s", "formatted") func (a *Assertions) Greaterf(e1 interface{}, e2 interface{}, msg string, args ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() } return Greaterf(a.t, e1, e2, msg, args...) } // HTTPBodyContains asserts that a specified handler returns a // body that contains a string. // // a.HTTPBodyContains(myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky") // // Returns whether the assertion was successful (true) or not (false). func (a *Assertions) HTTPBodyContains(handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msgAndArgs ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() } return HTTPBodyContains(a.t, handler, method, url, values, str, msgAndArgs...) } // HTTPBodyContainsf asserts that a specified handler returns a // body that contains a string. // // a.HTTPBodyContainsf(myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky", "error message %s", "formatted") // // Returns whether the assertion was successful (true) or not (false). func (a *Assertions) HTTPBodyContainsf(handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msg string, args ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() } return HTTPBodyContainsf(a.t, handler, method, url, values, str, msg, args...) } // HTTPBodyNotContains asserts that a specified handler returns a // body that does not contain a string. // // a.HTTPBodyNotContains(myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky") // // Returns whether the assertion was successful (true) or not (false). func (a *Assertions) HTTPBodyNotContains(handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msgAndArgs ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() } return HTTPBodyNotContains(a.t, handler, method, url, values, str, msgAndArgs...) } // HTTPBodyNotContainsf asserts that a specified handler returns a // body that does not contain a string. // // a.HTTPBodyNotContainsf(myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky", "error message %s", "formatted") // // Returns whether the assertion was successful (true) or not (false). func (a *Assertions) HTTPBodyNotContainsf(handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msg string, args ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() } return HTTPBodyNotContainsf(a.t, handler, method, url, values, str, msg, args...) } // HTTPError asserts that a specified handler returns an error status code. // // a.HTTPError(myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}} // // Returns whether the assertion was successful (true) or not (false). func (a *Assertions) HTTPError(handler http.HandlerFunc, method string, url string, values url.Values, msgAndArgs ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() } return HTTPError(a.t, handler, method, url, values, msgAndArgs...) } // HTTPErrorf asserts that a specified handler returns an error status code. // // a.HTTPErrorf(myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}} // // Returns whether the assertion was successful (true, "error message %s", "formatted") or not (false). func (a *Assertions) HTTPErrorf(handler http.HandlerFunc, method string, url string, values url.Values, msg string, args ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() } return HTTPErrorf(a.t, handler, method, url, values, msg, args...) } // HTTPRedirect asserts that a specified handler returns a redirect status code. // // a.HTTPRedirect(myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}} // // Returns whether the assertion was successful (true) or not (false). func (a *Assertions) HTTPRedirect(handler http.HandlerFunc, method string, url string, values url.Values, msgAndArgs ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() } return HTTPRedirect(a.t, handler, method, url, values, msgAndArgs...) } // HTTPRedirectf asserts that a specified handler returns a redirect status code. // // a.HTTPRedirectf(myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}} // // Returns whether the assertion was successful (true, "error message %s", "formatted") or not (false). func (a *Assertions) HTTPRedirectf(handler http.HandlerFunc, method string, url string, values url.Values, msg string, args ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() } return HTTPRedirectf(a.t, handler, method, url, values, msg, args...) } // HTTPSuccess asserts that a specified handler returns a success status code. // // a.HTTPSuccess(myHandler, "POST", "http://www.google.com", nil) // // Returns whether the assertion was successful (true) or not (false). func (a *Assertions) HTTPSuccess(handler http.HandlerFunc, method string, url string, values url.Values, msgAndArgs ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() } return HTTPSuccess(a.t, handler, method, url, values, msgAndArgs...) } // HTTPSuccessf asserts that a specified handler returns a success status code. // // a.HTTPSuccessf(myHandler, "POST", "http://www.google.com", nil, "error message %s", "formatted") // // Returns whether the assertion was successful (true) or not (false). func (a *Assertions) HTTPSuccessf(handler http.HandlerFunc, method string, url string, values url.Values, msg string, args ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() } return HTTPSuccessf(a.t, handler, method, url, values, msg, args...) } // Implements asserts that an object is implemented by the specified interface. // // a.Implements((*MyInterface)(nil), new(MyObject)) func (a *Assertions) Implements(interfaceObject interface{}, object interface{}, msgAndArgs ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() } return Implements(a.t, interfaceObject, object, msgAndArgs...) } // Implementsf asserts that an object is implemented by the specified interface. // // a.Implementsf((*MyInterface, "error message %s", "formatted")(nil), new(MyObject)) func (a *Assertions) Implementsf(interfaceObject interface{}, object interface{}, msg string, args ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() } return Implementsf(a.t, interfaceObject, object, msg, args...) } // InDelta asserts that the two numerals are within delta of each other. // // a.InDelta(math.Pi, 22/7.0, 0.01) func (a *Assertions) InDelta(expected interface{}, actual interface{}, delta float64, msgAndArgs ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() } return InDelta(a.t, expected, actual, delta, msgAndArgs...) } // InDeltaMapValues is the same as InDelta, but it compares all values between two maps. Both maps must have exactly the same keys. func (a *Assertions) InDeltaMapValues(expected interface{}, actual interface{}, delta float64, msgAndArgs ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() } return InDeltaMapValues(a.t, expected, actual, delta, msgAndArgs...) } // InDeltaMapValuesf is the same as InDelta, but it compares all values between two maps. Both maps must have exactly the same keys. func (a *Assertions) InDeltaMapValuesf(expected interface{}, actual interface{}, delta float64, msg string, args ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() } return InDeltaMapValuesf(a.t, expected, actual, delta, msg, args...) } // InDeltaSlice is the same as InDelta, except it compares two slices. func (a *Assertions) InDeltaSlice(expected interface{}, actual interface{}, delta float64, msgAndArgs ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() } return InDeltaSlice(a.t, expected, actual, delta, msgAndArgs...) } // InDeltaSlicef is the same as InDelta, except it compares two slices. func (a *Assertions) InDeltaSlicef(expected interface{}, actual interface{}, delta float64, msg string, args ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() } return InDeltaSlicef(a.t, expected, actual, delta, msg, args...) } // InDeltaf asserts that the two numerals are within delta of each other. // // a.InDeltaf(math.Pi, 22/7.0, 0.01, "error message %s", "formatted") func (a *Assertions) InDeltaf(expected interface{}, actual interface{}, delta float64, msg string, args ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() } return InDeltaf(a.t, expected, actual, delta, msg, args...) } // InEpsilon asserts that expected and actual have a relative error less than epsilon func (a *Assertions) InEpsilon(expected interface{}, actual interface{}, epsilon float64, msgAndArgs ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() } return InEpsilon(a.t, expected, actual, epsilon, msgAndArgs...) } // InEpsilonSlice is the same as InEpsilon, except it compares each value from two slices. func (a *Assertions) InEpsilonSlice(expected interface{}, actual interface{}, epsilon float64, msgAndArgs ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() } return InEpsilonSlice(a.t, expected, actual, epsilon, msgAndArgs...) } // InEpsilonSlicef is the same as InEpsilon, except it compares each value from two slices. func (a *Assertions) InEpsilonSlicef(expected interface{}, actual interface{}, epsilon float64, msg string, args ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() } return InEpsilonSlicef(a.t, expected, actual, epsilon, msg, args...) } // InEpsilonf asserts that expected and actual have a relative error less than epsilon func (a *Assertions) InEpsilonf(expected interface{}, actual interface{}, epsilon float64, msg string, args ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() } return InEpsilonf(a.t, expected, actual, epsilon, msg, args...) } // IsType asserts that the specified objects are of the same type. func (a *Assertions) IsType(expectedType interface{}, object interface{}, msgAndArgs ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() } return IsType(a.t, expectedType, object, msgAndArgs...) } // IsTypef asserts that the specified objects are of the same type. func (a *Assertions) IsTypef(expectedType interface{}, object interface{}, msg string, args ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() } return IsTypef(a.t, expectedType, object, msg, args...) } // JSONEq asserts that two JSON strings are equivalent. // // a.JSONEq(`{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`) func (a *Assertions) JSONEq(expected string, actual string, msgAndArgs ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() } return JSONEq(a.t, expected, actual, msgAndArgs...) } // JSONEqf asserts that two JSON strings are equivalent. // // a.JSONEqf(`{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`, "error message %s", "formatted") func (a *Assertions) JSONEqf(expected string, actual string, msg string, args ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() } return JSONEqf(a.t, expected, actual, msg, args...) } // Len asserts that the specified object has specific length. // Len also fails if the object has a type that len() not accept. // // a.Len(mySlice, 3) func (a *Assertions) Len(object interface{}, length int, msgAndArgs ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() } return Len(a.t, object, length, msgAndArgs...) } // Lenf asserts that the specified object has specific length. // Lenf also fails if the object has a type that len() not accept. // // a.Lenf(mySlice, 3, "error message %s", "formatted") func (a *Assertions) Lenf(object interface{}, length int, msg string, args ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() } return Lenf(a.t, object, length, msg, args...) } // Less asserts that the first element is less than the second // // a.Less(1, 2) // a.Less(float64(1), float64(2)) // a.Less("a", "b") func (a *Assertions) Less(e1 interface{}, e2 interface{}, msgAndArgs ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() } return Less(a.t, e1, e2, msgAndArgs...) } // LessOrEqual asserts that the first element is less than or equal to the second // // a.LessOrEqual(1, 2) // a.LessOrEqual(2, 2) // a.LessOrEqual("a", "b") // a.LessOrEqual("b", "b") func (a *Assertions) LessOrEqual(e1 interface{}, e2 interface{}, msgAndArgs ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() } return LessOrEqual(a.t, e1, e2, msgAndArgs...) } // LessOrEqualf asserts that the first element is less than or equal to the second // // a.LessOrEqualf(1, 2, "error message %s", "formatted") // a.LessOrEqualf(2, 2, "error message %s", "formatted") // a.LessOrEqualf("a", "b", "error message %s", "formatted") // a.LessOrEqualf("b", "b", "error message %s", "formatted") func (a *Assertions) LessOrEqualf(e1 interface{}, e2 interface{}, msg string, args ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() } return LessOrEqualf(a.t, e1, e2, msg, args...) } // Lessf asserts that the first element is less than the second // // a.Lessf(1, 2, "error message %s", "formatted") // a.Lessf(float64(1, "error message %s", "formatted"), float64(2)) // a.Lessf("a", "b", "error message %s", "formatted") func (a *Assertions) Lessf(e1 interface{}, e2 interface{}, msg string, args ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() } return Lessf(a.t, e1, e2, msg, args...) } // Never asserts that the given condition doesn't satisfy in waitFor time, // periodically checking the target function each tick. // // a.Never(func() bool { return false; }, time.Second, 10*time.Millisecond) func (a *Assertions) Never(condition func() bool, waitFor time.Duration, tick time.Duration, msgAndArgs ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() } return Never(a.t, condition, waitFor, tick, msgAndArgs...) } // Neverf asserts that the given condition doesn't satisfy in waitFor time, // periodically checking the target function each tick. // // a.Neverf(func() bool { return false; }, time.Second, 10*time.Millisecond, "error message %s", "formatted") func (a *Assertions) Neverf(condition func() bool, waitFor time.Duration, tick time.Duration, msg string, args ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() } return Neverf(a.t, condition, waitFor, tick, msg, args...) } // Nil asserts that the specified object is nil. // // a.Nil(err) func (a *Assertions) Nil(object interface{}, msgAndArgs ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() } return Nil(a.t, object, msgAndArgs...) } // Nilf asserts that the specified object is nil. // // a.Nilf(err, "error message %s", "formatted") func (a *Assertions) Nilf(object interface{}, msg string, args ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() } return Nilf(a.t, object, msg, args...) } // NoDirExists checks whether a directory does not exist in the given path. // It fails if the path points to an existing _directory_ only. func (a *Assertions) NoDirExists(path string, msgAndArgs ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() } return NoDirExists(a.t, path, msgAndArgs...) } // NoDirExistsf checks whether a directory does not exist in the given path. // It fails if the path points to an existing _directory_ only. func (a *Assertions) NoDirExistsf(path string, msg string, args ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() } return NoDirExistsf(a.t, path, msg, args...) } // NoError asserts that a function returned no error (i.e. `nil`). // // actualObj, err := SomeFunction() // if a.NoError(err) { // assert.Equal(t, expectedObj, actualObj) // } func (a *Assertions) NoError(err error, msgAndArgs ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() } return NoError(a.t, err, msgAndArgs...) } // NoErrorf asserts that a function returned no error (i.e. `nil`). // // actualObj, err := SomeFunction() // if a.NoErrorf(err, "error message %s", "formatted") { // assert.Equal(t, expectedObj, actualObj) // } func (a *Assertions) NoErrorf(err error, msg string, args ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() } return NoErrorf(a.t, err, msg, args...) } // NoFileExists checks whether a file does not exist in a given path. It fails // if the path points to an existing _file_ only. func (a *Assertions) NoFileExists(path string, msgAndArgs ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() } return NoFileExists(a.t, path, msgAndArgs...) } // NoFileExistsf checks whether a file does not exist in a given path. It fails // if the path points to an existing _file_ only. func (a *Assertions) NoFileExistsf(path string, msg string, args ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() } return NoFileExistsf(a.t, path, msg, args...) } // NotContains asserts that the specified string, list(array, slice...) or map does NOT contain the // specified substring or element. // // a.NotContains("Hello World", "Earth") // a.NotContains(["Hello", "World"], "Earth") // a.NotContains({"Hello": "World"}, "Earth") func (a *Assertions) NotContains(s interface{}, contains interface{}, msgAndArgs ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() } return NotContains(a.t, s, contains, msgAndArgs...) } // NotContainsf asserts that the specified string, list(array, slice...) or map does NOT contain the // specified substring or element. // // a.NotContainsf("Hello World", "Earth", "error message %s", "formatted") // a.NotContainsf(["Hello", "World"], "Earth", "error message %s", "formatted") // a.NotContainsf({"Hello": "World"}, "Earth", "error message %s", "formatted") func (a *Assertions) NotContainsf(s interface{}, contains interface{}, msg string, args ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() } return NotContainsf(a.t, s, contains, msg, args...) } // NotEmpty asserts that the specified object is NOT empty. I.e. not nil, "", false, 0 or either // a slice or a channel with len == 0. // // if a.NotEmpty(obj) { // assert.Equal(t, "two", obj[1]) // } func (a *Assertions) NotEmpty(object interface{}, msgAndArgs ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() } return NotEmpty(a.t, object, msgAndArgs...) } // NotEmptyf asserts that the specified object is NOT empty. I.e. not nil, "", false, 0 or either // a slice or a channel with len == 0. // // if a.NotEmptyf(obj, "error message %s", "formatted") { // assert.Equal(t, "two", obj[1]) // } func (a *Assertions) NotEmptyf(object interface{}, msg string, args ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() } return NotEmptyf(a.t, object, msg, args...) } // NotEqual asserts that the specified values are NOT equal. // // a.NotEqual(obj1, obj2) // // Pointer variable equality is determined based on the equality of the // referenced values (as opposed to the memory addresses). func (a *Assertions) NotEqual(expected interface{}, actual interface{}, msgAndArgs ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() } return NotEqual(a.t, expected, actual, msgAndArgs...) } // NotEqualf asserts that the specified values are NOT equal. // // a.NotEqualf(obj1, obj2, "error message %s", "formatted") // // Pointer variable equality is determined based on the equality of the // referenced values (as opposed to the memory addresses). func (a *Assertions) NotEqualf(expected interface{}, actual interface{}, msg string, args ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() } return NotEqualf(a.t, expected, actual, msg, args...) } // NotNil asserts that the specified object is not nil. // // a.NotNil(err) func (a *Assertions) NotNil(object interface{}, msgAndArgs ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() } return NotNil(a.t, object, msgAndArgs...) } // NotNilf asserts that the specified object is not nil. // // a.NotNilf(err, "error message %s", "formatted") func (a *Assertions) NotNilf(object interface{}, msg string, args ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() } return NotNilf(a.t, object, msg, args...) } // NotPanics asserts that the code inside the specified PanicTestFunc does NOT panic. // // a.NotPanics(func(){ RemainCalm() }) func (a *Assertions) NotPanics(f PanicTestFunc, msgAndArgs ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() } return NotPanics(a.t, f, msgAndArgs...) } // NotPanicsf asserts that the code inside the specified PanicTestFunc does NOT panic. // // a.NotPanicsf(func(){ RemainCalm() }, "error message %s", "formatted") func (a *Assertions) NotPanicsf(f PanicTestFunc, msg string, args ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() } return NotPanicsf(a.t, f, msg, args...) } // NotRegexp asserts that a specified regexp does not match a string. // // a.NotRegexp(regexp.MustCompile("starts"), "it's starting") // a.NotRegexp("^start", "it's not starting") func (a *Assertions) NotRegexp(rx interface{}, str interface{}, msgAndArgs ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() } return NotRegexp(a.t, rx, str, msgAndArgs...) } // NotRegexpf asserts that a specified regexp does not match a string. // // a.NotRegexpf(regexp.MustCompile("starts", "error message %s", "formatted"), "it's starting") // a.NotRegexpf("^start", "it's not starting", "error message %s", "formatted") func (a *Assertions) NotRegexpf(rx interface{}, str interface{}, msg string, args ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() } return NotRegexpf(a.t, rx, str, msg, args...) } // NotSame asserts that two pointers do not reference the same object. // // a.NotSame(ptr1, ptr2) // // Both arguments must be pointer variables. Pointer variable sameness is // determined based on the equality of both type and value. func (a *Assertions) NotSame(expected interface{}, actual interface{}, msgAndArgs ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() } return NotSame(a.t, expected, actual, msgAndArgs...) } // NotSamef asserts that two pointers do not reference the same object. // // a.NotSamef(ptr1, ptr2, "error message %s", "formatted") // // Both arguments must be pointer variables. Pointer variable sameness is // determined based on the equality of both type and value. func (a *Assertions) NotSamef(expected interface{}, actual interface{}, msg string, args ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() } return NotSamef(a.t, expected, actual, msg, args...) } // NotSubset asserts that the specified list(array, slice...) contains not all // elements given in the specified subset(array, slice...). // // a.NotSubset([1, 3, 4], [1, 2], "But [1, 3, 4] does not contain [1, 2]") func (a *Assertions) NotSubset(list interface{}, subset interface{}, msgAndArgs ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() } return NotSubset(a.t, list, subset, msgAndArgs...) } // NotSubsetf asserts that the specified list(array, slice...) contains not all // elements given in the specified subset(array, slice...). // // a.NotSubsetf([1, 3, 4], [1, 2], "But [1, 3, 4] does not contain [1, 2]", "error message %s", "formatted") func (a *Assertions) NotSubsetf(list interface{}, subset interface{}, msg string, args ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() } return NotSubsetf(a.t, list, subset, msg, args...) } // NotZero asserts that i is not the zero value for its type. func (a *Assertions) NotZero(i interface{}, msgAndArgs ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() } return NotZero(a.t, i, msgAndArgs...) } // NotZerof asserts that i is not the zero value for its type. func (a *Assertions) NotZerof(i interface{}, msg string, args ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() } return NotZerof(a.t, i, msg, args...) } // Panics asserts that the code inside the specified PanicTestFunc panics. // // a.Panics(func(){ GoCrazy() }) func (a *Assertions) Panics(f PanicTestFunc, msgAndArgs ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() } return Panics(a.t, f, msgAndArgs...) } // PanicsWithError asserts that the code inside the specified PanicTestFunc // panics, and that the recovered panic value is an error that satisfies the // EqualError comparison. // // a.PanicsWithError("crazy error", func(){ GoCrazy() }) func (a *Assertions) PanicsWithError(errString string, f PanicTestFunc, msgAndArgs ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() } return PanicsWithError(a.t, errString, f, msgAndArgs...) } // PanicsWithErrorf asserts that the code inside the specified PanicTestFunc // panics, and that the recovered panic value is an error that satisfies the // EqualError comparison. // // a.PanicsWithErrorf("crazy error", func(){ GoCrazy() }, "error message %s", "formatted") func (a *Assertions) PanicsWithErrorf(errString string, f PanicTestFunc, msg string, args ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() } return PanicsWithErrorf(a.t, errString, f, msg, args...) } // PanicsWithValue asserts that the code inside the specified PanicTestFunc panics, and that // the recovered panic value equals the expected panic value. // // a.PanicsWithValue("crazy error", func(){ GoCrazy() }) func (a *Assertions) PanicsWithValue(expected interface{}, f PanicTestFunc, msgAndArgs ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() } return PanicsWithValue(a.t, expected, f, msgAndArgs...) } // PanicsWithValuef asserts that the code inside the specified PanicTestFunc panics, and that // the recovered panic value equals the expected panic value. // // a.PanicsWithValuef("crazy error", func(){ GoCrazy() }, "error message %s", "formatted") func (a *Assertions) PanicsWithValuef(expected interface{}, f PanicTestFunc, msg string, args ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() } return PanicsWithValuef(a.t, expected, f, msg, args...) } // Panicsf asserts that the code inside the specified PanicTestFunc panics. // // a.Panicsf(func(){ GoCrazy() }, "error message %s", "formatted") func (a *Assertions) Panicsf(f PanicTestFunc, msg string, args ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() } return Panicsf(a.t, f, msg, args...) } // Regexp asserts that a specified regexp matches a string. // // a.Regexp(regexp.MustCompile("start"), "it's starting") // a.Regexp("start...$", "it's not starting") func (a *Assertions) Regexp(rx interface{}, str interface{}, msgAndArgs ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() } return Regexp(a.t, rx, str, msgAndArgs...) } // Regexpf asserts that a specified regexp matches a string. // // a.Regexpf(regexp.MustCompile("start", "error message %s", "formatted"), "it's starting") // a.Regexpf("start...$", "it's not starting", "error message %s", "formatted") func (a *Assertions) Regexpf(rx interface{}, str interface{}, msg string, args ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() } return Regexpf(a.t, rx, str, msg, args...) } // Same asserts that two pointers reference the same object. // // a.Same(ptr1, ptr2) // // Both arguments must be pointer variables. Pointer variable sameness is // determined based on the equality of both type and value. func (a *Assertions) Same(expected interface{}, actual interface{}, msgAndArgs ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() } return Same(a.t, expected, actual, msgAndArgs...) } // Samef asserts that two pointers reference the same object. // // a.Samef(ptr1, ptr2, "error message %s", "formatted") // // Both arguments must be pointer variables. Pointer variable sameness is // determined based on the equality of both type and value. func (a *Assertions) Samef(expected interface{}, actual interface{}, msg string, args ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() } return Samef(a.t, expected, actual, msg, args...) } // Subset asserts that the specified list(array, slice...) contains all // elements given in the specified subset(array, slice...). // // a.Subset([1, 2, 3], [1, 2], "But [1, 2, 3] does contain [1, 2]") func (a *Assertions) Subset(list interface{}, subset interface{}, msgAndArgs ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() } return Subset(a.t, list, subset, msgAndArgs...) } // Subsetf asserts that the specified list(array, slice...) contains all // elements given in the specified subset(array, slice...). // // a.Subsetf([1, 2, 3], [1, 2], "But [1, 2, 3] does contain [1, 2]", "error message %s", "formatted") func (a *Assertions) Subsetf(list interface{}, subset interface{}, msg string, args ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() } return Subsetf(a.t, list, subset, msg, args...) } // True asserts that the specified value is true. // // a.True(myBool) func (a *Assertions) True(value bool, msgAndArgs ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() } return True(a.t, value, msgAndArgs...) } // Truef asserts that the specified value is true. // // a.Truef(myBool, "error message %s", "formatted") func (a *Assertions) Truef(value bool, msg string, args ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() } return Truef(a.t, value, msg, args...) } // WithinDuration asserts that the two times are within duration delta of each other. // // a.WithinDuration(time.Now(), time.Now(), 10*time.Second) func (a *Assertions) WithinDuration(expected time.Time, actual time.Time, delta time.Duration, msgAndArgs ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() } return WithinDuration(a.t, expected, actual, delta, msgAndArgs...) } // WithinDurationf asserts that the two times are within duration delta of each other. // // a.WithinDurationf(time.Now(), time.Now(), 10*time.Second, "error message %s", "formatted") func (a *Assertions) WithinDurationf(expected time.Time, actual time.Time, delta time.Duration, msg string, args ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() } return WithinDurationf(a.t, expected, actual, delta, msg, args...) } // YAMLEq asserts that two YAML strings are equivalent. func (a *Assertions) YAMLEq(expected string, actual string, msgAndArgs ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() } return YAMLEq(a.t, expected, actual, msgAndArgs...) } // YAMLEqf asserts that two YAML strings are equivalent. func (a *Assertions) YAMLEqf(expected string, actual string, msg string, args ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() } return YAMLEqf(a.t, expected, actual, msg, args...) } // Zero asserts that i is the zero value for its type. func (a *Assertions) Zero(i interface{}, msgAndArgs ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() } return Zero(a.t, i, msgAndArgs...) } // Zerof asserts that i is the zero value for its type. func (a *Assertions) Zerof(i interface{}, msg string, args ...interface{}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() } return Zerof(a.t, i, msg, args...) } go-jmespath-0.4.0/internal/testify/assert/assertion_forward.go.tmpl000066400000000000000000000002711373124421700255760ustar00rootroot00000000000000{{.CommentWithoutT "a"}} func (a *Assertions) {{.DocInfo.Name}}({{.Params}}) bool { if h, ok := a.t.(tHelper); ok { h.Helper() } return {{.DocInfo.Name}}(a.t, {{.ForwardedParams}}) } go-jmespath-0.4.0/internal/testify/assert/assertion_order.go000066400000000000000000000151321373124421700242740ustar00rootroot00000000000000package assert import ( "fmt" "reflect" ) func compare(obj1, obj2 interface{}, kind reflect.Kind) (int, bool) { switch kind { case reflect.Int: { intobj1 := obj1.(int) intobj2 := obj2.(int) if intobj1 > intobj2 { return -1, true } if intobj1 == intobj2 { return 0, true } if intobj1 < intobj2 { return 1, true } } case reflect.Int8: { int8obj1 := obj1.(int8) int8obj2 := obj2.(int8) if int8obj1 > int8obj2 { return -1, true } if int8obj1 == int8obj2 { return 0, true } if int8obj1 < int8obj2 { return 1, true } } case reflect.Int16: { int16obj1 := obj1.(int16) int16obj2 := obj2.(int16) if int16obj1 > int16obj2 { return -1, true } if int16obj1 == int16obj2 { return 0, true } if int16obj1 < int16obj2 { return 1, true } } case reflect.Int32: { int32obj1 := obj1.(int32) int32obj2 := obj2.(int32) if int32obj1 > int32obj2 { return -1, true } if int32obj1 == int32obj2 { return 0, true } if int32obj1 < int32obj2 { return 1, true } } case reflect.Int64: { int64obj1 := obj1.(int64) int64obj2 := obj2.(int64) if int64obj1 > int64obj2 { return -1, true } if int64obj1 == int64obj2 { return 0, true } if int64obj1 < int64obj2 { return 1, true } } case reflect.Uint: { uintobj1 := obj1.(uint) uintobj2 := obj2.(uint) if uintobj1 > uintobj2 { return -1, true } if uintobj1 == uintobj2 { return 0, true } if uintobj1 < uintobj2 { return 1, true } } case reflect.Uint8: { uint8obj1 := obj1.(uint8) uint8obj2 := obj2.(uint8) if uint8obj1 > uint8obj2 { return -1, true } if uint8obj1 == uint8obj2 { return 0, true } if uint8obj1 < uint8obj2 { return 1, true } } case reflect.Uint16: { uint16obj1 := obj1.(uint16) uint16obj2 := obj2.(uint16) if uint16obj1 > uint16obj2 { return -1, true } if uint16obj1 == uint16obj2 { return 0, true } if uint16obj1 < uint16obj2 { return 1, true } } case reflect.Uint32: { uint32obj1 := obj1.(uint32) uint32obj2 := obj2.(uint32) if uint32obj1 > uint32obj2 { return -1, true } if uint32obj1 == uint32obj2 { return 0, true } if uint32obj1 < uint32obj2 { return 1, true } } case reflect.Uint64: { uint64obj1 := obj1.(uint64) uint64obj2 := obj2.(uint64) if uint64obj1 > uint64obj2 { return -1, true } if uint64obj1 == uint64obj2 { return 0, true } if uint64obj1 < uint64obj2 { return 1, true } } case reflect.Float32: { float32obj1 := obj1.(float32) float32obj2 := obj2.(float32) if float32obj1 > float32obj2 { return -1, true } if float32obj1 == float32obj2 { return 0, true } if float32obj1 < float32obj2 { return 1, true } } case reflect.Float64: { float64obj1 := obj1.(float64) float64obj2 := obj2.(float64) if float64obj1 > float64obj2 { return -1, true } if float64obj1 == float64obj2 { return 0, true } if float64obj1 < float64obj2 { return 1, true } } case reflect.String: { stringobj1 := obj1.(string) stringobj2 := obj2.(string) if stringobj1 > stringobj2 { return -1, true } if stringobj1 == stringobj2 { return 0, true } if stringobj1 < stringobj2 { return 1, true } } } return 0, false } // Greater asserts that the first element is greater than the second // // assert.Greater(t, 2, 1) // assert.Greater(t, float64(2), float64(1)) // assert.Greater(t, "b", "a") func Greater(t TestingT, e1 interface{}, e2 interface{}, msgAndArgs ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() } e1Kind := reflect.ValueOf(e1).Kind() e2Kind := reflect.ValueOf(e2).Kind() if e1Kind != e2Kind { return Fail(t, "Elements should be the same type", msgAndArgs...) } res, isComparable := compare(e1, e2, e1Kind) if !isComparable { return Fail(t, fmt.Sprintf("Can not compare type \"%s\"", reflect.TypeOf(e1)), msgAndArgs...) } if res != -1 { return Fail(t, fmt.Sprintf("\"%v\" is not greater than \"%v\"", e1, e2), msgAndArgs...) } return true } // GreaterOrEqual asserts that the first element is greater than or equal to the second // // assert.GreaterOrEqual(t, 2, 1) // assert.GreaterOrEqual(t, 2, 2) // assert.GreaterOrEqual(t, "b", "a") // assert.GreaterOrEqual(t, "b", "b") func GreaterOrEqual(t TestingT, e1 interface{}, e2 interface{}, msgAndArgs ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() } e1Kind := reflect.ValueOf(e1).Kind() e2Kind := reflect.ValueOf(e2).Kind() if e1Kind != e2Kind { return Fail(t, "Elements should be the same type", msgAndArgs...) } res, isComparable := compare(e1, e2, e1Kind) if !isComparable { return Fail(t, fmt.Sprintf("Can not compare type \"%s\"", reflect.TypeOf(e1)), msgAndArgs...) } if res != -1 && res != 0 { return Fail(t, fmt.Sprintf("\"%v\" is not greater than or equal to \"%v\"", e1, e2), msgAndArgs...) } return true } // Less asserts that the first element is less than the second // // assert.Less(t, 1, 2) // assert.Less(t, float64(1), float64(2)) // assert.Less(t, "a", "b") func Less(t TestingT, e1 interface{}, e2 interface{}, msgAndArgs ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() } e1Kind := reflect.ValueOf(e1).Kind() e2Kind := reflect.ValueOf(e2).Kind() if e1Kind != e2Kind { return Fail(t, "Elements should be the same type", msgAndArgs...) } res, isComparable := compare(e1, e2, e1Kind) if !isComparable { return Fail(t, fmt.Sprintf("Can not compare type \"%s\"", reflect.TypeOf(e1)), msgAndArgs...) } if res != 1 { return Fail(t, fmt.Sprintf("\"%v\" is not less than \"%v\"", e1, e2), msgAndArgs...) } return true } // LessOrEqual asserts that the first element is less than or equal to the second // // assert.LessOrEqual(t, 1, 2) // assert.LessOrEqual(t, 2, 2) // assert.LessOrEqual(t, "a", "b") // assert.LessOrEqual(t, "b", "b") func LessOrEqual(t TestingT, e1 interface{}, e2 interface{}, msgAndArgs ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() } e1Kind := reflect.ValueOf(e1).Kind() e2Kind := reflect.ValueOf(e2).Kind() if e1Kind != e2Kind { return Fail(t, "Elements should be the same type", msgAndArgs...) } res, isComparable := compare(e1, e2, e1Kind) if !isComparable { return Fail(t, fmt.Sprintf("Can not compare type \"%s\"", reflect.TypeOf(e1)), msgAndArgs...) } if res != 1 && res != 0 { return Fail(t, fmt.Sprintf("\"%v\" is not less than or equal to \"%v\"", e1, e2), msgAndArgs...) } return true } go-jmespath-0.4.0/internal/testify/assert/assertion_order_test.go000066400000000000000000000055201373124421700253330ustar00rootroot00000000000000package assert import ( "reflect" "testing" ) func TestCompare(t *testing.T) { for _, currCase := range []struct { less interface{} greater interface{} cType string }{ {less: "a", greater: "b", cType: "string"}, {less: int(1), greater: int(2), cType: "int"}, {less: int8(1), greater: int8(2), cType: "int8"}, {less: int16(1), greater: int16(2), cType: "int16"}, {less: int32(1), greater: int32(2), cType: "int32"}, {less: int64(1), greater: int64(2), cType: "int64"}, {less: uint8(1), greater: uint8(2), cType: "uint8"}, {less: uint16(1), greater: uint16(2), cType: "uint16"}, {less: uint32(1), greater: uint32(2), cType: "uint32"}, {less: uint64(1), greater: uint64(2), cType: "uint64"}, {less: float32(1), greater: float32(2), cType: "float32"}, {less: float64(1), greater: float64(2), cType: "float64"}, } { resLess, isComparable := compare(currCase.less, currCase.greater, reflect.ValueOf(currCase.less).Kind()) if !isComparable { t.Error("object should be comparable for type " + currCase.cType) } if resLess != 1 { t.Errorf("object less should be less than greater for type " + currCase.cType) } resGreater, isComparable := compare(currCase.greater, currCase.less, reflect.ValueOf(currCase.less).Kind()) if !isComparable { t.Error("object are comparable for type " + currCase.cType) } if resGreater != -1 { t.Errorf("object greater should be greater than less for type " + currCase.cType) } resEqual, isComparable := compare(currCase.less, currCase.less, reflect.ValueOf(currCase.less).Kind()) if !isComparable { t.Error("object are comparable for type " + currCase.cType) } if resEqual != 0 { t.Errorf("objects should be equal for type " + currCase.cType) } } } func TestGreater(t *testing.T) { mockT := new(testing.T) if !Greater(mockT, 2, 1) { t.Error("Greater should return true") } if Greater(mockT, 1, 1) { t.Error("Greater should return false") } if Greater(mockT, 1, 2) { t.Error("Greater should return false") } } func TestGreaterOrEqual(t *testing.T) { mockT := new(testing.T) if !GreaterOrEqual(mockT, 2, 1) { t.Error("Greater should return true") } if !GreaterOrEqual(mockT, 1, 1) { t.Error("Greater should return true") } if GreaterOrEqual(mockT, 1, 2) { t.Error("Greater should return false") } } func TestLess(t *testing.T) { mockT := new(testing.T) if !Less(mockT, 1, 2) { t.Error("Less should return true") } if Less(mockT, 1, 1) { t.Error("Less should return false") } if Less(mockT, 2, 1) { t.Error("Less should return false") } } func TestLessOrEqual(t *testing.T) { mockT := new(testing.T) if !LessOrEqual(mockT, 1, 2) { t.Error("Greater should return true") } if !LessOrEqual(mockT, 1, 1) { t.Error("Greater should return true") } if LessOrEqual(mockT, 2, 1) { t.Error("Greater should return false") } } go-jmespath-0.4.0/internal/testify/assert/assertions.go000066400000000000000000001313701373124421700232670ustar00rootroot00000000000000package assert import ( "bufio" "bytes" "encoding/json" "errors" "fmt" "math" "os" "reflect" "regexp" "runtime" "runtime/debug" "strings" "time" "unicode" "unicode/utf8" "github.com/davecgh/go-spew/spew" "github.com/pmezard/go-difflib/difflib" yaml "gopkg.in/yaml.v2" ) //go:generate sh -c "cd ../_codegen && go build && cd - && ../_codegen/_codegen -output-package=assert -template=assertion_format.go.tmpl" // TestingT is an interface wrapper around *testing.T type TestingT interface { Errorf(format string, args ...interface{}) } // ComparisonAssertionFunc is a common function prototype when comparing two values. Can be useful // for table driven tests. type ComparisonAssertionFunc func(TestingT, interface{}, interface{}, ...interface{}) bool // ValueAssertionFunc is a common function prototype when validating a single value. Can be useful // for table driven tests. type ValueAssertionFunc func(TestingT, interface{}, ...interface{}) bool // BoolAssertionFunc is a common function prototype when validating a bool value. Can be useful // for table driven tests. type BoolAssertionFunc func(TestingT, bool, ...interface{}) bool // ErrorAssertionFunc is a common function prototype when validating an error value. Can be useful // for table driven tests. type ErrorAssertionFunc func(TestingT, error, ...interface{}) bool // Comparison a custom function that returns true on success and false on failure type Comparison func() (success bool) /* Helper functions */ // ObjectsAreEqual determines if two objects are considered equal. // // This function does no assertion of any kind. func ObjectsAreEqual(expected, actual interface{}) bool { if expected == nil || actual == nil { return expected == actual } exp, ok := expected.([]byte) if !ok { return reflect.DeepEqual(expected, actual) } act, ok := actual.([]byte) if !ok { return false } if exp == nil || act == nil { return exp == nil && act == nil } return bytes.Equal(exp, act) } // ObjectsAreEqualValues gets whether two objects are equal, or if their // values are equal. func ObjectsAreEqualValues(expected, actual interface{}) bool { if ObjectsAreEqual(expected, actual) { return true } actualType := reflect.TypeOf(actual) if actualType == nil { return false } expectedValue := reflect.ValueOf(expected) if expectedValue.IsValid() && expectedValue.Type().ConvertibleTo(actualType) { // Attempt comparison after type conversion return reflect.DeepEqual(expectedValue.Convert(actualType).Interface(), actual) } return false } /* CallerInfo is necessary because the assert functions use the testing object internally, causing it to print the file:line of the assert method, rather than where the problem actually occurred in calling code.*/ // CallerInfo returns an array of strings containing the file and line number // of each stack frame leading from the current test to the assert call that // failed. func CallerInfo() []string { pc := uintptr(0) file := "" line := 0 ok := false name := "" callers := []string{} for i := 0; ; i++ { pc, file, line, ok = runtime.Caller(i) if !ok { // The breaks below failed to terminate the loop, and we ran off the // end of the call stack. break } // This is a huge edge case, but it will panic if this is the case, see #180 if file == "" { break } f := runtime.FuncForPC(pc) if f == nil { break } name = f.Name() // testing.tRunner is the standard library function that calls // tests. Subtests are called directly by tRunner, without going through // the Test/Benchmark/Example function that contains the t.Run calls, so // with subtests we should break when we hit tRunner, without adding it // to the list of callers. if name == "testing.tRunner" { break } parts := strings.Split(file, "/") file = parts[len(parts)-1] if len(parts) > 1 { dir := parts[len(parts)-2] if (dir != "assert" && dir != "mock" && dir != "require") || file == "mock_test.go" { callers = append(callers, fmt.Sprintf("%s:%d", file, line)) } } // Drop the package segments := strings.Split(name, ".") name = segments[len(segments)-1] if isTest(name, "Test") || isTest(name, "Benchmark") || isTest(name, "Example") { break } } return callers } // Stolen from the `go test` tool. // isTest tells whether name looks like a test (or benchmark, according to prefix). // It is a Test (say) if there is a character after Test that is not a lower-case letter. // We don't want TesticularCancer. func isTest(name, prefix string) bool { if !strings.HasPrefix(name, prefix) { return false } if len(name) == len(prefix) { // "Test" is ok return true } rune, _ := utf8.DecodeRuneInString(name[len(prefix):]) return !unicode.IsLower(rune) } func messageFromMsgAndArgs(msgAndArgs ...interface{}) string { if len(msgAndArgs) == 0 || msgAndArgs == nil { return "" } if len(msgAndArgs) == 1 { msg := msgAndArgs[0] if msgAsStr, ok := msg.(string); ok { return msgAsStr } return fmt.Sprintf("%+v", msg) } if len(msgAndArgs) > 1 { return fmt.Sprintf(msgAndArgs[0].(string), msgAndArgs[1:]...) } return "" } // Aligns the provided message so that all lines after the first line start at the same location as the first line. // Assumes that the first line starts at the correct location (after carriage return, tab, label, spacer and tab). // The longestLabelLen parameter specifies the length of the longest label in the output (required becaues this is the // basis on which the alignment occurs). func indentMessageLines(message string, longestLabelLen int) string { outBuf := new(bytes.Buffer) for i, scanner := 0, bufio.NewScanner(strings.NewReader(message)); scanner.Scan(); i++ { // no need to align first line because it starts at the correct location (after the label) if i != 0 { // append alignLen+1 spaces to align with "{{longestLabel}}:" before adding tab outBuf.WriteString("\n\t" + strings.Repeat(" ", longestLabelLen+1) + "\t") } outBuf.WriteString(scanner.Text()) } return outBuf.String() } type failNower interface { FailNow() } // FailNow fails test func FailNow(t TestingT, failureMessage string, msgAndArgs ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() } Fail(t, failureMessage, msgAndArgs...) // We cannot extend TestingT with FailNow() and // maintain backwards compatibility, so we fallback // to panicking when FailNow is not available in // TestingT. // See issue #263 if t, ok := t.(failNower); ok { t.FailNow() } else { panic("test failed and t is missing `FailNow()`") } return false } // Fail reports a failure through func Fail(t TestingT, failureMessage string, msgAndArgs ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() } content := []labeledContent{ {"Error Trace", strings.Join(CallerInfo(), "\n\t\t\t")}, {"Error", failureMessage}, } // Add test name if the Go version supports it if n, ok := t.(interface { Name() string }); ok { content = append(content, labeledContent{"Test", n.Name()}) } message := messageFromMsgAndArgs(msgAndArgs...) if len(message) > 0 { content = append(content, labeledContent{"Messages", message}) } t.Errorf("\n%s", ""+labeledOutput(content...)) return false } type labeledContent struct { label string content string } // labeledOutput returns a string consisting of the provided labeledContent. Each labeled output is appended in the following manner: // // \t{{label}}:{{align_spaces}}\t{{content}}\n // // The initial carriage return is required to undo/erase any padding added by testing.T.Errorf. The "\t{{label}}:" is for the label. // If a label is shorter than the longest label provided, padding spaces are added to make all the labels match in length. Once this // alignment is achieved, "\t{{content}}\n" is added for the output. // // If the content of the labeledOutput contains line breaks, the subsequent lines are aligned so that they start at the same location as the first line. func labeledOutput(content ...labeledContent) string { longestLabel := 0 for _, v := range content { if len(v.label) > longestLabel { longestLabel = len(v.label) } } var output string for _, v := range content { output += "\t" + v.label + ":" + strings.Repeat(" ", longestLabel-len(v.label)) + "\t" + indentMessageLines(v.content, longestLabel) + "\n" } return output } // Implements asserts that an object is implemented by the specified interface. // // assert.Implements(t, (*MyInterface)(nil), new(MyObject)) func Implements(t TestingT, interfaceObject interface{}, object interface{}, msgAndArgs ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() } interfaceType := reflect.TypeOf(interfaceObject).Elem() if object == nil { return Fail(t, fmt.Sprintf("Cannot check if nil implements %v", interfaceType), msgAndArgs...) } if !reflect.TypeOf(object).Implements(interfaceType) { return Fail(t, fmt.Sprintf("%T must implement %v", object, interfaceType), msgAndArgs...) } return true } // IsType asserts that the specified objects are of the same type. func IsType(t TestingT, expectedType interface{}, object interface{}, msgAndArgs ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() } if !ObjectsAreEqual(reflect.TypeOf(object), reflect.TypeOf(expectedType)) { return Fail(t, fmt.Sprintf("Object expected to be of type %v, but was %v", reflect.TypeOf(expectedType), reflect.TypeOf(object)), msgAndArgs...) } return true } // Equal asserts that two objects are equal. // // assert.Equal(t, 123, 123) // // Pointer variable equality is determined based on the equality of the // referenced values (as opposed to the memory addresses). Function equality // cannot be determined and will always fail. func Equal(t TestingT, expected, actual interface{}, msgAndArgs ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() } if err := validateEqualArgs(expected, actual); err != nil { return Fail(t, fmt.Sprintf("Invalid operation: %#v == %#v (%s)", expected, actual, err), msgAndArgs...) } if !ObjectsAreEqual(expected, actual) { diff := diff(expected, actual) expected, actual = formatUnequalValues(expected, actual) return Fail(t, fmt.Sprintf("Not equal: \n"+ "expected: %s\n"+ "actual : %s%s", expected, actual, diff), msgAndArgs...) } return true } // validateEqualArgs checks whether provided arguments can be safely used in the // Equal/NotEqual functions. func validateEqualArgs(expected, actual interface{}) error { if expected == nil && actual == nil { return nil } if isFunction(expected) || isFunction(actual) { return errors.New("cannot take func type as argument") } return nil } // Same asserts that two pointers reference the same object. // // assert.Same(t, ptr1, ptr2) // // Both arguments must be pointer variables. Pointer variable sameness is // determined based on the equality of both type and value. func Same(t TestingT, expected, actual interface{}, msgAndArgs ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() } if !samePointers(expected, actual) { return Fail(t, fmt.Sprintf("Not same: \n"+ "expected: %p %#v\n"+ "actual : %p %#v", expected, expected, actual, actual), msgAndArgs...) } return true } // NotSame asserts that two pointers do not reference the same object. // // assert.NotSame(t, ptr1, ptr2) // // Both arguments must be pointer variables. Pointer variable sameness is // determined based on the equality of both type and value. func NotSame(t TestingT, expected, actual interface{}, msgAndArgs ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() } if samePointers(expected, actual) { return Fail(t, fmt.Sprintf( "Expected and actual point to the same object: %p %#v", expected, expected), msgAndArgs...) } return true } // samePointers compares two generic interface objects and returns whether // they point to the same object func samePointers(first, second interface{}) bool { firstPtr, secondPtr := reflect.ValueOf(first), reflect.ValueOf(second) if firstPtr.Kind() != reflect.Ptr || secondPtr.Kind() != reflect.Ptr { return false } firstType, secondType := reflect.TypeOf(first), reflect.TypeOf(second) if firstType != secondType { return false } // compare pointer addresses return first == second } // formatUnequalValues takes two values of arbitrary types and returns string // representations appropriate to be presented to the user. // // If the values are not of like type, the returned strings will be prefixed // with the type name, and the value will be enclosed in parenthesis similar // to a type conversion in the Go grammar. func formatUnequalValues(expected, actual interface{}) (e string, a string) { if reflect.TypeOf(expected) != reflect.TypeOf(actual) { return fmt.Sprintf("%T(%#v)", expected, expected), fmt.Sprintf("%T(%#v)", actual, actual) } switch expected.(type) { case time.Duration: return fmt.Sprintf("%v", expected), fmt.Sprintf("%v", actual) } return fmt.Sprintf("%#v", expected), fmt.Sprintf("%#v", actual) } // EqualValues asserts that two objects are equal or convertable to the same types // and equal. // // assert.EqualValues(t, uint32(123), int32(123)) func EqualValues(t TestingT, expected, actual interface{}, msgAndArgs ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() } if !ObjectsAreEqualValues(expected, actual) { diff := diff(expected, actual) expected, actual = formatUnequalValues(expected, actual) return Fail(t, fmt.Sprintf("Not equal: \n"+ "expected: %s\n"+ "actual : %s%s", expected, actual, diff), msgAndArgs...) } return true } // Exactly asserts that two objects are equal in value and type. // // assert.Exactly(t, int32(123), int64(123)) func Exactly(t TestingT, expected, actual interface{}, msgAndArgs ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() } aType := reflect.TypeOf(expected) bType := reflect.TypeOf(actual) if aType != bType { return Fail(t, fmt.Sprintf("Types expected to match exactly\n\t%v != %v", aType, bType), msgAndArgs...) } return Equal(t, expected, actual, msgAndArgs...) } // NotNil asserts that the specified object is not nil. // // assert.NotNil(t, err) func NotNil(t TestingT, object interface{}, msgAndArgs ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() } if !isNil(object) { return true } return Fail(t, "Expected value not to be nil.", msgAndArgs...) } // containsKind checks if a specified kind in the slice of kinds. func containsKind(kinds []reflect.Kind, kind reflect.Kind) bool { for i := 0; i < len(kinds); i++ { if kind == kinds[i] { return true } } return false } // isNil checks if a specified object is nil or not, without Failing. func isNil(object interface{}) bool { if object == nil { return true } value := reflect.ValueOf(object) kind := value.Kind() isNilableKind := containsKind( []reflect.Kind{ reflect.Chan, reflect.Func, reflect.Interface, reflect.Map, reflect.Ptr, reflect.Slice}, kind) if isNilableKind && value.IsNil() { return true } return false } // Nil asserts that the specified object is nil. // // assert.Nil(t, err) func Nil(t TestingT, object interface{}, msgAndArgs ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() } if isNil(object) { return true } return Fail(t, fmt.Sprintf("Expected nil, but got: %#v", object), msgAndArgs...) } // isEmpty gets whether the specified object is considered empty or not. func isEmpty(object interface{}) bool { // get nil case out of the way if object == nil { return true } objValue := reflect.ValueOf(object) switch objValue.Kind() { // collection types are empty when they have no element case reflect.Array, reflect.Chan, reflect.Map, reflect.Slice: return objValue.Len() == 0 // pointers are empty if nil or if the value they point to is empty case reflect.Ptr: if objValue.IsNil() { return true } deref := objValue.Elem().Interface() return isEmpty(deref) // for all other types, compare against the zero value default: zero := reflect.Zero(objValue.Type()) return reflect.DeepEqual(object, zero.Interface()) } } // Empty asserts that the specified object is empty. I.e. nil, "", false, 0 or either // a slice or a channel with len == 0. // // assert.Empty(t, obj) func Empty(t TestingT, object interface{}, msgAndArgs ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() } pass := isEmpty(object) if !pass { Fail(t, fmt.Sprintf("Should be empty, but was %v", object), msgAndArgs...) } return pass } // NotEmpty asserts that the specified object is NOT empty. I.e. not nil, "", false, 0 or either // a slice or a channel with len == 0. // // if assert.NotEmpty(t, obj) { // assert.Equal(t, "two", obj[1]) // } func NotEmpty(t TestingT, object interface{}, msgAndArgs ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() } pass := !isEmpty(object) if !pass { Fail(t, fmt.Sprintf("Should NOT be empty, but was %v", object), msgAndArgs...) } return pass } // getLen try to get length of object. // return (false, 0) if impossible. func getLen(x interface{}) (ok bool, length int) { v := reflect.ValueOf(x) defer func() { if e := recover(); e != nil { ok = false } }() return true, v.Len() } // Len asserts that the specified object has specific length. // Len also fails if the object has a type that len() not accept. // // assert.Len(t, mySlice, 3) func Len(t TestingT, object interface{}, length int, msgAndArgs ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() } ok, l := getLen(object) if !ok { return Fail(t, fmt.Sprintf("\"%s\" could not be applied builtin len()", object), msgAndArgs...) } if l != length { return Fail(t, fmt.Sprintf("\"%s\" should have %d item(s), but has %d", object, length, l), msgAndArgs...) } return true } // True asserts that the specified value is true. // // assert.True(t, myBool) func True(t TestingT, value bool, msgAndArgs ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() } if h, ok := t.(interface { Helper() }); ok { h.Helper() } if value != true { return Fail(t, "Should be true", msgAndArgs...) } return true } // False asserts that the specified value is false. // // assert.False(t, myBool) func False(t TestingT, value bool, msgAndArgs ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() } if value != false { return Fail(t, "Should be false", msgAndArgs...) } return true } // NotEqual asserts that the specified values are NOT equal. // // assert.NotEqual(t, obj1, obj2) // // Pointer variable equality is determined based on the equality of the // referenced values (as opposed to the memory addresses). func NotEqual(t TestingT, expected, actual interface{}, msgAndArgs ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() } if err := validateEqualArgs(expected, actual); err != nil { return Fail(t, fmt.Sprintf("Invalid operation: %#v != %#v (%s)", expected, actual, err), msgAndArgs...) } if ObjectsAreEqual(expected, actual) { return Fail(t, fmt.Sprintf("Should not be: %#v\n", actual), msgAndArgs...) } return true } // containsElement try loop over the list check if the list includes the element. // return (false, false) if impossible. // return (true, false) if element was not found. // return (true, true) if element was found. func includeElement(list interface{}, element interface{}) (ok, found bool) { listValue := reflect.ValueOf(list) listKind := reflect.TypeOf(list).Kind() defer func() { if e := recover(); e != nil { ok = false found = false } }() if listKind == reflect.String { elementValue := reflect.ValueOf(element) return true, strings.Contains(listValue.String(), elementValue.String()) } if listKind == reflect.Map { mapKeys := listValue.MapKeys() for i := 0; i < len(mapKeys); i++ { if ObjectsAreEqual(mapKeys[i].Interface(), element) { return true, true } } return true, false } for i := 0; i < listValue.Len(); i++ { if ObjectsAreEqual(listValue.Index(i).Interface(), element) { return true, true } } return true, false } // Contains asserts that the specified string, list(array, slice...) or map contains the // specified substring or element. // // assert.Contains(t, "Hello World", "World") // assert.Contains(t, ["Hello", "World"], "World") // assert.Contains(t, {"Hello": "World"}, "Hello") func Contains(t TestingT, s, contains interface{}, msgAndArgs ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() } ok, found := includeElement(s, contains) if !ok { return Fail(t, fmt.Sprintf("\"%s\" could not be applied builtin len()", s), msgAndArgs...) } if !found { return Fail(t, fmt.Sprintf("\"%s\" does not contain \"%s\"", s, contains), msgAndArgs...) } return true } // NotContains asserts that the specified string, list(array, slice...) or map does NOT contain the // specified substring or element. // // assert.NotContains(t, "Hello World", "Earth") // assert.NotContains(t, ["Hello", "World"], "Earth") // assert.NotContains(t, {"Hello": "World"}, "Earth") func NotContains(t TestingT, s, contains interface{}, msgAndArgs ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() } ok, found := includeElement(s, contains) if !ok { return Fail(t, fmt.Sprintf("\"%s\" could not be applied builtin len()", s), msgAndArgs...) } if found { return Fail(t, fmt.Sprintf("\"%s\" should not contain \"%s\"", s, contains), msgAndArgs...) } return true } // Subset asserts that the specified list(array, slice...) contains all // elements given in the specified subset(array, slice...). // // assert.Subset(t, [1, 2, 3], [1, 2], "But [1, 2, 3] does contain [1, 2]") func Subset(t TestingT, list, subset interface{}, msgAndArgs ...interface{}) (ok bool) { if h, ok := t.(tHelper); ok { h.Helper() } if subset == nil { return true // we consider nil to be equal to the nil set } subsetValue := reflect.ValueOf(subset) defer func() { if e := recover(); e != nil { ok = false } }() listKind := reflect.TypeOf(list).Kind() subsetKind := reflect.TypeOf(subset).Kind() if listKind != reflect.Array && listKind != reflect.Slice { return Fail(t, fmt.Sprintf("%q has an unsupported type %s", list, listKind), msgAndArgs...) } if subsetKind != reflect.Array && subsetKind != reflect.Slice { return Fail(t, fmt.Sprintf("%q has an unsupported type %s", subset, subsetKind), msgAndArgs...) } for i := 0; i < subsetValue.Len(); i++ { element := subsetValue.Index(i).Interface() ok, found := includeElement(list, element) if !ok { return Fail(t, fmt.Sprintf("\"%s\" could not be applied builtin len()", list), msgAndArgs...) } if !found { return Fail(t, fmt.Sprintf("\"%s\" does not contain \"%s\"", list, element), msgAndArgs...) } } return true } // NotSubset asserts that the specified list(array, slice...) contains not all // elements given in the specified subset(array, slice...). // // assert.NotSubset(t, [1, 3, 4], [1, 2], "But [1, 3, 4] does not contain [1, 2]") func NotSubset(t TestingT, list, subset interface{}, msgAndArgs ...interface{}) (ok bool) { if h, ok := t.(tHelper); ok { h.Helper() } if subset == nil { return Fail(t, fmt.Sprintf("nil is the empty set which is a subset of every set"), msgAndArgs...) } subsetValue := reflect.ValueOf(subset) defer func() { if e := recover(); e != nil { ok = false } }() listKind := reflect.TypeOf(list).Kind() subsetKind := reflect.TypeOf(subset).Kind() if listKind != reflect.Array && listKind != reflect.Slice { return Fail(t, fmt.Sprintf("%q has an unsupported type %s", list, listKind), msgAndArgs...) } if subsetKind != reflect.Array && subsetKind != reflect.Slice { return Fail(t, fmt.Sprintf("%q has an unsupported type %s", subset, subsetKind), msgAndArgs...) } for i := 0; i < subsetValue.Len(); i++ { element := subsetValue.Index(i).Interface() ok, found := includeElement(list, element) if !ok { return Fail(t, fmt.Sprintf("\"%s\" could not be applied builtin len()", list), msgAndArgs...) } if !found { return true } } return Fail(t, fmt.Sprintf("%q is a subset of %q", subset, list), msgAndArgs...) } // ElementsMatch asserts that the specified listA(array, slice...) is equal to specified // listB(array, slice...) ignoring the order of the elements. If there are duplicate elements, // the number of appearances of each of them in both lists should match. // // assert.ElementsMatch(t, [1, 3, 2, 3], [1, 3, 3, 2]) func ElementsMatch(t TestingT, listA, listB interface{}, msgAndArgs ...interface{}) (ok bool) { if h, ok := t.(tHelper); ok { h.Helper() } if isEmpty(listA) && isEmpty(listB) { return true } aKind := reflect.TypeOf(listA).Kind() bKind := reflect.TypeOf(listB).Kind() if aKind != reflect.Array && aKind != reflect.Slice { return Fail(t, fmt.Sprintf("%q has an unsupported type %s", listA, aKind), msgAndArgs...) } if bKind != reflect.Array && bKind != reflect.Slice { return Fail(t, fmt.Sprintf("%q has an unsupported type %s", listB, bKind), msgAndArgs...) } aValue := reflect.ValueOf(listA) bValue := reflect.ValueOf(listB) aLen := aValue.Len() bLen := bValue.Len() if aLen != bLen { return Fail(t, fmt.Sprintf("lengths don't match: %d != %d", aLen, bLen), msgAndArgs...) } // Mark indexes in bValue that we already used visited := make([]bool, bLen) for i := 0; i < aLen; i++ { element := aValue.Index(i).Interface() found := false for j := 0; j < bLen; j++ { if visited[j] { continue } if ObjectsAreEqual(bValue.Index(j).Interface(), element) { visited[j] = true found = true break } } if !found { return Fail(t, fmt.Sprintf("element %s appears more times in %s than in %s", element, aValue, bValue), msgAndArgs...) } } return true } // Condition uses a Comparison to assert a complex condition. func Condition(t TestingT, comp Comparison, msgAndArgs ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() } result := comp() if !result { Fail(t, "Condition failed!", msgAndArgs...) } return result } // PanicTestFunc defines a func that should be passed to the assert.Panics and assert.NotPanics // methods, and represents a simple func that takes no arguments, and returns nothing. type PanicTestFunc func() // didPanic returns true if the function passed to it panics. Otherwise, it returns false. func didPanic(f PanicTestFunc) (bool, interface{}, string) { didPanic := false var message interface{} var stack string func() { defer func() { if message = recover(); message != nil { didPanic = true stack = string(debug.Stack()) } }() // call the target function f() }() return didPanic, message, stack } // Panics asserts that the code inside the specified PanicTestFunc panics. // // assert.Panics(t, func(){ GoCrazy() }) func Panics(t TestingT, f PanicTestFunc, msgAndArgs ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() } if funcDidPanic, panicValue, _ := didPanic(f); !funcDidPanic { return Fail(t, fmt.Sprintf("func %#v should panic\n\tPanic value:\t%#v", f, panicValue), msgAndArgs...) } return true } // PanicsWithValue asserts that the code inside the specified PanicTestFunc panics, and that // the recovered panic value equals the expected panic value. // // assert.PanicsWithValue(t, "crazy error", func(){ GoCrazy() }) func PanicsWithValue(t TestingT, expected interface{}, f PanicTestFunc, msgAndArgs ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() } funcDidPanic, panicValue, panickedStack := didPanic(f) if !funcDidPanic { return Fail(t, fmt.Sprintf("func %#v should panic\n\tPanic value:\t%#v", f, panicValue), msgAndArgs...) } if panicValue != expected { return Fail(t, fmt.Sprintf("func %#v should panic with value:\t%#v\n\tPanic value:\t%#v\n\tPanic stack:\t%s", f, expected, panicValue, panickedStack), msgAndArgs...) } return true } // PanicsWithError asserts that the code inside the specified PanicTestFunc // panics, and that the recovered panic value is an error that satisfies the // EqualError comparison. // // assert.PanicsWithError(t, "crazy error", func(){ GoCrazy() }) func PanicsWithError(t TestingT, errString string, f PanicTestFunc, msgAndArgs ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() } funcDidPanic, panicValue, panickedStack := didPanic(f) if !funcDidPanic { return Fail(t, fmt.Sprintf("func %#v should panic\n\tPanic value:\t%#v", f, panicValue), msgAndArgs...) } panicErr, ok := panicValue.(error) if !ok || panicErr.Error() != errString { return Fail(t, fmt.Sprintf("func %#v should panic with error message:\t%#v\n\tPanic value:\t%#v\n\tPanic stack:\t%s", f, errString, panicValue, panickedStack), msgAndArgs...) } return true } // NotPanics asserts that the code inside the specified PanicTestFunc does NOT panic. // // assert.NotPanics(t, func(){ RemainCalm() }) func NotPanics(t TestingT, f PanicTestFunc, msgAndArgs ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() } if funcDidPanic, panicValue, panickedStack := didPanic(f); funcDidPanic { return Fail(t, fmt.Sprintf("func %#v should not panic\n\tPanic value:\t%v\n\tPanic stack:\t%s", f, panicValue, panickedStack), msgAndArgs...) } return true } // WithinDuration asserts that the two times are within duration delta of each other. // // assert.WithinDuration(t, time.Now(), time.Now(), 10*time.Second) func WithinDuration(t TestingT, expected, actual time.Time, delta time.Duration, msgAndArgs ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() } dt := expected.Sub(actual) if dt < -delta || dt > delta { return Fail(t, fmt.Sprintf("Max difference between %v and %v allowed is %v, but difference was %v", expected, actual, delta, dt), msgAndArgs...) } return true } func toFloat(x interface{}) (float64, bool) { var xf float64 xok := true switch xn := x.(type) { case uint8: xf = float64(xn) case uint16: xf = float64(xn) case uint32: xf = float64(xn) case uint64: xf = float64(xn) case int: xf = float64(xn) case int8: xf = float64(xn) case int16: xf = float64(xn) case int32: xf = float64(xn) case int64: xf = float64(xn) case float32: xf = float64(xn) case float64: xf = float64(xn) case time.Duration: xf = float64(xn) default: xok = false } return xf, xok } // InDelta asserts that the two numerals are within delta of each other. // // assert.InDelta(t, math.Pi, 22/7.0, 0.01) func InDelta(t TestingT, expected, actual interface{}, delta float64, msgAndArgs ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() } af, aok := toFloat(expected) bf, bok := toFloat(actual) if !aok || !bok { return Fail(t, fmt.Sprintf("Parameters must be numerical"), msgAndArgs...) } if math.IsNaN(af) { return Fail(t, fmt.Sprintf("Expected must not be NaN"), msgAndArgs...) } if math.IsNaN(bf) { return Fail(t, fmt.Sprintf("Expected %v with delta %v, but was NaN", expected, delta), msgAndArgs...) } dt := af - bf if dt < -delta || dt > delta { return Fail(t, fmt.Sprintf("Max difference between %v and %v allowed is %v, but difference was %v", expected, actual, delta, dt), msgAndArgs...) } return true } // InDeltaSlice is the same as InDelta, except it compares two slices. func InDeltaSlice(t TestingT, expected, actual interface{}, delta float64, msgAndArgs ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() } if expected == nil || actual == nil || reflect.TypeOf(actual).Kind() != reflect.Slice || reflect.TypeOf(expected).Kind() != reflect.Slice { return Fail(t, fmt.Sprintf("Parameters must be slice"), msgAndArgs...) } actualSlice := reflect.ValueOf(actual) expectedSlice := reflect.ValueOf(expected) for i := 0; i < actualSlice.Len(); i++ { result := InDelta(t, actualSlice.Index(i).Interface(), expectedSlice.Index(i).Interface(), delta, msgAndArgs...) if !result { return result } } return true } // InDeltaMapValues is the same as InDelta, but it compares all values between two maps. Both maps must have exactly the same keys. func InDeltaMapValues(t TestingT, expected, actual interface{}, delta float64, msgAndArgs ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() } if expected == nil || actual == nil || reflect.TypeOf(actual).Kind() != reflect.Map || reflect.TypeOf(expected).Kind() != reflect.Map { return Fail(t, "Arguments must be maps", msgAndArgs...) } expectedMap := reflect.ValueOf(expected) actualMap := reflect.ValueOf(actual) if expectedMap.Len() != actualMap.Len() { return Fail(t, "Arguments must have the same number of keys", msgAndArgs...) } for _, k := range expectedMap.MapKeys() { ev := expectedMap.MapIndex(k) av := actualMap.MapIndex(k) if !ev.IsValid() { return Fail(t, fmt.Sprintf("missing key %q in expected map", k), msgAndArgs...) } if !av.IsValid() { return Fail(t, fmt.Sprintf("missing key %q in actual map", k), msgAndArgs...) } if !InDelta( t, ev.Interface(), av.Interface(), delta, msgAndArgs..., ) { return false } } return true } func calcRelativeError(expected, actual interface{}) (float64, error) { af, aok := toFloat(expected) if !aok { return 0, fmt.Errorf("expected value %q cannot be converted to float", expected) } if af == 0 { return 0, fmt.Errorf("expected value must have a value other than zero to calculate the relative error") } bf, bok := toFloat(actual) if !bok { return 0, fmt.Errorf("actual value %q cannot be converted to float", actual) } return math.Abs(af-bf) / math.Abs(af), nil } // InEpsilon asserts that expected and actual have a relative error less than epsilon func InEpsilon(t TestingT, expected, actual interface{}, epsilon float64, msgAndArgs ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() } actualEpsilon, err := calcRelativeError(expected, actual) if err != nil { return Fail(t, err.Error(), msgAndArgs...) } if actualEpsilon > epsilon { return Fail(t, fmt.Sprintf("Relative error is too high: %#v (expected)\n"+ " < %#v (actual)", epsilon, actualEpsilon), msgAndArgs...) } return true } // InEpsilonSlice is the same as InEpsilon, except it compares each value from two slices. func InEpsilonSlice(t TestingT, expected, actual interface{}, epsilon float64, msgAndArgs ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() } if expected == nil || actual == nil || reflect.TypeOf(actual).Kind() != reflect.Slice || reflect.TypeOf(expected).Kind() != reflect.Slice { return Fail(t, fmt.Sprintf("Parameters must be slice"), msgAndArgs...) } actualSlice := reflect.ValueOf(actual) expectedSlice := reflect.ValueOf(expected) for i := 0; i < actualSlice.Len(); i++ { result := InEpsilon(t, actualSlice.Index(i).Interface(), expectedSlice.Index(i).Interface(), epsilon) if !result { return result } } return true } /* Errors */ // NoError asserts that a function returned no error (i.e. `nil`). // // actualObj, err := SomeFunction() // if assert.NoError(t, err) { // assert.Equal(t, expectedObj, actualObj) // } func NoError(t TestingT, err error, msgAndArgs ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() } if err != nil { return Fail(t, fmt.Sprintf("Received unexpected error:\n%+v", err), msgAndArgs...) } return true } // Error asserts that a function returned an error (i.e. not `nil`). // // actualObj, err := SomeFunction() // if assert.Error(t, err) { // assert.Equal(t, expectedError, err) // } func Error(t TestingT, err error, msgAndArgs ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() } if err == nil { return Fail(t, "An error is expected but got nil.", msgAndArgs...) } return true } // EqualError asserts that a function returned an error (i.e. not `nil`) // and that it is equal to the provided error. // // actualObj, err := SomeFunction() // assert.EqualError(t, err, expectedErrorString) func EqualError(t TestingT, theError error, errString string, msgAndArgs ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() } if !Error(t, theError, msgAndArgs...) { return false } expected := errString actual := theError.Error() // don't need to use deep equals here, we know they are both strings if expected != actual { return Fail(t, fmt.Sprintf("Error message not equal:\n"+ "expected: %q\n"+ "actual : %q", expected, actual), msgAndArgs...) } return true } // matchRegexp return true if a specified regexp matches a string. func matchRegexp(rx interface{}, str interface{}) bool { var r *regexp.Regexp if rr, ok := rx.(*regexp.Regexp); ok { r = rr } else { r = regexp.MustCompile(fmt.Sprint(rx)) } return (r.FindStringIndex(fmt.Sprint(str)) != nil) } // Regexp asserts that a specified regexp matches a string. // // assert.Regexp(t, regexp.MustCompile("start"), "it's starting") // assert.Regexp(t, "start...$", "it's not starting") func Regexp(t TestingT, rx interface{}, str interface{}, msgAndArgs ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() } match := matchRegexp(rx, str) if !match { Fail(t, fmt.Sprintf("Expect \"%v\" to match \"%v\"", str, rx), msgAndArgs...) } return match } // NotRegexp asserts that a specified regexp does not match a string. // // assert.NotRegexp(t, regexp.MustCompile("starts"), "it's starting") // assert.NotRegexp(t, "^start", "it's not starting") func NotRegexp(t TestingT, rx interface{}, str interface{}, msgAndArgs ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() } match := matchRegexp(rx, str) if match { Fail(t, fmt.Sprintf("Expect \"%v\" to NOT match \"%v\"", str, rx), msgAndArgs...) } return !match } // Zero asserts that i is the zero value for its type. func Zero(t TestingT, i interface{}, msgAndArgs ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() } if i != nil && !reflect.DeepEqual(i, reflect.Zero(reflect.TypeOf(i)).Interface()) { return Fail(t, fmt.Sprintf("Should be zero, but was %v", i), msgAndArgs...) } return true } // NotZero asserts that i is not the zero value for its type. func NotZero(t TestingT, i interface{}, msgAndArgs ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() } if i == nil || reflect.DeepEqual(i, reflect.Zero(reflect.TypeOf(i)).Interface()) { return Fail(t, fmt.Sprintf("Should not be zero, but was %v", i), msgAndArgs...) } return true } // FileExists checks whether a file exists in the given path. It also fails if // the path points to a directory or there is an error when trying to check the file. func FileExists(t TestingT, path string, msgAndArgs ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() } info, err := os.Lstat(path) if err != nil { if os.IsNotExist(err) { return Fail(t, fmt.Sprintf("unable to find file %q", path), msgAndArgs...) } return Fail(t, fmt.Sprintf("error when running os.Lstat(%q): %s", path, err), msgAndArgs...) } if info.IsDir() { return Fail(t, fmt.Sprintf("%q is a directory", path), msgAndArgs...) } return true } // NoFileExists checks whether a file does not exist in a given path. It fails // if the path points to an existing _file_ only. func NoFileExists(t TestingT, path string, msgAndArgs ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() } info, err := os.Lstat(path) if err != nil { return true } if info.IsDir() { return true } return Fail(t, fmt.Sprintf("file %q exists", path), msgAndArgs...) } // DirExists checks whether a directory exists in the given path. It also fails // if the path is a file rather a directory or there is an error checking whether it exists. func DirExists(t TestingT, path string, msgAndArgs ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() } info, err := os.Lstat(path) if err != nil { if os.IsNotExist(err) { return Fail(t, fmt.Sprintf("unable to find file %q", path), msgAndArgs...) } return Fail(t, fmt.Sprintf("error when running os.Lstat(%q): %s", path, err), msgAndArgs...) } if !info.IsDir() { return Fail(t, fmt.Sprintf("%q is a file", path), msgAndArgs...) } return true } // NoDirExists checks whether a directory does not exist in the given path. // It fails if the path points to an existing _directory_ only. func NoDirExists(t TestingT, path string, msgAndArgs ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() } info, err := os.Lstat(path) if err != nil { if os.IsNotExist(err) { return true } return true } if !info.IsDir() { return true } return Fail(t, fmt.Sprintf("directory %q exists", path), msgAndArgs...) } // JSONEq asserts that two JSON strings are equivalent. // // assert.JSONEq(t, `{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`) func JSONEq(t TestingT, expected string, actual string, msgAndArgs ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() } var expectedJSONAsInterface, actualJSONAsInterface interface{} if err := json.Unmarshal([]byte(expected), &expectedJSONAsInterface); err != nil { return Fail(t, fmt.Sprintf("Expected value ('%s') is not valid json.\nJSON parsing error: '%s'", expected, err.Error()), msgAndArgs...) } if err := json.Unmarshal([]byte(actual), &actualJSONAsInterface); err != nil { return Fail(t, fmt.Sprintf("Input ('%s') needs to be valid json.\nJSON parsing error: '%s'", actual, err.Error()), msgAndArgs...) } return Equal(t, expectedJSONAsInterface, actualJSONAsInterface, msgAndArgs...) } // YAMLEq asserts that two YAML strings are equivalent. func YAMLEq(t TestingT, expected string, actual string, msgAndArgs ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() } var expectedYAMLAsInterface, actualYAMLAsInterface interface{} if err := yaml.Unmarshal([]byte(expected), &expectedYAMLAsInterface); err != nil { return Fail(t, fmt.Sprintf("Expected value ('%s') is not valid yaml.\nYAML parsing error: '%s'", expected, err.Error()), msgAndArgs...) } if err := yaml.Unmarshal([]byte(actual), &actualYAMLAsInterface); err != nil { return Fail(t, fmt.Sprintf("Input ('%s') needs to be valid yaml.\nYAML error: '%s'", actual, err.Error()), msgAndArgs...) } return Equal(t, expectedYAMLAsInterface, actualYAMLAsInterface, msgAndArgs...) } func typeAndKind(v interface{}) (reflect.Type, reflect.Kind) { t := reflect.TypeOf(v) k := t.Kind() if k == reflect.Ptr { t = t.Elem() k = t.Kind() } return t, k } // diff returns a diff of both values as long as both are of the same type and // are a struct, map, slice, array or string. Otherwise it returns an empty string. func diff(expected interface{}, actual interface{}) string { if expected == nil || actual == nil { return "" } et, ek := typeAndKind(expected) at, _ := typeAndKind(actual) if et != at { return "" } if ek != reflect.Struct && ek != reflect.Map && ek != reflect.Slice && ek != reflect.Array && ek != reflect.String { return "" } var e, a string if et != reflect.TypeOf("") { e = spewConfig.Sdump(expected) a = spewConfig.Sdump(actual) } else { e = reflect.ValueOf(expected).String() a = reflect.ValueOf(actual).String() } diff, _ := difflib.GetUnifiedDiffString(difflib.UnifiedDiff{ A: difflib.SplitLines(e), B: difflib.SplitLines(a), FromFile: "Expected", FromDate: "", ToFile: "Actual", ToDate: "", Context: 1, }) return "\n\nDiff:\n" + diff } func isFunction(arg interface{}) bool { if arg == nil { return false } return reflect.TypeOf(arg).Kind() == reflect.Func } var spewConfig = spew.ConfigState{ Indent: " ", DisablePointerAddresses: true, DisableCapacities: true, SortKeys: true, } type tHelper interface { Helper() } // Eventually asserts that given condition will be met in waitFor time, // periodically checking target function each tick. // // assert.Eventually(t, func() bool { return true; }, time.Second, 10*time.Millisecond) func Eventually(t TestingT, condition func() bool, waitFor time.Duration, tick time.Duration, msgAndArgs ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() } ch := make(chan bool, 1) timer := time.NewTimer(waitFor) defer timer.Stop() ticker := time.NewTicker(tick) defer ticker.Stop() for tick := ticker.C; ; { select { case <-timer.C: return Fail(t, "Condition never satisfied", msgAndArgs...) case <-tick: tick = nil go func() { ch <- condition() }() case v := <-ch: if v { return true } tick = ticker.C } } } // Never asserts that the given condition doesn't satisfy in waitFor time, // periodically checking the target function each tick. // // assert.Never(t, func() bool { return false; }, time.Second, 10*time.Millisecond) func Never(t TestingT, condition func() bool, waitFor time.Duration, tick time.Duration, msgAndArgs ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() } ch := make(chan bool, 1) timer := time.NewTimer(waitFor) defer timer.Stop() ticker := time.NewTicker(tick) defer ticker.Stop() for tick := ticker.C; ; { select { case <-timer.C: return true case <-tick: tick = nil go func() { ch <- condition() }() case v := <-ch: if v { return Fail(t, "Condition satisfied", msgAndArgs...) } tick = ticker.C } } } go-jmespath-0.4.0/internal/testify/assert/assertions_test.go000066400000000000000000001561601373124421700243320ustar00rootroot00000000000000package assert import ( "bytes" "encoding/json" "errors" "fmt" "io" "math" "os" "reflect" "regexp" "runtime" "strings" "testing" "time" ) var ( i interface{} zeros = []interface{}{ false, byte(0), complex64(0), complex128(0), float32(0), float64(0), int(0), int8(0), int16(0), int32(0), int64(0), rune(0), uint(0), uint8(0), uint16(0), uint32(0), uint64(0), uintptr(0), "", [0]interface{}{}, []interface{}(nil), struct{ x int }{}, (*interface{})(nil), (func())(nil), nil, interface{}(nil), map[interface{}]interface{}(nil), (chan interface{})(nil), (<-chan interface{})(nil), (chan<- interface{})(nil), } nonZeros = []interface{}{ true, byte(1), complex64(1), complex128(1), float32(1), float64(1), int(1), int8(1), int16(1), int32(1), int64(1), rune(1), uint(1), uint8(1), uint16(1), uint32(1), uint64(1), uintptr(1), "s", [1]interface{}{1}, []interface{}{}, struct{ x int }{1}, (*interface{})(&i), (func())(func() {}), interface{}(1), map[interface{}]interface{}{}, (chan interface{})(make(chan interface{})), (<-chan interface{})(make(chan interface{})), (chan<- interface{})(make(chan interface{})), } ) // AssertionTesterInterface defines an interface to be used for testing assertion methods type AssertionTesterInterface interface { TestMethod() } // AssertionTesterConformingObject is an object that conforms to the AssertionTesterInterface interface type AssertionTesterConformingObject struct { } func (a *AssertionTesterConformingObject) TestMethod() { } // AssertionTesterNonConformingObject is an object that does not conform to the AssertionTesterInterface interface type AssertionTesterNonConformingObject struct { } func TestObjectsAreEqual(t *testing.T) { if !ObjectsAreEqual("Hello World", "Hello World") { t.Error("objectsAreEqual should return true") } if !ObjectsAreEqual(123, 123) { t.Error("objectsAreEqual should return true") } if !ObjectsAreEqual(123.5, 123.5) { t.Error("objectsAreEqual should return true") } if !ObjectsAreEqual([]byte("Hello World"), []byte("Hello World")) { t.Error("objectsAreEqual should return true") } if !ObjectsAreEqual(nil, nil) { t.Error("objectsAreEqual should return true") } if ObjectsAreEqual(map[int]int{5: 10}, map[int]int{10: 20}) { t.Error("objectsAreEqual should return false") } if ObjectsAreEqual('x', "x") { t.Error("objectsAreEqual should return false") } if ObjectsAreEqual("x", 'x') { t.Error("objectsAreEqual should return false") } if ObjectsAreEqual(0, 0.1) { t.Error("objectsAreEqual should return false") } if ObjectsAreEqual(0.1, 0) { t.Error("objectsAreEqual should return false") } if ObjectsAreEqual(time.Now, time.Now) { t.Error("objectsAreEqual should return false") } if ObjectsAreEqual(func() {}, func() {}) { t.Error("objectsAreEqual should return false") } if ObjectsAreEqual(uint32(10), int32(10)) { t.Error("objectsAreEqual should return false") } if !ObjectsAreEqualValues(uint32(10), int32(10)) { t.Error("ObjectsAreEqualValues should return true") } if ObjectsAreEqualValues(0, nil) { t.Fail() } if ObjectsAreEqualValues(nil, 0) { t.Fail() } } func TestImplements(t *testing.T) { mockT := new(testing.T) if !Implements(mockT, (*AssertionTesterInterface)(nil), new(AssertionTesterConformingObject)) { t.Error("Implements method should return true: AssertionTesterConformingObject implements AssertionTesterInterface") } if Implements(mockT, (*AssertionTesterInterface)(nil), new(AssertionTesterNonConformingObject)) { t.Error("Implements method should return false: AssertionTesterNonConformingObject does not implements AssertionTesterInterface") } if Implements(mockT, (*AssertionTesterInterface)(nil), nil) { t.Error("Implements method should return false: nil does not implement AssertionTesterInterface") } } func TestIsType(t *testing.T) { mockT := new(testing.T) if !IsType(mockT, new(AssertionTesterConformingObject), new(AssertionTesterConformingObject)) { t.Error("IsType should return true: AssertionTesterConformingObject is the same type as AssertionTesterConformingObject") } if IsType(mockT, new(AssertionTesterConformingObject), new(AssertionTesterNonConformingObject)) { t.Error("IsType should return false: AssertionTesterConformingObject is not the same type as AssertionTesterNonConformingObject") } } type myType string func TestEqual(t *testing.T) { mockT := new(testing.T) if !Equal(mockT, "Hello World", "Hello World") { t.Error("Equal should return true") } if !Equal(mockT, 123, 123) { t.Error("Equal should return true") } if !Equal(mockT, 123.5, 123.5) { t.Error("Equal should return true") } if !Equal(mockT, []byte("Hello World"), []byte("Hello World")) { t.Error("Equal should return true") } if !Equal(mockT, nil, nil) { t.Error("Equal should return true") } if !Equal(mockT, int32(123), int32(123)) { t.Error("Equal should return true") } if !Equal(mockT, uint64(123), uint64(123)) { t.Error("Equal should return true") } if !Equal(mockT, myType("1"), myType("1")) { t.Error("Equal should return true") } if !Equal(mockT, &struct{}{}, &struct{}{}) { t.Error("Equal should return true (pointer equality is based on equality of underlying value)") } var m map[string]interface{} if Equal(mockT, m["bar"], "something") { t.Error("Equal should return false") } if Equal(mockT, myType("1"), myType("2")) { t.Error("Equal should return false") } } func ptr(i int) *int { return &i } func TestSame(t *testing.T) { mockT := new(testing.T) if Same(mockT, ptr(1), ptr(1)) { t.Error("Same should return false") } if Same(mockT, 1, 1) { t.Error("Same should return false") } p := ptr(2) if Same(mockT, p, *p) { t.Error("Same should return false") } if !Same(mockT, p, p) { t.Error("Same should return true") } } func TestNotSame(t *testing.T) { mockT := new(testing.T) if !NotSame(mockT, ptr(1), ptr(1)) { t.Error("NotSame should return true; different pointers") } if !NotSame(mockT, 1, 1) { t.Error("NotSame should return true; constant inputs") } p := ptr(2) if !NotSame(mockT, p, *p) { t.Error("NotSame should return true; mixed-type inputs") } if NotSame(mockT, p, p) { t.Error("NotSame should return false") } } func Test_samePointers(t *testing.T) { p := ptr(2) type args struct { first interface{} second interface{} } tests := []struct { name string args args assertion BoolAssertionFunc }{ { name: "1 != 2", args: args{first: 1, second: 2}, assertion: False, }, { name: "1 != 1 (not same ptr)", args: args{first: 1, second: 1}, assertion: False, }, { name: "ptr(1) == ptr(1)", args: args{first: p, second: p}, assertion: True, }, { name: "int(1) != float32(1)", args: args{first: int(1), second: float32(1)}, assertion: False, }, { name: "array != slice", args: args{first: [2]int{1, 2}, second: []int{1, 2}}, assertion: False, }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { tt.assertion(t, samePointers(tt.args.first, tt.args.second)) }) } } // bufferT implements TestingT. Its implementation of Errorf writes the output that would be produced by // testing.T.Errorf to an internal bytes.Buffer. type bufferT struct { buf bytes.Buffer } func (t *bufferT) Errorf(format string, args ...interface{}) { // implementation of decorate is copied from testing.T decorate := func(s string) string { _, file, line, ok := runtime.Caller(3) // decorate + log + public function. if ok { // Truncate file name at last file name separator. if index := strings.LastIndex(file, "/"); index >= 0 { file = file[index+1:] } else if index = strings.LastIndex(file, "\\"); index >= 0 { file = file[index+1:] } } else { file = "???" line = 1 } buf := new(bytes.Buffer) // Every line is indented at least one tab. buf.WriteByte('\t') fmt.Fprintf(buf, "%s:%d: ", file, line) lines := strings.Split(s, "\n") if l := len(lines); l > 1 && lines[l-1] == "" { lines = lines[:l-1] } for i, line := range lines { if i > 0 { // Second and subsequent lines are indented an extra tab. buf.WriteString("\n\t\t") } buf.WriteString(line) } buf.WriteByte('\n') return buf.String() } t.buf.WriteString(decorate(fmt.Sprintf(format, args...))) } func TestStringEqual(t *testing.T) { for i, currCase := range []struct { equalWant string equalGot string msgAndArgs []interface{} want string }{ {equalWant: "hi, \nmy name is", equalGot: "what,\nmy name is", want: "\tassertions.go:\\d+: \n\t+Error Trace:\t\n\t+Error:\\s+Not equal:\\s+\n\\s+expected: \"hi, \\\\nmy name is\"\n\\s+actual\\s+: \"what,\\\\nmy name is\"\n\\s+Diff:\n\\s+-+ Expected\n\\s+\\++ Actual\n\\s+@@ -1,2 \\+1,2 @@\n\\s+-hi, \n\\s+\\+what,\n\\s+my name is"}, } { mockT := &bufferT{} Equal(mockT, currCase.equalWant, currCase.equalGot, currCase.msgAndArgs...) Regexp(t, regexp.MustCompile(currCase.want), mockT.buf.String(), "Case %d", i) } } func TestEqualFormatting(t *testing.T) { for i, currCase := range []struct { equalWant string equalGot string msgAndArgs []interface{} want string }{ {equalWant: "want", equalGot: "got", want: "\tassertions.go:\\d+: \n\t+Error Trace:\t\n\t+Error:\\s+Not equal:\\s+\n\\s+expected: \"want\"\n\\s+actual\\s+: \"got\"\n\\s+Diff:\n\\s+-+ Expected\n\\s+\\++ Actual\n\\s+@@ -1 \\+1 @@\n\\s+-want\n\\s+\\+got\n"}, {equalWant: "want", equalGot: "got", msgAndArgs: []interface{}{"hello, %v!", "world"}, want: "\tassertions.go:[0-9]+: \n\t+Error Trace:\t\n\t+Error:\\s+Not equal:\\s+\n\\s+expected: \"want\"\n\\s+actual\\s+: \"got\"\n\\s+Diff:\n\\s+-+ Expected\n\\s+\\++ Actual\n\\s+@@ -1 \\+1 @@\n\\s+-want\n\\s+\\+got\n\\s+Messages:\\s+hello, world!\n"}, {equalWant: "want", equalGot: "got", msgAndArgs: []interface{}{123}, want: "\tassertions.go:[0-9]+: \n\t+Error Trace:\t\n\t+Error:\\s+Not equal:\\s+\n\\s+expected: \"want\"\n\\s+actual\\s+: \"got\"\n\\s+Diff:\n\\s+-+ Expected\n\\s+\\++ Actual\n\\s+@@ -1 \\+1 @@\n\\s+-want\n\\s+\\+got\n\\s+Messages:\\s+123\n"}, {equalWant: "want", equalGot: "got", msgAndArgs: []interface{}{struct{ a string }{"hello"}}, want: "\tassertions.go:[0-9]+: \n\t+Error Trace:\t\n\t+Error:\\s+Not equal:\\s+\n\\s+expected: \"want\"\n\\s+actual\\s+: \"got\"\n\\s+Diff:\n\\s+-+ Expected\n\\s+\\++ Actual\n\\s+@@ -1 \\+1 @@\n\\s+-want\n\\s+\\+got\n\\s+Messages:\\s+{a:hello}\n"}, } { mockT := &bufferT{} Equal(mockT, currCase.equalWant, currCase.equalGot, currCase.msgAndArgs...) Regexp(t, regexp.MustCompile(currCase.want), mockT.buf.String(), "Case %d", i) } } func TestFormatUnequalValues(t *testing.T) { expected, actual := formatUnequalValues("foo", "bar") Equal(t, `"foo"`, expected, "value should not include type") Equal(t, `"bar"`, actual, "value should not include type") expected, actual = formatUnequalValues(123, 123) Equal(t, `123`, expected, "value should not include type") Equal(t, `123`, actual, "value should not include type") expected, actual = formatUnequalValues(int64(123), int32(123)) Equal(t, `int64(123)`, expected, "value should include type") Equal(t, `int32(123)`, actual, "value should include type") expected, actual = formatUnequalValues(int64(123), nil) Equal(t, `int64(123)`, expected, "value should include type") Equal(t, `()`, actual, "value should include type") type testStructType struct { Val string } expected, actual = formatUnequalValues(&testStructType{Val: "test"}, &testStructType{Val: "test"}) Equal(t, `&assert.testStructType{Val:"test"}`, expected, "value should not include type annotation") Equal(t, `&assert.testStructType{Val:"test"}`, actual, "value should not include type annotation") } func TestNotNil(t *testing.T) { mockT := new(testing.T) if !NotNil(mockT, new(AssertionTesterConformingObject)) { t.Error("NotNil should return true: object is not nil") } if NotNil(mockT, nil) { t.Error("NotNil should return false: object is nil") } if NotNil(mockT, (*struct{})(nil)) { t.Error("NotNil should return false: object is (*struct{})(nil)") } } func TestNil(t *testing.T) { mockT := new(testing.T) if !Nil(mockT, nil) { t.Error("Nil should return true: object is nil") } if !Nil(mockT, (*struct{})(nil)) { t.Error("Nil should return true: object is (*struct{})(nil)") } if Nil(mockT, new(AssertionTesterConformingObject)) { t.Error("Nil should return false: object is not nil") } } func TestTrue(t *testing.T) { mockT := new(testing.T) if !True(mockT, true) { t.Error("True should return true") } if True(mockT, false) { t.Error("True should return false") } } func TestFalse(t *testing.T) { mockT := new(testing.T) if !False(mockT, false) { t.Error("False should return true") } if False(mockT, true) { t.Error("False should return false") } } func TestExactly(t *testing.T) { mockT := new(testing.T) a := float32(1) b := float64(1) c := float32(1) d := float32(2) if Exactly(mockT, a, b) { t.Error("Exactly should return false") } if Exactly(mockT, a, d) { t.Error("Exactly should return false") } if !Exactly(mockT, a, c) { t.Error("Exactly should return true") } if Exactly(mockT, nil, a) { t.Error("Exactly should return false") } if Exactly(mockT, a, nil) { t.Error("Exactly should return false") } } func TestNotEqual(t *testing.T) { mockT := new(testing.T) if !NotEqual(mockT, "Hello World", "Hello World!") { t.Error("NotEqual should return true") } if !NotEqual(mockT, 123, 1234) { t.Error("NotEqual should return true") } if !NotEqual(mockT, 123.5, 123.55) { t.Error("NotEqual should return true") } if !NotEqual(mockT, []byte("Hello World"), []byte("Hello World!")) { t.Error("NotEqual should return true") } if !NotEqual(mockT, nil, new(AssertionTesterConformingObject)) { t.Error("NotEqual should return true") } funcA := func() int { return 23 } funcB := func() int { return 42 } if NotEqual(mockT, funcA, funcB) { t.Error("NotEqual should return false") } if NotEqual(mockT, nil, nil) { t.Error("NotEqual should return false") } if NotEqual(mockT, "Hello World", "Hello World") { t.Error("NotEqual should return false") } if NotEqual(mockT, 123, 123) { t.Error("NotEqual should return false") } if NotEqual(mockT, 123.5, 123.5) { t.Error("NotEqual should return false") } if NotEqual(mockT, []byte("Hello World"), []byte("Hello World")) { t.Error("NotEqual should return false") } if NotEqual(mockT, new(AssertionTesterConformingObject), new(AssertionTesterConformingObject)) { t.Error("NotEqual should return false") } if NotEqual(mockT, &struct{}{}, &struct{}{}) { t.Error("NotEqual should return false") } } type A struct { Name, Value string } func TestContains(t *testing.T) { mockT := new(testing.T) list := []string{"Foo", "Bar"} complexList := []*A{ {"b", "c"}, {"d", "e"}, {"g", "h"}, {"j", "k"}, } simpleMap := map[interface{}]interface{}{"Foo": "Bar"} if !Contains(mockT, "Hello World", "Hello") { t.Error("Contains should return true: \"Hello World\" contains \"Hello\"") } if Contains(mockT, "Hello World", "Salut") { t.Error("Contains should return false: \"Hello World\" does not contain \"Salut\"") } if !Contains(mockT, list, "Bar") { t.Error("Contains should return true: \"[\"Foo\", \"Bar\"]\" contains \"Bar\"") } if Contains(mockT, list, "Salut") { t.Error("Contains should return false: \"[\"Foo\", \"Bar\"]\" does not contain \"Salut\"") } if !Contains(mockT, complexList, &A{"g", "h"}) { t.Error("Contains should return true: complexList contains {\"g\", \"h\"}") } if Contains(mockT, complexList, &A{"g", "e"}) { t.Error("Contains should return false: complexList contains {\"g\", \"e\"}") } if Contains(mockT, complexList, &A{"g", "e"}) { t.Error("Contains should return false: complexList contains {\"g\", \"e\"}") } if !Contains(mockT, simpleMap, "Foo") { t.Error("Contains should return true: \"{\"Foo\": \"Bar\"}\" contains \"Foo\"") } if Contains(mockT, simpleMap, "Bar") { t.Error("Contains should return false: \"{\"Foo\": \"Bar\"}\" does not contains \"Bar\"") } } func TestNotContains(t *testing.T) { mockT := new(testing.T) list := []string{"Foo", "Bar"} simpleMap := map[interface{}]interface{}{"Foo": "Bar"} if !NotContains(mockT, "Hello World", "Hello!") { t.Error("NotContains should return true: \"Hello World\" does not contain \"Hello!\"") } if NotContains(mockT, "Hello World", "Hello") { t.Error("NotContains should return false: \"Hello World\" contains \"Hello\"") } if !NotContains(mockT, list, "Foo!") { t.Error("NotContains should return true: \"[\"Foo\", \"Bar\"]\" does not contain \"Foo!\"") } if NotContains(mockT, list, "Foo") { t.Error("NotContains should return false: \"[\"Foo\", \"Bar\"]\" contains \"Foo\"") } if NotContains(mockT, simpleMap, "Foo") { t.Error("Contains should return true: \"{\"Foo\": \"Bar\"}\" contains \"Foo\"") } if !NotContains(mockT, simpleMap, "Bar") { t.Error("Contains should return false: \"{\"Foo\": \"Bar\"}\" does not contains \"Bar\"") } } func TestSubset(t *testing.T) { mockT := new(testing.T) if !Subset(mockT, []int{1, 2, 3}, nil) { t.Error("Subset should return true: given subset is nil") } if !Subset(mockT, []int{1, 2, 3}, []int{}) { t.Error("Subset should return true: any set contains the nil set") } if !Subset(mockT, []int{1, 2, 3}, []int{1, 2}) { t.Error("Subset should return true: [1, 2, 3] contains [1, 2]") } if !Subset(mockT, []int{1, 2, 3}, []int{1, 2, 3}) { t.Error("Subset should return true: [1, 2, 3] contains [1, 2, 3]") } if !Subset(mockT, []string{"hello", "world"}, []string{"hello"}) { t.Error("Subset should return true: [\"hello\", \"world\"] contains [\"hello\"]") } if Subset(mockT, []string{"hello", "world"}, []string{"hello", "testify"}) { t.Error("Subset should return false: [\"hello\", \"world\"] does not contain [\"hello\", \"testify\"]") } if Subset(mockT, []int{1, 2, 3}, []int{4, 5}) { t.Error("Subset should return false: [1, 2, 3] does not contain [4, 5]") } if Subset(mockT, []int{1, 2, 3}, []int{1, 5}) { t.Error("Subset should return false: [1, 2, 3] does not contain [1, 5]") } } func TestNotSubset(t *testing.T) { mockT := new(testing.T) if NotSubset(mockT, []int{1, 2, 3}, nil) { t.Error("NotSubset should return false: given subset is nil") } if NotSubset(mockT, []int{1, 2, 3}, []int{}) { t.Error("NotSubset should return false: any set contains the nil set") } if NotSubset(mockT, []int{1, 2, 3}, []int{1, 2}) { t.Error("NotSubset should return false: [1, 2, 3] contains [1, 2]") } if NotSubset(mockT, []int{1, 2, 3}, []int{1, 2, 3}) { t.Error("NotSubset should return false: [1, 2, 3] contains [1, 2, 3]") } if NotSubset(mockT, []string{"hello", "world"}, []string{"hello"}) { t.Error("NotSubset should return false: [\"hello\", \"world\"] contains [\"hello\"]") } if !NotSubset(mockT, []string{"hello", "world"}, []string{"hello", "testify"}) { t.Error("NotSubset should return true: [\"hello\", \"world\"] does not contain [\"hello\", \"testify\"]") } if !NotSubset(mockT, []int{1, 2, 3}, []int{4, 5}) { t.Error("NotSubset should return true: [1, 2, 3] does not contain [4, 5]") } if !NotSubset(mockT, []int{1, 2, 3}, []int{1, 5}) { t.Error("NotSubset should return true: [1, 2, 3] does not contain [1, 5]") } } func TestNotSubsetNil(t *testing.T) { mockT := new(testing.T) NotSubset(mockT, []string{"foo"}, nil) if !mockT.Failed() { t.Error("NotSubset on nil set should have failed the test") } } func Test_includeElement(t *testing.T) { list1 := []string{"Foo", "Bar"} list2 := []int{1, 2} simpleMap := map[interface{}]interface{}{"Foo": "Bar"} ok, found := includeElement("Hello World", "World") True(t, ok) True(t, found) ok, found = includeElement(list1, "Foo") True(t, ok) True(t, found) ok, found = includeElement(list1, "Bar") True(t, ok) True(t, found) ok, found = includeElement(list2, 1) True(t, ok) True(t, found) ok, found = includeElement(list2, 2) True(t, ok) True(t, found) ok, found = includeElement(list1, "Foo!") True(t, ok) False(t, found) ok, found = includeElement(list2, 3) True(t, ok) False(t, found) ok, found = includeElement(list2, "1") True(t, ok) False(t, found) ok, found = includeElement(simpleMap, "Foo") True(t, ok) True(t, found) ok, found = includeElement(simpleMap, "Bar") True(t, ok) False(t, found) ok, found = includeElement(1433, "1") False(t, ok) False(t, found) } func TestElementsMatch(t *testing.T) { mockT := new(testing.T) if !ElementsMatch(mockT, nil, nil) { t.Error("ElementsMatch should return true") } if !ElementsMatch(mockT, []int{}, []int{}) { t.Error("ElementsMatch should return true") } if !ElementsMatch(mockT, []int{1}, []int{1}) { t.Error("ElementsMatch should return true") } if !ElementsMatch(mockT, []int{1, 1}, []int{1, 1}) { t.Error("ElementsMatch should return true") } if !ElementsMatch(mockT, []int{1, 2}, []int{1, 2}) { t.Error("ElementsMatch should return true") } if !ElementsMatch(mockT, []int{1, 2}, []int{2, 1}) { t.Error("ElementsMatch should return true") } if !ElementsMatch(mockT, [2]int{1, 2}, [2]int{2, 1}) { t.Error("ElementsMatch should return true") } if !ElementsMatch(mockT, []string{"hello", "world"}, []string{"world", "hello"}) { t.Error("ElementsMatch should return true") } if !ElementsMatch(mockT, []string{"hello", "hello"}, []string{"hello", "hello"}) { t.Error("ElementsMatch should return true") } if !ElementsMatch(mockT, []string{"hello", "hello", "world"}, []string{"hello", "world", "hello"}) { t.Error("ElementsMatch should return true") } if !ElementsMatch(mockT, [3]string{"hello", "hello", "world"}, [3]string{"hello", "world", "hello"}) { t.Error("ElementsMatch should return true") } if !ElementsMatch(mockT, []int{}, nil) { t.Error("ElementsMatch should return true") } if ElementsMatch(mockT, []int{1}, []int{1, 1}) { t.Error("ElementsMatch should return false") } if ElementsMatch(mockT, []int{1, 2}, []int{2, 2}) { t.Error("ElementsMatch should return false") } if ElementsMatch(mockT, []string{"hello", "hello"}, []string{"hello"}) { t.Error("ElementsMatch should return false") } } func TestCondition(t *testing.T) { mockT := new(testing.T) if !Condition(mockT, func() bool { return true }, "Truth") { t.Error("Condition should return true") } if Condition(mockT, func() bool { return false }, "Lie") { t.Error("Condition should return false") } } func TestDidPanic(t *testing.T) { if funcDidPanic, _, _ := didPanic(func() { panic("Panic!") }); !funcDidPanic { t.Error("didPanic should return true") } if funcDidPanic, _, _ := didPanic(func() { }); funcDidPanic { t.Error("didPanic should return false") } } func TestPanics(t *testing.T) { mockT := new(testing.T) if !Panics(mockT, func() { panic("Panic!") }) { t.Error("Panics should return true") } if Panics(mockT, func() { }) { t.Error("Panics should return false") } } func TestPanicsWithValue(t *testing.T) { mockT := new(testing.T) if !PanicsWithValue(mockT, "Panic!", func() { panic("Panic!") }) { t.Error("PanicsWithValue should return true") } if PanicsWithValue(mockT, "Panic!", func() { }) { t.Error("PanicsWithValue should return false") } if PanicsWithValue(mockT, "at the disco", func() { panic("Panic!") }) { t.Error("PanicsWithValue should return false") } } func TestPanicsWithError(t *testing.T) { mockT := new(testing.T) if !PanicsWithError(mockT, "panic", func() { panic(errors.New("panic")) }) { t.Error("PanicsWithError should return true") } if PanicsWithError(mockT, "Panic!", func() { }) { t.Error("PanicsWithError should return false") } if PanicsWithError(mockT, "at the disco", func() { panic(errors.New("panic")) }) { t.Error("PanicsWithError should return false") } if PanicsWithError(mockT, "Panic!", func() { panic("panic") }) { t.Error("PanicsWithError should return false") } } func TestNotPanics(t *testing.T) { mockT := new(testing.T) if !NotPanics(mockT, func() { }) { t.Error("NotPanics should return true") } if NotPanics(mockT, func() { panic("Panic!") }) { t.Error("NotPanics should return false") } } func TestNoError(t *testing.T) { mockT := new(testing.T) // start with a nil error var err error True(t, NoError(mockT, err), "NoError should return True for nil arg") // now set an error err = errors.New("some error") False(t, NoError(mockT, err), "NoError with error should return False") // returning an empty error interface err = func() error { var err *customError if err != nil { t.Fatal("err should be nil here") } return err }() if err == nil { // err is not nil here! t.Errorf("Error should be nil due to empty interface: %s", err) } False(t, NoError(mockT, err), "NoError should fail with empty error interface") } type customError struct{} func (*customError) Error() string { return "fail" } func TestError(t *testing.T) { mockT := new(testing.T) // start with a nil error var err error False(t, Error(mockT, err), "Error should return False for nil arg") // now set an error err = errors.New("some error") True(t, Error(mockT, err), "Error with error should return True") // go vet check True(t, Errorf(mockT, err, "example with %s", "formatted message"), "Errorf with error should rturn True") // returning an empty error interface err = func() error { var err *customError if err != nil { t.Fatal("err should be nil here") } return err }() if err == nil { // err is not nil here! t.Errorf("Error should be nil due to empty interface: %s", err) } True(t, Error(mockT, err), "Error should pass with empty error interface") } func TestEqualError(t *testing.T) { mockT := new(testing.T) // start with a nil error var err error False(t, EqualError(mockT, err, ""), "EqualError should return false for nil arg") // now set an error err = errors.New("some error") False(t, EqualError(mockT, err, "Not some error"), "EqualError should return false for different error string") True(t, EqualError(mockT, err, "some error"), "EqualError should return true") } func Test_isEmpty(t *testing.T) { chWithValue := make(chan struct{}, 1) chWithValue <- struct{}{} True(t, isEmpty("")) True(t, isEmpty(nil)) True(t, isEmpty([]string{})) True(t, isEmpty(0)) True(t, isEmpty(int32(0))) True(t, isEmpty(int64(0))) True(t, isEmpty(false)) True(t, isEmpty(map[string]string{})) True(t, isEmpty(new(time.Time))) True(t, isEmpty(time.Time{})) True(t, isEmpty(make(chan struct{}))) False(t, isEmpty("something")) False(t, isEmpty(errors.New("something"))) False(t, isEmpty([]string{"something"})) False(t, isEmpty(1)) False(t, isEmpty(true)) False(t, isEmpty(map[string]string{"Hello": "World"})) False(t, isEmpty(chWithValue)) } func TestEmpty(t *testing.T) { mockT := new(testing.T) chWithValue := make(chan struct{}, 1) chWithValue <- struct{}{} var tiP *time.Time var tiNP time.Time var s *string var f *os.File sP := &s x := 1 xP := &x type TString string type TStruct struct { x int s []int } True(t, Empty(mockT, ""), "Empty string is empty") True(t, Empty(mockT, nil), "Nil is empty") True(t, Empty(mockT, []string{}), "Empty string array is empty") True(t, Empty(mockT, 0), "Zero int value is empty") True(t, Empty(mockT, false), "False value is empty") True(t, Empty(mockT, make(chan struct{})), "Channel without values is empty") True(t, Empty(mockT, s), "Nil string pointer is empty") True(t, Empty(mockT, f), "Nil os.File pointer is empty") True(t, Empty(mockT, tiP), "Nil time.Time pointer is empty") True(t, Empty(mockT, tiNP), "time.Time is empty") True(t, Empty(mockT, TStruct{}), "struct with zero values is empty") True(t, Empty(mockT, TString("")), "empty aliased string is empty") True(t, Empty(mockT, sP), "ptr to nil value is empty") False(t, Empty(mockT, "something"), "Non Empty string is not empty") False(t, Empty(mockT, errors.New("something")), "Non nil object is not empty") False(t, Empty(mockT, []string{"something"}), "Non empty string array is not empty") False(t, Empty(mockT, 1), "Non-zero int value is not empty") False(t, Empty(mockT, true), "True value is not empty") False(t, Empty(mockT, chWithValue), "Channel with values is not empty") False(t, Empty(mockT, TStruct{x: 1}), "struct with initialized values is empty") False(t, Empty(mockT, TString("abc")), "non-empty aliased string is empty") False(t, Empty(mockT, xP), "ptr to non-nil value is not empty") } func TestNotEmpty(t *testing.T) { mockT := new(testing.T) chWithValue := make(chan struct{}, 1) chWithValue <- struct{}{} False(t, NotEmpty(mockT, ""), "Empty string is empty") False(t, NotEmpty(mockT, nil), "Nil is empty") False(t, NotEmpty(mockT, []string{}), "Empty string array is empty") False(t, NotEmpty(mockT, 0), "Zero int value is empty") False(t, NotEmpty(mockT, false), "False value is empty") False(t, NotEmpty(mockT, make(chan struct{})), "Channel without values is empty") True(t, NotEmpty(mockT, "something"), "Non Empty string is not empty") True(t, NotEmpty(mockT, errors.New("something")), "Non nil object is not empty") True(t, NotEmpty(mockT, []string{"something"}), "Non empty string array is not empty") True(t, NotEmpty(mockT, 1), "Non-zero int value is not empty") True(t, NotEmpty(mockT, true), "True value is not empty") True(t, NotEmpty(mockT, chWithValue), "Channel with values is not empty") } func Test_getLen(t *testing.T) { falseCases := []interface{}{ nil, 0, true, false, 'A', struct{}{}, } for _, v := range falseCases { ok, l := getLen(v) False(t, ok, "Expected getLen fail to get length of %#v", v) Equal(t, 0, l, "getLen should return 0 for %#v", v) } ch := make(chan int, 5) ch <- 1 ch <- 2 ch <- 3 trueCases := []struct { v interface{} l int }{ {[]int{1, 2, 3}, 3}, {[...]int{1, 2, 3}, 3}, {"ABC", 3}, {map[int]int{1: 2, 2: 4, 3: 6}, 3}, {ch, 3}, {[]int{}, 0}, {map[int]int{}, 0}, {make(chan int), 0}, {[]int(nil), 0}, {map[int]int(nil), 0}, {(chan int)(nil), 0}, } for _, c := range trueCases { ok, l := getLen(c.v) True(t, ok, "Expected getLen success to get length of %#v", c.v) Equal(t, c.l, l) } } func TestLen(t *testing.T) { mockT := new(testing.T) False(t, Len(mockT, nil, 0), "nil does not have length") False(t, Len(mockT, 0, 0), "int does not have length") False(t, Len(mockT, true, 0), "true does not have length") False(t, Len(mockT, false, 0), "false does not have length") False(t, Len(mockT, 'A', 0), "Rune does not have length") False(t, Len(mockT, struct{}{}, 0), "Struct does not have length") ch := make(chan int, 5) ch <- 1 ch <- 2 ch <- 3 cases := []struct { v interface{} l int }{ {[]int{1, 2, 3}, 3}, {[...]int{1, 2, 3}, 3}, {"ABC", 3}, {map[int]int{1: 2, 2: 4, 3: 6}, 3}, {ch, 3}, {[]int{}, 0}, {map[int]int{}, 0}, {make(chan int), 0}, {[]int(nil), 0}, {map[int]int(nil), 0}, {(chan int)(nil), 0}, } for _, c := range cases { True(t, Len(mockT, c.v, c.l), "%#v have %d items", c.v, c.l) } cases = []struct { v interface{} l int }{ {[]int{1, 2, 3}, 4}, {[...]int{1, 2, 3}, 2}, {"ABC", 2}, {map[int]int{1: 2, 2: 4, 3: 6}, 4}, {ch, 2}, {[]int{}, 1}, {map[int]int{}, 1}, {make(chan int), 1}, {[]int(nil), 1}, {map[int]int(nil), 1}, {(chan int)(nil), 1}, } for _, c := range cases { False(t, Len(mockT, c.v, c.l), "%#v have %d items", c.v, c.l) } } func TestWithinDuration(t *testing.T) { mockT := new(testing.T) a := time.Now() b := a.Add(10 * time.Second) True(t, WithinDuration(mockT, a, b, 10*time.Second), "A 10s difference is within a 10s time difference") True(t, WithinDuration(mockT, b, a, 10*time.Second), "A 10s difference is within a 10s time difference") False(t, WithinDuration(mockT, a, b, 9*time.Second), "A 10s difference is not within a 9s time difference") False(t, WithinDuration(mockT, b, a, 9*time.Second), "A 10s difference is not within a 9s time difference") False(t, WithinDuration(mockT, a, b, -9*time.Second), "A 10s difference is not within a 9s time difference") False(t, WithinDuration(mockT, b, a, -9*time.Second), "A 10s difference is not within a 9s time difference") False(t, WithinDuration(mockT, a, b, -11*time.Second), "A 10s difference is not within a 9s time difference") False(t, WithinDuration(mockT, b, a, -11*time.Second), "A 10s difference is not within a 9s time difference") } func TestInDelta(t *testing.T) { mockT := new(testing.T) True(t, InDelta(mockT, 1.001, 1, 0.01), "|1.001 - 1| <= 0.01") True(t, InDelta(mockT, 1, 1.001, 0.01), "|1 - 1.001| <= 0.01") True(t, InDelta(mockT, 1, 2, 1), "|1 - 2| <= 1") False(t, InDelta(mockT, 1, 2, 0.5), "Expected |1 - 2| <= 0.5 to fail") False(t, InDelta(mockT, 2, 1, 0.5), "Expected |2 - 1| <= 0.5 to fail") False(t, InDelta(mockT, "", nil, 1), "Expected non numerals to fail") False(t, InDelta(mockT, 42, math.NaN(), 0.01), "Expected NaN for actual to fail") False(t, InDelta(mockT, math.NaN(), 42, 0.01), "Expected NaN for expected to fail") cases := []struct { a, b interface{} delta float64 }{ {uint8(2), uint8(1), 1}, {uint16(2), uint16(1), 1}, {uint32(2), uint32(1), 1}, {uint64(2), uint64(1), 1}, {int(2), int(1), 1}, {int8(2), int8(1), 1}, {int16(2), int16(1), 1}, {int32(2), int32(1), 1}, {int64(2), int64(1), 1}, {float32(2), float32(1), 1}, {float64(2), float64(1), 1}, } for _, tc := range cases { True(t, InDelta(mockT, tc.a, tc.b, tc.delta), "Expected |%V - %V| <= %v", tc.a, tc.b, tc.delta) } } func TestInDeltaSlice(t *testing.T) { mockT := new(testing.T) True(t, InDeltaSlice(mockT, []float64{1.001, 0.999}, []float64{1, 1}, 0.1), "{1.001, 0.009} is element-wise close to {1, 1} in delta=0.1") True(t, InDeltaSlice(mockT, []float64{1, 2}, []float64{0, 3}, 1), "{1, 2} is element-wise close to {0, 3} in delta=1") False(t, InDeltaSlice(mockT, []float64{1, 2}, []float64{0, 3}, 0.1), "{1, 2} is not element-wise close to {0, 3} in delta=0.1") False(t, InDeltaSlice(mockT, "", nil, 1), "Expected non numeral slices to fail") } func TestInDeltaMapValues(t *testing.T) { mockT := new(testing.T) for _, tc := range []struct { title string expect interface{} actual interface{} f func(TestingT, bool, ...interface{}) bool delta float64 }{ { title: "Within delta", expect: map[string]float64{ "foo": 1.0, "bar": 2.0, }, actual: map[string]float64{ "foo": 1.01, "bar": 1.99, }, delta: 0.1, f: True, }, { title: "Within delta", expect: map[int]float64{ 1: 1.0, 2: 2.0, }, actual: map[int]float64{ 1: 1.0, 2: 1.99, }, delta: 0.1, f: True, }, { title: "Different number of keys", expect: map[int]float64{ 1: 1.0, 2: 2.0, }, actual: map[int]float64{ 1: 1.0, }, delta: 0.1, f: False, }, { title: "Within delta with zero value", expect: map[string]float64{ "zero": 0.0, }, actual: map[string]float64{ "zero": 0.0, }, delta: 0.1, f: True, }, { title: "With missing key with zero value", expect: map[string]float64{ "zero": 0.0, "foo": 0.0, }, actual: map[string]float64{ "zero": 0.0, "bar": 0.0, }, f: False, }, } { tc.f(t, InDeltaMapValues(mockT, tc.expect, tc.actual, tc.delta), tc.title+"\n"+diff(tc.expect, tc.actual)) } } func TestInEpsilon(t *testing.T) { mockT := new(testing.T) cases := []struct { a, b interface{} epsilon float64 }{ {uint8(2), uint16(2), .001}, {2.1, 2.2, 0.1}, {2.2, 2.1, 0.1}, {-2.1, -2.2, 0.1}, {-2.2, -2.1, 0.1}, {uint64(100), uint8(101), 0.01}, {0.1, -0.1, 2}, {0.1, 0, 2}, {time.Second, time.Second + time.Millisecond, 0.002}, } for _, tc := range cases { True(t, InEpsilon(t, tc.a, tc.b, tc.epsilon, "Expected %V and %V to have a relative difference of %v", tc.a, tc.b, tc.epsilon), "test: %q", tc) } cases = []struct { a, b interface{} epsilon float64 }{ {uint8(2), int16(-2), .001}, {uint64(100), uint8(102), 0.01}, {2.1, 2.2, 0.001}, {2.2, 2.1, 0.001}, {2.1, -2.2, 1}, {2.1, "bla-bla", 0}, {0.1, -0.1, 1.99}, {0, 0.1, 2}, // expected must be different to zero {time.Second, time.Second + 10*time.Millisecond, 0.002}, } for _, tc := range cases { False(t, InEpsilon(mockT, tc.a, tc.b, tc.epsilon, "Expected %V and %V to have a relative difference of %v", tc.a, tc.b, tc.epsilon)) } } func TestInEpsilonSlice(t *testing.T) { mockT := new(testing.T) True(t, InEpsilonSlice(mockT, []float64{2.2, 2.0}, []float64{2.1, 2.1}, 0.06), "{2.2, 2.0} is element-wise close to {2.1, 2.1} in espilon=0.06") False(t, InEpsilonSlice(mockT, []float64{2.2, 2.0}, []float64{2.1, 2.1}, 0.04), "{2.2, 2.0} is not element-wise close to {2.1, 2.1} in espilon=0.04") False(t, InEpsilonSlice(mockT, "", nil, 1), "Expected non numeral slices to fail") } func TestRegexp(t *testing.T) { mockT := new(testing.T) cases := []struct { rx, str string }{ {"^start", "start of the line"}, {"end$", "in the end"}, {"[0-9]{3}[.-]?[0-9]{2}[.-]?[0-9]{2}", "My phone number is 650.12.34"}, } for _, tc := range cases { True(t, Regexp(mockT, tc.rx, tc.str)) True(t, Regexp(mockT, regexp.MustCompile(tc.rx), tc.str)) False(t, NotRegexp(mockT, tc.rx, tc.str)) False(t, NotRegexp(mockT, regexp.MustCompile(tc.rx), tc.str)) } cases = []struct { rx, str string }{ {"^asdfastart", "Not the start of the line"}, {"end$", "in the end."}, {"[0-9]{3}[.-]?[0-9]{2}[.-]?[0-9]{2}", "My phone number is 650.12a.34"}, } for _, tc := range cases { False(t, Regexp(mockT, tc.rx, tc.str), "Expected \"%s\" to not match \"%s\"", tc.rx, tc.str) False(t, Regexp(mockT, regexp.MustCompile(tc.rx), tc.str)) True(t, NotRegexp(mockT, tc.rx, tc.str)) True(t, NotRegexp(mockT, regexp.MustCompile(tc.rx), tc.str)) } } func testAutogeneratedFunction() { defer func() { if err := recover(); err == nil { panic("did not panic") } CallerInfo() }() t := struct { io.Closer }{} var c io.Closer c = t c.Close() } func TestCallerInfoWithAutogeneratedFunctions(t *testing.T) { NotPanics(t, func() { testAutogeneratedFunction() }) } func TestZero(t *testing.T) { mockT := new(testing.T) for _, test := range zeros { True(t, Zero(mockT, test, "%#v is not the %v zero value", test, reflect.TypeOf(test))) } for _, test := range nonZeros { False(t, Zero(mockT, test, "%#v is not the %v zero value", test, reflect.TypeOf(test))) } } func TestNotZero(t *testing.T) { mockT := new(testing.T) for _, test := range zeros { False(t, NotZero(mockT, test, "%#v is not the %v zero value", test, reflect.TypeOf(test))) } for _, test := range nonZeros { True(t, NotZero(mockT, test, "%#v is not the %v zero value", test, reflect.TypeOf(test))) } } func TestFileExists(t *testing.T) { mockT := new(testing.T) True(t, FileExists(mockT, "assertions.go")) mockT = new(testing.T) False(t, FileExists(mockT, "random_file")) mockT = new(testing.T) False(t, FileExists(mockT, "../_codegen")) var tempFiles []string link, err := getTempSymlinkPath("assertions.go") if err != nil { t.Fatal("could not create temp symlink, err:", err) } tempFiles = append(tempFiles, link) mockT = new(testing.T) True(t, FileExists(mockT, link)) link, err = getTempSymlinkPath("non_existent_file") if err != nil { t.Fatal("could not create temp symlink, err:", err) } tempFiles = append(tempFiles, link) mockT = new(testing.T) True(t, FileExists(mockT, link)) errs := cleanUpTempFiles(tempFiles) if len(errs) > 0 { t.Fatal("could not clean up temporary files") } } func TestNoFileExists(t *testing.T) { mockT := new(testing.T) False(t, NoFileExists(mockT, "assertions.go")) mockT = new(testing.T) True(t, NoFileExists(mockT, "non_existent_file")) mockT = new(testing.T) True(t, NoFileExists(mockT, "../_codegen")) var tempFiles []string link, err := getTempSymlinkPath("assertions.go") if err != nil { t.Fatal("could not create temp symlink, err:", err) } tempFiles = append(tempFiles, link) mockT = new(testing.T) False(t, NoFileExists(mockT, link)) link, err = getTempSymlinkPath("non_existent_file") if err != nil { t.Fatal("could not create temp symlink, err:", err) } tempFiles = append(tempFiles, link) mockT = new(testing.T) False(t, NoFileExists(mockT, link)) errs := cleanUpTempFiles(tempFiles) if len(errs) > 0 { t.Fatal("could not clean up temporary files") } } func getTempSymlinkPath(file string) (string, error) { link := file + "_symlink" err := os.Symlink(file, link) return link, err } func cleanUpTempFiles(paths []string) []error { var res []error for _, path := range paths { err := os.Remove(path) if err != nil { res = append(res, err) } } return res } func TestDirExists(t *testing.T) { mockT := new(testing.T) False(t, DirExists(mockT, "assertions.go")) mockT = new(testing.T) False(t, DirExists(mockT, "non_existent_dir")) mockT = new(testing.T) True(t, DirExists(mockT, "../_codegen")) var tempFiles []string link, err := getTempSymlinkPath("assertions.go") if err != nil { t.Fatal("could not create temp symlink, err:", err) } tempFiles = append(tempFiles, link) mockT = new(testing.T) False(t, DirExists(mockT, link)) link, err = getTempSymlinkPath("non_existent_dir") if err != nil { t.Fatal("could not create temp symlink, err:", err) } tempFiles = append(tempFiles, link) mockT = new(testing.T) False(t, DirExists(mockT, link)) errs := cleanUpTempFiles(tempFiles) if len(errs) > 0 { t.Fatal("could not clean up temporary files") } } func TestNoDirExists(t *testing.T) { mockT := new(testing.T) True(t, NoDirExists(mockT, "assertions.go")) mockT = new(testing.T) True(t, NoDirExists(mockT, "non_existent_dir")) mockT = new(testing.T) False(t, NoDirExists(mockT, "../_codegen")) var tempFiles []string link, err := getTempSymlinkPath("assertions.go") if err != nil { t.Fatal("could not create temp symlink, err:", err) } tempFiles = append(tempFiles, link) mockT = new(testing.T) True(t, NoDirExists(mockT, link)) link, err = getTempSymlinkPath("non_existent_dir") if err != nil { t.Fatal("could not create temp symlink, err:", err) } tempFiles = append(tempFiles, link) mockT = new(testing.T) True(t, NoDirExists(mockT, link)) errs := cleanUpTempFiles(tempFiles) if len(errs) > 0 { t.Fatal("could not clean up temporary files") } } func TestJSONEq_EqualSONString(t *testing.T) { mockT := new(testing.T) True(t, JSONEq(mockT, `{"hello": "world", "foo": "bar"}`, `{"hello": "world", "foo": "bar"}`)) } func TestJSONEq_EquivalentButNotEqual(t *testing.T) { mockT := new(testing.T) True(t, JSONEq(mockT, `{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`)) } func TestJSONEq_HashOfArraysAndHashes(t *testing.T) { mockT := new(testing.T) True(t, JSONEq(mockT, "{\r\n\t\"numeric\": 1.5,\r\n\t\"array\": [{\"foo\": \"bar\"}, 1, \"string\", [\"nested\", \"array\", 5.5]],\r\n\t\"hash\": {\"nested\": \"hash\", \"nested_slice\": [\"this\", \"is\", \"nested\"]},\r\n\t\"string\": \"foo\"\r\n}", "{\r\n\t\"numeric\": 1.5,\r\n\t\"hash\": {\"nested\": \"hash\", \"nested_slice\": [\"this\", \"is\", \"nested\"]},\r\n\t\"string\": \"foo\",\r\n\t\"array\": [{\"foo\": \"bar\"}, 1, \"string\", [\"nested\", \"array\", 5.5]]\r\n}")) } func TestJSONEq_Array(t *testing.T) { mockT := new(testing.T) True(t, JSONEq(mockT, `["foo", {"hello": "world", "nested": "hash"}]`, `["foo", {"nested": "hash", "hello": "world"}]`)) } func TestJSONEq_HashAndArrayNotEquivalent(t *testing.T) { mockT := new(testing.T) False(t, JSONEq(mockT, `["foo", {"hello": "world", "nested": "hash"}]`, `{"foo": "bar", {"nested": "hash", "hello": "world"}}`)) } func TestJSONEq_HashesNotEquivalent(t *testing.T) { mockT := new(testing.T) False(t, JSONEq(mockT, `{"foo": "bar"}`, `{"foo": "bar", "hello": "world"}`)) } func TestJSONEq_ActualIsNotJSON(t *testing.T) { mockT := new(testing.T) False(t, JSONEq(mockT, `{"foo": "bar"}`, "Not JSON")) } func TestJSONEq_ExpectedIsNotJSON(t *testing.T) { mockT := new(testing.T) False(t, JSONEq(mockT, "Not JSON", `{"foo": "bar", "hello": "world"}`)) } func TestJSONEq_ExpectedAndActualNotJSON(t *testing.T) { mockT := new(testing.T) False(t, JSONEq(mockT, "Not JSON", "Not JSON")) } func TestJSONEq_ArraysOfDifferentOrder(t *testing.T) { mockT := new(testing.T) False(t, JSONEq(mockT, `["foo", {"hello": "world", "nested": "hash"}]`, `[{ "hello": "world", "nested": "hash"}, "foo"]`)) } func TestYAMLEq_EqualYAMLString(t *testing.T) { mockT := new(testing.T) True(t, YAMLEq(mockT, `{"hello": "world", "foo": "bar"}`, `{"hello": "world", "foo": "bar"}`)) } func TestYAMLEq_EquivalentButNotEqual(t *testing.T) { mockT := new(testing.T) True(t, YAMLEq(mockT, `{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`)) } func TestYAMLEq_HashOfArraysAndHashes(t *testing.T) { mockT := new(testing.T) expected := ` numeric: 1.5 array: - foo: bar - 1 - "string" - ["nested", "array", 5.5] hash: nested: hash nested_slice: [this, is, nested] string: "foo" ` actual := ` numeric: 1.5 hash: nested: hash nested_slice: [this, is, nested] string: "foo" array: - foo: bar - 1 - "string" - ["nested", "array", 5.5] ` True(t, YAMLEq(mockT, expected, actual)) } func TestYAMLEq_Array(t *testing.T) { mockT := new(testing.T) True(t, YAMLEq(mockT, `["foo", {"hello": "world", "nested": "hash"}]`, `["foo", {"nested": "hash", "hello": "world"}]`)) } func TestYAMLEq_HashAndArrayNotEquivalent(t *testing.T) { mockT := new(testing.T) False(t, YAMLEq(mockT, `["foo", {"hello": "world", "nested": "hash"}]`, `{"foo": "bar", {"nested": "hash", "hello": "world"}}`)) } func TestYAMLEq_HashesNotEquivalent(t *testing.T) { mockT := new(testing.T) False(t, YAMLEq(mockT, `{"foo": "bar"}`, `{"foo": "bar", "hello": "world"}`)) } func TestYAMLEq_ActualIsSimpleString(t *testing.T) { mockT := new(testing.T) False(t, YAMLEq(mockT, `{"foo": "bar"}`, "Simple String")) } func TestYAMLEq_ExpectedIsSimpleString(t *testing.T) { mockT := new(testing.T) False(t, YAMLEq(mockT, "Simple String", `{"foo": "bar", "hello": "world"}`)) } func TestYAMLEq_ExpectedAndActualSimpleString(t *testing.T) { mockT := new(testing.T) True(t, YAMLEq(mockT, "Simple String", "Simple String")) } func TestYAMLEq_ArraysOfDifferentOrder(t *testing.T) { mockT := new(testing.T) False(t, YAMLEq(mockT, `["foo", {"hello": "world", "nested": "hash"}]`, `[{ "hello": "world", "nested": "hash"}, "foo"]`)) } func TestDiff(t *testing.T) { expected := ` Diff: --- Expected +++ Actual @@ -1,3 +1,3 @@ (struct { foo string }) { - foo: (string) (len=5) "hello" + foo: (string) (len=3) "bar" } ` actual := diff( struct{ foo string }{"hello"}, struct{ foo string }{"bar"}, ) Equal(t, expected, actual) expected = ` Diff: --- Expected +++ Actual @@ -2,5 +2,5 @@ (int) 1, - (int) 2, (int) 3, - (int) 4 + (int) 5, + (int) 7 } ` actual = diff( []int{1, 2, 3, 4}, []int{1, 3, 5, 7}, ) Equal(t, expected, actual) expected = ` Diff: --- Expected +++ Actual @@ -2,4 +2,4 @@ (int) 1, - (int) 2, - (int) 3 + (int) 3, + (int) 5 } ` actual = diff( []int{1, 2, 3, 4}[0:3], []int{1, 3, 5, 7}[0:3], ) Equal(t, expected, actual) expected = ` Diff: --- Expected +++ Actual @@ -1,6 +1,6 @@ (map[string]int) (len=4) { - (string) (len=4) "four": (int) 4, + (string) (len=4) "five": (int) 5, (string) (len=3) "one": (int) 1, - (string) (len=5) "three": (int) 3, - (string) (len=3) "two": (int) 2 + (string) (len=5) "seven": (int) 7, + (string) (len=5) "three": (int) 3 } ` actual = diff( map[string]int{"one": 1, "two": 2, "three": 3, "four": 4}, map[string]int{"one": 1, "three": 3, "five": 5, "seven": 7}, ) Equal(t, expected, actual) } func TestTimeEqualityErrorFormatting(t *testing.T) { mockT := new(mockTestingT) Equal(mockT, time.Second*2, time.Millisecond) expectedErr := "\\s+Error Trace:\\s+Error:\\s+Not equal:\\s+\n\\s+expected: 2s\n\\s+actual\\s+: 1ms\n" Regexp(t, regexp.MustCompile(expectedErr), mockT.errorString()) } func TestDiffEmptyCases(t *testing.T) { Equal(t, "", diff(nil, nil)) Equal(t, "", diff(struct{ foo string }{}, nil)) Equal(t, "", diff(nil, struct{ foo string }{})) Equal(t, "", diff(1, 2)) Equal(t, "", diff(1, 2)) Equal(t, "", diff([]int{1}, []bool{true})) } // Ensure there are no data races func TestDiffRace(t *testing.T) { t.Parallel() expected := map[string]string{ "a": "A", "b": "B", "c": "C", } actual := map[string]string{ "d": "D", "e": "E", "f": "F", } // run diffs in parallel simulating tests with t.Parallel() numRoutines := 10 rChans := make([]chan string, numRoutines) for idx := range rChans { rChans[idx] = make(chan string) go func(ch chan string) { defer close(ch) ch <- diff(expected, actual) }(rChans[idx]) } for _, ch := range rChans { for msg := range ch { NotZero(t, msg) // dummy assert } } } type mockTestingT struct { errorFmt string args []interface{} } func (m *mockTestingT) errorString() string { return fmt.Sprintf(m.errorFmt, m.args...) } func (m *mockTestingT) Errorf(format string, args ...interface{}) { m.errorFmt = format m.args = args } func TestFailNowWithPlainTestingT(t *testing.T) { mockT := &mockTestingT{} Panics(t, func() { FailNow(mockT, "failed") }, "should panic since mockT is missing FailNow()") } type mockFailNowTestingT struct { } func (m *mockFailNowTestingT) Errorf(format string, args ...interface{}) {} func (m *mockFailNowTestingT) FailNow() {} func TestFailNowWithFullTestingT(t *testing.T) { mockT := &mockFailNowTestingT{} NotPanics(t, func() { FailNow(mockT, "failed") }, "should call mockT.FailNow() rather than panicking") } func TestBytesEqual(t *testing.T) { var cases = []struct { a, b []byte }{ {make([]byte, 2), make([]byte, 2)}, {make([]byte, 2), make([]byte, 2, 3)}, {nil, make([]byte, 0)}, } for i, c := range cases { Equal(t, reflect.DeepEqual(c.a, c.b), ObjectsAreEqual(c.a, c.b), "case %d failed", i+1) } } func BenchmarkBytesEqual(b *testing.B) { const size = 1024 * 8 s := make([]byte, size) for i := range s { s[i] = byte(i % 255) } s2 := make([]byte, size) copy(s2, s) mockT := &mockFailNowTestingT{} b.ResetTimer() for i := 0; i < b.N; i++ { Equal(mockT, s, s2) } } func ExampleComparisonAssertionFunc() { t := &testing.T{} // provided by test adder := func(x, y int) int { return x + y } type args struct { x int y int } tests := []struct { name string args args expect int assertion ComparisonAssertionFunc }{ {"2+2=4", args{2, 2}, 4, Equal}, {"2+2!=5", args{2, 2}, 5, NotEqual}, {"2+3==5", args{2, 3}, 5, Exactly}, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { tt.assertion(t, tt.expect, adder(tt.args.x, tt.args.y)) }) } } func TestComparisonAssertionFunc(t *testing.T) { type iface interface { Name() string } tests := []struct { name string expect interface{} got interface{} assertion ComparisonAssertionFunc }{ {"implements", (*iface)(nil), t, Implements}, {"isType", (*testing.T)(nil), t, IsType}, {"equal", t, t, Equal}, {"equalValues", t, t, EqualValues}, {"exactly", t, t, Exactly}, {"notEqual", t, nil, NotEqual}, {"notContains", []int{1, 2, 3}, 4, NotContains}, {"subset", []int{1, 2, 3, 4}, []int{2, 3}, Subset}, {"notSubset", []int{1, 2, 3, 4}, []int{0, 3}, NotSubset}, {"elementsMatch", []byte("abc"), []byte("bac"), ElementsMatch}, {"regexp", "^t.*y$", "testify", Regexp}, {"notRegexp", "^t.*y$", "Testify", NotRegexp}, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { tt.assertion(t, tt.expect, tt.got) }) } } func ExampleValueAssertionFunc() { t := &testing.T{} // provided by test dumbParse := func(input string) interface{} { var x interface{} json.Unmarshal([]byte(input), &x) return x } tests := []struct { name string arg string assertion ValueAssertionFunc }{ {"true is not nil", "true", NotNil}, {"empty string is nil", "", Nil}, {"zero is not nil", "0", NotNil}, {"zero is zero", "0", Zero}, {"false is zero", "false", Zero}, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { tt.assertion(t, dumbParse(tt.arg)) }) } } func TestValueAssertionFunc(t *testing.T) { tests := []struct { name string value interface{} assertion ValueAssertionFunc }{ {"notNil", true, NotNil}, {"nil", nil, Nil}, {"empty", []int{}, Empty}, {"notEmpty", []int{1}, NotEmpty}, {"zero", false, Zero}, {"notZero", 42, NotZero}, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { tt.assertion(t, tt.value) }) } } func ExampleBoolAssertionFunc() { t := &testing.T{} // provided by test isOkay := func(x int) bool { return x >= 42 } tests := []struct { name string arg int assertion BoolAssertionFunc }{ {"-1 is bad", -1, False}, {"42 is good", 42, True}, {"41 is bad", 41, False}, {"45 is cool", 45, True}, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { tt.assertion(t, isOkay(tt.arg)) }) } } func TestBoolAssertionFunc(t *testing.T) { tests := []struct { name string value bool assertion BoolAssertionFunc }{ {"true", true, True}, {"false", false, False}, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { tt.assertion(t, tt.value) }) } } func ExampleErrorAssertionFunc() { t := &testing.T{} // provided by test dumbParseNum := func(input string, v interface{}) error { return json.Unmarshal([]byte(input), v) } tests := []struct { name string arg string assertion ErrorAssertionFunc }{ {"1.2 is number", "1.2", NoError}, {"1.2.3 not number", "1.2.3", Error}, {"true is not number", "true", Error}, {"3 is number", "3", NoError}, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { var x float64 tt.assertion(t, dumbParseNum(tt.arg, &x)) }) } } func TestErrorAssertionFunc(t *testing.T) { tests := []struct { name string err error assertion ErrorAssertionFunc }{ {"noError", nil, NoError}, {"error", errors.New("whoops"), Error}, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { tt.assertion(t, tt.err) }) } } func TestEventuallyFalse(t *testing.T) { mockT := new(testing.T) condition := func() bool { return false } False(t, Eventually(mockT, condition, 100*time.Millisecond, 20*time.Millisecond)) } func TestEventuallyTrue(t *testing.T) { state := 0 condition := func() bool { defer func() { state = state + 1 }() return state == 2 } True(t, Eventually(t, condition, 100*time.Millisecond, 20*time.Millisecond)) } func TestNeverFalse(t *testing.T) { condition := func() bool { return false } True(t, Never(t, condition, 100*time.Millisecond, 20*time.Millisecond)) } func TestNeverTrue(t *testing.T) { mockT := new(testing.T) state := 0 condition := func() bool { defer func() { state = state + 1 }() return state == 2 } False(t, Never(mockT, condition, 100*time.Millisecond, 20*time.Millisecond)) } func TestEventuallyIssue805(t *testing.T) { mockT := new(testing.T) NotPanics(t, func() { condition := func() bool { <-time.After(time.Millisecond); return true } False(t, Eventually(mockT, condition, time.Millisecond, time.Microsecond)) }) } func Test_validateEqualArgs(t *testing.T) { if validateEqualArgs(func() {}, func() {}) == nil { t.Error("non-nil functions should error") } if validateEqualArgs(func() {}, func() {}) == nil { t.Error("non-nil functions should error") } if validateEqualArgs(nil, nil) != nil { t.Error("nil functions are equal") } } go-jmespath-0.4.0/internal/testify/assert/doc.go000066400000000000000000000026151373124421700216410ustar00rootroot00000000000000// Package assert provides a set of comprehensive testing tools for use with the normal Go testing system. // // Example Usage // // The following is a complete example using assert in a standard test function: // import ( // "testing" // "github.com/jmespath/go-jmespath/internal/testify/assert" // ) // // func TestSomething(t *testing.T) { // // var a string = "Hello" // var b string = "Hello" // // assert.Equal(t, a, b, "The two words should be the same.") // // } // // if you assert many times, use the format below: // // import ( // "testing" // "github.com/jmespath/go-jmespath/internal/testify/assert" // ) // // func TestSomething(t *testing.T) { // assert := assert.New(t) // // var a string = "Hello" // var b string = "Hello" // // assert.Equal(a, b, "The two words should be the same.") // } // // Assertions // // Assertions allow you to easily write test code, and are global funcs in the `assert` package. // All assertion functions take, as the first argument, the `*testing.T` object provided by the // testing framework. This allows the assertion funcs to write the failings and other details to // the correct place. // // Every assertion function also takes an optional string message as the final argument, // allowing custom error messages to be appended to the message the assertion method outputs. package assert go-jmespath-0.4.0/internal/testify/assert/errors.go000066400000000000000000000005061373124421700224050ustar00rootroot00000000000000package assert import ( "errors" ) // AnError is an error instance useful for testing. If the code does not care // about error specifics, and only needs to return the error for example, this // error should be used to make the test code more readable. var AnError = errors.New("assert.AnError general error for testing") go-jmespath-0.4.0/internal/testify/assert/forward_assertions.go000066400000000000000000000006541373124421700250130ustar00rootroot00000000000000package assert // Assertions provides assertion methods around the // TestingT interface. type Assertions struct { t TestingT } // New makes a new Assertions object for the specified TestingT. func New(t TestingT) *Assertions { return &Assertions{ t: t, } } //go:generate sh -c "cd ../_codegen && go build && cd - && ../_codegen/_codegen -output-package=assert -template=assertion_forward.go.tmpl -include-format-funcs" go-jmespath-0.4.0/internal/testify/assert/forward_assertions_test.go000066400000000000000000000464021373124421700260530ustar00rootroot00000000000000package assert import ( "errors" "regexp" "testing" "time" ) func TestImplementsWrapper(t *testing.T) { assert := New(new(testing.T)) if !assert.Implements((*AssertionTesterInterface)(nil), new(AssertionTesterConformingObject)) { t.Error("Implements method should return true: AssertionTesterConformingObject implements AssertionTesterInterface") } if assert.Implements((*AssertionTesterInterface)(nil), new(AssertionTesterNonConformingObject)) { t.Error("Implements method should return false: AssertionTesterNonConformingObject does not implements AssertionTesterInterface") } } func TestIsTypeWrapper(t *testing.T) { assert := New(new(testing.T)) if !assert.IsType(new(AssertionTesterConformingObject), new(AssertionTesterConformingObject)) { t.Error("IsType should return true: AssertionTesterConformingObject is the same type as AssertionTesterConformingObject") } if assert.IsType(new(AssertionTesterConformingObject), new(AssertionTesterNonConformingObject)) { t.Error("IsType should return false: AssertionTesterConformingObject is not the same type as AssertionTesterNonConformingObject") } } func TestEqualWrapper(t *testing.T) { assert := New(new(testing.T)) if !assert.Equal("Hello World", "Hello World") { t.Error("Equal should return true") } if !assert.Equal(123, 123) { t.Error("Equal should return true") } if !assert.Equal(123.5, 123.5) { t.Error("Equal should return true") } if !assert.Equal([]byte("Hello World"), []byte("Hello World")) { t.Error("Equal should return true") } if !assert.Equal(nil, nil) { t.Error("Equal should return true") } } func TestEqualValuesWrapper(t *testing.T) { assert := New(new(testing.T)) if !assert.EqualValues(uint32(10), int32(10)) { t.Error("EqualValues should return true") } } func TestNotNilWrapper(t *testing.T) { assert := New(new(testing.T)) if !assert.NotNil(new(AssertionTesterConformingObject)) { t.Error("NotNil should return true: object is not nil") } if assert.NotNil(nil) { t.Error("NotNil should return false: object is nil") } } func TestNilWrapper(t *testing.T) { assert := New(new(testing.T)) if !assert.Nil(nil) { t.Error("Nil should return true: object is nil") } if assert.Nil(new(AssertionTesterConformingObject)) { t.Error("Nil should return false: object is not nil") } } func TestTrueWrapper(t *testing.T) { assert := New(new(testing.T)) if !assert.True(true) { t.Error("True should return true") } if assert.True(false) { t.Error("True should return false") } } func TestFalseWrapper(t *testing.T) { assert := New(new(testing.T)) if !assert.False(false) { t.Error("False should return true") } if assert.False(true) { t.Error("False should return false") } } func TestExactlyWrapper(t *testing.T) { assert := New(new(testing.T)) a := float32(1) b := float64(1) c := float32(1) d := float32(2) if assert.Exactly(a, b) { t.Error("Exactly should return false") } if assert.Exactly(a, d) { t.Error("Exactly should return false") } if !assert.Exactly(a, c) { t.Error("Exactly should return true") } if assert.Exactly(nil, a) { t.Error("Exactly should return false") } if assert.Exactly(a, nil) { t.Error("Exactly should return false") } } func TestNotEqualWrapper(t *testing.T) { assert := New(new(testing.T)) if !assert.NotEqual("Hello World", "Hello World!") { t.Error("NotEqual should return true") } if !assert.NotEqual(123, 1234) { t.Error("NotEqual should return true") } if !assert.NotEqual(123.5, 123.55) { t.Error("NotEqual should return true") } if !assert.NotEqual([]byte("Hello World"), []byte("Hello World!")) { t.Error("NotEqual should return true") } if !assert.NotEqual(nil, new(AssertionTesterConformingObject)) { t.Error("NotEqual should return true") } } func TestContainsWrapper(t *testing.T) { assert := New(new(testing.T)) list := []string{"Foo", "Bar"} if !assert.Contains("Hello World", "Hello") { t.Error("Contains should return true: \"Hello World\" contains \"Hello\"") } if assert.Contains("Hello World", "Salut") { t.Error("Contains should return false: \"Hello World\" does not contain \"Salut\"") } if !assert.Contains(list, "Foo") { t.Error("Contains should return true: \"[\"Foo\", \"Bar\"]\" contains \"Foo\"") } if assert.Contains(list, "Salut") { t.Error("Contains should return false: \"[\"Foo\", \"Bar\"]\" does not contain \"Salut\"") } } func TestNotContainsWrapper(t *testing.T) { assert := New(new(testing.T)) list := []string{"Foo", "Bar"} if !assert.NotContains("Hello World", "Hello!") { t.Error("NotContains should return true: \"Hello World\" does not contain \"Hello!\"") } if assert.NotContains("Hello World", "Hello") { t.Error("NotContains should return false: \"Hello World\" contains \"Hello\"") } if !assert.NotContains(list, "Foo!") { t.Error("NotContains should return true: \"[\"Foo\", \"Bar\"]\" does not contain \"Foo!\"") } if assert.NotContains(list, "Foo") { t.Error("NotContains should return false: \"[\"Foo\", \"Bar\"]\" contains \"Foo\"") } } func TestConditionWrapper(t *testing.T) { assert := New(new(testing.T)) if !assert.Condition(func() bool { return true }, "Truth") { t.Error("Condition should return true") } if assert.Condition(func() bool { return false }, "Lie") { t.Error("Condition should return false") } } func TestDidPanicWrapper(t *testing.T) { if funcDidPanic, _, _ := didPanic(func() { panic("Panic!") }); !funcDidPanic { t.Error("didPanic should return true") } if funcDidPanic, _, _ := didPanic(func() { }); funcDidPanic { t.Error("didPanic should return false") } } func TestPanicsWrapper(t *testing.T) { assert := New(new(testing.T)) if !assert.Panics(func() { panic("Panic!") }) { t.Error("Panics should return true") } if assert.Panics(func() { }) { t.Error("Panics should return false") } } func TestNotPanicsWrapper(t *testing.T) { assert := New(new(testing.T)) if !assert.NotPanics(func() { }) { t.Error("NotPanics should return true") } if assert.NotPanics(func() { panic("Panic!") }) { t.Error("NotPanics should return false") } } func TestNoErrorWrapper(t *testing.T) { assert := New(t) mockAssert := New(new(testing.T)) // start with a nil error var err error assert.True(mockAssert.NoError(err), "NoError should return True for nil arg") // now set an error err = errors.New("Some error") assert.False(mockAssert.NoError(err), "NoError with error should return False") } func TestErrorWrapper(t *testing.T) { assert := New(t) mockAssert := New(new(testing.T)) // start with a nil error var err error assert.False(mockAssert.Error(err), "Error should return False for nil arg") // now set an error err = errors.New("Some error") assert.True(mockAssert.Error(err), "Error with error should return True") } func TestEqualErrorWrapper(t *testing.T) { assert := New(t) mockAssert := New(new(testing.T)) // start with a nil error var err error assert.False(mockAssert.EqualError(err, ""), "EqualError should return false for nil arg") // now set an error err = errors.New("some error") assert.False(mockAssert.EqualError(err, "Not some error"), "EqualError should return false for different error string") assert.True(mockAssert.EqualError(err, "some error"), "EqualError should return true") } func TestEmptyWrapper(t *testing.T) { assert := New(t) mockAssert := New(new(testing.T)) assert.True(mockAssert.Empty(""), "Empty string is empty") assert.True(mockAssert.Empty(nil), "Nil is empty") assert.True(mockAssert.Empty([]string{}), "Empty string array is empty") assert.True(mockAssert.Empty(0), "Zero int value is empty") assert.True(mockAssert.Empty(false), "False value is empty") assert.False(mockAssert.Empty("something"), "Non Empty string is not empty") assert.False(mockAssert.Empty(errors.New("something")), "Non nil object is not empty") assert.False(mockAssert.Empty([]string{"something"}), "Non empty string array is not empty") assert.False(mockAssert.Empty(1), "Non-zero int value is not empty") assert.False(mockAssert.Empty(true), "True value is not empty") } func TestNotEmptyWrapper(t *testing.T) { assert := New(t) mockAssert := New(new(testing.T)) assert.False(mockAssert.NotEmpty(""), "Empty string is empty") assert.False(mockAssert.NotEmpty(nil), "Nil is empty") assert.False(mockAssert.NotEmpty([]string{}), "Empty string array is empty") assert.False(mockAssert.NotEmpty(0), "Zero int value is empty") assert.False(mockAssert.NotEmpty(false), "False value is empty") assert.True(mockAssert.NotEmpty("something"), "Non Empty string is not empty") assert.True(mockAssert.NotEmpty(errors.New("something")), "Non nil object is not empty") assert.True(mockAssert.NotEmpty([]string{"something"}), "Non empty string array is not empty") assert.True(mockAssert.NotEmpty(1), "Non-zero int value is not empty") assert.True(mockAssert.NotEmpty(true), "True value is not empty") } func TestLenWrapper(t *testing.T) { assert := New(t) mockAssert := New(new(testing.T)) assert.False(mockAssert.Len(nil, 0), "nil does not have length") assert.False(mockAssert.Len(0, 0), "int does not have length") assert.False(mockAssert.Len(true, 0), "true does not have length") assert.False(mockAssert.Len(false, 0), "false does not have length") assert.False(mockAssert.Len('A', 0), "Rune does not have length") assert.False(mockAssert.Len(struct{}{}, 0), "Struct does not have length") ch := make(chan int, 5) ch <- 1 ch <- 2 ch <- 3 cases := []struct { v interface{} l int }{ {[]int{1, 2, 3}, 3}, {[...]int{1, 2, 3}, 3}, {"ABC", 3}, {map[int]int{1: 2, 2: 4, 3: 6}, 3}, {ch, 3}, {[]int{}, 0}, {map[int]int{}, 0}, {make(chan int), 0}, {[]int(nil), 0}, {map[int]int(nil), 0}, {(chan int)(nil), 0}, } for _, c := range cases { assert.True(mockAssert.Len(c.v, c.l), "%#v have %d items", c.v, c.l) } } func TestWithinDurationWrapper(t *testing.T) { assert := New(t) mockAssert := New(new(testing.T)) a := time.Now() b := a.Add(10 * time.Second) assert.True(mockAssert.WithinDuration(a, b, 10*time.Second), "A 10s difference is within a 10s time difference") assert.True(mockAssert.WithinDuration(b, a, 10*time.Second), "A 10s difference is within a 10s time difference") assert.False(mockAssert.WithinDuration(a, b, 9*time.Second), "A 10s difference is not within a 9s time difference") assert.False(mockAssert.WithinDuration(b, a, 9*time.Second), "A 10s difference is not within a 9s time difference") assert.False(mockAssert.WithinDuration(a, b, -9*time.Second), "A 10s difference is not within a 9s time difference") assert.False(mockAssert.WithinDuration(b, a, -9*time.Second), "A 10s difference is not within a 9s time difference") assert.False(mockAssert.WithinDuration(a, b, -11*time.Second), "A 10s difference is not within a 9s time difference") assert.False(mockAssert.WithinDuration(b, a, -11*time.Second), "A 10s difference is not within a 9s time difference") } func TestInDeltaWrapper(t *testing.T) { assert := New(new(testing.T)) True(t, assert.InDelta(1.001, 1, 0.01), "|1.001 - 1| <= 0.01") True(t, assert.InDelta(1, 1.001, 0.01), "|1 - 1.001| <= 0.01") True(t, assert.InDelta(1, 2, 1), "|1 - 2| <= 1") False(t, assert.InDelta(1, 2, 0.5), "Expected |1 - 2| <= 0.5 to fail") False(t, assert.InDelta(2, 1, 0.5), "Expected |2 - 1| <= 0.5 to fail") False(t, assert.InDelta("", nil, 1), "Expected non numerals to fail") cases := []struct { a, b interface{} delta float64 }{ {uint8(2), uint8(1), 1}, {uint16(2), uint16(1), 1}, {uint32(2), uint32(1), 1}, {uint64(2), uint64(1), 1}, {int(2), int(1), 1}, {int8(2), int8(1), 1}, {int16(2), int16(1), 1}, {int32(2), int32(1), 1}, {int64(2), int64(1), 1}, {float32(2), float32(1), 1}, {float64(2), float64(1), 1}, } for _, tc := range cases { True(t, assert.InDelta(tc.a, tc.b, tc.delta), "Expected |%V - %V| <= %v", tc.a, tc.b, tc.delta) } } func TestInEpsilonWrapper(t *testing.T) { assert := New(new(testing.T)) cases := []struct { a, b interface{} epsilon float64 }{ {uint8(2), uint16(2), .001}, {2.1, 2.2, 0.1}, {2.2, 2.1, 0.1}, {-2.1, -2.2, 0.1}, {-2.2, -2.1, 0.1}, {uint64(100), uint8(101), 0.01}, {0.1, -0.1, 2}, } for _, tc := range cases { True(t, assert.InEpsilon(tc.a, tc.b, tc.epsilon, "Expected %V and %V to have a relative difference of %v", tc.a, tc.b, tc.epsilon)) } cases = []struct { a, b interface{} epsilon float64 }{ {uint8(2), int16(-2), .001}, {uint64(100), uint8(102), 0.01}, {2.1, 2.2, 0.001}, {2.2, 2.1, 0.001}, {2.1, -2.2, 1}, {2.1, "bla-bla", 0}, {0.1, -0.1, 1.99}, } for _, tc := range cases { False(t, assert.InEpsilon(tc.a, tc.b, tc.epsilon, "Expected %V and %V to have a relative difference of %v", tc.a, tc.b, tc.epsilon)) } } func TestRegexpWrapper(t *testing.T) { assert := New(new(testing.T)) cases := []struct { rx, str string }{ {"^start", "start of the line"}, {"end$", "in the end"}, {"[0-9]{3}[.-]?[0-9]{2}[.-]?[0-9]{2}", "My phone number is 650.12.34"}, } for _, tc := range cases { True(t, assert.Regexp(tc.rx, tc.str)) True(t, assert.Regexp(regexp.MustCompile(tc.rx), tc.str)) False(t, assert.NotRegexp(tc.rx, tc.str)) False(t, assert.NotRegexp(regexp.MustCompile(tc.rx), tc.str)) } cases = []struct { rx, str string }{ {"^asdfastart", "Not the start of the line"}, {"end$", "in the end."}, {"[0-9]{3}[.-]?[0-9]{2}[.-]?[0-9]{2}", "My phone number is 650.12a.34"}, } for _, tc := range cases { False(t, assert.Regexp(tc.rx, tc.str), "Expected \"%s\" to not match \"%s\"", tc.rx, tc.str) False(t, assert.Regexp(regexp.MustCompile(tc.rx), tc.str)) True(t, assert.NotRegexp(tc.rx, tc.str)) True(t, assert.NotRegexp(regexp.MustCompile(tc.rx), tc.str)) } } func TestZeroWrapper(t *testing.T) { assert := New(t) mockAssert := New(new(testing.T)) for _, test := range zeros { assert.True(mockAssert.Zero(test), "Zero should return true for %v", test) } for _, test := range nonZeros { assert.False(mockAssert.Zero(test), "Zero should return false for %v", test) } } func TestNotZeroWrapper(t *testing.T) { assert := New(t) mockAssert := New(new(testing.T)) for _, test := range zeros { assert.False(mockAssert.NotZero(test), "Zero should return true for %v", test) } for _, test := range nonZeros { assert.True(mockAssert.NotZero(test), "Zero should return false for %v", test) } } func TestJSONEqWrapper_EqualSONString(t *testing.T) { assert := New(new(testing.T)) if !assert.JSONEq(`{"hello": "world", "foo": "bar"}`, `{"hello": "world", "foo": "bar"}`) { t.Error("JSONEq should return true") } } func TestJSONEqWrapper_EquivalentButNotEqual(t *testing.T) { assert := New(new(testing.T)) if !assert.JSONEq(`{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`) { t.Error("JSONEq should return true") } } func TestJSONEqWrapper_HashOfArraysAndHashes(t *testing.T) { assert := New(new(testing.T)) if !assert.JSONEq("{\r\n\t\"numeric\": 1.5,\r\n\t\"array\": [{\"foo\": \"bar\"}, 1, \"string\", [\"nested\", \"array\", 5.5]],\r\n\t\"hash\": {\"nested\": \"hash\", \"nested_slice\": [\"this\", \"is\", \"nested\"]},\r\n\t\"string\": \"foo\"\r\n}", "{\r\n\t\"numeric\": 1.5,\r\n\t\"hash\": {\"nested\": \"hash\", \"nested_slice\": [\"this\", \"is\", \"nested\"]},\r\n\t\"string\": \"foo\",\r\n\t\"array\": [{\"foo\": \"bar\"}, 1, \"string\", [\"nested\", \"array\", 5.5]]\r\n}") { t.Error("JSONEq should return true") } } func TestJSONEqWrapper_Array(t *testing.T) { assert := New(new(testing.T)) if !assert.JSONEq(`["foo", {"hello": "world", "nested": "hash"}]`, `["foo", {"nested": "hash", "hello": "world"}]`) { t.Error("JSONEq should return true") } } func TestJSONEqWrapper_HashAndArrayNotEquivalent(t *testing.T) { assert := New(new(testing.T)) if assert.JSONEq(`["foo", {"hello": "world", "nested": "hash"}]`, `{"foo": "bar", {"nested": "hash", "hello": "world"}}`) { t.Error("JSONEq should return false") } } func TestJSONEqWrapper_HashesNotEquivalent(t *testing.T) { assert := New(new(testing.T)) if assert.JSONEq(`{"foo": "bar"}`, `{"foo": "bar", "hello": "world"}`) { t.Error("JSONEq should return false") } } func TestJSONEqWrapper_ActualIsNotJSON(t *testing.T) { assert := New(new(testing.T)) if assert.JSONEq(`{"foo": "bar"}`, "Not JSON") { t.Error("JSONEq should return false") } } func TestJSONEqWrapper_ExpectedIsNotJSON(t *testing.T) { assert := New(new(testing.T)) if assert.JSONEq("Not JSON", `{"foo": "bar", "hello": "world"}`) { t.Error("JSONEq should return false") } } func TestJSONEqWrapper_ExpectedAndActualNotJSON(t *testing.T) { assert := New(new(testing.T)) if assert.JSONEq("Not JSON", "Not JSON") { t.Error("JSONEq should return false") } } func TestJSONEqWrapper_ArraysOfDifferentOrder(t *testing.T) { assert := New(new(testing.T)) if assert.JSONEq(`["foo", {"hello": "world", "nested": "hash"}]`, `[{ "hello": "world", "nested": "hash"}, "foo"]`) { t.Error("JSONEq should return false") } } func TestYAMLEqWrapper_EqualYAMLString(t *testing.T) { assert := New(new(testing.T)) if !assert.YAMLEq(`{"hello": "world", "foo": "bar"}`, `{"hello": "world", "foo": "bar"}`) { t.Error("YAMLEq should return true") } } func TestYAMLEqWrapper_EquivalentButNotEqual(t *testing.T) { assert := New(new(testing.T)) if !assert.YAMLEq(`{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`) { t.Error("YAMLEq should return true") } } func TestYAMLEqWrapper_HashOfArraysAndHashes(t *testing.T) { assert := New(new(testing.T)) expected := ` numeric: 1.5 array: - foo: bar - 1 - "string" - ["nested", "array", 5.5] hash: nested: hash nested_slice: [this, is, nested] string: "foo" ` actual := ` numeric: 1.5 hash: nested: hash nested_slice: [this, is, nested] string: "foo" array: - foo: bar - 1 - "string" - ["nested", "array", 5.5] ` if !assert.YAMLEq(expected, actual) { t.Error("YAMLEq should return true") } } func TestYAMLEqWrapper_Array(t *testing.T) { assert := New(new(testing.T)) if !assert.YAMLEq(`["foo", {"hello": "world", "nested": "hash"}]`, `["foo", {"nested": "hash", "hello": "world"}]`) { t.Error("YAMLEq should return true") } } func TestYAMLEqWrapper_HashAndArrayNotEquivalent(t *testing.T) { assert := New(new(testing.T)) if assert.YAMLEq(`["foo", {"hello": "world", "nested": "hash"}]`, `{"foo": "bar", {"nested": "hash", "hello": "world"}}`) { t.Error("YAMLEq should return false") } } func TestYAMLEqWrapper_HashesNotEquivalent(t *testing.T) { assert := New(new(testing.T)) if assert.YAMLEq(`{"foo": "bar"}`, `{"foo": "bar", "hello": "world"}`) { t.Error("YAMLEq should return false") } } func TestYAMLEqWrapper_ActualIsSimpleString(t *testing.T) { assert := New(new(testing.T)) if assert.YAMLEq(`{"foo": "bar"}`, "Simple String") { t.Error("YAMLEq should return false") } } func TestYAMLEqWrapper_ExpectedIsSimpleString(t *testing.T) { assert := New(new(testing.T)) if assert.YAMLEq("Simple String", `{"foo": "bar", "hello": "world"}`) { t.Error("YAMLEq should return false") } } func TestYAMLEqWrapper_ExpectedAndActualSimpleString(t *testing.T) { assert := New(new(testing.T)) if !assert.YAMLEq("Simple String", "Simple String") { t.Error("YAMLEq should return true") } } func TestYAMLEqWrapper_ArraysOfDifferentOrder(t *testing.T) { assert := New(new(testing.T)) if assert.YAMLEq(`["foo", {"hello": "world", "nested": "hash"}]`, `[{ "hello": "world", "nested": "hash"}, "foo"]`) { t.Error("YAMLEq should return false") } } go-jmespath-0.4.0/internal/testify/assert/http_assertions.go000066400000000000000000000113221373124421700243200ustar00rootroot00000000000000package assert import ( "fmt" "net/http" "net/http/httptest" "net/url" "strings" ) // httpCode is a helper that returns HTTP code of the response. It returns -1 and // an error if building a new request fails. func httpCode(handler http.HandlerFunc, method, url string, values url.Values) (int, error) { w := httptest.NewRecorder() req, err := http.NewRequest(method, url, nil) if err != nil { return -1, err } req.URL.RawQuery = values.Encode() handler(w, req) return w.Code, nil } // HTTPSuccess asserts that a specified handler returns a success status code. // // assert.HTTPSuccess(t, myHandler, "POST", "http://www.google.com", nil) // // Returns whether the assertion was successful (true) or not (false). func HTTPSuccess(t TestingT, handler http.HandlerFunc, method, url string, values url.Values, msgAndArgs ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() } code, err := httpCode(handler, method, url, values) if err != nil { Fail(t, fmt.Sprintf("Failed to build test request, got error: %s", err)) return false } isSuccessCode := code >= http.StatusOK && code <= http.StatusPartialContent if !isSuccessCode { Fail(t, fmt.Sprintf("Expected HTTP success status code for %q but received %d", url+"?"+values.Encode(), code)) } return isSuccessCode } // HTTPRedirect asserts that a specified handler returns a redirect status code. // // assert.HTTPRedirect(t, myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}} // // Returns whether the assertion was successful (true) or not (false). func HTTPRedirect(t TestingT, handler http.HandlerFunc, method, url string, values url.Values, msgAndArgs ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() } code, err := httpCode(handler, method, url, values) if err != nil { Fail(t, fmt.Sprintf("Failed to build test request, got error: %s", err)) return false } isRedirectCode := code >= http.StatusMultipleChoices && code <= http.StatusTemporaryRedirect if !isRedirectCode { Fail(t, fmt.Sprintf("Expected HTTP redirect status code for %q but received %d", url+"?"+values.Encode(), code)) } return isRedirectCode } // HTTPError asserts that a specified handler returns an error status code. // // assert.HTTPError(t, myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}} // // Returns whether the assertion was successful (true) or not (false). func HTTPError(t TestingT, handler http.HandlerFunc, method, url string, values url.Values, msgAndArgs ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() } code, err := httpCode(handler, method, url, values) if err != nil { Fail(t, fmt.Sprintf("Failed to build test request, got error: %s", err)) return false } isErrorCode := code >= http.StatusBadRequest if !isErrorCode { Fail(t, fmt.Sprintf("Expected HTTP error status code for %q but received %d", url+"?"+values.Encode(), code)) } return isErrorCode } // HTTPBody is a helper that returns HTTP body of the response. It returns // empty string if building a new request fails. func HTTPBody(handler http.HandlerFunc, method, url string, values url.Values) string { w := httptest.NewRecorder() req, err := http.NewRequest(method, url+"?"+values.Encode(), nil) if err != nil { return "" } handler(w, req) return w.Body.String() } // HTTPBodyContains asserts that a specified handler returns a // body that contains a string. // // assert.HTTPBodyContains(t, myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky") // // Returns whether the assertion was successful (true) or not (false). func HTTPBodyContains(t TestingT, handler http.HandlerFunc, method, url string, values url.Values, str interface{}, msgAndArgs ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() } body := HTTPBody(handler, method, url, values) contains := strings.Contains(body, fmt.Sprint(str)) if !contains { Fail(t, fmt.Sprintf("Expected response body for \"%s\" to contain \"%s\" but found \"%s\"", url+"?"+values.Encode(), str, body)) } return contains } // HTTPBodyNotContains asserts that a specified handler returns a // body that does not contain a string. // // assert.HTTPBodyNotContains(t, myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky") // // Returns whether the assertion was successful (true) or not (false). func HTTPBodyNotContains(t TestingT, handler http.HandlerFunc, method, url string, values url.Values, str interface{}, msgAndArgs ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() } body := HTTPBody(handler, method, url, values) contains := strings.Contains(body, fmt.Sprint(str)) if contains { Fail(t, fmt.Sprintf("Expected response body for \"%s\" to NOT contain \"%s\" but found \"%s\"", url+"?"+values.Encode(), str, body)) } return !contains } go-jmespath-0.4.0/internal/testify/assert/http_assertions_test.go000066400000000000000000000115211373124421700253600ustar00rootroot00000000000000package assert import ( "fmt" "net/http" "net/url" "testing" ) func httpOK(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusOK) } func httpRedirect(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusTemporaryRedirect) } func httpError(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusInternalServerError) } func TestHTTPSuccess(t *testing.T) { assert := New(t) mockT1 := new(testing.T) assert.Equal(HTTPSuccess(mockT1, httpOK, "GET", "/", nil), true) assert.False(mockT1.Failed()) mockT2 := new(testing.T) assert.Equal(HTTPSuccess(mockT2, httpRedirect, "GET", "/", nil), false) assert.True(mockT2.Failed()) mockT3 := new(testing.T) assert.Equal(HTTPSuccess(mockT3, httpError, "GET", "/", nil), false) assert.True(mockT3.Failed()) } func TestHTTPRedirect(t *testing.T) { assert := New(t) mockT1 := new(testing.T) assert.Equal(HTTPRedirect(mockT1, httpOK, "GET", "/", nil), false) assert.True(mockT1.Failed()) mockT2 := new(testing.T) assert.Equal(HTTPRedirect(mockT2, httpRedirect, "GET", "/", nil), true) assert.False(mockT2.Failed()) mockT3 := new(testing.T) assert.Equal(HTTPRedirect(mockT3, httpError, "GET", "/", nil), false) assert.True(mockT3.Failed()) } func TestHTTPError(t *testing.T) { assert := New(t) mockT1 := new(testing.T) assert.Equal(HTTPError(mockT1, httpOK, "GET", "/", nil), false) assert.True(mockT1.Failed()) mockT2 := new(testing.T) assert.Equal(HTTPError(mockT2, httpRedirect, "GET", "/", nil), false) assert.True(mockT2.Failed()) mockT3 := new(testing.T) assert.Equal(HTTPError(mockT3, httpError, "GET", "/", nil), true) assert.False(mockT3.Failed()) } func TestHTTPStatusesWrapper(t *testing.T) { assert := New(t) mockAssert := New(new(testing.T)) assert.Equal(mockAssert.HTTPSuccess(httpOK, "GET", "/", nil), true) assert.Equal(mockAssert.HTTPSuccess(httpRedirect, "GET", "/", nil), false) assert.Equal(mockAssert.HTTPSuccess(httpError, "GET", "/", nil), false) assert.Equal(mockAssert.HTTPRedirect(httpOK, "GET", "/", nil), false) assert.Equal(mockAssert.HTTPRedirect(httpRedirect, "GET", "/", nil), true) assert.Equal(mockAssert.HTTPRedirect(httpError, "GET", "/", nil), false) assert.Equal(mockAssert.HTTPError(httpOK, "GET", "/", nil), false) assert.Equal(mockAssert.HTTPError(httpRedirect, "GET", "/", nil), false) assert.Equal(mockAssert.HTTPError(httpError, "GET", "/", nil), true) } func httpHelloName(w http.ResponseWriter, r *http.Request) { name := r.FormValue("name") w.Write([]byte(fmt.Sprintf("Hello, %s!", name))) } func TestHTTPRequestWithNoParams(t *testing.T) { var got *http.Request handler := func(w http.ResponseWriter, r *http.Request) { got = r w.WriteHeader(http.StatusOK) } True(t, HTTPSuccess(t, handler, "GET", "/url", nil)) Empty(t, got.URL.Query()) Equal(t, "/url", got.URL.RequestURI()) } func TestHTTPRequestWithParams(t *testing.T) { var got *http.Request handler := func(w http.ResponseWriter, r *http.Request) { got = r w.WriteHeader(http.StatusOK) } params := url.Values{} params.Add("id", "12345") True(t, HTTPSuccess(t, handler, "GET", "/url", params)) Equal(t, url.Values{"id": []string{"12345"}}, got.URL.Query()) Equal(t, "/url?id=12345", got.URL.String()) Equal(t, "/url?id=12345", got.URL.RequestURI()) } func TestHttpBody(t *testing.T) { assert := New(t) mockT := new(testing.T) assert.True(HTTPBodyContains(mockT, httpHelloName, "GET", "/", url.Values{"name": []string{"World"}}, "Hello, World!")) assert.True(HTTPBodyContains(mockT, httpHelloName, "GET", "/", url.Values{"name": []string{"World"}}, "World")) assert.False(HTTPBodyContains(mockT, httpHelloName, "GET", "/", url.Values{"name": []string{"World"}}, "world")) assert.False(HTTPBodyNotContains(mockT, httpHelloName, "GET", "/", url.Values{"name": []string{"World"}}, "Hello, World!")) assert.False(HTTPBodyNotContains(mockT, httpHelloName, "GET", "/", url.Values{"name": []string{"World"}}, "World")) assert.True(HTTPBodyNotContains(mockT, httpHelloName, "GET", "/", url.Values{"name": []string{"World"}}, "world")) } func TestHttpBodyWrappers(t *testing.T) { assert := New(t) mockAssert := New(new(testing.T)) assert.True(mockAssert.HTTPBodyContains(httpHelloName, "GET", "/", url.Values{"name": []string{"World"}}, "Hello, World!")) assert.True(mockAssert.HTTPBodyContains(httpHelloName, "GET", "/", url.Values{"name": []string{"World"}}, "World")) assert.False(mockAssert.HTTPBodyContains(httpHelloName, "GET", "/", url.Values{"name": []string{"World"}}, "world")) assert.False(mockAssert.HTTPBodyNotContains(httpHelloName, "GET", "/", url.Values{"name": []string{"World"}}, "Hello, World!")) assert.False(mockAssert.HTTPBodyNotContains(httpHelloName, "GET", "/", url.Values{"name": []string{"World"}}, "World")) assert.True(mockAssert.HTTPBodyNotContains(httpHelloName, "GET", "/", url.Values{"name": []string{"World"}}, "world")) } go-jmespath-0.4.0/internal/testify/doc.go000066400000000000000000000017531373124421700203420ustar00rootroot00000000000000// Package testify is a set of packages that provide many tools for testifying that your code will behave as you intend. // // testify contains the following packages: // // The assert package provides a comprehensive set of assertion functions that tie in to the Go testing system. // // The http package contains tools to make it easier to test http activity using the Go testing system. // // The mock package provides a system by which it is possible to mock your objects and verify calls are happening as expected. // // The suite package provides a basic structure for using structs as testing suites, and methods on those structs as tests. It includes setup/teardown functionality in the way of interfaces. package testify // blank imports help docs. import ( // assert package _ "github.com/jmespath/go-jmespath/internal/testify/assert" // http package _ "github.com/jmespath/go-jmespath/internal/testify/http" // mock package _ "github.com/jmespath/go-jmespath/internal/testify/mock" ) go-jmespath-0.4.0/internal/testify/go.mod000066400000000000000000000003211373124421700203420ustar00rootroot00000000000000module github.com/jmespath/go-jmespath/internal/testify require ( github.com/davecgh/go-spew v1.1.0 github.com/pmezard/go-difflib v1.0.0 github.com/stretchr/objx v0.1.0 gopkg.in/yaml.v2 v2.2.8 ) go 1.13 go-jmespath-0.4.0/internal/testify/go.sum000066400000000000000000000017571373124421700204050ustar00rootroot00000000000000github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= github.com/stretchr/objx v0.1.0 h1:4G4v2dO3VZwixGIRoQ5Lfboy6nUhCyYzaqnIAPPhYs4= github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= gopkg.in/yaml.v2 v2.2.2 h1:ZCJp+EgiOT7lHqUV2J862kp8Qj64Jo6az82+3Td9dZw= gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= gopkg.in/yaml.v2 v2.2.8 h1:obN1ZagJSUGI0Ek/LBmuj4SNLPfIny3KsKFopxRdj10= gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= go-jmespath-0.4.0/internal/testify/http/000077500000000000000000000000001373124421700202175ustar00rootroot00000000000000go-jmespath-0.4.0/internal/testify/http/doc.go000066400000000000000000000000761373124421700213160ustar00rootroot00000000000000// Package http DEPRECATED USE net/http/httptest package http go-jmespath-0.4.0/internal/testify/http/test_response_writer.go000066400000000000000000000023071373124421700250410ustar00rootroot00000000000000package http import ( "net/http" ) // TestResponseWriter DEPRECATED: We recommend you use http://golang.org/pkg/net/http/httptest instead. type TestResponseWriter struct { // StatusCode is the last int written by the call to WriteHeader(int) StatusCode int // Output is a string containing the written bytes using the Write([]byte) func. Output string // header is the internal storage of the http.Header object header http.Header } // Header DEPRECATED: We recommend you use http://golang.org/pkg/net/http/httptest instead. func (rw *TestResponseWriter) Header() http.Header { if rw.header == nil { rw.header = make(http.Header) } return rw.header } // Write DEPRECATED: We recommend you use http://golang.org/pkg/net/http/httptest instead. func (rw *TestResponseWriter) Write(bytes []byte) (int, error) { // assume 200 success if no header has been set if rw.StatusCode == 0 { rw.WriteHeader(200) } // add these bytes to the output string rw.Output = rw.Output + string(bytes) // return normal values return 0, nil } // WriteHeader DEPRECATED: We recommend you use http://golang.org/pkg/net/http/httptest instead. func (rw *TestResponseWriter) WriteHeader(i int) { rw.StatusCode = i } go-jmespath-0.4.0/internal/testify/http/test_round_tripper.go000066400000000000000000000006161373124421700245040ustar00rootroot00000000000000package http import ( "github.com/jmespath/go-jmespath/internal/testify/mock" "net/http" ) // TestRoundTripper DEPRECATED USE net/http/httptest type TestRoundTripper struct { mock.Mock } // RoundTrip DEPRECATED USE net/http/httptest func (t *TestRoundTripper) RoundTrip(req *http.Request) (*http.Response, error) { args := t.Called(req) return args.Get(0).(*http.Response), args.Error(1) } go-jmespath-0.4.0/internal/testify/mock/000077500000000000000000000000001373124421700201715ustar00rootroot00000000000000go-jmespath-0.4.0/internal/testify/mock/doc.go000066400000000000000000000030751373124421700212720ustar00rootroot00000000000000// Package mock provides a system by which it is possible to mock your objects // and verify calls are happening as expected. // // Example Usage // // The mock package provides an object, Mock, that tracks activity on another object. It is usually // embedded into a test object as shown below: // // type MyTestObject struct { // // add a Mock object instance // mock.Mock // // // other fields go here as normal // } // // When implementing the methods of an interface, you wire your functions up // to call the Mock.Called(args...) method, and return the appropriate values. // // For example, to mock a method that saves the name and age of a person and returns // the year of their birth or an error, you might write this: // // func (o *MyTestObject) SavePersonDetails(firstname, lastname string, age int) (int, error) { // args := o.Called(firstname, lastname, age) // return args.Int(0), args.Error(1) // } // // The Int, Error and Bool methods are examples of strongly typed getters that take the argument // index position. Given this argument list: // // (12, true, "Something") // // You could read them out strongly typed like this: // // args.Int(0) // args.Bool(1) // args.String(2) // // For objects of your own type, use the generic Arguments.Get(index) method and make a type assertion: // // return args.Get(0).(*MyObject), args.Get(1).(*AnotherObjectOfMine) // // This may cause a panic if the object you are getting is nil (the type assertion will fail), in those // cases you should check for nil first. package mock go-jmespath-0.4.0/internal/testify/mock/mock.go000066400000000000000000000650201373124421700214540ustar00rootroot00000000000000package mock import ( "errors" "fmt" "reflect" "regexp" "runtime" "strings" "sync" "time" "github.com/davecgh/go-spew/spew" "github.com/pmezard/go-difflib/difflib" "github.com/stretchr/objx" "github.com/jmespath/go-jmespath/internal/testify/assert" ) // TestingT is an interface wrapper around *testing.T type TestingT interface { Logf(format string, args ...interface{}) Errorf(format string, args ...interface{}) FailNow() } /* Call */ // Call represents a method call and is used for setting expectations, // as well as recording activity. type Call struct { Parent *Mock // The name of the method that was or will be called. Method string // Holds the arguments of the method. Arguments Arguments // Holds the arguments that should be returned when // this method is called. ReturnArguments Arguments // Holds the caller info for the On() call callerInfo []string // The number of times to return the return arguments when setting // expectations. 0 means to always return the value. Repeatability int // Amount of times this call has been called totalCalls int // Call to this method can be optional optional bool // Holds a channel that will be used to block the Return until it either // receives a message or is closed. nil means it returns immediately. WaitFor <-chan time.Time waitTime time.Duration // Holds a handler used to manipulate arguments content that are passed by // reference. It's useful when mocking methods such as unmarshalers or // decoders. RunFn func(Arguments) } func newCall(parent *Mock, methodName string, callerInfo []string, methodArguments ...interface{}) *Call { return &Call{ Parent: parent, Method: methodName, Arguments: methodArguments, ReturnArguments: make([]interface{}, 0), callerInfo: callerInfo, Repeatability: 0, WaitFor: nil, RunFn: nil, } } func (c *Call) lock() { c.Parent.mutex.Lock() } func (c *Call) unlock() { c.Parent.mutex.Unlock() } // Return specifies the return arguments for the expectation. // // Mock.On("DoSomething").Return(errors.New("failed")) func (c *Call) Return(returnArguments ...interface{}) *Call { c.lock() defer c.unlock() c.ReturnArguments = returnArguments return c } // Once indicates that that the mock should only return the value once. // // Mock.On("MyMethod", arg1, arg2).Return(returnArg1, returnArg2).Once() func (c *Call) Once() *Call { return c.Times(1) } // Twice indicates that that the mock should only return the value twice. // // Mock.On("MyMethod", arg1, arg2).Return(returnArg1, returnArg2).Twice() func (c *Call) Twice() *Call { return c.Times(2) } // Times indicates that that the mock should only return the indicated number // of times. // // Mock.On("MyMethod", arg1, arg2).Return(returnArg1, returnArg2).Times(5) func (c *Call) Times(i int) *Call { c.lock() defer c.unlock() c.Repeatability = i return c } // WaitUntil sets the channel that will block the mock's return until its closed // or a message is received. // // Mock.On("MyMethod", arg1, arg2).WaitUntil(time.After(time.Second)) func (c *Call) WaitUntil(w <-chan time.Time) *Call { c.lock() defer c.unlock() c.WaitFor = w return c } // After sets how long to block until the call returns // // Mock.On("MyMethod", arg1, arg2).After(time.Second) func (c *Call) After(d time.Duration) *Call { c.lock() defer c.unlock() c.waitTime = d return c } // Run sets a handler to be called before returning. It can be used when // mocking a method (such as an unmarshaler) that takes a pointer to a struct and // sets properties in such struct // // Mock.On("Unmarshal", AnythingOfType("*map[string]interface{}").Return().Run(func(args Arguments) { // arg := args.Get(0).(*map[string]interface{}) // arg["foo"] = "bar" // }) func (c *Call) Run(fn func(args Arguments)) *Call { c.lock() defer c.unlock() c.RunFn = fn return c } // Maybe allows the method call to be optional. Not calling an optional method // will not cause an error while asserting expectations func (c *Call) Maybe() *Call { c.lock() defer c.unlock() c.optional = true return c } // On chains a new expectation description onto the mocked interface. This // allows syntax like. // // Mock. // On("MyMethod", 1).Return(nil). // On("MyOtherMethod", 'a', 'b', 'c').Return(errors.New("Some Error")) //go:noinline func (c *Call) On(methodName string, arguments ...interface{}) *Call { return c.Parent.On(methodName, arguments...) } // Mock is the workhorse used to track activity on another object. // For an example of its usage, refer to the "Example Usage" section at the top // of this document. type Mock struct { // Represents the calls that are expected of // an object. ExpectedCalls []*Call // Holds the calls that were made to this mocked object. Calls []Call // test is An optional variable that holds the test struct, to be used when an // invalid mock call was made. test TestingT // TestData holds any data that might be useful for testing. Testify ignores // this data completely allowing you to do whatever you like with it. testData objx.Map mutex sync.Mutex } // TestData holds any data that might be useful for testing. Testify ignores // this data completely allowing you to do whatever you like with it. func (m *Mock) TestData() objx.Map { if m.testData == nil { m.testData = make(objx.Map) } return m.testData } /* Setting expectations */ // Test sets the test struct variable of the mock object func (m *Mock) Test(t TestingT) { m.mutex.Lock() defer m.mutex.Unlock() m.test = t } // fail fails the current test with the given formatted format and args. // In case that a test was defined, it uses the test APIs for failing a test, // otherwise it uses panic. func (m *Mock) fail(format string, args ...interface{}) { m.mutex.Lock() defer m.mutex.Unlock() if m.test == nil { panic(fmt.Sprintf(format, args...)) } m.test.Errorf(format, args...) m.test.FailNow() } // On starts a description of an expectation of the specified method // being called. // // Mock.On("MyMethod", arg1, arg2) func (m *Mock) On(methodName string, arguments ...interface{}) *Call { for _, arg := range arguments { if v := reflect.ValueOf(arg); v.Kind() == reflect.Func { panic(fmt.Sprintf("cannot use Func in expectations. Use mock.AnythingOfType(\"%T\")", arg)) } } m.mutex.Lock() defer m.mutex.Unlock() c := newCall(m, methodName, assert.CallerInfo(), arguments...) m.ExpectedCalls = append(m.ExpectedCalls, c) return c } // /* // Recording and responding to activity // */ func (m *Mock) findExpectedCall(method string, arguments ...interface{}) (int, *Call) { var expectedCall *Call for i, call := range m.ExpectedCalls { if call.Method == method { _, diffCount := call.Arguments.Diff(arguments) if diffCount == 0 { expectedCall = call if call.Repeatability > -1 { return i, call } } } } return -1, expectedCall } func (m *Mock) findClosestCall(method string, arguments ...interface{}) (*Call, string) { var diffCount int var closestCall *Call var err string for _, call := range m.expectedCalls() { if call.Method == method { errInfo, tempDiffCount := call.Arguments.Diff(arguments) if tempDiffCount < diffCount || diffCount == 0 { diffCount = tempDiffCount closestCall = call err = errInfo } } } return closestCall, err } func callString(method string, arguments Arguments, includeArgumentValues bool) string { var argValsString string if includeArgumentValues { var argVals []string for argIndex, arg := range arguments { argVals = append(argVals, fmt.Sprintf("%d: %#v", argIndex, arg)) } argValsString = fmt.Sprintf("\n\t\t%s", strings.Join(argVals, "\n\t\t")) } return fmt.Sprintf("%s(%s)%s", method, arguments.String(), argValsString) } // Called tells the mock object that a method has been called, and gets an array // of arguments to return. Panics if the call is unexpected (i.e. not preceded by // appropriate .On .Return() calls) // If Call.WaitFor is set, blocks until the channel is closed or receives a message. func (m *Mock) Called(arguments ...interface{}) Arguments { // get the calling function's name pc, _, _, ok := runtime.Caller(1) if !ok { panic("Couldn't get the caller information") } functionPath := runtime.FuncForPC(pc).Name() //Next four lines are required to use GCCGO function naming conventions. //For Ex: github_com_docker_libkv_store_mock.WatchTree.pN39_github_com_docker_libkv_store_mock.Mock //uses interface information unlike golang github.com/docker/libkv/store/mock.(*Mock).WatchTree //With GCCGO we need to remove interface information starting from pN
. re := regexp.MustCompile("\\.pN\\d+_") if re.MatchString(functionPath) { functionPath = re.Split(functionPath, -1)[0] } parts := strings.Split(functionPath, ".") functionName := parts[len(parts)-1] return m.MethodCalled(functionName, arguments...) } // MethodCalled tells the mock object that the given method has been called, and gets // an array of arguments to return. Panics if the call is unexpected (i.e. not preceded // by appropriate .On .Return() calls) // If Call.WaitFor is set, blocks until the channel is closed or receives a message. func (m *Mock) MethodCalled(methodName string, arguments ...interface{}) Arguments { m.mutex.Lock() //TODO: could combine expected and closes in single loop found, call := m.findExpectedCall(methodName, arguments...) if found < 0 { // expected call found but it has already been called with repeatable times if call != nil { m.mutex.Unlock() m.fail("\nassert: mock: The method has been called over %d times.\n\tEither do one more Mock.On(\"%s\").Return(...), or remove extra call.\n\tThis call was unexpected:\n\t\t%s\n\tat: %s", call.totalCalls, methodName, callString(methodName, arguments, true), assert.CallerInfo()) } // we have to fail here - because we don't know what to do // as the return arguments. This is because: // // a) this is a totally unexpected call to this method, // b) the arguments are not what was expected, or // c) the developer has forgotten to add an accompanying On...Return pair. closestCall, mismatch := m.findClosestCall(methodName, arguments...) m.mutex.Unlock() if closestCall != nil { m.fail("\n\nmock: Unexpected Method Call\n-----------------------------\n\n%s\n\nThe closest call I have is: \n\n%s\n\n%s\nDiff: %s", callString(methodName, arguments, true), callString(methodName, closestCall.Arguments, true), diffArguments(closestCall.Arguments, arguments), strings.TrimSpace(mismatch), ) } else { m.fail("\nassert: mock: I don't know what to return because the method call was unexpected.\n\tEither do Mock.On(\"%s\").Return(...) first, or remove the %s() call.\n\tThis method was unexpected:\n\t\t%s\n\tat: %s", methodName, methodName, callString(methodName, arguments, true), assert.CallerInfo()) } } if call.Repeatability == 1 { call.Repeatability = -1 } else if call.Repeatability > 1 { call.Repeatability-- } call.totalCalls++ // add the call m.Calls = append(m.Calls, *newCall(m, methodName, assert.CallerInfo(), arguments...)) m.mutex.Unlock() // block if specified if call.WaitFor != nil { <-call.WaitFor } else { time.Sleep(call.waitTime) } m.mutex.Lock() runFn := call.RunFn m.mutex.Unlock() if runFn != nil { runFn(arguments) } m.mutex.Lock() returnArgs := call.ReturnArguments m.mutex.Unlock() return returnArgs } /* Assertions */ type assertExpectationser interface { AssertExpectations(TestingT) bool } // AssertExpectationsForObjects asserts that everything specified with On and Return // of the specified objects was in fact called as expected. // // Calls may have occurred in any order. func AssertExpectationsForObjects(t TestingT, testObjects ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() } for _, obj := range testObjects { if m, ok := obj.(Mock); ok { t.Logf("Deprecated mock.AssertExpectationsForObjects(myMock.Mock) use mock.AssertExpectationsForObjects(myMock)") obj = &m } m := obj.(assertExpectationser) if !m.AssertExpectations(t) { t.Logf("Expectations didn't match for Mock: %+v", reflect.TypeOf(m)) return false } } return true } // AssertExpectations asserts that everything specified with On and Return was // in fact called as expected. Calls may have occurred in any order. func (m *Mock) AssertExpectations(t TestingT) bool { if h, ok := t.(tHelper); ok { h.Helper() } m.mutex.Lock() defer m.mutex.Unlock() var somethingMissing bool var failedExpectations int // iterate through each expectation expectedCalls := m.expectedCalls() for _, expectedCall := range expectedCalls { if !expectedCall.optional && !m.methodWasCalled(expectedCall.Method, expectedCall.Arguments) && expectedCall.totalCalls == 0 { somethingMissing = true failedExpectations++ t.Logf("FAIL:\t%s(%s)\n\t\tat: %s", expectedCall.Method, expectedCall.Arguments.String(), expectedCall.callerInfo) } else { if expectedCall.Repeatability > 0 { somethingMissing = true failedExpectations++ t.Logf("FAIL:\t%s(%s)\n\t\tat: %s", expectedCall.Method, expectedCall.Arguments.String(), expectedCall.callerInfo) } else { t.Logf("PASS:\t%s(%s)", expectedCall.Method, expectedCall.Arguments.String()) } } } if somethingMissing { t.Errorf("FAIL: %d out of %d expectation(s) were met.\n\tThe code you are testing needs to make %d more call(s).\n\tat: %s", len(expectedCalls)-failedExpectations, len(expectedCalls), failedExpectations, assert.CallerInfo()) } return !somethingMissing } // AssertNumberOfCalls asserts that the method was called expectedCalls times. func (m *Mock) AssertNumberOfCalls(t TestingT, methodName string, expectedCalls int) bool { if h, ok := t.(tHelper); ok { h.Helper() } m.mutex.Lock() defer m.mutex.Unlock() var actualCalls int for _, call := range m.calls() { if call.Method == methodName { actualCalls++ } } return assert.Equal(t, expectedCalls, actualCalls, fmt.Sprintf("Expected number of calls (%d) does not match the actual number of calls (%d).", expectedCalls, actualCalls)) } // AssertCalled asserts that the method was called. // It can produce a false result when an argument is a pointer type and the underlying value changed after calling the mocked method. func (m *Mock) AssertCalled(t TestingT, methodName string, arguments ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() } m.mutex.Lock() defer m.mutex.Unlock() if !m.methodWasCalled(methodName, arguments) { var calledWithArgs []string for _, call := range m.calls() { calledWithArgs = append(calledWithArgs, fmt.Sprintf("%v", call.Arguments)) } if len(calledWithArgs) == 0 { return assert.Fail(t, "Should have called with given arguments", fmt.Sprintf("Expected %q to have been called with:\n%v\nbut no actual calls happened", methodName, arguments)) } return assert.Fail(t, "Should have called with given arguments", fmt.Sprintf("Expected %q to have been called with:\n%v\nbut actual calls were:\n %v", methodName, arguments, strings.Join(calledWithArgs, "\n"))) } return true } // AssertNotCalled asserts that the method was not called. // It can produce a false result when an argument is a pointer type and the underlying value changed after calling the mocked method. func (m *Mock) AssertNotCalled(t TestingT, methodName string, arguments ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() } m.mutex.Lock() defer m.mutex.Unlock() if m.methodWasCalled(methodName, arguments) { return assert.Fail(t, "Should not have called with given arguments", fmt.Sprintf("Expected %q to not have been called with:\n%v\nbut actually it was.", methodName, arguments)) } return true } func (m *Mock) methodWasCalled(methodName string, expected []interface{}) bool { for _, call := range m.calls() { if call.Method == methodName { _, differences := Arguments(expected).Diff(call.Arguments) if differences == 0 { // found the expected call return true } } } // we didn't find the expected call return false } func (m *Mock) expectedCalls() []*Call { return append([]*Call{}, m.ExpectedCalls...) } func (m *Mock) calls() []Call { return append([]Call{}, m.Calls...) } /* Arguments */ // Arguments holds an array of method arguments or return values. type Arguments []interface{} const ( // Anything is used in Diff and Assert when the argument being tested // shouldn't be taken into consideration. Anything = "mock.Anything" ) // AnythingOfTypeArgument is a string that contains the type of an argument // for use when type checking. Used in Diff and Assert. type AnythingOfTypeArgument string // AnythingOfType returns an AnythingOfTypeArgument object containing the // name of the type to check for. Used in Diff and Assert. // // For example: // Assert(t, AnythingOfType("string"), AnythingOfType("int")) func AnythingOfType(t string) AnythingOfTypeArgument { return AnythingOfTypeArgument(t) } // IsTypeArgument is a struct that contains the type of an argument // for use when type checking. This is an alternative to AnythingOfType. // Used in Diff and Assert. type IsTypeArgument struct { t interface{} } // IsType returns an IsTypeArgument object containing the type to check for. // You can provide a zero-value of the type to check. This is an // alternative to AnythingOfType. Used in Diff and Assert. // // For example: // Assert(t, IsType(""), IsType(0)) func IsType(t interface{}) *IsTypeArgument { return &IsTypeArgument{t: t} } // argumentMatcher performs custom argument matching, returning whether or // not the argument is matched by the expectation fixture function. type argumentMatcher struct { // fn is a function which accepts one argument, and returns a bool. fn reflect.Value } func (f argumentMatcher) Matches(argument interface{}) bool { expectType := f.fn.Type().In(0) expectTypeNilSupported := false switch expectType.Kind() { case reflect.Interface, reflect.Chan, reflect.Func, reflect.Map, reflect.Slice, reflect.Ptr: expectTypeNilSupported = true } argType := reflect.TypeOf(argument) var arg reflect.Value if argType == nil { arg = reflect.New(expectType).Elem() } else { arg = reflect.ValueOf(argument) } if argType == nil && !expectTypeNilSupported { panic(errors.New("attempting to call matcher with nil for non-nil expected type")) } if argType == nil || argType.AssignableTo(expectType) { result := f.fn.Call([]reflect.Value{arg}) return result[0].Bool() } return false } func (f argumentMatcher) String() string { return fmt.Sprintf("func(%s) bool", f.fn.Type().In(0).Name()) } // MatchedBy can be used to match a mock call based on only certain properties // from a complex struct or some calculation. It takes a function that will be // evaluated with the called argument and will return true when there's a match // and false otherwise. // // Example: // m.On("Do", MatchedBy(func(req *http.Request) bool { return req.Host == "example.com" })) // // |fn|, must be a function accepting a single argument (of the expected type) // which returns a bool. If |fn| doesn't match the required signature, // MatchedBy() panics. func MatchedBy(fn interface{}) argumentMatcher { fnType := reflect.TypeOf(fn) if fnType.Kind() != reflect.Func { panic(fmt.Sprintf("assert: arguments: %s is not a func", fn)) } if fnType.NumIn() != 1 { panic(fmt.Sprintf("assert: arguments: %s does not take exactly one argument", fn)) } if fnType.NumOut() != 1 || fnType.Out(0).Kind() != reflect.Bool { panic(fmt.Sprintf("assert: arguments: %s does not return a bool", fn)) } return argumentMatcher{fn: reflect.ValueOf(fn)} } // Get Returns the argument at the specified index. func (args Arguments) Get(index int) interface{} { if index+1 > len(args) { panic(fmt.Sprintf("assert: arguments: Cannot call Get(%d) because there are %d argument(s).", index, len(args))) } return args[index] } // Is gets whether the objects match the arguments specified. func (args Arguments) Is(objects ...interface{}) bool { for i, obj := range args { if obj != objects[i] { return false } } return true } // Diff gets a string describing the differences between the arguments // and the specified objects. // // Returns the diff string and number of differences found. func (args Arguments) Diff(objects []interface{}) (string, int) { //TODO: could return string as error and nil for No difference var output = "\n" var differences int var maxArgCount = len(args) if len(objects) > maxArgCount { maxArgCount = len(objects) } for i := 0; i < maxArgCount; i++ { var actual, expected interface{} var actualFmt, expectedFmt string if len(objects) <= i { actual = "(Missing)" actualFmt = "(Missing)" } else { actual = objects[i] actualFmt = fmt.Sprintf("(%[1]T=%[1]v)", actual) } if len(args) <= i { expected = "(Missing)" expectedFmt = "(Missing)" } else { expected = args[i] expectedFmt = fmt.Sprintf("(%[1]T=%[1]v)", expected) } if matcher, ok := expected.(argumentMatcher); ok { if matcher.Matches(actual) { output = fmt.Sprintf("%s\t%d: PASS: %s matched by %s\n", output, i, actualFmt, matcher) } else { differences++ output = fmt.Sprintf("%s\t%d: FAIL: %s not matched by %s\n", output, i, actualFmt, matcher) } } else if reflect.TypeOf(expected) == reflect.TypeOf((*AnythingOfTypeArgument)(nil)).Elem() { // type checking if reflect.TypeOf(actual).Name() != string(expected.(AnythingOfTypeArgument)) && reflect.TypeOf(actual).String() != string(expected.(AnythingOfTypeArgument)) { // not match differences++ output = fmt.Sprintf("%s\t%d: FAIL: type %s != type %s - %s\n", output, i, expected, reflect.TypeOf(actual).Name(), actualFmt) } } else if reflect.TypeOf(expected) == reflect.TypeOf((*IsTypeArgument)(nil)) { t := expected.(*IsTypeArgument).t if reflect.TypeOf(t) != reflect.TypeOf(actual) { differences++ output = fmt.Sprintf("%s\t%d: FAIL: type %s != type %s - %s\n", output, i, reflect.TypeOf(t).Name(), reflect.TypeOf(actual).Name(), actualFmt) } } else { // normal checking if assert.ObjectsAreEqual(expected, Anything) || assert.ObjectsAreEqual(actual, Anything) || assert.ObjectsAreEqual(actual, expected) { // match output = fmt.Sprintf("%s\t%d: PASS: %s == %s\n", output, i, actualFmt, expectedFmt) } else { // not match differences++ output = fmt.Sprintf("%s\t%d: FAIL: %s != %s\n", output, i, actualFmt, expectedFmt) } } } if differences == 0 { return "No differences.", differences } return output, differences } // Assert compares the arguments with the specified objects and fails if // they do not exactly match. func (args Arguments) Assert(t TestingT, objects ...interface{}) bool { if h, ok := t.(tHelper); ok { h.Helper() } // get the differences diff, diffCount := args.Diff(objects) if diffCount == 0 { return true } // there are differences... report them... t.Logf(diff) t.Errorf("%sArguments do not match.", assert.CallerInfo()) return false } // String gets the argument at the specified index. Panics if there is no argument, or // if the argument is of the wrong type. // // If no index is provided, String() returns a complete string representation // of the arguments. func (args Arguments) String(indexOrNil ...int) string { if len(indexOrNil) == 0 { // normal String() method - return a string representation of the args var argsStr []string for _, arg := range args { argsStr = append(argsStr, fmt.Sprintf("%s", reflect.TypeOf(arg))) } return strings.Join(argsStr, ",") } else if len(indexOrNil) == 1 { // Index has been specified - get the argument at that index var index = indexOrNil[0] var s string var ok bool if s, ok = args.Get(index).(string); !ok { panic(fmt.Sprintf("assert: arguments: String(%d) failed because object wasn't correct type: %s", index, args.Get(index))) } return s } panic(fmt.Sprintf("assert: arguments: Wrong number of arguments passed to String. Must be 0 or 1, not %d", len(indexOrNil))) } // Int gets the argument at the specified index. Panics if there is no argument, or // if the argument is of the wrong type. func (args Arguments) Int(index int) int { var s int var ok bool if s, ok = args.Get(index).(int); !ok { panic(fmt.Sprintf("assert: arguments: Int(%d) failed because object wasn't correct type: %v", index, args.Get(index))) } return s } // Error gets the argument at the specified index. Panics if there is no argument, or // if the argument is of the wrong type. func (args Arguments) Error(index int) error { obj := args.Get(index) var s error var ok bool if obj == nil { return nil } if s, ok = obj.(error); !ok { panic(fmt.Sprintf("assert: arguments: Error(%d) failed because object wasn't correct type: %v", index, args.Get(index))) } return s } // Bool gets the argument at the specified index. Panics if there is no argument, or // if the argument is of the wrong type. func (args Arguments) Bool(index int) bool { var s bool var ok bool if s, ok = args.Get(index).(bool); !ok { panic(fmt.Sprintf("assert: arguments: Bool(%d) failed because object wasn't correct type: %v", index, args.Get(index))) } return s } func typeAndKind(v interface{}) (reflect.Type, reflect.Kind) { t := reflect.TypeOf(v) k := t.Kind() if k == reflect.Ptr { t = t.Elem() k = t.Kind() } return t, k } func diffArguments(expected Arguments, actual Arguments) string { if len(expected) != len(actual) { return fmt.Sprintf("Provided %v arguments, mocked for %v arguments", len(expected), len(actual)) } for x := range expected { if diffString := diff(expected[x], actual[x]); diffString != "" { return fmt.Sprintf("Difference found in argument %v:\n\n%s", x, diffString) } } return "" } // diff returns a diff of both values as long as both are of the same type and // are a struct, map, slice or array. Otherwise it returns an empty string. func diff(expected interface{}, actual interface{}) string { if expected == nil || actual == nil { return "" } et, ek := typeAndKind(expected) at, _ := typeAndKind(actual) if et != at { return "" } if ek != reflect.Struct && ek != reflect.Map && ek != reflect.Slice && ek != reflect.Array { return "" } e := spewConfig.Sdump(expected) a := spewConfig.Sdump(actual) diff, _ := difflib.GetUnifiedDiffString(difflib.UnifiedDiff{ A: difflib.SplitLines(e), B: difflib.SplitLines(a), FromFile: "Expected", FromDate: "", ToFile: "Actual", ToDate: "", Context: 1, }) return diff } var spewConfig = spew.ConfigState{ Indent: " ", DisablePointerAddresses: true, DisableCapacities: true, SortKeys: true, } type tHelper interface { Helper() } go-jmespath-0.4.0/internal/testify/mock/mock_test.go000066400000000000000000001236731373124421700225240ustar00rootroot00000000000000package mock import ( "errors" "fmt" "regexp" "runtime" "sync" "testing" "time" "github.com/jmespath/go-jmespath/internal/testify/assert" "github.com/jmespath/go-jmespath/internal/testify/require" ) /* Test objects */ // ExampleInterface represents an example interface. type ExampleInterface interface { TheExampleMethod(a, b, c int) (int, error) } // TestExampleImplementation is a test implementation of ExampleInterface type TestExampleImplementation struct { Mock } func (i *TestExampleImplementation) TheExampleMethod(a, b, c int) (int, error) { args := i.Called(a, b, c) return args.Int(0), errors.New("Whoops") } //go:noinline func (i *TestExampleImplementation) TheExampleMethod2(yesorno bool) { i.Called(yesorno) } type ExampleType struct { ran bool } func (i *TestExampleImplementation) TheExampleMethod3(et *ExampleType) error { args := i.Called(et) return args.Error(0) } func (i *TestExampleImplementation) TheExampleMethod4(v ExampleInterface) error { args := i.Called(v) return args.Error(0) } func (i *TestExampleImplementation) TheExampleMethod5(ch chan struct{}) error { args := i.Called(ch) return args.Error(0) } func (i *TestExampleImplementation) TheExampleMethod6(m map[string]bool) error { args := i.Called(m) return args.Error(0) } func (i *TestExampleImplementation) TheExampleMethod7(slice []bool) error { args := i.Called(slice) return args.Error(0) } func (i *TestExampleImplementation) TheExampleMethodFunc(fn func(string) error) error { args := i.Called(fn) return args.Error(0) } func (i *TestExampleImplementation) TheExampleMethodVariadic(a ...int) error { args := i.Called(a) return args.Error(0) } func (i *TestExampleImplementation) TheExampleMethodVariadicInterface(a ...interface{}) error { args := i.Called(a) return args.Error(0) } func (i *TestExampleImplementation) TheExampleMethodMixedVariadic(a int, b ...int) error { args := i.Called(a, b) return args.Error(0) } type ExampleFuncType func(string) error func (i *TestExampleImplementation) TheExampleMethodFuncType(fn ExampleFuncType) error { args := i.Called(fn) return args.Error(0) } // MockTestingT mocks a test struct type MockTestingT struct { logfCount, errorfCount, failNowCount int } const mockTestingTFailNowCalled = "FailNow was called" func (m *MockTestingT) Logf(string, ...interface{}) { m.logfCount++ } func (m *MockTestingT) Errorf(string, ...interface{}) { m.errorfCount++ } // FailNow mocks the FailNow call. // It panics in order to mimic the FailNow behavior in the sense that // the execution stops. // When expecting this method, the call that invokes it should use the following code: // // assert.PanicsWithValue(t, mockTestingTFailNowCalled, func() {...}) func (m *MockTestingT) FailNow() { m.failNowCount++ // this function should panic now to stop the execution as expected panic(mockTestingTFailNowCalled) } /* Mock */ func Test_Mock_TestData(t *testing.T) { var mockedService = new(TestExampleImplementation) if assert.NotNil(t, mockedService.TestData()) { mockedService.TestData().Set("something", 123) assert.Equal(t, 123, mockedService.TestData().Get("something").Data()) } } func Test_Mock_On(t *testing.T) { // make a test impl object var mockedService = new(TestExampleImplementation) c := mockedService.On("TheExampleMethod") assert.Equal(t, []*Call{c}, mockedService.ExpectedCalls) assert.Equal(t, "TheExampleMethod", c.Method) } func Test_Mock_Chained_On(t *testing.T) { // make a test impl object var mockedService = new(TestExampleImplementation) // determine our current line number so we can assert the expected calls callerInfo properly _, _, line, _ := runtime.Caller(0) mockedService. On("TheExampleMethod", 1, 2, 3). Return(0). On("TheExampleMethod3", AnythingOfType("*mock.ExampleType")). Return(nil) expectedCalls := []*Call{ { Parent: &mockedService.Mock, Method: "TheExampleMethod", Arguments: []interface{}{1, 2, 3}, ReturnArguments: []interface{}{0}, callerInfo: []string{fmt.Sprintf("mock_test.go:%d", line+2)}, }, { Parent: &mockedService.Mock, Method: "TheExampleMethod3", Arguments: []interface{}{AnythingOfType("*mock.ExampleType")}, ReturnArguments: []interface{}{nil}, callerInfo: []string{fmt.Sprintf("mock_test.go:%d", line+4)}, }, } assert.Equal(t, expectedCalls, mockedService.ExpectedCalls) } func Test_Mock_On_WithArgs(t *testing.T) { // make a test impl object var mockedService = new(TestExampleImplementation) c := mockedService.On("TheExampleMethod", 1, 2, 3, 4) assert.Equal(t, []*Call{c}, mockedService.ExpectedCalls) assert.Equal(t, "TheExampleMethod", c.Method) assert.Equal(t, Arguments{1, 2, 3, 4}, c.Arguments) } func Test_Mock_On_WithFuncArg(t *testing.T) { // make a test impl object var mockedService = new(TestExampleImplementation) c := mockedService. On("TheExampleMethodFunc", AnythingOfType("func(string) error")). Return(nil) assert.Equal(t, []*Call{c}, mockedService.ExpectedCalls) assert.Equal(t, "TheExampleMethodFunc", c.Method) assert.Equal(t, 1, len(c.Arguments)) assert.Equal(t, AnythingOfType("func(string) error"), c.Arguments[0]) fn := func(string) error { return nil } assert.NotPanics(t, func() { mockedService.TheExampleMethodFunc(fn) }) } func Test_Mock_On_WithIntArgMatcher(t *testing.T) { var mockedService TestExampleImplementation mockedService.On("TheExampleMethod", MatchedBy(func(a int) bool { return a == 1 }), MatchedBy(func(b int) bool { return b == 2 }), MatchedBy(func(c int) bool { return c == 3 })).Return(0, nil) assert.Panics(t, func() { mockedService.TheExampleMethod(1, 2, 4) }) assert.Panics(t, func() { mockedService.TheExampleMethod(2, 2, 3) }) assert.NotPanics(t, func() { mockedService.TheExampleMethod(1, 2, 3) }) } func TestMock_WithTest(t *testing.T) { var ( mockedService TestExampleImplementation mockedTest MockTestingT ) mockedService.Test(&mockedTest) mockedService.On("TheExampleMethod", 1, 2, 3).Return(0, nil) // Test that on an expected call, the test was not failed mockedService.TheExampleMethod(1, 2, 3) // Assert that Errorf and FailNow were not called assert.Equal(t, 0, mockedTest.errorfCount) assert.Equal(t, 0, mockedTest.failNowCount) // Test that on unexpected call, the mocked test was called to fail the test assert.PanicsWithValue(t, mockTestingTFailNowCalled, func() { mockedService.TheExampleMethod(1, 1, 1) }) // Assert that Errorf and FailNow were called once assert.Equal(t, 1, mockedTest.errorfCount) assert.Equal(t, 1, mockedTest.failNowCount) } func Test_Mock_On_WithPtrArgMatcher(t *testing.T) { var mockedService TestExampleImplementation mockedService.On("TheExampleMethod3", MatchedBy(func(a *ExampleType) bool { return a != nil && a.ran == true }), ).Return(nil) mockedService.On("TheExampleMethod3", MatchedBy(func(a *ExampleType) bool { return a != nil && a.ran == false }), ).Return(errors.New("error")) mockedService.On("TheExampleMethod3", MatchedBy(func(a *ExampleType) bool { return a == nil }), ).Return(errors.New("error2")) assert.Equal(t, mockedService.TheExampleMethod3(&ExampleType{true}), nil) assert.EqualError(t, mockedService.TheExampleMethod3(&ExampleType{false}), "error") assert.EqualError(t, mockedService.TheExampleMethod3(nil), "error2") } func Test_Mock_On_WithFuncArgMatcher(t *testing.T) { var mockedService TestExampleImplementation fixture1, fixture2 := errors.New("fixture1"), errors.New("fixture2") mockedService.On("TheExampleMethodFunc", MatchedBy(func(a func(string) error) bool { return a != nil && a("string") == fixture1 }), ).Return(errors.New("fixture1")) mockedService.On("TheExampleMethodFunc", MatchedBy(func(a func(string) error) bool { return a != nil && a("string") == fixture2 }), ).Return(errors.New("fixture2")) mockedService.On("TheExampleMethodFunc", MatchedBy(func(a func(string) error) bool { return a == nil }), ).Return(errors.New("fixture3")) assert.EqualError(t, mockedService.TheExampleMethodFunc( func(string) error { return fixture1 }), "fixture1") assert.EqualError(t, mockedService.TheExampleMethodFunc( func(string) error { return fixture2 }), "fixture2") assert.EqualError(t, mockedService.TheExampleMethodFunc(nil), "fixture3") } func Test_Mock_On_WithInterfaceArgMatcher(t *testing.T) { var mockedService TestExampleImplementation mockedService.On("TheExampleMethod4", MatchedBy(func(a ExampleInterface) bool { return a == nil }), ).Return(errors.New("fixture1")) assert.EqualError(t, mockedService.TheExampleMethod4(nil), "fixture1") } func Test_Mock_On_WithChannelArgMatcher(t *testing.T) { var mockedService TestExampleImplementation mockedService.On("TheExampleMethod5", MatchedBy(func(ch chan struct{}) bool { return ch == nil }), ).Return(errors.New("fixture1")) assert.EqualError(t, mockedService.TheExampleMethod5(nil), "fixture1") } func Test_Mock_On_WithMapArgMatcher(t *testing.T) { var mockedService TestExampleImplementation mockedService.On("TheExampleMethod6", MatchedBy(func(m map[string]bool) bool { return m == nil }), ).Return(errors.New("fixture1")) assert.EqualError(t, mockedService.TheExampleMethod6(nil), "fixture1") } func Test_Mock_On_WithSliceArgMatcher(t *testing.T) { var mockedService TestExampleImplementation mockedService.On("TheExampleMethod7", MatchedBy(func(slice []bool) bool { return slice == nil }), ).Return(errors.New("fixture1")) assert.EqualError(t, mockedService.TheExampleMethod7(nil), "fixture1") } func Test_Mock_On_WithVariadicFunc(t *testing.T) { // make a test impl object var mockedService = new(TestExampleImplementation) c := mockedService. On("TheExampleMethodVariadic", []int{1, 2, 3}). Return(nil) assert.Equal(t, []*Call{c}, mockedService.ExpectedCalls) assert.Equal(t, 1, len(c.Arguments)) assert.Equal(t, []int{1, 2, 3}, c.Arguments[0]) assert.NotPanics(t, func() { mockedService.TheExampleMethodVariadic(1, 2, 3) }) assert.Panics(t, func() { mockedService.TheExampleMethodVariadic(1, 2) }) } func Test_Mock_On_WithMixedVariadicFunc(t *testing.T) { // make a test impl object var mockedService = new(TestExampleImplementation) c := mockedService. On("TheExampleMethodMixedVariadic", 1, []int{2, 3, 4}). Return(nil) assert.Equal(t, []*Call{c}, mockedService.ExpectedCalls) assert.Equal(t, 2, len(c.Arguments)) assert.Equal(t, 1, c.Arguments[0]) assert.Equal(t, []int{2, 3, 4}, c.Arguments[1]) assert.NotPanics(t, func() { mockedService.TheExampleMethodMixedVariadic(1, 2, 3, 4) }) assert.Panics(t, func() { mockedService.TheExampleMethodMixedVariadic(1, 2, 3, 5) }) } func Test_Mock_On_WithVariadicFuncWithInterface(t *testing.T) { // make a test impl object var mockedService = new(TestExampleImplementation) c := mockedService.On("TheExampleMethodVariadicInterface", []interface{}{1, 2, 3}). Return(nil) assert.Equal(t, []*Call{c}, mockedService.ExpectedCalls) assert.Equal(t, 1, len(c.Arguments)) assert.Equal(t, []interface{}{1, 2, 3}, c.Arguments[0]) assert.NotPanics(t, func() { mockedService.TheExampleMethodVariadicInterface(1, 2, 3) }) assert.Panics(t, func() { mockedService.TheExampleMethodVariadicInterface(1, 2) }) } func Test_Mock_On_WithVariadicFuncWithEmptyInterfaceArray(t *testing.T) { // make a test impl object var mockedService = new(TestExampleImplementation) var expected []interface{} c := mockedService. On("TheExampleMethodVariadicInterface", expected). Return(nil) assert.Equal(t, []*Call{c}, mockedService.ExpectedCalls) assert.Equal(t, 1, len(c.Arguments)) assert.Equal(t, expected, c.Arguments[0]) assert.NotPanics(t, func() { mockedService.TheExampleMethodVariadicInterface() }) assert.Panics(t, func() { mockedService.TheExampleMethodVariadicInterface(1, 2) }) } func Test_Mock_On_WithFuncPanics(t *testing.T) { // make a test impl object var mockedService = new(TestExampleImplementation) assert.Panics(t, func() { mockedService.On("TheExampleMethodFunc", func(string) error { return nil }) }) } func Test_Mock_On_WithFuncTypeArg(t *testing.T) { // make a test impl object var mockedService = new(TestExampleImplementation) c := mockedService. On("TheExampleMethodFuncType", AnythingOfType("mock.ExampleFuncType")). Return(nil) assert.Equal(t, []*Call{c}, mockedService.ExpectedCalls) assert.Equal(t, 1, len(c.Arguments)) assert.Equal(t, AnythingOfType("mock.ExampleFuncType"), c.Arguments[0]) fn := func(string) error { return nil } assert.NotPanics(t, func() { mockedService.TheExampleMethodFuncType(fn) }) } func Test_Mock_Return(t *testing.T) { // make a test impl object var mockedService = new(TestExampleImplementation) c := mockedService. On("TheExampleMethod", "A", "B", true). Return(1, "two", true) require.Equal(t, []*Call{c}, mockedService.ExpectedCalls) call := mockedService.ExpectedCalls[0] assert.Equal(t, "TheExampleMethod", call.Method) assert.Equal(t, "A", call.Arguments[0]) assert.Equal(t, "B", call.Arguments[1]) assert.Equal(t, true, call.Arguments[2]) assert.Equal(t, 1, call.ReturnArguments[0]) assert.Equal(t, "two", call.ReturnArguments[1]) assert.Equal(t, true, call.ReturnArguments[2]) assert.Equal(t, 0, call.Repeatability) assert.Nil(t, call.WaitFor) } func Test_Mock_Return_WaitUntil(t *testing.T) { // make a test impl object var mockedService = new(TestExampleImplementation) ch := time.After(time.Second) c := mockedService.Mock. On("TheExampleMethod", "A", "B", true). WaitUntil(ch). Return(1, "two", true) // assert that the call was created require.Equal(t, []*Call{c}, mockedService.ExpectedCalls) call := mockedService.ExpectedCalls[0] assert.Equal(t, "TheExampleMethod", call.Method) assert.Equal(t, "A", call.Arguments[0]) assert.Equal(t, "B", call.Arguments[1]) assert.Equal(t, true, call.Arguments[2]) assert.Equal(t, 1, call.ReturnArguments[0]) assert.Equal(t, "two", call.ReturnArguments[1]) assert.Equal(t, true, call.ReturnArguments[2]) assert.Equal(t, 0, call.Repeatability) assert.Equal(t, ch, call.WaitFor) } func Test_Mock_Return_After(t *testing.T) { // make a test impl object var mockedService = new(TestExampleImplementation) c := mockedService.Mock. On("TheExampleMethod", "A", "B", true). Return(1, "two", true). After(time.Second) require.Equal(t, []*Call{c}, mockedService.ExpectedCalls) call := mockedService.Mock.ExpectedCalls[0] assert.Equal(t, "TheExampleMethod", call.Method) assert.Equal(t, "A", call.Arguments[0]) assert.Equal(t, "B", call.Arguments[1]) assert.Equal(t, true, call.Arguments[2]) assert.Equal(t, 1, call.ReturnArguments[0]) assert.Equal(t, "two", call.ReturnArguments[1]) assert.Equal(t, true, call.ReturnArguments[2]) assert.Equal(t, 0, call.Repeatability) assert.NotEqual(t, nil, call.WaitFor) } func Test_Mock_Return_Run(t *testing.T) { // make a test impl object var mockedService = new(TestExampleImplementation) fn := func(args Arguments) { arg := args.Get(0).(*ExampleType) arg.ran = true } c := mockedService.Mock. On("TheExampleMethod3", AnythingOfType("*mock.ExampleType")). Return(nil). Run(fn) require.Equal(t, []*Call{c}, mockedService.ExpectedCalls) call := mockedService.Mock.ExpectedCalls[0] assert.Equal(t, "TheExampleMethod3", call.Method) assert.Equal(t, AnythingOfType("*mock.ExampleType"), call.Arguments[0]) assert.Equal(t, nil, call.ReturnArguments[0]) assert.Equal(t, 0, call.Repeatability) assert.NotEqual(t, nil, call.WaitFor) assert.NotNil(t, call.Run) et := ExampleType{} assert.Equal(t, false, et.ran) mockedService.TheExampleMethod3(&et) assert.Equal(t, true, et.ran) } func Test_Mock_Return_Run_Out_Of_Order(t *testing.T) { // make a test impl object var mockedService = new(TestExampleImplementation) f := func(args Arguments) { arg := args.Get(0).(*ExampleType) arg.ran = true } c := mockedService.Mock. On("TheExampleMethod3", AnythingOfType("*mock.ExampleType")). Run(f). Return(nil) require.Equal(t, []*Call{c}, mockedService.ExpectedCalls) call := mockedService.Mock.ExpectedCalls[0] assert.Equal(t, "TheExampleMethod3", call.Method) assert.Equal(t, AnythingOfType("*mock.ExampleType"), call.Arguments[0]) assert.Equal(t, nil, call.ReturnArguments[0]) assert.Equal(t, 0, call.Repeatability) assert.NotEqual(t, nil, call.WaitFor) assert.NotNil(t, call.Run) } func Test_Mock_Return_Once(t *testing.T) { // make a test impl object var mockedService = new(TestExampleImplementation) c := mockedService.On("TheExampleMethod", "A", "B", true). Return(1, "two", true). Once() require.Equal(t, []*Call{c}, mockedService.ExpectedCalls) call := mockedService.ExpectedCalls[0] assert.Equal(t, "TheExampleMethod", call.Method) assert.Equal(t, "A", call.Arguments[0]) assert.Equal(t, "B", call.Arguments[1]) assert.Equal(t, true, call.Arguments[2]) assert.Equal(t, 1, call.ReturnArguments[0]) assert.Equal(t, "two", call.ReturnArguments[1]) assert.Equal(t, true, call.ReturnArguments[2]) assert.Equal(t, 1, call.Repeatability) assert.Nil(t, call.WaitFor) } func Test_Mock_Return_Twice(t *testing.T) { // make a test impl object var mockedService = new(TestExampleImplementation) c := mockedService. On("TheExampleMethod", "A", "B", true). Return(1, "two", true). Twice() require.Equal(t, []*Call{c}, mockedService.ExpectedCalls) call := mockedService.ExpectedCalls[0] assert.Equal(t, "TheExampleMethod", call.Method) assert.Equal(t, "A", call.Arguments[0]) assert.Equal(t, "B", call.Arguments[1]) assert.Equal(t, true, call.Arguments[2]) assert.Equal(t, 1, call.ReturnArguments[0]) assert.Equal(t, "two", call.ReturnArguments[1]) assert.Equal(t, true, call.ReturnArguments[2]) assert.Equal(t, 2, call.Repeatability) assert.Nil(t, call.WaitFor) } func Test_Mock_Return_Times(t *testing.T) { // make a test impl object var mockedService = new(TestExampleImplementation) c := mockedService. On("TheExampleMethod", "A", "B", true). Return(1, "two", true). Times(5) require.Equal(t, []*Call{c}, mockedService.ExpectedCalls) call := mockedService.ExpectedCalls[0] assert.Equal(t, "TheExampleMethod", call.Method) assert.Equal(t, "A", call.Arguments[0]) assert.Equal(t, "B", call.Arguments[1]) assert.Equal(t, true, call.Arguments[2]) assert.Equal(t, 1, call.ReturnArguments[0]) assert.Equal(t, "two", call.ReturnArguments[1]) assert.Equal(t, true, call.ReturnArguments[2]) assert.Equal(t, 5, call.Repeatability) assert.Nil(t, call.WaitFor) } func Test_Mock_Return_Nothing(t *testing.T) { // make a test impl object var mockedService = new(TestExampleImplementation) c := mockedService. On("TheExampleMethod", "A", "B", true). Return() require.Equal(t, []*Call{c}, mockedService.ExpectedCalls) call := mockedService.ExpectedCalls[0] assert.Equal(t, "TheExampleMethod", call.Method) assert.Equal(t, "A", call.Arguments[0]) assert.Equal(t, "B", call.Arguments[1]) assert.Equal(t, true, call.Arguments[2]) assert.Equal(t, 0, len(call.ReturnArguments)) } func Test_Mock_findExpectedCall(t *testing.T) { m := new(Mock) m.On("One", 1).Return("one") m.On("Two", 2).Return("two") m.On("Two", 3).Return("three") f, c := m.findExpectedCall("Two", 3) if assert.Equal(t, 2, f) { if assert.NotNil(t, c) { assert.Equal(t, "Two", c.Method) assert.Equal(t, 3, c.Arguments[0]) assert.Equal(t, "three", c.ReturnArguments[0]) } } } func Test_Mock_findExpectedCall_For_Unknown_Method(t *testing.T) { m := new(Mock) m.On("One", 1).Return("one") m.On("Two", 2).Return("two") m.On("Two", 3).Return("three") f, _ := m.findExpectedCall("Two") assert.Equal(t, -1, f) } func Test_Mock_findExpectedCall_Respects_Repeatability(t *testing.T) { m := new(Mock) m.On("One", 1).Return("one") m.On("Two", 2).Return("two").Once() m.On("Two", 3).Return("three").Twice() m.On("Two", 3).Return("three").Times(8) f, c := m.findExpectedCall("Two", 3) if assert.Equal(t, 2, f) { if assert.NotNil(t, c) { assert.Equal(t, "Two", c.Method) assert.Equal(t, 3, c.Arguments[0]) assert.Equal(t, "three", c.ReturnArguments[0]) } } c = m.On("Once", 1).Return("one").Once() c.Repeatability = -1 f, c = m.findExpectedCall("Once", 1) if assert.Equal(t, -1, f) { if assert.NotNil(t, c) { assert.Equal(t, "Once", c.Method) assert.Equal(t, 1, c.Arguments[0]) assert.Equal(t, "one", c.ReturnArguments[0]) } } } func Test_callString(t *testing.T) { assert.Equal(t, `Method(int,bool,string)`, callString("Method", []interface{}{1, true, "something"}, false)) } func Test_Mock_Called(t *testing.T) { var mockedService = new(TestExampleImplementation) mockedService.On("Test_Mock_Called", 1, 2, 3).Return(5, "6", true) returnArguments := mockedService.Called(1, 2, 3) if assert.Equal(t, 1, len(mockedService.Calls)) { assert.Equal(t, "Test_Mock_Called", mockedService.Calls[0].Method) assert.Equal(t, 1, mockedService.Calls[0].Arguments[0]) assert.Equal(t, 2, mockedService.Calls[0].Arguments[1]) assert.Equal(t, 3, mockedService.Calls[0].Arguments[2]) } if assert.Equal(t, 3, len(returnArguments)) { assert.Equal(t, 5, returnArguments[0]) assert.Equal(t, "6", returnArguments[1]) assert.Equal(t, true, returnArguments[2]) } } func asyncCall(m *Mock, ch chan Arguments) { ch <- m.Called(1, 2, 3) } func Test_Mock_Called_blocks(t *testing.T) { var mockedService = new(TestExampleImplementation) mockedService.Mock.On("asyncCall", 1, 2, 3).Return(5, "6", true).After(2 * time.Millisecond) ch := make(chan Arguments) go asyncCall(&mockedService.Mock, ch) select { case <-ch: t.Fatal("should have waited") case <-time.After(1 * time.Millisecond): } returnArguments := <-ch if assert.Equal(t, 1, len(mockedService.Mock.Calls)) { assert.Equal(t, "asyncCall", mockedService.Mock.Calls[0].Method) assert.Equal(t, 1, mockedService.Mock.Calls[0].Arguments[0]) assert.Equal(t, 2, mockedService.Mock.Calls[0].Arguments[1]) assert.Equal(t, 3, mockedService.Mock.Calls[0].Arguments[2]) } if assert.Equal(t, 3, len(returnArguments)) { assert.Equal(t, 5, returnArguments[0]) assert.Equal(t, "6", returnArguments[1]) assert.Equal(t, true, returnArguments[2]) } } func Test_Mock_Called_For_Bounded_Repeatability(t *testing.T) { var mockedService = new(TestExampleImplementation) mockedService. On("Test_Mock_Called_For_Bounded_Repeatability", 1, 2, 3). Return(5, "6", true). Once() mockedService. On("Test_Mock_Called_For_Bounded_Repeatability", 1, 2, 3). Return(-1, "hi", false) returnArguments1 := mockedService.Called(1, 2, 3) returnArguments2 := mockedService.Called(1, 2, 3) if assert.Equal(t, 2, len(mockedService.Calls)) { assert.Equal(t, "Test_Mock_Called_For_Bounded_Repeatability", mockedService.Calls[0].Method) assert.Equal(t, 1, mockedService.Calls[0].Arguments[0]) assert.Equal(t, 2, mockedService.Calls[0].Arguments[1]) assert.Equal(t, 3, mockedService.Calls[0].Arguments[2]) assert.Equal(t, "Test_Mock_Called_For_Bounded_Repeatability", mockedService.Calls[1].Method) assert.Equal(t, 1, mockedService.Calls[1].Arguments[0]) assert.Equal(t, 2, mockedService.Calls[1].Arguments[1]) assert.Equal(t, 3, mockedService.Calls[1].Arguments[2]) } if assert.Equal(t, 3, len(returnArguments1)) { assert.Equal(t, 5, returnArguments1[0]) assert.Equal(t, "6", returnArguments1[1]) assert.Equal(t, true, returnArguments1[2]) } if assert.Equal(t, 3, len(returnArguments2)) { assert.Equal(t, -1, returnArguments2[0]) assert.Equal(t, "hi", returnArguments2[1]) assert.Equal(t, false, returnArguments2[2]) } } func Test_Mock_Called_For_SetTime_Expectation(t *testing.T) { var mockedService = new(TestExampleImplementation) mockedService.On("TheExampleMethod", 1, 2, 3).Return(5, "6", true).Times(4) mockedService.TheExampleMethod(1, 2, 3) mockedService.TheExampleMethod(1, 2, 3) mockedService.TheExampleMethod(1, 2, 3) mockedService.TheExampleMethod(1, 2, 3) assert.Panics(t, func() { mockedService.TheExampleMethod(1, 2, 3) }) } func Test_Mock_Called_Unexpected(t *testing.T) { var mockedService = new(TestExampleImplementation) // make sure it panics if no expectation was made assert.Panics(t, func() { mockedService.Called(1, 2, 3) }, "Calling unexpected method should panic") } func Test_AssertExpectationsForObjects_Helper(t *testing.T) { var mockedService1 = new(TestExampleImplementation) var mockedService2 = new(TestExampleImplementation) var mockedService3 = new(TestExampleImplementation) mockedService1.On("Test_AssertExpectationsForObjects_Helper", 1).Return() mockedService2.On("Test_AssertExpectationsForObjects_Helper", 2).Return() mockedService3.On("Test_AssertExpectationsForObjects_Helper", 3).Return() mockedService1.Called(1) mockedService2.Called(2) mockedService3.Called(3) assert.True(t, AssertExpectationsForObjects(t, &mockedService1.Mock, &mockedService2.Mock, &mockedService3.Mock)) assert.True(t, AssertExpectationsForObjects(t, mockedService1, mockedService2, mockedService3)) } func Test_AssertExpectationsForObjects_Helper_Failed(t *testing.T) { var mockedService1 = new(TestExampleImplementation) var mockedService2 = new(TestExampleImplementation) var mockedService3 = new(TestExampleImplementation) mockedService1.On("Test_AssertExpectationsForObjects_Helper_Failed", 1).Return() mockedService2.On("Test_AssertExpectationsForObjects_Helper_Failed", 2).Return() mockedService3.On("Test_AssertExpectationsForObjects_Helper_Failed", 3).Return() mockedService1.Called(1) mockedService3.Called(3) tt := new(testing.T) assert.False(t, AssertExpectationsForObjects(tt, &mockedService1.Mock, &mockedService2.Mock, &mockedService3.Mock)) assert.False(t, AssertExpectationsForObjects(tt, mockedService1, mockedService2, mockedService3)) } func Test_Mock_AssertExpectations(t *testing.T) { var mockedService = new(TestExampleImplementation) mockedService.On("Test_Mock_AssertExpectations", 1, 2, 3).Return(5, 6, 7) tt := new(testing.T) assert.False(t, mockedService.AssertExpectations(tt)) // make the call now mockedService.Called(1, 2, 3) // now assert expectations assert.True(t, mockedService.AssertExpectations(tt)) } func Test_Mock_AssertExpectations_Placeholder_NoArgs(t *testing.T) { var mockedService = new(TestExampleImplementation) mockedService.On("Test_Mock_AssertExpectations_Placeholder_NoArgs").Return(5, 6, 7).Once() mockedService.On("Test_Mock_AssertExpectations_Placeholder_NoArgs").Return(7, 6, 5) tt := new(testing.T) assert.False(t, mockedService.AssertExpectations(tt)) // make the call now mockedService.Called() // now assert expectations assert.True(t, mockedService.AssertExpectations(tt)) } func Test_Mock_AssertExpectations_Placeholder(t *testing.T) { var mockedService = new(TestExampleImplementation) mockedService.On("Test_Mock_AssertExpectations_Placeholder", 1, 2, 3).Return(5, 6, 7).Once() mockedService.On("Test_Mock_AssertExpectations_Placeholder", 3, 2, 1).Return(7, 6, 5) tt := new(testing.T) assert.False(t, mockedService.AssertExpectations(tt)) // make the call now mockedService.Called(1, 2, 3) // now assert expectations assert.False(t, mockedService.AssertExpectations(tt)) // make call to the second expectation mockedService.Called(3, 2, 1) // now assert expectations again assert.True(t, mockedService.AssertExpectations(tt)) } func Test_Mock_AssertExpectations_With_Pointers(t *testing.T) { var mockedService = new(TestExampleImplementation) mockedService.On("Test_Mock_AssertExpectations_With_Pointers", &struct{ Foo int }{1}).Return(1) mockedService.On("Test_Mock_AssertExpectations_With_Pointers", &struct{ Foo int }{2}).Return(2) tt := new(testing.T) assert.False(t, mockedService.AssertExpectations(tt)) s := struct{ Foo int }{1} // make the calls now mockedService.Called(&s) s.Foo = 2 mockedService.Called(&s) // now assert expectations assert.True(t, mockedService.AssertExpectations(tt)) } func Test_Mock_AssertExpectationsCustomType(t *testing.T) { var mockedService = new(TestExampleImplementation) mockedService.On("TheExampleMethod3", AnythingOfType("*mock.ExampleType")).Return(nil).Once() tt := new(testing.T) assert.False(t, mockedService.AssertExpectations(tt)) // make the call now mockedService.TheExampleMethod3(&ExampleType{}) // now assert expectations assert.True(t, mockedService.AssertExpectations(tt)) } func Test_Mock_AssertExpectations_With_Repeatability(t *testing.T) { var mockedService = new(TestExampleImplementation) mockedService.On("Test_Mock_AssertExpectations_With_Repeatability", 1, 2, 3).Return(5, 6, 7).Twice() tt := new(testing.T) assert.False(t, mockedService.AssertExpectations(tt)) // make the call now mockedService.Called(1, 2, 3) assert.False(t, mockedService.AssertExpectations(tt)) mockedService.Called(1, 2, 3) // now assert expectations assert.True(t, mockedService.AssertExpectations(tt)) } func Test_Mock_TwoCallsWithDifferentArguments(t *testing.T) { var mockedService = new(TestExampleImplementation) mockedService.On("Test_Mock_TwoCallsWithDifferentArguments", 1, 2, 3).Return(5, 6, 7) mockedService.On("Test_Mock_TwoCallsWithDifferentArguments", 4, 5, 6).Return(5, 6, 7) args1 := mockedService.Called(1, 2, 3) assert.Equal(t, 5, args1.Int(0)) assert.Equal(t, 6, args1.Int(1)) assert.Equal(t, 7, args1.Int(2)) args2 := mockedService.Called(4, 5, 6) assert.Equal(t, 5, args2.Int(0)) assert.Equal(t, 6, args2.Int(1)) assert.Equal(t, 7, args2.Int(2)) } func Test_Mock_AssertNumberOfCalls(t *testing.T) { var mockedService = new(TestExampleImplementation) mockedService.On("Test_Mock_AssertNumberOfCalls", 1, 2, 3).Return(5, 6, 7) mockedService.Called(1, 2, 3) assert.True(t, mockedService.AssertNumberOfCalls(t, "Test_Mock_AssertNumberOfCalls", 1)) mockedService.Called(1, 2, 3) assert.True(t, mockedService.AssertNumberOfCalls(t, "Test_Mock_AssertNumberOfCalls", 2)) } func Test_Mock_AssertCalled(t *testing.T) { var mockedService = new(TestExampleImplementation) mockedService.On("Test_Mock_AssertCalled", 1, 2, 3).Return(5, 6, 7) mockedService.Called(1, 2, 3) assert.True(t, mockedService.AssertCalled(t, "Test_Mock_AssertCalled", 1, 2, 3)) } func Test_Mock_AssertCalled_WithAnythingOfTypeArgument(t *testing.T) { var mockedService = new(TestExampleImplementation) mockedService. On("Test_Mock_AssertCalled_WithAnythingOfTypeArgument", Anything, Anything, Anything). Return() mockedService.Called(1, "two", []uint8("three")) assert.True(t, mockedService.AssertCalled(t, "Test_Mock_AssertCalled_WithAnythingOfTypeArgument", AnythingOfType("int"), AnythingOfType("string"), AnythingOfType("[]uint8"))) } func Test_Mock_AssertCalled_WithArguments(t *testing.T) { var mockedService = new(TestExampleImplementation) mockedService.On("Test_Mock_AssertCalled_WithArguments", 1, 2, 3).Return(5, 6, 7) mockedService.Called(1, 2, 3) tt := new(testing.T) assert.True(t, mockedService.AssertCalled(tt, "Test_Mock_AssertCalled_WithArguments", 1, 2, 3)) assert.False(t, mockedService.AssertCalled(tt, "Test_Mock_AssertCalled_WithArguments", 2, 3, 4)) } func Test_Mock_AssertCalled_WithArguments_With_Repeatability(t *testing.T) { var mockedService = new(TestExampleImplementation) mockedService.On("Test_Mock_AssertCalled_WithArguments_With_Repeatability", 1, 2, 3).Return(5, 6, 7).Once() mockedService.On("Test_Mock_AssertCalled_WithArguments_With_Repeatability", 2, 3, 4).Return(5, 6, 7).Once() mockedService.Called(1, 2, 3) mockedService.Called(2, 3, 4) tt := new(testing.T) assert.True(t, mockedService.AssertCalled(tt, "Test_Mock_AssertCalled_WithArguments_With_Repeatability", 1, 2, 3)) assert.True(t, mockedService.AssertCalled(tt, "Test_Mock_AssertCalled_WithArguments_With_Repeatability", 2, 3, 4)) assert.False(t, mockedService.AssertCalled(tt, "Test_Mock_AssertCalled_WithArguments_With_Repeatability", 3, 4, 5)) } func Test_Mock_AssertNotCalled(t *testing.T) { var mockedService = new(TestExampleImplementation) mockedService.On("Test_Mock_AssertNotCalled", 1, 2, 3).Return(5, 6, 7) mockedService.Called(1, 2, 3) assert.True(t, mockedService.AssertNotCalled(t, "Test_Mock_NotCalled")) } func Test_Mock_AssertOptional(t *testing.T) { // Optional called var ms1 = new(TestExampleImplementation) ms1.On("TheExampleMethod", 1, 2, 3).Maybe().Return(4, nil) ms1.TheExampleMethod(1, 2, 3) tt1 := new(testing.T) assert.Equal(t, true, ms1.AssertExpectations(tt1)) // Optional not called var ms2 = new(TestExampleImplementation) ms2.On("TheExampleMethod", 1, 2, 3).Maybe().Return(4, nil) tt2 := new(testing.T) assert.Equal(t, true, ms2.AssertExpectations(tt2)) // Non-optional called var ms3 = new(TestExampleImplementation) ms3.On("TheExampleMethod", 1, 2, 3).Return(4, nil) ms3.TheExampleMethod(1, 2, 3) tt3 := new(testing.T) assert.Equal(t, true, ms3.AssertExpectations(tt3)) } /* Arguments helper methods */ func Test_Arguments_Get(t *testing.T) { var args = Arguments([]interface{}{"string", 123, true}) assert.Equal(t, "string", args.Get(0).(string)) assert.Equal(t, 123, args.Get(1).(int)) assert.Equal(t, true, args.Get(2).(bool)) } func Test_Arguments_Is(t *testing.T) { var args = Arguments([]interface{}{"string", 123, true}) assert.True(t, args.Is("string", 123, true)) assert.False(t, args.Is("wrong", 456, false)) } func Test_Arguments_Diff(t *testing.T) { var args = Arguments([]interface{}{"Hello World", 123, true}) var diff string var count int diff, count = args.Diff([]interface{}{"Hello World", 456, "false"}) assert.Equal(t, 2, count) assert.Contains(t, diff, `(int=456) != (int=123)`) assert.Contains(t, diff, `(string=false) != (bool=true)`) } func Test_Arguments_Diff_DifferentNumberOfArgs(t *testing.T) { var args = Arguments([]interface{}{"string", 123, true}) var diff string var count int diff, count = args.Diff([]interface{}{"string", 456, "false", "extra"}) assert.Equal(t, 3, count) assert.Contains(t, diff, `(string=extra) != (Missing)`) } func Test_Arguments_Diff_WithAnythingArgument(t *testing.T) { var args = Arguments([]interface{}{"string", 123, true}) var count int _, count = args.Diff([]interface{}{"string", Anything, true}) assert.Equal(t, 0, count) } func Test_Arguments_Diff_WithAnythingArgument_InActualToo(t *testing.T) { var args = Arguments([]interface{}{"string", Anything, true}) var count int _, count = args.Diff([]interface{}{"string", 123, true}) assert.Equal(t, 0, count) } func Test_Arguments_Diff_WithAnythingOfTypeArgument(t *testing.T) { var args = Arguments([]interface{}{"string", AnythingOfType("int"), true}) var count int _, count = args.Diff([]interface{}{"string", 123, true}) assert.Equal(t, 0, count) } func Test_Arguments_Diff_WithAnythingOfTypeArgument_Failing(t *testing.T) { var args = Arguments([]interface{}{"string", AnythingOfType("string"), true}) var count int var diff string diff, count = args.Diff([]interface{}{"string", 123, true}) assert.Equal(t, 1, count) assert.Contains(t, diff, `string != type int - (int=123)`) } func Test_Arguments_Diff_WithIsTypeArgument(t *testing.T) { var args = Arguments([]interface{}{"string", IsType(0), true}) var count int _, count = args.Diff([]interface{}{"string", 123, true}) assert.Equal(t, 0, count) } func Test_Arguments_Diff_WithIsTypeArgument_Failing(t *testing.T) { var args = Arguments([]interface{}{"string", IsType(""), true}) var count int var diff string diff, count = args.Diff([]interface{}{"string", 123, true}) assert.Equal(t, 1, count) assert.Contains(t, diff, `string != type int - (int=123)`) } func Test_Arguments_Diff_WithArgMatcher(t *testing.T) { matchFn := func(a int) bool { return a == 123 } var args = Arguments([]interface{}{"string", MatchedBy(matchFn), true}) diff, count := args.Diff([]interface{}{"string", 124, true}) assert.Equal(t, 1, count) assert.Contains(t, diff, `(int=124) not matched by func(int) bool`) diff, count = args.Diff([]interface{}{"string", false, true}) assert.Equal(t, 1, count) assert.Contains(t, diff, `(bool=false) not matched by func(int) bool`) diff, count = args.Diff([]interface{}{"string", 123, false}) assert.Contains(t, diff, `(int=123) matched by func(int) bool`) diff, count = args.Diff([]interface{}{"string", 123, true}) assert.Equal(t, 0, count) assert.Contains(t, diff, `No differences.`) } func Test_Arguments_Assert(t *testing.T) { var args = Arguments([]interface{}{"string", 123, true}) assert.True(t, args.Assert(t, "string", 123, true)) } func Test_Arguments_String_Representation(t *testing.T) { var args = Arguments([]interface{}{"string", 123, true}) assert.Equal(t, `string,int,bool`, args.String()) } func Test_Arguments_String(t *testing.T) { var args = Arguments([]interface{}{"string", 123, true}) assert.Equal(t, "string", args.String(0)) } func Test_Arguments_Error(t *testing.T) { var err = errors.New("An Error") var args = Arguments([]interface{}{"string", 123, true, err}) assert.Equal(t, err, args.Error(3)) } func Test_Arguments_Error_Nil(t *testing.T) { var args = Arguments([]interface{}{"string", 123, true, nil}) assert.Equal(t, nil, args.Error(3)) } func Test_Arguments_Int(t *testing.T) { var args = Arguments([]interface{}{"string", 123, true}) assert.Equal(t, 123, args.Int(1)) } func Test_Arguments_Bool(t *testing.T) { var args = Arguments([]interface{}{"string", 123, true}) assert.Equal(t, true, args.Bool(2)) } func Test_WaitUntil_Parallel(t *testing.T) { // make a test impl object var mockedService = new(TestExampleImplementation) ch1 := make(chan time.Time) ch2 := make(chan time.Time) mockedService.Mock.On("TheExampleMethod2", true).Return().WaitUntil(ch2).Run(func(args Arguments) { ch1 <- time.Now() }) mockedService.Mock.On("TheExampleMethod2", false).Return().WaitUntil(ch1) // Lock both goroutines on the .WaitUntil method go func() { mockedService.TheExampleMethod2(false) }() go func() { mockedService.TheExampleMethod2(true) }() // Allow the first call to execute, so the second one executes afterwards ch2 <- time.Now() } func Test_MockMethodCalled(t *testing.T) { m := new(Mock) m.On("foo", "hello").Return("world") retArgs := m.MethodCalled("foo", "hello") require.True(t, len(retArgs) == 1) require.Equal(t, "world", retArgs[0]) m.AssertExpectations(t) } // Test to validate fix for racy concurrent call access in MethodCalled() func Test_MockReturnAndCalledConcurrent(t *testing.T) { iterations := 1000 m := &Mock{} call := m.On("ConcurrencyTestMethod") wg := sync.WaitGroup{} wg.Add(2) go func() { for i := 0; i < iterations; i++ { call.Return(10) } wg.Done() }() go func() { for i := 0; i < iterations; i++ { ConcurrencyTestMethod(m) } wg.Done() }() wg.Wait() } type timer struct{ Mock } func (s *timer) GetTime(i int) string { return s.Called(i).Get(0).(string) } type tCustomLogger struct { *testing.T logs []string errs []string } func (tc *tCustomLogger) Logf(format string, args ...interface{}) { tc.T.Logf(format, args...) tc.logs = append(tc.logs, fmt.Sprintf(format, args...)) } func (tc *tCustomLogger) Errorf(format string, args ...interface{}) { tc.errs = append(tc.errs, fmt.Sprintf(format, args...)) } func (tc *tCustomLogger) FailNow() {} func TestLoggingAssertExpectations(t *testing.T) { m := new(timer) m.On("GetTime", 0).Return("") tcl := &tCustomLogger{t, []string{}, []string{}} AssertExpectationsForObjects(tcl, m, new(TestExampleImplementation)) require.Equal(t, 1, len(tcl.errs)) assert.Regexp(t, regexp.MustCompile("(?s)FAIL: 0 out of 1 expectation\\(s\\) were met.*The code you are testing needs to make 1 more call\\(s\\).*"), tcl.errs[0]) require.Equal(t, 2, len(tcl.logs)) assert.Regexp(t, regexp.MustCompile("(?s)FAIL:\tGetTime\\(int\\).*"), tcl.logs[0]) require.Equal(t, "Expectations didn't match for Mock: *mock.timer", tcl.logs[1]) } func TestAfterTotalWaitTimeWhileExecution(t *testing.T) { waitDuration := 1 total, waitMs := 5, time.Millisecond*time.Duration(waitDuration) aTimer := new(timer) for i := 0; i < total; i++ { aTimer.On("GetTime", i).After(waitMs).Return(fmt.Sprintf("Time%d", i)).Once() } time.Sleep(waitMs) start := time.Now() var results []string for i := 0; i < total; i++ { results = append(results, aTimer.GetTime(i)) } end := time.Now() elapsedTime := end.Sub(start) assert.True(t, elapsedTime > waitMs, fmt.Sprintf("Total elapsed time:%v should be atleast greater than %v", elapsedTime, waitMs)) assert.Equal(t, total, len(results)) for i := range results { assert.Equal(t, fmt.Sprintf("Time%d", i), results[i], "Return value of method should be same") } } func TestArgumentMatcherToPrintMismatch(t *testing.T) { defer func() { if r := recover(); r != nil { matchingExp := regexp.MustCompile( `\s+mock: Unexpected Method Call\s+-*\s+GetTime\(int\)\s+0: 1\s+The closest call I have is:\s+GetTime\(mock.argumentMatcher\)\s+0: mock.argumentMatcher\{.*?\}\s+Diff:.*\(int=1\) not matched by func\(int\) bool`) assert.Regexp(t, matchingExp, r) } }() m := new(timer) m.On("GetTime", MatchedBy(func(i int) bool { return false })).Return("SomeTime").Once() res := m.GetTime(1) require.Equal(t, "SomeTime", res) m.AssertExpectations(t) } func TestClosestCallMismatchedArgumentInformationShowsTheClosest(t *testing.T) { defer func() { if r := recover(); r != nil { matchingExp := regexp.MustCompile(unexpectedCallRegex(`TheExampleMethod(int,int,int)`, `0: 1\s+1: 1\s+2: 2`, `0: 1\s+1: 1\s+2: 1`, `0: PASS: \(int=1\) == \(int=1\)\s+1: PASS: \(int=1\) == \(int=1\)\s+2: FAIL: \(int=2\) != \(int=1\)`)) assert.Regexp(t, matchingExp, r) } }() m := new(TestExampleImplementation) m.On("TheExampleMethod", 1, 1, 1).Return(1, nil).Once() m.On("TheExampleMethod", 2, 2, 2).Return(2, nil).Once() m.TheExampleMethod(1, 1, 2) } func TestClosestCallMismatchedArgumentValueInformation(t *testing.T) { defer func() { if r := recover(); r != nil { matchingExp := regexp.MustCompile(unexpectedCallRegex(`GetTime(int)`, "0: 1", "0: 999", `0: FAIL: \(int=1\) != \(int=999\)`)) assert.Regexp(t, matchingExp, r) } }() m := new(timer) m.On("GetTime", 999).Return("SomeTime").Once() _ = m.GetTime(1) } func unexpectedCallRegex(method, calledArg, expectedArg, diff string) string { rMethod := regexp.QuoteMeta(method) return fmt.Sprintf(`\s+mock: Unexpected Method Call\s+-*\s+%s\s+%s\s+The closest call I have is:\s+%s\s+%s\s+Diff: %s`, rMethod, calledArg, rMethod, expectedArg, diff) } //go:noinline func ConcurrencyTestMethod(m *Mock) { m.Called() } go-jmespath-0.4.0/internal/testify/package_test.go000066400000000000000000000003171373124421700222220ustar00rootroot00000000000000package testify import ( "testing" "github.com/jmespath/go-jmespath/internal/testify/assert" ) func TestImports(t *testing.T) { if assert.Equal(t, 1, 1) != true { t.Error("Something is wrong.") } } go-jmespath-0.4.0/internal/testify/require/000077500000000000000000000000001373124421700207145ustar00rootroot00000000000000go-jmespath-0.4.0/internal/testify/require/doc.go000066400000000000000000000016011373124421700220060ustar00rootroot00000000000000// Package require implements the same assertions as the `assert` package but // stops test execution when a test fails. // // Example Usage // // The following is a complete example using require in a standard test function: // import ( // "testing" // "github.com/jmespath/go-jmespath/internal/testify/require" // ) // // func TestSomething(t *testing.T) { // // var a string = "Hello" // var b string = "Hello" // // require.Equal(t, a, b, "The two words should be the same.") // // } // // Assertions // // The `require` package have same global functions as in the `assert` package, // but instead of returning a boolean result they call `t.FailNow()`. // // Every assertion function also takes an optional string message as the final argument, // allowing custom error messages to be appended to the message the assertion method outputs. package require go-jmespath-0.4.0/internal/testify/require/forward_requirements.go000066400000000000000000000006541373124421700255170ustar00rootroot00000000000000package require // Assertions provides assertion methods around the // TestingT interface. type Assertions struct { t TestingT } // New makes a new Assertions object for the specified TestingT. func New(t TestingT) *Assertions { return &Assertions{ t: t, } } //go:generate sh -c "cd ../_codegen && go build && cd - && ../_codegen/_codegen -output-package=require -template=require_forward.go.tmpl -include-format-funcs" go-jmespath-0.4.0/internal/testify/require/forward_requirements_test.go000066400000000000000000000257511373124421700265630ustar00rootroot00000000000000package require import ( "errors" "testing" "time" ) func TestImplementsWrapper(t *testing.T) { require := New(t) require.Implements((*AssertionTesterInterface)(nil), new(AssertionTesterConformingObject)) mockT := new(MockT) mockRequire := New(mockT) mockRequire.Implements((*AssertionTesterInterface)(nil), new(AssertionTesterNonConformingObject)) if !mockT.Failed { t.Error("Check should fail") } } func TestIsTypeWrapper(t *testing.T) { require := New(t) require.IsType(new(AssertionTesterConformingObject), new(AssertionTesterConformingObject)) mockT := new(MockT) mockRequire := New(mockT) mockRequire.IsType(new(AssertionTesterConformingObject), new(AssertionTesterNonConformingObject)) if !mockT.Failed { t.Error("Check should fail") } } func TestEqualWrapper(t *testing.T) { require := New(t) require.Equal(1, 1) mockT := new(MockT) mockRequire := New(mockT) mockRequire.Equal(1, 2) if !mockT.Failed { t.Error("Check should fail") } } func TestNotEqualWrapper(t *testing.T) { require := New(t) require.NotEqual(1, 2) mockT := new(MockT) mockRequire := New(mockT) mockRequire.NotEqual(2, 2) if !mockT.Failed { t.Error("Check should fail") } } func TestExactlyWrapper(t *testing.T) { require := New(t) a := float32(1) b := float32(1) c := float64(1) require.Exactly(a, b) mockT := new(MockT) mockRequire := New(mockT) mockRequire.Exactly(a, c) if !mockT.Failed { t.Error("Check should fail") } } func TestNotNilWrapper(t *testing.T) { require := New(t) require.NotNil(t, new(AssertionTesterConformingObject)) mockT := new(MockT) mockRequire := New(mockT) mockRequire.NotNil(nil) if !mockT.Failed { t.Error("Check should fail") } } func TestNilWrapper(t *testing.T) { require := New(t) require.Nil(nil) mockT := new(MockT) mockRequire := New(mockT) mockRequire.Nil(new(AssertionTesterConformingObject)) if !mockT.Failed { t.Error("Check should fail") } } func TestTrueWrapper(t *testing.T) { require := New(t) require.True(true) mockT := new(MockT) mockRequire := New(mockT) mockRequire.True(false) if !mockT.Failed { t.Error("Check should fail") } } func TestFalseWrapper(t *testing.T) { require := New(t) require.False(false) mockT := new(MockT) mockRequire := New(mockT) mockRequire.False(true) if !mockT.Failed { t.Error("Check should fail") } } func TestContainsWrapper(t *testing.T) { require := New(t) require.Contains("Hello World", "Hello") mockT := new(MockT) mockRequire := New(mockT) mockRequire.Contains("Hello World", "Salut") if !mockT.Failed { t.Error("Check should fail") } } func TestNotContainsWrapper(t *testing.T) { require := New(t) require.NotContains("Hello World", "Hello!") mockT := new(MockT) mockRequire := New(mockT) mockRequire.NotContains("Hello World", "Hello") if !mockT.Failed { t.Error("Check should fail") } } func TestPanicsWrapper(t *testing.T) { require := New(t) require.Panics(func() { panic("Panic!") }) mockT := new(MockT) mockRequire := New(mockT) mockRequire.Panics(func() {}) if !mockT.Failed { t.Error("Check should fail") } } func TestNotPanicsWrapper(t *testing.T) { require := New(t) require.NotPanics(func() {}) mockT := new(MockT) mockRequire := New(mockT) mockRequire.NotPanics(func() { panic("Panic!") }) if !mockT.Failed { t.Error("Check should fail") } } func TestNoErrorWrapper(t *testing.T) { require := New(t) require.NoError(nil) mockT := new(MockT) mockRequire := New(mockT) mockRequire.NoError(errors.New("some error")) if !mockT.Failed { t.Error("Check should fail") } } func TestErrorWrapper(t *testing.T) { require := New(t) require.Error(errors.New("some error")) mockT := new(MockT) mockRequire := New(mockT) mockRequire.Error(nil) if !mockT.Failed { t.Error("Check should fail") } } func TestEqualErrorWrapper(t *testing.T) { require := New(t) require.EqualError(errors.New("some error"), "some error") mockT := new(MockT) mockRequire := New(mockT) mockRequire.EqualError(errors.New("some error"), "Not some error") if !mockT.Failed { t.Error("Check should fail") } } func TestEmptyWrapper(t *testing.T) { require := New(t) require.Empty("") mockT := new(MockT) mockRequire := New(mockT) mockRequire.Empty("x") if !mockT.Failed { t.Error("Check should fail") } } func TestNotEmptyWrapper(t *testing.T) { require := New(t) require.NotEmpty("x") mockT := new(MockT) mockRequire := New(mockT) mockRequire.NotEmpty("") if !mockT.Failed { t.Error("Check should fail") } } func TestWithinDurationWrapper(t *testing.T) { require := New(t) a := time.Now() b := a.Add(10 * time.Second) require.WithinDuration(a, b, 15*time.Second) mockT := new(MockT) mockRequire := New(mockT) mockRequire.WithinDuration(a, b, 5*time.Second) if !mockT.Failed { t.Error("Check should fail") } } func TestInDeltaWrapper(t *testing.T) { require := New(t) require.InDelta(1.001, 1, 0.01) mockT := new(MockT) mockRequire := New(mockT) mockRequire.InDelta(1, 2, 0.5) if !mockT.Failed { t.Error("Check should fail") } } func TestZeroWrapper(t *testing.T) { require := New(t) require.Zero(0) mockT := new(MockT) mockRequire := New(mockT) mockRequire.Zero(1) if !mockT.Failed { t.Error("Check should fail") } } func TestNotZeroWrapper(t *testing.T) { require := New(t) require.NotZero(1) mockT := new(MockT) mockRequire := New(mockT) mockRequire.NotZero(0) if !mockT.Failed { t.Error("Check should fail") } } func TestJSONEqWrapper_EqualSONString(t *testing.T) { mockT := new(MockT) mockRequire := New(mockT) mockRequire.JSONEq(`{"hello": "world", "foo": "bar"}`, `{"hello": "world", "foo": "bar"}`) if mockT.Failed { t.Error("Check should pass") } } func TestJSONEqWrapper_EquivalentButNotEqual(t *testing.T) { mockT := new(MockT) mockRequire := New(mockT) mockRequire.JSONEq(`{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`) if mockT.Failed { t.Error("Check should pass") } } func TestJSONEqWrapper_HashOfArraysAndHashes(t *testing.T) { mockT := new(MockT) mockRequire := New(mockT) mockRequire.JSONEq("{\r\n\t\"numeric\": 1.5,\r\n\t\"array\": [{\"foo\": \"bar\"}, 1, \"string\", [\"nested\", \"array\", 5.5]],\r\n\t\"hash\": {\"nested\": \"hash\", \"nested_slice\": [\"this\", \"is\", \"nested\"]},\r\n\t\"string\": \"foo\"\r\n}", "{\r\n\t\"numeric\": 1.5,\r\n\t\"hash\": {\"nested\": \"hash\", \"nested_slice\": [\"this\", \"is\", \"nested\"]},\r\n\t\"string\": \"foo\",\r\n\t\"array\": [{\"foo\": \"bar\"}, 1, \"string\", [\"nested\", \"array\", 5.5]]\r\n}") if mockT.Failed { t.Error("Check should pass") } } func TestJSONEqWrapper_Array(t *testing.T) { mockT := new(MockT) mockRequire := New(mockT) mockRequire.JSONEq(`["foo", {"hello": "world", "nested": "hash"}]`, `["foo", {"nested": "hash", "hello": "world"}]`) if mockT.Failed { t.Error("Check should pass") } } func TestJSONEqWrapper_HashAndArrayNotEquivalent(t *testing.T) { mockT := new(MockT) mockRequire := New(mockT) mockRequire.JSONEq(`["foo", {"hello": "world", "nested": "hash"}]`, `{"foo": "bar", {"nested": "hash", "hello": "world"}}`) if !mockT.Failed { t.Error("Check should fail") } } func TestJSONEqWrapper_HashesNotEquivalent(t *testing.T) { mockT := new(MockT) mockRequire := New(mockT) mockRequire.JSONEq(`{"foo": "bar"}`, `{"foo": "bar", "hello": "world"}`) if !mockT.Failed { t.Error("Check should fail") } } func TestJSONEqWrapper_ActualIsNotJSON(t *testing.T) { mockT := new(MockT) mockRequire := New(mockT) mockRequire.JSONEq(`{"foo": "bar"}`, "Not JSON") if !mockT.Failed { t.Error("Check should fail") } } func TestJSONEqWrapper_ExpectedIsNotJSON(t *testing.T) { mockT := new(MockT) mockRequire := New(mockT) mockRequire.JSONEq("Not JSON", `{"foo": "bar", "hello": "world"}`) if !mockT.Failed { t.Error("Check should fail") } } func TestJSONEqWrapper_ExpectedAndActualNotJSON(t *testing.T) { mockT := new(MockT) mockRequire := New(mockT) mockRequire.JSONEq("Not JSON", "Not JSON") if !mockT.Failed { t.Error("Check should fail") } } func TestJSONEqWrapper_ArraysOfDifferentOrder(t *testing.T) { mockT := new(MockT) mockRequire := New(mockT) mockRequire.JSONEq(`["foo", {"hello": "world", "nested": "hash"}]`, `[{ "hello": "world", "nested": "hash"}, "foo"]`) if !mockT.Failed { t.Error("Check should fail") } } func TestYAMLEqWrapper_EqualYAMLString(t *testing.T) { mockT := new(MockT) mockRequire := New(mockT) mockRequire.YAMLEq(`{"hello": "world", "foo": "bar"}`, `{"hello": "world", "foo": "bar"}`) if mockT.Failed { t.Error("Check should pass") } } func TestYAMLEqWrapper_EquivalentButNotEqual(t *testing.T) { mockT := new(MockT) mockRequire := New(mockT) mockRequire.YAMLEq(`{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`) if mockT.Failed { t.Error("Check should pass") } } func TestYAMLEqWrapper_HashOfArraysAndHashes(t *testing.T) { mockT := new(MockT) mockRequire := New(mockT) expected := ` numeric: 1.5 array: - foo: bar - 1 - "string" - ["nested", "array", 5.5] hash: nested: hash nested_slice: [this, is, nested] string: "foo" ` actual := ` numeric: 1.5 hash: nested: hash nested_slice: [this, is, nested] string: "foo" array: - foo: bar - 1 - "string" - ["nested", "array", 5.5] ` mockRequire.YAMLEq(expected, actual) if mockT.Failed { t.Error("Check should pass") } } func TestYAMLEqWrapper_Array(t *testing.T) { mockT := new(MockT) mockRequire := New(mockT) mockRequire.YAMLEq(`["foo", {"hello": "world", "nested": "hash"}]`, `["foo", {"nested": "hash", "hello": "world"}]`) if mockT.Failed { t.Error("Check should pass") } } func TestYAMLEqWrapper_HashAndArrayNotEquivalent(t *testing.T) { mockT := new(MockT) mockRequire := New(mockT) mockRequire.YAMLEq(`["foo", {"hello": "world", "nested": "hash"}]`, `{"foo": "bar", {"nested": "hash", "hello": "world"}}`) if !mockT.Failed { t.Error("Check should fail") } } func TestYAMLEqWrapper_HashesNotEquivalent(t *testing.T) { mockT := new(MockT) mockRequire := New(mockT) mockRequire.YAMLEq(`{"foo": "bar"}`, `{"foo": "bar", "hello": "world"}`) if !mockT.Failed { t.Error("Check should fail") } } func TestYAMLEqWrapper_ActualIsSimpleString(t *testing.T) { mockT := new(MockT) mockRequire := New(mockT) mockRequire.YAMLEq(`{"foo": "bar"}`, "Simple String") if !mockT.Failed { t.Error("Check should fail") } } func TestYAMLEqWrapper_ExpectedIsSimpleString(t *testing.T) { mockT := new(MockT) mockRequire := New(mockT) mockRequire.YAMLEq("Simple String", `{"foo": "bar", "hello": "world"}`) if !mockT.Failed { t.Error("Check should fail") } } func TestYAMLEqWrapper_ExpectedAndActualSimpleString(t *testing.T) { mockT := new(MockT) mockRequire := New(mockT) mockRequire.YAMLEq("Simple String", "Simple String") if mockT.Failed { t.Error("Check should pass") } } func TestYAMLEqWrapper_ArraysOfDifferentOrder(t *testing.T) { mockT := new(MockT) mockRequire := New(mockT) mockRequire.YAMLEq(`["foo", {"hello": "world", "nested": "hash"}]`, `[{ "hello": "world", "nested": "hash"}, "foo"]`) if !mockT.Failed { t.Error("Check should fail") } } go-jmespath-0.4.0/internal/testify/require/require.go000066400000000000000000001347301373124421700227270ustar00rootroot00000000000000/* * CODE GENERATED AUTOMATICALLY WITH github.com/jmespath/go-jmespath/internal/testify/_codegen * THIS FILE MUST NOT BE EDITED BY HAND */ package require import ( assert "github.com/jmespath/go-jmespath/internal/testify/assert" http "net/http" url "net/url" time "time" ) // Condition uses a Comparison to assert a complex condition. func Condition(t TestingT, comp assert.Comparison, msgAndArgs ...interface{}) { if h, ok := t.(tHelper); ok { h.Helper() } if assert.Condition(t, comp, msgAndArgs...) { return } t.FailNow() } // Conditionf uses a Comparison to assert a complex condition. func Conditionf(t TestingT, comp assert.Comparison, msg string, args ...interface{}) { if h, ok := t.(tHelper); ok { h.Helper() } if assert.Conditionf(t, comp, msg, args...) { return } t.FailNow() } // Contains asserts that the specified string, list(array, slice...) or map contains the // specified substring or element. // // assert.Contains(t, "Hello World", "World") // assert.Contains(t, ["Hello", "World"], "World") // assert.Contains(t, {"Hello": "World"}, "Hello") func Contains(t TestingT, s interface{}, contains interface{}, msgAndArgs ...interface{}) { if h, ok := t.(tHelper); ok { h.Helper() } if assert.Contains(t, s, contains, msgAndArgs...) { return } t.FailNow() } // Containsf asserts that the specified string, list(array, slice...) or map contains the // specified substring or element. // // assert.Containsf(t, "Hello World", "World", "error message %s", "formatted") // assert.Containsf(t, ["Hello", "World"], "World", "error message %s", "formatted") // assert.Containsf(t, {"Hello": "World"}, "Hello", "error message %s", "formatted") func Containsf(t TestingT, s interface{}, contains interface{}, msg string, args ...interface{}) { if h, ok := t.(tHelper); ok { h.Helper() } if assert.Containsf(t, s, contains, msg, args...) { return } t.FailNow() } // DirExists checks whether a directory exists in the given path. It also fails // if the path is a file rather a directory or there is an error checking whether it exists. func DirExists(t TestingT, path string, msgAndArgs ...interface{}) { if h, ok := t.(tHelper); ok { h.Helper() } if assert.DirExists(t, path, msgAndArgs...) { return } t.FailNow() } // DirExistsf checks whether a directory exists in the given path. It also fails // if the path is a file rather a directory or there is an error checking whether it exists. func DirExistsf(t TestingT, path string, msg string, args ...interface{}) { if h, ok := t.(tHelper); ok { h.Helper() } if assert.DirExistsf(t, path, msg, args...) { return } t.FailNow() } // ElementsMatch asserts that the specified listA(array, slice...) is equal to specified // listB(array, slice...) ignoring the order of the elements. If there are duplicate elements, // the number of appearances of each of them in both lists should match. // // assert.ElementsMatch(t, [1, 3, 2, 3], [1, 3, 3, 2]) func ElementsMatch(t TestingT, listA interface{}, listB interface{}, msgAndArgs ...interface{}) { if h, ok := t.(tHelper); ok { h.Helper() } if assert.ElementsMatch(t, listA, listB, msgAndArgs...) { return } t.FailNow() } // ElementsMatchf asserts that the specified listA(array, slice...) is equal to specified // listB(array, slice...) ignoring the order of the elements. If there are duplicate elements, // the number of appearances of each of them in both lists should match. // // assert.ElementsMatchf(t, [1, 3, 2, 3], [1, 3, 3, 2], "error message %s", "formatted") func ElementsMatchf(t TestingT, listA interface{}, listB interface{}, msg string, args ...interface{}) { if h, ok := t.(tHelper); ok { h.Helper() } if assert.ElementsMatchf(t, listA, listB, msg, args...) { return } t.FailNow() } // Empty asserts that the specified object is empty. I.e. nil, "", false, 0 or either // a slice or a channel with len == 0. // // assert.Empty(t, obj) func Empty(t TestingT, object interface{}, msgAndArgs ...interface{}) { if h, ok := t.(tHelper); ok { h.Helper() } if assert.Empty(t, object, msgAndArgs...) { return } t.FailNow() } // Emptyf asserts that the specified object is empty. I.e. nil, "", false, 0 or either // a slice or a channel with len == 0. // // assert.Emptyf(t, obj, "error message %s", "formatted") func Emptyf(t TestingT, object interface{}, msg string, args ...interface{}) { if h, ok := t.(tHelper); ok { h.Helper() } if assert.Emptyf(t, object, msg, args...) { return } t.FailNow() } // Equal asserts that two objects are equal. // // assert.Equal(t, 123, 123) // // Pointer variable equality is determined based on the equality of the // referenced values (as opposed to the memory addresses). Function equality // cannot be determined and will always fail. func Equal(t TestingT, expected interface{}, actual interface{}, msgAndArgs ...interface{}) { if h, ok := t.(tHelper); ok { h.Helper() } if assert.Equal(t, expected, actual, msgAndArgs...) { return } t.FailNow() } // EqualError asserts that a function returned an error (i.e. not `nil`) // and that it is equal to the provided error. // // actualObj, err := SomeFunction() // assert.EqualError(t, err, expectedErrorString) func EqualError(t TestingT, theError error, errString string, msgAndArgs ...interface{}) { if h, ok := t.(tHelper); ok { h.Helper() } if assert.EqualError(t, theError, errString, msgAndArgs...) { return } t.FailNow() } // EqualErrorf asserts that a function returned an error (i.e. not `nil`) // and that it is equal to the provided error. // // actualObj, err := SomeFunction() // assert.EqualErrorf(t, err, expectedErrorString, "error message %s", "formatted") func EqualErrorf(t TestingT, theError error, errString string, msg string, args ...interface{}) { if h, ok := t.(tHelper); ok { h.Helper() } if assert.EqualErrorf(t, theError, errString, msg, args...) { return } t.FailNow() } // EqualValues asserts that two objects are equal or convertable to the same types // and equal. // // assert.EqualValues(t, uint32(123), int32(123)) func EqualValues(t TestingT, expected interface{}, actual interface{}, msgAndArgs ...interface{}) { if h, ok := t.(tHelper); ok { h.Helper() } if assert.EqualValues(t, expected, actual, msgAndArgs...) { return } t.FailNow() } // EqualValuesf asserts that two objects are equal or convertable to the same types // and equal. // // assert.EqualValuesf(t, uint32(123, "error message %s", "formatted"), int32(123)) func EqualValuesf(t TestingT, expected interface{}, actual interface{}, msg string, args ...interface{}) { if h, ok := t.(tHelper); ok { h.Helper() } if assert.EqualValuesf(t, expected, actual, msg, args...) { return } t.FailNow() } // Equalf asserts that two objects are equal. // // assert.Equalf(t, 123, 123, "error message %s", "formatted") // // Pointer variable equality is determined based on the equality of the // referenced values (as opposed to the memory addresses). Function equality // cannot be determined and will always fail. func Equalf(t TestingT, expected interface{}, actual interface{}, msg string, args ...interface{}) { if h, ok := t.(tHelper); ok { h.Helper() } if assert.Equalf(t, expected, actual, msg, args...) { return } t.FailNow() } // Error asserts that a function returned an error (i.e. not `nil`). // // actualObj, err := SomeFunction() // if assert.Error(t, err) { // assert.Equal(t, expectedError, err) // } func Error(t TestingT, err error, msgAndArgs ...interface{}) { if h, ok := t.(tHelper); ok { h.Helper() } if assert.Error(t, err, msgAndArgs...) { return } t.FailNow() } // Errorf asserts that a function returned an error (i.e. not `nil`). // // actualObj, err := SomeFunction() // if assert.Errorf(t, err, "error message %s", "formatted") { // assert.Equal(t, expectedErrorf, err) // } func Errorf(t TestingT, err error, msg string, args ...interface{}) { if h, ok := t.(tHelper); ok { h.Helper() } if assert.Errorf(t, err, msg, args...) { return } t.FailNow() } // Eventually asserts that given condition will be met in waitFor time, // periodically checking target function each tick. // // assert.Eventually(t, func() bool { return true; }, time.Second, 10*time.Millisecond) func Eventually(t TestingT, condition func() bool, waitFor time.Duration, tick time.Duration, msgAndArgs ...interface{}) { if h, ok := t.(tHelper); ok { h.Helper() } if assert.Eventually(t, condition, waitFor, tick, msgAndArgs...) { return } t.FailNow() } // Eventuallyf asserts that given condition will be met in waitFor time, // periodically checking target function each tick. // // assert.Eventuallyf(t, func() bool { return true; }, time.Second, 10*time.Millisecond, "error message %s", "formatted") func Eventuallyf(t TestingT, condition func() bool, waitFor time.Duration, tick time.Duration, msg string, args ...interface{}) { if h, ok := t.(tHelper); ok { h.Helper() } if assert.Eventuallyf(t, condition, waitFor, tick, msg, args...) { return } t.FailNow() } // Exactly asserts that two objects are equal in value and type. // // assert.Exactly(t, int32(123), int64(123)) func Exactly(t TestingT, expected interface{}, actual interface{}, msgAndArgs ...interface{}) { if h, ok := t.(tHelper); ok { h.Helper() } if assert.Exactly(t, expected, actual, msgAndArgs...) { return } t.FailNow() } // Exactlyf asserts that two objects are equal in value and type. // // assert.Exactlyf(t, int32(123, "error message %s", "formatted"), int64(123)) func Exactlyf(t TestingT, expected interface{}, actual interface{}, msg string, args ...interface{}) { if h, ok := t.(tHelper); ok { h.Helper() } if assert.Exactlyf(t, expected, actual, msg, args...) { return } t.FailNow() } // Fail reports a failure through func Fail(t TestingT, failureMessage string, msgAndArgs ...interface{}) { if h, ok := t.(tHelper); ok { h.Helper() } if assert.Fail(t, failureMessage, msgAndArgs...) { return } t.FailNow() } // FailNow fails test func FailNow(t TestingT, failureMessage string, msgAndArgs ...interface{}) { if h, ok := t.(tHelper); ok { h.Helper() } if assert.FailNow(t, failureMessage, msgAndArgs...) { return } t.FailNow() } // FailNowf fails test func FailNowf(t TestingT, failureMessage string, msg string, args ...interface{}) { if h, ok := t.(tHelper); ok { h.Helper() } if assert.FailNowf(t, failureMessage, msg, args...) { return } t.FailNow() } // Failf reports a failure through func Failf(t TestingT, failureMessage string, msg string, args ...interface{}) { if h, ok := t.(tHelper); ok { h.Helper() } if assert.Failf(t, failureMessage, msg, args...) { return } t.FailNow() } // False asserts that the specified value is false. // // assert.False(t, myBool) func False(t TestingT, value bool, msgAndArgs ...interface{}) { if h, ok := t.(tHelper); ok { h.Helper() } if assert.False(t, value, msgAndArgs...) { return } t.FailNow() } // Falsef asserts that the specified value is false. // // assert.Falsef(t, myBool, "error message %s", "formatted") func Falsef(t TestingT, value bool, msg string, args ...interface{}) { if h, ok := t.(tHelper); ok { h.Helper() } if assert.Falsef(t, value, msg, args...) { return } t.FailNow() } // FileExists checks whether a file exists in the given path. It also fails if // the path points to a directory or there is an error when trying to check the file. func FileExists(t TestingT, path string, msgAndArgs ...interface{}) { if h, ok := t.(tHelper); ok { h.Helper() } if assert.FileExists(t, path, msgAndArgs...) { return } t.FailNow() } // FileExistsf checks whether a file exists in the given path. It also fails if // the path points to a directory or there is an error when trying to check the file. func FileExistsf(t TestingT, path string, msg string, args ...interface{}) { if h, ok := t.(tHelper); ok { h.Helper() } if assert.FileExistsf(t, path, msg, args...) { return } t.FailNow() } // Greater asserts that the first element is greater than the second // // assert.Greater(t, 2, 1) // assert.Greater(t, float64(2), float64(1)) // assert.Greater(t, "b", "a") func Greater(t TestingT, e1 interface{}, e2 interface{}, msgAndArgs ...interface{}) { if h, ok := t.(tHelper); ok { h.Helper() } if assert.Greater(t, e1, e2, msgAndArgs...) { return } t.FailNow() } // GreaterOrEqual asserts that the first element is greater than or equal to the second // // assert.GreaterOrEqual(t, 2, 1) // assert.GreaterOrEqual(t, 2, 2) // assert.GreaterOrEqual(t, "b", "a") // assert.GreaterOrEqual(t, "b", "b") func GreaterOrEqual(t TestingT, e1 interface{}, e2 interface{}, msgAndArgs ...interface{}) { if h, ok := t.(tHelper); ok { h.Helper() } if assert.GreaterOrEqual(t, e1, e2, msgAndArgs...) { return } t.FailNow() } // GreaterOrEqualf asserts that the first element is greater than or equal to the second // // assert.GreaterOrEqualf(t, 2, 1, "error message %s", "formatted") // assert.GreaterOrEqualf(t, 2, 2, "error message %s", "formatted") // assert.GreaterOrEqualf(t, "b", "a", "error message %s", "formatted") // assert.GreaterOrEqualf(t, "b", "b", "error message %s", "formatted") func GreaterOrEqualf(t TestingT, e1 interface{}, e2 interface{}, msg string, args ...interface{}) { if h, ok := t.(tHelper); ok { h.Helper() } if assert.GreaterOrEqualf(t, e1, e2, msg, args...) { return } t.FailNow() } // Greaterf asserts that the first element is greater than the second // // assert.Greaterf(t, 2, 1, "error message %s", "formatted") // assert.Greaterf(t, float64(2, "error message %s", "formatted"), float64(1)) // assert.Greaterf(t, "b", "a", "error message %s", "formatted") func Greaterf(t TestingT, e1 interface{}, e2 interface{}, msg string, args ...interface{}) { if h, ok := t.(tHelper); ok { h.Helper() } if assert.Greaterf(t, e1, e2, msg, args...) { return } t.FailNow() } // HTTPBodyContains asserts that a specified handler returns a // body that contains a string. // // assert.HTTPBodyContains(t, myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky") // // Returns whether the assertion was successful (true) or not (false). func HTTPBodyContains(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msgAndArgs ...interface{}) { if h, ok := t.(tHelper); ok { h.Helper() } if assert.HTTPBodyContains(t, handler, method, url, values, str, msgAndArgs...) { return } t.FailNow() } // HTTPBodyContainsf asserts that a specified handler returns a // body that contains a string. // // assert.HTTPBodyContainsf(t, myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky", "error message %s", "formatted") // // Returns whether the assertion was successful (true) or not (false). func HTTPBodyContainsf(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msg string, args ...interface{}) { if h, ok := t.(tHelper); ok { h.Helper() } if assert.HTTPBodyContainsf(t, handler, method, url, values, str, msg, args...) { return } t.FailNow() } // HTTPBodyNotContains asserts that a specified handler returns a // body that does not contain a string. // // assert.HTTPBodyNotContains(t, myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky") // // Returns whether the assertion was successful (true) or not (false). func HTTPBodyNotContains(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msgAndArgs ...interface{}) { if h, ok := t.(tHelper); ok { h.Helper() } if assert.HTTPBodyNotContains(t, handler, method, url, values, str, msgAndArgs...) { return } t.FailNow() } // HTTPBodyNotContainsf asserts that a specified handler returns a // body that does not contain a string. // // assert.HTTPBodyNotContainsf(t, myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky", "error message %s", "formatted") // // Returns whether the assertion was successful (true) or not (false). func HTTPBodyNotContainsf(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msg string, args ...interface{}) { if h, ok := t.(tHelper); ok { h.Helper() } if assert.HTTPBodyNotContainsf(t, handler, method, url, values, str, msg, args...) { return } t.FailNow() } // HTTPError asserts that a specified handler returns an error status code. // // assert.HTTPError(t, myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}} // // Returns whether the assertion was successful (true) or not (false). func HTTPError(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, msgAndArgs ...interface{}) { if h, ok := t.(tHelper); ok { h.Helper() } if assert.HTTPError(t, handler, method, url, values, msgAndArgs...) { return } t.FailNow() } // HTTPErrorf asserts that a specified handler returns an error status code. // // assert.HTTPErrorf(t, myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}} // // Returns whether the assertion was successful (true, "error message %s", "formatted") or not (false). func HTTPErrorf(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, msg string, args ...interface{}) { if h, ok := t.(tHelper); ok { h.Helper() } if assert.HTTPErrorf(t, handler, method, url, values, msg, args...) { return } t.FailNow() } // HTTPRedirect asserts that a specified handler returns a redirect status code. // // assert.HTTPRedirect(t, myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}} // // Returns whether the assertion was successful (true) or not (false). func HTTPRedirect(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, msgAndArgs ...interface{}) { if h, ok := t.(tHelper); ok { h.Helper() } if assert.HTTPRedirect(t, handler, method, url, values, msgAndArgs...) { return } t.FailNow() } // HTTPRedirectf asserts that a specified handler returns a redirect status code. // // assert.HTTPRedirectf(t, myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}} // // Returns whether the assertion was successful (true, "error message %s", "formatted") or not (false). func HTTPRedirectf(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, msg string, args ...interface{}) { if h, ok := t.(tHelper); ok { h.Helper() } if assert.HTTPRedirectf(t, handler, method, url, values, msg, args...) { return } t.FailNow() } // HTTPSuccess asserts that a specified handler returns a success status code. // // assert.HTTPSuccess(t, myHandler, "POST", "http://www.google.com", nil) // // Returns whether the assertion was successful (true) or not (false). func HTTPSuccess(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, msgAndArgs ...interface{}) { if h, ok := t.(tHelper); ok { h.Helper() } if assert.HTTPSuccess(t, handler, method, url, values, msgAndArgs...) { return } t.FailNow() } // HTTPSuccessf asserts that a specified handler returns a success status code. // // assert.HTTPSuccessf(t, myHandler, "POST", "http://www.google.com", nil, "error message %s", "formatted") // // Returns whether the assertion was successful (true) or not (false). func HTTPSuccessf(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, msg string, args ...interface{}) { if h, ok := t.(tHelper); ok { h.Helper() } if assert.HTTPSuccessf(t, handler, method, url, values, msg, args...) { return } t.FailNow() } // Implements asserts that an object is implemented by the specified interface. // // assert.Implements(t, (*MyInterface)(nil), new(MyObject)) func Implements(t TestingT, interfaceObject interface{}, object interface{}, msgAndArgs ...interface{}) { if h, ok := t.(tHelper); ok { h.Helper() } if assert.Implements(t, interfaceObject, object, msgAndArgs...) { return } t.FailNow() } // Implementsf asserts that an object is implemented by the specified interface. // // assert.Implementsf(t, (*MyInterface, "error message %s", "formatted")(nil), new(MyObject)) func Implementsf(t TestingT, interfaceObject interface{}, object interface{}, msg string, args ...interface{}) { if h, ok := t.(tHelper); ok { h.Helper() } if assert.Implementsf(t, interfaceObject, object, msg, args...) { return } t.FailNow() } // InDelta asserts that the two numerals are within delta of each other. // // assert.InDelta(t, math.Pi, 22/7.0, 0.01) func InDelta(t TestingT, expected interface{}, actual interface{}, delta float64, msgAndArgs ...interface{}) { if h, ok := t.(tHelper); ok { h.Helper() } if assert.InDelta(t, expected, actual, delta, msgAndArgs...) { return } t.FailNow() } // InDeltaMapValues is the same as InDelta, but it compares all values between two maps. Both maps must have exactly the same keys. func InDeltaMapValues(t TestingT, expected interface{}, actual interface{}, delta float64, msgAndArgs ...interface{}) { if h, ok := t.(tHelper); ok { h.Helper() } if assert.InDeltaMapValues(t, expected, actual, delta, msgAndArgs...) { return } t.FailNow() } // InDeltaMapValuesf is the same as InDelta, but it compares all values between two maps. Both maps must have exactly the same keys. func InDeltaMapValuesf(t TestingT, expected interface{}, actual interface{}, delta float64, msg string, args ...interface{}) { if h, ok := t.(tHelper); ok { h.Helper() } if assert.InDeltaMapValuesf(t, expected, actual, delta, msg, args...) { return } t.FailNow() } // InDeltaSlice is the same as InDelta, except it compares two slices. func InDeltaSlice(t TestingT, expected interface{}, actual interface{}, delta float64, msgAndArgs ...interface{}) { if h, ok := t.(tHelper); ok { h.Helper() } if assert.InDeltaSlice(t, expected, actual, delta, msgAndArgs...) { return } t.FailNow() } // InDeltaSlicef is the same as InDelta, except it compares two slices. func InDeltaSlicef(t TestingT, expected interface{}, actual interface{}, delta float64, msg string, args ...interface{}) { if h, ok := t.(tHelper); ok { h.Helper() } if assert.InDeltaSlicef(t, expected, actual, delta, msg, args...) { return } t.FailNow() } // InDeltaf asserts that the two numerals are within delta of each other. // // assert.InDeltaf(t, math.Pi, 22/7.0, 0.01, "error message %s", "formatted") func InDeltaf(t TestingT, expected interface{}, actual interface{}, delta float64, msg string, args ...interface{}) { if h, ok := t.(tHelper); ok { h.Helper() } if assert.InDeltaf(t, expected, actual, delta, msg, args...) { return } t.FailNow() } // InEpsilon asserts that expected and actual have a relative error less than epsilon func InEpsilon(t TestingT, expected interface{}, actual interface{}, epsilon float64, msgAndArgs ...interface{}) { if h, ok := t.(tHelper); ok { h.Helper() } if assert.InEpsilon(t, expected, actual, epsilon, msgAndArgs...) { return } t.FailNow() } // InEpsilonSlice is the same as InEpsilon, except it compares each value from two slices. func InEpsilonSlice(t TestingT, expected interface{}, actual interface{}, epsilon float64, msgAndArgs ...interface{}) { if h, ok := t.(tHelper); ok { h.Helper() } if assert.InEpsilonSlice(t, expected, actual, epsilon, msgAndArgs...) { return } t.FailNow() } // InEpsilonSlicef is the same as InEpsilon, except it compares each value from two slices. func InEpsilonSlicef(t TestingT, expected interface{}, actual interface{}, epsilon float64, msg string, args ...interface{}) { if h, ok := t.(tHelper); ok { h.Helper() } if assert.InEpsilonSlicef(t, expected, actual, epsilon, msg, args...) { return } t.FailNow() } // InEpsilonf asserts that expected and actual have a relative error less than epsilon func InEpsilonf(t TestingT, expected interface{}, actual interface{}, epsilon float64, msg string, args ...interface{}) { if h, ok := t.(tHelper); ok { h.Helper() } if assert.InEpsilonf(t, expected, actual, epsilon, msg, args...) { return } t.FailNow() } // IsType asserts that the specified objects are of the same type. func IsType(t TestingT, expectedType interface{}, object interface{}, msgAndArgs ...interface{}) { if h, ok := t.(tHelper); ok { h.Helper() } if assert.IsType(t, expectedType, object, msgAndArgs...) { return } t.FailNow() } // IsTypef asserts that the specified objects are of the same type. func IsTypef(t TestingT, expectedType interface{}, object interface{}, msg string, args ...interface{}) { if h, ok := t.(tHelper); ok { h.Helper() } if assert.IsTypef(t, expectedType, object, msg, args...) { return } t.FailNow() } // JSONEq asserts that two JSON strings are equivalent. // // assert.JSONEq(t, `{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`) func JSONEq(t TestingT, expected string, actual string, msgAndArgs ...interface{}) { if h, ok := t.(tHelper); ok { h.Helper() } if assert.JSONEq(t, expected, actual, msgAndArgs...) { return } t.FailNow() } // JSONEqf asserts that two JSON strings are equivalent. // // assert.JSONEqf(t, `{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`, "error message %s", "formatted") func JSONEqf(t TestingT, expected string, actual string, msg string, args ...interface{}) { if h, ok := t.(tHelper); ok { h.Helper() } if assert.JSONEqf(t, expected, actual, msg, args...) { return } t.FailNow() } // Len asserts that the specified object has specific length. // Len also fails if the object has a type that len() not accept. // // assert.Len(t, mySlice, 3) func Len(t TestingT, object interface{}, length int, msgAndArgs ...interface{}) { if h, ok := t.(tHelper); ok { h.Helper() } if assert.Len(t, object, length, msgAndArgs...) { return } t.FailNow() } // Lenf asserts that the specified object has specific length. // Lenf also fails if the object has a type that len() not accept. // // assert.Lenf(t, mySlice, 3, "error message %s", "formatted") func Lenf(t TestingT, object interface{}, length int, msg string, args ...interface{}) { if h, ok := t.(tHelper); ok { h.Helper() } if assert.Lenf(t, object, length, msg, args...) { return } t.FailNow() } // Less asserts that the first element is less than the second // // assert.Less(t, 1, 2) // assert.Less(t, float64(1), float64(2)) // assert.Less(t, "a", "b") func Less(t TestingT, e1 interface{}, e2 interface{}, msgAndArgs ...interface{}) { if h, ok := t.(tHelper); ok { h.Helper() } if assert.Less(t, e1, e2, msgAndArgs...) { return } t.FailNow() } // LessOrEqual asserts that the first element is less than or equal to the second // // assert.LessOrEqual(t, 1, 2) // assert.LessOrEqual(t, 2, 2) // assert.LessOrEqual(t, "a", "b") // assert.LessOrEqual(t, "b", "b") func LessOrEqual(t TestingT, e1 interface{}, e2 interface{}, msgAndArgs ...interface{}) { if h, ok := t.(tHelper); ok { h.Helper() } if assert.LessOrEqual(t, e1, e2, msgAndArgs...) { return } t.FailNow() } // LessOrEqualf asserts that the first element is less than or equal to the second // // assert.LessOrEqualf(t, 1, 2, "error message %s", "formatted") // assert.LessOrEqualf(t, 2, 2, "error message %s", "formatted") // assert.LessOrEqualf(t, "a", "b", "error message %s", "formatted") // assert.LessOrEqualf(t, "b", "b", "error message %s", "formatted") func LessOrEqualf(t TestingT, e1 interface{}, e2 interface{}, msg string, args ...interface{}) { if h, ok := t.(tHelper); ok { h.Helper() } if assert.LessOrEqualf(t, e1, e2, msg, args...) { return } t.FailNow() } // Lessf asserts that the first element is less than the second // // assert.Lessf(t, 1, 2, "error message %s", "formatted") // assert.Lessf(t, float64(1, "error message %s", "formatted"), float64(2)) // assert.Lessf(t, "a", "b", "error message %s", "formatted") func Lessf(t TestingT, e1 interface{}, e2 interface{}, msg string, args ...interface{}) { if h, ok := t.(tHelper); ok { h.Helper() } if assert.Lessf(t, e1, e2, msg, args...) { return } t.FailNow() } // Never asserts that the given condition doesn't satisfy in waitFor time, // periodically checking the target function each tick. // // assert.Never(t, func() bool { return false; }, time.Second, 10*time.Millisecond) func Never(t TestingT, condition func() bool, waitFor time.Duration, tick time.Duration, msgAndArgs ...interface{}) { if h, ok := t.(tHelper); ok { h.Helper() } if assert.Never(t, condition, waitFor, tick, msgAndArgs...) { return } t.FailNow() } // Neverf asserts that the given condition doesn't satisfy in waitFor time, // periodically checking the target function each tick. // // assert.Neverf(t, func() bool { return false; }, time.Second, 10*time.Millisecond, "error message %s", "formatted") func Neverf(t TestingT, condition func() bool, waitFor time.Duration, tick time.Duration, msg string, args ...interface{}) { if h, ok := t.(tHelper); ok { h.Helper() } if assert.Neverf(t, condition, waitFor, tick, msg, args...) { return } t.FailNow() } // Nil asserts that the specified object is nil. // // assert.Nil(t, err) func Nil(t TestingT, object interface{}, msgAndArgs ...interface{}) { if h, ok := t.(tHelper); ok { h.Helper() } if assert.Nil(t, object, msgAndArgs...) { return } t.FailNow() } // Nilf asserts that the specified object is nil. // // assert.Nilf(t, err, "error message %s", "formatted") func Nilf(t TestingT, object interface{}, msg string, args ...interface{}) { if h, ok := t.(tHelper); ok { h.Helper() } if assert.Nilf(t, object, msg, args...) { return } t.FailNow() } // NoDirExists checks whether a directory does not exist in the given path. // It fails if the path points to an existing _directory_ only. func NoDirExists(t TestingT, path string, msgAndArgs ...interface{}) { if h, ok := t.(tHelper); ok { h.Helper() } if assert.NoDirExists(t, path, msgAndArgs...) { return } t.FailNow() } // NoDirExistsf checks whether a directory does not exist in the given path. // It fails if the path points to an existing _directory_ only. func NoDirExistsf(t TestingT, path string, msg string, args ...interface{}) { if h, ok := t.(tHelper); ok { h.Helper() } if assert.NoDirExistsf(t, path, msg, args...) { return } t.FailNow() } // NoError asserts that a function returned no error (i.e. `nil`). // // actualObj, err := SomeFunction() // if assert.NoError(t, err) { // assert.Equal(t, expectedObj, actualObj) // } func NoError(t TestingT, err error, msgAndArgs ...interface{}) { if h, ok := t.(tHelper); ok { h.Helper() } if assert.NoError(t, err, msgAndArgs...) { return } t.FailNow() } // NoErrorf asserts that a function returned no error (i.e. `nil`). // // actualObj, err := SomeFunction() // if assert.NoErrorf(t, err, "error message %s", "formatted") { // assert.Equal(t, expectedObj, actualObj) // } func NoErrorf(t TestingT, err error, msg string, args ...interface{}) { if h, ok := t.(tHelper); ok { h.Helper() } if assert.NoErrorf(t, err, msg, args...) { return } t.FailNow() } // NoFileExists checks whether a file does not exist in a given path. It fails // if the path points to an existing _file_ only. func NoFileExists(t TestingT, path string, msgAndArgs ...interface{}) { if h, ok := t.(tHelper); ok { h.Helper() } if assert.NoFileExists(t, path, msgAndArgs...) { return } t.FailNow() } // NoFileExistsf checks whether a file does not exist in a given path. It fails // if the path points to an existing _file_ only. func NoFileExistsf(t TestingT, path string, msg string, args ...interface{}) { if h, ok := t.(tHelper); ok { h.Helper() } if assert.NoFileExistsf(t, path, msg, args...) { return } t.FailNow() } // NotContains asserts that the specified string, list(array, slice...) or map does NOT contain the // specified substring or element. // // assert.NotContains(t, "Hello World", "Earth") // assert.NotContains(t, ["Hello", "World"], "Earth") // assert.NotContains(t, {"Hello": "World"}, "Earth") func NotContains(t TestingT, s interface{}, contains interface{}, msgAndArgs ...interface{}) { if h, ok := t.(tHelper); ok { h.Helper() } if assert.NotContains(t, s, contains, msgAndArgs...) { return } t.FailNow() } // NotContainsf asserts that the specified string, list(array, slice...) or map does NOT contain the // specified substring or element. // // assert.NotContainsf(t, "Hello World", "Earth", "error message %s", "formatted") // assert.NotContainsf(t, ["Hello", "World"], "Earth", "error message %s", "formatted") // assert.NotContainsf(t, {"Hello": "World"}, "Earth", "error message %s", "formatted") func NotContainsf(t TestingT, s interface{}, contains interface{}, msg string, args ...interface{}) { if h, ok := t.(tHelper); ok { h.Helper() } if assert.NotContainsf(t, s, contains, msg, args...) { return } t.FailNow() } // NotEmpty asserts that the specified object is NOT empty. I.e. not nil, "", false, 0 or either // a slice or a channel with len == 0. // // if assert.NotEmpty(t, obj) { // assert.Equal(t, "two", obj[1]) // } func NotEmpty(t TestingT, object interface{}, msgAndArgs ...interface{}) { if h, ok := t.(tHelper); ok { h.Helper() } if assert.NotEmpty(t, object, msgAndArgs...) { return } t.FailNow() } // NotEmptyf asserts that the specified object is NOT empty. I.e. not nil, "", false, 0 or either // a slice or a channel with len == 0. // // if assert.NotEmptyf(t, obj, "error message %s", "formatted") { // assert.Equal(t, "two", obj[1]) // } func NotEmptyf(t TestingT, object interface{}, msg string, args ...interface{}) { if h, ok := t.(tHelper); ok { h.Helper() } if assert.NotEmptyf(t, object, msg, args...) { return } t.FailNow() } // NotEqual asserts that the specified values are NOT equal. // // assert.NotEqual(t, obj1, obj2) // // Pointer variable equality is determined based on the equality of the // referenced values (as opposed to the memory addresses). func NotEqual(t TestingT, expected interface{}, actual interface{}, msgAndArgs ...interface{}) { if h, ok := t.(tHelper); ok { h.Helper() } if assert.NotEqual(t, expected, actual, msgAndArgs...) { return } t.FailNow() } // NotEqualf asserts that the specified values are NOT equal. // // assert.NotEqualf(t, obj1, obj2, "error message %s", "formatted") // // Pointer variable equality is determined based on the equality of the // referenced values (as opposed to the memory addresses). func NotEqualf(t TestingT, expected interface{}, actual interface{}, msg string, args ...interface{}) { if h, ok := t.(tHelper); ok { h.Helper() } if assert.NotEqualf(t, expected, actual, msg, args...) { return } t.FailNow() } // NotNil asserts that the specified object is not nil. // // assert.NotNil(t, err) func NotNil(t TestingT, object interface{}, msgAndArgs ...interface{}) { if h, ok := t.(tHelper); ok { h.Helper() } if assert.NotNil(t, object, msgAndArgs...) { return } t.FailNow() } // NotNilf asserts that the specified object is not nil. // // assert.NotNilf(t, err, "error message %s", "formatted") func NotNilf(t TestingT, object interface{}, msg string, args ...interface{}) { if h, ok := t.(tHelper); ok { h.Helper() } if assert.NotNilf(t, object, msg, args...) { return } t.FailNow() } // NotPanics asserts that the code inside the specified PanicTestFunc does NOT panic. // // assert.NotPanics(t, func(){ RemainCalm() }) func NotPanics(t TestingT, f assert.PanicTestFunc, msgAndArgs ...interface{}) { if h, ok := t.(tHelper); ok { h.Helper() } if assert.NotPanics(t, f, msgAndArgs...) { return } t.FailNow() } // NotPanicsf asserts that the code inside the specified PanicTestFunc does NOT panic. // // assert.NotPanicsf(t, func(){ RemainCalm() }, "error message %s", "formatted") func NotPanicsf(t TestingT, f assert.PanicTestFunc, msg string, args ...interface{}) { if h, ok := t.(tHelper); ok { h.Helper() } if assert.NotPanicsf(t, f, msg, args...) { return } t.FailNow() } // NotRegexp asserts that a specified regexp does not match a string. // // assert.NotRegexp(t, regexp.MustCompile("starts"), "it's starting") // assert.NotRegexp(t, "^start", "it's not starting") func NotRegexp(t TestingT, rx interface{}, str interface{}, msgAndArgs ...interface{}) { if h, ok := t.(tHelper); ok { h.Helper() } if assert.NotRegexp(t, rx, str, msgAndArgs...) { return } t.FailNow() } // NotRegexpf asserts that a specified regexp does not match a string. // // assert.NotRegexpf(t, regexp.MustCompile("starts", "error message %s", "formatted"), "it's starting") // assert.NotRegexpf(t, "^start", "it's not starting", "error message %s", "formatted") func NotRegexpf(t TestingT, rx interface{}, str interface{}, msg string, args ...interface{}) { if h, ok := t.(tHelper); ok { h.Helper() } if assert.NotRegexpf(t, rx, str, msg, args...) { return } t.FailNow() } // NotSame asserts that two pointers do not reference the same object. // // assert.NotSame(t, ptr1, ptr2) // // Both arguments must be pointer variables. Pointer variable sameness is // determined based on the equality of both type and value. func NotSame(t TestingT, expected interface{}, actual interface{}, msgAndArgs ...interface{}) { if h, ok := t.(tHelper); ok { h.Helper() } if assert.NotSame(t, expected, actual, msgAndArgs...) { return } t.FailNow() } // NotSamef asserts that two pointers do not reference the same object. // // assert.NotSamef(t, ptr1, ptr2, "error message %s", "formatted") // // Both arguments must be pointer variables. Pointer variable sameness is // determined based on the equality of both type and value. func NotSamef(t TestingT, expected interface{}, actual interface{}, msg string, args ...interface{}) { if h, ok := t.(tHelper); ok { h.Helper() } if assert.NotSamef(t, expected, actual, msg, args...) { return } t.FailNow() } // NotSubset asserts that the specified list(array, slice...) contains not all // elements given in the specified subset(array, slice...). // // assert.NotSubset(t, [1, 3, 4], [1, 2], "But [1, 3, 4] does not contain [1, 2]") func NotSubset(t TestingT, list interface{}, subset interface{}, msgAndArgs ...interface{}) { if h, ok := t.(tHelper); ok { h.Helper() } if assert.NotSubset(t, list, subset, msgAndArgs...) { return } t.FailNow() } // NotSubsetf asserts that the specified list(array, slice...) contains not all // elements given in the specified subset(array, slice...). // // assert.NotSubsetf(t, [1, 3, 4], [1, 2], "But [1, 3, 4] does not contain [1, 2]", "error message %s", "formatted") func NotSubsetf(t TestingT, list interface{}, subset interface{}, msg string, args ...interface{}) { if h, ok := t.(tHelper); ok { h.Helper() } if assert.NotSubsetf(t, list, subset, msg, args...) { return } t.FailNow() } // NotZero asserts that i is not the zero value for its type. func NotZero(t TestingT, i interface{}, msgAndArgs ...interface{}) { if h, ok := t.(tHelper); ok { h.Helper() } if assert.NotZero(t, i, msgAndArgs...) { return } t.FailNow() } // NotZerof asserts that i is not the zero value for its type. func NotZerof(t TestingT, i interface{}, msg string, args ...interface{}) { if h, ok := t.(tHelper); ok { h.Helper() } if assert.NotZerof(t, i, msg, args...) { return } t.FailNow() } // Panics asserts that the code inside the specified PanicTestFunc panics. // // assert.Panics(t, func(){ GoCrazy() }) func Panics(t TestingT, f assert.PanicTestFunc, msgAndArgs ...interface{}) { if h, ok := t.(tHelper); ok { h.Helper() } if assert.Panics(t, f, msgAndArgs...) { return } t.FailNow() } // PanicsWithError asserts that the code inside the specified PanicTestFunc // panics, and that the recovered panic value is an error that satisfies the // EqualError comparison. // // assert.PanicsWithError(t, "crazy error", func(){ GoCrazy() }) func PanicsWithError(t TestingT, errString string, f assert.PanicTestFunc, msgAndArgs ...interface{}) { if h, ok := t.(tHelper); ok { h.Helper() } if assert.PanicsWithError(t, errString, f, msgAndArgs...) { return } t.FailNow() } // PanicsWithErrorf asserts that the code inside the specified PanicTestFunc // panics, and that the recovered panic value is an error that satisfies the // EqualError comparison. // // assert.PanicsWithErrorf(t, "crazy error", func(){ GoCrazy() }, "error message %s", "formatted") func PanicsWithErrorf(t TestingT, errString string, f assert.PanicTestFunc, msg string, args ...interface{}) { if h, ok := t.(tHelper); ok { h.Helper() } if assert.PanicsWithErrorf(t, errString, f, msg, args...) { return } t.FailNow() } // PanicsWithValue asserts that the code inside the specified PanicTestFunc panics, and that // the recovered panic value equals the expected panic value. // // assert.PanicsWithValue(t, "crazy error", func(){ GoCrazy() }) func PanicsWithValue(t TestingT, expected interface{}, f assert.PanicTestFunc, msgAndArgs ...interface{}) { if h, ok := t.(tHelper); ok { h.Helper() } if assert.PanicsWithValue(t, expected, f, msgAndArgs...) { return } t.FailNow() } // PanicsWithValuef asserts that the code inside the specified PanicTestFunc panics, and that // the recovered panic value equals the expected panic value. // // assert.PanicsWithValuef(t, "crazy error", func(){ GoCrazy() }, "error message %s", "formatted") func PanicsWithValuef(t TestingT, expected interface{}, f assert.PanicTestFunc, msg string, args ...interface{}) { if h, ok := t.(tHelper); ok { h.Helper() } if assert.PanicsWithValuef(t, expected, f, msg, args...) { return } t.FailNow() } // Panicsf asserts that the code inside the specified PanicTestFunc panics. // // assert.Panicsf(t, func(){ GoCrazy() }, "error message %s", "formatted") func Panicsf(t TestingT, f assert.PanicTestFunc, msg string, args ...interface{}) { if h, ok := t.(tHelper); ok { h.Helper() } if assert.Panicsf(t, f, msg, args...) { return } t.FailNow() } // Regexp asserts that a specified regexp matches a string. // // assert.Regexp(t, regexp.MustCompile("start"), "it's starting") // assert.Regexp(t, "start...$", "it's not starting") func Regexp(t TestingT, rx interface{}, str interface{}, msgAndArgs ...interface{}) { if h, ok := t.(tHelper); ok { h.Helper() } if assert.Regexp(t, rx, str, msgAndArgs...) { return } t.FailNow() } // Regexpf asserts that a specified regexp matches a string. // // assert.Regexpf(t, regexp.MustCompile("start", "error message %s", "formatted"), "it's starting") // assert.Regexpf(t, "start...$", "it's not starting", "error message %s", "formatted") func Regexpf(t TestingT, rx interface{}, str interface{}, msg string, args ...interface{}) { if h, ok := t.(tHelper); ok { h.Helper() } if assert.Regexpf(t, rx, str, msg, args...) { return } t.FailNow() } // Same asserts that two pointers reference the same object. // // assert.Same(t, ptr1, ptr2) // // Both arguments must be pointer variables. Pointer variable sameness is // determined based on the equality of both type and value. func Same(t TestingT, expected interface{}, actual interface{}, msgAndArgs ...interface{}) { if h, ok := t.(tHelper); ok { h.Helper() } if assert.Same(t, expected, actual, msgAndArgs...) { return } t.FailNow() } // Samef asserts that two pointers reference the same object. // // assert.Samef(t, ptr1, ptr2, "error message %s", "formatted") // // Both arguments must be pointer variables. Pointer variable sameness is // determined based on the equality of both type and value. func Samef(t TestingT, expected interface{}, actual interface{}, msg string, args ...interface{}) { if h, ok := t.(tHelper); ok { h.Helper() } if assert.Samef(t, expected, actual, msg, args...) { return } t.FailNow() } // Subset asserts that the specified list(array, slice...) contains all // elements given in the specified subset(array, slice...). // // assert.Subset(t, [1, 2, 3], [1, 2], "But [1, 2, 3] does contain [1, 2]") func Subset(t TestingT, list interface{}, subset interface{}, msgAndArgs ...interface{}) { if h, ok := t.(tHelper); ok { h.Helper() } if assert.Subset(t, list, subset, msgAndArgs...) { return } t.FailNow() } // Subsetf asserts that the specified list(array, slice...) contains all // elements given in the specified subset(array, slice...). // // assert.Subsetf(t, [1, 2, 3], [1, 2], "But [1, 2, 3] does contain [1, 2]", "error message %s", "formatted") func Subsetf(t TestingT, list interface{}, subset interface{}, msg string, args ...interface{}) { if h, ok := t.(tHelper); ok { h.Helper() } if assert.Subsetf(t, list, subset, msg, args...) { return } t.FailNow() } // True asserts that the specified value is true. // // assert.True(t, myBool) func True(t TestingT, value bool, msgAndArgs ...interface{}) { if h, ok := t.(tHelper); ok { h.Helper() } if assert.True(t, value, msgAndArgs...) { return } t.FailNow() } // Truef asserts that the specified value is true. // // assert.Truef(t, myBool, "error message %s", "formatted") func Truef(t TestingT, value bool, msg string, args ...interface{}) { if h, ok := t.(tHelper); ok { h.Helper() } if assert.Truef(t, value, msg, args...) { return } t.FailNow() } // WithinDuration asserts that the two times are within duration delta of each other. // // assert.WithinDuration(t, time.Now(), time.Now(), 10*time.Second) func WithinDuration(t TestingT, expected time.Time, actual time.Time, delta time.Duration, msgAndArgs ...interface{}) { if h, ok := t.(tHelper); ok { h.Helper() } if assert.WithinDuration(t, expected, actual, delta, msgAndArgs...) { return } t.FailNow() } // WithinDurationf asserts that the two times are within duration delta of each other. // // assert.WithinDurationf(t, time.Now(), time.Now(), 10*time.Second, "error message %s", "formatted") func WithinDurationf(t TestingT, expected time.Time, actual time.Time, delta time.Duration, msg string, args ...interface{}) { if h, ok := t.(tHelper); ok { h.Helper() } if assert.WithinDurationf(t, expected, actual, delta, msg, args...) { return } t.FailNow() } // YAMLEq asserts that two YAML strings are equivalent. func YAMLEq(t TestingT, expected string, actual string, msgAndArgs ...interface{}) { if h, ok := t.(tHelper); ok { h.Helper() } if assert.YAMLEq(t, expected, actual, msgAndArgs...) { return } t.FailNow() } // YAMLEqf asserts that two YAML strings are equivalent. func YAMLEqf(t TestingT, expected string, actual string, msg string, args ...interface{}) { if h, ok := t.(tHelper); ok { h.Helper() } if assert.YAMLEqf(t, expected, actual, msg, args...) { return } t.FailNow() } // Zero asserts that i is the zero value for its type. func Zero(t TestingT, i interface{}, msgAndArgs ...interface{}) { if h, ok := t.(tHelper); ok { h.Helper() } if assert.Zero(t, i, msgAndArgs...) { return } t.FailNow() } // Zerof asserts that i is the zero value for its type. func Zerof(t TestingT, i interface{}, msg string, args ...interface{}) { if h, ok := t.(tHelper); ok { h.Helper() } if assert.Zerof(t, i, msg, args...) { return } t.FailNow() } go-jmespath-0.4.0/internal/testify/require/require.go.tmpl000066400000000000000000000002731373124421700236740ustar00rootroot00000000000000{{.Comment}} func {{.DocInfo.Name}}(t TestingT, {{.Params}}) { if h, ok := t.(tHelper); ok { h.Helper() } if assert.{{.DocInfo.Name}}(t, {{.ForwardedParams}}) { return } t.FailNow() } go-jmespath-0.4.0/internal/testify/require/require_forward.go000066400000000000000000001245161373124421700244540ustar00rootroot00000000000000/* * CODE GENERATED AUTOMATICALLY WITH github.com/jmespath/go-jmespath/internal/testify/_codegen * THIS FILE MUST NOT BE EDITED BY HAND */ package require import ( assert "github.com/jmespath/go-jmespath/internal/testify/assert" http "net/http" url "net/url" time "time" ) // Condition uses a Comparison to assert a complex condition. func (a *Assertions) Condition(comp assert.Comparison, msgAndArgs ...interface{}) { if h, ok := a.t.(tHelper); ok { h.Helper() } Condition(a.t, comp, msgAndArgs...) } // Conditionf uses a Comparison to assert a complex condition. func (a *Assertions) Conditionf(comp assert.Comparison, msg string, args ...interface{}) { if h, ok := a.t.(tHelper); ok { h.Helper() } Conditionf(a.t, comp, msg, args...) } // Contains asserts that the specified string, list(array, slice...) or map contains the // specified substring or element. // // a.Contains("Hello World", "World") // a.Contains(["Hello", "World"], "World") // a.Contains({"Hello": "World"}, "Hello") func (a *Assertions) Contains(s interface{}, contains interface{}, msgAndArgs ...interface{}) { if h, ok := a.t.(tHelper); ok { h.Helper() } Contains(a.t, s, contains, msgAndArgs...) } // Containsf asserts that the specified string, list(array, slice...) or map contains the // specified substring or element. // // a.Containsf("Hello World", "World", "error message %s", "formatted") // a.Containsf(["Hello", "World"], "World", "error message %s", "formatted") // a.Containsf({"Hello": "World"}, "Hello", "error message %s", "formatted") func (a *Assertions) Containsf(s interface{}, contains interface{}, msg string, args ...interface{}) { if h, ok := a.t.(tHelper); ok { h.Helper() } Containsf(a.t, s, contains, msg, args...) } // DirExists checks whether a directory exists in the given path. It also fails // if the path is a file rather a directory or there is an error checking whether it exists. func (a *Assertions) DirExists(path string, msgAndArgs ...interface{}) { if h, ok := a.t.(tHelper); ok { h.Helper() } DirExists(a.t, path, msgAndArgs...) } // DirExistsf checks whether a directory exists in the given path. It also fails // if the path is a file rather a directory or there is an error checking whether it exists. func (a *Assertions) DirExistsf(path string, msg string, args ...interface{}) { if h, ok := a.t.(tHelper); ok { h.Helper() } DirExistsf(a.t, path, msg, args...) } // ElementsMatch asserts that the specified listA(array, slice...) is equal to specified // listB(array, slice...) ignoring the order of the elements. If there are duplicate elements, // the number of appearances of each of them in both lists should match. // // a.ElementsMatch([1, 3, 2, 3], [1, 3, 3, 2]) func (a *Assertions) ElementsMatch(listA interface{}, listB interface{}, msgAndArgs ...interface{}) { if h, ok := a.t.(tHelper); ok { h.Helper() } ElementsMatch(a.t, listA, listB, msgAndArgs...) } // ElementsMatchf asserts that the specified listA(array, slice...) is equal to specified // listB(array, slice...) ignoring the order of the elements. If there are duplicate elements, // the number of appearances of each of them in both lists should match. // // a.ElementsMatchf([1, 3, 2, 3], [1, 3, 3, 2], "error message %s", "formatted") func (a *Assertions) ElementsMatchf(listA interface{}, listB interface{}, msg string, args ...interface{}) { if h, ok := a.t.(tHelper); ok { h.Helper() } ElementsMatchf(a.t, listA, listB, msg, args...) } // Empty asserts that the specified object is empty. I.e. nil, "", false, 0 or either // a slice or a channel with len == 0. // // a.Empty(obj) func (a *Assertions) Empty(object interface{}, msgAndArgs ...interface{}) { if h, ok := a.t.(tHelper); ok { h.Helper() } Empty(a.t, object, msgAndArgs...) } // Emptyf asserts that the specified object is empty. I.e. nil, "", false, 0 or either // a slice or a channel with len == 0. // // a.Emptyf(obj, "error message %s", "formatted") func (a *Assertions) Emptyf(object interface{}, msg string, args ...interface{}) { if h, ok := a.t.(tHelper); ok { h.Helper() } Emptyf(a.t, object, msg, args...) } // Equal asserts that two objects are equal. // // a.Equal(123, 123) // // Pointer variable equality is determined based on the equality of the // referenced values (as opposed to the memory addresses). Function equality // cannot be determined and will always fail. func (a *Assertions) Equal(expected interface{}, actual interface{}, msgAndArgs ...interface{}) { if h, ok := a.t.(tHelper); ok { h.Helper() } Equal(a.t, expected, actual, msgAndArgs...) } // EqualError asserts that a function returned an error (i.e. not `nil`) // and that it is equal to the provided error. // // actualObj, err := SomeFunction() // a.EqualError(err, expectedErrorString) func (a *Assertions) EqualError(theError error, errString string, msgAndArgs ...interface{}) { if h, ok := a.t.(tHelper); ok { h.Helper() } EqualError(a.t, theError, errString, msgAndArgs...) } // EqualErrorf asserts that a function returned an error (i.e. not `nil`) // and that it is equal to the provided error. // // actualObj, err := SomeFunction() // a.EqualErrorf(err, expectedErrorString, "error message %s", "formatted") func (a *Assertions) EqualErrorf(theError error, errString string, msg string, args ...interface{}) { if h, ok := a.t.(tHelper); ok { h.Helper() } EqualErrorf(a.t, theError, errString, msg, args...) } // EqualValues asserts that two objects are equal or convertable to the same types // and equal. // // a.EqualValues(uint32(123), int32(123)) func (a *Assertions) EqualValues(expected interface{}, actual interface{}, msgAndArgs ...interface{}) { if h, ok := a.t.(tHelper); ok { h.Helper() } EqualValues(a.t, expected, actual, msgAndArgs...) } // EqualValuesf asserts that two objects are equal or convertable to the same types // and equal. // // a.EqualValuesf(uint32(123, "error message %s", "formatted"), int32(123)) func (a *Assertions) EqualValuesf(expected interface{}, actual interface{}, msg string, args ...interface{}) { if h, ok := a.t.(tHelper); ok { h.Helper() } EqualValuesf(a.t, expected, actual, msg, args...) } // Equalf asserts that two objects are equal. // // a.Equalf(123, 123, "error message %s", "formatted") // // Pointer variable equality is determined based on the equality of the // referenced values (as opposed to the memory addresses). Function equality // cannot be determined and will always fail. func (a *Assertions) Equalf(expected interface{}, actual interface{}, msg string, args ...interface{}) { if h, ok := a.t.(tHelper); ok { h.Helper() } Equalf(a.t, expected, actual, msg, args...) } // Error asserts that a function returned an error (i.e. not `nil`). // // actualObj, err := SomeFunction() // if a.Error(err) { // assert.Equal(t, expectedError, err) // } func (a *Assertions) Error(err error, msgAndArgs ...interface{}) { if h, ok := a.t.(tHelper); ok { h.Helper() } Error(a.t, err, msgAndArgs...) } // Errorf asserts that a function returned an error (i.e. not `nil`). // // actualObj, err := SomeFunction() // if a.Errorf(err, "error message %s", "formatted") { // assert.Equal(t, expectedErrorf, err) // } func (a *Assertions) Errorf(err error, msg string, args ...interface{}) { if h, ok := a.t.(tHelper); ok { h.Helper() } Errorf(a.t, err, msg, args...) } // Eventually asserts that given condition will be met in waitFor time, // periodically checking target function each tick. // // a.Eventually(func() bool { return true; }, time.Second, 10*time.Millisecond) func (a *Assertions) Eventually(condition func() bool, waitFor time.Duration, tick time.Duration, msgAndArgs ...interface{}) { if h, ok := a.t.(tHelper); ok { h.Helper() } Eventually(a.t, condition, waitFor, tick, msgAndArgs...) } // Eventuallyf asserts that given condition will be met in waitFor time, // periodically checking target function each tick. // // a.Eventuallyf(func() bool { return true; }, time.Second, 10*time.Millisecond, "error message %s", "formatted") func (a *Assertions) Eventuallyf(condition func() bool, waitFor time.Duration, tick time.Duration, msg string, args ...interface{}) { if h, ok := a.t.(tHelper); ok { h.Helper() } Eventuallyf(a.t, condition, waitFor, tick, msg, args...) } // Exactly asserts that two objects are equal in value and type. // // a.Exactly(int32(123), int64(123)) func (a *Assertions) Exactly(expected interface{}, actual interface{}, msgAndArgs ...interface{}) { if h, ok := a.t.(tHelper); ok { h.Helper() } Exactly(a.t, expected, actual, msgAndArgs...) } // Exactlyf asserts that two objects are equal in value and type. // // a.Exactlyf(int32(123, "error message %s", "formatted"), int64(123)) func (a *Assertions) Exactlyf(expected interface{}, actual interface{}, msg string, args ...interface{}) { if h, ok := a.t.(tHelper); ok { h.Helper() } Exactlyf(a.t, expected, actual, msg, args...) } // Fail reports a failure through func (a *Assertions) Fail(failureMessage string, msgAndArgs ...interface{}) { if h, ok := a.t.(tHelper); ok { h.Helper() } Fail(a.t, failureMessage, msgAndArgs...) } // FailNow fails test func (a *Assertions) FailNow(failureMessage string, msgAndArgs ...interface{}) { if h, ok := a.t.(tHelper); ok { h.Helper() } FailNow(a.t, failureMessage, msgAndArgs...) } // FailNowf fails test func (a *Assertions) FailNowf(failureMessage string, msg string, args ...interface{}) { if h, ok := a.t.(tHelper); ok { h.Helper() } FailNowf(a.t, failureMessage, msg, args...) } // Failf reports a failure through func (a *Assertions) Failf(failureMessage string, msg string, args ...interface{}) { if h, ok := a.t.(tHelper); ok { h.Helper() } Failf(a.t, failureMessage, msg, args...) } // False asserts that the specified value is false. // // a.False(myBool) func (a *Assertions) False(value bool, msgAndArgs ...interface{}) { if h, ok := a.t.(tHelper); ok { h.Helper() } False(a.t, value, msgAndArgs...) } // Falsef asserts that the specified value is false. // // a.Falsef(myBool, "error message %s", "formatted") func (a *Assertions) Falsef(value bool, msg string, args ...interface{}) { if h, ok := a.t.(tHelper); ok { h.Helper() } Falsef(a.t, value, msg, args...) } // FileExists checks whether a file exists in the given path. It also fails if // the path points to a directory or there is an error when trying to check the file. func (a *Assertions) FileExists(path string, msgAndArgs ...interface{}) { if h, ok := a.t.(tHelper); ok { h.Helper() } FileExists(a.t, path, msgAndArgs...) } // FileExistsf checks whether a file exists in the given path. It also fails if // the path points to a directory or there is an error when trying to check the file. func (a *Assertions) FileExistsf(path string, msg string, args ...interface{}) { if h, ok := a.t.(tHelper); ok { h.Helper() } FileExistsf(a.t, path, msg, args...) } // Greater asserts that the first element is greater than the second // // a.Greater(2, 1) // a.Greater(float64(2), float64(1)) // a.Greater("b", "a") func (a *Assertions) Greater(e1 interface{}, e2 interface{}, msgAndArgs ...interface{}) { if h, ok := a.t.(tHelper); ok { h.Helper() } Greater(a.t, e1, e2, msgAndArgs...) } // GreaterOrEqual asserts that the first element is greater than or equal to the second // // a.GreaterOrEqual(2, 1) // a.GreaterOrEqual(2, 2) // a.GreaterOrEqual("b", "a") // a.GreaterOrEqual("b", "b") func (a *Assertions) GreaterOrEqual(e1 interface{}, e2 interface{}, msgAndArgs ...interface{}) { if h, ok := a.t.(tHelper); ok { h.Helper() } GreaterOrEqual(a.t, e1, e2, msgAndArgs...) } // GreaterOrEqualf asserts that the first element is greater than or equal to the second // // a.GreaterOrEqualf(2, 1, "error message %s", "formatted") // a.GreaterOrEqualf(2, 2, "error message %s", "formatted") // a.GreaterOrEqualf("b", "a", "error message %s", "formatted") // a.GreaterOrEqualf("b", "b", "error message %s", "formatted") func (a *Assertions) GreaterOrEqualf(e1 interface{}, e2 interface{}, msg string, args ...interface{}) { if h, ok := a.t.(tHelper); ok { h.Helper() } GreaterOrEqualf(a.t, e1, e2, msg, args...) } // Greaterf asserts that the first element is greater than the second // // a.Greaterf(2, 1, "error message %s", "formatted") // a.Greaterf(float64(2, "error message %s", "formatted"), float64(1)) // a.Greaterf("b", "a", "error message %s", "formatted") func (a *Assertions) Greaterf(e1 interface{}, e2 interface{}, msg string, args ...interface{}) { if h, ok := a.t.(tHelper); ok { h.Helper() } Greaterf(a.t, e1, e2, msg, args...) } // HTTPBodyContains asserts that a specified handler returns a // body that contains a string. // // a.HTTPBodyContains(myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky") // // Returns whether the assertion was successful (true) or not (false). func (a *Assertions) HTTPBodyContains(handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msgAndArgs ...interface{}) { if h, ok := a.t.(tHelper); ok { h.Helper() } HTTPBodyContains(a.t, handler, method, url, values, str, msgAndArgs...) } // HTTPBodyContainsf asserts that a specified handler returns a // body that contains a string. // // a.HTTPBodyContainsf(myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky", "error message %s", "formatted") // // Returns whether the assertion was successful (true) or not (false). func (a *Assertions) HTTPBodyContainsf(handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msg string, args ...interface{}) { if h, ok := a.t.(tHelper); ok { h.Helper() } HTTPBodyContainsf(a.t, handler, method, url, values, str, msg, args...) } // HTTPBodyNotContains asserts that a specified handler returns a // body that does not contain a string. // // a.HTTPBodyNotContains(myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky") // // Returns whether the assertion was successful (true) or not (false). func (a *Assertions) HTTPBodyNotContains(handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msgAndArgs ...interface{}) { if h, ok := a.t.(tHelper); ok { h.Helper() } HTTPBodyNotContains(a.t, handler, method, url, values, str, msgAndArgs...) } // HTTPBodyNotContainsf asserts that a specified handler returns a // body that does not contain a string. // // a.HTTPBodyNotContainsf(myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky", "error message %s", "formatted") // // Returns whether the assertion was successful (true) or not (false). func (a *Assertions) HTTPBodyNotContainsf(handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msg string, args ...interface{}) { if h, ok := a.t.(tHelper); ok { h.Helper() } HTTPBodyNotContainsf(a.t, handler, method, url, values, str, msg, args...) } // HTTPError asserts that a specified handler returns an error status code. // // a.HTTPError(myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}} // // Returns whether the assertion was successful (true) or not (false). func (a *Assertions) HTTPError(handler http.HandlerFunc, method string, url string, values url.Values, msgAndArgs ...interface{}) { if h, ok := a.t.(tHelper); ok { h.Helper() } HTTPError(a.t, handler, method, url, values, msgAndArgs...) } // HTTPErrorf asserts that a specified handler returns an error status code. // // a.HTTPErrorf(myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}} // // Returns whether the assertion was successful (true, "error message %s", "formatted") or not (false). func (a *Assertions) HTTPErrorf(handler http.HandlerFunc, method string, url string, values url.Values, msg string, args ...interface{}) { if h, ok := a.t.(tHelper); ok { h.Helper() } HTTPErrorf(a.t, handler, method, url, values, msg, args...) } // HTTPRedirect asserts that a specified handler returns a redirect status code. // // a.HTTPRedirect(myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}} // // Returns whether the assertion was successful (true) or not (false). func (a *Assertions) HTTPRedirect(handler http.HandlerFunc, method string, url string, values url.Values, msgAndArgs ...interface{}) { if h, ok := a.t.(tHelper); ok { h.Helper() } HTTPRedirect(a.t, handler, method, url, values, msgAndArgs...) } // HTTPRedirectf asserts that a specified handler returns a redirect status code. // // a.HTTPRedirectf(myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}} // // Returns whether the assertion was successful (true, "error message %s", "formatted") or not (false). func (a *Assertions) HTTPRedirectf(handler http.HandlerFunc, method string, url string, values url.Values, msg string, args ...interface{}) { if h, ok := a.t.(tHelper); ok { h.Helper() } HTTPRedirectf(a.t, handler, method, url, values, msg, args...) } // HTTPSuccess asserts that a specified handler returns a success status code. // // a.HTTPSuccess(myHandler, "POST", "http://www.google.com", nil) // // Returns whether the assertion was successful (true) or not (false). func (a *Assertions) HTTPSuccess(handler http.HandlerFunc, method string, url string, values url.Values, msgAndArgs ...interface{}) { if h, ok := a.t.(tHelper); ok { h.Helper() } HTTPSuccess(a.t, handler, method, url, values, msgAndArgs...) } // HTTPSuccessf asserts that a specified handler returns a success status code. // // a.HTTPSuccessf(myHandler, "POST", "http://www.google.com", nil, "error message %s", "formatted") // // Returns whether the assertion was successful (true) or not (false). func (a *Assertions) HTTPSuccessf(handler http.HandlerFunc, method string, url string, values url.Values, msg string, args ...interface{}) { if h, ok := a.t.(tHelper); ok { h.Helper() } HTTPSuccessf(a.t, handler, method, url, values, msg, args...) } // Implements asserts that an object is implemented by the specified interface. // // a.Implements((*MyInterface)(nil), new(MyObject)) func (a *Assertions) Implements(interfaceObject interface{}, object interface{}, msgAndArgs ...interface{}) { if h, ok := a.t.(tHelper); ok { h.Helper() } Implements(a.t, interfaceObject, object, msgAndArgs...) } // Implementsf asserts that an object is implemented by the specified interface. // // a.Implementsf((*MyInterface, "error message %s", "formatted")(nil), new(MyObject)) func (a *Assertions) Implementsf(interfaceObject interface{}, object interface{}, msg string, args ...interface{}) { if h, ok := a.t.(tHelper); ok { h.Helper() } Implementsf(a.t, interfaceObject, object, msg, args...) } // InDelta asserts that the two numerals are within delta of each other. // // a.InDelta(math.Pi, 22/7.0, 0.01) func (a *Assertions) InDelta(expected interface{}, actual interface{}, delta float64, msgAndArgs ...interface{}) { if h, ok := a.t.(tHelper); ok { h.Helper() } InDelta(a.t, expected, actual, delta, msgAndArgs...) } // InDeltaMapValues is the same as InDelta, but it compares all values between two maps. Both maps must have exactly the same keys. func (a *Assertions) InDeltaMapValues(expected interface{}, actual interface{}, delta float64, msgAndArgs ...interface{}) { if h, ok := a.t.(tHelper); ok { h.Helper() } InDeltaMapValues(a.t, expected, actual, delta, msgAndArgs...) } // InDeltaMapValuesf is the same as InDelta, but it compares all values between two maps. Both maps must have exactly the same keys. func (a *Assertions) InDeltaMapValuesf(expected interface{}, actual interface{}, delta float64, msg string, args ...interface{}) { if h, ok := a.t.(tHelper); ok { h.Helper() } InDeltaMapValuesf(a.t, expected, actual, delta, msg, args...) } // InDeltaSlice is the same as InDelta, except it compares two slices. func (a *Assertions) InDeltaSlice(expected interface{}, actual interface{}, delta float64, msgAndArgs ...interface{}) { if h, ok := a.t.(tHelper); ok { h.Helper() } InDeltaSlice(a.t, expected, actual, delta, msgAndArgs...) } // InDeltaSlicef is the same as InDelta, except it compares two slices. func (a *Assertions) InDeltaSlicef(expected interface{}, actual interface{}, delta float64, msg string, args ...interface{}) { if h, ok := a.t.(tHelper); ok { h.Helper() } InDeltaSlicef(a.t, expected, actual, delta, msg, args...) } // InDeltaf asserts that the two numerals are within delta of each other. // // a.InDeltaf(math.Pi, 22/7.0, 0.01, "error message %s", "formatted") func (a *Assertions) InDeltaf(expected interface{}, actual interface{}, delta float64, msg string, args ...interface{}) { if h, ok := a.t.(tHelper); ok { h.Helper() } InDeltaf(a.t, expected, actual, delta, msg, args...) } // InEpsilon asserts that expected and actual have a relative error less than epsilon func (a *Assertions) InEpsilon(expected interface{}, actual interface{}, epsilon float64, msgAndArgs ...interface{}) { if h, ok := a.t.(tHelper); ok { h.Helper() } InEpsilon(a.t, expected, actual, epsilon, msgAndArgs...) } // InEpsilonSlice is the same as InEpsilon, except it compares each value from two slices. func (a *Assertions) InEpsilonSlice(expected interface{}, actual interface{}, epsilon float64, msgAndArgs ...interface{}) { if h, ok := a.t.(tHelper); ok { h.Helper() } InEpsilonSlice(a.t, expected, actual, epsilon, msgAndArgs...) } // InEpsilonSlicef is the same as InEpsilon, except it compares each value from two slices. func (a *Assertions) InEpsilonSlicef(expected interface{}, actual interface{}, epsilon float64, msg string, args ...interface{}) { if h, ok := a.t.(tHelper); ok { h.Helper() } InEpsilonSlicef(a.t, expected, actual, epsilon, msg, args...) } // InEpsilonf asserts that expected and actual have a relative error less than epsilon func (a *Assertions) InEpsilonf(expected interface{}, actual interface{}, epsilon float64, msg string, args ...interface{}) { if h, ok := a.t.(tHelper); ok { h.Helper() } InEpsilonf(a.t, expected, actual, epsilon, msg, args...) } // IsType asserts that the specified objects are of the same type. func (a *Assertions) IsType(expectedType interface{}, object interface{}, msgAndArgs ...interface{}) { if h, ok := a.t.(tHelper); ok { h.Helper() } IsType(a.t, expectedType, object, msgAndArgs...) } // IsTypef asserts that the specified objects are of the same type. func (a *Assertions) IsTypef(expectedType interface{}, object interface{}, msg string, args ...interface{}) { if h, ok := a.t.(tHelper); ok { h.Helper() } IsTypef(a.t, expectedType, object, msg, args...) } // JSONEq asserts that two JSON strings are equivalent. // // a.JSONEq(`{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`) func (a *Assertions) JSONEq(expected string, actual string, msgAndArgs ...interface{}) { if h, ok := a.t.(tHelper); ok { h.Helper() } JSONEq(a.t, expected, actual, msgAndArgs...) } // JSONEqf asserts that two JSON strings are equivalent. // // a.JSONEqf(`{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`, "error message %s", "formatted") func (a *Assertions) JSONEqf(expected string, actual string, msg string, args ...interface{}) { if h, ok := a.t.(tHelper); ok { h.Helper() } JSONEqf(a.t, expected, actual, msg, args...) } // Len asserts that the specified object has specific length. // Len also fails if the object has a type that len() not accept. // // a.Len(mySlice, 3) func (a *Assertions) Len(object interface{}, length int, msgAndArgs ...interface{}) { if h, ok := a.t.(tHelper); ok { h.Helper() } Len(a.t, object, length, msgAndArgs...) } // Lenf asserts that the specified object has specific length. // Lenf also fails if the object has a type that len() not accept. // // a.Lenf(mySlice, 3, "error message %s", "formatted") func (a *Assertions) Lenf(object interface{}, length int, msg string, args ...interface{}) { if h, ok := a.t.(tHelper); ok { h.Helper() } Lenf(a.t, object, length, msg, args...) } // Less asserts that the first element is less than the second // // a.Less(1, 2) // a.Less(float64(1), float64(2)) // a.Less("a", "b") func (a *Assertions) Less(e1 interface{}, e2 interface{}, msgAndArgs ...interface{}) { if h, ok := a.t.(tHelper); ok { h.Helper() } Less(a.t, e1, e2, msgAndArgs...) } // LessOrEqual asserts that the first element is less than or equal to the second // // a.LessOrEqual(1, 2) // a.LessOrEqual(2, 2) // a.LessOrEqual("a", "b") // a.LessOrEqual("b", "b") func (a *Assertions) LessOrEqual(e1 interface{}, e2 interface{}, msgAndArgs ...interface{}) { if h, ok := a.t.(tHelper); ok { h.Helper() } LessOrEqual(a.t, e1, e2, msgAndArgs...) } // LessOrEqualf asserts that the first element is less than or equal to the second // // a.LessOrEqualf(1, 2, "error message %s", "formatted") // a.LessOrEqualf(2, 2, "error message %s", "formatted") // a.LessOrEqualf("a", "b", "error message %s", "formatted") // a.LessOrEqualf("b", "b", "error message %s", "formatted") func (a *Assertions) LessOrEqualf(e1 interface{}, e2 interface{}, msg string, args ...interface{}) { if h, ok := a.t.(tHelper); ok { h.Helper() } LessOrEqualf(a.t, e1, e2, msg, args...) } // Lessf asserts that the first element is less than the second // // a.Lessf(1, 2, "error message %s", "formatted") // a.Lessf(float64(1, "error message %s", "formatted"), float64(2)) // a.Lessf("a", "b", "error message %s", "formatted") func (a *Assertions) Lessf(e1 interface{}, e2 interface{}, msg string, args ...interface{}) { if h, ok := a.t.(tHelper); ok { h.Helper() } Lessf(a.t, e1, e2, msg, args...) } // Never asserts that the given condition doesn't satisfy in waitFor time, // periodically checking the target function each tick. // // a.Never(func() bool { return false; }, time.Second, 10*time.Millisecond) func (a *Assertions) Never(condition func() bool, waitFor time.Duration, tick time.Duration, msgAndArgs ...interface{}) { if h, ok := a.t.(tHelper); ok { h.Helper() } Never(a.t, condition, waitFor, tick, msgAndArgs...) } // Neverf asserts that the given condition doesn't satisfy in waitFor time, // periodically checking the target function each tick. // // a.Neverf(func() bool { return false; }, time.Second, 10*time.Millisecond, "error message %s", "formatted") func (a *Assertions) Neverf(condition func() bool, waitFor time.Duration, tick time.Duration, msg string, args ...interface{}) { if h, ok := a.t.(tHelper); ok { h.Helper() } Neverf(a.t, condition, waitFor, tick, msg, args...) } // Nil asserts that the specified object is nil. // // a.Nil(err) func (a *Assertions) Nil(object interface{}, msgAndArgs ...interface{}) { if h, ok := a.t.(tHelper); ok { h.Helper() } Nil(a.t, object, msgAndArgs...) } // Nilf asserts that the specified object is nil. // // a.Nilf(err, "error message %s", "formatted") func (a *Assertions) Nilf(object interface{}, msg string, args ...interface{}) { if h, ok := a.t.(tHelper); ok { h.Helper() } Nilf(a.t, object, msg, args...) } // NoDirExists checks whether a directory does not exist in the given path. // It fails if the path points to an existing _directory_ only. func (a *Assertions) NoDirExists(path string, msgAndArgs ...interface{}) { if h, ok := a.t.(tHelper); ok { h.Helper() } NoDirExists(a.t, path, msgAndArgs...) } // NoDirExistsf checks whether a directory does not exist in the given path. // It fails if the path points to an existing _directory_ only. func (a *Assertions) NoDirExistsf(path string, msg string, args ...interface{}) { if h, ok := a.t.(tHelper); ok { h.Helper() } NoDirExistsf(a.t, path, msg, args...) } // NoError asserts that a function returned no error (i.e. `nil`). // // actualObj, err := SomeFunction() // if a.NoError(err) { // assert.Equal(t, expectedObj, actualObj) // } func (a *Assertions) NoError(err error, msgAndArgs ...interface{}) { if h, ok := a.t.(tHelper); ok { h.Helper() } NoError(a.t, err, msgAndArgs...) } // NoErrorf asserts that a function returned no error (i.e. `nil`). // // actualObj, err := SomeFunction() // if a.NoErrorf(err, "error message %s", "formatted") { // assert.Equal(t, expectedObj, actualObj) // } func (a *Assertions) NoErrorf(err error, msg string, args ...interface{}) { if h, ok := a.t.(tHelper); ok { h.Helper() } NoErrorf(a.t, err, msg, args...) } // NoFileExists checks whether a file does not exist in a given path. It fails // if the path points to an existing _file_ only. func (a *Assertions) NoFileExists(path string, msgAndArgs ...interface{}) { if h, ok := a.t.(tHelper); ok { h.Helper() } NoFileExists(a.t, path, msgAndArgs...) } // NoFileExistsf checks whether a file does not exist in a given path. It fails // if the path points to an existing _file_ only. func (a *Assertions) NoFileExistsf(path string, msg string, args ...interface{}) { if h, ok := a.t.(tHelper); ok { h.Helper() } NoFileExistsf(a.t, path, msg, args...) } // NotContains asserts that the specified string, list(array, slice...) or map does NOT contain the // specified substring or element. // // a.NotContains("Hello World", "Earth") // a.NotContains(["Hello", "World"], "Earth") // a.NotContains({"Hello": "World"}, "Earth") func (a *Assertions) NotContains(s interface{}, contains interface{}, msgAndArgs ...interface{}) { if h, ok := a.t.(tHelper); ok { h.Helper() } NotContains(a.t, s, contains, msgAndArgs...) } // NotContainsf asserts that the specified string, list(array, slice...) or map does NOT contain the // specified substring or element. // // a.NotContainsf("Hello World", "Earth", "error message %s", "formatted") // a.NotContainsf(["Hello", "World"], "Earth", "error message %s", "formatted") // a.NotContainsf({"Hello": "World"}, "Earth", "error message %s", "formatted") func (a *Assertions) NotContainsf(s interface{}, contains interface{}, msg string, args ...interface{}) { if h, ok := a.t.(tHelper); ok { h.Helper() } NotContainsf(a.t, s, contains, msg, args...) } // NotEmpty asserts that the specified object is NOT empty. I.e. not nil, "", false, 0 or either // a slice or a channel with len == 0. // // if a.NotEmpty(obj) { // assert.Equal(t, "two", obj[1]) // } func (a *Assertions) NotEmpty(object interface{}, msgAndArgs ...interface{}) { if h, ok := a.t.(tHelper); ok { h.Helper() } NotEmpty(a.t, object, msgAndArgs...) } // NotEmptyf asserts that the specified object is NOT empty. I.e. not nil, "", false, 0 or either // a slice or a channel with len == 0. // // if a.NotEmptyf(obj, "error message %s", "formatted") { // assert.Equal(t, "two", obj[1]) // } func (a *Assertions) NotEmptyf(object interface{}, msg string, args ...interface{}) { if h, ok := a.t.(tHelper); ok { h.Helper() } NotEmptyf(a.t, object, msg, args...) } // NotEqual asserts that the specified values are NOT equal. // // a.NotEqual(obj1, obj2) // // Pointer variable equality is determined based on the equality of the // referenced values (as opposed to the memory addresses). func (a *Assertions) NotEqual(expected interface{}, actual interface{}, msgAndArgs ...interface{}) { if h, ok := a.t.(tHelper); ok { h.Helper() } NotEqual(a.t, expected, actual, msgAndArgs...) } // NotEqualf asserts that the specified values are NOT equal. // // a.NotEqualf(obj1, obj2, "error message %s", "formatted") // // Pointer variable equality is determined based on the equality of the // referenced values (as opposed to the memory addresses). func (a *Assertions) NotEqualf(expected interface{}, actual interface{}, msg string, args ...interface{}) { if h, ok := a.t.(tHelper); ok { h.Helper() } NotEqualf(a.t, expected, actual, msg, args...) } // NotNil asserts that the specified object is not nil. // // a.NotNil(err) func (a *Assertions) NotNil(object interface{}, msgAndArgs ...interface{}) { if h, ok := a.t.(tHelper); ok { h.Helper() } NotNil(a.t, object, msgAndArgs...) } // NotNilf asserts that the specified object is not nil. // // a.NotNilf(err, "error message %s", "formatted") func (a *Assertions) NotNilf(object interface{}, msg string, args ...interface{}) { if h, ok := a.t.(tHelper); ok { h.Helper() } NotNilf(a.t, object, msg, args...) } // NotPanics asserts that the code inside the specified PanicTestFunc does NOT panic. // // a.NotPanics(func(){ RemainCalm() }) func (a *Assertions) NotPanics(f assert.PanicTestFunc, msgAndArgs ...interface{}) { if h, ok := a.t.(tHelper); ok { h.Helper() } NotPanics(a.t, f, msgAndArgs...) } // NotPanicsf asserts that the code inside the specified PanicTestFunc does NOT panic. // // a.NotPanicsf(func(){ RemainCalm() }, "error message %s", "formatted") func (a *Assertions) NotPanicsf(f assert.PanicTestFunc, msg string, args ...interface{}) { if h, ok := a.t.(tHelper); ok { h.Helper() } NotPanicsf(a.t, f, msg, args...) } // NotRegexp asserts that a specified regexp does not match a string. // // a.NotRegexp(regexp.MustCompile("starts"), "it's starting") // a.NotRegexp("^start", "it's not starting") func (a *Assertions) NotRegexp(rx interface{}, str interface{}, msgAndArgs ...interface{}) { if h, ok := a.t.(tHelper); ok { h.Helper() } NotRegexp(a.t, rx, str, msgAndArgs...) } // NotRegexpf asserts that a specified regexp does not match a string. // // a.NotRegexpf(regexp.MustCompile("starts", "error message %s", "formatted"), "it's starting") // a.NotRegexpf("^start", "it's not starting", "error message %s", "formatted") func (a *Assertions) NotRegexpf(rx interface{}, str interface{}, msg string, args ...interface{}) { if h, ok := a.t.(tHelper); ok { h.Helper() } NotRegexpf(a.t, rx, str, msg, args...) } // NotSame asserts that two pointers do not reference the same object. // // a.NotSame(ptr1, ptr2) // // Both arguments must be pointer variables. Pointer variable sameness is // determined based on the equality of both type and value. func (a *Assertions) NotSame(expected interface{}, actual interface{}, msgAndArgs ...interface{}) { if h, ok := a.t.(tHelper); ok { h.Helper() } NotSame(a.t, expected, actual, msgAndArgs...) } // NotSamef asserts that two pointers do not reference the same object. // // a.NotSamef(ptr1, ptr2, "error message %s", "formatted") // // Both arguments must be pointer variables. Pointer variable sameness is // determined based on the equality of both type and value. func (a *Assertions) NotSamef(expected interface{}, actual interface{}, msg string, args ...interface{}) { if h, ok := a.t.(tHelper); ok { h.Helper() } NotSamef(a.t, expected, actual, msg, args...) } // NotSubset asserts that the specified list(array, slice...) contains not all // elements given in the specified subset(array, slice...). // // a.NotSubset([1, 3, 4], [1, 2], "But [1, 3, 4] does not contain [1, 2]") func (a *Assertions) NotSubset(list interface{}, subset interface{}, msgAndArgs ...interface{}) { if h, ok := a.t.(tHelper); ok { h.Helper() } NotSubset(a.t, list, subset, msgAndArgs...) } // NotSubsetf asserts that the specified list(array, slice...) contains not all // elements given in the specified subset(array, slice...). // // a.NotSubsetf([1, 3, 4], [1, 2], "But [1, 3, 4] does not contain [1, 2]", "error message %s", "formatted") func (a *Assertions) NotSubsetf(list interface{}, subset interface{}, msg string, args ...interface{}) { if h, ok := a.t.(tHelper); ok { h.Helper() } NotSubsetf(a.t, list, subset, msg, args...) } // NotZero asserts that i is not the zero value for its type. func (a *Assertions) NotZero(i interface{}, msgAndArgs ...interface{}) { if h, ok := a.t.(tHelper); ok { h.Helper() } NotZero(a.t, i, msgAndArgs...) } // NotZerof asserts that i is not the zero value for its type. func (a *Assertions) NotZerof(i interface{}, msg string, args ...interface{}) { if h, ok := a.t.(tHelper); ok { h.Helper() } NotZerof(a.t, i, msg, args...) } // Panics asserts that the code inside the specified PanicTestFunc panics. // // a.Panics(func(){ GoCrazy() }) func (a *Assertions) Panics(f assert.PanicTestFunc, msgAndArgs ...interface{}) { if h, ok := a.t.(tHelper); ok { h.Helper() } Panics(a.t, f, msgAndArgs...) } // PanicsWithError asserts that the code inside the specified PanicTestFunc // panics, and that the recovered panic value is an error that satisfies the // EqualError comparison. // // a.PanicsWithError("crazy error", func(){ GoCrazy() }) func (a *Assertions) PanicsWithError(errString string, f assert.PanicTestFunc, msgAndArgs ...interface{}) { if h, ok := a.t.(tHelper); ok { h.Helper() } PanicsWithError(a.t, errString, f, msgAndArgs...) } // PanicsWithErrorf asserts that the code inside the specified PanicTestFunc // panics, and that the recovered panic value is an error that satisfies the // EqualError comparison. // // a.PanicsWithErrorf("crazy error", func(){ GoCrazy() }, "error message %s", "formatted") func (a *Assertions) PanicsWithErrorf(errString string, f assert.PanicTestFunc, msg string, args ...interface{}) { if h, ok := a.t.(tHelper); ok { h.Helper() } PanicsWithErrorf(a.t, errString, f, msg, args...) } // PanicsWithValue asserts that the code inside the specified PanicTestFunc panics, and that // the recovered panic value equals the expected panic value. // // a.PanicsWithValue("crazy error", func(){ GoCrazy() }) func (a *Assertions) PanicsWithValue(expected interface{}, f assert.PanicTestFunc, msgAndArgs ...interface{}) { if h, ok := a.t.(tHelper); ok { h.Helper() } PanicsWithValue(a.t, expected, f, msgAndArgs...) } // PanicsWithValuef asserts that the code inside the specified PanicTestFunc panics, and that // the recovered panic value equals the expected panic value. // // a.PanicsWithValuef("crazy error", func(){ GoCrazy() }, "error message %s", "formatted") func (a *Assertions) PanicsWithValuef(expected interface{}, f assert.PanicTestFunc, msg string, args ...interface{}) { if h, ok := a.t.(tHelper); ok { h.Helper() } PanicsWithValuef(a.t, expected, f, msg, args...) } // Panicsf asserts that the code inside the specified PanicTestFunc panics. // // a.Panicsf(func(){ GoCrazy() }, "error message %s", "formatted") func (a *Assertions) Panicsf(f assert.PanicTestFunc, msg string, args ...interface{}) { if h, ok := a.t.(tHelper); ok { h.Helper() } Panicsf(a.t, f, msg, args...) } // Regexp asserts that a specified regexp matches a string. // // a.Regexp(regexp.MustCompile("start"), "it's starting") // a.Regexp("start...$", "it's not starting") func (a *Assertions) Regexp(rx interface{}, str interface{}, msgAndArgs ...interface{}) { if h, ok := a.t.(tHelper); ok { h.Helper() } Regexp(a.t, rx, str, msgAndArgs...) } // Regexpf asserts that a specified regexp matches a string. // // a.Regexpf(regexp.MustCompile("start", "error message %s", "formatted"), "it's starting") // a.Regexpf("start...$", "it's not starting", "error message %s", "formatted") func (a *Assertions) Regexpf(rx interface{}, str interface{}, msg string, args ...interface{}) { if h, ok := a.t.(tHelper); ok { h.Helper() } Regexpf(a.t, rx, str, msg, args...) } // Same asserts that two pointers reference the same object. // // a.Same(ptr1, ptr2) // // Both arguments must be pointer variables. Pointer variable sameness is // determined based on the equality of both type and value. func (a *Assertions) Same(expected interface{}, actual interface{}, msgAndArgs ...interface{}) { if h, ok := a.t.(tHelper); ok { h.Helper() } Same(a.t, expected, actual, msgAndArgs...) } // Samef asserts that two pointers reference the same object. // // a.Samef(ptr1, ptr2, "error message %s", "formatted") // // Both arguments must be pointer variables. Pointer variable sameness is // determined based on the equality of both type and value. func (a *Assertions) Samef(expected interface{}, actual interface{}, msg string, args ...interface{}) { if h, ok := a.t.(tHelper); ok { h.Helper() } Samef(a.t, expected, actual, msg, args...) } // Subset asserts that the specified list(array, slice...) contains all // elements given in the specified subset(array, slice...). // // a.Subset([1, 2, 3], [1, 2], "But [1, 2, 3] does contain [1, 2]") func (a *Assertions) Subset(list interface{}, subset interface{}, msgAndArgs ...interface{}) { if h, ok := a.t.(tHelper); ok { h.Helper() } Subset(a.t, list, subset, msgAndArgs...) } // Subsetf asserts that the specified list(array, slice...) contains all // elements given in the specified subset(array, slice...). // // a.Subsetf([1, 2, 3], [1, 2], "But [1, 2, 3] does contain [1, 2]", "error message %s", "formatted") func (a *Assertions) Subsetf(list interface{}, subset interface{}, msg string, args ...interface{}) { if h, ok := a.t.(tHelper); ok { h.Helper() } Subsetf(a.t, list, subset, msg, args...) } // True asserts that the specified value is true. // // a.True(myBool) func (a *Assertions) True(value bool, msgAndArgs ...interface{}) { if h, ok := a.t.(tHelper); ok { h.Helper() } True(a.t, value, msgAndArgs...) } // Truef asserts that the specified value is true. // // a.Truef(myBool, "error message %s", "formatted") func (a *Assertions) Truef(value bool, msg string, args ...interface{}) { if h, ok := a.t.(tHelper); ok { h.Helper() } Truef(a.t, value, msg, args...) } // WithinDuration asserts that the two times are within duration delta of each other. // // a.WithinDuration(time.Now(), time.Now(), 10*time.Second) func (a *Assertions) WithinDuration(expected time.Time, actual time.Time, delta time.Duration, msgAndArgs ...interface{}) { if h, ok := a.t.(tHelper); ok { h.Helper() } WithinDuration(a.t, expected, actual, delta, msgAndArgs...) } // WithinDurationf asserts that the two times are within duration delta of each other. // // a.WithinDurationf(time.Now(), time.Now(), 10*time.Second, "error message %s", "formatted") func (a *Assertions) WithinDurationf(expected time.Time, actual time.Time, delta time.Duration, msg string, args ...interface{}) { if h, ok := a.t.(tHelper); ok { h.Helper() } WithinDurationf(a.t, expected, actual, delta, msg, args...) } // YAMLEq asserts that two YAML strings are equivalent. func (a *Assertions) YAMLEq(expected string, actual string, msgAndArgs ...interface{}) { if h, ok := a.t.(tHelper); ok { h.Helper() } YAMLEq(a.t, expected, actual, msgAndArgs...) } // YAMLEqf asserts that two YAML strings are equivalent. func (a *Assertions) YAMLEqf(expected string, actual string, msg string, args ...interface{}) { if h, ok := a.t.(tHelper); ok { h.Helper() } YAMLEqf(a.t, expected, actual, msg, args...) } // Zero asserts that i is the zero value for its type. func (a *Assertions) Zero(i interface{}, msgAndArgs ...interface{}) { if h, ok := a.t.(tHelper); ok { h.Helper() } Zero(a.t, i, msgAndArgs...) } // Zerof asserts that i is the zero value for its type. func (a *Assertions) Zerof(i interface{}, msg string, args ...interface{}) { if h, ok := a.t.(tHelper); ok { h.Helper() } Zerof(a.t, i, msg, args...) } go-jmespath-0.4.0/internal/testify/require/require_forward.go.tmpl000066400000000000000000000002551373124421700254200ustar00rootroot00000000000000{{.CommentWithoutT "a"}} func (a *Assertions) {{.DocInfo.Name}}({{.Params}}) { if h, ok := a.t.(tHelper); ok { h.Helper() } {{.DocInfo.Name}}(a.t, {{.ForwardedParams}}) } go-jmespath-0.4.0/internal/testify/require/requirements.go000066400000000000000000000021531373124421700237670ustar00rootroot00000000000000package require // TestingT is an interface wrapper around *testing.T type TestingT interface { Errorf(format string, args ...interface{}) FailNow() } type tHelper interface { Helper() } // ComparisonAssertionFunc is a common function prototype when comparing two values. Can be useful // for table driven tests. type ComparisonAssertionFunc func(TestingT, interface{}, interface{}, ...interface{}) // ValueAssertionFunc is a common function prototype when validating a single value. Can be useful // for table driven tests. type ValueAssertionFunc func(TestingT, interface{}, ...interface{}) // BoolAssertionFunc is a common function prototype when validating a bool value. Can be useful // for table driven tests. type BoolAssertionFunc func(TestingT, bool, ...interface{}) // ErrorAssertionFunc is a common function prototype when validating an error value. Can be useful // for table driven tests. type ErrorAssertionFunc func(TestingT, error, ...interface{}) //go:generate sh -c "cd ../_codegen && go build && cd - && ../_codegen/_codegen -output-package=require -template=require.go.tmpl -include-format-funcs" go-jmespath-0.4.0/internal/testify/require/requirements_test.go000066400000000000000000000330141373124421700250260ustar00rootroot00000000000000package require import ( "encoding/json" "errors" "testing" "time" ) // AssertionTesterInterface defines an interface to be used for testing assertion methods type AssertionTesterInterface interface { TestMethod() } // AssertionTesterConformingObject is an object that conforms to the AssertionTesterInterface interface type AssertionTesterConformingObject struct { } func (a *AssertionTesterConformingObject) TestMethod() { } // AssertionTesterNonConformingObject is an object that does not conform to the AssertionTesterInterface interface type AssertionTesterNonConformingObject struct { } type MockT struct { Failed bool } func (t *MockT) FailNow() { t.Failed = true } func (t *MockT) Errorf(format string, args ...interface{}) { _, _ = format, args } func TestImplements(t *testing.T) { Implements(t, (*AssertionTesterInterface)(nil), new(AssertionTesterConformingObject)) mockT := new(MockT) Implements(mockT, (*AssertionTesterInterface)(nil), new(AssertionTesterNonConformingObject)) if !mockT.Failed { t.Error("Check should fail") } } func TestIsType(t *testing.T) { IsType(t, new(AssertionTesterConformingObject), new(AssertionTesterConformingObject)) mockT := new(MockT) IsType(mockT, new(AssertionTesterConformingObject), new(AssertionTesterNonConformingObject)) if !mockT.Failed { t.Error("Check should fail") } } func TestEqual(t *testing.T) { Equal(t, 1, 1) mockT := new(MockT) Equal(mockT, 1, 2) if !mockT.Failed { t.Error("Check should fail") } } func TestNotEqual(t *testing.T) { NotEqual(t, 1, 2) mockT := new(MockT) NotEqual(mockT, 2, 2) if !mockT.Failed { t.Error("Check should fail") } } func TestExactly(t *testing.T) { a := float32(1) b := float32(1) c := float64(1) Exactly(t, a, b) mockT := new(MockT) Exactly(mockT, a, c) if !mockT.Failed { t.Error("Check should fail") } } func TestNotNil(t *testing.T) { NotNil(t, new(AssertionTesterConformingObject)) mockT := new(MockT) NotNil(mockT, nil) if !mockT.Failed { t.Error("Check should fail") } } func TestNil(t *testing.T) { Nil(t, nil) mockT := new(MockT) Nil(mockT, new(AssertionTesterConformingObject)) if !mockT.Failed { t.Error("Check should fail") } } func TestTrue(t *testing.T) { True(t, true) mockT := new(MockT) True(mockT, false) if !mockT.Failed { t.Error("Check should fail") } } func TestFalse(t *testing.T) { False(t, false) mockT := new(MockT) False(mockT, true) if !mockT.Failed { t.Error("Check should fail") } } func TestContains(t *testing.T) { Contains(t, "Hello World", "Hello") mockT := new(MockT) Contains(mockT, "Hello World", "Salut") if !mockT.Failed { t.Error("Check should fail") } } func TestNotContains(t *testing.T) { NotContains(t, "Hello World", "Hello!") mockT := new(MockT) NotContains(mockT, "Hello World", "Hello") if !mockT.Failed { t.Error("Check should fail") } } func TestPanics(t *testing.T) { Panics(t, func() { panic("Panic!") }) mockT := new(MockT) Panics(mockT, func() {}) if !mockT.Failed { t.Error("Check should fail") } } func TestNotPanics(t *testing.T) { NotPanics(t, func() {}) mockT := new(MockT) NotPanics(mockT, func() { panic("Panic!") }) if !mockT.Failed { t.Error("Check should fail") } } func TestNoError(t *testing.T) { NoError(t, nil) mockT := new(MockT) NoError(mockT, errors.New("some error")) if !mockT.Failed { t.Error("Check should fail") } } func TestError(t *testing.T) { Error(t, errors.New("some error")) mockT := new(MockT) Error(mockT, nil) if !mockT.Failed { t.Error("Check should fail") } } func TestEqualError(t *testing.T) { EqualError(t, errors.New("some error"), "some error") mockT := new(MockT) EqualError(mockT, errors.New("some error"), "Not some error") if !mockT.Failed { t.Error("Check should fail") } } func TestEmpty(t *testing.T) { Empty(t, "") mockT := new(MockT) Empty(mockT, "x") if !mockT.Failed { t.Error("Check should fail") } } func TestNotEmpty(t *testing.T) { NotEmpty(t, "x") mockT := new(MockT) NotEmpty(mockT, "") if !mockT.Failed { t.Error("Check should fail") } } func TestWithinDuration(t *testing.T) { a := time.Now() b := a.Add(10 * time.Second) WithinDuration(t, a, b, 15*time.Second) mockT := new(MockT) WithinDuration(mockT, a, b, 5*time.Second) if !mockT.Failed { t.Error("Check should fail") } } func TestInDelta(t *testing.T) { InDelta(t, 1.001, 1, 0.01) mockT := new(MockT) InDelta(mockT, 1, 2, 0.5) if !mockT.Failed { t.Error("Check should fail") } } func TestZero(t *testing.T) { Zero(t, "") mockT := new(MockT) Zero(mockT, "x") if !mockT.Failed { t.Error("Check should fail") } } func TestNotZero(t *testing.T) { NotZero(t, "x") mockT := new(MockT) NotZero(mockT, "") if !mockT.Failed { t.Error("Check should fail") } } func TestJSONEq_EqualSONString(t *testing.T) { mockT := new(MockT) JSONEq(mockT, `{"hello": "world", "foo": "bar"}`, `{"hello": "world", "foo": "bar"}`) if mockT.Failed { t.Error("Check should pass") } } func TestJSONEq_EquivalentButNotEqual(t *testing.T) { mockT := new(MockT) JSONEq(mockT, `{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`) if mockT.Failed { t.Error("Check should pass") } } func TestJSONEq_HashOfArraysAndHashes(t *testing.T) { mockT := new(MockT) JSONEq(mockT, "{\r\n\t\"numeric\": 1.5,\r\n\t\"array\": [{\"foo\": \"bar\"}, 1, \"string\", [\"nested\", \"array\", 5.5]],\r\n\t\"hash\": {\"nested\": \"hash\", \"nested_slice\": [\"this\", \"is\", \"nested\"]},\r\n\t\"string\": \"foo\"\r\n}", "{\r\n\t\"numeric\": 1.5,\r\n\t\"hash\": {\"nested\": \"hash\", \"nested_slice\": [\"this\", \"is\", \"nested\"]},\r\n\t\"string\": \"foo\",\r\n\t\"array\": [{\"foo\": \"bar\"}, 1, \"string\", [\"nested\", \"array\", 5.5]]\r\n}") if mockT.Failed { t.Error("Check should pass") } } func TestJSONEq_Array(t *testing.T) { mockT := new(MockT) JSONEq(mockT, `["foo", {"hello": "world", "nested": "hash"}]`, `["foo", {"nested": "hash", "hello": "world"}]`) if mockT.Failed { t.Error("Check should pass") } } func TestJSONEq_HashAndArrayNotEquivalent(t *testing.T) { mockT := new(MockT) JSONEq(mockT, `["foo", {"hello": "world", "nested": "hash"}]`, `{"foo": "bar", {"nested": "hash", "hello": "world"}}`) if !mockT.Failed { t.Error("Check should fail") } } func TestJSONEq_HashesNotEquivalent(t *testing.T) { mockT := new(MockT) JSONEq(mockT, `{"foo": "bar"}`, `{"foo": "bar", "hello": "world"}`) if !mockT.Failed { t.Error("Check should fail") } } func TestJSONEq_ActualIsNotJSON(t *testing.T) { mockT := new(MockT) JSONEq(mockT, `{"foo": "bar"}`, "Not JSON") if !mockT.Failed { t.Error("Check should fail") } } func TestJSONEq_ExpectedIsNotJSON(t *testing.T) { mockT := new(MockT) JSONEq(mockT, "Not JSON", `{"foo": "bar", "hello": "world"}`) if !mockT.Failed { t.Error("Check should fail") } } func TestJSONEq_ExpectedAndActualNotJSON(t *testing.T) { mockT := new(MockT) JSONEq(mockT, "Not JSON", "Not JSON") if !mockT.Failed { t.Error("Check should fail") } } func TestJSONEq_ArraysOfDifferentOrder(t *testing.T) { mockT := new(MockT) JSONEq(mockT, `["foo", {"hello": "world", "nested": "hash"}]`, `[{ "hello": "world", "nested": "hash"}, "foo"]`) if !mockT.Failed { t.Error("Check should fail") } } func TestYAMLEq_EqualYAMLString(t *testing.T) { mockT := new(MockT) YAMLEq(mockT, `{"hello": "world", "foo": "bar"}`, `{"hello": "world", "foo": "bar"}`) if mockT.Failed { t.Error("Check should pass") } } func TestYAMLEq_EquivalentButNotEqual(t *testing.T) { mockT := new(MockT) YAMLEq(mockT, `{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`) if mockT.Failed { t.Error("Check should pass") } } func TestYAMLEq_HashOfArraysAndHashes(t *testing.T) { mockT := new(MockT) expected := ` numeric: 1.5 array: - foo: bar - 1 - "string" - ["nested", "array", 5.5] hash: nested: hash nested_slice: [this, is, nested] string: "foo" ` actual := ` numeric: 1.5 hash: nested: hash nested_slice: [this, is, nested] string: "foo" array: - foo: bar - 1 - "string" - ["nested", "array", 5.5] ` YAMLEq(mockT, expected, actual) if mockT.Failed { t.Error("Check should pass") } } func TestYAMLEq_Array(t *testing.T) { mockT := new(MockT) YAMLEq(mockT, `["foo", {"hello": "world", "nested": "hash"}]`, `["foo", {"nested": "hash", "hello": "world"}]`) if mockT.Failed { t.Error("Check should pass") } } func TestYAMLEq_HashAndArrayNotEquivalent(t *testing.T) { mockT := new(MockT) YAMLEq(mockT, `["foo", {"hello": "world", "nested": "hash"}]`, `{"foo": "bar", {"nested": "hash", "hello": "world"}}`) if !mockT.Failed { t.Error("Check should fail") } } func TestYAMLEq_HashesNotEquivalent(t *testing.T) { mockT := new(MockT) YAMLEq(mockT, `{"foo": "bar"}`, `{"foo": "bar", "hello": "world"}`) if !mockT.Failed { t.Error("Check should fail") } } func TestYAMLEq_ActualIsSimpleString(t *testing.T) { mockT := new(MockT) YAMLEq(mockT, `{"foo": "bar"}`, "Simple String") if !mockT.Failed { t.Error("Check should fail") } } func TestYAMLEq_ExpectedIsSimpleString(t *testing.T) { mockT := new(MockT) YAMLEq(mockT, "Simple String", `{"foo": "bar", "hello": "world"}`) if !mockT.Failed { t.Error("Check should fail") } } func TestYAMLEq_ExpectedAndActualSimpleString(t *testing.T) { mockT := new(MockT) YAMLEq(mockT, "Simple String", "Simple String") if mockT.Failed { t.Error("Check should pass") } } func TestYAMLEq_ArraysOfDifferentOrder(t *testing.T) { mockT := new(MockT) YAMLEq(mockT, `["foo", {"hello": "world", "nested": "hash"}]`, `[{ "hello": "world", "nested": "hash"}, "foo"]`) if !mockT.Failed { t.Error("Check should fail") } } func ExampleComparisonAssertionFunc() { t := &testing.T{} // provided by test adder := func(x, y int) int { return x + y } type args struct { x int y int } tests := []struct { name string args args expect int assertion ComparisonAssertionFunc }{ {"2+2=4", args{2, 2}, 4, Equal}, {"2+2!=5", args{2, 2}, 5, NotEqual}, {"2+3==5", args{2, 3}, 5, Exactly}, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { tt.assertion(t, tt.expect, adder(tt.args.x, tt.args.y)) }) } } func TestComparisonAssertionFunc(t *testing.T) { type iface interface { Name() string } tests := []struct { name string expect interface{} got interface{} assertion ComparisonAssertionFunc }{ {"implements", (*iface)(nil), t, Implements}, {"isType", (*testing.T)(nil), t, IsType}, {"equal", t, t, Equal}, {"equalValues", t, t, EqualValues}, {"exactly", t, t, Exactly}, {"notEqual", t, nil, NotEqual}, {"notContains", []int{1, 2, 3}, 4, NotContains}, {"subset", []int{1, 2, 3, 4}, []int{2, 3}, Subset}, {"notSubset", []int{1, 2, 3, 4}, []int{0, 3}, NotSubset}, {"elementsMatch", []byte("abc"), []byte("bac"), ElementsMatch}, {"regexp", "^t.*y$", "testify", Regexp}, {"notRegexp", "^t.*y$", "Testify", NotRegexp}, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { tt.assertion(t, tt.expect, tt.got) }) } } func ExampleValueAssertionFunc() { t := &testing.T{} // provided by test dumbParse := func(input string) interface{} { var x interface{} json.Unmarshal([]byte(input), &x) return x } tests := []struct { name string arg string assertion ValueAssertionFunc }{ {"true is not nil", "true", NotNil}, {"empty string is nil", "", Nil}, {"zero is not nil", "0", NotNil}, {"zero is zero", "0", Zero}, {"false is zero", "false", Zero}, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { tt.assertion(t, dumbParse(tt.arg)) }) } } func TestValueAssertionFunc(t *testing.T) { tests := []struct { name string value interface{} assertion ValueAssertionFunc }{ {"notNil", true, NotNil}, {"nil", nil, Nil}, {"empty", []int{}, Empty}, {"notEmpty", []int{1}, NotEmpty}, {"zero", false, Zero}, {"notZero", 42, NotZero}, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { tt.assertion(t, tt.value) }) } } func ExampleBoolAssertionFunc() { t := &testing.T{} // provided by test isOkay := func(x int) bool { return x >= 42 } tests := []struct { name string arg int assertion BoolAssertionFunc }{ {"-1 is bad", -1, False}, {"42 is good", 42, True}, {"41 is bad", 41, False}, {"45 is cool", 45, True}, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { tt.assertion(t, isOkay(tt.arg)) }) } } func TestBoolAssertionFunc(t *testing.T) { tests := []struct { name string value bool assertion BoolAssertionFunc }{ {"true", true, True}, {"false", false, False}, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { tt.assertion(t, tt.value) }) } } func ExampleErrorAssertionFunc() { t := &testing.T{} // provided by test dumbParseNum := func(input string, v interface{}) error { return json.Unmarshal([]byte(input), v) } tests := []struct { name string arg string assertion ErrorAssertionFunc }{ {"1.2 is number", "1.2", NoError}, {"1.2.3 not number", "1.2.3", Error}, {"true is not number", "true", Error}, {"3 is number", "3", NoError}, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { var x float64 tt.assertion(t, dumbParseNum(tt.arg, &x)) }) } } func TestErrorAssertionFunc(t *testing.T) { tests := []struct { name string err error assertion ErrorAssertionFunc }{ {"noError", nil, NoError}, {"error", errors.New("whoops"), Error}, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { tt.assertion(t, tt.err) }) } } go-jmespath-0.4.0/internal/testify/suite/000077500000000000000000000000001373124421700203715ustar00rootroot00000000000000go-jmespath-0.4.0/internal/testify/suite/doc.go000066400000000000000000000052441373124421700214720ustar00rootroot00000000000000// Package suite contains logic for creating testing suite structs // and running the methods on those structs as tests. The most useful // piece of this package is that you can create setup/teardown methods // on your testing suites, which will run before/after the whole suite // or individual tests (depending on which interface(s) you // implement). // // A testing suite is usually built by first extending the built-in // suite functionality from suite.Suite in testify. Alternatively, // you could reproduce that logic on your own if you wanted (you // just need to implement the TestingSuite interface from // suite/interfaces.go). // // After that, you can implement any of the interfaces in // suite/interfaces.go to add setup/teardown functionality to your // suite, and add any methods that start with "Test" to add tests. // Methods that do not match any suite interfaces and do not begin // with "Test" will not be run by testify, and can safely be used as // helper methods. // // Once you've built your testing suite, you need to run the suite // (using suite.Run from testify) inside any function that matches the // identity that "go test" is already looking for (i.e. // func(*testing.T)). // // Regular expression to select test suites specified command-line // argument "-run". Regular expression to select the methods // of test suites specified command-line argument "-m". // Suite object has assertion methods. // // A crude example: // // Basic imports // import ( // "testing" // "github.com/jmespath/go-jmespath/internal/testify/assert" // "github.com/jmespath/go-jmespath/internal/testify/suite" // ) // // // Define the suite, and absorb the built-in basic suite // // functionality from testify - including a T() method which // // returns the current testing context // type ExampleTestSuite struct { // suite.Suite // VariableThatShouldStartAtFive int // } // // // Make sure that VariableThatShouldStartAtFive is set to five // // before each test // func (suite *ExampleTestSuite) SetupTest() { // suite.VariableThatShouldStartAtFive = 5 // } // // // All methods that begin with "Test" are run as tests within a // // suite. // func (suite *ExampleTestSuite) TestExample() { // assert.Equal(suite.T(), 5, suite.VariableThatShouldStartAtFive) // suite.Equal(5, suite.VariableThatShouldStartAtFive) // } // // // In order for 'go test' to run this suite, we need to create // // a normal test function and pass our suite to suite.Run // func TestExampleTestSuite(t *testing.T) { // suite.Run(t, new(ExampleTestSuite)) // } package suite go-jmespath-0.4.0/internal/testify/suite/interfaces.go000066400000000000000000000022401373124421700230410ustar00rootroot00000000000000package suite import "testing" // TestingSuite can store and return the current *testing.T context // generated by 'go test'. type TestingSuite interface { T() *testing.T SetT(*testing.T) } // SetupAllSuite has a SetupSuite method, which will run before the // tests in the suite are run. type SetupAllSuite interface { SetupSuite() } // SetupTestSuite has a SetupTest method, which will run before each // test in the suite. type SetupTestSuite interface { SetupTest() } // TearDownAllSuite has a TearDownSuite method, which will run after // all the tests in the suite have been run. type TearDownAllSuite interface { TearDownSuite() } // TearDownTestSuite has a TearDownTest method, which will run after // each test in the suite. type TearDownTestSuite interface { TearDownTest() } // BeforeTest has a function to be executed right before the test // starts and receives the suite and test names as input type BeforeTest interface { BeforeTest(suiteName, testName string) } // AfterTest has a function to be executed right after the test // finishes and receives the suite and test names as input type AfterTest interface { AfterTest(suiteName, testName string) } go-jmespath-0.4.0/internal/testify/suite/suite.go000066400000000000000000000106521373124421700220550ustar00rootroot00000000000000package suite import ( "flag" "fmt" "os" "reflect" "regexp" "runtime/debug" "sync" "testing" "github.com/jmespath/go-jmespath/internal/testify/assert" "github.com/jmespath/go-jmespath/internal/testify/require" ) var allTestsFilter = func(_, _ string) (bool, error) { return true, nil } var matchMethod = flag.String("testify.m", "", "regular expression to select tests of the testify suite to run") // Suite is a basic testing suite with methods for storing and // retrieving the current *testing.T context. type Suite struct { *assert.Assertions require *require.Assertions t *testing.T } // T retrieves the current *testing.T context. func (suite *Suite) T() *testing.T { return suite.t } // SetT sets the current *testing.T context. func (suite *Suite) SetT(t *testing.T) { suite.t = t suite.Assertions = assert.New(t) suite.require = require.New(t) } // Require returns a require context for suite. func (suite *Suite) Require() *require.Assertions { if suite.require == nil { suite.require = require.New(suite.T()) } return suite.require } // Assert returns an assert context for suite. Normally, you can call // `suite.NoError(expected, actual)`, but for situations where the embedded // methods are overridden (for example, you might want to override // assert.Assertions with require.Assertions), this method is provided so you // can call `suite.Assert().NoError()`. func (suite *Suite) Assert() *assert.Assertions { if suite.Assertions == nil { suite.Assertions = assert.New(suite.T()) } return suite.Assertions } func failOnPanic(t *testing.T) { r := recover() if r != nil { t.Errorf("test panicked: %v\n%s", r, debug.Stack()) t.FailNow() } } // Run provides suite functionality around golang subtests. It should be // called in place of t.Run(name, func(t *testing.T)) in test suite code. // The passed-in func will be executed as a subtest with a fresh instance of t. // Provides compatibility with go test pkg -run TestSuite/TestName/SubTestName. func (suite *Suite) Run(name string, subtest func()) bool { oldT := suite.T() defer suite.SetT(oldT) return oldT.Run(name, func(t *testing.T) { suite.SetT(t) subtest() }) } // Run takes a testing suite and runs all of the tests attached // to it. func Run(t *testing.T, suite TestingSuite) { testsSync := &sync.WaitGroup{} suite.SetT(t) defer failOnPanic(t) suiteSetupDone := false methodFinder := reflect.TypeOf(suite) tests := []testing.InternalTest{} for index := 0; index < methodFinder.NumMethod(); index++ { method := methodFinder.Method(index) ok, err := methodFilter(method.Name) if err != nil { fmt.Fprintf(os.Stderr, "testify: invalid regexp for -m: %s\n", err) os.Exit(1) } if !ok { continue } if !suiteSetupDone { if setupAllSuite, ok := suite.(SetupAllSuite); ok { setupAllSuite.SetupSuite() } defer func() { if tearDownAllSuite, ok := suite.(TearDownAllSuite); ok { testsSync.Wait() tearDownAllSuite.TearDownSuite() } }() suiteSetupDone = true } test := testing.InternalTest{ Name: method.Name, F: func(t *testing.T) { defer testsSync.Done() parentT := suite.T() suite.SetT(t) defer failOnPanic(t) if setupTestSuite, ok := suite.(SetupTestSuite); ok { setupTestSuite.SetupTest() } if beforeTestSuite, ok := suite.(BeforeTest); ok { beforeTestSuite.BeforeTest(methodFinder.Elem().Name(), method.Name) } defer func() { if afterTestSuite, ok := suite.(AfterTest); ok { afterTestSuite.AfterTest(methodFinder.Elem().Name(), method.Name) } if tearDownTestSuite, ok := suite.(TearDownTestSuite); ok { tearDownTestSuite.TearDownTest() } suite.SetT(parentT) }() method.Func.Call([]reflect.Value{reflect.ValueOf(suite)}) }, } tests = append(tests, test) testsSync.Add(1) } runTests(t, tests) } func runTests(t testing.TB, tests []testing.InternalTest) { r, ok := t.(runner) if !ok { // backwards compatibility with Go 1.6 and below if !testing.RunTests(allTestsFilter, tests) { t.Fail() } return } for _, test := range tests { r.Run(test.Name, test.F) } } // Filtering method according to set regular expression // specified command-line argument -m func methodFilter(name string) (bool, error) { if ok, _ := regexp.MatchString("^Test", name); !ok { return false, nil } return regexp.MatchString(*matchMethod, name) } type runner interface { Run(name string, f func(t *testing.T)) bool } go-jmespath-0.4.0/internal/testify/suite/suite_test.go000066400000000000000000000313721373124421700231160ustar00rootroot00000000000000package suite import ( "errors" "io/ioutil" "math/rand" "os" "strings" "testing" "time" "github.com/jmespath/go-jmespath/internal/testify/assert" "github.com/jmespath/go-jmespath/internal/testify/require" ) // SuiteRequireTwice is intended to test the usage of suite.Require in two // different tests type SuiteRequireTwice struct{ Suite } // TestSuiteRequireTwice checks for regressions of issue #149 where // suite.requirements was not initialised in suite.SetT() // A regression would result on these tests panicking rather than failing. func TestSuiteRequireTwice(t *testing.T) { ok := testing.RunTests( allTestsFilter, []testing.InternalTest{{ Name: "TestSuiteRequireTwice", F: func(t *testing.T) { suite := new(SuiteRequireTwice) Run(t, suite) }, }}, ) assert.Equal(t, false, ok) } func (s *SuiteRequireTwice) TestRequireOne() { r := s.Require() r.Equal(1, 2) } func (s *SuiteRequireTwice) TestRequireTwo() { r := s.Require() r.Equal(1, 2) } type panickingSuite struct { Suite panicInSetupSuite bool panicInSetupTest bool panicInBeforeTest bool panicInTest bool panicInAfterTest bool panicInTearDownTest bool panicInTearDownSuite bool } func (s *panickingSuite) SetupSuite() { if s.panicInSetupSuite { panic("oops in setup suite") } } func (s *panickingSuite) SetupTest() { if s.panicInSetupTest { panic("oops in setup test") } } func (s *panickingSuite) BeforeTest(_, _ string) { if s.panicInBeforeTest { panic("oops in before test") } } func (s *panickingSuite) Test() { if s.panicInTest { panic("oops in test") } } func (s *panickingSuite) AfterTest(_, _ string) { if s.panicInAfterTest { panic("oops in after test") } } func (s *panickingSuite) TearDownTest() { if s.panicInTearDownTest { panic("oops in tear down test") } } func (s *panickingSuite) TearDownSuite() { if s.panicInTearDownSuite { panic("oops in tear down suite") } } func TestSuiteRecoverPanic(t *testing.T) { ok := true panickingTests := []testing.InternalTest{ { Name: "TestPanicInSetupSuite", F: func(t *testing.T) { Run(t, &panickingSuite{panicInSetupSuite: true}) }, }, { Name: "TestPanicInSetupTest", F: func(t *testing.T) { Run(t, &panickingSuite{panicInSetupTest: true}) }, }, { Name: "TestPanicInBeforeTest", F: func(t *testing.T) { Run(t, &panickingSuite{panicInBeforeTest: true}) }, }, { Name: "TestPanicInTest", F: func(t *testing.T) { Run(t, &panickingSuite{panicInTest: true}) }, }, { Name: "TestPanicInAfterTest", F: func(t *testing.T) { Run(t, &panickingSuite{panicInAfterTest: true}) }, }, { Name: "TestPanicInTearDownTest", F: func(t *testing.T) { Run(t, &panickingSuite{panicInTearDownTest: true}) }, }, { Name: "TestPanicInTearDownSuite", F: func(t *testing.T) { Run(t, &panickingSuite{panicInTearDownSuite: true}) }, }, } require.NotPanics(t, func() { ok = testing.RunTests(allTestsFilter, panickingTests) }) assert.False(t, ok) } // This suite is intended to store values to make sure that only // testing-suite-related methods are run. It's also a fully // functional example of a testing suite, using setup/teardown methods // and a helper method that is ignored by testify. To make this look // more like a real world example, all tests in the suite perform some // type of assertion. type SuiteTester struct { // Include our basic suite logic. Suite // Keep counts of how many times each method is run. SetupSuiteRunCount int TearDownSuiteRunCount int SetupTestRunCount int TearDownTestRunCount int TestOneRunCount int TestTwoRunCount int TestSubtestRunCount int NonTestMethodRunCount int SuiteNameBefore []string TestNameBefore []string SuiteNameAfter []string TestNameAfter []string TimeBefore []time.Time TimeAfter []time.Time } // The SetupSuite method will be run by testify once, at the very // start of the testing suite, before any tests are run. func (suite *SuiteTester) SetupSuite() { suite.SetupSuiteRunCount++ } func (suite *SuiteTester) BeforeTest(suiteName, testName string) { suite.SuiteNameBefore = append(suite.SuiteNameBefore, suiteName) suite.TestNameBefore = append(suite.TestNameBefore, testName) suite.TimeBefore = append(suite.TimeBefore, time.Now()) } func (suite *SuiteTester) AfterTest(suiteName, testName string) { suite.SuiteNameAfter = append(suite.SuiteNameAfter, suiteName) suite.TestNameAfter = append(suite.TestNameAfter, testName) suite.TimeAfter = append(suite.TimeAfter, time.Now()) } // The TearDownSuite method will be run by testify once, at the very // end of the testing suite, after all tests have been run. func (suite *SuiteTester) TearDownSuite() { suite.TearDownSuiteRunCount++ } // The SetupTest method will be run before every test in the suite. func (suite *SuiteTester) SetupTest() { suite.SetupTestRunCount++ } // The TearDownTest method will be run after every test in the suite. func (suite *SuiteTester) TearDownTest() { suite.TearDownTestRunCount++ } // Every method in a testing suite that begins with "Test" will be run // as a test. TestOne is an example of a test. For the purposes of // this example, we've included assertions in the tests, since most // tests will issue assertions. func (suite *SuiteTester) TestOne() { beforeCount := suite.TestOneRunCount suite.TestOneRunCount++ assert.Equal(suite.T(), suite.TestOneRunCount, beforeCount+1) suite.Equal(suite.TestOneRunCount, beforeCount+1) } // TestTwo is another example of a test. func (suite *SuiteTester) TestTwo() { beforeCount := suite.TestTwoRunCount suite.TestTwoRunCount++ assert.NotEqual(suite.T(), suite.TestTwoRunCount, beforeCount) suite.NotEqual(suite.TestTwoRunCount, beforeCount) } func (suite *SuiteTester) TestSkip() { suite.T().Skip() } // NonTestMethod does not begin with "Test", so it will not be run by // testify as a test in the suite. This is useful for creating helper // methods for your tests. func (suite *SuiteTester) NonTestMethod() { suite.NonTestMethodRunCount++ } func (suite *SuiteTester) TestSubtest() { suite.TestSubtestRunCount++ for _, t := range []struct { testName string }{ {"first"}, {"second"}, } { suiteT := suite.T() suite.Run(t.testName, func() { // We should get a different *testing.T for subtests, so that // go test recognizes them as proper subtests for output formatting // and running individual subtests subTestT := suite.T() suite.NotEqual(subTestT, suiteT) }) suite.Equal(suiteT, suite.T()) } } type SuiteSkipTester struct { // Include our basic suite logic. Suite // Keep counts of how many times each method is run. SetupSuiteRunCount int TearDownSuiteRunCount int } func (suite *SuiteSkipTester) SetupSuite() { suite.SetupSuiteRunCount++ suite.T().Skip() } func (suite *SuiteSkipTester) TestNothing() { // SetupSuite is only called when at least one test satisfies // test filter. For this suite to be set up (and then tore down) // it is necessary to add at least one test method. } func (suite *SuiteSkipTester) TearDownSuite() { suite.TearDownSuiteRunCount++ } // TestRunSuite will be run by the 'go test' command, so within it, we // can run our suite using the Run(*testing.T, TestingSuite) function. func TestRunSuite(t *testing.T) { suiteTester := new(SuiteTester) Run(t, suiteTester) // Normally, the test would end here. The following are simply // some assertions to ensure that the Run function is working as // intended - they are not part of the example. // The suite was only run once, so the SetupSuite and TearDownSuite // methods should have each been run only once. assert.Equal(t, suiteTester.SetupSuiteRunCount, 1) assert.Equal(t, suiteTester.TearDownSuiteRunCount, 1) assert.Equal(t, len(suiteTester.SuiteNameAfter), 4) assert.Equal(t, len(suiteTester.SuiteNameBefore), 4) assert.Equal(t, len(suiteTester.TestNameAfter), 4) assert.Equal(t, len(suiteTester.TestNameBefore), 4) assert.Contains(t, suiteTester.TestNameAfter, "TestOne") assert.Contains(t, suiteTester.TestNameAfter, "TestTwo") assert.Contains(t, suiteTester.TestNameAfter, "TestSkip") assert.Contains(t, suiteTester.TestNameAfter, "TestSubtest") assert.Contains(t, suiteTester.TestNameBefore, "TestOne") assert.Contains(t, suiteTester.TestNameBefore, "TestTwo") assert.Contains(t, suiteTester.TestNameBefore, "TestSkip") assert.Contains(t, suiteTester.TestNameBefore, "TestSubtest") for _, suiteName := range suiteTester.SuiteNameAfter { assert.Equal(t, "SuiteTester", suiteName) } for _, suiteName := range suiteTester.SuiteNameBefore { assert.Equal(t, "SuiteTester", suiteName) } for _, when := range suiteTester.TimeAfter { assert.False(t, when.IsZero()) } for _, when := range suiteTester.TimeBefore { assert.False(t, when.IsZero()) } // There are four test methods (TestOne, TestTwo, TestSkip, and TestSubtest), so // the SetupTest and TearDownTest methods (which should be run once for // each test) should have been run four times. assert.Equal(t, suiteTester.SetupTestRunCount, 4) assert.Equal(t, suiteTester.TearDownTestRunCount, 4) // Each test should have been run once. assert.Equal(t, suiteTester.TestOneRunCount, 1) assert.Equal(t, suiteTester.TestTwoRunCount, 1) assert.Equal(t, suiteTester.TestSubtestRunCount, 1) // Methods that don't match the test method identifier shouldn't // have been run at all. assert.Equal(t, suiteTester.NonTestMethodRunCount, 0) suiteSkipTester := new(SuiteSkipTester) Run(t, suiteSkipTester) // The suite was only run once, so the SetupSuite and TearDownSuite // methods should have each been run only once, even though SetupSuite // called Skip() assert.Equal(t, suiteSkipTester.SetupSuiteRunCount, 1) assert.Equal(t, suiteSkipTester.TearDownSuiteRunCount, 1) } // This suite has no Test... methods. It's setup and teardown must be skipped. type SuiteSetupSkipTester struct { Suite setUp bool toreDown bool } func (s *SuiteSetupSkipTester) SetupSuite() { s.setUp = true } func (s *SuiteSetupSkipTester) NonTestMethod() { } func (s *SuiteSetupSkipTester) TearDownSuite() { s.toreDown = true } func TestSkippingSuiteSetup(t *testing.T) { suiteTester := new(SuiteSetupSkipTester) Run(t, suiteTester) assert.False(t, suiteTester.setUp) assert.False(t, suiteTester.toreDown) } func TestSuiteGetters(t *testing.T) { suite := new(SuiteTester) suite.SetT(t) assert.NotNil(t, suite.Assert()) assert.Equal(t, suite.Assertions, suite.Assert()) assert.NotNil(t, suite.Require()) assert.Equal(t, suite.require, suite.Require()) } type SuiteLoggingTester struct { Suite } func (s *SuiteLoggingTester) TestLoggingPass() { s.T().Log("TESTLOGPASS") } func (s *SuiteLoggingTester) TestLoggingFail() { s.T().Log("TESTLOGFAIL") assert.NotNil(s.T(), nil) // expected to fail } type StdoutCapture struct { oldStdout *os.File readPipe *os.File } func (sc *StdoutCapture) StartCapture() { sc.oldStdout = os.Stdout sc.readPipe, os.Stdout, _ = os.Pipe() } func (sc *StdoutCapture) StopCapture() (string, error) { if sc.oldStdout == nil || sc.readPipe == nil { return "", errors.New("StartCapture not called before StopCapture") } os.Stdout.Close() os.Stdout = sc.oldStdout bytes, err := ioutil.ReadAll(sc.readPipe) if err != nil { return "", err } return string(bytes), nil } func TestSuiteLogging(t *testing.T) { suiteLoggingTester := new(SuiteLoggingTester) capture := StdoutCapture{} internalTest := testing.InternalTest{ Name: "SomeTest", F: func(subT *testing.T) { Run(subT, suiteLoggingTester) }, } capture.StartCapture() testing.RunTests(allTestsFilter, []testing.InternalTest{internalTest}) output, err := capture.StopCapture() require.NoError(t, err, "Got an error trying to capture stdout and stderr!") require.NotEmpty(t, output, "output content must not be empty") // Failed tests' output is always printed assert.Contains(t, output, "TESTLOGFAIL") if testing.Verbose() { // In verbose mode, output from successful tests is also printed assert.Contains(t, output, "TESTLOGPASS") } else { assert.NotContains(t, output, "TESTLOGPASS") } } type CallOrderSuite struct { Suite callOrder []string } func (s *CallOrderSuite) call(method string) { time.Sleep(time.Duration(rand.Intn(300)) * time.Millisecond) s.callOrder = append(s.callOrder, method) } func TestSuiteCallOrder(t *testing.T) { Run(t, new(CallOrderSuite)) } func (s *CallOrderSuite) SetupSuite() { s.call("SetupSuite") } func (s *CallOrderSuite) TearDownSuite() { s.call("TearDownSuite") assert.Equal(s.T(), "SetupSuite;SetupTest;Test A;TearDownTest;SetupTest;Test B;TearDownTest;TearDownSuite", strings.Join(s.callOrder, ";")) } func (s *CallOrderSuite) SetupTest() { s.call("SetupTest") } func (s *CallOrderSuite) TearDownTest() { s.call("TearDownTest") } func (s *CallOrderSuite) Test_A() { s.call("Test A") } func (s *CallOrderSuite) Test_B() { s.call("Test B") } go-jmespath-0.4.0/interpreter.go000066400000000000000000000244141373124421700166340ustar00rootroot00000000000000package jmespath import ( "errors" "reflect" "unicode" "unicode/utf8" ) /* This is a tree based interpreter. It walks the AST and directly interprets the AST to search through a JSON document. */ type treeInterpreter struct { fCall *functionCaller } func newInterpreter() *treeInterpreter { interpreter := treeInterpreter{} interpreter.fCall = newFunctionCaller() return &interpreter } type expRef struct { ref ASTNode } // Execute takes an ASTNode and input data and interprets the AST directly. // It will produce the result of applying the JMESPath expression associated // with the ASTNode to the input data "value". func (intr *treeInterpreter) Execute(node ASTNode, value interface{}) (interface{}, error) { switch node.nodeType { case ASTComparator: left, err := intr.Execute(node.children[0], value) if err != nil { return nil, err } right, err := intr.Execute(node.children[1], value) if err != nil { return nil, err } switch node.value { case tEQ: return objsEqual(left, right), nil case tNE: return !objsEqual(left, right), nil } leftNum, ok := left.(float64) if !ok { return nil, nil } rightNum, ok := right.(float64) if !ok { return nil, nil } switch node.value { case tGT: return leftNum > rightNum, nil case tGTE: return leftNum >= rightNum, nil case tLT: return leftNum < rightNum, nil case tLTE: return leftNum <= rightNum, nil } case ASTExpRef: return expRef{ref: node.children[0]}, nil case ASTFunctionExpression: resolvedArgs := []interface{}{} for _, arg := range node.children { current, err := intr.Execute(arg, value) if err != nil { return nil, err } resolvedArgs = append(resolvedArgs, current) } return intr.fCall.CallFunction(node.value.(string), resolvedArgs, intr) case ASTField: if m, ok := value.(map[string]interface{}); ok { key := node.value.(string) return m[key], nil } return intr.fieldFromStruct(node.value.(string), value) case ASTFilterProjection: left, err := intr.Execute(node.children[0], value) if err != nil { return nil, nil } sliceType, ok := left.([]interface{}) if !ok { if isSliceType(left) { return intr.filterProjectionWithReflection(node, left) } return nil, nil } compareNode := node.children[2] collected := []interface{}{} for _, element := range sliceType { result, err := intr.Execute(compareNode, element) if err != nil { return nil, err } if !isFalse(result) { current, err := intr.Execute(node.children[1], element) if err != nil { return nil, err } if current != nil { collected = append(collected, current) } } } return collected, nil case ASTFlatten: left, err := intr.Execute(node.children[0], value) if err != nil { return nil, nil } sliceType, ok := left.([]interface{}) if !ok { // If we can't type convert to []interface{}, there's // a chance this could still work via reflection if we're // dealing with user provided types. if isSliceType(left) { return intr.flattenWithReflection(left) } return nil, nil } flattened := []interface{}{} for _, element := range sliceType { if elementSlice, ok := element.([]interface{}); ok { flattened = append(flattened, elementSlice...) } else if isSliceType(element) { reflectFlat := []interface{}{} v := reflect.ValueOf(element) for i := 0; i < v.Len(); i++ { reflectFlat = append(reflectFlat, v.Index(i).Interface()) } flattened = append(flattened, reflectFlat...) } else { flattened = append(flattened, element) } } return flattened, nil case ASTIdentity, ASTCurrentNode: return value, nil case ASTIndex: if sliceType, ok := value.([]interface{}); ok { index := node.value.(int) if index < 0 { index += len(sliceType) } if index < len(sliceType) && index >= 0 { return sliceType[index], nil } return nil, nil } // Otherwise try via reflection. rv := reflect.ValueOf(value) if rv.Kind() == reflect.Slice { index := node.value.(int) if index < 0 { index += rv.Len() } if index < rv.Len() && index >= 0 { v := rv.Index(index) return v.Interface(), nil } } return nil, nil case ASTKeyValPair: return intr.Execute(node.children[0], value) case ASTLiteral: return node.value, nil case ASTMultiSelectHash: if value == nil { return nil, nil } collected := make(map[string]interface{}) for _, child := range node.children { current, err := intr.Execute(child, value) if err != nil { return nil, err } key := child.value.(string) collected[key] = current } return collected, nil case ASTMultiSelectList: if value == nil { return nil, nil } collected := []interface{}{} for _, child := range node.children { current, err := intr.Execute(child, value) if err != nil { return nil, err } collected = append(collected, current) } return collected, nil case ASTOrExpression: matched, err := intr.Execute(node.children[0], value) if err != nil { return nil, err } if isFalse(matched) { matched, err = intr.Execute(node.children[1], value) if err != nil { return nil, err } } return matched, nil case ASTAndExpression: matched, err := intr.Execute(node.children[0], value) if err != nil { return nil, err } if isFalse(matched) { return matched, nil } return intr.Execute(node.children[1], value) case ASTNotExpression: matched, err := intr.Execute(node.children[0], value) if err != nil { return nil, err } if isFalse(matched) { return true, nil } return false, nil case ASTPipe: result := value var err error for _, child := range node.children { result, err = intr.Execute(child, result) if err != nil { return nil, err } } return result, nil case ASTProjection: left, err := intr.Execute(node.children[0], value) if err != nil { return nil, err } sliceType, ok := left.([]interface{}) if !ok { if isSliceType(left) { return intr.projectWithReflection(node, left) } return nil, nil } collected := []interface{}{} var current interface{} for _, element := range sliceType { current, err = intr.Execute(node.children[1], element) if err != nil { return nil, err } if current != nil { collected = append(collected, current) } } return collected, nil case ASTSubexpression, ASTIndexExpression: left, err := intr.Execute(node.children[0], value) if err != nil { return nil, err } return intr.Execute(node.children[1], left) case ASTSlice: sliceType, ok := value.([]interface{}) if !ok { if isSliceType(value) { return intr.sliceWithReflection(node, value) } return nil, nil } parts := node.value.([]*int) sliceParams := make([]sliceParam, 3) for i, part := range parts { if part != nil { sliceParams[i].Specified = true sliceParams[i].N = *part } } return slice(sliceType, sliceParams) case ASTValueProjection: left, err := intr.Execute(node.children[0], value) if err != nil { return nil, nil } mapType, ok := left.(map[string]interface{}) if !ok { return nil, nil } values := make([]interface{}, len(mapType)) for _, value := range mapType { values = append(values, value) } collected := []interface{}{} for _, element := range values { current, err := intr.Execute(node.children[1], element) if err != nil { return nil, err } if current != nil { collected = append(collected, current) } } return collected, nil } return nil, errors.New("Unknown AST node: " + node.nodeType.String()) } func (intr *treeInterpreter) fieldFromStruct(key string, value interface{}) (interface{}, error) { rv := reflect.ValueOf(value) first, n := utf8.DecodeRuneInString(key) fieldName := string(unicode.ToUpper(first)) + key[n:] if rv.Kind() == reflect.Struct { v := rv.FieldByName(fieldName) if !v.IsValid() { return nil, nil } return v.Interface(), nil } else if rv.Kind() == reflect.Ptr { // Handle multiple levels of indirection? if rv.IsNil() { return nil, nil } rv = rv.Elem() v := rv.FieldByName(fieldName) if !v.IsValid() { return nil, nil } return v.Interface(), nil } return nil, nil } func (intr *treeInterpreter) flattenWithReflection(value interface{}) (interface{}, error) { v := reflect.ValueOf(value) flattened := []interface{}{} for i := 0; i < v.Len(); i++ { element := v.Index(i).Interface() if reflect.TypeOf(element).Kind() == reflect.Slice { // Then insert the contents of the element // slice into the flattened slice, // i.e flattened = append(flattened, mySlice...) elementV := reflect.ValueOf(element) for j := 0; j < elementV.Len(); j++ { flattened = append( flattened, elementV.Index(j).Interface()) } } else { flattened = append(flattened, element) } } return flattened, nil } func (intr *treeInterpreter) sliceWithReflection(node ASTNode, value interface{}) (interface{}, error) { v := reflect.ValueOf(value) parts := node.value.([]*int) sliceParams := make([]sliceParam, 3) for i, part := range parts { if part != nil { sliceParams[i].Specified = true sliceParams[i].N = *part } } final := []interface{}{} for i := 0; i < v.Len(); i++ { element := v.Index(i).Interface() final = append(final, element) } return slice(final, sliceParams) } func (intr *treeInterpreter) filterProjectionWithReflection(node ASTNode, value interface{}) (interface{}, error) { compareNode := node.children[2] collected := []interface{}{} v := reflect.ValueOf(value) for i := 0; i < v.Len(); i++ { element := v.Index(i).Interface() result, err := intr.Execute(compareNode, element) if err != nil { return nil, err } if !isFalse(result) { current, err := intr.Execute(node.children[1], element) if err != nil { return nil, err } if current != nil { collected = append(collected, current) } } } return collected, nil } func (intr *treeInterpreter) projectWithReflection(node ASTNode, value interface{}) (interface{}, error) { collected := []interface{}{} v := reflect.ValueOf(value) for i := 0; i < v.Len(); i++ { element := v.Index(i).Interface() result, err := intr.Execute(node.children[1], element) if err != nil { return nil, err } if result != nil { collected = append(collected, result) } } return collected, nil } go-jmespath-0.4.0/interpreter_test.go000066400000000000000000000131751373124421700176750ustar00rootroot00000000000000package jmespath import ( "encoding/json" "testing" "github.com/jmespath/go-jmespath/internal/testify/assert" ) type scalars struct { Foo string Bar string } type sliceType struct { A string B []scalars C []*scalars } type benchmarkStruct struct { Fooasdfasdfasdfasdf string } type benchmarkNested struct { Fooasdfasdfasdfasdf nestedA } type nestedA struct { Fooasdfasdfasdfasdf nestedB } type nestedB struct { Fooasdfasdfasdfasdf nestedC } type nestedC struct { Fooasdfasdfasdfasdf string } type nestedSlice struct { A []sliceType } func TestCanSupportEmptyInterface(t *testing.T) { assert := assert.New(t) data := make(map[string]interface{}) data["foo"] = "bar" result, err := Search("foo", data) assert.Nil(err) assert.Equal("bar", result) } func TestCanSupportUserDefinedStructsValue(t *testing.T) { assert := assert.New(t) s := scalars{Foo: "one", Bar: "bar"} result, err := Search("Foo", s) assert.Nil(err) assert.Equal("one", result) } func TestCanSupportUserDefinedStructsRef(t *testing.T) { assert := assert.New(t) s := scalars{Foo: "one", Bar: "bar"} result, err := Search("Foo", &s) assert.Nil(err) assert.Equal("one", result) } func TestCanSupportStructWithSliceAll(t *testing.T) { assert := assert.New(t) data := sliceType{A: "foo", B: []scalars{{"f1", "b1"}, {"correct", "b2"}}} result, err := Search("B[].Foo", data) assert.Nil(err) assert.Equal([]interface{}{"f1", "correct"}, result) } func TestCanSupportStructWithSlicingExpression(t *testing.T) { assert := assert.New(t) data := sliceType{A: "foo", B: []scalars{{"f1", "b1"}, {"correct", "b2"}}} result, err := Search("B[:].Foo", data) assert.Nil(err) assert.Equal([]interface{}{"f1", "correct"}, result) } func TestCanSupportStructWithFilterProjection(t *testing.T) { assert := assert.New(t) data := sliceType{A: "foo", B: []scalars{{"f1", "b1"}, {"correct", "b2"}}} result, err := Search("B[? `true` ].Foo", data) assert.Nil(err) assert.Equal([]interface{}{"f1", "correct"}, result) } func TestCanSupportStructWithSlice(t *testing.T) { assert := assert.New(t) data := sliceType{A: "foo", B: []scalars{{"f1", "b1"}, {"correct", "b2"}}} result, err := Search("B[-1].Foo", data) assert.Nil(err) assert.Equal("correct", result) } func TestCanSupportStructWithOrExpressions(t *testing.T) { assert := assert.New(t) data := sliceType{A: "foo", C: nil} result, err := Search("C || A", data) assert.Nil(err) assert.Equal("foo", result) } func TestCanSupportStructWithSlicePointer(t *testing.T) { assert := assert.New(t) data := sliceType{A: "foo", C: []*scalars{{"f1", "b1"}, {"correct", "b2"}}} result, err := Search("C[-1].Foo", data) assert.Nil(err) assert.Equal("correct", result) } func TestWillAutomaticallyCapitalizeFieldNames(t *testing.T) { assert := assert.New(t) s := scalars{Foo: "one", Bar: "bar"} // Note that there's a lower cased "foo" instead of "Foo", // but it should still correspond to the Foo field in the // scalars struct result, err := Search("foo", &s) assert.Nil(err) assert.Equal("one", result) } func TestCanSupportStructWithSliceLowerCased(t *testing.T) { assert := assert.New(t) data := sliceType{A: "foo", B: []scalars{{"f1", "b1"}, {"correct", "b2"}}} result, err := Search("b[-1].foo", data) assert.Nil(err) assert.Equal("correct", result) } func TestCanSupportStructWithNestedPointers(t *testing.T) { assert := assert.New(t) data := struct{ A *struct{ B int } }{} result, err := Search("A.B", data) assert.Nil(err) assert.Nil(result) } func TestCanSupportFlattenNestedSlice(t *testing.T) { assert := assert.New(t) data := nestedSlice{A: []sliceType{ {B: []scalars{{Foo: "f1a"}, {Foo: "f1b"}}}, {B: []scalars{{Foo: "f2a"}, {Foo: "f2b"}}}, }} result, err := Search("A[].B[].Foo", data) assert.Nil(err) assert.Equal([]interface{}{"f1a", "f1b", "f2a", "f2b"}, result) } func TestCanSupportFlattenNestedEmptySlice(t *testing.T) { assert := assert.New(t) data := nestedSlice{A: []sliceType{ {}, {B: []scalars{{Foo: "a"}}}, }} result, err := Search("A[].B[].Foo", data) assert.Nil(err) assert.Equal([]interface{}{"a"}, result) } func TestCanSupportProjectionsWithStructs(t *testing.T) { assert := assert.New(t) data := nestedSlice{A: []sliceType{ {A: "first"}, {A: "second"}, {A: "third"}, }} result, err := Search("A[*].A", data) assert.Nil(err) assert.Equal([]interface{}{"first", "second", "third"}, result) } func TestCanSupportSliceOfStructsWithFunctions(t *testing.T) { assert := assert.New(t) data := []scalars{scalars{"a1", "b1"}, scalars{"a2", "b2"}} result, err := Search("length(@)", data) assert.Nil(err) assert.Equal(result.(float64), 2.0) } func BenchmarkInterpretSingleFieldStruct(b *testing.B) { intr := newInterpreter() parser := NewParser() ast, _ := parser.Parse("fooasdfasdfasdfasdf") data := benchmarkStruct{"foobarbazqux"} for i := 0; i < b.N; i++ { intr.Execute(ast, &data) } } func BenchmarkInterpretNestedStruct(b *testing.B) { intr := newInterpreter() parser := NewParser() ast, _ := parser.Parse("fooasdfasdfasdfasdf.fooasdfasdfasdfasdf.fooasdfasdfasdfasdf.fooasdfasdfasdfasdf") data := benchmarkNested{ nestedA{ nestedB{ nestedC{"foobarbazqux"}, }, }, } for i := 0; i < b.N; i++ { intr.Execute(ast, &data) } } func BenchmarkInterpretNestedMaps(b *testing.B) { jsonData := []byte(`{"fooasdfasdfasdfasdf": {"fooasdfasdfasdfasdf": {"fooasdfasdfasdfasdf": {"fooasdfasdfasdfasdf": "foobarbazqux"}}}}`) var data interface{} json.Unmarshal(jsonData, &data) intr := newInterpreter() parser := NewParser() ast, _ := parser.Parse("fooasdfasdfasdfasdf.fooasdfasdfasdfasdf.fooasdfasdfasdfasdf.fooasdfasdfasdfasdf") for i := 0; i < b.N; i++ { intr.Execute(ast, data) } } go-jmespath-0.4.0/lexer.go000066400000000000000000000240131373124421700154030ustar00rootroot00000000000000package jmespath import ( "bytes" "encoding/json" "fmt" "strconv" "strings" "unicode/utf8" ) type token struct { tokenType tokType value string position int length int } type tokType int const eof = -1 // Lexer contains information about the expression being tokenized. type Lexer struct { expression string // The expression provided by the user. currentPos int // The current position in the string. lastWidth int // The width of the current rune. This buf bytes.Buffer // Internal buffer used for building up values. } // SyntaxError is the main error used whenever a lexing or parsing error occurs. type SyntaxError struct { msg string // Error message displayed to user Expression string // Expression that generated a SyntaxError Offset int // The location in the string where the error occurred } func (e SyntaxError) Error() string { // In the future, it would be good to underline the specific // location where the error occurred. return "SyntaxError: " + e.msg } // HighlightLocation will show where the syntax error occurred. // It will place a "^" character on a line below the expression // at the point where the syntax error occurred. func (e SyntaxError) HighlightLocation() string { return e.Expression + "\n" + strings.Repeat(" ", e.Offset) + "^" } //go:generate stringer -type=tokType const ( tUnknown tokType = iota tStar tDot tFilter tFlatten tLparen tRparen tLbracket tRbracket tLbrace tRbrace tOr tPipe tNumber tUnquotedIdentifier tQuotedIdentifier tComma tColon tLT tLTE tGT tGTE tEQ tNE tJSONLiteral tStringLiteral tCurrent tExpref tAnd tNot tEOF ) var basicTokens = map[rune]tokType{ '.': tDot, '*': tStar, ',': tComma, ':': tColon, '{': tLbrace, '}': tRbrace, ']': tRbracket, // tLbracket not included because it could be "[]" '(': tLparen, ')': tRparen, '@': tCurrent, } // Bit mask for [a-zA-Z_] shifted down 64 bits to fit in a single uint64. // When using this bitmask just be sure to shift the rune down 64 bits // before checking against identifierStartBits. const identifierStartBits uint64 = 576460745995190270 // Bit mask for [a-zA-Z0-9], 128 bits -> 2 uint64s. var identifierTrailingBits = [2]uint64{287948901175001088, 576460745995190270} var whiteSpace = map[rune]bool{ ' ': true, '\t': true, '\n': true, '\r': true, } func (t token) String() string { return fmt.Sprintf("Token{%+v, %s, %d, %d}", t.tokenType, t.value, t.position, t.length) } // NewLexer creates a new JMESPath lexer. func NewLexer() *Lexer { lexer := Lexer{} return &lexer } func (lexer *Lexer) next() rune { if lexer.currentPos >= len(lexer.expression) { lexer.lastWidth = 0 return eof } r, w := utf8.DecodeRuneInString(lexer.expression[lexer.currentPos:]) lexer.lastWidth = w lexer.currentPos += w return r } func (lexer *Lexer) back() { lexer.currentPos -= lexer.lastWidth } func (lexer *Lexer) peek() rune { t := lexer.next() lexer.back() return t } // tokenize takes an expression and returns corresponding tokens. func (lexer *Lexer) tokenize(expression string) ([]token, error) { var tokens []token lexer.expression = expression lexer.currentPos = 0 lexer.lastWidth = 0 loop: for { r := lexer.next() if identifierStartBits&(1<<(uint64(r)-64)) > 0 { t := lexer.consumeUnquotedIdentifier() tokens = append(tokens, t) } else if val, ok := basicTokens[r]; ok { // Basic single char token. t := token{ tokenType: val, value: string(r), position: lexer.currentPos - lexer.lastWidth, length: 1, } tokens = append(tokens, t) } else if r == '-' || (r >= '0' && r <= '9') { t := lexer.consumeNumber() tokens = append(tokens, t) } else if r == '[' { t := lexer.consumeLBracket() tokens = append(tokens, t) } else if r == '"' { t, err := lexer.consumeQuotedIdentifier() if err != nil { return tokens, err } tokens = append(tokens, t) } else if r == '\'' { t, err := lexer.consumeRawStringLiteral() if err != nil { return tokens, err } tokens = append(tokens, t) } else if r == '`' { t, err := lexer.consumeLiteral() if err != nil { return tokens, err } tokens = append(tokens, t) } else if r == '|' { t := lexer.matchOrElse(r, '|', tOr, tPipe) tokens = append(tokens, t) } else if r == '<' { t := lexer.matchOrElse(r, '=', tLTE, tLT) tokens = append(tokens, t) } else if r == '>' { t := lexer.matchOrElse(r, '=', tGTE, tGT) tokens = append(tokens, t) } else if r == '!' { t := lexer.matchOrElse(r, '=', tNE, tNot) tokens = append(tokens, t) } else if r == '=' { t := lexer.matchOrElse(r, '=', tEQ, tUnknown) tokens = append(tokens, t) } else if r == '&' { t := lexer.matchOrElse(r, '&', tAnd, tExpref) tokens = append(tokens, t) } else if r == eof { break loop } else if _, ok := whiteSpace[r]; ok { // Ignore whitespace } else { return tokens, lexer.syntaxError(fmt.Sprintf("Unknown char: %s", strconv.QuoteRuneToASCII(r))) } } tokens = append(tokens, token{tEOF, "", len(lexer.expression), 0}) return tokens, nil } // Consume characters until the ending rune "r" is reached. // If the end of the expression is reached before seeing the // terminating rune "r", then an error is returned. // If no error occurs then the matching substring is returned. // The returned string will not include the ending rune. func (lexer *Lexer) consumeUntil(end rune) (string, error) { start := lexer.currentPos current := lexer.next() for current != end && current != eof { if current == '\\' && lexer.peek() != eof { lexer.next() } current = lexer.next() } if lexer.lastWidth == 0 { // Then we hit an EOF so we never reached the closing // delimiter. return "", SyntaxError{ msg: "Unclosed delimiter: " + string(end), Expression: lexer.expression, Offset: len(lexer.expression), } } return lexer.expression[start : lexer.currentPos-lexer.lastWidth], nil } func (lexer *Lexer) consumeLiteral() (token, error) { start := lexer.currentPos value, err := lexer.consumeUntil('`') if err != nil { return token{}, err } value = strings.Replace(value, "\\`", "`", -1) return token{ tokenType: tJSONLiteral, value: value, position: start, length: len(value), }, nil } func (lexer *Lexer) consumeRawStringLiteral() (token, error) { start := lexer.currentPos currentIndex := start current := lexer.next() for current != '\'' && lexer.peek() != eof { if current == '\\' && lexer.peek() == '\'' { chunk := lexer.expression[currentIndex : lexer.currentPos-1] lexer.buf.WriteString(chunk) lexer.buf.WriteString("'") lexer.next() currentIndex = lexer.currentPos } current = lexer.next() } if lexer.lastWidth == 0 { // Then we hit an EOF so we never reached the closing // delimiter. return token{}, SyntaxError{ msg: "Unclosed delimiter: '", Expression: lexer.expression, Offset: len(lexer.expression), } } if currentIndex < lexer.currentPos { lexer.buf.WriteString(lexer.expression[currentIndex : lexer.currentPos-1]) } value := lexer.buf.String() // Reset the buffer so it can reused again. lexer.buf.Reset() return token{ tokenType: tStringLiteral, value: value, position: start, length: len(value), }, nil } func (lexer *Lexer) syntaxError(msg string) SyntaxError { return SyntaxError{ msg: msg, Expression: lexer.expression, Offset: lexer.currentPos - 1, } } // Checks for a two char token, otherwise matches a single character // token. This is used whenever a two char token overlaps a single // char token, e.g. "||" -> tPipe, "|" -> tOr. func (lexer *Lexer) matchOrElse(first rune, second rune, matchedType tokType, singleCharType tokType) token { start := lexer.currentPos - lexer.lastWidth nextRune := lexer.next() var t token if nextRune == second { t = token{ tokenType: matchedType, value: string(first) + string(second), position: start, length: 2, } } else { lexer.back() t = token{ tokenType: singleCharType, value: string(first), position: start, length: 1, } } return t } func (lexer *Lexer) consumeLBracket() token { // There's three options here: // 1. A filter expression "[?" // 2. A flatten operator "[]" // 3. A bare rbracket "[" start := lexer.currentPos - lexer.lastWidth nextRune := lexer.next() var t token if nextRune == '?' { t = token{ tokenType: tFilter, value: "[?", position: start, length: 2, } } else if nextRune == ']' { t = token{ tokenType: tFlatten, value: "[]", position: start, length: 2, } } else { t = token{ tokenType: tLbracket, value: "[", position: start, length: 1, } lexer.back() } return t } func (lexer *Lexer) consumeQuotedIdentifier() (token, error) { start := lexer.currentPos value, err := lexer.consumeUntil('"') if err != nil { return token{}, err } var decoded string asJSON := []byte("\"" + value + "\"") if err := json.Unmarshal([]byte(asJSON), &decoded); err != nil { return token{}, err } return token{ tokenType: tQuotedIdentifier, value: decoded, position: start - 1, length: len(decoded), }, nil } func (lexer *Lexer) consumeUnquotedIdentifier() token { // Consume runes until we reach the end of an unquoted // identifier. start := lexer.currentPos - lexer.lastWidth for { r := lexer.next() if r < 0 || r > 128 || identifierTrailingBits[uint64(r)/64]&(1<<(uint64(r)%64)) == 0 { lexer.back() break } } value := lexer.expression[start:lexer.currentPos] return token{ tokenType: tUnquotedIdentifier, value: value, position: start, length: lexer.currentPos - start, } } func (lexer *Lexer) consumeNumber() token { // Consume runes until we reach something that's not a number. start := lexer.currentPos - lexer.lastWidth for { r := lexer.next() if r < '0' || r > '9' { lexer.back() break } } value := lexer.expression[start:lexer.currentPos] return token{ tokenType: tNumber, value: value, position: start, length: lexer.currentPos - start, } } go-jmespath-0.4.0/lexer_test.go000066400000000000000000000133361373124421700164500ustar00rootroot00000000000000package jmespath import ( "fmt" "testing" "github.com/jmespath/go-jmespath/internal/testify/assert" ) var lexingTests = []struct { expression string expected []token }{ {"*", []token{{tStar, "*", 0, 1}}}, {".", []token{{tDot, ".", 0, 1}}}, {"[?", []token{{tFilter, "[?", 0, 2}}}, {"[]", []token{{tFlatten, "[]", 0, 2}}}, {"(", []token{{tLparen, "(", 0, 1}}}, {")", []token{{tRparen, ")", 0, 1}}}, {"[", []token{{tLbracket, "[", 0, 1}}}, {"]", []token{{tRbracket, "]", 0, 1}}}, {"{", []token{{tLbrace, "{", 0, 1}}}, {"}", []token{{tRbrace, "}", 0, 1}}}, {"||", []token{{tOr, "||", 0, 2}}}, {"|", []token{{tPipe, "|", 0, 1}}}, {"29", []token{{tNumber, "29", 0, 2}}}, {"2", []token{{tNumber, "2", 0, 1}}}, {"0", []token{{tNumber, "0", 0, 1}}}, {"-20", []token{{tNumber, "-20", 0, 3}}}, {"foo", []token{{tUnquotedIdentifier, "foo", 0, 3}}}, {`"bar"`, []token{{tQuotedIdentifier, "bar", 0, 3}}}, // Escaping the delimiter {`"bar\"baz"`, []token{{tQuotedIdentifier, `bar"baz`, 0, 7}}}, {",", []token{{tComma, ",", 0, 1}}}, {":", []token{{tColon, ":", 0, 1}}}, {"<", []token{{tLT, "<", 0, 1}}}, {"<=", []token{{tLTE, "<=", 0, 2}}}, {">", []token{{tGT, ">", 0, 1}}}, {">=", []token{{tGTE, ">=", 0, 2}}}, {"==", []token{{tEQ, "==", 0, 2}}}, {"!=", []token{{tNE, "!=", 0, 2}}}, {"`[0, 1, 2]`", []token{{tJSONLiteral, "[0, 1, 2]", 1, 9}}}, {"'foo'", []token{{tStringLiteral, "foo", 1, 3}}}, {"'a'", []token{{tStringLiteral, "a", 1, 1}}}, {`'foo\'bar'`, []token{{tStringLiteral, "foo'bar", 1, 7}}}, {"@", []token{{tCurrent, "@", 0, 1}}}, {"&", []token{{tExpref, "&", 0, 1}}}, // Quoted identifier unicode escape sequences {`"\u2713"`, []token{{tQuotedIdentifier, "✓", 0, 3}}}, {`"\\"`, []token{{tQuotedIdentifier, `\`, 0, 1}}}, {"`\"foo\"`", []token{{tJSONLiteral, "\"foo\"", 1, 5}}}, // Combinations of tokens. {"foo.bar", []token{ {tUnquotedIdentifier, "foo", 0, 3}, {tDot, ".", 3, 1}, {tUnquotedIdentifier, "bar", 4, 3}, }}, {"foo[0]", []token{ {tUnquotedIdentifier, "foo", 0, 3}, {tLbracket, "[", 3, 1}, {tNumber, "0", 4, 1}, {tRbracket, "]", 5, 1}, }}, {"foo[?a 0 { output += fmt.Sprintf("%schildren: {\n", strings.Repeat(" ", nextIndent)) childIndent := nextIndent + 2 for _, elem := range node.children { output += elem.PrettyPrint(childIndent) } } output += fmt.Sprintf("%s}\n", spaces) return output } var bindingPowers = map[tokType]int{ tEOF: 0, tUnquotedIdentifier: 0, tQuotedIdentifier: 0, tRbracket: 0, tRparen: 0, tComma: 0, tRbrace: 0, tNumber: 0, tCurrent: 0, tExpref: 0, tColon: 0, tPipe: 1, tOr: 2, tAnd: 3, tEQ: 5, tLT: 5, tLTE: 5, tGT: 5, tGTE: 5, tNE: 5, tFlatten: 9, tStar: 20, tFilter: 21, tDot: 40, tNot: 45, tLbrace: 50, tLbracket: 55, tLparen: 60, } // Parser holds state about the current expression being parsed. type Parser struct { expression string tokens []token index int } // NewParser creates a new JMESPath parser. func NewParser() *Parser { p := Parser{} return &p } // Parse will compile a JMESPath expression. func (p *Parser) Parse(expression string) (ASTNode, error) { lexer := NewLexer() p.expression = expression p.index = 0 tokens, err := lexer.tokenize(expression) if err != nil { return ASTNode{}, err } p.tokens = tokens parsed, err := p.parseExpression(0) if err != nil { return ASTNode{}, err } if p.current() != tEOF { return ASTNode{}, p.syntaxError(fmt.Sprintf( "Unexpected token at the end of the expression: %s", p.current())) } return parsed, nil } func (p *Parser) parseExpression(bindingPower int) (ASTNode, error) { var err error leftToken := p.lookaheadToken(0) p.advance() leftNode, err := p.nud(leftToken) if err != nil { return ASTNode{}, err } currentToken := p.current() for bindingPower < bindingPowers[currentToken] { p.advance() leftNode, err = p.led(currentToken, leftNode) if err != nil { return ASTNode{}, err } currentToken = p.current() } return leftNode, nil } func (p *Parser) parseIndexExpression() (ASTNode, error) { if p.lookahead(0) == tColon || p.lookahead(1) == tColon { return p.parseSliceExpression() } indexStr := p.lookaheadToken(0).value parsedInt, err := strconv.Atoi(indexStr) if err != nil { return ASTNode{}, err } indexNode := ASTNode{nodeType: ASTIndex, value: parsedInt} p.advance() if err := p.match(tRbracket); err != nil { return ASTNode{}, err } return indexNode, nil } func (p *Parser) parseSliceExpression() (ASTNode, error) { parts := []*int{nil, nil, nil} index := 0 current := p.current() for current != tRbracket && index < 3 { if current == tColon { index++ p.advance() } else if current == tNumber { parsedInt, err := strconv.Atoi(p.lookaheadToken(0).value) if err != nil { return ASTNode{}, err } parts[index] = &parsedInt p.advance() } else { return ASTNode{}, p.syntaxError( "Expected tColon or tNumber" + ", received: " + p.current().String()) } current = p.current() } if err := p.match(tRbracket); err != nil { return ASTNode{}, err } return ASTNode{ nodeType: ASTSlice, value: parts, }, nil } func (p *Parser) match(tokenType tokType) error { if p.current() == tokenType { p.advance() return nil } return p.syntaxError("Expected " + tokenType.String() + ", received: " + p.current().String()) } func (p *Parser) led(tokenType tokType, node ASTNode) (ASTNode, error) { switch tokenType { case tDot: if p.current() != tStar { right, err := p.parseDotRHS(bindingPowers[tDot]) return ASTNode{ nodeType: ASTSubexpression, children: []ASTNode{node, right}, }, err } p.advance() right, err := p.parseProjectionRHS(bindingPowers[tDot]) return ASTNode{ nodeType: ASTValueProjection, children: []ASTNode{node, right}, }, err case tPipe: right, err := p.parseExpression(bindingPowers[tPipe]) return ASTNode{nodeType: ASTPipe, children: []ASTNode{node, right}}, err case tOr: right, err := p.parseExpression(bindingPowers[tOr]) return ASTNode{nodeType: ASTOrExpression, children: []ASTNode{node, right}}, err case tAnd: right, err := p.parseExpression(bindingPowers[tAnd]) return ASTNode{nodeType: ASTAndExpression, children: []ASTNode{node, right}}, err case tLparen: name := node.value var args []ASTNode for p.current() != tRparen { expression, err := p.parseExpression(0) if err != nil { return ASTNode{}, err } if p.current() == tComma { if err := p.match(tComma); err != nil { return ASTNode{}, err } } args = append(args, expression) } if err := p.match(tRparen); err != nil { return ASTNode{}, err } return ASTNode{ nodeType: ASTFunctionExpression, value: name, children: args, }, nil case tFilter: return p.parseFilter(node) case tFlatten: left := ASTNode{nodeType: ASTFlatten, children: []ASTNode{node}} right, err := p.parseProjectionRHS(bindingPowers[tFlatten]) return ASTNode{ nodeType: ASTProjection, children: []ASTNode{left, right}, }, err case tEQ, tNE, tGT, tGTE, tLT, tLTE: right, err := p.parseExpression(bindingPowers[tokenType]) if err != nil { return ASTNode{}, err } return ASTNode{ nodeType: ASTComparator, value: tokenType, children: []ASTNode{node, right}, }, nil case tLbracket: tokenType := p.current() var right ASTNode var err error if tokenType == tNumber || tokenType == tColon { right, err = p.parseIndexExpression() if err != nil { return ASTNode{}, err } return p.projectIfSlice(node, right) } // Otherwise this is a projection. if err := p.match(tStar); err != nil { return ASTNode{}, err } if err := p.match(tRbracket); err != nil { return ASTNode{}, err } right, err = p.parseProjectionRHS(bindingPowers[tStar]) if err != nil { return ASTNode{}, err } return ASTNode{ nodeType: ASTProjection, children: []ASTNode{node, right}, }, nil } return ASTNode{}, p.syntaxError("Unexpected token: " + tokenType.String()) } func (p *Parser) nud(token token) (ASTNode, error) { switch token.tokenType { case tJSONLiteral: var parsed interface{} err := json.Unmarshal([]byte(token.value), &parsed) if err != nil { return ASTNode{}, err } return ASTNode{nodeType: ASTLiteral, value: parsed}, nil case tStringLiteral: return ASTNode{nodeType: ASTLiteral, value: token.value}, nil case tUnquotedIdentifier: return ASTNode{ nodeType: ASTField, value: token.value, }, nil case tQuotedIdentifier: node := ASTNode{nodeType: ASTField, value: token.value} if p.current() == tLparen { return ASTNode{}, p.syntaxErrorToken("Can't have quoted identifier as function name.", token) } return node, nil case tStar: left := ASTNode{nodeType: ASTIdentity} var right ASTNode var err error if p.current() == tRbracket { right = ASTNode{nodeType: ASTIdentity} } else { right, err = p.parseProjectionRHS(bindingPowers[tStar]) } return ASTNode{nodeType: ASTValueProjection, children: []ASTNode{left, right}}, err case tFilter: return p.parseFilter(ASTNode{nodeType: ASTIdentity}) case tLbrace: return p.parseMultiSelectHash() case tFlatten: left := ASTNode{ nodeType: ASTFlatten, children: []ASTNode{{nodeType: ASTIdentity}}, } right, err := p.parseProjectionRHS(bindingPowers[tFlatten]) if err != nil { return ASTNode{}, err } return ASTNode{nodeType: ASTProjection, children: []ASTNode{left, right}}, nil case tLbracket: tokenType := p.current() //var right ASTNode if tokenType == tNumber || tokenType == tColon { right, err := p.parseIndexExpression() if err != nil { return ASTNode{}, nil } return p.projectIfSlice(ASTNode{nodeType: ASTIdentity}, right) } else if tokenType == tStar && p.lookahead(1) == tRbracket { p.advance() p.advance() right, err := p.parseProjectionRHS(bindingPowers[tStar]) if err != nil { return ASTNode{}, err } return ASTNode{ nodeType: ASTProjection, children: []ASTNode{{nodeType: ASTIdentity}, right}, }, nil } else { return p.parseMultiSelectList() } case tCurrent: return ASTNode{nodeType: ASTCurrentNode}, nil case tExpref: expression, err := p.parseExpression(bindingPowers[tExpref]) if err != nil { return ASTNode{}, err } return ASTNode{nodeType: ASTExpRef, children: []ASTNode{expression}}, nil case tNot: expression, err := p.parseExpression(bindingPowers[tNot]) if err != nil { return ASTNode{}, err } return ASTNode{nodeType: ASTNotExpression, children: []ASTNode{expression}}, nil case tLparen: expression, err := p.parseExpression(0) if err != nil { return ASTNode{}, err } if err := p.match(tRparen); err != nil { return ASTNode{}, err } return expression, nil case tEOF: return ASTNode{}, p.syntaxErrorToken("Incomplete expression", token) } return ASTNode{}, p.syntaxErrorToken("Invalid token: "+token.tokenType.String(), token) } func (p *Parser) parseMultiSelectList() (ASTNode, error) { var expressions []ASTNode for { expression, err := p.parseExpression(0) if err != nil { return ASTNode{}, err } expressions = append(expressions, expression) if p.current() == tRbracket { break } err = p.match(tComma) if err != nil { return ASTNode{}, err } } err := p.match(tRbracket) if err != nil { return ASTNode{}, err } return ASTNode{ nodeType: ASTMultiSelectList, children: expressions, }, nil } func (p *Parser) parseMultiSelectHash() (ASTNode, error) { var children []ASTNode for { keyToken := p.lookaheadToken(0) if err := p.match(tUnquotedIdentifier); err != nil { if err := p.match(tQuotedIdentifier); err != nil { return ASTNode{}, p.syntaxError("Expected tQuotedIdentifier or tUnquotedIdentifier") } } keyName := keyToken.value err := p.match(tColon) if err != nil { return ASTNode{}, err } value, err := p.parseExpression(0) if err != nil { return ASTNode{}, err } node := ASTNode{ nodeType: ASTKeyValPair, value: keyName, children: []ASTNode{value}, } children = append(children, node) if p.current() == tComma { err := p.match(tComma) if err != nil { return ASTNode{}, nil } } else if p.current() == tRbrace { err := p.match(tRbrace) if err != nil { return ASTNode{}, nil } break } } return ASTNode{ nodeType: ASTMultiSelectHash, children: children, }, nil } func (p *Parser) projectIfSlice(left ASTNode, right ASTNode) (ASTNode, error) { indexExpr := ASTNode{ nodeType: ASTIndexExpression, children: []ASTNode{left, right}, } if right.nodeType == ASTSlice { right, err := p.parseProjectionRHS(bindingPowers[tStar]) return ASTNode{ nodeType: ASTProjection, children: []ASTNode{indexExpr, right}, }, err } return indexExpr, nil } func (p *Parser) parseFilter(node ASTNode) (ASTNode, error) { var right, condition ASTNode var err error condition, err = p.parseExpression(0) if err != nil { return ASTNode{}, err } if err := p.match(tRbracket); err != nil { return ASTNode{}, err } if p.current() == tFlatten { right = ASTNode{nodeType: ASTIdentity} } else { right, err = p.parseProjectionRHS(bindingPowers[tFilter]) if err != nil { return ASTNode{}, err } } return ASTNode{ nodeType: ASTFilterProjection, children: []ASTNode{node, right, condition}, }, nil } func (p *Parser) parseDotRHS(bindingPower int) (ASTNode, error) { lookahead := p.current() if tokensOneOf([]tokType{tQuotedIdentifier, tUnquotedIdentifier, tStar}, lookahead) { return p.parseExpression(bindingPower) } else if lookahead == tLbracket { if err := p.match(tLbracket); err != nil { return ASTNode{}, err } return p.parseMultiSelectList() } else if lookahead == tLbrace { if err := p.match(tLbrace); err != nil { return ASTNode{}, err } return p.parseMultiSelectHash() } return ASTNode{}, p.syntaxError("Expected identifier, lbracket, or lbrace") } func (p *Parser) parseProjectionRHS(bindingPower int) (ASTNode, error) { current := p.current() if bindingPowers[current] < 10 { return ASTNode{nodeType: ASTIdentity}, nil } else if current == tLbracket { return p.parseExpression(bindingPower) } else if current == tFilter { return p.parseExpression(bindingPower) } else if current == tDot { err := p.match(tDot) if err != nil { return ASTNode{}, err } return p.parseDotRHS(bindingPower) } else { return ASTNode{}, p.syntaxError("Error") } } func (p *Parser) lookahead(number int) tokType { return p.lookaheadToken(number).tokenType } func (p *Parser) current() tokType { return p.lookahead(0) } func (p *Parser) lookaheadToken(number int) token { return p.tokens[p.index+number] } func (p *Parser) advance() { p.index++ } func tokensOneOf(elements []tokType, token tokType) bool { for _, elem := range elements { if elem == token { return true } } return false } func (p *Parser) syntaxError(msg string) SyntaxError { return SyntaxError{ msg: msg, Expression: p.expression, Offset: p.lookaheadToken(0).position, } } // Create a SyntaxError based on the provided token. // This differs from syntaxError() which creates a SyntaxError // based on the current lookahead token. func (p *Parser) syntaxErrorToken(msg string, t token) SyntaxError { return SyntaxError{ msg: msg, Expression: p.expression, Offset: t.position, } } go-jmespath-0.4.0/parser_test.go000066400000000000000000000055261373124421700166270ustar00rootroot00000000000000package jmespath import ( "fmt" "testing" "github.com/jmespath/go-jmespath/internal/testify/assert" ) var parsingErrorTests = []struct { expression string msg string }{ {"foo.", "Incopmlete expression"}, {"[foo", "Incopmlete expression"}, {"]", "Invalid"}, {")", "Invalid"}, {"}", "Invalid"}, {"foo..bar", "Invalid"}, {`foo."bar`, "Forwards lexer errors"}, {`{foo: bar`, "Incomplete expression"}, {`{foo bar}`, "Invalid"}, {`[foo bar]`, "Invalid"}, {`foo@`, "Invalid"}, {`&&&&&&&&&&&&t(`, "Invalid"}, {`[*][`, "Invalid"}, } func TestParsingErrors(t *testing.T) { assert := assert.New(t) parser := NewParser() for _, tt := range parsingErrorTests { _, err := parser.Parse(tt.expression) assert.NotNil(err, fmt.Sprintf("Expected parsing error: %s, for expression: %s", tt.msg, tt.expression)) } } var prettyPrinted = `ASTProjection { children: { ASTField { value: "foo" } ASTSubexpression { children: { ASTSubexpression { children: { ASTField { value: "bar" } ASTField { value: "baz" } } ASTField { value: "qux" } } } ` var prettyPrintedCompNode = `ASTFilterProjection { children: { ASTField { value: "a" } ASTIdentity { } ASTComparator { value: tLTE children: { ASTField { value: "b" } ASTField { value: "c" } } } ` func TestPrettyPrintedAST(t *testing.T) { assert := assert.New(t) parser := NewParser() parsed, _ := parser.Parse("foo[*].bar.baz.qux") assert.Equal(parsed.PrettyPrint(0), prettyPrinted) } func TestPrettyPrintedCompNode(t *testing.T) { assert := assert.New(t) parser := NewParser() parsed, _ := parser.Parse("a[?b<=c]") assert.Equal(parsed.PrettyPrint(0), prettyPrintedCompNode) } func BenchmarkParseIdentifier(b *testing.B) { runParseBenchmark(b, exprIdentifier) } func BenchmarkParseSubexpression(b *testing.B) { runParseBenchmark(b, exprSubexpr) } func BenchmarkParseDeeplyNested50(b *testing.B) { runParseBenchmark(b, deeplyNested50) } func BenchmarkParseDeepNested50Pipe(b *testing.B) { runParseBenchmark(b, deeplyNested50Pipe) } func BenchmarkParseDeepNested50Index(b *testing.B) { runParseBenchmark(b, deeplyNested50Index) } func BenchmarkParseQuotedIdentifier(b *testing.B) { runParseBenchmark(b, exprQuotedIdentifier) } func BenchmarkParseQuotedIdentifierEscapes(b *testing.B) { runParseBenchmark(b, quotedIdentifierEscapes) } func BenchmarkParseRawStringLiteral(b *testing.B) { runParseBenchmark(b, rawStringLiteral) } func BenchmarkParseDeepProjection104(b *testing.B) { runParseBenchmark(b, deepProjection104) } func runParseBenchmark(b *testing.B, expression string) { parser := NewParser() for i := 0; i < b.N; i++ { parser.Parse(expression) } } go-jmespath-0.4.0/toktype_string.go000066400000000000000000000012641373124421700173540ustar00rootroot00000000000000// generated by stringer -type=tokType; DO NOT EDIT package jmespath import "fmt" const _tokType_name = "tUnknowntStartDottFiltertFlattentLparentRparentLbrackettRbrackettLbracetRbracetOrtPipetNumbertUnquotedIdentifiertQuotedIdentifiertCommatColontLTtLTEtGTtGTEtEQtNEtJSONLiteraltStringLiteraltCurrenttExpreftAndtNottEOF" var _tokType_index = [...]uint8{0, 8, 13, 17, 24, 32, 39, 46, 55, 64, 71, 78, 81, 86, 93, 112, 129, 135, 141, 144, 148, 151, 155, 158, 161, 173, 187, 195, 202, 206, 210, 214} func (i tokType) String() string { if i < 0 || i >= tokType(len(_tokType_index)-1) { return fmt.Sprintf("tokType(%d)", i) } return _tokType_name[_tokType_index[i]:_tokType_index[i+1]] } go-jmespath-0.4.0/util.go000066400000000000000000000103561373124421700152460ustar00rootroot00000000000000package jmespath import ( "errors" "reflect" ) // IsFalse determines if an object is false based on the JMESPath spec. // JMESPath defines false values to be any of: // - An empty string array, or hash. // - The boolean value false. // - nil func isFalse(value interface{}) bool { switch v := value.(type) { case bool: return !v case []interface{}: return len(v) == 0 case map[string]interface{}: return len(v) == 0 case string: return len(v) == 0 case nil: return true } // Try the reflection cases before returning false. rv := reflect.ValueOf(value) switch rv.Kind() { case reflect.Struct: // A struct type will never be false, even if // all of its values are the zero type. return false case reflect.Slice, reflect.Map: return rv.Len() == 0 case reflect.Ptr: if rv.IsNil() { return true } // If it's a pointer type, we'll try to deref the pointer // and evaluate the pointer value for isFalse. element := rv.Elem() return isFalse(element.Interface()) } return false } // ObjsEqual is a generic object equality check. // It will take two arbitrary objects and recursively determine // if they are equal. func objsEqual(left interface{}, right interface{}) bool { return reflect.DeepEqual(left, right) } // SliceParam refers to a single part of a slice. // A slice consists of a start, a stop, and a step, similar to // python slices. type sliceParam struct { N int Specified bool } // Slice supports [start:stop:step] style slicing that's supported in JMESPath. func slice(slice []interface{}, parts []sliceParam) ([]interface{}, error) { computed, err := computeSliceParams(len(slice), parts) if err != nil { return nil, err } start, stop, step := computed[0], computed[1], computed[2] result := []interface{}{} if step > 0 { for i := start; i < stop; i += step { result = append(result, slice[i]) } } else { for i := start; i > stop; i += step { result = append(result, slice[i]) } } return result, nil } func computeSliceParams(length int, parts []sliceParam) ([]int, error) { var start, stop, step int if !parts[2].Specified { step = 1 } else if parts[2].N == 0 { return nil, errors.New("Invalid slice, step cannot be 0") } else { step = parts[2].N } var stepValueNegative bool if step < 0 { stepValueNegative = true } else { stepValueNegative = false } if !parts[0].Specified { if stepValueNegative { start = length - 1 } else { start = 0 } } else { start = capSlice(length, parts[0].N, step) } if !parts[1].Specified { if stepValueNegative { stop = -1 } else { stop = length } } else { stop = capSlice(length, parts[1].N, step) } return []int{start, stop, step}, nil } func capSlice(length int, actual int, step int) int { if actual < 0 { actual += length if actual < 0 { if step < 0 { actual = -1 } else { actual = 0 } } } else if actual >= length { if step < 0 { actual = length - 1 } else { actual = length } } return actual } // ToArrayNum converts an empty interface type to a slice of float64. // If any element in the array cannot be converted, then nil is returned // along with a second value of false. func toArrayNum(data interface{}) ([]float64, bool) { // Is there a better way to do this with reflect? if d, ok := data.([]interface{}); ok { result := make([]float64, len(d)) for i, el := range d { item, ok := el.(float64) if !ok { return nil, false } result[i] = item } return result, true } return nil, false } // ToArrayStr converts an empty interface type to a slice of strings. // If any element in the array cannot be converted, then nil is returned // along with a second value of false. If the input data could be entirely // converted, then the converted data, along with a second value of true, // will be returned. func toArrayStr(data interface{}) ([]string, bool) { // Is there a better way to do this with reflect? if d, ok := data.([]interface{}); ok { result := make([]string, len(d)) for i, el := range d { item, ok := el.(string) if !ok { return nil, false } result[i] = item } return result, true } return nil, false } func isSliceType(v interface{}) bool { if v == nil { return false } return reflect.TypeOf(v).Kind() == reflect.Slice } go-jmespath-0.4.0/util_test.go000066400000000000000000000033051373124421700163010ustar00rootroot00000000000000package jmespath import ( "testing" "github.com/jmespath/go-jmespath/internal/testify/assert" ) func TestSlicePositiveStep(t *testing.T) { assert := assert.New(t) input := make([]interface{}, 5) input[0] = 0 input[1] = 1 input[2] = 2 input[3] = 3 input[4] = 4 result, err := slice(input, []sliceParam{{0, true}, {3, true}, {1, true}}) assert.Nil(err) assert.Equal(input[:3], result) } func TestIsFalseJSONTypes(t *testing.T) { assert := assert.New(t) assert.True(isFalse(false)) assert.True(isFalse("")) var empty []interface{} assert.True(isFalse(empty)) m := make(map[string]interface{}) assert.True(isFalse(m)) assert.True(isFalse(nil)) } func TestIsFalseWithUserDefinedStructs(t *testing.T) { assert := assert.New(t) type nilStructType struct { SliceOfPointers []*string } nilStruct := nilStructType{SliceOfPointers: nil} assert.True(isFalse(nilStruct.SliceOfPointers)) // A user defined struct will never be false though, // even if it's fields are the zero type. assert.False(isFalse(nilStruct)) } func TestIsFalseWithNilInterface(t *testing.T) { assert := assert.New(t) var a *int var nilInterface interface{} nilInterface = a assert.True(isFalse(nilInterface)) } func TestIsFalseWithMapOfUserStructs(t *testing.T) { assert := assert.New(t) type foo struct { Bar string Baz string } m := make(map[int]foo) assert.True(isFalse(m)) } func TestObjsEqual(t *testing.T) { assert := assert.New(t) assert.True(objsEqual("foo", "foo")) assert.True(objsEqual(20, 20)) assert.True(objsEqual([]int{1, 2, 3}, []int{1, 2, 3})) assert.True(objsEqual(nil, nil)) assert.True(!objsEqual(nil, "foo")) assert.True(objsEqual([]int{}, []int{})) assert.True(!objsEqual([]int{}, nil)) }