assert

func CallerInfo ¶

func CallerInfo() []string

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 Condition ¶

func Condition(t T, comp Comparison, msgAndArgs ...any) bool

Condition uses a Comparison to assert a complex condition.

Usage ¶

assertions.Condition(t, func() bool { return myCondition })

Examples ¶

success:  func() bool { return true }
failure:  func() bool { return false }

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T)
	success := assert.Condition(t, func() bool {
		return true
	})
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func Conditionf ¶

func Conditionf(t T, comp Comparison, msg string, args ...any) bool

Conditionf is the same as Condition, but accepts a format msg string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func Contains ¶

func Contains(t T, s any, contains any, msgAndArgs ...any) bool

Contains asserts that the specified string, list(array, slice...) or map contains the specified substring or element.

Usage ¶

assertions.Contains(t, "Hello World", "World")
assertions.Contains(t, []string{"Hello", "World"}, "World")
assertions.Contains(t, map[string]string{"Hello": "World"}, "Hello")

Examples ¶

success: []string{"A","B"}, "A"
failure: []string{"A","B"}, "C"

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T)
	success := assert.Contains(t, []string{"A", "B"}, "A")
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func Containsf ¶

func Containsf(t T, s any, contains any, msg string, args ...any) bool

Containsf is the same as Contains, but accepts a format msg string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func DirExists ¶

func DirExists(t T, path string, msgAndArgs ...any) bool

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.

Usage ¶

assertions.DirExists(t, "path/to/directory")

Examples ¶

success: filepath.Join(testDataPath(),"existing_dir")
failure: filepath.Join(testDataPath(),"non_existing_dir")

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"path/filepath"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T)
	success := assert.DirExists(t, filepath.Join(testDataPath(), "existing_dir"))
	fmt.Printf("success: %t\n", success)

}

func testDataPath() string {
	return filepath.Join("..", "internal", "assertions", "testdata")
}

Output:

success: true

func DirExistsf ¶

func DirExistsf(t T, path string, msg string, args ...any) bool

DirExistsf is the same as DirExists, but accepts a format msg string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func ElementsMatch ¶

func ElementsMatch(t T, listA any, listB any, msgAndArgs ...any) (ok bool)

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.

Usage ¶

assertions.ElementsMatch(t, [1, 3, 2, 3], [1, 3, 3, 2])

Examples ¶

success: []int{1, 3, 2, 3}, []int{1, 3, 3, 2}
failure: []int{1, 2, 3}, []int{1, 2, 4}

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T)
	success := assert.ElementsMatch(t, []int{1, 3, 2, 3}, []int{1, 3, 3, 2})
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func ElementsMatchf ¶

func ElementsMatchf(t T, listA any, listB any, msg string, args ...any) (ok bool)

ElementsMatchf is the same as ElementsMatch, but accepts a format msg string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func Empty ¶

func Empty(t T, object any, msgAndArgs ...any) bool

Empty asserts that the given value is "empty".

Zero values are "empty".

Arrays are "empty" if every element is the zero value of the type (stricter than "empty").

Slices, maps and channels with zero length are "empty".

Pointer values are "empty" if the pointer is nil or if the pointed value is "empty".

Usage ¶

assertions.Empty(t, obj)

Examples ¶

success: ""
failure: "not empty"

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T)
	success := assert.Empty(t, "")
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func Emptyf ¶

func Emptyf(t T, object any, msg string, args ...any) bool

Emptyf is the same as Empty, but accepts a format msg string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func Equal ¶

func Equal(t T, expected any, actual any, msgAndArgs ...any) bool

Equal asserts that two objects are equal.

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.

Usage ¶

assertions.Equal(t, 123, 123)

Examples ¶

success: 123, 123
failure: 123, 456

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T)
	success := assert.Equal(t, 123, 123)
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func EqualError ¶

func EqualError(t T, theError error, errString string, msgAndArgs ...any) bool

EqualError asserts that a function returned a non-nil error (i.e. an error) and that it is equal to the provided error.

Usage ¶

actualObj, err := SomeFunction()
assertions.EqualError(t, err,  expectedErrorString)

Examples ¶

success: ErrTest, "assert.ErrTest general error for testing"
failure: ErrTest, "wrong error message"

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T)
	success := assert.EqualError(t, assert.ErrTest, "assert.ErrTest general error for testing")
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func EqualErrorf ¶

func EqualErrorf(t T, theError error, errString string, msg string, args ...any) bool

EqualErrorf is the same as EqualError, but accepts a format msg string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func EqualExportedValues ¶

func EqualExportedValues(t T, expected any, actual any, msgAndArgs ...any) bool

EqualExportedValues asserts that the types of two objects are equal and their public fields are also equal. This is useful for comparing structs that have private fields that could potentially differ.

Usage ¶

 type S struct {
	Exported     	int
	notExported   	int
 }
assertions.EqualExportedValues(t, S{1, 2}, S{1, 3}) => true
assertions.EqualExportedValues(t, S{1, 2}, S{2, 3}) => false

Examples ¶

success: &dummyStruct{A: "a", b: 1}, &dummyStruct{A: "a", b: 2}
failure:  &dummyStruct{A: "a", b: 1}, &dummyStruct{A: "b", b: 1}

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T)
	success := assert.EqualExportedValues(t, &dummyStruct{A: "a", b: 1}, &dummyStruct{A: "a", b: 2})
	fmt.Printf("success: %t\n", success)

}

type dummyStruct struct {
	A string
	b int
}

Output:

success: true

func EqualExportedValuesf ¶

func EqualExportedValuesf(t T, expected any, actual any, msg string, args ...any) bool

EqualExportedValuesf is the same as EqualExportedValues, but accepts a format msg string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func EqualValues ¶

func EqualValues(t T, expected any, actual any, msgAndArgs ...any) bool

EqualValues asserts that two objects are equal or convertible to the larger type and equal.

Usage ¶

assertions.EqualValues(t, uint32(123), int32(123))

Examples ¶

success: uint32(123), int32(123)
failure: uint32(123), int32(456)

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T)
	success := assert.EqualValues(t, uint32(123), int32(123))
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func EqualValuesf ¶

func EqualValuesf(t T, expected any, actual any, msg string, args ...any) bool

EqualValuesf is the same as EqualValues, but accepts a format msg string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func Equalf ¶

func Equalf(t T, expected any, actual any, msg string, args ...any) bool

Equalf is the same as Equal, but accepts a format msg string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func Error ¶

func Error(t T, err error, msgAndArgs ...any) bool

Error asserts that a function returned a non-nil error (ie. an error).

Usage ¶

actualObj, err := SomeFunction()
assertions.Error(t, err)

Examples ¶

success: ErrTest
failure: nil

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T)
	success := assert.Error(t, assert.ErrTest)
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func ErrorAs ¶

func ErrorAs(t T, err error, target any, msgAndArgs ...any) bool

ErrorAs asserts that at least one of the errors in err's chain matches target, and if so, sets target to that error value.

This is a wrapper for errors.As.

Usage ¶

assertions.ErrorAs(t, err, &target)

Examples ¶

success: fmt.Errorf("wrap: %w", &dummyError{}), new(*dummyError)
failure: ErrTest, new(*dummyError)

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T)
	success := assert.ErrorAs(t, fmt.Errorf("wrap: %w", &dummyError{}), new(*dummyError))
	fmt.Printf("success: %t\n", success)

}

type dummyError struct {
}

func (d *dummyError) Error() string {
	return "dummy error"
}

Output:

success: true

func ErrorAsf ¶

func ErrorAsf(t T, err error, target any, msg string, args ...any) bool

ErrorAsf is the same as ErrorAs, but accepts a format msg string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func ErrorContains ¶

func ErrorContains(t T, theError error, contains string, msgAndArgs ...any) bool

ErrorContains asserts that a function returned a non-nil error (i.e. an error) and that the error contains the specified substring.

Usage ¶

actualObj, err := SomeFunction()
assertions.ErrorContains(t, err,  expectedErrorSubString)

Examples ¶

success: ErrTest, "general error"
failure: ErrTest, "not in message"

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T)
	success := assert.ErrorContains(t, assert.ErrTest, "general error")
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func ErrorContainsf ¶

func ErrorContainsf(t T, theError error, contains string, msg string, args ...any) bool

ErrorContainsf is the same as ErrorContains, but accepts a format msg string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func ErrorIs ¶

func ErrorIs(t T, err error, target error, msgAndArgs ...any) bool

ErrorIs asserts that at least one of the errors in err's chain matches target.

This is a wrapper for errors.Is.

Usage ¶

assertions.ErrorIs(t, err, io.EOF)

Examples ¶

success: fmt.Errorf("wrap: %w", io.EOF), io.EOF
failure: ErrTest, io.EOF

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"io"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T)
	success := assert.ErrorIs(t, fmt.Errorf("wrap: %w", io.EOF), io.EOF)
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func ErrorIsf ¶

func ErrorIsf(t T, err error, target error, msg string, args ...any) bool

ErrorIsf is the same as ErrorIs, but accepts a format msg string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func Errorf ¶

func Errorf(t T, err error, msg string, args ...any) bool

Errorf is the same as Error, but accepts a format msg string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func Eventually ¶

func Eventually(t T, condition func() bool, waitFor time.Duration, tick time.Duration, msgAndArgs ...any) bool

Eventually asserts that given condition will be met in waitFor time, periodically checking target function each tick.

Usage ¶

assertions.Eventually(t, func() bool { return true; }, time.Second, 10*time.Millisecond)

Examples ¶

success:  func() bool { return true }, 100*time.Millisecond, 20*time.Millisecond
failure:  func() bool { return false }, 100*time.Millisecond, 20*time.Millisecond

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"
	"time"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T)
	success := assert.Eventually(t, func() bool {
		return true
	}, 100*time.Millisecond, 20*time.Millisecond)
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func EventuallyWithT ¶

func EventuallyWithT(t T, condition func(collect *CollectT), waitFor time.Duration, tick time.Duration, msgAndArgs ...any) bool

EventuallyWithT asserts that given condition will be met in waitFor time, periodically checking target function each tick. In contrast to Eventually, it supplies a CollectT to the condition function, so that the condition function can use the CollectT to call other assertions. The condition is considered "met" if no errors are raised in a tick. The supplied CollectT collects all errors from one tick (if there are any). If the condition is not met before waitFor, the collected errors of the last tick are copied to t.

Usage ¶

externalValue := false
go func() {
	time.Sleep(8*time.Second)
	externalValue = true
}()
assertions.EventuallyWithT(t, func(c *assertions.CollectT) {
	// add assertions as needed; any assertion failure will fail the current tick
	assertions.True(c, externalValue, "expected 'externalValue' to be true")
}, 10*time.Second, 1*time.Second, "external state has not changed to 'true'; still false")

Examples ¶

success: func(c *CollectT) { True(c,true) }, 100*time.Millisecond, 20*time.Millisecond
failure: func(c *CollectT) { False(c,true) }, 100*time.Millisecond, 20*time.Millisecond

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"
	"time"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T)
	success := assert.EventuallyWithT(t, func(c *assert.CollectT) {
		assert.True(c, true)
	}, 100*time.Millisecond, 20*time.Millisecond)
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func EventuallyWithTf ¶

func EventuallyWithTf(t T, condition func(collect *CollectT), waitFor time.Duration, tick time.Duration, msg string, args ...any) bool

EventuallyWithTf is the same as EventuallyWithT, but accepts a format msg string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func Eventuallyf ¶

func Eventuallyf(t T, condition func() bool, waitFor time.Duration, tick time.Duration, msg string, args ...any) bool

Eventuallyf is the same as Eventually, but accepts a format msg string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func Exactly ¶

func Exactly(t T, expected any, actual any, msgAndArgs ...any) bool

Exactly asserts that two objects are equal in value and type.

Usage ¶

assertions.Exactly(t, int32(123), int64(123))

Examples ¶

success: int32(123), int32(123)
failure: int32(123), int64(123)

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T)
	success := assert.Exactly(t, int32(123), int32(123))
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func Exactlyf ¶

func Exactlyf(t T, expected any, actual any, msg string, args ...any) bool

Exactlyf is the same as Exactly, but accepts a format msg string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func Fail ¶

func Fail(t T, failureMessage string, msgAndArgs ...any) bool

Fail reports a failure through.

Usage ¶

assertions.Fail(t, "failed")

Examples ¶

failure: "failed"

Upon failure, the test T is marked as failed and continues execution.

func FailNow ¶

func FailNow(t T, failureMessage string, msgAndArgs ...any) bool

FailNow fails test.

Usage ¶

assertions.FailNow(t, "failed")

Examples ¶

failure: "failed"

Upon failure, the test T is marked as failed and continues execution.

func FailNowf ¶

func FailNowf(t T, failureMessage string, msg string, args ...any) bool

FailNowf is the same as FailNow, but accepts a format msg string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func Failf ¶

func Failf(t T, failureMessage string, msg string, args ...any) bool

Failf is the same as Fail, but accepts a format msg string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func False ¶

func False(t T, value bool, msgAndArgs ...any) bool

False asserts that the specified value is false.

Usage ¶

assertions.False(t, myBool)

Examples ¶

success: 1 == 0
failure: 1 == 1

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T)
	success := assert.False(t, 1 == 0)
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func Falsef ¶

func Falsef(t T, value bool, msg string, args ...any) bool

Falsef is the same as False, but accepts a format msg string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func FileEmpty ¶ added in v2.1.0

func FileEmpty(t T, path string, msgAndArgs ...any) bool

FileEmpty checks whether a file exists in the given path and is empty. It fails if the file is not empty, if the path points to a directory or there is an error when trying to check the file.

Usage ¶

assertions.FileEmpty(t, "path/to/file")

Examples ¶

success: filepath.Join(testDataPath(),"empty_file")
failure: filepath.Join(testDataPath(),"existing_file")

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"path/filepath"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T)
	success := assert.FileEmpty(t, filepath.Join(testDataPath(), "empty_file"))
	fmt.Printf("success: %t\n", success)

}

func testDataPath() string {
	return filepath.Join("..", "internal", "assertions", "testdata")
}

Output:

success: true

func FileEmptyf ¶ added in v2.1.0

func FileEmptyf(t T, path string, msg string, args ...any) bool

FileEmptyf is the same as FileEmpty, but accepts a format msg string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func FileExists ¶

func FileExists(t T, path string, msgAndArgs ...any) bool

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.

Usage ¶

assertions.FileExists(t, "path/to/file")

Examples ¶

success: filepath.Join(testDataPath(),"existing_file")
failure: filepath.Join(testDataPath(),"non_existing_file")

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"path/filepath"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T)
	success := assert.FileExists(t, filepath.Join(testDataPath(), "existing_file"))
	fmt.Printf("success: %t\n", success)

}

func testDataPath() string {
	return filepath.Join("..", "internal", "assertions", "testdata")
}

Output:

success: true

func FileExistsf ¶

func FileExistsf(t T, path string, msg string, args ...any) bool

FileExistsf is the same as FileExists, but accepts a format msg string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func FileNotEmpty ¶ added in v2.1.0

func FileNotEmpty(t T, path string, msgAndArgs ...any) bool

FileNotEmpty checks whether a file exists in the given path and is not empty. It fails if the file is empty, if the path points to a directory or there is an error when trying to check the file.

Usage ¶

assertions.FileNotEmpty(t, "path/to/file")

Examples ¶

success: filepath.Join(testDataPath(),"existing_file")
failure: filepath.Join(testDataPath(),"empty_file")

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"path/filepath"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T)
	success := assert.FileNotEmpty(t, filepath.Join(testDataPath(), "existing_file"))
	fmt.Printf("success: %t\n", success)

}

func testDataPath() string {
	return filepath.Join("..", "internal", "assertions", "testdata")
}

Output:

success: true

func FileNotEmptyf ¶ added in v2.1.0

func FileNotEmptyf(t T, path string, msg string, args ...any) bool

FileNotEmptyf is the same as FileNotEmpty, but accepts a format msg string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func Greater ¶

func Greater(t T, e1 any, e2 any, msgAndArgs ...any) bool

Greater asserts that the first element is strictly greater than the second.

Usage ¶

assertions.Greater(t, 2, 1)
assertions.Greater(t, float64(2), float64(1))
assertions.Greater(t, "b", "a")

Examples ¶

success: 2, 1
failure: 1, 2

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T)
	success := assert.Greater(t, 2, 1)
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func GreaterOrEqual ¶

func GreaterOrEqual(t T, e1 any, e2 any, msgAndArgs ...any) bool

GreaterOrEqual asserts that the first element is greater than or equal to the second.

Usage ¶

assertions.GreaterOrEqual(t, 2, 1)
assertions.GreaterOrEqual(t, 2, 2)
assertions.GreaterOrEqual(t, "b", "a")
assertions.GreaterOrEqual(t, "b", "b")

Examples ¶

success: 2, 1
failure: 1, 2

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T)
	success := assert.GreaterOrEqual(t, 2, 1)
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func GreaterOrEqualf ¶

func GreaterOrEqualf(t T, e1 any, e2 any, msg string, args ...any) bool

GreaterOrEqualf is the same as GreaterOrEqual, but accepts a format msg string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func Greaterf ¶

func Greaterf(t T, e1 any, e2 any, msg string, args ...any) bool

Greaterf is the same as Greater, but accepts a format msg string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func HTTPBody ¶

func HTTPBody(handler http.HandlerFunc, method string, url string, values url.Values) string

HTTPBody is a helper that returns the HTTP body of the response. It returns the empty string if building a new request fails.

func HTTPBodyContains ¶

func HTTPBodyContains(t T, handler http.HandlerFunc, method string, url string, values url.Values, str any, msgAndArgs ...any) bool

HTTPBodyContains asserts that a specified handler returns a body that contains a string.

Returns whether the assertion was successful (true) or not (false).

Usage ¶

assertions.HTTPBodyContains(t, myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky")

Examples ¶

success: httpBody, "GET", "/", url.Values{"name": []string{"World"}}, "Hello, World!"
failure: httpBody, "GET", "/", url.Values{"name": []string{"Bob"}}, "Hello, World!"

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"net/http"
	"net/url"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T)
	success := assert.HTTPBodyContains(t, httpBody, "GET", "/", url.Values{"name": []string{"World"}}, "Hello, World!")
	fmt.Printf("success: %t\n", success)

}

func httpBody(w http.ResponseWriter, r *http.Request) {
	name := r.FormValue("name")
	_, _ = fmt.Fprintf(w, "Hello, %s!", name)
}

Output:

success: true

func HTTPBodyContainsf ¶

func HTTPBodyContainsf(t T, handler http.HandlerFunc, method string, url string, values url.Values, str any, msg string, args ...any) bool

HTTPBodyContainsf is the same as HTTPBodyContains, but accepts a format msg string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func HTTPBodyNotContains ¶

func HTTPBodyNotContains(t T, handler http.HandlerFunc, method string, url string, values url.Values, str any, msgAndArgs ...any) bool

HTTPBodyNotContains asserts that a specified handler returns a body that does not contain a string.

Returns whether the assertion was successful (true) or not (false).

Usage ¶

assertions.HTTPBodyNotContains(t, myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky")

Examples ¶

success: httpBody, "GET", "/", url.Values{"name": []string{"World"}}, "Hello, Bob!"
failure: httpBody, "GET", "/", url.Values{"name": []string{"Bob"}}, "Hello, Bob!"

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"net/http"
	"net/url"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T)
	success := assert.HTTPBodyNotContains(t, httpBody, "GET", "/", url.Values{"name": []string{"World"}}, "Hello, Bob!")
	fmt.Printf("success: %t\n", success)

}

func httpBody(w http.ResponseWriter, r *http.Request) {
	name := r.FormValue("name")
	_, _ = fmt.Fprintf(w, "Hello, %s!", name)
}

Output:

success: true

func HTTPBodyNotContainsf ¶

func HTTPBodyNotContainsf(t T, handler http.HandlerFunc, method string, url string, values url.Values, str any, msg string, args ...any) bool

HTTPBodyNotContainsf is the same as HTTPBodyNotContains, but accepts a format msg string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func HTTPError ¶

func HTTPError(t T, handler http.HandlerFunc, method string, url string, values url.Values, msgAndArgs ...any) bool

HTTPError asserts that a specified handler returns an error status code.

Returns whether the assertion was successful (true) or not (false).

Usage ¶

assertions.HTTPError(t, myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}}

Examples ¶

success: httpError, "GET", "/", nil
failure: httpOK, "GET", "/", nil

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"net/http"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T)
	success := assert.HTTPError(t, httpError, "GET", "/", nil)
	fmt.Printf("success: %t\n", success)

}

func httpError(w http.ResponseWriter, _ *http.Request) {
	w.WriteHeader(http.StatusInternalServerError)
}

Output:

success: true

func HTTPErrorf ¶

func HTTPErrorf(t T, handler http.HandlerFunc, method string, url string, values url.Values, msg string, args ...any) bool

HTTPErrorf is the same as HTTPError, but accepts a format msg string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func HTTPRedirect ¶

func HTTPRedirect(t T, handler http.HandlerFunc, method string, url string, values url.Values, msgAndArgs ...any) bool

HTTPRedirect asserts that a specified handler returns a redirect status code.

Returns whether the assertion was successful (true) or not (false).

Usage ¶

assertions.HTTPRedirect(t, myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}}

Examples ¶

success: httpRedirect, "GET", "/", nil
failure: httpError, "GET", "/", nil

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"net/http"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T)
	success := assert.HTTPRedirect(t, httpRedirect, "GET", "/", nil)
	fmt.Printf("success: %t\n", success)

}

func httpRedirect(w http.ResponseWriter, _ *http.Request) {
	w.WriteHeader(http.StatusTemporaryRedirect)
}

Output:

success: true

func HTTPRedirectf ¶

func HTTPRedirectf(t T, handler http.HandlerFunc, method string, url string, values url.Values, msg string, args ...any) bool

HTTPRedirectf is the same as HTTPRedirect, but accepts a format msg string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func HTTPStatusCode ¶

func HTTPStatusCode(t T, handler http.HandlerFunc, method string, url string, values url.Values, statuscode int, msgAndArgs ...any) bool

HTTPStatusCode asserts that a specified handler returns a specified status code.

Returns whether the assertion was successful (true) or not (false).

Usage ¶

assertions.HTTPStatusCode(t, myHandler, "GET", "/notImplemented", nil, 501)

Examples ¶

success: httpOK, "GET", "/", nil, http.StatusOK
failure: httpError, "GET", "/", nil, http.StatusOK

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"net/http"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T)
	success := assert.HTTPStatusCode(t, httpOK, "GET", "/", nil, http.StatusOK)
	fmt.Printf("success: %t\n", success)

}

func httpOK(w http.ResponseWriter, _ *http.Request) {
	w.WriteHeader(http.StatusOK)
}

Output:

success: true

func HTTPStatusCodef ¶

func HTTPStatusCodef(t T, handler http.HandlerFunc, method string, url string, values url.Values, statuscode int, msg string, args ...any) bool

HTTPStatusCodef is the same as HTTPStatusCode, but accepts a format msg string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func HTTPSuccess ¶

func HTTPSuccess(t T, handler http.HandlerFunc, method string, url string, values url.Values, msgAndArgs ...any) bool

HTTPSuccess asserts that a specified handler returns a success status code.

Returns whether the assertion was successful (true) or not (false).

Usage ¶

assertions.HTTPSuccess(t, myHandler, "POST", "http://www.google.com", nil)

Examples ¶

success: httpOK, "GET", "/", nil
failure: httpError, "GET", "/", nil

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"net/http"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T)
	success := assert.HTTPSuccess(t, httpOK, "GET", "/", nil)
	fmt.Printf("success: %t\n", success)

}

func httpOK(w http.ResponseWriter, _ *http.Request) {
	w.WriteHeader(http.StatusOK)
}

Output:

success: true

func HTTPSuccessf ¶

func HTTPSuccessf(t T, handler http.HandlerFunc, method string, url string, values url.Values, msg string, args ...any) bool

HTTPSuccessf is the same as HTTPSuccess, but accepts a format msg string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func Implements ¶

func Implements(t T, interfaceObject any, object any, msgAndArgs ...any) bool

Implements asserts that an object is implemented by the specified interface.

Usage ¶

assertions.Implements(t, (*MyInterface)(nil), new(MyObject))

Examples ¶

success: ptr(dummyInterface), new(testing.T)
failure: (*error)(nil), new(testing.T)

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T)
	success := assert.Implements(t, ptr(dummyInterface), new(testing.T))
	fmt.Printf("success: %t\n", success)

}

//nolint:gochecknoglobals // this is on purpose to share a common pointer when testing
var (
	staticVar = "static string"

	dummyInterface assert.T
)

func ptr[T any](value T) *T {
	p := value

	return &p
}

Output:

success: true

func Implementsf ¶

func Implementsf(t T, interfaceObject any, object any, msg string, args ...any) bool

Implementsf is the same as Implements, but accepts a format msg string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func InDelta ¶

func InDelta(t T, expected any, actual any, delta float64, msgAndArgs ...any) bool

InDelta asserts that the two numerals are within delta of each other.

Usage ¶

assertions.InDelta(t, math.Pi, 22/7.0, 0.01)

Examples ¶

success: 1.0, 1.01, 0.02
failure: 1.0, 1.1, 0.05

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T)
	success := assert.InDelta(t, 1.0, 1.01, 0.02)
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func InDeltaMapValues ¶

func InDeltaMapValues(t T, expected any, actual any, delta float64, msgAndArgs ...any) bool

InDeltaMapValues is the same as InDelta, but it compares all values between two maps. Both maps must have exactly the same keys.

Usage ¶

assertions.InDeltaMapValues(t, map[string]float64{"a": 1.0}, map[string]float64{"a": 1.01}, 0.02)

Examples ¶

success: map[string]float64{"a": 1.0}, map[string]float64{"a": 1.01}, 0.02
failure: map[string]float64{"a": 1.0}, map[string]float64{"a": 1.1}, 0.05

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T)
	success := assert.InDeltaMapValues(t, map[string]float64{"a": 1.0}, map[string]float64{"a": 1.01}, 0.02)
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func InDeltaMapValuesf ¶

func InDeltaMapValuesf(t T, expected any, actual any, delta float64, msg string, args ...any) bool

InDeltaMapValuesf is the same as InDeltaMapValues, but accepts a format msg string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func InDeltaSlice ¶

func InDeltaSlice(t T, expected any, actual any, delta float64, msgAndArgs ...any) bool

InDeltaSlice is the same as InDelta, except it compares two slices.

Usage ¶

assertions.InDeltaSlice(t, []float64{1.0, 2.0}, []float64{1.01, 2.01}, 0.02)

Examples ¶

success: []float64{1.0, 2.0}, []float64{1.01, 2.01}, 0.02
failure: []float64{1.0, 2.0}, []float64{1.1, 2.1}, 0.05

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T)
	success := assert.InDeltaSlice(t, []float64{1.0, 2.0}, []float64{1.01, 2.01}, 0.02)
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func InDeltaSlicef ¶

func InDeltaSlicef(t T, expected any, actual any, delta float64, msg string, args ...any) bool

InDeltaSlicef is the same as InDeltaSlice, but accepts a format msg string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func InDeltaf ¶

func InDeltaf(t T, expected any, actual any, delta float64, msg string, args ...any) bool

InDeltaf is the same as InDelta, but accepts a format msg string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func InEpsilon ¶

func InEpsilon(t T, expected any, actual any, epsilon float64, msgAndArgs ...any) bool

InEpsilon asserts that expected and actual have a relative error less than epsilon.

Usage ¶

assertions.InEpsilon(t, 100.0, 101.0, 0.02)

Examples ¶

success: 100.0, 101.0, 0.02
failure: 100.0, 110.0, 0.05

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T)
	success := assert.InEpsilon(t, 100.0, 101.0, 0.02)
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func InEpsilonSlice ¶

func InEpsilonSlice(t T, expected any, actual any, epsilon float64, msgAndArgs ...any) bool

InEpsilonSlice is the same as InEpsilon, except it compares each value from two slices.

Usage ¶

assertions.InEpsilonSlice(t, []float64{100.0, 200.0}, []float64{101.0, 202.0}, 0.02)

Examples ¶

success: []float64{100.0, 200.0}, []float64{101.0, 202.0}, 0.02
failure: []float64{100.0, 200.0}, []float64{110.0, 220.0}, 0.05

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T)
	success := assert.InEpsilonSlice(t, []float64{100.0, 200.0}, []float64{101.0, 202.0}, 0.02)
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func InEpsilonSlicef ¶

func InEpsilonSlicef(t T, expected any, actual any, epsilon float64, msg string, args ...any) bool

InEpsilonSlicef is the same as InEpsilonSlice, but accepts a format msg string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func InEpsilonf ¶

func InEpsilonf(t T, expected any, actual any, epsilon float64, msg string, args ...any) bool

InEpsilonf is the same as InEpsilon, but accepts a format msg string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func IsDecreasing ¶

func IsDecreasing(t T, object any, msgAndArgs ...any) bool

IsDecreasing asserts that the collection is decreasing.

Usage ¶

assertions.IsDecreasing(t, []int{2, 1, 0})
assertions.IsDecreasing(t, []float{2, 1})
assertions.IsDecreasing(t, []string{"b", "a"})

Examples ¶

success: []int{3, 2, 1}
failure: []int{1, 2, 3}

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T)
	success := assert.IsDecreasing(t, []int{3, 2, 1})
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func IsDecreasingf ¶

func IsDecreasingf(t T, object any, msg string, args ...any) bool

IsDecreasingf is the same as IsDecreasing, but accepts a format msg string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func IsIncreasing ¶

func IsIncreasing(t T, object any, msgAndArgs ...any) bool

IsIncreasing asserts that the collection is increasing.

Usage ¶

assertions.IsIncreasing(t, []int{1, 2, 3})
assertions.IsIncreasing(t, []float{1, 2})
assertions.IsIncreasing(t, []string{"a", "b"})

Examples ¶

success: []int{1, 2, 3}
failure: []int{1, 1, 2}

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T)
	success := assert.IsIncreasing(t, []int{1, 2, 3})
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func IsIncreasingf ¶

func IsIncreasingf(t T, object any, msg string, args ...any) bool

IsIncreasingf is the same as IsIncreasing, but accepts a format msg string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func IsNonDecreasing ¶

func IsNonDecreasing(t T, object any, msgAndArgs ...any) bool

IsNonDecreasing asserts that the collection is not decreasing.

Usage ¶

assertions.IsNonDecreasing(t, []int{1, 1, 2})
assertions.IsNonDecreasing(t, []float{1, 2})
assertions.IsNonDecreasing(t, []string{"a", "b"})

Examples ¶

success: []int{1, 1, 2}
failure: []int{2, 1, 1}

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T)
	success := assert.IsNonDecreasing(t, []int{1, 1, 2})
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func IsNonDecreasingf ¶

func IsNonDecreasingf(t T, object any, msg string, args ...any) bool

IsNonDecreasingf is the same as IsNonDecreasing, but accepts a format msg string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func IsNonIncreasing ¶

func IsNonIncreasing(t T, object any, msgAndArgs ...any) bool

IsNonIncreasing asserts that the collection is not increasing.

Usage ¶

assertions.IsNonIncreasing(t, []int{2, 1, 1})
assertions.IsNonIncreasing(t, []float{2, 1})
assertions.IsNonIncreasing(t, []string{"b", "a"})

Examples ¶

success: []int{2, 1, 1}
failure: []int{1, 2, 3}

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T)
	success := assert.IsNonIncreasing(t, []int{2, 1, 1})
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func IsNonIncreasingf ¶

func IsNonIncreasingf(t T, object any, msg string, args ...any) bool

IsNonIncreasingf is the same as IsNonIncreasing, but accepts a format msg string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func IsNotType ¶

func IsNotType(t T, theType any, object any, msgAndArgs ...any) bool

IsNotType asserts that the specified objects are not of the same type.

Usage ¶

assertions.IsNotType(t, &NotMyStruct{}, &MyStruct{})

Examples ¶

success: int32(123), int64(456)
failure: 123, 456

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T)
	success := assert.IsNotType(t, int32(123), int64(456))
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func IsNotTypef ¶

func IsNotTypef(t T, theType any, object any, msg string, args ...any) bool

IsNotTypef is the same as IsNotType, but accepts a format msg string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func IsType ¶

func IsType(t T, expectedType any, object any, msgAndArgs ...any) bool

IsType asserts that the specified objects are of the same type.

Usage ¶

assertions.IsType(t, &MyStruct{}, &MyStruct{})

Examples ¶

success: 123, 456
failure: int32(123), int64(456)

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T)
	success := assert.IsType(t, 123, 456)
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func IsTypef ¶

func IsTypef(t T, expectedType any, object any, msg string, args ...any) bool

IsTypef is the same as IsType, but accepts a format msg string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func JSONEq ¶

func JSONEq(t T, expected string, actual string, msgAndArgs ...any) bool

JSONEq asserts that two JSON strings are equivalent.

Usage ¶

assertions.JSONEq(t, `{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`)

Examples ¶

success: `{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`
failure: `{"hello": "world", "foo": "bar"}`, `[{"foo": "bar"}, {"hello": "world"}]`

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T)
	success := assert.JSONEq(t, `{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`)
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func JSONEqBytes ¶ added in v2.0.2

func JSONEqBytes(t T, expected []byte, actual []byte, msgAndArgs ...any) bool

JSONEqBytes asserts that two JSON byte slices are equivalent.

Usage ¶

assertions.JSONEqBytes(t, []byte(`{"hello": "world", "foo": "bar"}`), []byte(`{"foo": "bar", "hello": "world"}`))

Examples ¶

success: []byte(`{"hello": "world", "foo": "bar"}`), []byte(`{"foo": "bar", "hello": "world"}`)
failure: []byte(`{"hello": "world", "foo": "bar"}`), []byte(`[{"foo": "bar"}, {"hello": "world"}]`)

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T)
	success := assert.JSONEqBytes(t, []byte(`{"hello": "world", "foo": "bar"}`), []byte(`{"foo": "bar", "hello": "world"}`))
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func JSONEqBytesf ¶ added in v2.0.2

func JSONEqBytesf(t T, expected []byte, actual []byte, msg string, args ...any) bool

JSONEqBytesf is the same as JSONEqBytes, but accepts a format msg string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func JSONEqf ¶

func JSONEqf(t T, expected string, actual string, msg string, args ...any) bool

JSONEqf is the same as JSONEq, but accepts a format msg string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func Len ¶

func Len(t T, object any, length int, msgAndArgs ...any) bool

Len asserts that the specified object has specific length.

Len also fails if the object has a type that len() does not accept.

The asserted object can be a string, a slice, a map, an array or a channel.

See also reflect.Len.

Usage ¶

assertions.Len(t, mySlice, 3)
assertions.Len(t, myString, 4)
assertions.Len(t, myMap, 5)

Examples ¶

success: []string{"A","B"}, 2
failure: []string{"A","B"}, 1

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T)
	success := assert.Len(t, []string{"A", "B"}, 2)
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func Lenf ¶

func Lenf(t T, object any, length int, msg string, args ...any) bool

Lenf is the same as Len, but accepts a format msg string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func Less ¶

func Less(t T, e1 any, e2 any, msgAndArgs ...any) bool

Less asserts that the first element is strictly less than the second.

Usage ¶

assertions.Less(t, 1, 2)
assertions.Less(t, float64(1), float64(2))
assertions.Less(t, "a", "b")

Examples ¶

success: 1, 2
failure: 2, 1

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T)
	success := assert.Less(t, 1, 2)
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func LessOrEqual ¶

func LessOrEqual(t T, e1 any, e2 any, msgAndArgs ...any) bool

LessOrEqual asserts that the first element is less than or equal to the second.

Usage ¶

assertions.LessOrEqual(t, 1, 2)
assertions.LessOrEqual(t, 2, 2)
assertions.LessOrEqual(t, "a", "b")
assertions.LessOrEqual(t, "b", "b")

Examples ¶

success: 1, 2
failure: 2, 1

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T)
	success := assert.LessOrEqual(t, 1, 2)
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func LessOrEqualf ¶

func LessOrEqualf(t T, e1 any, e2 any, msg string, args ...any) bool

LessOrEqualf is the same as LessOrEqual, but accepts a format msg string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func Lessf ¶

func Lessf(t T, e1 any, e2 any, msg string, args ...any) bool

Lessf is the same as Less, but accepts a format msg string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func Negative ¶

func Negative(t T, e any, msgAndArgs ...any) bool

Negative asserts that the specified element is strictly negative.

Usage ¶

assertions.Negative(t, -1)
assertions.Negative(t, -1.23)

Examples ¶

success: -1
failure: 1

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T)
	success := assert.Negative(t, -1)
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func Negativef ¶

func Negativef(t T, e any, msg string, args ...any) bool

Negativef is the same as Negative, but accepts a format msg string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func Never ¶

func Never(t T, condition func() bool, waitFor time.Duration, tick time.Duration, msgAndArgs ...any) bool

Never asserts that the given condition doesn't satisfy in waitFor time, periodically checking the target function each tick.

Usage ¶

assertions.Never(t, func() bool { return false; }, time.Second, 10*time.Millisecond)

Examples ¶

success:  func() bool { return false }, 100*time.Millisecond, 20*time.Millisecond
failure:  func() bool { return true }, 100*time.Millisecond, 20*time.Millisecond

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"
	"time"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T)
	success := assert.Never(t, func() bool {
		return false
	}, 100*time.Millisecond, 20*time.Millisecond)
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func Neverf ¶

func Neverf(t T, condition func() bool, waitFor time.Duration, tick time.Duration, msg string, args ...any) bool

Neverf is the same as Never, but accepts a format msg string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func Nil ¶

func Nil(t T, object any, msgAndArgs ...any) bool

Nil asserts that the specified object is nil.

Usage ¶

assertions.Nil(t, err)

Examples ¶

success: nil
failure: "not nil"

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T)
	success := assert.Nil(t, nil)
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func Nilf ¶

func Nilf(t T, object any, msg string, args ...any) bool

Nilf is the same as Nil, but accepts a format msg string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func NoDirExists ¶

func NoDirExists(t T, path string, msgAndArgs ...any) bool

NoDirExists checks whether a directory does not exist in the given path. It fails if the path points to an existing _directory_ only.

Usage ¶

assertions.NoDirExists(t, "path/to/directory")

Examples ¶

success: filepath.Join(testDataPath(),"non_existing_dir")
failure: filepath.Join(testDataPath(),"existing_dir")

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"path/filepath"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T)
	success := assert.NoDirExists(t, filepath.Join(testDataPath(), "non_existing_dir"))
	fmt.Printf("success: %t\n", success)

}

func testDataPath() string {
	return filepath.Join("..", "internal", "assertions", "testdata")
}

Output:

success: true

func NoDirExistsf ¶

func NoDirExistsf(t T, path string, msg string, args ...any) bool

NoDirExistsf is the same as NoDirExists, but accepts a format msg string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func NoError ¶

func NoError(t T, err error, msgAndArgs ...any) bool

NoError asserts that a function returned a nil error (ie. no error).

Usage ¶

actualObj, err := SomeFunction()
if assert.NoError(t, err) {
	assertions.Equal(t, expectedObj, actualObj)
}

Examples ¶

success: nil
failure: ErrTest

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T)
	success := assert.NoError(t, nil)
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func NoErrorf ¶

func NoErrorf(t T, err error, msg string, args ...any) bool

NoErrorf is the same as NoError, but accepts a format msg string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func NoFileExists ¶

func NoFileExists(t T, path string, msgAndArgs ...any) bool

NoFileExists checks whether a file does not exist in a given path. It fails if the path points to an existing _file_ only.

Usage ¶

assertions.NoFileExists(t, "path/to/file")

Examples ¶

success: filepath.Join(testDataPath(),"non_existing_file")
failure: filepath.Join(testDataPath(),"existing_file")

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"path/filepath"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T)
	success := assert.NoFileExists(t, filepath.Join(testDataPath(), "non_existing_file"))
	fmt.Printf("success: %t\n", success)

}

func testDataPath() string {
	return filepath.Join("..", "internal", "assertions", "testdata")
}

Output:

success: true

func NoFileExistsf ¶

func NoFileExistsf(t T, path string, msg string, args ...any) bool

NoFileExistsf is the same as NoFileExists, but accepts a format msg string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func NotContains ¶

func NotContains(t T, s any, contains any, msgAndArgs ...any) bool

NotContains asserts that the specified string, list(array, slice...) or map does NOT contain the specified substring or element.

Usage ¶

assertions.NotContains(t, "Hello World", "Earth")
assertions.NotContains(t, ["Hello", "World"], "Earth")
assertions.NotContains(t, {"Hello": "World"}, "Earth")

Examples ¶

success: []string{"A","B"}, "C"
failure: []string{"A","B"}, "B"

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T)
	success := assert.NotContains(t, []string{"A", "B"}, "C")
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func NotContainsf ¶

func NotContainsf(t T, s any, contains any, msg string, args ...any) bool

NotContainsf is the same as NotContains, but accepts a format msg string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func NotElementsMatch ¶

func NotElementsMatch(t T, listA any, listB any, msgAndArgs ...any) (ok bool)

NotElementsMatch asserts that the specified listA(array, slice...) is NOT 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 not match. This is an inverse of ElementsMatch.

Usage ¶

assertions.NotElementsMatch(t, [1, 1, 2, 3], [1, 1, 2, 3]) -> false
assertions.NotElementsMatch(t, [1, 1, 2, 3], [1, 2, 3]) -> true
assertions.NotElementsMatch(t, [1, 2, 3], [1, 2, 4]) -> true

Examples ¶

success: []int{1, 2, 3}, []int{1, 2, 4}
failure: []int{1, 3, 2, 3}, []int{1, 3, 3, 2}

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T)
	success := assert.NotElementsMatch(t, []int{1, 2, 3}, []int{1, 2, 4})
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func NotElementsMatchf ¶

func NotElementsMatchf(t T, listA any, listB any, msg string, args ...any) (ok bool)

NotElementsMatchf is the same as NotElementsMatch, but accepts a format msg string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func NotEmpty ¶

func NotEmpty(t T, object any, msgAndArgs ...any) bool

NotEmpty asserts that the specified object is NOT Empty.

Usage ¶

if assert.NotEmpty(t, obj) {
	assertions.Equal(t, "two", obj[1])
}

Examples ¶

success: "not empty"
failure: ""

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T)
	success := assert.NotEmpty(t, "not empty")
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func NotEmptyf ¶

func NotEmptyf(t T, object any, msg string, args ...any) bool

NotEmptyf is the same as NotEmpty, but accepts a format msg string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func NotEqual ¶

func NotEqual(t T, expected any, actual any, msgAndArgs ...any) bool

NotEqual asserts that the specified values are NOT equal.

Usage ¶

assertions.NotEqual(t, obj1, obj2)

Pointer variable equality is determined based on the equality of the referenced values (as opposed to the memory addresses).

Examples ¶

success: 123, 456
failure: 123, 123

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T)
	success := assert.NotEqual(t, 123, 456)
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func NotEqualValues ¶

func NotEqualValues(t T, expected any, actual any, msgAndArgs ...any) bool

NotEqualValues asserts that two objects are not equal even when converted to the same type.

Usage ¶

assertions.NotEqualValues(t, obj1, obj2)

Examples ¶

success: uint32(123), int32(456)
failure: uint32(123), int32(123)

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T)
	success := assert.NotEqualValues(t, uint32(123), int32(456))
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func NotEqualValuesf ¶

func NotEqualValuesf(t T, expected any, actual any, msg string, args ...any) bool

NotEqualValuesf is the same as NotEqualValues, but accepts a format msg string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func NotEqualf ¶

func NotEqualf(t T, expected any, actual any, msg string, args ...any) bool

NotEqualf is the same as NotEqual, but accepts a format msg string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func NotErrorAs ¶

func NotErrorAs(t T, err error, target any, msgAndArgs ...any) bool

NotErrorAs asserts that none of the errors in err's chain matches target, but if so, sets target to that error value.

Usage ¶

assertions.NotErrorAs(t, err, &target)

Examples ¶

success: ErrTest, new(*dummyError)
failure: fmt.Errorf("wrap: %w", &dummyError{}), new(*dummyError)

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T)
	success := assert.NotErrorAs(t, assert.ErrTest, new(*dummyError))
	fmt.Printf("success: %t\n", success)

}

type dummyError struct {
}

func (d *dummyError) Error() string {
	return "dummy error"
}

Output:

success: true

func NotErrorAsf ¶

func NotErrorAsf(t T, err error, target any, msg string, args ...any) bool

NotErrorAsf is the same as NotErrorAs, but accepts a format msg string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func NotErrorIs ¶

func NotErrorIs(t T, err error, target error, msgAndArgs ...any) bool

NotErrorIs asserts that none of the errors in err's chain matches target.

This is a wrapper for errors.Is.

Usage ¶

assertions.NotErrorIs(t, err, io.EOF)

Examples ¶

success: ErrTest, io.EOF
failure: fmt.Errorf("wrap: %w", io.EOF), io.EOF

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"io"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T)
	success := assert.NotErrorIs(t, assert.ErrTest, io.EOF)
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func NotErrorIsf ¶

func NotErrorIsf(t T, err error, target error, msg string, args ...any) bool

NotErrorIsf is the same as NotErrorIs, but accepts a format msg string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func NotImplements ¶

func NotImplements(t T, interfaceObject any, object any, msgAndArgs ...any) bool

NotImplements asserts that an object does not implement the specified interface.

Usage ¶

assertions.NotImplements(t, (*MyInterface)(nil), new(MyObject))

Examples ¶

success: (*error)(nil), new(testing.T)
failure: ptr(dummyInterface), new(testing.T)

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T)
	success := assert.NotImplements(t, (*error)(nil), new(testing.T))
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func NotImplementsf ¶

func NotImplementsf(t T, interfaceObject any, object any, msg string, args ...any) bool

NotImplementsf is the same as NotImplements, but accepts a format msg string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func NotNil ¶

func NotNil(t T, object any, msgAndArgs ...any) bool

NotNil asserts that the specified object is not nil.

Usage ¶

assertions.NotNil(t, err)

Examples ¶

success: "not nil"
failure: nil

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T)
	success := assert.NotNil(t, "not nil")
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func NotNilf ¶

func NotNilf(t T, object any, msg string, args ...any) bool

NotNilf is the same as NotNil, but accepts a format msg string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func NotPanics ¶

func NotPanics(t T, f assertions.PanicTestFunc, msgAndArgs ...any) bool

NotPanics asserts that the code inside the specified PanicTestFunc does NOT panic.

Usage ¶

assertions.NotPanics(t, func(){ RemainCalm() })

Examples ¶

success: func() { }
failure: func() { panic("panicking") }

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T)
	success := assert.NotPanics(t, func() {
	})
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func NotPanicsf ¶

func NotPanicsf(t T, f assertions.PanicTestFunc, msg string, args ...any) bool

NotPanicsf is the same as NotPanics, but accepts a format msg string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func NotRegexp ¶

func NotRegexp(t T, rx any, str any, msgAndArgs ...any) bool

NotRegexp asserts that a specified regexp does not match a string.

Usage ¶

assertions.NotRegexp(t, regexp.MustCompile("starts"), "it's starting")
assertions.NotRegexp(t, "^start", "it's not starting")

Examples ¶

success: "^start", "not starting"
failure: "^start", "starting"

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T)
	success := assert.NotRegexp(t, "^start", "not starting")
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func NotRegexpf ¶

func NotRegexpf(t T, rx any, str any, msg string, args ...any) bool

NotRegexpf is the same as NotRegexp, but accepts a format msg string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func NotSame ¶

func NotSame(t T, expected any, actual any, msgAndArgs ...any) bool

NotSame asserts that two pointers do not reference the same object.

Both arguments must be pointer variables. Pointer variable sameness is determined based on the equality of both type and value.

Usage ¶

assertions.NotSame(t, ptr1, ptr2)

Examples ¶

success: &staticVar, ptr("static string")
failure: &staticVar, staticVarPtr

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T)
	success := assert.NotSame(t, &staticVar, ptr("static string"))
	fmt.Printf("success: %t\n", success)

}

//nolint:gochecknoglobals // this is on purpose to share a common pointer when testing
var staticVar = "static string"

func ptr[T any](value T) *T {
	p := value

	return &p
}

Output:

success: true

func NotSamef ¶

func NotSamef(t T, expected any, actual any, msg string, args ...any) bool

NotSamef is the same as NotSame, but accepts a format msg string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func NotSubset ¶

func NotSubset(t T, list any, subset any, msgAndArgs ...any) (ok bool)

NotSubset asserts that the list (array, slice, or map) does NOT contain all elements given in the subset (array, slice, or map). Map elements are key-value pairs unless compared with an array or slice where only the map key is evaluated.

Usage ¶

assertions.NotSubset(t, [1, 3, 4], [1, 2])
assertions.NotSubset(t, {"x": 1, "y": 2}, {"z": 3})
assertions.NotSubset(t, [1, 3, 4], {1: "one", 2: "two"})
assertions.NotSubset(t, {"x": 1, "y": 2}, ["z"])

Examples ¶

success: []int{1, 2, 3}, []int{4, 5}
failure: []int{1, 2, 3}, []int{1, 2}

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T)
	success := assert.NotSubset(t, []int{1, 2, 3}, []int{4, 5})
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func NotSubsetf ¶

func NotSubsetf(t T, list any, subset any, msg string, args ...any) (ok bool)

NotSubsetf is the same as NotSubset, but accepts a format msg string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func NotZero ¶

func NotZero(t T, i any, msgAndArgs ...any) bool

NotZero asserts that i is not the zero value for its type.

Usage ¶

assertions.NotZero(t, obj)

Examples ¶

success: 1
failure: 0

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T)
	success := assert.NotZero(t, 1)
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func NotZerof ¶

func NotZerof(t T, i any, msg string, args ...any) bool

NotZerof is the same as NotZero, but accepts a format msg string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func ObjectsAreEqual ¶

func ObjectsAreEqual(expected any, actual any) bool

ObjectsAreEqual determines if two objects are considered equal.

This function does no assertion of any kind.

func ObjectsAreEqualValues ¶

func ObjectsAreEqualValues(expected any, actual any) bool

ObjectsAreEqualValues gets whether two objects are equal, or if their values are equal.

func Panics ¶

func Panics(t T, f assertions.PanicTestFunc, msgAndArgs ...any) bool

Panics asserts that the code inside the specified PanicTestFunc panics.

Usage ¶

assertions.Panics(t, func(){ GoCrazy() })

Examples ¶

success: func() { panic("panicking") }
failure: func() { }

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T)
	success := assert.Panics(t, func() {
		panic("panicking")
	})
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func PanicsWithError ¶

func PanicsWithError(t T, errString string, f assertions.PanicTestFunc, msgAndArgs ...any) bool

PanicsWithError asserts that the code inside the specified PanicTestFunc panics, and that the recovered panic value is an error that satisfies the EqualError comparison.

Usage ¶

assertions.PanicsWithError(t, "crazy error", func(){ GoCrazy() })

Examples ¶

success: ErrTest.Error(), func() { panic(ErrTest) }
failure: ErrTest.Error(), func() { }

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T)
	success := assert.PanicsWithError(t, assert.ErrTest.Error(), func() {
		panic(assert.ErrTest)
	})
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func PanicsWithErrorf ¶

func PanicsWithErrorf(t T, errString string, f assertions.PanicTestFunc, msg string, args ...any) bool

PanicsWithErrorf is the same as PanicsWithError, but accepts a format msg string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func PanicsWithValue ¶

func PanicsWithValue(t T, expected any, f assertions.PanicTestFunc, msgAndArgs ...any) bool

PanicsWithValue asserts that the code inside the specified PanicTestFunc panics, and that the recovered panic value equals the expected panic value.

Usage ¶

assertions.PanicsWithValue(t, "crazy error", func(){ GoCrazy() })

Examples ¶

success: "panicking", func() { panic("panicking") }
failure: "panicking", func() { }

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T)
	success := assert.PanicsWithValue(t, "panicking", func() {
		panic("panicking")
	})
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func PanicsWithValuef ¶

func PanicsWithValuef(t T, expected any, f assertions.PanicTestFunc, msg string, args ...any) bool

PanicsWithValuef is the same as PanicsWithValue, but accepts a format msg string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func Panicsf ¶

func Panicsf(t T, f assertions.PanicTestFunc, msg string, args ...any) bool

Panicsf is the same as Panics, but accepts a format msg string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func Positive ¶

func Positive(t T, e any, msgAndArgs ...any) bool

Positive asserts that the specified element is strictly positive.

Usage ¶

assertions.Positive(t, 1)
assertions.Positive(t, 1.23)

Examples ¶

success: 1
failure: -1

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T)
	success := assert.Positive(t, 1)
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func Positivef ¶

func Positivef(t T, e any, msg string, args ...any) bool

Positivef is the same as Positive, but accepts a format msg string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func Regexp ¶

func Regexp(t T, rx any, str any, msgAndArgs ...any) bool

Regexp asserts that a specified regexp matches a string.

Usage ¶

assertions.Regexp(t, regexp.MustCompile("start"), "it's starting")
assertions.Regexp(t, "start...$", "it's not starting")

Examples ¶

success: "^start", "starting"
failure: "^start", "not starting"

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T)
	success := assert.Regexp(t, "^start", "starting")
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func Regexpf ¶

func Regexpf(t T, rx any, str any, msg string, args ...any) bool

Regexpf is the same as Regexp, but accepts a format msg string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func Same ¶

func Same(t T, expected any, actual any, msgAndArgs ...any) bool

Same asserts that two pointers reference the same object.

Both arguments must be pointer variables. Pointer variable sameness is determined based on the equality of both type and value.

Usage ¶

assertions.Same(t, ptr1, ptr2)

Examples ¶

success: &staticVar, staticVarPtr
failure: &staticVar, ptr("static string")

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T)
	success := assert.Same(t, &staticVar, staticVarPtr)
	fmt.Printf("success: %t\n", success)

}

//nolint:gochecknoglobals // this is on purpose to share a common pointer when testing
var (
	staticVar    = "static string"
	staticVarPtr = &staticVar
)

Output:

success: true

func Samef ¶

func Samef(t T, expected any, actual any, msg string, args ...any) bool

Samef is the same as Same, but accepts a format msg string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func Subset ¶

func Subset(t T, list any, subset any, msgAndArgs ...any) (ok bool)

Subset asserts that the list (array, slice, or map) contains all elements given in the subset (array, slice, or map).

Map elements are key-value pairs unless compared with an array or slice where only the map key is evaluated.

Usage ¶

assertions.Subset(t, [1, 2, 3], [1, 2])
assertions.Subset(t, {"x": 1, "y": 2}, {"x": 1})
assertions.Subset(t, [1, 2, 3], {1: "one", 2: "two"})
assertions.Subset(t, {"x": 1, "y": 2}, ["x"])

Examples ¶

success: []int{1, 2, 3}, []int{1, 2}
failure: []int{1, 2, 3}, []int{4, 5}

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T)
	success := assert.Subset(t, []int{1, 2, 3}, []int{1, 2})
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func Subsetf ¶

func Subsetf(t T, list any, subset any, msg string, args ...any) (ok bool)

Subsetf is the same as Subset, but accepts a format msg string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func True ¶

func True(t T, value bool, msgAndArgs ...any) bool

True asserts that the specified value is true.

Usage ¶

assertions.True(t, myBool)

Examples ¶

success: 1 == 1
failure: 1 == 0

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T)
	success := assert.True(t, 1 == 1)
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func Truef ¶

func Truef(t T, value bool, msg string, args ...any) bool

Truef is the same as True, but accepts a format msg string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func WithinDuration ¶

func WithinDuration(t T, expected time.Time, actual time.Time, delta time.Duration, msgAndArgs ...any) bool

WithinDuration asserts that the two times are within duration delta of each other.

Usage ¶

assertions.WithinDuration(t, time.Now(), 10*time.Second)

Examples ¶

success: time.Date(2024, 1, 1, 12, 0, 0, 0, time.UTC), time.Date(2024, 1, 1, 12, 0, 1, 0, time.UTC), 2*time.Second
failure: time.Date(2024, 1, 1, 12, 0, 0, 0, time.UTC), time.Date(2024, 1, 1, 12, 0, 10, 0, time.UTC), 1*time.Second

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"
	"time"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T)
	success := assert.WithinDuration(t, time.Date(2024, 1, 1, 12, 0, 0, 0, time.UTC), time.Date(2024, 1, 1, 12, 0, 1, 0, time.UTC), 2*time.Second)
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func WithinDurationf ¶

func WithinDurationf(t T, expected time.Time, actual time.Time, delta time.Duration, msg string, args ...any) bool

WithinDurationf is the same as WithinDuration, but accepts a format msg string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func WithinRange ¶

func WithinRange(t T, actual time.Time, start time.Time, end time.Time, msgAndArgs ...any) bool

WithinRange asserts that a time is within a time range (inclusive).

Usage ¶

assertions.WithinRange(t, time.Now(), time.Now().Add(-time.Second), time.Now().Add(time.Second))

Examples ¶

success: time.Date(2024, 1, 1, 12, 0, 0, 0, time.UTC), time.Date(2024, 1, 1, 11, 0, 0, 0, time.UTC), time.Date(2024, 1, 1, 13, 0, 0, 0, time.UTC)
failure: time.Date(2024, 1, 1, 14, 0, 0, 0, time.UTC), time.Date(2024, 1, 1, 11, 0, 0, 0, time.UTC), time.Date(2024, 1, 1, 13, 0, 0, 0, time.UTC)

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"
	"time"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T)
	success := assert.WithinRange(t, time.Date(2024, 1, 1, 12, 0, 0, 0, time.UTC), time.Date(2024, 1, 1, 11, 0, 0, 0, time.UTC), time.Date(2024, 1, 1, 13, 0, 0, 0, time.UTC))
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func WithinRangef ¶

func WithinRangef(t T, actual time.Time, start time.Time, end time.Time, msg string, args ...any) bool

WithinRangef is the same as WithinRange, but accepts a format msg string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func YAMLEq ¶

func YAMLEq(t T, expected string, actual string, msgAndArgs ...any) bool

YAMLEq asserts that the first documents in the two YAML strings are equivalent.

Usage ¶

expected := `---
key: value
---
key: this is a second document, it is not evaluated
`
actual := `---
key: value
---
key: this is a subsequent document, it is not evaluated
`
assertions.YAMLEq(t, expected, actual)

Examples ¶

panic: "key: value", "key: value"
should panic without the yaml feature enabled.

Upon failure, the test T is marked as failed and continues execution.

func YAMLEqf ¶

func YAMLEqf(t T, expected string, actual string, msg string, args ...any) bool

YAMLEqf is the same as YAMLEq, but accepts a format msg string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func Zero ¶

func Zero(t T, i any, msgAndArgs ...any) bool

Zero asserts that i is the zero value for its type.

Usage ¶

assertions.Zero(t, obj)

Examples ¶

success: 0
failure: 1

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T)
	success := assert.Zero(t, 0)
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func Zerof ¶

func Zerof(t T, i any, msg string, args ...any) bool

Zerof is the same as Zero, but accepts a format msg string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.