@@ -19,7 +19,7 @@ github.com/docker/go-units 9e638d38cf6977a37a8ea0078f3ee75a7cdb2dd1

 github.com/docker/go-connections 7beb39f0b969b075d1325fecb092faf27fd357b6

 golang.org/x/text f72d8390a633d5dfb0cc84043294db9f6c935756

 github.com/pmezard/go-difflib v1.0.0

-github.com/gotestyourself/gotestyourself cf3a5ab914a2efa8bc838d09f5918c1d44d029

+gotest.tools v2.1.0

 github.com/google/go-cmp v0.2.0

 github.com/RackSec/srslog 456df3a81436d29ba874f3590eeeee25d666f8a5

deleted file mode 100644

@@ -1,202 +0,0 @@

-

-                                 Apache License

-                           Version 2.0, January 2004

-                        http://www.apache.org/licenses/

-

-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION

-

-   1. Definitions.

-

-      "License" shall mean the terms and conditions for use, reproduction,

-      and distribution as defined by Sections 1 through 9 of this document.

-

-      "Licensor" shall mean the copyright owner or entity authorized by

-      the copyright owner that is granting the License.

-

-      "Legal Entity" shall mean the union of the acting entity and all

-      other entities that control, are controlled by, or are under common

-      control with that entity. For the purposes of this definition,

-      "control" means (i) the power, direct or indirect, to cause the

-      direction or management of such entity, whether by contract or

-      otherwise, or (ii) ownership of fifty percent (50%) or more of the

-      outstanding shares, or (iii) beneficial ownership of such entity.

-

-      "You" (or "Your") shall mean an individual or Legal Entity

-      exercising permissions granted by this License.

-

-      "Source" form shall mean the preferred form for making modifications,

-      including but not limited to software source code, documentation

-      source, and configuration files.

-

-      "Object" form shall mean any form resulting from mechanical

-      transformation or translation of a Source form, including but

-      not limited to compiled object code, generated documentation,

-      and conversions to other media types.

-

-      "Work" shall mean the work of authorship, whether in Source or

-      Object form, made available under the License, as indicated by a

-      copyright notice that is included in or attached to the work

-      (an example is provided in the Appendix below).

-

-      "Derivative Works" shall mean any work, whether in Source or Object

-      form, that is based on (or derived from) the Work and for which the

-      editorial revisions, annotations, elaborations, or other modifications

-      represent, as a whole, an original work of authorship. For the purposes

-      of this License, Derivative Works shall not include works that remain

-      separable from, or merely link (or bind by name) to the interfaces of,

-      the Work and Derivative Works thereof.

-

-      "Contribution" shall mean any work of authorship, including

-      the original version of the Work and any modifications or additions

-      to that Work or Derivative Works thereof, that is intentionally

-      submitted to Licensor for inclusion in the Work by the copyright owner

-      or by an individual or Legal Entity authorized to submit on behalf of

-      the copyright owner. For the purposes of this definition, "submitted"

-      means any form of electronic, verbal, or written communication sent

-      to the Licensor or its representatives, including but not limited to

-      communication on electronic mailing lists, source code control systems,

-      and issue tracking systems that are managed by, or on behalf of, the

-      Licensor for the purpose of discussing and improving the Work, but

-      excluding communication that is conspicuously marked or otherwise

-      designated in writing by the copyright owner as "Not a Contribution."

-

-      "Contributor" shall mean Licensor and any individual or Legal Entity

-      on behalf of whom a Contribution has been received by Licensor and

-      subsequently incorporated within the Work.

-

-   2. Grant of Copyright License. Subject to the terms and conditions of

-      this License, each Contributor hereby grants to You a perpetual,

-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable

-      copyright license to reproduce, prepare Derivative Works of,

-      publicly display, publicly perform, sublicense, and distribute the

-      Work and such Derivative Works in Source or Object form.

-

-   3. Grant of Patent License. Subject to the terms and conditions of

-      this License, each Contributor hereby grants to You a perpetual,

-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable

-      (except as stated in this section) patent license to make, have made,

-      use, offer to sell, sell, import, and otherwise transfer the Work,

-      where such license applies only to those patent claims licensable

-      by such Contributor that are necessarily infringed by their

-      Contribution(s) alone or by combination of their Contribution(s)

-      with the Work to which such Contribution(s) was submitted. If You

-      institute patent litigation against any entity (including a

-      cross-claim or counterclaim in a lawsuit) alleging that the Work

-      or a Contribution incorporated within the Work constitutes direct

-      or contributory patent infringement, then any patent licenses

-      granted to You under this License for that Work shall terminate

-      as of the date such litigation is filed.

-

-   4. Redistribution. You may reproduce and distribute copies of the

-      Work or Derivative Works thereof in any medium, with or without

-      modifications, and in Source or Object form, provided that You

-      meet the following conditions:

-

-      (a) You must give any other recipients of the Work or

-          Derivative Works a copy of this License; and

-

-      (b) You must cause any modified files to carry prominent notices

-          stating that You changed the files; and

-

-      (c) You must retain, in the Source form of any Derivative Works

-          that You distribute, all copyright, patent, trademark, and

-          attribution notices from the Source form of the Work,

-          excluding those notices that do not pertain to any part of

-          the Derivative Works; and

-

-      (d) If the Work includes a "NOTICE" text file as part of its

-          distribution, then any Derivative Works that You distribute must

-          include a readable copy of the attribution notices contained

-          within such NOTICE file, excluding those notices that do not

-          pertain to any part of the Derivative Works, in at least one

-          of the following places: within a NOTICE text file distributed

-          as part of the Derivative Works; within the Source form or

-          documentation, if provided along with the Derivative Works; or,

-          within a display generated by the Derivative Works, if and

-          wherever such third-party notices normally appear. The contents

-          of the NOTICE file are for informational purposes only and

-          do not modify the License. You may add Your own attribution

-          notices within Derivative Works that You distribute, alongside

-          or as an addendum to the NOTICE text from the Work, provided

-          that such additional attribution notices cannot be construed

-          as modifying the License.

-

-      You may add Your own copyright statement to Your modifications and

-      may provide additional or different license terms and conditions

-      for use, reproduction, or distribution of Your modifications, or

-      for any such Derivative Works as a whole, provided Your use,

-      reproduction, and distribution of the Work otherwise complies with

-      the conditions stated in this License.

-

-   5. Submission of Contributions. Unless You explicitly state otherwise,

-      any Contribution intentionally submitted for inclusion in the Work

-      by You to the Licensor shall be under the terms and conditions of

-      this License, without any additional terms or conditions.

-      Notwithstanding the above, nothing herein shall supersede or modify

-      the terms of any separate license agreement you may have executed

-      with Licensor regarding such Contributions.

-

-   6. Trademarks. This License does not grant permission to use the trade

-      names, trademarks, service marks, or product names of the Licensor,

-      except as required for reasonable and customary use in describing the

-      origin of the Work and reproducing the content of the NOTICE file.

-

-   7. Disclaimer of Warranty. Unless required by applicable law or

-      agreed to in writing, Licensor provides the Work (and each

-      Contributor provides its Contributions) on an "AS IS" BASIS,

-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or

-      implied, including, without limitation, any warranties or conditions

-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A

-      PARTICULAR PURPOSE. You are solely responsible for determining the

-      appropriateness of using or redistributing the Work and assume any

-      risks associated with Your exercise of permissions under this License.

-

-   8. Limitation of Liability. In no event and under no legal theory,

-      whether in tort (including negligence), contract, or otherwise,

-      unless required by applicable law (such as deliberate and grossly

-      negligent acts) or agreed to in writing, shall any Contributor be

-      liable to You for damages, including any direct, indirect, special,

-      incidental, or consequential damages of any character arising as a

-      result of this License or out of the use or inability to use the

-      Work (including but not limited to damages for loss of goodwill,

-      work stoppage, computer failure or malfunction, or any and all

-      other commercial damages or losses), even if such Contributor

-      has been advised of the possibility of such damages.

-

-   9. Accepting Warranty or Additional Liability. While redistributing

-      the Work or Derivative Works thereof, You may choose to offer,

-      and charge a fee for, acceptance of support, warranty, indemnity,

-      or other liability obligations and/or rights consistent with this

-      License. However, in accepting such obligations, You may act only

-      on Your own behalf and on Your sole responsibility, not on behalf

-      of any other Contributor, and only if You agree to indemnify,

-      defend, and hold each Contributor harmless for any liability

-      incurred by, or claims asserted against, such Contributor by reason

-      of your accepting any such warranty or additional liability.

-

-   END OF TERMS AND CONDITIONS

-

-   APPENDIX: How to apply the Apache License to your work.

-

-      To apply the Apache License to your work, attach the following

-      boilerplate notice, with the fields enclosed by brackets "[]"

-      replaced with your own identifying information. (Don't include

-      the brackets!)  The text should be enclosed in the appropriate

-      comment syntax for the file format. We also recommend that a

-      file or class name and description of purpose be included on the

-      same "printed page" as the copyright notice for easier

-      identification within third-party archives.

-

-   Copyright [yyyy] [name of copyright owner]

-

-   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.

deleted file mode 100644

@@ -1,33 +0,0 @@

-# Go Test Yourself

-

-A collection of packages compatible with `go test` to support common testing

-patterns.

-

-[![GoDoc](https://godoc.org/github.com/gotestyourself/gotestyourself?status.svg)](https://godoc.org/github.com/gotestyourself/gotestyourself)

-[![CircleCI](https://circleci.com/gh/gotestyourself/gotestyourself/tree/master.svg?style=shield)](https://circleci.com/gh/gotestyourself/gotestyourself/tree/master)

-[![Go Reportcard](https://goreportcard.com/badge/github.com/gotestyourself/gotestyourself)](https://goreportcard.com/report/github.com/gotestyourself/gotestyourself)

-

-

-## Packages

-

-* [assert](http://godoc.org/github.com/gotestyourself/gotestyourself/assert) -

-  compare values and fail the test when the comparison fails

-* [env](http://godoc.org/github.com/gotestyourself/gotestyourself/env) -

-  test code that uses environment variables

-* [fs](http://godoc.org/github.com/gotestyourself/gotestyourself/fs) -

-  create test files and directories

-* [golden](http://godoc.org/github.com/gotestyourself/gotestyourself/golden) -

-  compare large multi-line strings

-* [icmd](http://godoc.org/github.com/gotestyourself/gotestyourself/icmd) -

-  execute binaries and test the output

-* [poll](http://godoc.org/github.com/gotestyourself/gotestyourself/poll) -

-  test asynchronous code by polling until a desired state is reached

-* [skip](http://godoc.org/github.com/gotestyourself/gotestyourself/skip) -

-  skip tests based on conditions

-* [testsum](http://godoc.org/github.com/gotestyourself/gotestyourself/testsum) -

-  a program to summarize `go test` output and test failures

-

-## Related

-

-* [maxbrunsfeld/counterfeiter](https://github.com/maxbrunsfeld/counterfeiter) - generate fakes for interfaces

-* [jonboulle/clockwork](https://github.com/jonboulle/clockwork) - a fake clock for testing code that uses `time`

deleted file mode 100644

@@ -1,289 +0,0 @@

-/*Package assert provides assertions for comparing expected values to actual

-values. When an assertion fails a helpful error message is printed.

-

-Assert and Check

-

-Assert() and Check() both accept a Comparison, and fail the test when the

-comparison fails. The one difference is that Assert() will end the test execution

-immediately (using t.FailNow()) whereas Check() will fail the test (using t.Fail()),

-return the value of the comparison, then proceed with the rest of the test case.

-

-Example Usage

-

-The example below shows assert used with some common types.

-

-

-	import (

-	    "testing"

-

-	    "github.com/gotestyourself/gotestyourself/assert"

-	    is "github.com/gotestyourself/gotestyourself/assert/cmp"

-	)

-

-	func TestEverything(t *testing.T) {

-	    // booleans

-	    assert.Assert(t, ok)

-	    assert.Assert(t, !missing)

-

-	    // primitives

-	    assert.Equal(t, count, 1)

-	    assert.Equal(t, msg, "the message")

-	    assert.Assert(t, total != 10) // NotEqual

-

-	    // errors

-	    assert.NilError(t, closer.Close())

-	    assert.Error(t, err, "the exact error message")

-	    assert.ErrorContains(t, err, "includes this")

-	    assert.ErrorType(t, err, os.IsNotExist)

-

-	    // complex types

-	    assert.DeepEqual(t, result, myStruct{Name: "title"})

-	    assert.Assert(t, is.Len(items, 3))

-	    assert.Assert(t, len(sequence) != 0) // NotEmpty

-	    assert.Assert(t, is.Contains(mapping, "key"))

-

-	    // pointers and interface

-	    assert.Assert(t, is.Nil(ref))

-	    assert.Assert(t, ref != nil) // NotNil

-	}

-

-Comparisons

-

-https://godoc.org/github.com/gotestyourself/gotestyourself/assert/cmp provides

-many common comparisons. Additional comparisons can be written to compare

-values in other ways. See the example Assert (CustomComparison).

-

-*/

-package assert

-

-import (

-	"fmt"

-	"go/ast"

-	"go/token"

-

-	gocmp "github.com/google/go-cmp/cmp"

-	"github.com/gotestyourself/gotestyourself/assert/cmp"

-	"github.com/gotestyourself/gotestyourself/internal/format"

-	"github.com/gotestyourself/gotestyourself/internal/source"

-)

-

-// BoolOrComparison can be a bool, or cmp.Comparison. See Assert() for usage.

-type BoolOrComparison interface{}

-

-// TestingT is the subset of testing.T used by the assert package.

-type TestingT interface {

-	FailNow()

-	Fail()

-	Log(args ...interface{})

-}

-

-type helperT interface {

-	Helper()

-}

-

-const failureMessage = "assertion failed: "

-

-// nolint: gocyclo

-func assert(

-	t TestingT,

-	failer func(),

-	argSelector argSelector,

-	comparison BoolOrComparison,

-	msgAndArgs ...interface{},

-) bool {

-	if ht, ok := t.(helperT); ok {

-		ht.Helper()

-	}

-	var success bool

-	switch check := comparison.(type) {

-	case bool:

-		if check {

-			return true

-		}

-		logFailureFromBool(t, msgAndArgs...)

-

-	// Undocumented legacy comparison without Result type

-	case func() (success bool, message string):

-		success = runCompareFunc(t, check, msgAndArgs...)

-

-	case nil:

-		return true

-

-	case error:

-		msg := "error is not nil: "

-		t.Log(format.WithCustomMessage(failureMessage+msg+check.Error(), msgAndArgs...))

-

-	case cmp.Comparison:

-		success = runComparison(t, argSelector, check, msgAndArgs...)

-

-	case func() cmp.Result:

-		success = runComparison(t, argSelector, check, msgAndArgs...)

-

-	default:

-		t.Log(fmt.Sprintf("invalid Comparison: %v (%T)", check, check))

-	}

-

-	if success {

-		return true

-	}

-	failer()

-	return false

-}

-

-func runCompareFunc(

-	t TestingT,

-	f func() (success bool, message string),

-	msgAndArgs ...interface{},

-) bool {

-	if ht, ok := t.(helperT); ok {

-		ht.Helper()

-	}

-	if success, message := f(); !success {

-		t.Log(format.WithCustomMessage(failureMessage+message, msgAndArgs...))

-		return false

-	}

-	return true

-}

-

-func logFailureFromBool(t TestingT, msgAndArgs ...interface{}) {

-	if ht, ok := t.(helperT); ok {

-		ht.Helper()

-	}

-	const stackIndex = 3 // Assert()/Check(), assert(), formatFailureFromBool()

-	const comparisonArgPos = 1

-	args, err := source.CallExprArgs(stackIndex)

-	if err != nil {

-		t.Log(err.Error())

-		return

-	}

-

-	msg, err := boolFailureMessage(args[comparisonArgPos])

-	if err != nil {

-		t.Log(err.Error())

-		msg = "expression is false"

-	}

-

-	t.Log(format.WithCustomMessage(failureMessage+msg, msgAndArgs...))

-}

-

-func boolFailureMessage(expr ast.Expr) (string, error) {

-	if binaryExpr, ok := expr.(*ast.BinaryExpr); ok && binaryExpr.Op == token.NEQ {

-		x, err := source.FormatNode(binaryExpr.X)

-		if err != nil {

-			return "", err

-		}

-		y, err := source.FormatNode(binaryExpr.Y)

-		if err != nil {

-			return "", err

-		}

-		return x + " is " + y, nil

-	}

-

-	if unaryExpr, ok := expr.(*ast.UnaryExpr); ok && unaryExpr.Op == token.NOT {

-		x, err := source.FormatNode(unaryExpr.X)

-		if err != nil {

-			return "", err

-		}

-		return x + " is true", nil

-	}

-

-	formatted, err := source.FormatNode(expr)

-	if err != nil {

-		return "", err

-	}

-	return "expression is false: " + formatted, nil

-}

-

-// Assert performs a comparison. If the comparison fails the test is marked as

-// failed, a failure message is logged, and execution is stopped immediately.

-//

-// The comparison argument may be one of three types: bool, cmp.Comparison or

-// error.

-// When called with a bool the failure message will contain the literal source

-// code of the expression.

-// When called with a cmp.Comparison the comparison is responsible for producing

-// a helpful failure message.

-// When called with an error a nil value is considered success. A non-nil error

-// is a failure, and Error() is used as the failure message.

-func Assert(t TestingT, comparison BoolOrComparison, msgAndArgs ...interface{}) {

-	if ht, ok := t.(helperT); ok {

-		ht.Helper()

-	}

-	assert(t, t.FailNow, argsFromComparisonCall, comparison, msgAndArgs...)

-}

-

-// Check performs a comparison. If the comparison fails the test is marked as

-// failed, a failure message is logged, and Check returns false. Otherwise returns

-// true.

-//

-// See Assert for details about the comparison arg and failure messages.

-func Check(t TestingT, comparison BoolOrComparison, msgAndArgs ...interface{}) bool {

-	if ht, ok := t.(helperT); ok {

-		ht.Helper()

-	}

-	return assert(t, t.Fail, argsFromComparisonCall, comparison, msgAndArgs...)

-}

-

-// NilError fails the test immediately if err is not nil.

-// This is equivalent to Assert(t, err)

-func NilError(t TestingT, err error, msgAndArgs ...interface{}) {

-	if ht, ok := t.(helperT); ok {

-		ht.Helper()

-	}

-	assert(t, t.FailNow, argsAfterT, err, msgAndArgs...)

-}

-

-// Equal uses the == operator to assert two values are equal and fails the test

-// if they are not equal. This is equivalent to Assert(t, cmp.Equal(x, y)).

-func Equal(t TestingT, x, y interface{}, msgAndArgs ...interface{}) {

-	if ht, ok := t.(helperT); ok {

-		ht.Helper()

-	}

-	assert(t, t.FailNow, argsAfterT, cmp.Equal(x, y), msgAndArgs...)

-}

-

-// DeepEqual uses https://github.com/google/go-cmp/cmp to assert two values

-// are equal and fails the test if they are not equal.

-// This is equivalent to Assert(t, cmp.DeepEqual(x, y)).

-func DeepEqual(t TestingT, x, y interface{}, opts ...gocmp.Option) {

-	if ht, ok := t.(helperT); ok {

-		ht.Helper()

-	}

-	assert(t, t.FailNow, argsAfterT, cmp.DeepEqual(x, y, opts...))

-}

-

-// Error fails the test if err is nil, or the error message is not the expected

-// message.

-// Equivalent to Assert(t, cmp.Error(err, message)).

-func Error(t TestingT, err error, message string, msgAndArgs ...interface{}) {

-	if ht, ok := t.(helperT); ok {

-		ht.Helper()

-	}

-	assert(t, t.FailNow, argsAfterT, cmp.Error(err, message), msgAndArgs...)

-}

-

-// ErrorContains fails the test if err is nil, or the error message does not

-// contain the expected substring.

-// Equivalent to Assert(t, cmp.ErrorContains(err, substring)).

-func ErrorContains(t TestingT, err error, substring string, msgAndArgs ...interface{}) {

-	if ht, ok := t.(helperT); ok {

-		ht.Helper()

-	}

-	assert(t, t.FailNow, argsAfterT, cmp.ErrorContains(err, substring), msgAndArgs...)

-}

-

-// ErrorType fails the test if err is nil, or err is not the expected type.

-//

-// Expected can be one of:

-// a func(error) bool which returns true if the error is the expected type,

-// an instance of a struct of the expected type,

-// a pointer to an interface the error is expected to implement,

-// a reflect.Type of the expected struct or interface.

-//

-// Equivalent to Assert(t, cmp.ErrorType(err, expected)).

-func ErrorType(t TestingT, err error, expected interface{}, msgAndArgs ...interface{}) {

-	if ht, ok := t.(helperT); ok {

-		ht.Helper()

-	}

-	assert(t, t.FailNow, argsAfterT, cmp.ErrorType(err, expected), msgAndArgs...)

-}

deleted file mode 100644

@@ -1,310 +0,0 @@

-/*Package cmp provides Comparisons for Assert and Check*/

-package cmp

-

-import (

-	"fmt"

-	"reflect"

-	"strings"

-

-	"github.com/google/go-cmp/cmp"

-	"github.com/pmezard/go-difflib/difflib"

-)

-

-// Comparison is a function which compares values and returns ResultSuccess if

-// the actual value matches the expected value. If the values do not match the

-// Result will contain a message about why it failed.

-type Comparison func() Result

-

-// DeepEqual compares two values using https://godoc.org/github.com/google/go-cmp/cmp

-// and succeeds if the values are equal.

-//

-// The comparison can be customized using comparison Options.

-func DeepEqual(x, y interface{}, opts ...cmp.Option) Comparison {

-	return func() (result Result) {

-		defer func() {

-			if panicmsg, handled := handleCmpPanic(recover()); handled {

-				result = ResultFailure(panicmsg)

-			}

-		}()

-		diff := cmp.Diff(x, y, opts...)

-		return toResult(diff == "", "\n"+diff)

-	}

-}

-

-func handleCmpPanic(r interface{}) (string, bool) {

-	if r == nil {

-		return "", false

-	}

-	panicmsg, ok := r.(string)

-	if !ok {

-		panic(r)

-	}

-	switch {

-	case strings.HasPrefix(panicmsg, "cannot handle unexported field"):

-		return panicmsg, true

-	}

-	panic(r)

-}

-

-func toResult(success bool, msg string) Result {

-	if success {

-		return ResultSuccess

-	}

-	return ResultFailure(msg)

-}

-

-// Equal succeeds if x == y.

-func Equal(x, y interface{}) Comparison {

-	return func() Result {

-		switch {

-		case x == y:

-			return ResultSuccess

-		case isMultiLineStringCompare(x, y):

-			return multiLineStringDiffResult(x.(string), y.(string))

-		}

-		return ResultFailureTemplate(`

-			{{- .Data.x}} (

-				{{- with callArg 0 }}{{ formatNode . }} {{end -}}

-				{{- printf "%T" .Data.x -}}

-			) != {{ .Data.y}} (

-				{{- with callArg 1 }}{{ formatNode . }} {{end -}}

-				{{- printf "%T" .Data.y -}}

-			)`,

-			map[string]interface{}{"x": x, "y": y})

-	}

-}

-

-func isMultiLineStringCompare(x, y interface{}) bool {

-	strX, ok := x.(string)

-	if !ok {

-		return false

-	}

-	strY, ok := y.(string)

-	if !ok {

-		return false

-	}

-	return strings.Contains(strX, "\n") || strings.Contains(strY, "\n")

-}

-

-func multiLineStringDiffResult(x, y string) Result {

-	diff, err := difflib.GetUnifiedDiffString(difflib.UnifiedDiff{

-		A:       difflib.SplitLines(x),

-		B:       difflib.SplitLines(y),

-		Context: 3,

-	})

-	if err != nil {

-		return ResultFailure(fmt.Sprintf("failed to diff: %s", err))

-	}

-	return ResultFailureTemplate(`

-+++ {{ with callArg 1 }}{{ formatNode . }}{{else}}→{{end}}

-{{ .Data.diff }}`,

-		map[string]interface{}{"diff": diff})

-}

-

-// Len succeeds if the sequence has the expected length.

-func Len(seq interface{}, expected int) Comparison {

-	return func() (result Result) {

-		defer func() {

-			if e := recover(); e != nil {

-				result = ResultFailure(fmt.Sprintf("type %T does not have a length", seq))

-			}

-		}()

-		value := reflect.ValueOf(seq)

-		length := value.Len()

-		if length == expected {

-			return ResultSuccess

-		}

-		msg := fmt.Sprintf("expected %s (length %d) to have length %d", seq, length, expected)

-		return ResultFailure(msg)

-	}

-}

-

-// Contains succeeds if item is in collection. Collection may be a string, map,

-// slice, or array.

-//

-// If collection is a string, item must also be a string, and is compared using

-// strings.Contains().

-// If collection is a Map, contains will succeed if item is a key in the map.

-// If collection is a slice or array, item is compared to each item in the

-// sequence using reflect.DeepEqual().

-func Contains(collection interface{}, item interface{}) Comparison {

-	return func() Result {

-		colValue := reflect.ValueOf(collection)

-		if !colValue.IsValid() {

-			return ResultFailure(fmt.Sprintf("nil does not contain items"))

-		}

-		msg := fmt.Sprintf("%v does not contain %v", collection, item)

-

-		itemValue := reflect.ValueOf(item)

-		switch colValue.Type().Kind() {

-		case reflect.String:

-			if itemValue.Type().Kind() != reflect.String {

-				return ResultFailure("string may only contain strings")

-			}

-			return toResult(

-				strings.Contains(colValue.String(), itemValue.String()),

-				fmt.Sprintf("string %q does not contain %q", collection, item))

-

-		case reflect.Map:

-			if itemValue.Type() != colValue.Type().Key() {

-				return ResultFailure(fmt.Sprintf(

-					"%v can not contain a %v key", colValue.Type(), itemValue.Type()))

-			}

-			return toResult(colValue.MapIndex(itemValue).IsValid(), msg)

-

-		case reflect.Slice, reflect.Array:

-			for i := 0; i < colValue.Len(); i++ {

-				if reflect.DeepEqual(colValue.Index(i).Interface(), item) {

-					return ResultSuccess

-				}

-			}

-			return ResultFailure(msg)

-		default:

-			return ResultFailure(fmt.Sprintf("type %T does not contain items", collection))

-		}

-	}

-}

-

-// Panics succeeds if f() panics.

-func Panics(f func()) Comparison {

-	return func() (result Result) {

-		defer func() {

-			if err := recover(); err != nil {

-				result = ResultSuccess

-			}

-		}()

-		f()

-		return ResultFailure("did not panic")

-	}

-}

-

-// Error succeeds if err is a non-nil error, and the error message equals the

-// expected message.

-func Error(err error, message string) Comparison {

-	return func() Result {

-		switch {

-		case err == nil:

-			return ResultFailure("expected an error, got nil")

-		case err.Error() != message:

-			return ResultFailure(fmt.Sprintf(

-				"expected error %q, got %+v", message, err))

-		}

-		return ResultSuccess

-	}

-}

-

-// ErrorContains succeeds if err is a non-nil error, and the error message contains

-// the expected substring.

-func ErrorContains(err error, substring string) Comparison {

-	return func() Result {

-		switch {

-		case err == nil:

-			return ResultFailure("expected an error, got nil")

-		case !strings.Contains(err.Error(), substring):

-			return ResultFailure(fmt.Sprintf(

-				"expected error to contain %q, got %+v", substring, err))

-		}

-		return ResultSuccess

-	}

-}

-

-// Nil succeeds if obj is a nil interface, pointer, or function.

-//

-// Use NilError() for comparing errors. Use Len(obj, 0) for comparing slices,

-// maps, and channels.

-func Nil(obj interface{}) Comparison {

-	msgFunc := func(value reflect.Value) string {

-		return fmt.Sprintf("%v (type %s) is not nil", reflect.Indirect(value), value.Type())

-	}

-	return isNil(obj, msgFunc)

-}

-

-func isNil(obj interface{}, msgFunc func(reflect.Value) string) Comparison {

-	return func() Result {

-		if obj == nil {

-			return ResultSuccess

-		}

-		value := reflect.ValueOf(obj)

-		kind := value.Type().Kind()

-		if kind >= reflect.Chan && kind <= reflect.Slice {

-			if value.IsNil() {

-				return ResultSuccess

-			}

-			return ResultFailure(msgFunc(value))

-		}

-

-		return ResultFailure(fmt.Sprintf("%v (type %s) can not be nil", value, value.Type()))

-	}

-}

-

-// ErrorType succeeds if err is not nil and is of the expected type.

-//

-// Expected can be one of:

-// a func(error) bool which returns true if the error is the expected type,

-// an instance of a struct of the expected type,

-// a pointer to an interface the error is expected to implement,

-// a reflect.Type of the expected struct or interface.

-func ErrorType(err error, expected interface{}) Comparison {

-	return func() Result {

-		switch expectedType := expected.(type) {

-		case func(error) bool:

-			return cmpErrorTypeFunc(err, expectedType)

-		case reflect.Type:

-			if expectedType.Kind() == reflect.Interface {

-				return cmpErrorTypeImplementsType(err, expectedType)

-			}

-			return cmpErrorTypeEqualType(err, expectedType)

-		case nil:

-			return ResultFailure(fmt.Sprintf("invalid type for expected: nil"))

-		}

-

-		expectedType := reflect.TypeOf(expected)

-		switch {

-		case expectedType.Kind() == reflect.Struct:

-			return cmpErrorTypeEqualType(err, expectedType)

-		case isPtrToInterface(expectedType):

-			return cmpErrorTypeImplementsType(err, expectedType.Elem())

-		}

-		return ResultFailure(fmt.Sprintf("invalid type for expected: %T", expected))

-	}

-}

-

-func cmpErrorTypeFunc(err error, f func(error) bool) Result {

-	if f(err) {

-		return ResultSuccess

-	}

-	actual := "nil"

-	if err != nil {

-		actual = fmt.Sprintf("%s (%T)", err, err)

-	}

-	return ResultFailureTemplate(`error is {{ .Data.actual }}

-		{{- with callArg 1 }}, not {{ formatNode . }}{{end -}}`,

-		map[string]interface{}{"actual": actual})

-}

-

-func cmpErrorTypeEqualType(err error, expectedType reflect.Type) Result {

-	if err == nil {

-		return ResultFailure(fmt.Sprintf("error is nil, not %s", expectedType))

-	}

-	errValue := reflect.ValueOf(err)

-	if errValue.Type() == expectedType {

-		return ResultSuccess

-	}

-	return ResultFailure(fmt.Sprintf("error is %s (%T), not %s", err, err, expectedType))

-}

-

-func cmpErrorTypeImplementsType(err error, expectedType reflect.Type) Result {

-	if err == nil {

-		return ResultFailure(fmt.Sprintf("error is nil, not %s", expectedType))

-	}

-	errValue := reflect.ValueOf(err)

-	if errValue.Type().Implements(expectedType) {

-		return ResultSuccess

-	}

-	return ResultFailure(fmt.Sprintf("error is %s (%T), not %s", err, err, expectedType))

-}

-

-func isPtrToInterface(typ reflect.Type) bool {

-	return typ.Kind() == reflect.Ptr && typ.Elem().Kind() == reflect.Interface

-}

deleted file mode 100644

@@ -1,94 +0,0 @@

-package cmp

-

-import (

-	"bytes"

-	"fmt"

-	"go/ast"