require

func CallerInfo ¶ added in v2.1.0

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)

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

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.Condition(t, func() bool {
		return true
	})
	fmt.Println("passed")

}

Output:

passed

func Conditionf ¶

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

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

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

func Contains ¶

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

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

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.Contains(t, []string{"A", "B"}, "A")
	fmt.Println("passed")

}

Output:

passed

func Containsf ¶

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

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

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

func DirExists ¶

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

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

package main

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

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

func main() {
	t := new(testing.T)
	require.DirExists(t, filepath.Join(testDataPath(), "existing_dir"))
	fmt.Println("passed")

}

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

Output:

passed

func DirExistsf ¶

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

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

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

func ElementsMatch ¶

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

ElementsMatch asserts that the specified listA(array, slice...) is equal to specified listB(array, slice...) ignoring the order of the elements. If there are duplicate elements, the number of appearances of each of them in both lists should match.

Usage ¶

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

Examples ¶

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

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

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.ElementsMatch(t, []int{1, 3, 2, 3}, []int{1, 3, 3, 2})
	fmt.Println("passed")

}

Output:

passed

func ElementsMatchf ¶

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

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

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

func Empty ¶

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

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

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.Empty(t, "")
	fmt.Println("passed")

}

Output:

passed

func Emptyf ¶

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

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

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

func Equal ¶

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

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

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.Equal(t, 123, 123)
	fmt.Println("passed")

}

Output:

passed

func EqualError ¶

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

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

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.EqualError(t, require.ErrTest, "assert.ErrTest general error for testing")
	fmt.Println("passed")

}

Output:

passed

func EqualErrorf ¶

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

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

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

func EqualExportedValues ¶

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

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

Usage ¶

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

Examples ¶

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

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

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.EqualExportedValues(t, &dummyStruct{A: "a", b: 1}, &dummyStruct{A: "a", b: 2})
	fmt.Println("passed")

}

type dummyStruct struct {
	A string
	b int
}

Output:

passed

func EqualExportedValuesf ¶

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

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

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

func EqualValues ¶

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

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

Usage ¶

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

Examples ¶

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

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

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.EqualValues(t, uint32(123), int32(123))
	fmt.Println("passed")

}

Output:

passed

func EqualValuesf ¶

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

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

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

func Equalf ¶

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

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

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

func Error ¶

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

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

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.Error(t, require.ErrTest)
	fmt.Println("passed")

}

Output:

passed

func ErrorAs ¶

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

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

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.ErrorAs(t, fmt.Errorf("wrap: %w", &dummyError{}), new(*dummyError))
	fmt.Println("passed")

}

type dummyError struct {
}

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

Output:

passed

func ErrorAsf ¶

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

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

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

func ErrorContains ¶

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

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

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.ErrorContains(t, require.ErrTest, "general error")
	fmt.Println("passed")

}

Output:

passed

func ErrorContainsf ¶

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

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

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

func ErrorIs ¶

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

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

package main

import (
	"fmt"
	"io"
	"testing"

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

func main() {
	t := new(testing.T)
	require.ErrorIs(t, fmt.Errorf("wrap: %w", io.EOF), io.EOF)
	fmt.Println("passed")

}

Output:

passed

func ErrorIsf ¶

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

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

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

func Errorf ¶

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

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

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

func Eventually ¶

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

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

Usage ¶

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

Examples ¶

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

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

package main

import (
	"fmt"
	"testing"
	"time"

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

func main() {
	t := new(testing.T)
	require.Eventually(t, func() bool {
		return true
	}, 100*time.Millisecond, 20*time.Millisecond)
	fmt.Println("passed")

}

Output:

passed

func EventuallyWithT ¶

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

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

Usage ¶

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

Examples ¶

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

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

package main

import (
	"fmt"
	"testing"
	"time"

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

func main() {
	t := new(testing.T)
	require.EventuallyWithT(t, func(c *assert.CollectT) {
		assert.True(c, true)
	}, 100*time.Millisecond, 20*time.Millisecond)
	fmt.Println("passed")

}

Output:

passed

func EventuallyWithTf ¶

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

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

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

func Eventuallyf ¶

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

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

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

func Exactly ¶

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

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

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.Exactly(t, int32(123), int32(123))
	fmt.Println("passed")

}

Output:

passed

func Exactlyf ¶

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

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

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

func Fail ¶

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

Fail reports a failure through.

Usage ¶

assertions.Fail(t, "failed")

Examples ¶

failure: "failed"

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

func FailNow ¶

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

FailNow fails test.

Usage ¶

assertions.FailNow(t, "failed")

Examples ¶

failure: "failed"

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

func FailNowf ¶

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

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

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

func Failf ¶

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

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

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

func False ¶

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

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

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.False(t, 1 == 0)
	fmt.Println("passed")

}

Output:

passed

func Falsef ¶

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

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

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

func FileEmpty ¶ added in v2.1.0

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

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

package main

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

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

func main() {
	t := new(testing.T)
	require.FileEmpty(t, filepath.Join(testDataPath(), "empty_file"))
	fmt.Println("passed")

}

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

Output:

passed

func FileEmptyf ¶ added in v2.1.0

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

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

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

func FileExists ¶

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

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

package main

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

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

func main() {
	t := new(testing.T)
	require.FileExists(t, filepath.Join(testDataPath(), "existing_file"))
	fmt.Println("passed")

}

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

Output:

passed

func FileExistsf ¶

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

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

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

func FileNotEmpty ¶ added in v2.1.0

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

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

package main

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

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

func main() {
	t := new(testing.T)
	require.FileNotEmpty(t, filepath.Join(testDataPath(), "existing_file"))
	fmt.Println("passed")

}

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

Output:

passed

func FileNotEmptyf ¶ added in v2.1.0

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

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

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

func Greater ¶

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

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

Usage ¶

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

Examples ¶

success: 2, 1
failure: 1, 2

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

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.Greater(t, 2, 1)
	fmt.Println("passed")

}

Output:

passed

func GreaterOrEqual ¶

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

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

Usage ¶

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

Examples ¶

success: 2, 1
failure: 1, 2

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

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.GreaterOrEqual(t, 2, 1)
	fmt.Println("passed")

}

Output:

passed

func GreaterOrEqualf ¶

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

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

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

func Greaterf ¶

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

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

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

func HTTPBody ¶ added in v2.1.0

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)

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

package main

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

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

func main() {
	t := new(testing.T)
	require.HTTPBodyContains(t, httpBody, "GET", "/", url.Values{"name": []string{"World"}}, "Hello, World!")
	fmt.Println("passed")

}

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

Output:

passed

func HTTPBodyContainsf ¶

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

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

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

func HTTPBodyNotContains ¶

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

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

package main

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

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

func main() {
	t := new(testing.T)
	require.HTTPBodyNotContains(t, httpBody, "GET", "/", url.Values{"name": []string{"World"}}, "Hello, Bob!")
	fmt.Println("passed")

}

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

Output:

passed

func HTTPBodyNotContainsf ¶

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

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

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

func HTTPError ¶

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

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

package main

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

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

func main() {
	t := new(testing.T)
	require.HTTPError(t, httpError, "GET", "/", nil)
	fmt.Println("passed")

}

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

Output:

passed

func HTTPErrorf ¶

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

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

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

func HTTPRedirect ¶

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

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

package main

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

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

func main() {
	t := new(testing.T)
	require.HTTPRedirect(t, httpRedirect, "GET", "/", nil)
	fmt.Println("passed")

}

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

Output:

passed

func HTTPRedirectf ¶

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

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

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

func HTTPStatusCode ¶

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

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

package main

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

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

func main() {
	t := new(testing.T)
	require.HTTPStatusCode(t, httpOK, "GET", "/", nil, http.StatusOK)
	fmt.Println("passed")

}

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

Output:

passed

func HTTPStatusCodef ¶

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

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

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

func HTTPSuccess ¶

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

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

package main

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

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

func main() {
	t := new(testing.T)
	require.HTTPSuccess(t, httpOK, "GET", "/", nil)
	fmt.Println("passed")

}

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

Output:

passed

func HTTPSuccessf ¶

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

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

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

func Implements ¶

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

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

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.Implements(t, ptr(dummyInterface), new(testing.T))
	fmt.Println("passed")

}

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

	dummyInterface require.T
)

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

	return &p
}

Output:

passed

func Implementsf ¶

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

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

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

func InDelta ¶

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

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

Usage ¶

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

Examples ¶

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

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

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.InDelta(t, 1.0, 1.01, 0.02)
	fmt.Println("passed")

}

Output:

passed

func InDeltaMapValues ¶

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

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

Usage ¶

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

Examples ¶

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

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

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.InDeltaMapValues(t, map[string]float64{"a": 1.0}, map[string]float64{"a": 1.01}, 0.02)
	fmt.Println("passed")

}

Output:

passed

func InDeltaMapValuesf ¶

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

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

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

func InDeltaSlice ¶

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

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

Usage ¶

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

Examples ¶

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

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

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.InDeltaSlice(t, []float64{1.0, 2.0}, []float64{1.01, 2.01}, 0.02)
	fmt.Println("passed")

}

Output:

passed

func InDeltaSlicef ¶

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

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

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

func InDeltaf ¶

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

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

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

func InEpsilon ¶

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

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

Usage ¶

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

Examples ¶

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

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

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.InEpsilon(t, 100.0, 101.0, 0.02)
	fmt.Println("passed")

}

Output:

passed

func InEpsilonSlice ¶

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

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

Usage ¶

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

Examples ¶

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

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

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.InEpsilonSlice(t, []float64{100.0, 200.0}, []float64{101.0, 202.0}, 0.02)
	fmt.Println("passed")

}

Output:

passed

func InEpsilonSlicef ¶

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

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

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

func InEpsilonf ¶

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

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

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

func IsDecreasing ¶

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

IsDecreasing asserts that the collection is decreasing.

Usage ¶

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

Examples ¶

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

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

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.IsDecreasing(t, []int{3, 2, 1})
	fmt.Println("passed")

}

Output:

passed

func IsDecreasingf ¶

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

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

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

func IsIncreasing ¶

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

IsIncreasing asserts that the collection is increasing.

Usage ¶

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

Examples ¶

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

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

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.IsIncreasing(t, []int{1, 2, 3})
	fmt.Println("passed")

}

Output:

passed

func IsIncreasingf ¶

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

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

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

func IsNonDecreasing ¶

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

IsNonDecreasing asserts that the collection is not decreasing.

Usage ¶

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

Examples ¶

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

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

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.IsNonDecreasing(t, []int{1, 1, 2})
	fmt.Println("passed")

}

Output:

passed

func IsNonDecreasingf ¶

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

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

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

func IsNonIncreasing ¶

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

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

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.IsNonIncreasing(t, []int{2, 1, 1})
	fmt.Println("passed")

}

Output:

passed

func IsNonIncreasingf ¶

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

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

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

func IsNotType ¶

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

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

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.IsNotType(t, int32(123), int64(456))
	fmt.Println("passed")

}

Output:

passed

func IsNotTypef ¶

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

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

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

func IsType ¶

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

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

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.IsType(t, 123, 456)
	fmt.Println("passed")

}

Output:

passed

func IsTypef ¶

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

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

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

func JSONEq ¶

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

JSONEq asserts that two JSON strings are equivalent.

Usage ¶

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

Examples ¶

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

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

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.JSONEq(t, `{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`)
	fmt.Println("passed")

}

Output:

passed

func JSONEqBytes ¶ added in v2.0.2

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

JSONEqBytes asserts that two JSON byte slices are equivalent.

Usage ¶

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

Examples ¶

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

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

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.JSONEqBytes(t, []byte(`{"hello": "world", "foo": "bar"}`), []byte(`{"foo": "bar", "hello": "world"}`))
	fmt.Println("passed")

}

Output:

passed

func JSONEqBytesf ¶ added in v2.0.2

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

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

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

func JSONEqf ¶

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

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

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

func Len ¶

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

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

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.Len(t, []string{"A", "B"}, 2)
	fmt.Println("passed")

}

Output:

passed

func Lenf ¶

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

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

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

func Less ¶

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

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

Usage ¶

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

Examples ¶

success: 1, 2
failure: 2, 1

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

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.Less(t, 1, 2)
	fmt.Println("passed")

}

Output:

passed

func LessOrEqual ¶

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

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

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.LessOrEqual(t, 1, 2)
	fmt.Println("passed")

}

Output:

passed

func LessOrEqualf ¶

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

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

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

func Lessf ¶

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

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

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

func Negative ¶

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

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

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.Negative(t, -1)
	fmt.Println("passed")

}

Output:

passed

func Negativef ¶

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

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

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

func Never ¶

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

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

Usage ¶

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

Examples ¶

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

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

package main

import (
	"fmt"
	"testing"
	"time"

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

func main() {
	t := new(testing.T)
	require.Never(t, func() bool {
		return false
	}, 100*time.Millisecond, 20*time.Millisecond)
	fmt.Println("passed")

}

Output:

passed

func Neverf ¶

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

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

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

func Nil ¶

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

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

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.Nil(t, nil)
	fmt.Println("passed")

}

Output:

passed

func Nilf ¶

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

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

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

func NoDirExists ¶

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

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

Usage ¶

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

Examples ¶

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

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

package main

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

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

func main() {
	t := new(testing.T)
	require.NoDirExists(t, filepath.Join(testDataPath(), "non_existing_dir"))
	fmt.Println("passed")

}

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

Output:

passed

func NoDirExistsf ¶

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

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

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

func NoError ¶

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

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

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.NoError(t, nil)
	fmt.Println("passed")

}

Output:

passed

func NoErrorf ¶

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

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

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

func NoFileExists ¶

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

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

Usage ¶

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

Examples ¶

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

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

package main

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

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

func main() {
	t := new(testing.T)
	require.NoFileExists(t, filepath.Join(testDataPath(), "non_existing_file"))
	fmt.Println("passed")

}

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

Output:

passed

func NoFileExistsf ¶

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

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

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

func NotContains ¶

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

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

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.NotContains(t, []string{"A", "B"}, "C")
	fmt.Println("passed")

}

Output:

passed

func NotContainsf ¶

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

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

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

func NotElementsMatch ¶

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

NotElementsMatch asserts that the specified listA(array, slice...) is NOT equal to specified listB(array, slice...) ignoring the order of the elements. If there are duplicate elements, the number of appearances of each of them in both lists should not match. This is an inverse of ElementsMatch.

Usage ¶

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

Examples ¶

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

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

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.NotElementsMatch(t, []int{1, 2, 3}, []int{1, 2, 4})
	fmt.Println("passed")

}

Output:

passed

func NotElementsMatchf ¶

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

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

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

func NotEmpty ¶

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

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

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.NotEmpty(t, "not empty")
	fmt.Println("passed")

}

Output:

passed

func NotEmptyf ¶

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

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

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

func NotEqual ¶

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

NotEqual asserts that the specified values are NOT equal.

Usage ¶

assertions.NotEqual(t, obj1, obj2)

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

Examples ¶

success: 123, 456
failure: 123, 123

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

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.NotEqual(t, 123, 456)
	fmt.Println("passed")

}

Output:

passed

func NotEqualValues ¶

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

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

Usage ¶

assertions.NotEqualValues(t, obj1, obj2)

Examples ¶

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

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

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.NotEqualValues(t, uint32(123), int32(456))
	fmt.Println("passed")

}

Output:

passed

func NotEqualValuesf ¶

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

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

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

func NotEqualf ¶

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

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

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

func NotErrorAs ¶

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

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

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.NotErrorAs(t, require.ErrTest, new(*dummyError))
	fmt.Println("passed")

}

type dummyError struct {
}

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

Output:

passed

func NotErrorAsf ¶

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

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

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

func NotErrorIs ¶

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

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

package main

import (
	"fmt"
	"io"
	"testing"

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

func main() {
	t := new(testing.T)
	require.NotErrorIs(t, require.ErrTest, io.EOF)
	fmt.Println("passed")

}

Output:

passed

func NotErrorIsf ¶

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

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

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

func NotImplements ¶

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

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

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.NotImplements(t, (*error)(nil), new(testing.T))
	fmt.Println("passed")

}

Output:

passed

func NotImplementsf ¶

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

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

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

func NotNil ¶

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

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

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.NotNil(t, "not nil")
	fmt.Println("passed")

}

Output:

passed

func NotNilf ¶

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

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

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

func NotPanics ¶

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

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

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.NotPanics(t, func() {
	})
	fmt.Println("passed")

}

Output:

passed

func NotPanicsf ¶

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

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

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

func NotRegexp ¶

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

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

Usage ¶

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

Examples ¶

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

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

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.NotRegexp(t, "^start", "not starting")
	fmt.Println("passed")

}

Output:

passed

func NotRegexpf ¶

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

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

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

func NotSame ¶

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

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

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

Usage ¶

assertions.NotSame(t, ptr1, ptr2)

Examples ¶

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

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

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.NotSame(t, &staticVar, ptr("static string"))
	fmt.Println("passed")

}

//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:

passed

func NotSamef ¶

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

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

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

func NotSubset ¶

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

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

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.NotSubset(t, []int{1, 2, 3}, []int{4, 5})
	fmt.Println("passed")

}

Output:

passed

func NotSubsetf ¶

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

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

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

func NotZero ¶

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

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

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.NotZero(t, 1)
	fmt.Println("passed")

}

Output:

passed

func NotZerof ¶

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

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

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

func ObjectsAreEqual ¶ added in v2.1.0

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

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)

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

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.Panics(t, func() {
		panic("panicking")
	})
	fmt.Println("passed")

}

Output:

passed

func PanicsWithError ¶

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

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

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.PanicsWithError(t, assert.ErrTest.Error(), func() {
		panic(assert.ErrTest)
	})
	fmt.Println("passed")

}

Output:

passed

func PanicsWithErrorf ¶

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

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

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

func PanicsWithValue ¶

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

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

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.PanicsWithValue(t, "panicking", func() {
		panic("panicking")
	})
	fmt.Println("passed")

}

Output:

passed

func PanicsWithValuef ¶

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

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

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

func Panicsf ¶

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

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

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

func Positive ¶

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

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

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.Positive(t, 1)
	fmt.Println("passed")

}

Output:

passed

func Positivef ¶

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

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

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

func Regexp ¶

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

Regexp asserts that a specified regexp matches a string.

Usage ¶

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

Examples ¶

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

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

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.Regexp(t, "^start", "starting")
	fmt.Println("passed")

}

Output:

passed

func Regexpf ¶

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

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

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

func Same ¶

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

Same asserts that two pointers reference the same object.

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

Usage ¶

assertions.Same(t, ptr1, ptr2)

Examples ¶

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

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

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.Same(t, &staticVar, staticVarPtr)
	fmt.Println("passed")

}

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

Output:

passed

func Samef ¶

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

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

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

func Subset ¶

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

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

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

Usage ¶

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

Examples ¶

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

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

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.Subset(t, []int{1, 2, 3}, []int{1, 2})
	fmt.Println("passed")

}

Output:

passed

func Subsetf ¶

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

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

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

func True ¶

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

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

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.True(t, 1 == 1)
	fmt.Println("passed")

}

Output:

passed

func Truef ¶

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

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

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

func WithinDuration ¶

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

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

package main

import (
	"fmt"
	"testing"
	"time"

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

func main() {
	t := new(testing.T)
	require.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.Println("passed")

}

Output:

passed

func WithinDurationf ¶

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

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

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

func WithinRange ¶

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

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

package main

import (
	"fmt"
	"testing"
	"time"

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

func main() {
	t := new(testing.T)
	require.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.Println("passed")

}

Output:

passed

func WithinRangef ¶

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

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

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

func YAMLEq ¶

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

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

Usage ¶

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

Examples ¶

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

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

func YAMLEqf ¶

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

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

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

func Zero ¶

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

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

Usage ¶

assertions.Zero(t, obj)

Examples ¶

success: 0
failure: 1

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

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.Zero(t, 0)
	fmt.Println("passed")

}

Output:

passed

func Zerof ¶

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

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

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