// Code generated by testifylint/internal/testgen. DO NOT EDIT.

package expectedactual

import (
	"encoding/json"
	"io"
	"net/http"
	"testing"
	"time"

	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
)

type user struct {
	Name string
	id   uint64
}

type testCase struct{ expected string } //
func (c testCase) exp() string          { return c.expected }
func (c testCase) expPtr() *string      { return &c.expected }

func TestExpectedActualChecker(t *testing.T) {
	var expected string
	var expectedPtr *string
	var tt testCase
	var ttPtr *testCase
	expectedVal := func() any { return nil }
	var expectedObj struct{ Val int }
	var expectedObjPtr = &expectedObj
	var expectedFields []string

	var result any

	// Invalid.
	{
		assert.Equal(t, result, expected)                                                             // want "expected-actual: need to reverse actual and expected values"
		assert.Equalf(t, result, expected, "msg with args %d %s", 42, "42")                           // want "expected-actual: need to reverse actual and expected values"
		assert.Equal(t, result, expectedObj.Val)                                                      // want "expected-actual: need to reverse actual and expected values"
		assert.Equalf(t, result, expectedObj.Val, "msg with args %d %s", 42, "42")                    // want "expected-actual: need to reverse actual and expected values"
		assert.Equal(t, result, tt.expected)                                                          // want "expected-actual: need to reverse actual and expected values"
		assert.Equalf(t, result, tt.expected, "msg with args %d %s", 42, "42")                        // want "expected-actual: need to reverse actual and expected values"
		assert.Equal(t, result, tt.exp())                                                             // want "expected-actual: need to reverse actual and expected values"
		assert.Equalf(t, result, tt.exp(), "msg with args %d %s", 42, "42")                           // want "expected-actual: need to reverse actual and expected values"
		assert.Equal(t, result, tt.expPtr())                                                          // want "expected-actual: need to reverse actual and expected values"
		assert.Equalf(t, result, tt.expPtr(), "msg with args %d %s", 42, "42")                        // want "expected-actual: need to reverse actual and expected values"
		assert.Equal(t, result, expectedVal())                                                        // want "expected-actual: need to reverse actual and expected values"
		assert.Equalf(t, result, expectedVal(), "msg with args %d %s", 42, "42")                      // want "expected-actual: need to reverse actual and expected values"
		assert.Equal(t, result, []int{1, 2, 3})                                                       // want "expected-actual: need to reverse actual and expected values"
		assert.Equalf(t, result, []int{1, 2, 3}, "msg with args %d %s", 42, "42")                     // want "expected-actual: need to reverse actual and expected values"
		assert.Equal(t, result, [3]int{1, 2, 3})                                                      // want "expected-actual: need to reverse actual and expected values"
		assert.Equalf(t, result, [3]int{1, 2, 3}, "msg with args %d %s", 42, "42")                    // want "expected-actual: need to reverse actual and expected values"
		assert.Equal(t, result, map[string]int{"0": 1})                                               // want "expected-actual: need to reverse actual and expected values"
		assert.Equalf(t, result, map[string]int{"0": 1}, "msg with args %d %s", 42, "42")             // want "expected-actual: need to reverse actual and expected values"
		assert.Equal(t, result, user{Name: "Rob"})                                                    // want "expected-actual: need to reverse actual and expected values"
		assert.Equalf(t, result, user{Name: "Rob"}, "msg with args %d %s", 42, "42")                  // want "expected-actual: need to reverse actual and expected values"
		assert.Equal(t, result, struct{ Name string }{Name: "Rob"})                                   // want "expected-actual: need to reverse actual and expected values"
		assert.Equalf(t, result, struct{ Name string }{Name: "Rob"}, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
		assert.Equal(t, result, nil)                                                                  // want "expected-actual: need to reverse actual and expected values"
		assert.Equalf(t, result, nil, "msg with args %d %s", 42, "42")                                // want "expected-actual: need to reverse actual and expected values"
		assert.Equal(t, result, &expected)                                                            // want "expected-actual: need to reverse actual and expected values"
		assert.Equalf(t, result, &expected, "msg with args %d %s", 42, "42")                          // want "expected-actual: need to reverse actual and expected values"
		assert.Equal(t, result, &expectedObj.Val)                                                     // want "expected-actual: need to reverse actual and expected values"
		assert.Equalf(t, result, &expectedObj.Val, "msg with args %d %s", 42, "42")                   // want "expected-actual: need to reverse actual and expected values"
		assert.Equal(t, result, &(expectedObj.Val))                                                   // want "expected-actual: need to reverse actual and expected values"
		assert.Equalf(t, result, &(expectedObj.Val), "msg with args %d %s", 42, "42")                 // want "expected-actual: need to reverse actual and expected values"
		assert.Equal(t, result, &tt.expected)                                                         // want "expected-actual: need to reverse actual and expected values"
		assert.Equalf(t, result, &tt.expected, "msg with args %d %s", 42, "42")                       // want "expected-actual: need to reverse actual and expected values"
		assert.Equal(t, result, &(tt.expected))                                                       // want "expected-actual: need to reverse actual and expected values"
		assert.Equalf(t, result, &(tt.expected), "msg with args %d %s", 42, "42")                     // want "expected-actual: need to reverse actual and expected values"
		assert.Equal(t, result, &user{Name: "Rob"})                                                   // want "expected-actual: need to reverse actual and expected values"
		assert.Equalf(t, result, &user{Name: "Rob"}, "msg with args %d %s", 42, "42")                 // want "expected-actual: need to reverse actual and expected values"
		assert.Equal(t, result, *expectedPtr)                                                         // want "expected-actual: need to reverse actual and expected values"
		assert.Equalf(t, result, *expectedPtr, "msg with args %d %s", 42, "42")                       // want "expected-actual: need to reverse actual and expected values"
		assert.Equal(t, result, expectedObjPtr.Val)                                                   // want "expected-actual: need to reverse actual and expected values"
		assert.Equalf(t, result, expectedObjPtr.Val, "msg with args %d %s", 42, "42")                 // want "expected-actual: need to reverse actual and expected values"
		assert.Equal(t, result, *tt.expPtr())                                                         // want "expected-actual: need to reverse actual and expected values"
		assert.Equalf(t, result, *tt.expPtr(), "msg with args %d %s", 42, "42")                       // want "expected-actual: need to reverse actual and expected values"
		assert.Equal(t, result, *(tt.expPtr()))                                                       // want "expected-actual: need to reverse actual and expected values"
		assert.Equalf(t, result, *(tt.expPtr()), "msg with args %d %s", 42, "42")                     // want "expected-actual: need to reverse actual and expected values"
		assert.Equal(t, result, ttPtr.expected)                                                       // want "expected-actual: need to reverse actual and expected values"
		assert.Equalf(t, result, ttPtr.expected, "msg with args %d %s", 42, "42")                     // want "expected-actual: need to reverse actual and expected values"
		assert.Equal(t, result, len(expectedFields))                                                  // want "expected-actual: need to reverse actual and expected values"
		assert.Equalf(t, result, len(expectedFields), "msg with args %d %s", 42, "42")                // want "expected-actual: need to reverse actual and expected values"
		assert.Equal(t, result, 42)                                                                   // want "expected-actual: need to reverse actual and expected values"
		assert.Equalf(t, result, 42, "msg with args %d %s", 42, "42")                                 // want "expected-actual: need to reverse actual and expected values"
		assert.Equal(t, result, 3.14)                                                                 // want "expected-actual: need to reverse actual and expected values"
		assert.Equalf(t, result, 3.14, "msg with args %d %s", 42, "42")                               // want "expected-actual: need to reverse actual and expected values"
		assert.Equal(t, result, 0.707i)                                                               // want "expected-actual: need to reverse actual and expected values"
		assert.Equalf(t, result, 0.707i, "msg with args %d %s", 42, "42")                             // want "expected-actual: need to reverse actual and expected values"
		assert.Equal(t, result, "raw string")                                                         // want "expected-actual: need to reverse actual and expected values"
		assert.Equalf(t, result, "raw string", "msg with args %d %s", 42, "42")                       // want "expected-actual: need to reverse actual and expected values"
		assert.Equal(t, result, '\U00101234')                                                         // want "expected-actual: need to reverse actual and expected values"
		assert.Equalf(t, result, '\U00101234', "msg with args %d %s", 42, "42")                       // want "expected-actual: need to reverse actual and expected values"
		assert.Equal(t, result, true)                                                                 // want "expected-actual: need to reverse actual and expected values"
		assert.Equalf(t, result, true, "msg with args %d %s", 42, "42")                               // want "expected-actual: need to reverse actual and expected values"

		assert.NotEqual(t, result, expected)                                                             // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqualf(t, result, expected, "msg with args %d %s", 42, "42")                           // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqual(t, result, expectedObj.Val)                                                      // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqualf(t, result, expectedObj.Val, "msg with args %d %s", 42, "42")                    // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqual(t, result, tt.expected)                                                          // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqualf(t, result, tt.expected, "msg with args %d %s", 42, "42")                        // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqual(t, result, tt.exp())                                                             // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqualf(t, result, tt.exp(), "msg with args %d %s", 42, "42")                           // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqual(t, result, tt.expPtr())                                                          // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqualf(t, result, tt.expPtr(), "msg with args %d %s", 42, "42")                        // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqual(t, result, expectedVal())                                                        // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqualf(t, result, expectedVal(), "msg with args %d %s", 42, "42")                      // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqual(t, result, []int{1, 2, 3})                                                       // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqualf(t, result, []int{1, 2, 3}, "msg with args %d %s", 42, "42")                     // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqual(t, result, [3]int{1, 2, 3})                                                      // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqualf(t, result, [3]int{1, 2, 3}, "msg with args %d %s", 42, "42")                    // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqual(t, result, map[string]int{"0": 1})                                               // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqualf(t, result, map[string]int{"0": 1}, "msg with args %d %s", 42, "42")             // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqual(t, result, user{Name: "Rob"})                                                    // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqualf(t, result, user{Name: "Rob"}, "msg with args %d %s", 42, "42")                  // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqual(t, result, struct{ Name string }{Name: "Rob"})                                   // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqualf(t, result, struct{ Name string }{Name: "Rob"}, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqual(t, result, nil)                                                                  // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqualf(t, result, nil, "msg with args %d %s", 42, "42")                                // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqual(t, result, &expected)                                                            // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqualf(t, result, &expected, "msg with args %d %s", 42, "42")                          // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqual(t, result, &expectedObj.Val)                                                     // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqualf(t, result, &expectedObj.Val, "msg with args %d %s", 42, "42")                   // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqual(t, result, &(expectedObj.Val))                                                   // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqualf(t, result, &(expectedObj.Val), "msg with args %d %s", 42, "42")                 // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqual(t, result, &tt.expected)                                                         // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqualf(t, result, &tt.expected, "msg with args %d %s", 42, "42")                       // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqual(t, result, &(tt.expected))                                                       // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqualf(t, result, &(tt.expected), "msg with args %d %s", 42, "42")                     // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqual(t, result, &user{Name: "Rob"})                                                   // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqualf(t, result, &user{Name: "Rob"}, "msg with args %d %s", 42, "42")                 // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqual(t, result, *expectedPtr)                                                         // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqualf(t, result, *expectedPtr, "msg with args %d %s", 42, "42")                       // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqual(t, result, expectedObjPtr.Val)                                                   // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqualf(t, result, expectedObjPtr.Val, "msg with args %d %s", 42, "42")                 // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqual(t, result, *tt.expPtr())                                                         // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqualf(t, result, *tt.expPtr(), "msg with args %d %s", 42, "42")                       // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqual(t, result, *(tt.expPtr()))                                                       // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqualf(t, result, *(tt.expPtr()), "msg with args %d %s", 42, "42")                     // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqual(t, result, ttPtr.expected)                                                       // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqualf(t, result, ttPtr.expected, "msg with args %d %s", 42, "42")                     // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqual(t, result, len(expectedFields))                                                  // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqualf(t, result, len(expectedFields), "msg with args %d %s", 42, "42")                // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqual(t, result, 42)                                                                   // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqualf(t, result, 42, "msg with args %d %s", 42, "42")                                 // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqual(t, result, 3.14)                                                                 // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqualf(t, result, 3.14, "msg with args %d %s", 42, "42")                               // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqual(t, result, 0.707i)                                                               // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqualf(t, result, 0.707i, "msg with args %d %s", 42, "42")                             // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqual(t, result, "raw string")                                                         // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqualf(t, result, "raw string", "msg with args %d %s", 42, "42")                       // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqual(t, result, '\U00101234')                                                         // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqualf(t, result, '\U00101234', "msg with args %d %s", 42, "42")                       // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqual(t, result, true)                                                                 // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqualf(t, result, true, "msg with args %d %s", 42, "42")                               // want "expected-actual: need to reverse actual and expected values"
	}

	// Valid.
	{
		assert.Equal(t, expected, result)
		assert.Equalf(t, expected, result, "msg with args %d %s", 42, "42")
		assert.Equal(t, expectedObj.Val, result)
		assert.Equalf(t, expectedObj.Val, result, "msg with args %d %s", 42, "42")
		assert.Equal(t, tt.expected, result)
		assert.Equalf(t, tt.expected, result, "msg with args %d %s", 42, "42")
		assert.Equal(t, tt.exp(), result)
		assert.Equalf(t, tt.exp(), result, "msg with args %d %s", 42, "42")
		assert.Equal(t, tt.expPtr(), result)
		assert.Equalf(t, tt.expPtr(), result, "msg with args %d %s", 42, "42")
		assert.Equal(t, expectedVal(), result)
		assert.Equalf(t, expectedVal(), result, "msg with args %d %s", 42, "42")
		assert.Equal(t, []int{1, 2, 3}, result)
		assert.Equalf(t, []int{1, 2, 3}, result, "msg with args %d %s", 42, "42")
		assert.Equal(t, [3]int{1, 2, 3}, result)
		assert.Equalf(t, [3]int{1, 2, 3}, result, "msg with args %d %s", 42, "42")
		assert.Equal(t, map[string]int{"0": 1}, result)
		assert.Equalf(t, map[string]int{"0": 1}, result, "msg with args %d %s", 42, "42")
		assert.Equal(t, user{Name: "Rob"}, result)
		assert.Equalf(t, user{Name: "Rob"}, result, "msg with args %d %s", 42, "42")
		assert.Equal(t, struct{ Name string }{Name: "Rob"}, result)
		assert.Equalf(t, struct{ Name string }{Name: "Rob"}, result, "msg with args %d %s", 42, "42")
		assert.Equal(t, nil, result)
		assert.Equalf(t, nil, result, "msg with args %d %s", 42, "42")
		assert.Equal(t, &expected, result)
		assert.Equalf(t, &expected, result, "msg with args %d %s", 42, "42")
		assert.Equal(t, &expectedObj.Val, result)
		assert.Equalf(t, &expectedObj.Val, result, "msg with args %d %s", 42, "42")
		assert.Equal(t, &(expectedObj.Val), result)
		assert.Equalf(t, &(expectedObj.Val), result, "msg with args %d %s", 42, "42")
		assert.Equal(t, &tt.expected, result)
		assert.Equalf(t, &tt.expected, result, "msg with args %d %s", 42, "42")
		assert.Equal(t, &(tt.expected), result)
		assert.Equalf(t, &(tt.expected), result, "msg with args %d %s", 42, "42")
		assert.Equal(t, &user{Name: "Rob"}, result)
		assert.Equalf(t, &user{Name: "Rob"}, result, "msg with args %d %s", 42, "42")
		assert.Equal(t, *expectedPtr, result)
		assert.Equalf(t, *expectedPtr, result, "msg with args %d %s", 42, "42")
		assert.Equal(t, expectedObjPtr.Val, result)
		assert.Equalf(t, expectedObjPtr.Val, result, "msg with args %d %s", 42, "42")
		assert.Equal(t, *tt.expPtr(), result)
		assert.Equalf(t, *tt.expPtr(), result, "msg with args %d %s", 42, "42")
		assert.Equal(t, *(tt.expPtr()), result)
		assert.Equalf(t, *(tt.expPtr()), result, "msg with args %d %s", 42, "42")
		assert.Equal(t, ttPtr.expected, result)
		assert.Equalf(t, ttPtr.expected, result, "msg with args %d %s", 42, "42")
		assert.Equal(t, len(expectedFields), result)
		assert.Equalf(t, len(expectedFields), result, "msg with args %d %s", 42, "42")
		assert.Equal(t, 42, result)
		assert.Equalf(t, 42, result, "msg with args %d %s", 42, "42")
		assert.Equal(t, 3.14, result)
		assert.Equalf(t, 3.14, result, "msg with args %d %s", 42, "42")
		assert.Equal(t, 0.707i, result)
		assert.Equalf(t, 0.707i, result, "msg with args %d %s", 42, "42")
		assert.Equal(t, "raw string", result)
		assert.Equalf(t, "raw string", result, "msg with args %d %s", 42, "42")
		assert.Equal(t, '\U00101234', result)
		assert.Equalf(t, '\U00101234', result, "msg with args %d %s", 42, "42")
		assert.Equal(t, true, result)
		assert.Equalf(t, true, result, "msg with args %d %s", 42, "42")

		assert.NotEqual(t, expected, result)
		assert.NotEqualf(t, expected, result, "msg with args %d %s", 42, "42")
		assert.NotEqual(t, expectedObj.Val, result)
		assert.NotEqualf(t, expectedObj.Val, result, "msg with args %d %s", 42, "42")
		assert.NotEqual(t, tt.expected, result)
		assert.NotEqualf(t, tt.expected, result, "msg with args %d %s", 42, "42")
		assert.NotEqual(t, tt.exp(), result)
		assert.NotEqualf(t, tt.exp(), result, "msg with args %d %s", 42, "42")
		assert.NotEqual(t, tt.expPtr(), result)
		assert.NotEqualf(t, tt.expPtr(), result, "msg with args %d %s", 42, "42")
		assert.NotEqual(t, expectedVal(), result)
		assert.NotEqualf(t, expectedVal(), result, "msg with args %d %s", 42, "42")
		assert.NotEqual(t, []int{1, 2, 3}, result)
		assert.NotEqualf(t, []int{1, 2, 3}, result, "msg with args %d %s", 42, "42")
		assert.NotEqual(t, [3]int{1, 2, 3}, result)
		assert.NotEqualf(t, [3]int{1, 2, 3}, result, "msg with args %d %s", 42, "42")
		assert.NotEqual(t, map[string]int{"0": 1}, result)
		assert.NotEqualf(t, map[string]int{"0": 1}, result, "msg with args %d %s", 42, "42")
		assert.NotEqual(t, user{Name: "Rob"}, result)
		assert.NotEqualf(t, user{Name: "Rob"}, result, "msg with args %d %s", 42, "42")
		assert.NotEqual(t, struct{ Name string }{Name: "Rob"}, result)
		assert.NotEqualf(t, struct{ Name string }{Name: "Rob"}, result, "msg with args %d %s", 42, "42")
		assert.NotEqual(t, nil, result)
		assert.NotEqualf(t, nil, result, "msg with args %d %s", 42, "42")
		assert.NotEqual(t, &expected, result)
		assert.NotEqualf(t, &expected, result, "msg with args %d %s", 42, "42")
		assert.NotEqual(t, &expectedObj.Val, result)
		assert.NotEqualf(t, &expectedObj.Val, result, "msg with args %d %s", 42, "42")
		assert.NotEqual(t, &(expectedObj.Val), result)
		assert.NotEqualf(t, &(expectedObj.Val), result, "msg with args %d %s", 42, "42")
		assert.NotEqual(t, &tt.expected, result)
		assert.NotEqualf(t, &tt.expected, result, "msg with args %d %s", 42, "42")
		assert.NotEqual(t, &(tt.expected), result)
		assert.NotEqualf(t, &(tt.expected), result, "msg with args %d %s", 42, "42")
		assert.NotEqual(t, &user{Name: "Rob"}, result)
		assert.NotEqualf(t, &user{Name: "Rob"}, result, "msg with args %d %s", 42, "42")
		assert.NotEqual(t, *expectedPtr, result)
		assert.NotEqualf(t, *expectedPtr, result, "msg with args %d %s", 42, "42")
		assert.NotEqual(t, expectedObjPtr.Val, result)
		assert.NotEqualf(t, expectedObjPtr.Val, result, "msg with args %d %s", 42, "42")
		assert.NotEqual(t, *tt.expPtr(), result)
		assert.NotEqualf(t, *tt.expPtr(), result, "msg with args %d %s", 42, "42")
		assert.NotEqual(t, *(tt.expPtr()), result)
		assert.NotEqualf(t, *(tt.expPtr()), result, "msg with args %d %s", 42, "42")
		assert.NotEqual(t, ttPtr.expected, result)
		assert.NotEqualf(t, ttPtr.expected, result, "msg with args %d %s", 42, "42")
		assert.NotEqual(t, len(expectedFields), result)
		assert.NotEqualf(t, len(expectedFields), result, "msg with args %d %s", 42, "42")
		assert.NotEqual(t, 42, result)
		assert.NotEqualf(t, 42, result, "msg with args %d %s", 42, "42")
		assert.NotEqual(t, 3.14, result)
		assert.NotEqualf(t, 3.14, result, "msg with args %d %s", 42, "42")
		assert.NotEqual(t, 0.707i, result)
		assert.NotEqualf(t, 0.707i, result, "msg with args %d %s", 42, "42")
		assert.NotEqual(t, "raw string", result)
		assert.NotEqualf(t, "raw string", result, "msg with args %d %s", 42, "42")
		assert.NotEqual(t, '\U00101234', result)
		assert.NotEqualf(t, '\U00101234', result, "msg with args %d %s", 42, "42")
		assert.NotEqual(t, true, result)
		assert.NotEqualf(t, true, result, "msg with args %d %s", 42, "42")
	}
}

func TestExpectedActualChecker_Other(t *testing.T) {
	var (
		result, expected             any
		resultPtr, expectedPtr       *int
		resultObj, expectedObj       user
		resultTime, expectedTime     time.Time
		value                        int
		actualFields, expectedFields []string
	)

	// Invalid.
	{
		assert.Equal(t, len(actualFields), len(expectedFields))                                                                                   // want "expected-actual: need to reverse actual and expected values"
		assert.Equalf(t, len(actualFields), len(expectedFields), "msg with args %d %s", 42, "42")                                                 // want "expected-actual: need to reverse actual and expected values"
		assert.EqualExportedValues(t, resultObj, expectedObj)                                                                                     // want "expected-actual: need to reverse actual and expected values"
		assert.EqualExportedValuesf(t, resultObj, expectedObj, "msg with args %d %s", 42, "42")                                                   // want "expected-actual: need to reverse actual and expected values"
		assert.EqualExportedValues(t, resultObj, user{Name: "Rob"})                                                                               // want "expected-actual: need to reverse actual and expected values"
		assert.EqualExportedValuesf(t, resultObj, user{Name: "Rob"}, "msg with args %d %s", 42, "42")                                             // want "expected-actual: need to reverse actual and expected values"
		assert.EqualExportedValues(t, resultObj, struct{ Name string }{Name: "Rob"})                                                              // want "expected-actual: need to reverse actual and expected values"
		assert.EqualExportedValuesf(t, resultObj, struct{ Name string }{Name: "Rob"}, "msg with args %d %s", 42, "42")                            // want "expected-actual: need to reverse actual and expected values"
		assert.EqualValues(t, result, expected)                                                                                                   // want "expected-actual: need to reverse actual and expected values"
		assert.EqualValuesf(t, result, expected, "msg with args %d %s", 42, "42")                                                                 // want "expected-actual: need to reverse actual and expected values"
		assert.EqualValues(t, result, uint32(100))                                                                                                // want "expected-actual: need to reverse actual and expected values"
		assert.EqualValuesf(t, result, uint32(100), "msg with args %d %s", 42, "42")                                                              // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqualValues(t, result, expected)                                                                                                // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqualValuesf(t, result, expected, "msg with args %d %s", 42, "42")                                                              // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqualValues(t, result, uint32(100))                                                                                             // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqualValuesf(t, result, uint32(100), "msg with args %d %s", 42, "42")                                                           // want "expected-actual: need to reverse actual and expected values"
		assert.Exactly(t, result, expected)                                                                                                       // want "expected-actual: need to reverse actual and expected values"
		assert.Exactlyf(t, result, expected, "msg with args %d %s", 42, "42")                                                                     // want "expected-actual: need to reverse actual and expected values"
		assert.Exactly(t, result, int64(1))                                                                                                       // want "expected-actual: need to reverse actual and expected values"
		assert.Exactlyf(t, result, int64(1), "msg with args %d %s", 42, "42")                                                                     // want "expected-actual: need to reverse actual and expected values"
		assert.InDelta(t, result, expected, 1.0)                                                                                                  // want "expected-actual: need to reverse actual and expected values"
		assert.InDeltaf(t, result, expected, 1.0, "msg with args %d %s", 42, "42")                                                                // want "expected-actual: need to reverse actual and expected values"
		assert.InDelta(t, result, 42.42, 1.0)                                                                                                     // want "expected-actual: need to reverse actual and expected values"
		assert.InDeltaf(t, result, 42.42, 1.0, "msg with args %d %s", 42, "42")                                                                   // want "expected-actual: need to reverse actual and expected values"
		assert.InDeltaMapValues(t, result, expected, 2.0)                                                                                         // want "expected-actual: need to reverse actual and expected values"
		assert.InDeltaMapValuesf(t, result, expected, 2.0, "msg with args %d %s", 42, "42")                                                       // want "expected-actual: need to reverse actual and expected values"
		assert.InDeltaMapValues(t, result, map[string]float64{"score": 0.99}, 2.0)                                                                // want "expected-actual: need to reverse actual and expected values"
		assert.InDeltaMapValuesf(t, result, map[string]float64{"score": 0.99}, 2.0, "msg with args %d %s", 42, "42")                              // want "expected-actual: need to reverse actual and expected values"
		assert.InDeltaSlice(t, result, expected, 1.0)                                                                                             // want "expected-actual: need to reverse actual and expected values"
		assert.InDeltaSlicef(t, result, expected, 1.0, "msg with args %d %s", 42, "42")                                                           // want "expected-actual: need to reverse actual and expected values"
		assert.InDeltaSlice(t, result, []float64{0.98, 0.99}, 1.0)                                                                                // want "expected-actual: need to reverse actual and expected values"
		assert.InDeltaSlicef(t, result, []float64{0.98, 0.99}, 1.0, "msg with args %d %s", 42, "42")                                              // want "expected-actual: need to reverse actual and expected values"
		assert.InEpsilon(t, result, expected, 0.0001)                                                                                             // want "expected-actual: need to reverse actual and expected values"
		assert.InEpsilonf(t, result, expected, 0.0001, "msg with args %d %s", 42, "42")                                                           // want "expected-actual: need to reverse actual and expected values"
		assert.InEpsilon(t, result, 42.42, 0.0001)                                                                                                // want "expected-actual: need to reverse actual and expected values"
		assert.InEpsilonf(t, result, 42.42, 0.0001, "msg with args %d %s", 42, "42")                                                              // want "expected-actual: need to reverse actual and expected values"
		assert.InEpsilonSlice(t, result, expected, 0.0001)                                                                                        // want "expected-actual: need to reverse actual and expected values"
		assert.InEpsilonSlicef(t, result, expected, 0.0001, "msg with args %d %s", 42, "42")                                                      // want "expected-actual: need to reverse actual and expected values"
		assert.InEpsilonSlice(t, result, []float64{0.9801, 0.9902}, 0.0001)                                                                       // want "expected-actual: need to reverse actual and expected values"
		assert.InEpsilonSlicef(t, result, []float64{0.9801, 0.9902}, 0.0001, "msg with args %d %s", 42, "42")                                     // want "expected-actual: need to reverse actual and expected values"
		assert.IsNotType(t, result, expected)                                                                                                     // want "expected-actual: need to reverse actual and expected values"
		assert.IsNotTypef(t, result, expected, "msg with args %d %s", 42, "42")                                                                   // want "expected-actual: need to reverse actual and expected values"
		assert.IsNotType(t, result, user{})                                                                                                       // want "expected-actual: need to reverse actual and expected values"
		assert.IsNotTypef(t, result, user{}, "msg with args %d %s", 42, "42")                                                                     // want "expected-actual: need to reverse actual and expected values"
		assert.IsNotType(t, result, (*user)(nil))                                                                                                 // want "expected-actual: need to reverse actual and expected values"
		assert.IsNotTypef(t, result, (*user)(nil), "msg with args %d %s", 42, "42")                                                               // want "expected-actual: need to reverse actual and expected values"
		assert.IsType(t, result, expected)                                                                                                        // want "expected-actual: need to reverse actual and expected values"
		assert.IsTypef(t, result, expected, "msg with args %d %s", 42, "42")                                                                      // want "expected-actual: need to reverse actual and expected values"
		assert.IsType(t, result, user{})                                                                                                          // want "expected-actual: need to reverse actual and expected values"
		assert.IsTypef(t, result, user{}, "msg with args %d %s", 42, "42")                                                                        // want "expected-actual: need to reverse actual and expected values"
		assert.IsType(t, result, (*user)(nil))                                                                                                    // want "expected-actual: need to reverse actual and expected values"
		assert.IsTypef(t, result, (*user)(nil), "msg with args %d %s", 42, "42")                                                                  // want "expected-actual: need to reverse actual and expected values"
		assert.Same(t, resultPtr, expectedPtr)                                                                                                    // want "expected-actual: need to reverse actual and expected values"
		assert.Samef(t, resultPtr, expectedPtr, "msg with args %d %s", 42, "42")                                                                  // want "expected-actual: need to reverse actual and expected values"
		assert.Same(t, &value, expectedPtr)                                                                                                       // want "expected-actual: need to reverse actual and expected values"
		assert.Samef(t, &value, expectedPtr, "msg with args %d %s", 42, "42")                                                                     // want "expected-actual: need to reverse actual and expected values"
		assert.Same(t, value, &expected)                                                                                                          // want "expected-actual: need to reverse actual and expected values"
		assert.Samef(t, value, &expected, "msg with args %d %s", 42, "42")                                                                        // want "expected-actual: need to reverse actual and expected values"
		assert.NotSame(t, resultPtr, expectedPtr)                                                                                                 // want "expected-actual: need to reverse actual and expected values"
		assert.NotSamef(t, resultPtr, expectedPtr, "msg with args %d %s", 42, "42")                                                               // want "expected-actual: need to reverse actual and expected values"
		assert.NotSame(t, &value, expectedPtr)                                                                                                    // want "expected-actual: need to reverse actual and expected values"
		assert.NotSamef(t, &value, expectedPtr, "msg with args %d %s", 42, "42")                                                                  // want "expected-actual: need to reverse actual and expected values"
		assert.NotSame(t, value, &expected)                                                                                                       // want "expected-actual: need to reverse actual and expected values"
		assert.NotSamef(t, value, &expected, "msg with args %d %s", 42, "42")                                                                     // want "expected-actual: need to reverse actual and expected values"
		assert.WithinDuration(t, resultTime, expectedTime, time.Second)                                                                           // want "expected-actual: need to reverse actual and expected values"
		assert.WithinDurationf(t, resultTime, expectedTime, time.Second, "msg with args %d %s", 42, "42")                                         // want "expected-actual: need to reverse actual and expected values"
		assert.WithinDuration(t, resultTime, time.Date(2023, 01, 12, 11, 46, 33, 0, nil), 100*time.Millisecond)                                   // want "expected-actual: need to reverse actual and expected values"
		assert.WithinDurationf(t, resultTime, time.Date(2023, 01, 12, 11, 46, 33, 0, nil), 100*time.Millisecond, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
	}

	// Valid.
	{
		assert.EqualExportedValues(t, expectedObj, resultObj)
		assert.EqualExportedValuesf(t, expectedObj, resultObj, "msg with args %d %s", 42, "42")
		assert.EqualExportedValues(t, user{Name: "Rob"}, resultObj)
		assert.EqualExportedValuesf(t, user{Name: "Rob"}, resultObj, "msg with args %d %s", 42, "42")
		assert.EqualExportedValues(t, struct{ Name string }{Name: "Rob"}, resultObj)
		assert.EqualExportedValuesf(t, struct{ Name string }{Name: "Rob"}, resultObj, "msg with args %d %s", 42, "42")
		assert.EqualValues(t, expected, result)
		assert.EqualValuesf(t, expected, result, "msg with args %d %s", 42, "42")
		assert.EqualValues(t, uint32(100), result)
		assert.EqualValuesf(t, uint32(100), result, "msg with args %d %s", 42, "42")
		assert.NotEqualValues(t, expected, result)
		assert.NotEqualValuesf(t, expected, result, "msg with args %d %s", 42, "42")
		assert.NotEqualValues(t, uint32(100), result)
		assert.NotEqualValuesf(t, uint32(100), result, "msg with args %d %s", 42, "42")
		assert.Exactly(t, expected, result)
		assert.Exactlyf(t, expected, result, "msg with args %d %s", 42, "42")
		assert.Exactly(t, int64(1), result)
		assert.Exactlyf(t, int64(1), result, "msg with args %d %s", 42, "42")
		assert.InDelta(t, expected, result, 1.0)
		assert.InDeltaf(t, expected, result, 1.0, "msg with args %d %s", 42, "42")
		assert.InDelta(t, 42.42, result, 1.0)
		assert.InDeltaf(t, 42.42, result, 1.0, "msg with args %d %s", 42, "42")
		assert.InDeltaMapValues(t, expected, result, 2.0)
		assert.InDeltaMapValuesf(t, expected, result, 2.0, "msg with args %d %s", 42, "42")
		assert.InDeltaMapValues(t, map[string]float64{"score": 0.99}, result, 2.0)
		assert.InDeltaMapValuesf(t, map[string]float64{"score": 0.99}, result, 2.0, "msg with args %d %s", 42, "42")
		assert.InEpsilon(t, expected, result, 0.0001)
		assert.InEpsilonf(t, expected, result, 0.0001, "msg with args %d %s", 42, "42")
		assert.InEpsilon(t, 42.42, result, 0.0001)
		assert.InEpsilonf(t, 42.42, result, 0.0001, "msg with args %d %s", 42, "42")
		assert.IsNotType(t, expected, result)
		assert.IsNotTypef(t, expected, result, "msg with args %d %s", 42, "42")
		assert.IsNotType(t, user{}, result)
		assert.IsNotTypef(t, user{}, result, "msg with args %d %s", 42, "42")
		assert.IsNotType(t, (*user)(nil), result)
		assert.IsNotTypef(t, (*user)(nil), result, "msg with args %d %s", 42, "42")
		assert.IsType(t, expected, result)
		assert.IsTypef(t, expected, result, "msg with args %d %s", 42, "42")
		assert.IsType(t, user{}, result)
		assert.IsTypef(t, user{}, result, "msg with args %d %s", 42, "42")
		assert.IsType(t, (*user)(nil), result)
		assert.IsTypef(t, (*user)(nil), result, "msg with args %d %s", 42, "42")
		assert.Same(t, expectedPtr, resultPtr)
		assert.Samef(t, expectedPtr, resultPtr, "msg with args %d %s", 42, "42")
		assert.Same(t, &value, resultPtr)
		assert.Samef(t, &value, resultPtr, "msg with args %d %s", 42, "42")
		assert.NotSame(t, expectedPtr, resultPtr)
		assert.NotSamef(t, expectedPtr, resultPtr, "msg with args %d %s", 42, "42")
		assert.NotSame(t, &value, resultPtr)
		assert.NotSamef(t, &value, resultPtr, "msg with args %d %s", 42, "42")
		assert.WithinDuration(t, expectedTime, resultTime, time.Second)
		assert.WithinDurationf(t, expectedTime, resultTime, time.Second, "msg with args %d %s", 42, "42")
		assert.WithinDuration(t, time.Date(2023, 01, 12, 11, 46, 33, 0, nil), resultTime, 100*time.Millisecond)
		assert.WithinDurationf(t, time.Date(2023, 01, 12, 11, 46, 33, 0, nil), resultTime, 100*time.Millisecond, "msg with args %d %s", 42, "42")
	}
}

func TestExpectedActualChecker_DetectConsts(t *testing.T) {
	type OwnInt int
	type OwnString string

	const (
		tc0        bool       = true
		tc0casted             = bool(true)
		tc1        uint       = 10
		tc1casted             = uint(10)
		tc2        uint8      = 11
		tc2casted             = uint8(11)
		tc3        uint16     = 12
		tc3casted             = uint16(12)
		tc4        uint32     = 13
		tc4casted             = uint32(13)
		tc5        uint64     = 14
		tc5casted             = uint64(14)
		tc6        int        = 20
		tc6casted             = int(20)
		tc7        int8       = 21
		tc7casted             = int8(21)
		tc8        int16      = 22
		tc8casted             = int16(22)
		tc9        int32      = 23
		tc9casted             = int32(23)
		tc10       int64      = 14
		tc10casted            = int64(14)
		tc11       float32    = 30.
		tc11casted            = float32(30.)
		tc12       float64    = 31.
		tc12casted            = float64(31.)
		tc13       complex64  = 40i
		tc13casted            = complex64(40i)
		tc14       complex128 = 41i
		tc14casted            = complex128(41i)
		tc15       string     = "50"
		tc15casted            = string("50")
		tc16       uintptr    = 60
		tc16casted            = uintptr(60)
		tc17       byte       = 70
		tc17casted            = byte(70)
		tc18       rune       = '\x80'
		tc18casted            = rune('\x80')
		tc19       OwnInt     = 90
		tc19casted            = OwnInt(90)
		tc20       OwnString  = "91"
		tc20casted            = OwnString("91")
	)

	const (
		uc0 = 42
		uc1 = 3.14
		uc2 = 0.707i
		uc3 = "raw string"
		uc4 = '\U00101234'
		uc5 = true
	)

	var result any

	// Invalid.
	{
		assert.Equal(t, result, tc0)                                             // want "expected-actual: need to reverse actual and expected values"
		assert.Equalf(t, result, tc0, "msg with args %d %s", 42, "42")           // want "expected-actual: need to reverse actual and expected values"
		assert.Equal(t, result, tc0casted)                                       // want "expected-actual: need to reverse actual and expected values"
		assert.Equalf(t, result, tc0casted, "msg with args %d %s", 42, "42")     // want "expected-actual: need to reverse actual and expected values"
		assert.Equal(t, result, tc1)                                             // want "expected-actual: need to reverse actual and expected values"
		assert.Equalf(t, result, tc1, "msg with args %d %s", 42, "42")           // want "expected-actual: need to reverse actual and expected values"
		assert.Equal(t, result, tc1casted)                                       // want "expected-actual: need to reverse actual and expected values"
		assert.Equalf(t, result, tc1casted, "msg with args %d %s", 42, "42")     // want "expected-actual: need to reverse actual and expected values"
		assert.Equal(t, result, tc2)                                             // want "expected-actual: need to reverse actual and expected values"
		assert.Equalf(t, result, tc2, "msg with args %d %s", 42, "42")           // want "expected-actual: need to reverse actual and expected values"
		assert.Equal(t, result, tc2casted)                                       // want "expected-actual: need to reverse actual and expected values"
		assert.Equalf(t, result, tc2casted, "msg with args %d %s", 42, "42")     // want "expected-actual: need to reverse actual and expected values"
		assert.Equal(t, result, tc3)                                             // want "expected-actual: need to reverse actual and expected values"
		assert.Equalf(t, result, tc3, "msg with args %d %s", 42, "42")           // want "expected-actual: need to reverse actual and expected values"
		assert.Equal(t, result, tc3casted)                                       // want "expected-actual: need to reverse actual and expected values"
		assert.Equalf(t, result, tc3casted, "msg with args %d %s", 42, "42")     // want "expected-actual: need to reverse actual and expected values"
		assert.Equal(t, result, tc4)                                             // want "expected-actual: need to reverse actual and expected values"
		assert.Equalf(t, result, tc4, "msg with args %d %s", 42, "42")           // want "expected-actual: need to reverse actual and expected values"
		assert.Equal(t, result, tc4casted)                                       // want "expected-actual: need to reverse actual and expected values"
		assert.Equalf(t, result, tc4casted, "msg with args %d %s", 42, "42")     // want "expected-actual: need to reverse actual and expected values"
		assert.Equal(t, result, tc5)                                             // want "expected-actual: need to reverse actual and expected values"
		assert.Equalf(t, result, tc5, "msg with args %d %s", 42, "42")           // want "expected-actual: need to reverse actual and expected values"
		assert.Equal(t, result, tc5casted)                                       // want "expected-actual: need to reverse actual and expected values"
		assert.Equalf(t, result, tc5casted, "msg with args %d %s", 42, "42")     // want "expected-actual: need to reverse actual and expected values"
		assert.Equal(t, result, tc6)                                             // want "expected-actual: need to reverse actual and expected values"
		assert.Equalf(t, result, tc6, "msg with args %d %s", 42, "42")           // want "expected-actual: need to reverse actual and expected values"
		assert.Equal(t, result, tc6casted)                                       // want "expected-actual: need to reverse actual and expected values"
		assert.Equalf(t, result, tc6casted, "msg with args %d %s", 42, "42")     // want "expected-actual: need to reverse actual and expected values"
		assert.Equal(t, result, tc7)                                             // want "expected-actual: need to reverse actual and expected values"
		assert.Equalf(t, result, tc7, "msg with args %d %s", 42, "42")           // want "expected-actual: need to reverse actual and expected values"
		assert.Equal(t, result, tc7casted)                                       // want "expected-actual: need to reverse actual and expected values"
		assert.Equalf(t, result, tc7casted, "msg with args %d %s", 42, "42")     // want "expected-actual: need to reverse actual and expected values"
		assert.Equal(t, result, tc8)                                             // want "expected-actual: need to reverse actual and expected values"
		assert.Equalf(t, result, tc8, "msg with args %d %s", 42, "42")           // want "expected-actual: need to reverse actual and expected values"
		assert.Equal(t, result, tc8casted)                                       // want "expected-actual: need to reverse actual and expected values"
		assert.Equalf(t, result, tc8casted, "msg with args %d %s", 42, "42")     // want "expected-actual: need to reverse actual and expected values"
		assert.Equal(t, result, tc9)                                             // want "expected-actual: need to reverse actual and expected values"
		assert.Equalf(t, result, tc9, "msg with args %d %s", 42, "42")           // want "expected-actual: need to reverse actual and expected values"
		assert.Equal(t, result, tc9casted)                                       // want "expected-actual: need to reverse actual and expected values"
		assert.Equalf(t, result, tc9casted, "msg with args %d %s", 42, "42")     // want "expected-actual: need to reverse actual and expected values"
		assert.Equal(t, result, tc10)                                            // want "expected-actual: need to reverse actual and expected values"
		assert.Equalf(t, result, tc10, "msg with args %d %s", 42, "42")          // want "expected-actual: need to reverse actual and expected values"
		assert.Equal(t, result, tc10casted)                                      // want "expected-actual: need to reverse actual and expected values"
		assert.Equalf(t, result, tc10casted, "msg with args %d %s", 42, "42")    // want "expected-actual: need to reverse actual and expected values"
		assert.Equal(t, result, tc11)                                            // want "expected-actual: need to reverse actual and expected values"
		assert.Equalf(t, result, tc11, "msg with args %d %s", 42, "42")          // want "expected-actual: need to reverse actual and expected values"
		assert.Equal(t, result, tc11casted)                                      // want "expected-actual: need to reverse actual and expected values"
		assert.Equalf(t, result, tc11casted, "msg with args %d %s", 42, "42")    // want "expected-actual: need to reverse actual and expected values"
		assert.Equal(t, result, tc12)                                            // want "expected-actual: need to reverse actual and expected values"
		assert.Equalf(t, result, tc12, "msg with args %d %s", 42, "42")          // want "expected-actual: need to reverse actual and expected values"
		assert.Equal(t, result, tc12casted)                                      // want "expected-actual: need to reverse actual and expected values"
		assert.Equalf(t, result, tc12casted, "msg with args %d %s", 42, "42")    // want "expected-actual: need to reverse actual and expected values"
		assert.Equal(t, result, tc13)                                            // want "expected-actual: need to reverse actual and expected values"
		assert.Equalf(t, result, tc13, "msg with args %d %s", 42, "42")          // want "expected-actual: need to reverse actual and expected values"
		assert.Equal(t, result, tc13casted)                                      // want "expected-actual: need to reverse actual and expected values"
		assert.Equalf(t, result, tc13casted, "msg with args %d %s", 42, "42")    // want "expected-actual: need to reverse actual and expected values"
		assert.Equal(t, result, tc14)                                            // want "expected-actual: need to reverse actual and expected values"
		assert.Equalf(t, result, tc14, "msg with args %d %s", 42, "42")          // want "expected-actual: need to reverse actual and expected values"
		assert.Equal(t, result, tc14casted)                                      // want "expected-actual: need to reverse actual and expected values"
		assert.Equalf(t, result, tc14casted, "msg with args %d %s", 42, "42")    // want "expected-actual: need to reverse actual and expected values"
		assert.Equal(t, result, tc15)                                            // want "expected-actual: need to reverse actual and expected values"
		assert.Equalf(t, result, tc15, "msg with args %d %s", 42, "42")          // want "expected-actual: need to reverse actual and expected values"
		assert.Equal(t, result, tc15casted)                                      // want "expected-actual: need to reverse actual and expected values"
		assert.Equalf(t, result, tc15casted, "msg with args %d %s", 42, "42")    // want "expected-actual: need to reverse actual and expected values"
		assert.Equal(t, result, tc16)                                            // want "expected-actual: need to reverse actual and expected values"
		assert.Equalf(t, result, tc16, "msg with args %d %s", 42, "42")          // want "expected-actual: need to reverse actual and expected values"
		assert.Equal(t, result, tc16casted)                                      // want "expected-actual: need to reverse actual and expected values"
		assert.Equalf(t, result, tc16casted, "msg with args %d %s", 42, "42")    // want "expected-actual: need to reverse actual and expected values"
		assert.Equal(t, result, tc17)                                            // want "expected-actual: need to reverse actual and expected values"
		assert.Equalf(t, result, tc17, "msg with args %d %s", 42, "42")          // want "expected-actual: need to reverse actual and expected values"
		assert.Equal(t, result, tc17casted)                                      // want "expected-actual: need to reverse actual and expected values"
		assert.Equalf(t, result, tc17casted, "msg with args %d %s", 42, "42")    // want "expected-actual: need to reverse actual and expected values"
		assert.Equal(t, result, tc18)                                            // want "expected-actual: need to reverse actual and expected values"
		assert.Equalf(t, result, tc18, "msg with args %d %s", 42, "42")          // want "expected-actual: need to reverse actual and expected values"
		assert.Equal(t, result, tc18casted)                                      // want "expected-actual: need to reverse actual and expected values"
		assert.Equalf(t, result, tc18casted, "msg with args %d %s", 42, "42")    // want "expected-actual: need to reverse actual and expected values"
		assert.Equal(t, result, tc19)                                            // want "expected-actual: need to reverse actual and expected values"
		assert.Equalf(t, result, tc19, "msg with args %d %s", 42, "42")          // want "expected-actual: need to reverse actual and expected values"
		assert.Equal(t, result, tc19casted)                                      // want "expected-actual: need to reverse actual and expected values"
		assert.Equalf(t, result, tc19casted, "msg with args %d %s", 42, "42")    // want "expected-actual: need to reverse actual and expected values"
		assert.Equal(t, result, tc20)                                            // want "expected-actual: need to reverse actual and expected values"
		assert.Equalf(t, result, tc20, "msg with args %d %s", 42, "42")          // want "expected-actual: need to reverse actual and expected values"
		assert.Equal(t, result, tc20casted)                                      // want "expected-actual: need to reverse actual and expected values"
		assert.Equalf(t, result, tc20casted, "msg with args %d %s", 42, "42")    // want "expected-actual: need to reverse actual and expected values"
		assert.Equal(t, result, uc0)                                             // want "expected-actual: need to reverse actual and expected values"
		assert.Equalf(t, result, uc0, "msg with args %d %s", 42, "42")           // want "expected-actual: need to reverse actual and expected values"
		assert.Equal(t, result, uc1)                                             // want "expected-actual: need to reverse actual and expected values"
		assert.Equalf(t, result, uc1, "msg with args %d %s", 42, "42")           // want "expected-actual: need to reverse actual and expected values"
		assert.Equal(t, result, uc2)                                             // want "expected-actual: need to reverse actual and expected values"
		assert.Equalf(t, result, uc2, "msg with args %d %s", 42, "42")           // want "expected-actual: need to reverse actual and expected values"
		assert.Equal(t, result, uc3)                                             // want "expected-actual: need to reverse actual and expected values"
		assert.Equalf(t, result, uc3, "msg with args %d %s", 42, "42")           // want "expected-actual: need to reverse actual and expected values"
		assert.Equal(t, result, uc4)                                             // want "expected-actual: need to reverse actual and expected values"
		assert.Equalf(t, result, uc4, "msg with args %d %s", 42, "42")           // want "expected-actual: need to reverse actual and expected values"
		assert.Equal(t, result, uc5)                                             // want "expected-actual: need to reverse actual and expected values"
		assert.Equalf(t, result, uc5, "msg with args %d %s", 42, "42")           // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqual(t, result, tc0)                                          // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqualf(t, result, tc0, "msg with args %d %s", 42, "42")        // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqual(t, result, tc0casted)                                    // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqualf(t, result, tc0casted, "msg with args %d %s", 42, "42")  // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqual(t, result, tc1)                                          // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqualf(t, result, tc1, "msg with args %d %s", 42, "42")        // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqual(t, result, tc1casted)                                    // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqualf(t, result, tc1casted, "msg with args %d %s", 42, "42")  // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqual(t, result, tc2)                                          // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqualf(t, result, tc2, "msg with args %d %s", 42, "42")        // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqual(t, result, tc2casted)                                    // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqualf(t, result, tc2casted, "msg with args %d %s", 42, "42")  // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqual(t, result, tc3)                                          // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqualf(t, result, tc3, "msg with args %d %s", 42, "42")        // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqual(t, result, tc3casted)                                    // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqualf(t, result, tc3casted, "msg with args %d %s", 42, "42")  // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqual(t, result, tc4)                                          // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqualf(t, result, tc4, "msg with args %d %s", 42, "42")        // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqual(t, result, tc4casted)                                    // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqualf(t, result, tc4casted, "msg with args %d %s", 42, "42")  // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqual(t, result, tc5)                                          // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqualf(t, result, tc5, "msg with args %d %s", 42, "42")        // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqual(t, result, tc5casted)                                    // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqualf(t, result, tc5casted, "msg with args %d %s", 42, "42")  // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqual(t, result, tc6)                                          // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqualf(t, result, tc6, "msg with args %d %s", 42, "42")        // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqual(t, result, tc6casted)                                    // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqualf(t, result, tc6casted, "msg with args %d %s", 42, "42")  // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqual(t, result, tc7)                                          // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqualf(t, result, tc7, "msg with args %d %s", 42, "42")        // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqual(t, result, tc7casted)                                    // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqualf(t, result, tc7casted, "msg with args %d %s", 42, "42")  // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqual(t, result, tc8)                                          // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqualf(t, result, tc8, "msg with args %d %s", 42, "42")        // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqual(t, result, tc8casted)                                    // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqualf(t, result, tc8casted, "msg with args %d %s", 42, "42")  // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqual(t, result, tc9)                                          // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqualf(t, result, tc9, "msg with args %d %s", 42, "42")        // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqual(t, result, tc9casted)                                    // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqualf(t, result, tc9casted, "msg with args %d %s", 42, "42")  // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqual(t, result, tc10)                                         // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqualf(t, result, tc10, "msg with args %d %s", 42, "42")       // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqual(t, result, tc10casted)                                   // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqualf(t, result, tc10casted, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqual(t, result, tc11)                                         // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqualf(t, result, tc11, "msg with args %d %s", 42, "42")       // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqual(t, result, tc11casted)                                   // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqualf(t, result, tc11casted, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqual(t, result, tc12)                                         // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqualf(t, result, tc12, "msg with args %d %s", 42, "42")       // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqual(t, result, tc12casted)                                   // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqualf(t, result, tc12casted, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqual(t, result, tc13)                                         // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqualf(t, result, tc13, "msg with args %d %s", 42, "42")       // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqual(t, result, tc13casted)                                   // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqualf(t, result, tc13casted, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqual(t, result, tc14)                                         // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqualf(t, result, tc14, "msg with args %d %s", 42, "42")       // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqual(t, result, tc14casted)                                   // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqualf(t, result, tc14casted, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqual(t, result, tc15)                                         // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqualf(t, result, tc15, "msg with args %d %s", 42, "42")       // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqual(t, result, tc15casted)                                   // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqualf(t, result, tc15casted, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqual(t, result, tc16)                                         // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqualf(t, result, tc16, "msg with args %d %s", 42, "42")       // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqual(t, result, tc16casted)                                   // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqualf(t, result, tc16casted, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqual(t, result, tc17)                                         // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqualf(t, result, tc17, "msg with args %d %s", 42, "42")       // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqual(t, result, tc17casted)                                   // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqualf(t, result, tc17casted, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqual(t, result, tc18)                                         // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqualf(t, result, tc18, "msg with args %d %s", 42, "42")       // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqual(t, result, tc18casted)                                   // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqualf(t, result, tc18casted, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqual(t, result, tc19)                                         // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqualf(t, result, tc19, "msg with args %d %s", 42, "42")       // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqual(t, result, tc19casted)                                   // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqualf(t, result, tc19casted, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqual(t, result, tc20)                                         // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqualf(t, result, tc20, "msg with args %d %s", 42, "42")       // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqual(t, result, tc20casted)                                   // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqualf(t, result, tc20casted, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqual(t, result, uc0)                                          // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqualf(t, result, uc0, "msg with args %d %s", 42, "42")        // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqual(t, result, uc1)                                          // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqualf(t, result, uc1, "msg with args %d %s", 42, "42")        // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqual(t, result, uc2)                                          // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqualf(t, result, uc2, "msg with args %d %s", 42, "42")        // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqual(t, result, uc3)                                          // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqualf(t, result, uc3, "msg with args %d %s", 42, "42")        // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqual(t, result, uc4)                                          // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqualf(t, result, uc4, "msg with args %d %s", 42, "42")        // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqual(t, result, uc5)                                          // want "expected-actual: need to reverse actual and expected values"
		assert.NotEqualf(t, result, uc5, "msg with args %d %s", 42, "42")        // want "expected-actual: need to reverse actual and expected values"
	}

	// Valid.
	{
		assert.Equal(t, tc0, result)
		assert.Equalf(t, tc0, result, "msg with args %d %s", 42, "42")
		assert.Equal(t, tc0casted, result)
		assert.Equalf(t, tc0casted, result, "msg with args %d %s", 42, "42")
		assert.Equal(t, tc1, result)
		assert.Equalf(t, tc1, result, "msg with args %d %s", 42, "42")
		assert.Equal(t, tc1casted, result)
		assert.Equalf(t, tc1casted, result, "msg with args %d %s", 42, "42")
		assert.Equal(t, tc2, result)
		assert.Equalf(t, tc2, result, "msg with args %d %s", 42, "42")
		assert.Equal(t, tc2casted, result)
		assert.Equalf(t, tc2casted, result, "msg with args %d %s", 42, "42")
		assert.Equal(t, tc3, result)
		assert.Equalf(t, tc3, result, "msg with args %d %s", 42, "42")
		assert.Equal(t, tc3casted, result)
		assert.Equalf(t, tc3casted, result, "msg with args %d %s", 42, "42")
		assert.Equal(t, tc4, result)
		assert.Equalf(t, tc4, result, "msg with args %d %s", 42, "42")
		assert.Equal(t, tc4casted, result)
		assert.Equalf(t, tc4casted, result, "msg with args %d %s", 42, "42")
		assert.Equal(t, tc5, result)
		assert.Equalf(t, tc5, result, "msg with args %d %s", 42, "42")
		assert.Equal(t, tc5casted, result)
		assert.Equalf(t, tc5casted, result, "msg with args %d %s", 42, "42")
		assert.Equal(t, tc6, result)
		assert.Equalf(t, tc6, result, "msg with args %d %s", 42, "42")
		assert.Equal(t, tc6casted, result)
		assert.Equalf(t, tc6casted, result, "msg with args %d %s", 42, "42")
		assert.Equal(t, tc7, result)
		assert.Equalf(t, tc7, result, "msg with args %d %s", 42, "42")
		assert.Equal(t, tc7casted, result)
		assert.Equalf(t, tc7casted, result, "msg with args %d %s", 42, "42")
		assert.Equal(t, tc8, result)
		assert.Equalf(t, tc8, result, "msg with args %d %s", 42, "42")
		assert.Equal(t, tc8casted, result)
		assert.Equalf(t, tc8casted, result, "msg with args %d %s", 42, "42")
		assert.Equal(t, tc9, result)
		assert.Equalf(t, tc9, result, "msg with args %d %s", 42, "42")
		assert.Equal(t, tc9casted, result)
		assert.Equalf(t, tc9casted, result, "msg with args %d %s", 42, "42")
		assert.Equal(t, tc10, result)
		assert.Equalf(t, tc10, result, "msg with args %d %s", 42, "42")
		assert.Equal(t, tc10casted, result)
		assert.Equalf(t, tc10casted, result, "msg with args %d %s", 42, "42")
		assert.Equal(t, tc11, result)
		assert.Equalf(t, tc11, result, "msg with args %d %s", 42, "42")
		assert.Equal(t, tc11casted, result)
		assert.Equalf(t, tc11casted, result, "msg with args %d %s", 42, "42")
		assert.Equal(t, tc12, result)
		assert.Equalf(t, tc12, result, "msg with args %d %s", 42, "42")
		assert.Equal(t, tc12casted, result)
		assert.Equalf(t, tc12casted, result, "msg with args %d %s", 42, "42")
		assert.Equal(t, tc13, result)
		assert.Equalf(t, tc13, result, "msg with args %d %s", 42, "42")
		assert.Equal(t, tc13casted, result)
		assert.Equalf(t, tc13casted, result, "msg with args %d %s", 42, "42")
		assert.Equal(t, tc14, result)
		assert.Equalf(t, tc14, result, "msg with args %d %s", 42, "42")
		assert.Equal(t, tc14casted, result)
		assert.Equalf(t, tc14casted, result, "msg with args %d %s", 42, "42")
		assert.Equal(t, tc15, result)
		assert.Equalf(t, tc15, result, "msg with args %d %s", 42, "42")
		assert.Equal(t, tc15casted, result)
		assert.Equalf(t, tc15casted, result, "msg with args %d %s", 42, "42")
		assert.Equal(t, tc16, result)
		assert.Equalf(t, tc16, result, "msg with args %d %s", 42, "42")
		assert.Equal(t, tc16casted, result)
		assert.Equalf(t, tc16casted, result, "msg with args %d %s", 42, "42")
		assert.Equal(t, tc17, result)
		assert.Equalf(t, tc17, result, "msg with args %d %s", 42, "42")
		assert.Equal(t, tc17casted, result)
		assert.Equalf(t, tc17casted, result, "msg with args %d %s", 42, "42")
		assert.Equal(t, tc18, result)
		assert.Equalf(t, tc18, result, "msg with args %d %s", 42, "42")
		assert.Equal(t, tc18casted, result)
		assert.Equalf(t, tc18casted, result, "msg with args %d %s", 42, "42")
		assert.Equal(t, tc19, result)
		assert.Equalf(t, tc19, result, "msg with args %d %s", 42, "42")
		assert.Equal(t, tc19casted, result)
		assert.Equalf(t, tc19casted, result, "msg with args %d %s", 42, "42")
		assert.Equal(t, tc20, result)
		assert.Equalf(t, tc20, result, "msg with args %d %s", 42, "42")
		assert.Equal(t, tc20casted, result)
		assert.Equalf(t, tc20casted, result, "msg with args %d %s", 42, "42")
		assert.Equal(t, uc0, result)
		assert.Equalf(t, uc0, result, "msg with args %d %s", 42, "42")
		assert.Equal(t, uc1, result)
		assert.Equalf(t, uc1, result, "msg with args %d %s", 42, "42")
		assert.Equal(t, uc2, result)
		assert.Equalf(t, uc2, result, "msg with args %d %s", 42, "42")
		assert.Equal(t, uc3, result)
		assert.Equalf(t, uc3, result, "msg with args %d %s", 42, "42")
		assert.Equal(t, uc4, result)
		assert.Equalf(t, uc4, result, "msg with args %d %s", 42, "42")
		assert.Equal(t, uc5, result)
		assert.Equalf(t, uc5, result, "msg with args %d %s", 42, "42")
		assert.NotEqual(t, tc0, result)
		assert.NotEqualf(t, tc0, result, "msg with args %d %s", 42, "42")
		assert.NotEqual(t, tc0casted, result)
		assert.NotEqualf(t, tc0casted, result, "msg with args %d %s", 42, "42")
		assert.NotEqual(t, tc1, result)
		assert.NotEqualf(t, tc1, result, "msg with args %d %s", 42, "42")
		assert.NotEqual(t, tc1casted, result)
		assert.NotEqualf(t, tc1casted, result, "msg with args %d %s", 42, "42")
		assert.NotEqual(t, tc2, result)
		assert.NotEqualf(t, tc2, result, "msg with args %d %s", 42, "42")
		assert.NotEqual(t, tc2casted, result)
		assert.NotEqualf(t, tc2casted, result, "msg with args %d %s", 42, "42")
		assert.NotEqual(t, tc3, result)
		assert.NotEqualf(t, tc3, result, "msg with args %d %s", 42, "42")
		assert.NotEqual(t, tc3casted, result)
		assert.NotEqualf(t, tc3casted, result, "msg with args %d %s", 42, "42")
		assert.NotEqual(t, tc4, result)
		assert.NotEqualf(t, tc4, result, "msg with args %d %s", 42, "42")
		assert.NotEqual(t, tc4casted, result)
		assert.NotEqualf(t, tc4casted, result, "msg with args %d %s", 42, "42")
		assert.NotEqual(t, tc5, result)
		assert.NotEqualf(t, tc5, result, "msg with args %d %s", 42, "42")
		assert.NotEqual(t, tc5casted, result)
		assert.NotEqualf(t, tc5casted, result, "msg with args %d %s", 42, "42")
		assert.NotEqual(t, tc6, result)
		assert.NotEqualf(t, tc6, result, "msg with args %d %s", 42, "42")
		assert.NotEqual(t, tc6casted, result)
		assert.NotEqualf(t, tc6casted, result, "msg with args %d %s", 42, "42")
		assert.NotEqual(t, tc7, result)
		assert.NotEqualf(t, tc7, result, "msg with args %d %s", 42, "42")
		assert.NotEqual(t, tc7casted, result)
		assert.NotEqualf(t, tc7casted, result, "msg with args %d %s", 42, "42")
		assert.NotEqual(t, tc8, result)
		assert.NotEqualf(t, tc8, result, "msg with args %d %s", 42, "42")
		assert.NotEqual(t, tc8casted, result)
		assert.NotEqualf(t, tc8casted, result, "msg with args %d %s", 42, "42")
		assert.NotEqual(t, tc9, result)
		assert.NotEqualf(t, tc9, result, "msg with args %d %s", 42, "42")
		assert.NotEqual(t, tc9casted, result)
		assert.NotEqualf(t, tc9casted, result, "msg with args %d %s", 42, "42")
		assert.NotEqual(t, tc10, result)
		assert.NotEqualf(t, tc10, result, "msg with args %d %s", 42, "42")
		assert.NotEqual(t, tc10casted, result)
		assert.NotEqualf(t, tc10casted, result, "msg with args %d %s", 42, "42")
		assert.NotEqual(t, tc11, result)
		assert.NotEqualf(t, tc11, result, "msg with args %d %s", 42, "42")
		assert.NotEqual(t, tc11casted, result)
		assert.NotEqualf(t, tc11casted, result, "msg with args %d %s", 42, "42")
		assert.NotEqual(t, tc12, result)
		assert.NotEqualf(t, tc12, result, "msg with args %d %s", 42, "42")
		assert.NotEqual(t, tc12casted, result)
		assert.NotEqualf(t, tc12casted, result, "msg with args %d %s", 42, "42")
		assert.NotEqual(t, tc13, result)
		assert.NotEqualf(t, tc13, result, "msg with args %d %s", 42, "42")
		assert.NotEqual(t, tc13casted, result)
		assert.NotEqualf(t, tc13casted, result, "msg with args %d %s", 42, "42")
		assert.NotEqual(t, tc14, result)
		assert.NotEqualf(t, tc14, result, "msg with args %d %s", 42, "42")
		assert.NotEqual(t, tc14casted, result)
		assert.NotEqualf(t, tc14casted, result, "msg with args %d %s", 42, "42")
		assert.NotEqual(t, tc15, result)
		assert.NotEqualf(t, tc15, result, "msg with args %d %s", 42, "42")
		assert.NotEqual(t, tc15casted, result)
		assert.NotEqualf(t, tc15casted, result, "msg with args %d %s", 42, "42")
		assert.NotEqual(t, tc16, result)
		assert.NotEqualf(t, tc16, result, "msg with args %d %s", 42, "42")
		assert.NotEqual(t, tc16casted, result)
		assert.NotEqualf(t, tc16casted, result, "msg with args %d %s", 42, "42")
		assert.NotEqual(t, tc17, result)
		assert.NotEqualf(t, tc17, result, "msg with args %d %s", 42, "42")
		assert.NotEqual(t, tc17casted, result)
		assert.NotEqualf(t, tc17casted, result, "msg with args %d %s", 42, "42")
		assert.NotEqual(t, tc18, result)
		assert.NotEqualf(t, tc18, result, "msg with args %d %s", 42, "42")
		assert.NotEqual(t, tc18casted, result)
		assert.NotEqualf(t, tc18casted, result, "msg with args %d %s", 42, "42")
		assert.NotEqual(t, tc19, result)
		assert.NotEqualf(t, tc19, result, "msg with args %d %s", 42, "42")
		assert.NotEqual(t, tc19casted, result)
		assert.NotEqualf(t, tc19casted, result, "msg with args %d %s", 42, "42")
		assert.NotEqual(t, tc20, result)
		assert.NotEqualf(t, tc20, result, "msg with args %d %s", 42, "42")
		assert.NotEqual(t, tc20casted, result)
		assert.NotEqualf(t, tc20casted, result, "msg with args %d %s", 42, "42")
		assert.NotEqual(t, uc0, result)
		assert.NotEqualf(t, uc0, result, "msg with args %d %s", 42, "42")
		assert.NotEqual(t, uc1, result)
		assert.NotEqualf(t, uc1, result, "msg with args %d %s", 42, "42")
		assert.NotEqual(t, uc2, result)
		assert.NotEqualf(t, uc2, result, "msg with args %d %s", 42, "42")
		assert.NotEqual(t, uc3, result)
		assert.NotEqualf(t, uc3, result, "msg with args %d %s", 42, "42")
		assert.NotEqual(t, uc4, result)
		assert.NotEqualf(t, uc4, result, "msg with args %d %s", 42, "42")
		assert.NotEqual(t, uc5, result)
		assert.NotEqualf(t, uc5, result, "msg with args %d %s", 42, "42")
	}
}

func TestExpectedActualChecker_Strings(t *testing.T) {
	const data = "{}"
	var result string

	// Invalid.
	{
		assert.JSONEq(t, result, data)                                   // want "expected-actual: need to reverse actual and expected values"
		assert.JSONEqf(t, result, data, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
		assert.YAMLEq(t, result, data)                                   // want "expected-actual: need to reverse actual and expected values"
		assert.YAMLEqf(t, result, data, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
	}

	// Valid.
	{
		assert.JSONEq(t, data, result)
		assert.JSONEqf(t, data, result, "msg with args %d %s", 42, "42")
		assert.YAMLEq(t, data, result)
		assert.YAMLEqf(t, data, result, "msg with args %d %s", 42, "42")
	}

	// Real life case.
	body, err := io.ReadAll(http.Response{}.Body)
	require.NoError(t, err)

	var expected = struct {
		ID   string
		Name string
	}{
		ID:   "1",
		Name: "Anthony",
	}
	expectedJSON, err := json.Marshal(expected)
	require.NoError(t, err)

	assert.JSONEq(t, string(body), string(expectedJSON))                                   // want "expected-actual: need to reverse actual and expected values"
	assert.JSONEqf(t, string(body), string(expectedJSON), "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
}

func TestExpectedActualChecker_CannotDetectVariablesLookedLikeConsts(t *testing.T) {
	type OwnInt int
	type OwnString string

	var (
		tc0        bool       = true
		tc0casted             = bool(true)
		tc1        uint       = 10
		tc1casted             = uint(10)
		tc2        uint8      = 11
		tc2casted             = uint8(11)
		tc3        uint16     = 12
		tc3casted             = uint16(12)
		tc4        uint32     = 13
		tc4casted             = uint32(13)
		tc5        uint64     = 14
		tc5casted             = uint64(14)
		tc6        int        = 20
		tc6casted             = int(20)
		tc7        int8       = 21
		tc7casted             = int8(21)
		tc8        int16      = 22
		tc8casted             = int16(22)
		tc9        int32      = 23
		tc9casted             = int32(23)
		tc10       int64      = 14
		tc10casted            = int64(14)
		tc11       float32    = 30.
		tc11casted            = float32(30.)
		tc12       float64    = 31.
		tc12casted            = float64(31.)
		tc13       complex64  = 40i
		tc13casted            = complex64(40i)
		tc14       complex128 = 41i
		tc14casted            = complex128(41i)
		tc15       string     = "50"
		tc15casted            = string("50")
		tc16       uintptr    = 60
		tc16casted            = uintptr(60)
		tc17       byte       = 70
		tc17casted            = byte(70)
		tc18       rune       = '\x80'
		tc18casted            = rune('\x80')
		tc19       OwnInt     = 90
		tc19casted            = OwnInt(90)
		tc20       OwnString  = "91"
		tc20casted            = OwnString("91")
	)

	var (
		uc0 = 42
		uc1 = 3.14
		uc2 = 0.707i
		uc3 = "raw string"
		uc4 = '\U00101234'
		uc5 = true
	)

	var result any

	assert.Equal(t, result, tc0)
	assert.Equalf(t, result, tc0, "msg with args %d %s", 42, "42")
	assert.Equal(t, result, tc0casted)
	assert.Equalf(t, result, tc0casted, "msg with args %d %s", 42, "42")
	assert.Equal(t, result, tc1)
	assert.Equalf(t, result, tc1, "msg with args %d %s", 42, "42")
	assert.Equal(t, result, tc1casted)
	assert.Equalf(t, result, tc1casted, "msg with args %d %s", 42, "42")
	assert.Equal(t, result, tc2)
	assert.Equalf(t, result, tc2, "msg with args %d %s", 42, "42")
	assert.Equal(t, result, tc2casted)
	assert.Equalf(t, result, tc2casted, "msg with args %d %s", 42, "42")
	assert.Equal(t, result, tc3)
	assert.Equalf(t, result, tc3, "msg with args %d %s", 42, "42")
	assert.Equal(t, result, tc3casted)
	assert.Equalf(t, result, tc3casted, "msg with args %d %s", 42, "42")
	assert.Equal(t, result, tc4)
	assert.Equalf(t, result, tc4, "msg with args %d %s", 42, "42")
	assert.Equal(t, result, tc4casted)
	assert.Equalf(t, result, tc4casted, "msg with args %d %s", 42, "42")
	assert.Equal(t, result, tc5)
	assert.Equalf(t, result, tc5, "msg with args %d %s", 42, "42")
	assert.Equal(t, result, tc5casted)
	assert.Equalf(t, result, tc5casted, "msg with args %d %s", 42, "42")
	assert.Equal(t, result, tc6)
	assert.Equalf(t, result, tc6, "msg with args %d %s", 42, "42")
	assert.Equal(t, result, tc6casted)
	assert.Equalf(t, result, tc6casted, "msg with args %d %s", 42, "42")
	assert.Equal(t, result, tc7)
	assert.Equalf(t, result, tc7, "msg with args %d %s", 42, "42")
	assert.Equal(t, result, tc7casted)
	assert.Equalf(t, result, tc7casted, "msg with args %d %s", 42, "42")
	assert.Equal(t, result, tc8)
	assert.Equalf(t, result, tc8, "msg with args %d %s", 42, "42")
	assert.Equal(t, result, tc8casted)
	assert.Equalf(t, result, tc8casted, "msg with args %d %s", 42, "42")
	assert.Equal(t, result, tc9)
	assert.Equalf(t, result, tc9, "msg with args %d %s", 42, "42")
	assert.Equal(t, result, tc9casted)
	assert.Equalf(t, result, tc9casted, "msg with args %d %s", 42, "42")
	assert.Equal(t, result, tc10)
	assert.Equalf(t, result, tc10, "msg with args %d %s", 42, "42")
	assert.Equal(t, result, tc10casted)
	assert.Equalf(t, result, tc10casted, "msg with args %d %s", 42, "42")
	assert.Equal(t, result, tc11)
	assert.Equalf(t, result, tc11, "msg with args %d %s", 42, "42")
	assert.Equal(t, result, tc11casted)
	assert.Equalf(t, result, tc11casted, "msg with args %d %s", 42, "42")
	assert.Equal(t, result, tc12)
	assert.Equalf(t, result, tc12, "msg with args %d %s", 42, "42")
	assert.Equal(t, result, tc12casted)
	assert.Equalf(t, result, tc12casted, "msg with args %d %s", 42, "42")
	assert.Equal(t, result, tc13)
	assert.Equalf(t, result, tc13, "msg with args %d %s", 42, "42")
	assert.Equal(t, result, tc13casted)
	assert.Equalf(t, result, tc13casted, "msg with args %d %s", 42, "42")
	assert.Equal(t, result, tc14)
	assert.Equalf(t, result, tc14, "msg with args %d %s", 42, "42")
	assert.Equal(t, result, tc14casted)
	assert.Equalf(t, result, tc14casted, "msg with args %d %s", 42, "42")
	assert.Equal(t, result, tc15)
	assert.Equalf(t, result, tc15, "msg with args %d %s", 42, "42")
	assert.Equal(t, result, tc15casted)
	assert.Equalf(t, result, tc15casted, "msg with args %d %s", 42, "42")
	assert.Equal(t, result, tc16)
	assert.Equalf(t, result, tc16, "msg with args %d %s", 42, "42")
	assert.Equal(t, result, tc16casted)
	assert.Equalf(t, result, tc16casted, "msg with args %d %s", 42, "42")
	assert.Equal(t, result, tc17)
	assert.Equalf(t, result, tc17, "msg with args %d %s", 42, "42")
	assert.Equal(t, result, tc17casted)
	assert.Equalf(t, result, tc17casted, "msg with args %d %s", 42, "42")
	assert.Equal(t, result, tc18)
	assert.Equalf(t, result, tc18, "msg with args %d %s", 42, "42")
	assert.Equal(t, result, tc18casted)
	assert.Equalf(t, result, tc18casted, "msg with args %d %s", 42, "42")
	assert.Equal(t, result, tc19)
	assert.Equalf(t, result, tc19, "msg with args %d %s", 42, "42")
	assert.Equal(t, result, tc19casted)
	assert.Equalf(t, result, tc19casted, "msg with args %d %s", 42, "42")
	assert.Equal(t, result, tc20)
	assert.Equalf(t, result, tc20, "msg with args %d %s", 42, "42")
	assert.Equal(t, result, tc20casted)
	assert.Equalf(t, result, tc20casted, "msg with args %d %s", 42, "42")
	assert.Equal(t, result, uc0)
	assert.Equalf(t, result, uc0, "msg with args %d %s", 42, "42")
	assert.Equal(t, result, uc1)
	assert.Equalf(t, result, uc1, "msg with args %d %s", 42, "42")
	assert.Equal(t, result, uc2)
	assert.Equalf(t, result, uc2, "msg with args %d %s", 42, "42")
	assert.Equal(t, result, uc3)
	assert.Equalf(t, result, uc3, "msg with args %d %s", 42, "42")
	assert.Equal(t, result, uc4)
	assert.Equalf(t, result, uc4, "msg with args %d %s", 42, "42")
	assert.Equal(t, result, uc5)
	assert.Equalf(t, result, uc5, "msg with args %d %s", 42, "42")

	assert.NotEqual(t, result, tc0)
	assert.NotEqualf(t, result, tc0, "msg with args %d %s", 42, "42")
	assert.NotEqual(t, result, tc0casted)
	assert.NotEqualf(t, result, tc0casted, "msg with args %d %s", 42, "42")
	assert.NotEqual(t, result, tc1)
	assert.NotEqualf(t, result, tc1, "msg with args %d %s", 42, "42")
	assert.NotEqual(t, result, tc1casted)
	assert.NotEqualf(t, result, tc1casted, "msg with args %d %s", 42, "42")
	assert.NotEqual(t, result, tc2)
	assert.NotEqualf(t, result, tc2, "msg with args %d %s", 42, "42")
	assert.NotEqual(t, result, tc2casted)
	assert.NotEqualf(t, result, tc2casted, "msg with args %d %s", 42, "42")
	assert.NotEqual(t, result, tc3)
	assert.NotEqualf(t, result, tc3, "msg with args %d %s", 42, "42")
	assert.NotEqual(t, result, tc3casted)
	assert.NotEqualf(t, result, tc3casted, "msg with args %d %s", 42, "42")
	assert.NotEqual(t, result, tc4)
	assert.NotEqualf(t, result, tc4, "msg with args %d %s", 42, "42")
	assert.NotEqual(t, result, tc4casted)
	assert.NotEqualf(t, result, tc4casted, "msg with args %d %s", 42, "42")
	assert.NotEqual(t, result, tc5)
	assert.NotEqualf(t, result, tc5, "msg with args %d %s", 42, "42")
	assert.NotEqual(t, result, tc5casted)
	assert.NotEqualf(t, result, tc5casted, "msg with args %d %s", 42, "42")
	assert.NotEqual(t, result, tc6)
	assert.NotEqualf(t, result, tc6, "msg with args %d %s", 42, "42")
	assert.NotEqual(t, result, tc6casted)
	assert.NotEqualf(t, result, tc6casted, "msg with args %d %s", 42, "42")
	assert.NotEqual(t, result, tc7)
	assert.NotEqualf(t, result, tc7, "msg with args %d %s", 42, "42")
	assert.NotEqual(t, result, tc7casted)
	assert.NotEqualf(t, result, tc7casted, "msg with args %d %s", 42, "42")
	assert.NotEqual(t, result, tc8)
	assert.NotEqualf(t, result, tc8, "msg with args %d %s", 42, "42")
	assert.NotEqual(t, result, tc8casted)
	assert.NotEqualf(t, result, tc8casted, "msg with args %d %s", 42, "42")
	assert.NotEqual(t, result, tc9)
	assert.NotEqualf(t, result, tc9, "msg with args %d %s", 42, "42")
	assert.NotEqual(t, result, tc9casted)
	assert.NotEqualf(t, result, tc9casted, "msg with args %d %s", 42, "42")
	assert.NotEqual(t, result, tc10)
	assert.NotEqualf(t, result, tc10, "msg with args %d %s", 42, "42")
	assert.NotEqual(t, result, tc10casted)
	assert.NotEqualf(t, result, tc10casted, "msg with args %d %s", 42, "42")
	assert.NotEqual(t, result, tc11)
	assert.NotEqualf(t, result, tc11, "msg with args %d %s", 42, "42")
	assert.NotEqual(t, result, tc11casted)
	assert.NotEqualf(t, result, tc11casted, "msg with args %d %s", 42, "42")
	assert.NotEqual(t, result, tc12)
	assert.NotEqualf(t, result, tc12, "msg with args %d %s", 42, "42")
	assert.NotEqual(t, result, tc12casted)
	assert.NotEqualf(t, result, tc12casted, "msg with args %d %s", 42, "42")
	assert.NotEqual(t, result, tc13)
	assert.NotEqualf(t, result, tc13, "msg with args %d %s", 42, "42")
	assert.NotEqual(t, result, tc13casted)
	assert.NotEqualf(t, result, tc13casted, "msg with args %d %s", 42, "42")
	assert.NotEqual(t, result, tc14)
	assert.NotEqualf(t, result, tc14, "msg with args %d %s", 42, "42")
	assert.NotEqual(t, result, tc14casted)
	assert.NotEqualf(t, result, tc14casted, "msg with args %d %s", 42, "42")
	assert.NotEqual(t, result, tc15)
	assert.NotEqualf(t, result, tc15, "msg with args %d %s", 42, "42")
	assert.NotEqual(t, result, tc15casted)
	assert.NotEqualf(t, result, tc15casted, "msg with args %d %s", 42, "42")
	assert.NotEqual(t, result, tc16)
	assert.NotEqualf(t, result, tc16, "msg with args %d %s", 42, "42")
	assert.NotEqual(t, result, tc16casted)
	assert.NotEqualf(t, result, tc16casted, "msg with args %d %s", 42, "42")
	assert.NotEqual(t, result, tc17)
	assert.NotEqualf(t, result, tc17, "msg with args %d %s", 42, "42")
	assert.NotEqual(t, result, tc17casted)
	assert.NotEqualf(t, result, tc17casted, "msg with args %d %s", 42, "42")
	assert.NotEqual(t, result, tc18)
	assert.NotEqualf(t, result, tc18, "msg with args %d %s", 42, "42")
	assert.NotEqual(t, result, tc18casted)
	assert.NotEqualf(t, result, tc18casted, "msg with args %d %s", 42, "42")
	assert.NotEqual(t, result, tc19)
	assert.NotEqualf(t, result, tc19, "msg with args %d %s", 42, "42")
	assert.NotEqual(t, result, tc19casted)
	assert.NotEqualf(t, result, tc19casted, "msg with args %d %s", 42, "42")
	assert.NotEqual(t, result, tc20)
	assert.NotEqualf(t, result, tc20, "msg with args %d %s", 42, "42")
	assert.NotEqual(t, result, tc20casted)
	assert.NotEqualf(t, result, tc20casted, "msg with args %d %s", 42, "42")
	assert.NotEqual(t, result, uc0)
	assert.NotEqualf(t, result, uc0, "msg with args %d %s", 42, "42")
	assert.NotEqual(t, result, uc1)
	assert.NotEqualf(t, result, uc1, "msg with args %d %s", 42, "42")
	assert.NotEqual(t, result, uc2)
	assert.NotEqualf(t, result, uc2, "msg with args %d %s", 42, "42")
	assert.NotEqual(t, result, uc3)
	assert.NotEqualf(t, result, uc3, "msg with args %d %s", 42, "42")
	assert.NotEqual(t, result, uc4)
	assert.NotEqualf(t, result, uc4, "msg with args %d %s", 42, "42")
	assert.NotEqual(t, result, uc5)
	assert.NotEqualf(t, result, uc5, "msg with args %d %s", 42, "42")
}

func TestExpectedActualChecker_Ignored(t *testing.T) {
	var (
		result, expected                       any
		resultPtr, expectedPtr                 *int
		value                                  int
		expectedTime                           time.Time
		expectedFields, interfaces, directions []string
	)

	assert.Equal(t, nil, nil)
	assert.Equalf(t, nil, nil, "msg with args %d %s", 42, "42")
	assert.Equal(t, "value", "value")
	assert.Equalf(t, "value", "value", "msg with args %d %s", 42, "42")
	assert.Equal(t, expected, expected)
	assert.Equalf(t, expected, expected, "msg with args %d %s", 42, "42")
	assert.Equal(t, len(expectedFields), len(expectedFields))
	assert.Equalf(t, len(expectedFields), len(expectedFields), "msg with args %d %s", 42, "42")
	assert.Equal(t, len(interfaces), len(directions))
	assert.Equalf(t, len(interfaces), len(directions), "msg with args %d %s", 42, "42")
	assert.Equal(t, value, &resultPtr)
	assert.Equalf(t, value, &resultPtr, "msg with args %d %s", 42, "42")
	assert.Equal(t, []int{1, 2}, map[int]int{1: 2})
	assert.Equalf(t, []int{1, 2}, map[int]int{1: 2}, "msg with args %d %s", 42, "42")
	assert.NotEqual(t, result, result)
	assert.NotEqualf(t, result, result, "msg with args %d %s", 42, "42")
	assert.NotEqual(t, value, &resultPtr)
	assert.NotEqualf(t, value, &resultPtr, "msg with args %d %s", 42, "42")
	assert.EqualExportedValues(t, user{Name: "Rob"}, struct{ Name string }{Name: "Rob"})
	assert.EqualExportedValuesf(t, user{Name: "Rob"}, struct{ Name string }{Name: "Rob"}, "msg with args %d %s", 42, "42")
	assert.EqualValues(t, uint32(100), int32(100))
	assert.EqualValuesf(t, uint32(100), int32(100), "msg with args %d %s", 42, "42")
	assert.Exactly(t, int32(200), int64(200))
	assert.Exactlyf(t, int32(200), int64(200), "msg with args %d %s", 42, "42")
	assert.NotEqualValues(t, int32(100), uint32(100))
	assert.NotEqualValuesf(t, int32(100), uint32(100), "msg with args %d %s", 42, "42")
	assert.InDelta(t, 42.42, expected, 1.0)
	assert.InDeltaf(t, 42.42, expected, 1.0, "msg with args %d %s", 42, "42")
	assert.InDeltaMapValues(t, map[string]float64{"score": 0.99}, nil, 2.0)
	assert.InDeltaMapValuesf(t, map[string]float64{"score": 0.99}, nil, 2.0, "msg with args %d %s", 42, "42")
	assert.InDeltaSlice(t, []float64{0.98, 0.99}, []float64{0.97, 0.99}, 1.0)
	assert.InDeltaSlicef(t, []float64{0.98, 0.99}, []float64{0.97, 0.99}, 1.0, "msg with args %d %s", 42, "42")
	assert.InEpsilon(t, 42.42, 0.0001, 0.0001)
	assert.InEpsilonf(t, 42.42, 0.0001, 0.0001, "msg with args %d %s", 42, "42")
	assert.IsType(t, (*user)(nil), user{})
	assert.IsTypef(t, (*user)(nil), user{}, "msg with args %d %s", 42, "42")
	assert.Same(t, &value, &value)
	assert.Samef(t, &value, &value, "msg with args %d %s", 42, "42")
	assert.Same(t, resultPtr, &value)
	assert.Samef(t, resultPtr, &value, "msg with args %d %s", 42, "42")
	assert.Same(t, expectedPtr, &value)
	assert.Samef(t, expectedPtr, &value, "msg with args %d %s", 42, "42")
	assert.Same(t, &expected, value)
	assert.Samef(t, &expected, value, "msg with args %d %s", 42, "42")
	assert.NotSame(t, &value, &value)
	assert.NotSamef(t, &value, &value, "msg with args %d %s", 42, "42")
	assert.NotSame(t, resultPtr, &value)
	assert.NotSamef(t, resultPtr, &value, "msg with args %d %s", 42, "42")
	assert.NotSame(t, expectedPtr, &value)
	assert.NotSamef(t, expectedPtr, &value, "msg with args %d %s", 42, "42")
	assert.NotSame(t, &expected, value)
	assert.NotSamef(t, &expected, value, "msg with args %d %s", 42, "42")
	assert.WithinDuration(t, expectedTime, time.Now(), time.Second)
	assert.WithinDurationf(t, expectedTime, time.Now(), time.Second, "msg with args %d %s", 42, "42")
	assert.WithinDuration(t, time.Date(2023, 01, 12, 11, 46, 33, 0, nil), time.Date(2023, 01, 12, 11, 46, 33, 0, nil), time.Millisecond)
	assert.WithinDurationf(t, time.Date(2023, 01, 12, 11, 46, 33, 0, nil), time.Date(2023, 01, 12, 11, 46, 33, 0, nil), time.Millisecond, "msg with args %d %s", 42, "42")
}
