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 it 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 it 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 it accepts a format msg string to format arguments like fmt.Printf.

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

func DirNotExists ¶ added in v2.2.0

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

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

Usage ¶

assertions.DirNotExists(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.DirNotExists(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 DirNotExistsf ¶ added in v2.2.0

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

DirNotExistsf is the same as DirNotExists, but it 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, []int{1, 3, 2, 3}, []int{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 ElementsMatchT ¶ added in v2.2.0

func ElementsMatchT[E comparable](t T, listA []E, listB []E, msgAndArgs ...any) bool

ElementsMatchT 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.ElementsMatchT(t, []int{1, 3, 2, 3}, []int{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.ElementsMatchT(t, []int{1, 3, 2, 3}, []int{1, 3, 3, 2})
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func ElementsMatchTf ¶ added in v2.2.0

func ElementsMatchTf[E comparable](t T, listA []E, listB []E, msg string, args ...any) bool

ElementsMatchTf is the same as ElementsMatchT, but it accepts a format msg string to format arguments like fmt.Printf.

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

func ElementsMatchf ¶

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

ElementsMatchf is the same as ElementsMatch, but it 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 it 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, err 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, err error, errString string, msg string, args ...any) bool

EqualErrorf is the same as EqualError, but it 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.

Function equality cannot be determined and will always fail.

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 it accepts a format msg string to format arguments like fmt.Printf.

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

func EqualT ¶ added in v2.2.0

func EqualT[V comparable](t T, expected V, actual V, msgAndArgs ...any) bool

EqualT asserts that two objects of the same comparable type are equal.

Pointer variable equality is determined based on the equality of the memory addresses (unlike Equal, but like Same).

Functions, slices and maps are not comparable. See also ComparisonOperators.

If you need to compare values of non-comparable types, or compare pointers by the value they point to, use Equal instead.

Usage ¶

assertions.EqualT(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.EqualT(t, 123, 123)
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func EqualTf ¶ added in v2.2.0

func EqualTf[V comparable](t T, expected V, actual V, msg string, args ...any) bool

EqualTf is the same as EqualT, but it 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.

Function equality cannot be determined and will always fail.

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 it 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 it 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 it 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, err 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, err error, contains string, msg string, args ...any) bool

ErrorContainsf is the same as ErrorContains, but it 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 it 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 it 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 the given condition will be met in waitFor time, periodically checking the target function on each tick.

Eventually waits until the condition returns true, for at most waitFor, or until the parent context of the test is cancelled.

If the condition takes longer than waitFor to complete, Eventually fails but waits for the current condition execution to finish before returning.

For long-running conditions to be interrupted early, check testing.T.Context which is cancelled on test failure.

Usage ¶

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

Concurrency ¶

The condition function is never executed in parallel: only one goroutine executes it. It may write to variables outside its scope without triggering race conditions.

A blocking condition will cause Eventually to hang until it returns.

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 the given condition will be met in waitFor time, periodically checking the target function at each tick.

In contrast to Eventually, the condition function is supplied with a CollectT to accumulate errors from calling 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 the condition is not met before waitFor, the collected errors from the last tick are copied to t.

Calling [CollectT.FailNow] cancels the condition immediately and fails the assertion.

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")

Concurrency ¶

The condition function is never executed in parallel: only one goroutine executes it. It may write to variables outside its scope without triggering race conditions.

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 it 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 it 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 it 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 it 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 it 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 FalseT ¶ added in v2.2.0

func FalseT[B Boolean](t T, value B, msgAndArgs ...any) bool

FalseT asserts that the specified value is false.

Usage ¶

 type B bool
 var b B = true

	assertions.FalseT(t, b)

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.FalseT(t, 1 == 0)
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func FalseTf ¶ added in v2.2.0

func FalseTf[B Boolean](t T, value B, msg string, args ...any) bool

FalseTf is the same as FalseT, but it accepts a format msg string to format arguments like fmt.Printf.

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

func Falsef ¶

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

Falsef is the same as False, but it 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 it 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 it 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 it accepts a format msg string to format arguments like fmt.Printf.

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

func FileNotExists ¶ added in v2.2.0

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

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

Usage ¶

assertions.FileNotExists(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.FileNotExists(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 FileNotExistsf ¶ added in v2.2.0

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

FileNotExistsf is the same as FileNotExists, but it 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.

Both elements must be of the same type in the reflect.Kind sense. To compare values that need a type conversion (e.g. float32 against float64), you need to convert types beforehand.

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.

See also Greater.

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 GreaterOrEqualT ¶ added in v2.2.0

func GreaterOrEqualT[Orderable Ordered](t T, e1 Orderable, e2 Orderable, msgAndArgs ...any) bool

GreaterOrEqualT asserts that for two elements of the same type, the first element is greater than or equal to the second.

The Ordered type can be any of Go's cmp.Ordered (strings, numeric types), []byte (uses bytes.Compare) and time.Time (uses time.Time.Compare.

Notice that pointers are not Ordered, but uintptr are. So you can't call GreaterOrEqualT with *time.Time.

GreaterOrEqualT ensures type safety at build time. If you need to compare values with a dynamically assigned type, use GreaterOrEqual instead.

To compare values that need a type conversion (e.g. float32 against float64), you need to convert types beforehand.

Usage ¶

assertions.GreaterOrEqualT(t, 2, 1)
assertions.GreaterOrEqualT(t, 2, 2)
assertions.GreaterOrEqualT(t, "b", "a")
assertions.GreaterOrEqualT(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.GreaterOrEqualT(t, 2, 1)
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func GreaterOrEqualTf ¶ added in v2.2.0

func GreaterOrEqualTf[Orderable Ordered](t T, e1 Orderable, e2 Orderable, msg string, args ...any) bool

GreaterOrEqualTf is the same as GreaterOrEqualT, but it accepts a format msg string to format arguments like fmt.Printf.

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

func GreaterOrEqualf ¶

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

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

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

func GreaterT ¶ added in v2.2.0

func GreaterT[Orderable Ordered](t T, e1 Orderable, e2 Orderable, msgAndArgs ...any) bool

GreaterT asserts that for two elements of the same type, the first element is strictly greater than the second.

The Ordered type can be any of Go's cmp.Ordered (strings, numeric types), []byte (uses bytes.Compare) and time.Time (uses time.Time.Compare.

Notice that pointers are not Ordered, but uintptr are. So you can't call GreaterT with *time.Time.

GreaterT ensures type safety at build time. If you need to compare values with a dynamically assigned type, use Greater instead.

To compare values that need a type conversion (e.g. float32 against float64), you need to convert types beforehand.

Usage ¶

assertions.GreaterT(t, 2, 1)
assertions.GreaterT(t, float64(2), float64(1))
assertions.GreaterT(t, "b", "a")
assertions.GreaterT(t, time.Date(2026,1,1,0,0,0,0,nil), time.Now())

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.GreaterT(t, 2, 1)
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func GreaterTf ¶ added in v2.2.0

func GreaterTf[Orderable Ordered](t T, e1 Orderable, e2 Orderable, msg string, args ...any) bool

GreaterTf is the same as GreaterT, but it 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 it 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 it 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 it 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 it 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 it 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 it 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 it 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 it 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.

Delta must be greater than or equal to zero.

Expected and actual values should convert to float64. To compare large integers that can't be represented accurately as float64 (eg. uint64), prefer InDeltaT to preserve the original type.

Behavior with IEEE floating point arithmetics ¶

• expected NaN is matched only by a NaN, e.g. this works: InDeltaT(math.NaN(), math.Sqrt(-1), 0.0)
• expected +Inf is matched only by a +Inf
• expected -Inf is matched only by a -Inf

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.

See InDelta.

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

See InDelta.

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 it accepts a format msg string to format arguments like fmt.Printf.

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

func InDeltaT ¶ added in v2.2.0

func InDeltaT[Number Measurable](t T, expected Number, actual Number, delta Number, msgAndArgs ...any) bool

InDeltaT asserts that the two numerals of the same type numerical type are within delta of each other.

InDeltaT accepts any go numeric type, including integer types.

The main difference with InDelta is that the delta is expressed with the same type as the values, not necessarily a float64.

Delta must be greater than or equal to zero.

Behavior with IEEE floating point arithmetics ¶

• expected NaN is matched only by a NaN, e.g. this works: InDeltaT(math.NaN(), math.Sqrt(-1), 0.0)
• expected +Inf is matched only by a +Inf
• expected -Inf is matched only by a -Inf

Usage ¶

assertions.InDeltaT(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.InDeltaT(t, 1.0, 1.01, 0.02)
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func InDeltaTf ¶ added in v2.2.0

func InDeltaTf[Number Measurable](t T, expected Number, actual Number, delta Number, msg string, args ...any) bool

InDeltaTf is the same as InDeltaT, but it 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 it 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.

Behavior with IEEE floating point arithmetics ¶

• expected NaN is matched only by a NaN, e.g. this works: InDeltaT(math.NaN(), math.Sqrt(-1), 0.0)
• expected +Inf is matched only by a +Inf
• expected -Inf is matched only by a -Inf

Edge case: for very large integers that do not convert accurately to a float64 (e.g. uint64), prefer InDeltaT.

Formula:

• If expected == 0: fail if |actual - expected| > epsilon
• If expected != 0: fail if |actual - expected| > epsilon * |expected|

This allows InEpsilonT to work naturally across the full numeric range including zero.

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.

See InEpsilon.

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 it accepts a format msg string to format arguments like fmt.Printf.

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

func InEpsilonT ¶ added in v2.2.0

func InEpsilonT[Number Measurable](t T, expected Number, actual Number, epsilon float64, msgAndArgs ...any) bool

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

When expected is zero, epsilon is interpreted as an absolute error threshold, since relative error is mathematically undefined for zero values.

Unlike InDeltaT, which preserves the original type, InEpsilonT converts the expected and actual numbers to float64, since the relative error doesn't make sense as an integer.

Behavior with IEEE floating point arithmetics ¶

• expected NaN is matched only by a NaN, e.g. this works: InDeltaT(math.NaN(), math.Sqrt(-1), 0.0)
• expected +Inf is matched only by a +Inf
• expected -Inf is matched only by a -Inf

Edge case: for very large integers that do not convert accurately to a float64 (e.g. uint64), prefer InDeltaT.

Formula:

• If expected == 0: fail if |actual - expected| > epsilon
• If expected != 0: fail if |actual - expected| > epsilon * |expected|

This allows InEpsilonT to work naturally across the full numeric range including zero.

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.InEpsilonT(t, 100.0, 101.0, 0.02)
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func InEpsilonTf ¶ added in v2.2.0

func InEpsilonTf[Number Measurable](t T, expected Number, actual Number, epsilon float64, msg string, args ...any) bool

InEpsilonTf is the same as InEpsilonT, but it 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 it 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, collection any, msgAndArgs ...any) bool

IsDecreasing asserts that the collection is strictly 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 IsDecreasingT ¶ added in v2.2.0

func IsDecreasingT[OrderedSlice ~[]E, E Ordered](t T, collection OrderedSlice, msgAndArgs ...any) bool

IsDecreasingT asserts that a slice of Ordered is strictly decreasing.

Usage ¶

assertions.IsDecreasingT(t, []int{2, 1, 0})
assertions.IsDecreasingT(t, []float{2, 1})
assertions.IsDecreasingT(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.IsDecreasingT(t, []int{3, 2, 1})
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func IsDecreasingTf ¶ added in v2.2.0

func IsDecreasingTf[OrderedSlice ~[]E, E Ordered](t T, collection OrderedSlice, msg string, args ...any) bool

IsDecreasingTf is the same as IsDecreasingT, but it accepts a format msg string to format arguments like fmt.Printf.

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

func IsDecreasingf ¶

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

IsDecreasingf is the same as IsDecreasing, but it 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, collection any, msgAndArgs ...any) bool

IsIncreasing asserts that the collection is strictly 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 IsIncreasingT ¶ added in v2.2.0

func IsIncreasingT[OrderedSlice ~[]E, E Ordered](t T, collection OrderedSlice, msgAndArgs ...any) bool

IsIncreasingT asserts that a slice of Ordered is strictly increasing.

Usage ¶

assertions.IsIncreasingT(t, []int{1, 2, 3})
assertions.IsIncreasingT(t, []float{1, 2})
assertions.IsIncreasingT(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.IsIncreasingT(t, []int{1, 2, 3})
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func IsIncreasingTf ¶ added in v2.2.0

func IsIncreasingTf[OrderedSlice ~[]E, E Ordered](t T, collection OrderedSlice, msg string, args ...any) bool

IsIncreasingTf is the same as IsIncreasingT, but it accepts a format msg string to format arguments like fmt.Printf.

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

func IsIncreasingf ¶

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

IsIncreasingf is the same as IsIncreasing, but it 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, collection any, msgAndArgs ...any) bool

IsNonDecreasing asserts that the collection is not strictly 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, 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.IsNonDecreasing(t, []int{1, 1, 2})
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func IsNonDecreasingT ¶ added in v2.2.0

func IsNonDecreasingT[OrderedSlice ~[]E, E Ordered](t T, collection OrderedSlice, msgAndArgs ...any) bool

IsNonDecreasingT asserts that a slice of Ordered is not decreasing.

Usage ¶

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

Examples ¶

success: []int{1, 1, 2}
failure: []int{2, 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.IsNonDecreasingT(t, []int{1, 1, 2})
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func IsNonDecreasingTf ¶ added in v2.2.0

func IsNonDecreasingTf[OrderedSlice ~[]E, E Ordered](t T, collection OrderedSlice, msg string, args ...any) bool

IsNonDecreasingTf is the same as IsNonDecreasingT, but it accepts a format msg string to format arguments like fmt.Printf.

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

func IsNonDecreasingf ¶

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

IsNonDecreasingf is the same as IsNonDecreasing, but it 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, collection 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 IsNonIncreasingT ¶ added in v2.2.0

func IsNonIncreasingT[OrderedSlice ~[]E, E Ordered](t T, collection OrderedSlice, msgAndArgs ...any) bool

IsNonIncreasingT asserts that a slice of Ordered is NOT strictly 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.IsNonIncreasingT(t, []int{2, 1, 1})
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func IsNonIncreasingTf ¶ added in v2.2.0

func IsNonIncreasingTf[OrderedSlice ~[]E, E Ordered](t T, collection OrderedSlice, msg string, args ...any) bool

IsNonIncreasingTf is the same as IsNonIncreasingT, but it accepts a format msg string to format arguments like fmt.Printf.

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

func IsNonIncreasingf ¶

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

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

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

func IsNotOfTypeT ¶ added in v2.2.0

func IsNotOfTypeT[EType any](t T, object any, msgAndArgs ...any) bool

IsNotOfTypeT asserts that an object is of a given type.

Usage ¶

assertions.IsOfType[MyType](t,myVar)

Examples ¶

success: 123.123
failure: myType(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.IsNotOfTypeT[myType](t, 123.123)
	fmt.Printf("success: %t\n", success)

}

type myType float64

Output:

success: true

func IsNotOfTypeTf ¶ added in v2.2.0

func IsNotOfTypeTf[EType any](t T, object any, msg string, args ...any) bool

IsNotOfTypeTf is the same as IsNotOfTypeT, but it 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 it accepts a format msg string to format arguments like fmt.Printf.

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

func IsOfTypeT ¶ added in v2.2.0

func IsOfTypeT[EType any](t T, object any, msgAndArgs ...any) bool

IsOfTypeT asserts that an object is of a given type.

Usage ¶

assertions.IsOfTypeT[MyType](t,myVar)

Examples ¶

success: myType(123.123)
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.IsOfTypeT[myType](t, myType(123.123))
	fmt.Printf("success: %t\n", success)

}

type myType float64

Output:

success: true

func IsOfTypeTf ¶ added in v2.2.0

func IsOfTypeTf[EType any](t T, object any, msg string, args ...any) bool

IsOfTypeTf is the same as IsOfTypeT, but it 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 it 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.

Expected and actual must be valid JSON.

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 slices of bytes are equivalent.

Expected and actual must be valid JSON.

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 it accepts a format msg string to format arguments like fmt.Printf.

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

func JSONEqT ¶ added in v2.2.0

func JSONEqT[EDoc, ADoc Text](t T, expected EDoc, actual ADoc, msgAndArgs ...any) bool

JSONEqT asserts that two JSON documents are equivalent.

The expected and actual arguments may be string or []byte. They do not need to be of the same type.

Expected and actual must be valid JSON.

Usage ¶

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

Examples ¶

success: `{"hello": "world", "foo": "bar"}`, []byte(`{"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.JSONEqT(t, `{"hello": "world", "foo": "bar"}`, []byte(`{"foo": "bar", "hello": "world"}`))
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func JSONEqTf ¶ added in v2.2.0

func JSONEqTf[EDoc, ADoc Text](t T, expected EDoc, actual ADoc, msg string, args ...any) bool

JSONEqTf is the same as JSONEqT, but it 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 it accepts a format msg string to format arguments like fmt.Printf.

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

func Kind ¶ added in v2.2.0

func Kind(t T, expectedKind reflect.Kind, object any, msgAndArgs ...any) bool

Kind asserts that the reflect.Kind of a given object matches the expected reflect.Kind.

Kind reflects the concrete value stored in the object. The nil value (or interface with nil value) are comparable to reflect.Invalid. See also reflect.Value.Kind.

Usage ¶

assertions.Kind(t, reflect.String, "Hello World")

Examples ¶

success: reflect.String, "hello"
failure: reflect.String, 0

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

package main

import (
	"fmt"
	"reflect"
	"testing"

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

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

}

Output:

success: true

func Kindf ¶ added in v2.2.0

func Kindf(t T, expectedKind reflect.Kind, object any, msg string, args ...any) bool

Kindf is the same as Kind, but it 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 it 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.

Both elements must be of the same type in the reflect.Kind sense. To compare values that need a type conversion (e.g. float32 against float64), you need to convert types beforehand.

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 LessOrEqualT ¶ added in v2.2.0

func LessOrEqualT[Orderable Ordered](t T, e1 Orderable, e2 Orderable, msgAndArgs ...any) bool

LessOrEqualT asserts that for two elements of the same type, the first element is less than or equal to the second.

The Ordered type can be any of Go's cmp.Ordered (strings, numeric types), []byte (uses bytes.Compare) and time.Time (uses time.Time.Compare.

Notice that pointers are not Ordered, but uintptr are. So you can't call LessOrEqualT with *time.Time.

LessOrEqualT ensures type safety at build time. If you need to compare values with a dynamically assigned type, use LessOrEqual instead.

To compare values that need a type conversion (e.g. float32 against float64), you should use LessOrEqual instead.

Usage ¶

assertions.LessOrEqualT(t, 1, 2)
assertions.LessOrEqualT(t, 2, 2)
assertions.LessOrEqualT(t, "a", "b")
assertions.LessOrEqualT(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.LessOrEqualT(t, 1, 2)
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func LessOrEqualTf ¶ added in v2.2.0

func LessOrEqualTf[Orderable Ordered](t T, e1 Orderable, e2 Orderable, msg string, args ...any) bool

LessOrEqualTf is the same as LessOrEqualT, but it accepts a format msg string to format arguments like fmt.Printf.

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

func LessOrEqualf ¶

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

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

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

func LessT ¶ added in v2.2.0

func LessT[Orderable Ordered](t T, e1 Orderable, e2 Orderable, msgAndArgs ...any) bool

LessT asserts that for two elements of the same type, the first element is strictly less than the second.

The Ordered type can be any of Go's cmp.Ordered (strings, numeric types), []byte (uses bytes.Compare) and time.Time (uses time.Time.Compare.

Notice that pointers are not Ordered, but uintptr are. So you can't call LessT with *time.Time.

LessT ensures type safety at build time. If you need to compare values with a dynamically assigned type, use Less instead.

To compare values that need a type conversion (e.g. float32 against float64), you need to convert types beforehand.

Usage ¶

assertions.LessT(t, 1, 2)
assertions.LessT(t, float64(1), float64(2))
assertions.LessT(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.LessT(t, 1, 2)
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func LessTf ¶ added in v2.2.0

func LessTf[Orderable Ordered](t T, e1 Orderable, e2 Orderable, msg string, args ...any) bool

LessTf is the same as LessT, but it 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 it accepts a format msg string to format arguments like fmt.Printf.

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

func MapContainsT ¶ added in v2.2.0

func MapContainsT[Map ~map[K]V, K comparable, V any](t T, m Map, key K, msgAndArgs ...any) bool

MapContainsT asserts that the specified map contains a key.

Usage ¶

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

Examples ¶

success: map[string]string{"A": "B"}, "A"
failure: map[string]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.MapContainsT(t, map[string]string{"A": "B"}, "A")
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func MapContainsTf ¶ added in v2.2.0

func MapContainsTf[Map ~map[K]V, K comparable, V any](t T, m Map, key K, msg string, args ...any) bool

MapContainsTf is the same as MapContainsT, but it accepts a format msg string to format arguments like fmt.Printf.

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

func MapNotContainsT ¶ added in v2.2.0

func MapNotContainsT[Map ~map[K]V, K comparable, V any](t T, m Map, key K, msgAndArgs ...any) bool

MapNotContainsT asserts that the specified map does not contain a key.

Usage ¶

assertions.MapNotContainsT(t, map[string]string{"Hello": "x","World": "y"}, "hi")

Examples ¶

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

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.MapNotContainsT(t, map[string]string{"A": "B"}, "C")
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func MapNotContainsTf ¶ added in v2.2.0

func MapNotContainsTf[Map ~map[K]V, K comparable, V any](t T, m Map, key K, msg string, args ...any) bool

MapNotContainsTf is the same as MapNotContainsT, but it 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 NegativeT ¶ added in v2.2.0

func NegativeT[SignedNumber SignedNumeric](t T, e SignedNumber, msgAndArgs ...any) bool

NegativeT asserts that the specified element of a signed numeric type is strictly negative.

Usage ¶

assertions.NegativeT(t, -1)
assertions.NegativeT(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.NegativeT(t, -1)
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func NegativeTf ¶ added in v2.2.0

func NegativeTf[SignedNumber SignedNumeric](t T, e SignedNumber, msg string, args ...any) bool

NegativeTf is the same as NegativeT, but it accepts a format msg string to format arguments like fmt.Printf.

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

func Negativef ¶

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

Negativef is the same as Negative, but it 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 is never satisfied within waitFor time, periodically checking the target function at each tick.

Never is the opposite of Eventually. It succeeds if the waitFor timeout is reached without the condition ever returning true.

If the parent context is cancelled before the timeout, Never fails.

Usage ¶

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

Concurrency ¶

The condition function is never executed in parallel: only one goroutine executes it. It may write to variables outside its scope without triggering race conditions.

A blocking condition will cause Never to hang until it returns.

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 it 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 it 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 it 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 it 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, []int{1, 1, 2, 3}, []int{1, 1, 2, 3}) -> false
assertions.NotElementsMatch(t, []int{1, 1, 2, 3}, []int{1, 2, 3}) -> true
assertions.NotElementsMatch(t, []int{1, 2, 3}, []int{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 NotElementsMatchT ¶ added in v2.2.0

func NotElementsMatchT[E comparable](t T, listA []E, listB []E, msgAndArgs ...any) (ok bool)

NotElementsMatchT 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.NotElementsMatchT(t, []int{1, 1, 2, 3}, []int{1, 1, 2, 3}) -> false
assertions.NotElementsMatchT(t, []int{1, 1, 2, 3}, []int{1, 2, 3}) -> true
assertions.NotElementsMatchT(t, []int{1, 2, 3}, []int{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.NotElementsMatchT(t, []int{1, 2, 3}, []int{1, 2, 4})
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func NotElementsMatchTf ¶ added in v2.2.0

func NotElementsMatchTf[E comparable](t T, listA []E, listB []E, msg string, args ...any) (ok bool)

NotElementsMatchTf is the same as NotElementsMatchT, but it accepts a format msg string to format arguments like fmt.Printf.

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

func NotElementsMatchf ¶

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

NotElementsMatchf is the same as NotElementsMatch, but it 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 it 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).

Function equality cannot be determined and will always fail.

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 NotEqualT ¶ added in v2.2.0

func NotEqualT[V comparable](t T, expected V, actual V, msgAndArgs ...any) bool

NotEqualT asserts that the specified values of the same comparable type are NOT equal.

See EqualT.

Usage ¶

assertions.NotEqualT(t, obj1, obj2)

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.NotEqualT(t, 123, 456)
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func NotEqualTf ¶ added in v2.2.0

func NotEqualTf[V comparable](t T, expected V, actual V, msg string, args ...any) bool

NotEqualTf is the same as NotEqualT, but it accepts a format msg string to format arguments like fmt.Printf.

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

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.

Function equality cannot be determined and will always fail.

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 it 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 it 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 it 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 it 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 it accepts a format msg string to format arguments like fmt.Printf.

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

func NotKind ¶ added in v2.2.0

func NotKind(t T, expectedKind reflect.Kind, object any, msgAndArgs ...any) bool

NotKind asserts that the reflect.Kind of a given object does not match the expected reflect.Kind.

Kind reflects the concrete value stored in the object. The nil value (or interface with nil value) are comparable to reflect.Invalid. See also reflect.Value.Kind.

Usage ¶

assertions.NotKind(t, reflect.Int, "Hello World")

Examples ¶

success: reflect.String, 0
failure: reflect.String, "hello"

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

package main

import (
	"fmt"
	"reflect"
	"testing"

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

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

}

Output:

success: true

func NotKindf ¶ added in v2.2.0

func NotKindf(t T, expectedKind reflect.Kind, object any, msg string, args ...any) bool

NotKindf is the same as NotKind, but it 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 it 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 it 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, actual any, msgAndArgs ...any) bool

NotRegexp asserts that a specified regular expression does not match a string.

See Regexp.

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 NotRegexpT ¶ added in v2.2.0

func NotRegexpT[Rex RegExp, ADoc Text](t T, rx Rex, actual ADoc, msgAndArgs ...any) bool

NotRegexpT asserts that a specified regular expression does not match a string.

See RegexpT.

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.NotRegexpT(t, "^start", "not starting")
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func NotRegexpTf ¶ added in v2.2.0

func NotRegexpTf[Rex RegExp, ADoc Text](t T, rx Rex, actual ADoc, msg string, args ...any) bool

NotRegexpTf is the same as NotRegexpT, but it accepts a format msg string to format arguments like fmt.Printf.

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

func NotRegexpf ¶

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

NotRegexpf is the same as NotRegexp, but it 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.

See Same.

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 NotSameT ¶ added in v2.2.0

func NotSameT[P any](t T, expected *P, actual *P, msgAndArgs ...any) bool

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

See SameT.

Usage ¶

assertions.NotSameT(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.NotSameT(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 NotSameTf ¶ added in v2.2.0

func NotSameTf[P any](t T, expected *P, actual *P, msg string, args ...any) bool

NotSameTf is the same as NotSameT, but it accepts a format msg string to format arguments like fmt.Printf.

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

func NotSamef ¶

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

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

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

func NotSortedT ¶ added in v2.2.0

func NotSortedT[OrderedSlice ~[]E, E Ordered](t T, collection OrderedSlice, msgAndArgs ...any) bool

NotSortedT asserts that the slice of Ordered is NOT sorted (i.e. non-strictly increasing).

Unlike IsDecreasingT, it accepts slices that are neither increasing nor decreasing.

Usage ¶

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

Examples ¶

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

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.NotSortedT(t, []int{3, 1, 3})
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func NotSortedTf ¶ added in v2.2.0

func NotSortedTf[OrderedSlice ~[]E, E Ordered](t T, collection OrderedSlice, msg string, args ...any) bool

NotSortedTf is the same as NotSortedT, but it 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 it 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 it 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 it 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 it 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 it 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 PositiveT ¶ added in v2.2.0

func PositiveT[SignedNumber SignedNumeric](t T, e SignedNumber, msgAndArgs ...any) bool

PositiveT asserts that the specified element of a signed numeric type is strictly positive.

Usage ¶

assertions.PositiveT(t, 1)
assertions.PositiveT(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.PositiveT(t, 1)
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func PositiveTf ¶ added in v2.2.0

func PositiveTf[SignedNumber SignedNumeric](t T, e SignedNumber, msg string, args ...any) bool

PositiveTf is the same as PositiveT, but it accepts a format msg string to format arguments like fmt.Printf.

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

func Positivef ¶

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

Positivef is the same as Positive, but it 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, actual any, msgAndArgs ...any) bool

Regexp asserts that a specified regular expression matches a string.

The regular expression may be passed as a regexp.Regexp, a string or a []byte and will be compiled.

The actual argument to be matched may be a string, []byte or anything that prints as a string with fmt.Sprint.

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 RegexpT ¶ added in v2.2.0

func RegexpT[Rex RegExp, ADoc Text](t T, rx Rex, actual ADoc, msgAndArgs ...any) bool

RegexpT asserts that a specified regular expression matches a string.

The actual argument to be matched may be a string or []byte.

See Regexp.

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.RegexpT(t, "^start", "starting")
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func RegexpTf ¶ added in v2.2.0

func RegexpTf[Rex RegExp, ADoc Text](t T, rx Rex, actual ADoc, msg string, args ...any) bool

RegexpTf is the same as RegexpT, but it accepts a format msg string to format arguments like fmt.Printf.

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

func Regexpf ¶

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

Regexpf is the same as Regexp, but it 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.

Unlike Equal pointers, Same pointers point to the same memory address.

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 SameT ¶ added in v2.2.0

func SameT[P any](t T, expected *P, actual *P, msgAndArgs ...any) bool

SameT asserts that two pointers of the same type reference the same object.

See Same.

Usage ¶

assertions.SameT(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.SameT(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 SameTf ¶ added in v2.2.0

func SameTf[P any](t T, expected *P, actual *P, msg string, args ...any) bool

SameTf is the same as SameT, but it accepts a format msg string to format arguments like fmt.Printf.

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

func Samef ¶

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

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

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

func SeqContainsT ¶ added in v2.2.0

func SeqContainsT[E comparable](t T, iter iter.Seq[E], element E, msgAndArgs ...any) bool

SeqContainsT asserts that the specified iterator contains a comparable element.

Usage ¶

assertions.SeqContainsT(t, slices.Values([]{"Hello","World"}), "World")

Examples ¶

success: slices.Values([]string{"A","B"}), "A"
failure: slices.Values([]string{"A","B"}), "C"

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

package main

import (
	"fmt"
	"slices"
	"testing"

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

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

}

Output:

success: true

func SeqContainsTf ¶ added in v2.2.0

func SeqContainsTf[E comparable](t T, iter iter.Seq[E], element E, msg string, args ...any) bool

SeqContainsTf is the same as SeqContainsT, but it accepts a format msg string to format arguments like fmt.Printf.

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

func SeqNotContainsT ¶ added in v2.2.0

func SeqNotContainsT[E comparable](t T, iter iter.Seq[E], element E, msgAndArgs ...any) bool

SeqNotContainsT asserts that the specified iterator does not contain a comparable element.

Usage ¶

assertions.SeqContainsT(t, slices.Values([]{"Hello","World"}), "World")

Examples ¶

success: slices.Values([]string{"A","B"}), "C"
failure: slices.Values([]string{"A","B"}), "A"

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

package main

import (
	"fmt"
	"slices"
	"testing"

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

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

}

Output:

success: true

func SeqNotContainsTf ¶ added in v2.2.0

func SeqNotContainsTf[E comparable](t T, iter iter.Seq[E], element E, msg string, args ...any) bool

SeqNotContainsTf is the same as SeqNotContainsT, but it accepts a format msg string to format arguments like fmt.Printf.

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

func SliceContainsT ¶ added in v2.2.0

func SliceContainsT[Slice ~[]E, E comparable](t T, s Slice, element E, msgAndArgs ...any) bool

SliceContainsT asserts that the specified slice contains a comparable element.

Usage ¶

assertions.SliceContainsT(t, []{"Hello","World"}, "World")

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.SliceContainsT(t, []string{"A", "B"}, "A")
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func SliceContainsTf ¶ added in v2.2.0

func SliceContainsTf[Slice ~[]E, E comparable](t T, s Slice, element E, msg string, args ...any) bool

SliceContainsTf is the same as SliceContainsT, but it accepts a format msg string to format arguments like fmt.Printf.

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

func SliceNotContainsT ¶ added in v2.2.0

func SliceNotContainsT[Slice ~[]E, E comparable](t T, s Slice, element E, msgAndArgs ...any) bool

SliceNotContainsT asserts that the specified slice does not contain a comparable element.

Usage ¶

assertions.SliceNotContainsT(t, []{"Hello","World"}, "hi")

Examples ¶

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

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.SliceNotContainsT(t, []string{"A", "B"}, "C")
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func SliceNotContainsTf ¶ added in v2.2.0

func SliceNotContainsTf[Slice ~[]E, E comparable](t T, s Slice, element E, msg string, args ...any) bool

SliceNotContainsTf is the same as SliceNotContainsT, but it accepts a format msg string to format arguments like fmt.Printf.

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

func SliceNotSubsetT ¶ added in v2.2.0

func SliceNotSubsetT[Slice ~[]E, E comparable](t T, list Slice, subset Slice, msgAndArgs ...any) (ok bool)

SliceNotSubsetT asserts that a slice of comparable elements does not contain all the elements given in the subset.

Usage ¶

assertions.SliceNotSubsetT(t, []int{1, 2, 3}, []int{1, 4})

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.SliceNotSubsetT(t, []int{1, 2, 3}, []int{4, 5})
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func SliceNotSubsetTf ¶ added in v2.2.0

func SliceNotSubsetTf[Slice ~[]E, E comparable](t T, list Slice, subset Slice, msg string, args ...any) (ok bool)

SliceNotSubsetTf is the same as SliceNotSubsetT, but it accepts a format msg string to format arguments like fmt.Printf.

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

func SliceSubsetT ¶ added in v2.2.0

func SliceSubsetT[Slice ~[]E, E comparable](t T, list Slice, subset Slice, msgAndArgs ...any) (ok bool)

SliceSubsetT asserts that a slice of comparable elements contains all the elements given in the subset.

Usage ¶

assertions.SliceSubsetT(t, []int{1, 2, 3}, []int{1, 2})

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.SliceSubsetT(t, []int{1, 2, 3}, []int{1, 2})
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func SliceSubsetTf ¶ added in v2.2.0

func SliceSubsetTf[Slice ~[]E, E comparable](t T, list Slice, subset Slice, msg string, args ...any) (ok bool)

SliceSubsetTf is the same as SliceSubsetT, but it accepts a format msg string to format arguments like fmt.Printf.

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

func SortedT ¶ added in v2.2.0

func SortedT[OrderedSlice ~[]E, E Ordered](t T, collection OrderedSlice, msgAndArgs ...any) bool

SortedT asserts that the slice of Ordered is sorted (i.e. non-strictly increasing).

Unlike IsIncreasingT, it accepts elements to be equal.

Usage ¶

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

Examples ¶

success: []int{1, 1, 3}
failure: []int{1, 4, 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.SortedT(t, []int{1, 1, 3})
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func SortedTf ¶ added in v2.2.0

func SortedTf[OrderedSlice ~[]E, E Ordered](t T, collection OrderedSlice, msg string, args ...any) bool

SortedTf is the same as SortedT, but it accepts a format msg string to format arguments like fmt.Printf.

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

func StringContainsT ¶ added in v2.2.0

func StringContainsT[ADoc, EDoc Text](t T, str ADoc, substring EDoc, msgAndArgs ...any) bool

StringContainsT asserts that a string contains the specified substring.

Strings may be go strings or []byte.

Usage ¶

assertions.StringContainsT(t, "Hello World", "World")

Examples ¶

success: "AB", "A"
failure: "AB", "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.StringContainsT(t, "AB", "A")
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func StringContainsTf ¶ added in v2.2.0

func StringContainsTf[ADoc, EDoc Text](t T, str ADoc, substring EDoc, msg string, args ...any) bool

StringContainsTf is the same as StringContainsT, but it accepts a format msg string to format arguments like fmt.Printf.

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

func StringNotContainsT ¶ added in v2.2.0

func StringNotContainsT[ADoc, EDoc Text](t T, str ADoc, substring EDoc, msgAndArgs ...any) bool

StringNotContainsT asserts that a string does not contain the specified substring.

Strings may be go strings or []byte.

Usage ¶

assertions.StringNotContainsT(t, "Hello World", "hi")

Examples ¶

success: "AB", "C"
failure: "AB", "A"

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.StringNotContainsT(t, "AB", "C")
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func StringNotContainsTf ¶ added in v2.2.0

func StringNotContainsTf[ADoc, EDoc Text](t T, str ADoc, substring EDoc, msg string, args ...any) bool

StringNotContainsTf is the same as StringNotContainsT, but it 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, []int{1, 2, 3}, []int{1, 2})
assertions.Subset(t, []string{"x": 1, "y": 2}, []string{"x": 1})
assertions.Subset(t, []int{1, 2, 3}, map[int]string{1: "one", 2: "two"})
assertions.Subset(t, map[string]int{"x": 1, "y": 2}, []string{"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 it 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 TrueT ¶ added in v2.2.0

func TrueT[B Boolean](t T, value B, msgAndArgs ...any) bool

TrueT asserts that the specified value is true.

Usage ¶

type B bool
var b B = true

assertions.True(t, b)

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.TrueT(t, 1 == 1)
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func TrueTf ¶ added in v2.2.0

func TrueTf[B Boolean](t T, value B, msg string, args ...any) bool

TrueTf is the same as TrueT, but it accepts a format msg string to format arguments like fmt.Printf.

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

func Truef ¶

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

Truef is the same as True, but it 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 it 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 it 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 two YAML strings are equivalent.

See YAMLEqBytes.

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 YAMLEqBytes ¶ added in v2.2.0

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

YAMLEqBytes asserts that two YAML slices of bytes are equivalent.

Expected and actual must be valid YAML.

Important ¶

By default, this function is disabled and will panic.

To enable it, you should add a blank import like so:

import(
  "github.com/go-openapi/testify/enable/yaml/v2"
)

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: []byte("key: value"), []byte("key: value")
should panic without the yaml feature enabled.

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

func YAMLEqBytesf ¶ added in v2.2.0

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

YAMLEqBytesf is the same as YAMLEqBytes, but it accepts a format msg string to format arguments like fmt.Printf.

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

func YAMLEqT ¶ added in v2.2.0

func YAMLEqT[EDoc, ADoc Text](t T, expected EDoc, actual ADoc, msgAndArgs ...any) bool

YAMLEqT asserts that two YAML documents are equivalent.

The expected and actual arguments may be string or []byte. They do not need to be of the same type.

See YAMLEqBytes.

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 YAMLEqTf ¶ added in v2.2.0