Equality

Asserting Two Things Are Equal

Assertions

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

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

Empty

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

Examples

	assertions.Empty(t, obj)
	success: ""
	failure: "not empty"

Copy and click to open Go Playground

// real-world test would inject *testing.T from TestEmpty(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 TestEmpty(t *testing.T)
	success := assert.Empty(t, "")
	fmt.Printf("success: %t\n", success)

}

Copy and click to open Go Playground

// real-world test would inject *testing.T from TestEmpty(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 TestEmpty(t *testing.T)
	require.Empty(t, "")
	fmt.Println("passed")

}

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

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

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

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

Equal

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.

Examples

	assertions.Equal(t, 123, 123)
	success: 123, 123
	failure: 123, 456

Copy and click to open Go Playground

// real-world test would inject *testing.T from TestEqual(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 TestEqual(t *testing.T)
	success := assert.Equal(t, 123, 123)
	fmt.Printf("success: %t\n", success)

}

Copy and click to open Go Playground

// real-world test would inject *testing.T from TestEqual(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 TestEqual(t *testing.T)
	require.Equal(t, 123, 123)
	fmt.Println("passed")

}

Signature	Usage
`assert.Equal(t T, expected any, actual any, msgAndArgs ...any) bool`	package-level function
`assert.Equalf(t T, expected any, actual any, msg string, args ...any) bool`	formatted variant
`assert.(*Assertions).Equal(expected any, actual any) bool`	method variant
`assert.(*Assertions).Equalf(expected any, actual any, msg string, args ..any)`	method formatted variant

Signature	Usage
`require.Equal(t T, expected any, actual any, msgAndArgs ...any) bool`	package-level function
`require.Equalf(t T, expected any, actual any, msg string, args ...any) bool`	formatted variant
`require.(*Assertions).Equal(expected any, actual any) bool`	method variant
`require.(*Assertions).Equalf(expected any, actual any, msg string, args ..any)`	method formatted variant

Signature	Usage
`assertions.Equal(t T, expected any, actual any, msgAndArgs ...any) bool`	internal implementation

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

EqualExportedValues

EqualExportedValues asserts that the types of two objects are equal and their public fields are also equal.

This is useful for comparing structs that have private fields that could potentially differ.

Function equality cannot be determined and will always fail.

Examples

	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
	success: &dummyStruct{A: "a", b: 1}, &dummyStruct{A: "a", b: 2}
	failure: &dummyStruct{A: "a", b: 1}, &dummyStruct{A: "b", b: 1}

Copy and click to open Go Playground

// real-world test would inject *testing.T from TestEqualExportedValues(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 TestEqualExportedValues(t *testing.T)
	success := assert.EqualExportedValues(t, &dummyStruct{A: "a", b: 1}, &dummyStruct{A: "a", b: 2})
	fmt.Printf("success: %t\n", success)

}

type dummyStruct struct {
	A string
	b int
}

Copy and click to open Go Playground

// real-world test would inject *testing.T from TestEqualExportedValues(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 TestEqualExportedValues(t *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
}

Signature	Usage
`assert.EqualExportedValues(t T, expected any, actual any, msgAndArgs ...any) bool`	package-level function
`assert.EqualExportedValuesf(t T, expected any, actual any, msg string, args ...any) bool`	formatted variant
`assert.(*Assertions).EqualExportedValues(expected any, actual any) bool`	method variant
`assert.(*Assertions).EqualExportedValuesf(expected any, actual any, msg string, args ..any)`	method formatted variant

Signature	Usage
`require.EqualExportedValues(t T, expected any, actual any, msgAndArgs ...any) bool`	package-level function
`require.EqualExportedValuesf(t T, expected any, actual any, msg string, args ...any) bool`	formatted variant
`require.(*Assertions).EqualExportedValues(expected any, actual any) bool`	method variant
`require.(*Assertions).EqualExportedValuesf(expected any, actual any, msg string, args ..any)`	method formatted variant

Signature	Usage
`assertions.EqualExportedValues(t T, expected any, actual any, msgAndArgs ...any) bool`	internal implementation

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

EqualT[V comparable]

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

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

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

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

Examples

	assertions.EqualT(t, 123, 123)
	success: 123, 123
	failure: 123, 456

Copy and click to open Go Playground

// real-world test would inject *testing.T from TestEqualT(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 TestEqualT(t *testing.T)
	success := assert.EqualT(t, 123, 123)
	fmt.Printf("success: %t\n", success)

}

Copy and click to open Go Playground

// real-world test would inject *testing.T from TestEqualT(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 TestEqualT(t *testing.T)
	require.EqualT(t, 123, 123)
	fmt.Println("passed")

}

Signature	Usage
`assert.EqualT[V comparable](t T, expected V, actual V, msgAndArgs ...any) bool`	package-level function
`assert.EqualTf[V comparable](t T, expected V, actual V, msg string, args ...any) bool`	formatted variant

Signature	Usage
`require.EqualT[V comparable](t T, expected V, actual V, msgAndArgs ...any) bool`	package-level function
`require.EqualTf[V comparable](t T, expected V, actual V, msg string, args ...any) bool`	formatted variant

Signature	Usage
`assertions.EqualT[V comparable](t T, expected V, actual V, msgAndArgs ...any) bool`	internal implementation

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

EqualValues

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

Function equality cannot be determined and will always fail.

Examples

	assertions.EqualValues(t, uint32(123), int32(123))
	success: uint32(123), int32(123)
	failure: uint32(123), int32(456)

Copy and click to open Go Playground

// real-world test would inject *testing.T from TestEqualValues(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 TestEqualValues(t *testing.T)
	success := assert.EqualValues(t, uint32(123), int32(123))
	fmt.Printf("success: %t\n", success)

}

Copy and click to open Go Playground

// real-world test would inject *testing.T from TestEqualValues(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 TestEqualValues(t *testing.T)
	require.EqualValues(t, uint32(123), int32(123))
	fmt.Println("passed")

}

Signature	Usage
`assert.EqualValues(t T, expected any, actual any, msgAndArgs ...any) bool`	package-level function
`assert.EqualValuesf(t T, expected any, actual any, msg string, args ...any) bool`	formatted variant
`assert.(*Assertions).EqualValues(expected any, actual any) bool`	method variant
`assert.(*Assertions).EqualValuesf(expected any, actual any, msg string, args ..any)`	method formatted variant

Signature	Usage
`require.EqualValues(t T, expected any, actual any, msgAndArgs ...any) bool`	package-level function
`require.EqualValuesf(t T, expected any, actual any, msg string, args ...any) bool`	formatted variant
`require.(*Assertions).EqualValues(expected any, actual any) bool`	method variant
`require.(*Assertions).EqualValuesf(expected any, actual any, msg string, args ..any)`	method formatted variant

Signature	Usage
`assertions.EqualValues(t T, expected any, actual any, msgAndArgs ...any) bool`	internal implementation

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

Exactly

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

Examples

	assertions.Exactly(t, int32(123), int64(123))
	success: int32(123), int32(123)
	failure: int32(123), int64(123)

Copy and click to open Go Playground

// real-world test would inject *testing.T from TestExactly(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 TestExactly(t *testing.T)
	success := assert.Exactly(t, int32(123), int32(123))
	fmt.Printf("success: %t\n", success)

}

Copy and click to open Go Playground

// real-world test would inject *testing.T from TestExactly(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 TestExactly(t *testing.T)
	require.Exactly(t, int32(123), int32(123))
	fmt.Println("passed")

}

Signature	Usage
`assert.Exactly(t T, expected any, actual any, msgAndArgs ...any) bool`	package-level function
`assert.Exactlyf(t T, expected any, actual any, msg string, args ...any) bool`	formatted variant
`assert.(*Assertions).Exactly(expected any, actual any) bool`	method variant
`assert.(*Assertions).Exactlyf(expected any, actual any, msg string, args ..any)`	method formatted variant

Signature	Usage
`require.Exactly(t T, expected any, actual any, msgAndArgs ...any) bool`	package-level function
`require.Exactlyf(t T, expected any, actual any, msg string, args ...any) bool`	formatted variant
`require.(*Assertions).Exactly(expected any, actual any) bool`	method variant
`require.(*Assertions).Exactlyf(expected any, actual any, msg string, args ..any)`	method formatted variant

Signature	Usage
`assertions.Exactly(t T, expected any, actual any, msgAndArgs ...any) bool`	internal implementation

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

Nil

Nil asserts that the specified object is nil.

Examples

	assertions.Nil(t, err)
	success: nil
	failure: "not nil"

Copy and click to open Go Playground

// real-world test would inject *testing.T from TestNil(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 TestNil(t *testing.T)
	success := assert.Nil(t, nil)
	fmt.Printf("success: %t\n", success)

}

Copy and click to open Go Playground

// real-world test would inject *testing.T from TestNil(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 TestNil(t *testing.T)
	require.Nil(t, nil)
	fmt.Println("passed")

}

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

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

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

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

NotEmpty

NotEmpty asserts that the specified object is NOT Empty.

Examples

	if assert.NotEmpty(t, obj) {
		assertions.Equal(t, "two", obj[1](https://pkg.go.dev/github.com/go-openapi/testify/v2/assert#1))
	}
	success: "not empty"
	failure: ""

Copy and click to open Go Playground

// real-world test would inject *testing.T from TestNotEmpty(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 TestNotEmpty(t *testing.T)
	success := assert.NotEmpty(t, "not empty")
	fmt.Printf("success: %t\n", success)

}

Copy and click to open Go Playground

// real-world test would inject *testing.T from TestNotEmpty(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 TestNotEmpty(t *testing.T)
	require.NotEmpty(t, "not empty")
	fmt.Println("passed")

}

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

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

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

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

NotEqual

NotEqual asserts that the specified values are NOT equal.

Examples

	assertions.NotEqual(t, obj1, obj2)
Pointer variable equality is determined based on the equality of the
referenced values (as opposed to the memory addresses).
Function equality cannot be determined and will always fail.
	success: 123, 456
	failure: 123, 123

Copy and click to open Go Playground

// real-world test would inject *testing.T from TestNotEqual(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 TestNotEqual(t *testing.T)
	success := assert.NotEqual(t, 123, 456)
	fmt.Printf("success: %t\n", success)

}

Copy and click to open Go Playground

// real-world test would inject *testing.T from TestNotEqual(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 TestNotEqual(t *testing.T)
	require.NotEqual(t, 123, 456)
	fmt.Println("passed")

}

Signature	Usage
`assert.NotEqual(t T, expected any, actual any, msgAndArgs ...any) bool`	package-level function
`assert.NotEqualf(t T, expected any, actual any, msg string, args ...any) bool`	formatted variant
`assert.(*Assertions).NotEqual(expected any, actual any) bool`	method variant
`assert.(*Assertions).NotEqualf(expected any, actual any, msg string, args ..any)`	method formatted variant

Signature	Usage
`require.NotEqual(t T, expected any, actual any, msgAndArgs ...any) bool`	package-level function
`require.NotEqualf(t T, expected any, actual any, msg string, args ...any) bool`	formatted variant
`require.(*Assertions).NotEqual(expected any, actual any) bool`	method variant
`require.(*Assertions).NotEqualf(expected any, actual any, msg string, args ..any)`	method formatted variant

Signature	Usage
`assertions.NotEqual(t T, expected any, actual any, msgAndArgs ...any) bool`	internal implementation

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

NotEqualT[V comparable]

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

See EqualT.

Examples

	assertions.NotEqualT(t, obj1, obj2)
	success: 123, 456
	failure: 123, 123

Copy and click to open Go Playground

// real-world test would inject *testing.T from TestNotEqualT(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 TestNotEqualT(t *testing.T)
	success := assert.NotEqualT(t, 123, 456)
	fmt.Printf("success: %t\n", success)

}

Copy and click to open Go Playground

// real-world test would inject *testing.T from TestNotEqualT(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 TestNotEqualT(t *testing.T)
	require.NotEqualT(t, 123, 456)
	fmt.Println("passed")

}

Signature	Usage
`assert.NotEqualT[V comparable](t T, expected V, actual V, msgAndArgs ...any) bool`	package-level function
`assert.NotEqualTf[V comparable](t T, expected V, actual V, msg string, args ...any) bool`	formatted variant

Signature	Usage
`require.NotEqualT[V comparable](t T, expected V, actual V, msgAndArgs ...any) bool`	package-level function
`require.NotEqualTf[V comparable](t T, expected V, actual V, msg string, args ...any) bool`	formatted variant

Signature	Usage
`assertions.NotEqualT[V comparable](t T, expected V, actual V, msgAndArgs ...any) bool`	internal implementation

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

NotEqualValues

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

Function equality cannot be determined and will always fail.

Examples

	assertions.NotEqualValues(t, obj1, obj2)
	success: uint32(123), int32(456)
	failure: uint32(123), int32(123)

Copy and click to open Go Playground

// real-world test would inject *testing.T from TestNotEqualValues(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 TestNotEqualValues(t *testing.T)
	success := assert.NotEqualValues(t, uint32(123), int32(456))
	fmt.Printf("success: %t\n", success)

}

Copy and click to open Go Playground

// real-world test would inject *testing.T from TestNotEqualValues(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 TestNotEqualValues(t *testing.T)
	require.NotEqualValues(t, uint32(123), int32(456))
	fmt.Println("passed")

}

Signature	Usage
`assert.NotEqualValues(t T, expected any, actual any, msgAndArgs ...any) bool`	package-level function
`assert.NotEqualValuesf(t T, expected any, actual any, msg string, args ...any) bool`	formatted variant
`assert.(*Assertions).NotEqualValues(expected any, actual any) bool`	method variant
`assert.(*Assertions).NotEqualValuesf(expected any, actual any, msg string, args ..any)`	method formatted variant

Signature	Usage
`require.NotEqualValues(t T, expected any, actual any, msgAndArgs ...any) bool`	package-level function
`require.NotEqualValuesf(t T, expected any, actual any, msg string, args ...any) bool`	formatted variant
`require.(*Assertions).NotEqualValues(expected any, actual any) bool`	method variant
`require.(*Assertions).NotEqualValuesf(expected any, actual any, msg string, args ..any)`	method formatted variant

Signature	Usage
`assertions.NotEqualValues(t T, expected any, actual any, msgAndArgs ...any) bool`	internal implementation

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

NotNil

NotNil asserts that the specified object is not nil.

Examples

	assertions.NotNil(t, err)
	success: "not nil"
	failure: nil

Copy and click to open Go Playground

// real-world test would inject *testing.T from TestNotNil(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 TestNotNil(t *testing.T)
	success := assert.NotNil(t, "not nil")
	fmt.Printf("success: %t\n", success)

}

Copy and click to open Go Playground

// real-world test would inject *testing.T from TestNotNil(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 TestNotNil(t *testing.T)
	require.NotNil(t, "not nil")
	fmt.Println("passed")

}

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

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

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

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

NotSame

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

See Same.

Examples

	assertions.NotSame(t, ptr1, ptr2)
	success: &staticVar, ptr("static string")
	failure: &staticVar, staticVarPtr

Copy and click to open Go Playground

// real-world test would inject *testing.T from TestNotSame(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 TestNotSame(t *testing.T)
	success := assert.NotSame(t, &staticVar, ptr("static string"))
	fmt.Printf("success: %t\n", success)

}

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

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

	return &p
}

Copy and click to open Go Playground

// real-world test would inject *testing.T from TestNotSame(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 TestNotSame(t *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
}

Signature	Usage
`assert.NotSame(t T, expected any, actual any, msgAndArgs ...any) bool`	package-level function
`assert.NotSamef(t T, expected any, actual any, msg string, args ...any) bool`	formatted variant
`assert.(*Assertions).NotSame(expected any, actual any) bool`	method variant
`assert.(*Assertions).NotSamef(expected any, actual any, msg string, args ..any)`	method formatted variant

Signature	Usage
`require.NotSame(t T, expected any, actual any, msgAndArgs ...any) bool`	package-level function
`require.NotSamef(t T, expected any, actual any, msg string, args ...any) bool`	formatted variant
`require.(*Assertions).NotSame(expected any, actual any) bool`	method variant
`require.(*Assertions).NotSamef(expected any, actual any, msg string, args ..any)`	method formatted variant

Signature	Usage
`assertions.NotSame(t T, expected any, actual any, msgAndArgs ...any) bool`	internal implementation

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

NotSameT[P any]

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

See SameT.

Examples

	assertions.NotSameT(t, ptr1, ptr2)
	success: &staticVar, ptr("static string")
	failure: &staticVar, staticVarPtr

Copy and click to open Go Playground

// real-world test would inject *testing.T from TestNotSameT(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 TestNotSameT(t *testing.T)
	success := assert.NotSameT(t, &staticVar, ptr("static string"))
	fmt.Printf("success: %t\n", success)

}

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

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

	return &p
}

Copy and click to open Go Playground

// real-world test would inject *testing.T from TestNotSameT(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 TestNotSameT(t *testing.T)
	require.NotSameT(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
}

Signature	Usage
`assert.NotSameT[P any](t T, expected P, actual P, msgAndArgs ...any) bool`	package-level function
`assert.NotSameTf[P any](t T, expected P, actual P, msg string, args ...any) bool`	formatted variant

Signature	Usage
`require.NotSameT[P any](t T, expected P, actual P, msgAndArgs ...any) bool`	package-level function
`require.NotSameTf[P any](t T, expected P, actual P, msg string, args ...any) bool`	formatted variant

Signature	Usage
`assertions.NotSameT[P any](t T, expected P, actual P, msgAndArgs ...any) bool`	internal implementation

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

Same

Same asserts that two pointers reference the same object.

Both arguments must be pointer variables.

Pointer variable sameness is determined based on the equality of both type and value.

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

Examples

	assertions.Same(t, ptr1, ptr2)
	success: &staticVar, staticVarPtr
	failure: &staticVar, ptr("static string")

Copy and click to open Go Playground

// real-world test would inject *testing.T from TestSame(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 TestSame(t *testing.T)
	success := assert.Same(t, &staticVar, staticVarPtr)
	fmt.Printf("success: %t\n", success)

}

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

Copy and click to open Go Playground

// real-world test would inject *testing.T from TestSame(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 TestSame(t *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
)

Signature	Usage
`assert.Same(t T, expected any, actual any, msgAndArgs ...any) bool`	package-level function
`assert.Samef(t T, expected any, actual any, msg string, args ...any) bool`	formatted variant
`assert.(*Assertions).Same(expected any, actual any) bool`	method variant
`assert.(*Assertions).Samef(expected any, actual any, msg string, args ..any)`	method formatted variant

Signature	Usage
`require.Same(t T, expected any, actual any, msgAndArgs ...any) bool`	package-level function
`require.Samef(t T, expected any, actual any, msg string, args ...any) bool`	formatted variant
`require.(*Assertions).Same(expected any, actual any) bool`	method variant
`require.(*Assertions).Samef(expected any, actual any, msg string, args ..any)`	method formatted variant

Signature	Usage
`assertions.Same(t T, expected any, actual any, msgAndArgs ...any) bool`	internal implementation

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

SameT[P any]

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

See Same.

Examples

	assertions.SameT(t, ptr1, ptr2)
	success: &staticVar, staticVarPtr
	failure: &staticVar, ptr("static string")

Copy and click to open Go Playground

// real-world test would inject *testing.T from TestSameT(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 TestSameT(t *testing.T)
	success := assert.SameT(t, &staticVar, staticVarPtr)
	fmt.Printf("success: %t\n", success)

}

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

Copy and click to open Go Playground

// real-world test would inject *testing.T from TestSameT(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 TestSameT(t *testing.T)
	require.SameT(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
)

Signature	Usage
`assert.SameT[P any](t T, expected P, actual P, msgAndArgs ...any) bool`	package-level function
`assert.SameTf[P any](t T, expected P, actual P, msg string, args ...any) bool`	formatted variant

Signature	Usage
`require.SameT[P any](t T, expected P, actual P, msgAndArgs ...any) bool`	package-level function
`require.SameTf[P any](t T, expected P, actual P, msg string, args ...any) bool`	formatted variant

Signature	Usage
`assertions.SameT[P any](t T, expected P, actual P, msgAndArgs ...any) bool`	internal implementation

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

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