Type

Asserting Types Rather Than Values

Assertions

All links point to https://pkg.go.dev/github.com/go-openapi/testify/v2

This domain exposes 10 functionalities. Generic assertions are marked with a .

Implements

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

Examples

	assertions.Implements(t, (*MyInterface)(nil), new(MyObject))
	success: ptr(dummyInterface), new(testing.T)
	failure: (*error)(nil), new(testing.T)

Copy and click to open Go Playground

// real-world test would inject *testing.T from TestImplements(t *testing.T)
package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestImplements(t *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
}

Copy and click to open Go Playground

// real-world test would inject *testing.T from TestImplements(t *testing.T)
package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestImplements(t *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
}

Signature	Usage
`assert.Implements(t T, interfaceObject any, object any, msgAndArgs ...any) bool`	package-level function
`assert.Implementsf(t T, interfaceObject any, object any, msg string, args ...any) bool`	formatted variant
`assert.(*Assertions).Implements(interfaceObject any, object any) bool`	method variant
`assert.(*Assertions).Implementsf(interfaceObject any, object any, msg string, args ..any)`	method formatted variant

Signature	Usage
`require.Implements(t T, interfaceObject any, object any, msgAndArgs ...any) bool`	package-level function
`require.Implementsf(t T, interfaceObject any, object any, msg string, args ...any) bool`	formatted variant
`require.(*Assertions).Implements(interfaceObject any, object any) bool`	method variant
`require.(*Assertions).Implementsf(interfaceObject any, object any, msg string, args ..any)`	method formatted variant

Signature	Usage
`assertions.Implements(t T, interfaceObject any, object any, msgAndArgs ...any) bool`	internal implementation

Source: github.com/go-openapi/testify/v2/internal/assertions#Implements

IsNotOfTypeT[EType any]

IsNotOfTypeT asserts that an object is not of a given type.

Examples

	assertions.IsOfType[MyType](t,myVar)
	success: 123.123
	failure: myType(123.123)

Copy and click to open Go Playground

// real-world test would inject *testing.T from TestIsNotOfTypeT(t *testing.T)
package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestIsNotOfTypeT(t *testing.T)
	success := assert.IsNotOfTypeT[myType](t, 123.123)
	fmt.Printf("success: %t\n", success)

}

type myType float64

Copy and click to open Go Playground

// real-world test would inject *testing.T from TestIsNotOfTypeT(t *testing.T)
package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestIsNotOfTypeT(t *testing.T)
	require.IsNotOfTypeT[myType](t, 123.123)
	fmt.Println("passed")

}

type myType float64

Signature	Usage
`assert.IsNotOfTypeT[EType any](t T, object any, msgAndArgs ...any) bool`	package-level function
`assert.IsNotOfTypeTf[EType any](t T, object any, msg string, args ...any) bool`	formatted variant

Signature	Usage
`require.IsNotOfTypeT[EType any](t T, object any, msgAndArgs ...any) bool`	package-level function
`require.IsNotOfTypeTf[EType any](t T, object any, msg string, args ...any) bool`	formatted variant

Signature	Usage
`assertions.IsNotOfTypeT[EType any](t T, object any, msgAndArgs ...any) bool`	internal implementation

Source: github.com/go-openapi/testify/v2/internal/assertions#IsNotOfTypeT

IsNotType

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

Examples

	assertions.IsNotType(t, &NotMyStruct{}, &MyStruct{})
	success: int32(123), int64(456)
	failure: 123, 456

Copy and click to open Go Playground

// real-world test would inject *testing.T from TestIsNotType(t *testing.T)
package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestIsNotType(t *testing.T)
	success := assert.IsNotType(t, int32(123), int64(456))
	fmt.Printf("success: %t\n", success)

}

Copy and click to open Go Playground

// real-world test would inject *testing.T from TestIsNotType(t *testing.T)
package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestIsNotType(t *testing.T)
	require.IsNotType(t, int32(123), int64(456))
	fmt.Println("passed")

}

Signature	Usage
`assert.IsNotType(t T, theType any, object any, msgAndArgs ...any) bool`	package-level function
`assert.IsNotTypef(t T, theType any, object any, msg string, args ...any) bool`	formatted variant
`assert.(*Assertions).IsNotType(theType any, object any) bool`	method variant
`assert.(*Assertions).IsNotTypef(theType any, object any, msg string, args ..any)`	method formatted variant

Signature	Usage
`require.IsNotType(t T, theType any, object any, msgAndArgs ...any) bool`	package-level function
`require.IsNotTypef(t T, theType any, object any, msg string, args ...any) bool`	formatted variant
`require.(*Assertions).IsNotType(theType any, object any) bool`	method variant
`require.(*Assertions).IsNotTypef(theType any, object any, msg string, args ..any)`	method formatted variant

Signature	Usage
`assertions.IsNotType(t T, theType any, object any, msgAndArgs ...any) bool`	internal implementation

Source: github.com/go-openapi/testify/v2/internal/assertions#IsNotType

IsOfTypeT[EType any]

IsOfTypeT asserts that an object is of a given type.

Examples

	assertions.IsOfTypeT[MyType](t,myVar)
	success: myType(123.123)
	failure: 123.123

Copy and click to open Go Playground

// real-world test would inject *testing.T from TestIsOfTypeT(t *testing.T)
package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestIsOfTypeT(t *testing.T)
	success := assert.IsOfTypeT[myType](t, myType(123.123))
	fmt.Printf("success: %t\n", success)

}

type myType float64

Copy and click to open Go Playground

// real-world test would inject *testing.T from TestIsOfTypeT(t *testing.T)
package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestIsOfTypeT(t *testing.T)
	require.IsOfTypeT[myType](t, myType(123.123))
	fmt.Println("passed")

}

type myType float64

Signature	Usage
`assert.IsOfTypeT[EType any](t T, object any, msgAndArgs ...any) bool`	package-level function
`assert.IsOfTypeTf[EType any](t T, object any, msg string, args ...any) bool`	formatted variant

Signature	Usage
`require.IsOfTypeT[EType any](t T, object any, msgAndArgs ...any) bool`	package-level function
`require.IsOfTypeTf[EType any](t T, object any, msg string, args ...any) bool`	formatted variant

Signature	Usage
`assertions.IsOfTypeT[EType any](t T, object any, msgAndArgs ...any) bool`	internal implementation

Source: github.com/go-openapi/testify/v2/internal/assertions#IsOfTypeT

IsType

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

Examples

	assertions.IsType(t, &MyStruct{}, &MyStruct{})
	success: 123, 456
	failure: int32(123), int64(456)

Copy and click to open Go Playground

// real-world test would inject *testing.T from TestIsType(t *testing.T)
package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestIsType(t *testing.T)
	success := assert.IsType(t, 123, 456)
	fmt.Printf("success: %t\n", success)

}

Copy and click to open Go Playground

// real-world test would inject *testing.T from TestIsType(t *testing.T)
package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestIsType(t *testing.T)
	require.IsType(t, 123, 456)
	fmt.Println("passed")

}

Signature	Usage
`assert.IsType(t T, expectedType any, object any, msgAndArgs ...any) bool`	package-level function
`assert.IsTypef(t T, expectedType any, object any, msg string, args ...any) bool`	formatted variant
`assert.(*Assertions).IsType(expectedType any, object any) bool`	method variant
`assert.(*Assertions).IsTypef(expectedType any, object any, msg string, args ..any)`	method formatted variant

Signature	Usage
`require.IsType(t T, expectedType any, object any, msgAndArgs ...any) bool`	package-level function
`require.IsTypef(t T, expectedType any, object any, msg string, args ...any) bool`	formatted variant
`require.(*Assertions).IsType(expectedType any, object any) bool`	method variant
`require.(*Assertions).IsTypef(expectedType any, object any, msg string, args ..any)`	method formatted variant

Signature	Usage
`assertions.IsType(t T, expectedType any, object any, msgAndArgs ...any) bool`	internal implementation

Source: github.com/go-openapi/testify/v2/internal/assertions#IsType

Kind

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.

Examples

	assertions.Kind(t, reflect.String, "Hello World")
	success: reflect.String, "hello"
	failure: reflect.String, 0

Copy and click to open Go Playground

// real-world test would inject *testing.T from TestKind(t *testing.T)
package main

import (
	"fmt"
	"reflect"
	"testing"

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

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestKind(t *testing.T)
	success := assert.Kind(t, reflect.String, "hello")
	fmt.Printf("success: %t\n", success)

}

Copy and click to open Go Playground

// real-world test would inject *testing.T from TestKind(t *testing.T)
package main

import (
	"fmt"
	"reflect"
	"testing"

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

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestKind(t *testing.T)
	require.Kind(t, reflect.String, "hello")
	fmt.Println("passed")

}

Signature	Usage
`assert.Kind(t T, expectedKind reflect.Kind, object any, msgAndArgs ...any) bool`	package-level function
`assert.Kindf(t T, expectedKind reflect.Kind, object any, msg string, args ...any) bool`	formatted variant
`assert.(*Assertions).Kind(expectedKind reflect.Kind, object any) bool`	method variant
`assert.(*Assertions).Kindf(expectedKind reflect.Kind, object any, msg string, args ..any)`	method formatted variant

Signature	Usage
`require.Kind(t T, expectedKind reflect.Kind, object any, msgAndArgs ...any) bool`	package-level function
`require.Kindf(t T, expectedKind reflect.Kind, object any, msg string, args ...any) bool`	formatted variant
`require.(*Assertions).Kind(expectedKind reflect.Kind, object any) bool`	method variant
`require.(*Assertions).Kindf(expectedKind reflect.Kind, object any, msg string, args ..any)`	method formatted variant

Signature	Usage
`assertions.Kind(t T, expectedKind reflect.Kind, object any, msgAndArgs ...any) bool`	internal implementation

Source: github.com/go-openapi/testify/v2/internal/assertions#Kind

NotImplements

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

Examples

	assertions.NotImplements(t, (*MyInterface)(nil), new(MyObject))
	success: (*error)(nil), new(testing.T)
	failure: ptr(dummyInterface), new(testing.T)

Copy and click to open Go Playground

// real-world test would inject *testing.T from TestNotImplements(t *testing.T)
package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestNotImplements(t *testing.T)
	success := assert.NotImplements(t, (*error)(nil), new(testing.T))
	fmt.Printf("success: %t\n", success)

}

Copy and click to open Go Playground

// real-world test would inject *testing.T from TestNotImplements(t *testing.T)
package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestNotImplements(t *testing.T)
	require.NotImplements(t, (*error)(nil), new(testing.T))
	fmt.Println("passed")

}

Signature	Usage
`assert.NotImplements(t T, interfaceObject any, object any, msgAndArgs ...any) bool`	package-level function
`assert.NotImplementsf(t T, interfaceObject any, object any, msg string, args ...any) bool`	formatted variant
`assert.(*Assertions).NotImplements(interfaceObject any, object any) bool`	method variant
`assert.(*Assertions).NotImplementsf(interfaceObject any, object any, msg string, args ..any)`	method formatted variant

Signature	Usage
`require.NotImplements(t T, interfaceObject any, object any, msgAndArgs ...any) bool`	package-level function
`require.NotImplementsf(t T, interfaceObject any, object any, msg string, args ...any) bool`	formatted variant
`require.(*Assertions).NotImplements(interfaceObject any, object any) bool`	method variant
`require.(*Assertions).NotImplementsf(interfaceObject any, object any, msg string, args ..any)`	method formatted variant

Signature	Usage
`assertions.NotImplements(t T, interfaceObject any, object any, msgAndArgs ...any) bool`	internal implementation

Source: github.com/go-openapi/testify/v2/internal/assertions#NotImplements

NotKind

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.

Examples

	assertions.NotKind(t, reflect.Int, "Hello World")
	success: reflect.String, 0
	failure: reflect.String, "hello"

Copy and click to open Go Playground

// real-world test would inject *testing.T from TestNotKind(t *testing.T)
package main

import (
	"fmt"
	"reflect"
	"testing"

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

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestNotKind(t *testing.T)
	success := assert.NotKind(t, reflect.String, 0)
	fmt.Printf("success: %t\n", success)

}

Copy and click to open Go Playground

// real-world test would inject *testing.T from TestNotKind(t *testing.T)
package main

import (
	"fmt"
	"reflect"
	"testing"

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

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestNotKind(t *testing.T)
	require.NotKind(t, reflect.String, 0)
	fmt.Println("passed")

}

Signature	Usage
`assert.NotKind(t T, expectedKind reflect.Kind, object any, msgAndArgs ...any) bool`	package-level function
`assert.NotKindf(t T, expectedKind reflect.Kind, object any, msg string, args ...any) bool`	formatted variant
`assert.(*Assertions).NotKind(expectedKind reflect.Kind, object any) bool`	method variant
`assert.(*Assertions).NotKindf(expectedKind reflect.Kind, object any, msg string, args ..any)`	method formatted variant

Signature	Usage
`require.NotKind(t T, expectedKind reflect.Kind, object any, msgAndArgs ...any) bool`	package-level function
`require.NotKindf(t T, expectedKind reflect.Kind, object any, msg string, args ...any) bool`	formatted variant
`require.(*Assertions).NotKind(expectedKind reflect.Kind, object any) bool`	method variant
`require.(*Assertions).NotKindf(expectedKind reflect.Kind, object any, msg string, args ..any)`	method formatted variant

Signature	Usage
`assertions.NotKind(t T, expectedKind reflect.Kind, object any, msgAndArgs ...any) bool`	internal implementation

Source: github.com/go-openapi/testify/v2/internal/assertions#NotKind

NotZero

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

Examples

	assertions.NotZero(t, obj)
	success: 1
	failure: 0

Copy and click to open Go Playground

// real-world test would inject *testing.T from TestNotZero(t *testing.T)
package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestNotZero(t *testing.T)
	success := assert.NotZero(t, 1)
	fmt.Printf("success: %t\n", success)

}

Copy and click to open Go Playground

// real-world test would inject *testing.T from TestNotZero(t *testing.T)
package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestNotZero(t *testing.T)
	require.NotZero(t, 1)
	fmt.Println("passed")

}

Signature	Usage
`assert.NotZero(t T, i any, msgAndArgs ...any) bool`	package-level function
`assert.NotZerof(t T, i any, msg string, args ...any) bool`	formatted variant
`assert.(*Assertions).NotZero(i any) bool`	method variant
`assert.(*Assertions).NotZerof(i any, msg string, args ..any)`	method formatted variant

Signature	Usage
`require.NotZero(t T, i any, msgAndArgs ...any) bool`	package-level function
`require.NotZerof(t T, i any, msg string, args ...any) bool`	formatted variant
`require.(*Assertions).NotZero(i any) bool`	method variant
`require.(*Assertions).NotZerof(i any, msg string, args ..any)`	method formatted variant

Signature	Usage
`assertions.NotZero(t T, i any, msgAndArgs ...any) bool`	internal implementation

Source: github.com/go-openapi/testify/v2/internal/assertions#NotZero

Zero

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

Examples

	assertions.Zero(t, obj)
	success: 0
	failure: 1

Copy and click to open Go Playground

// real-world test would inject *testing.T from TestZero(t *testing.T)
package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestZero(t *testing.T)
	success := assert.Zero(t, 0)
	fmt.Printf("success: %t\n", success)

}

Copy and click to open Go Playground

// real-world test would inject *testing.T from TestZero(t *testing.T)
package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestZero(t *testing.T)
	require.Zero(t, 0)
	fmt.Println("passed")

}

Signature	Usage
`assert.Zero(t T, i any, msgAndArgs ...any) bool`	package-level function
`assert.Zerof(t T, i any, msg string, args ...any) bool`	formatted variant
`assert.(*Assertions).Zero(i any) bool`	method variant
`assert.(*Assertions).Zerof(i any, msg string, args ..any)`	method formatted variant

Signature	Usage
`require.Zero(t T, i any, msgAndArgs ...any) bool`	package-level function
`require.Zerof(t T, i any, msg string, args ...any) bool`	formatted variant
`require.(*Assertions).Zero(i any) bool`	method variant
`require.(*Assertions).Zerof(i any, msg string, args ..any)`	method formatted variant

Signature	Usage
`assertions.Zero(t T, i any, msgAndArgs ...any) bool`	internal implementation

Source: github.com/go-openapi/testify/v2/internal/assertions#Zero

Generated with github.com/go-openapi/testify/codegen/v2