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

package uselessassert

import (
	"testing"
	"time"

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

func TestUselessAssertChecker(t *testing.T) {
	var value any
	var err error
	var elapsed time.Time
	var str string
	var num int
	var b bool
	var tc testCase
	var x []int

	// Invalid.
	{
		assert.Equal(t, 42, 42)                                                                           // want "useless-assert: asserting of the same variable"
		assert.Equal(t, 42, 42, "msg")                                                                    // want "useless-assert: asserting of the same variable"
		assert.Equal(t, 42, 42, "msg with arg %d", 42)                                                    // want "useless-assert: asserting of the same variable"
		assert.Equal(t, 42, 42, "msg with args %d %s", 42, "42")                                          // want "useless-assert: asserting of the same variable"
		assert.Equalf(t, 42, 42, "msg")                                                                   // want "useless-assert: asserting of the same variable"
		assert.Equalf(t, 42, 42, "msg with arg %d", 42)                                                   // want "useless-assert: asserting of the same variable"
		assert.Equalf(t, 42, 42, "msg with args %d %s", 42, "42")                                         // want "useless-assert: asserting of the same variable"
		assert.Equal(t, "value", "value")                                                                 // want "useless-assert: asserting of the same variable"
		assert.Equal(t, "value", "value", "msg")                                                          // want "useless-assert: asserting of the same variable"
		assert.Equal(t, "value", "value", "msg with arg %d", 42)                                          // want "useless-assert: asserting of the same variable"
		assert.Equal(t, "value", "value", "msg with args %d %s", 42, "42")                                // want "useless-assert: asserting of the same variable"
		assert.Equalf(t, "value", "value", "msg")                                                         // want "useless-assert: asserting of the same variable"
		assert.Equalf(t, "value", "value", "msg with arg %d", 42)                                         // want "useless-assert: asserting of the same variable"
		assert.Equalf(t, "value", "value", "msg with args %d %s", 42, "42")                               // want "useless-assert: asserting of the same variable"
		assert.Equal(t, value, value)                                                                     // want "useless-assert: asserting of the same variable"
		assert.Equal(t, value, value, "msg")                                                              // want "useless-assert: asserting of the same variable"
		assert.Equal(t, value, value, "msg with arg %d", 42)                                              // want "useless-assert: asserting of the same variable"
		assert.Equal(t, value, value, "msg with args %d %s", 42, "42")                                    // want "useless-assert: asserting of the same variable"
		assert.Equalf(t, value, value, "msg")                                                             // want "useless-assert: asserting of the same variable"
		assert.Equalf(t, value, value, "msg with arg %d", 42)                                             // want "useless-assert: asserting of the same variable"
		assert.Equalf(t, value, value, "msg with args %d %s", 42, "42")                                   // want "useless-assert: asserting of the same variable"
		assert.Equal(t, tc.A(), tc.A())                                                                   // want "useless-assert: asserting of the same variable"
		assert.Equal(t, tc.A(), tc.A(), "msg")                                                            // want "useless-assert: asserting of the same variable"
		assert.Equal(t, tc.A(), tc.A(), "msg with arg %d", 42)                                            // want "useless-assert: asserting of the same variable"
		assert.Equal(t, tc.A(), tc.A(), "msg with args %d %s", 42, "42")                                  // want "useless-assert: asserting of the same variable"
		assert.Equalf(t, tc.A(), tc.A(), "msg")                                                           // want "useless-assert: asserting of the same variable"
		assert.Equalf(t, tc.A(), tc.A(), "msg with arg %d", 42)                                           // want "useless-assert: asserting of the same variable"
		assert.Equalf(t, tc.A(), tc.A(), "msg with args %d %s", 42, "42")                                 // want "useless-assert: asserting of the same variable"
		assert.Equal(t, testCase{}.A().B().C(), testCase{}.A().B().C())                                   // want "useless-assert: asserting of the same variable"
		assert.Equal(t, testCase{}.A().B().C(), testCase{}.A().B().C(), "msg")                            // want "useless-assert: asserting of the same variable"
		assert.Equal(t, testCase{}.A().B().C(), testCase{}.A().B().C(), "msg with arg %d", 42)            // want "useless-assert: asserting of the same variable"
		assert.Equal(t, testCase{}.A().B().C(), testCase{}.A().B().C(), "msg with args %d %s", 42, "42")  // want "useless-assert: asserting of the same variable"
		assert.Equalf(t, testCase{}.A().B().C(), testCase{}.A().B().C(), "msg")                           // want "useless-assert: asserting of the same variable"
		assert.Equalf(t, testCase{}.A().B().C(), testCase{}.A().B().C(), "msg with arg %d", 42)           // want "useless-assert: asserting of the same variable"
		assert.Equalf(t, testCase{}.A().B().C(), testCase{}.A().B().C(), "msg with args %d %s", 42, "42") // want "useless-assert: asserting of the same variable"
		assert.IsNotType(t, (*testCase)(nil), (*testCase)(nil))                                           // want "useless-assert: asserting of the same variable"
		assert.IsNotType(t, (*testCase)(nil), (*testCase)(nil), "msg")                                    // want "useless-assert: asserting of the same variable"
		assert.IsNotType(t, (*testCase)(nil), (*testCase)(nil), "msg with arg %d", 42)                    // want "useless-assert: asserting of the same variable"
		assert.IsNotType(t, (*testCase)(nil), (*testCase)(nil), "msg with args %d %s", 42, "42")          // want "useless-assert: asserting of the same variable"
		assert.IsNotTypef(t, (*testCase)(nil), (*testCase)(nil), "msg")                                   // want "useless-assert: asserting of the same variable"
		assert.IsNotTypef(t, (*testCase)(nil), (*testCase)(nil), "msg with arg %d", 42)                   // want "useless-assert: asserting of the same variable"
		assert.IsNotTypef(t, (*testCase)(nil), (*testCase)(nil), "msg with args %d %s", 42, "42")         // want "useless-assert: asserting of the same variable"
		assert.IsType(t, (*testCase)(nil), (*testCase)(nil))                                              // want "useless-assert: asserting of the same variable"
		assert.IsType(t, (*testCase)(nil), (*testCase)(nil), "msg")                                       // want "useless-assert: asserting of the same variable"
		assert.IsType(t, (*testCase)(nil), (*testCase)(nil), "msg with arg %d", 42)                       // want "useless-assert: asserting of the same variable"
		assert.IsType(t, (*testCase)(nil), (*testCase)(nil), "msg with args %d %s", 42, "42")             // want "useless-assert: asserting of the same variable"
		assert.IsTypef(t, (*testCase)(nil), (*testCase)(nil), "msg")                                      // want "useless-assert: asserting of the same variable"
		assert.IsTypef(t, (*testCase)(nil), (*testCase)(nil), "msg with arg %d", 42)                      // want "useless-assert: asserting of the same variable"
		assert.IsTypef(t, (*testCase)(nil), (*testCase)(nil), "msg with args %d %s", 42, "42")            // want "useless-assert: asserting of the same variable"
		assert.Empty(t, "")                                                                               // want "useless-assert: meaningless assertion"
		assert.Empty(t, "", "msg")                                                                        // want "useless-assert: meaningless assertion"
		assert.Empty(t, "", "msg with arg %d", 42)                                                        // want "useless-assert: meaningless assertion"
		assert.Empty(t, "", "msg with args %d %s", 42, "42")                                              // want "useless-assert: meaningless assertion"
		assert.Emptyf(t, "", "msg")                                                                       // want "useless-assert: meaningless assertion"
		assert.Emptyf(t, "", "msg with arg %d", 42)                                                       // want "useless-assert: meaningless assertion"
		assert.Emptyf(t, "", "msg with args %d %s", 42, "42")                                             // want "useless-assert: meaningless assertion"
		assert.Empty(t, ``)                                                                               // want "useless-assert: meaningless assertion"
		assert.Empty(t, ``, "msg")                                                                        // want "useless-assert: meaningless assertion"
		assert.Empty(t, ``, "msg with arg %d", 42)                                                        // want "useless-assert: meaningless assertion"
		assert.Empty(t, ``, "msg with args %d %s", 42, "42")                                              // want "useless-assert: meaningless assertion"
		assert.Emptyf(t, ``, "msg")                                                                       // want "useless-assert: meaningless assertion"
		assert.Emptyf(t, ``, "msg with arg %d", 42)                                                       // want "useless-assert: meaningless assertion"
		assert.Emptyf(t, ``, "msg with args %d %s", 42, "42")                                             // want "useless-assert: meaningless assertion"
		assert.Empty(t, "value")                                                                          // want "useless-assert: meaningless assertion"
		assert.Empty(t, "value", "msg")                                                                   // want "useless-assert: meaningless assertion"
		assert.Empty(t, "value", "msg with arg %d", 42)                                                   // want "useless-assert: meaningless assertion"
		assert.Empty(t, "value", "msg with args %d %s", 42, "42")                                         // want "useless-assert: meaningless assertion"
		assert.Emptyf(t, "value", "msg")                                                                  // want "useless-assert: meaningless assertion"
		assert.Emptyf(t, "value", "msg with arg %d", 42)                                                  // want "useless-assert: meaningless assertion"
		assert.Emptyf(t, "value", "msg with args %d %s", 42, "42")                                        // want "useless-assert: meaningless assertion"
		assert.Error(t, nil)                                                                              // want "useless-assert: meaningless assertion"
		assert.Error(t, nil, "msg")                                                                       // want "useless-assert: meaningless assertion"
		assert.Error(t, nil, "msg with arg %d", 42)                                                       // want "useless-assert: meaningless assertion"
		assert.Error(t, nil, "msg with args %d %s", 42, "42")                                             // want "useless-assert: meaningless assertion"
		assert.Errorf(t, nil, "msg")                                                                      // want "useless-assert: meaningless assertion"
		assert.Errorf(t, nil, "msg with arg %d", 42)                                                      // want "useless-assert: meaningless assertion"
		assert.Errorf(t, nil, "msg with args %d %s", 42, "42")                                            // want "useless-assert: meaningless assertion"
		assert.False(t, false)                                                                            // want "useless-assert: meaningless assertion"
		assert.False(t, false, "msg")                                                                     // want "useless-assert: meaningless assertion"
		assert.False(t, false, "msg with arg %d", 42)                                                     // want "useless-assert: meaningless assertion"
		assert.False(t, false, "msg with args %d %s", 42, "42")                                           // want "useless-assert: meaningless assertion"
		assert.Falsef(t, false, "msg")                                                                    // want "useless-assert: meaningless assertion"
		assert.Falsef(t, false, "msg with arg %d", 42)                                                    // want "useless-assert: meaningless assertion"
		assert.Falsef(t, false, "msg with args %d %s", 42, "42")                                          // want "useless-assert: meaningless assertion"
		assert.False(t, true)                                                                             // want "useless-assert: meaningless assertion"
		assert.False(t, true, "msg")                                                                      // want "useless-assert: meaningless assertion"
		assert.False(t, true, "msg with arg %d", 42)                                                      // want "useless-assert: meaningless assertion"
		assert.False(t, true, "msg with args %d %s", 42, "42")                                            // want "useless-assert: meaningless assertion"
		assert.Falsef(t, true, "msg")                                                                     // want "useless-assert: meaningless assertion"
		assert.Falsef(t, true, "msg with arg %d", 42)                                                     // want "useless-assert: meaningless assertion"
		assert.Falsef(t, true, "msg with args %d %s", 42, "42")                                           // want "useless-assert: meaningless assertion"
		assert.Implements(t, (*any)(nil), new(testing.T))                                                 // want "useless-assert: meaningless assertion"
		assert.Implements(t, (*any)(nil), new(testing.T), "msg")                                          // want "useless-assert: meaningless assertion"
		assert.Implements(t, (*any)(nil), new(testing.T), "msg with arg %d", 42)                          // want "useless-assert: meaningless assertion"
		assert.Implements(t, (*any)(nil), new(testing.T), "msg with args %d %s", 42, "42")                // want "useless-assert: meaningless assertion"
		assert.Implementsf(t, (*any)(nil), new(testing.T), "msg")                                         // want "useless-assert: meaningless assertion"
		assert.Implementsf(t, (*any)(nil), new(testing.T), "msg with arg %d", 42)                         // want "useless-assert: meaningless assertion"
		assert.Implementsf(t, (*any)(nil), new(testing.T), "msg with args %d %s", 42, "42")               // want "useless-assert: meaningless assertion"
		assert.Negative(t, 42)                                                                            // want "useless-assert: meaningless assertion"
		assert.Negative(t, 42, "msg")                                                                     // want "useless-assert: meaningless assertion"
		assert.Negative(t, 42, "msg with arg %d", 42)                                                     // want "useless-assert: meaningless assertion"
		assert.Negative(t, 42, "msg with args %d %s", 42, "42")                                           // want "useless-assert: meaningless assertion"
		assert.Negativef(t, 42, "msg")                                                                    // want "useless-assert: meaningless assertion"
		assert.Negativef(t, 42, "msg with arg %d", 42)                                                    // want "useless-assert: meaningless assertion"
		assert.Negativef(t, 42, "msg with args %d %s", 42, "42")                                          // want "useless-assert: meaningless assertion"
		assert.Negative(t, 0)                                                                             // want "useless-assert: meaningless assertion"
		assert.Negative(t, 0, "msg")                                                                      // want "useless-assert: meaningless assertion"
		assert.Negative(t, 0, "msg with arg %d", 42)                                                      // want "useless-assert: meaningless assertion"
		assert.Negative(t, 0, "msg with args %d %s", 42, "42")                                            // want "useless-assert: meaningless assertion"
		assert.Negativef(t, 0, "msg")                                                                     // want "useless-assert: meaningless assertion"
		assert.Negativef(t, 0, "msg with arg %d", 42)                                                     // want "useless-assert: meaningless assertion"
		assert.Negativef(t, 0, "msg with args %d %s", 42, "42")                                           // want "useless-assert: meaningless assertion"
		assert.Negative(t, -42)                                                                           // want "useless-assert: meaningless assertion"
		assert.Negative(t, -42, "msg")                                                                    // want "useless-assert: meaningless assertion"
		assert.Negative(t, -42, "msg with arg %d", 42)                                                    // want "useless-assert: meaningless assertion"
		assert.Negative(t, -42, "msg with args %d %s", 42, "42")                                          // want "useless-assert: meaningless assertion"
		assert.Negativef(t, -42, "msg")                                                                   // want "useless-assert: meaningless assertion"
		assert.Negativef(t, -42, "msg with arg %d", 42)                                                   // want "useless-assert: meaningless assertion"
		assert.Negativef(t, -42, "msg with args %d %s", 42, "42")                                         // want "useless-assert: meaningless assertion"
		assert.Nil(t, nil)                                                                                // want "useless-assert: meaningless assertion"
		assert.Nil(t, nil, "msg")                                                                         // want "useless-assert: meaningless assertion"
		assert.Nil(t, nil, "msg with arg %d", 42)                                                         // want "useless-assert: meaningless assertion"
		assert.Nil(t, nil, "msg with args %d %s", 42, "42")                                               // want "useless-assert: meaningless assertion"
		assert.Nilf(t, nil, "msg")                                                                        // want "useless-assert: meaningless assertion"
		assert.Nilf(t, nil, "msg with arg %d", 42)                                                        // want "useless-assert: meaningless assertion"
		assert.Nilf(t, nil, "msg with args %d %s", 42, "42")                                              // want "useless-assert: meaningless assertion"
		assert.NoError(t, nil)                                                                            // want "useless-assert: meaningless assertion"
		assert.NoError(t, nil, "msg")                                                                     // want "useless-assert: meaningless assertion"
		assert.NoError(t, nil, "msg with arg %d", 42)                                                     // want "useless-assert: meaningless assertion"
		assert.NoError(t, nil, "msg with args %d %s", 42, "42")                                           // want "useless-assert: meaningless assertion"
		assert.NoErrorf(t, nil, "msg")                                                                    // want "useless-assert: meaningless assertion"
		assert.NoErrorf(t, nil, "msg with arg %d", 42)                                                    // want "useless-assert: meaningless assertion"
		assert.NoErrorf(t, nil, "msg with args %d %s", 42, "42")                                          // want "useless-assert: meaningless assertion"
		assert.NotEmpty(t, "")                                                                            // want "useless-assert: meaningless assertion"
		assert.NotEmpty(t, "", "msg")                                                                     // want "useless-assert: meaningless assertion"
		assert.NotEmpty(t, "", "msg with arg %d", 42)                                                     // want "useless-assert: meaningless assertion"
		assert.NotEmpty(t, "", "msg with args %d %s", 42, "42")                                           // want "useless-assert: meaningless assertion"
		assert.NotEmptyf(t, "", "msg")                                                                    // want "useless-assert: meaningless assertion"
		assert.NotEmptyf(t, "", "msg with arg %d", 42)                                                    // want "useless-assert: meaningless assertion"
		assert.NotEmptyf(t, "", "msg with args %d %s", 42, "42")                                          // want "useless-assert: meaningless assertion"
		assert.NotEmpty(t, ``)                                                                            // want "useless-assert: meaningless assertion"
		assert.NotEmpty(t, ``, "msg")                                                                     // want "useless-assert: meaningless assertion"
		assert.NotEmpty(t, ``, "msg with arg %d", 42)                                                     // want "useless-assert: meaningless assertion"
		assert.NotEmpty(t, ``, "msg with args %d %s", 42, "42")                                           // want "useless-assert: meaningless assertion"
		assert.NotEmptyf(t, ``, "msg")                                                                    // want "useless-assert: meaningless assertion"
		assert.NotEmptyf(t, ``, "msg with arg %d", 42)                                                    // want "useless-assert: meaningless assertion"
		assert.NotEmptyf(t, ``, "msg with args %d %s", 42, "42")                                          // want "useless-assert: meaningless assertion"
		assert.NotEmpty(t, "value")                                                                       // want "useless-assert: meaningless assertion"
		assert.NotEmpty(t, "value", "msg")                                                                // want "useless-assert: meaningless assertion"
		assert.NotEmpty(t, "value", "msg with arg %d", 42)                                                // want "useless-assert: meaningless assertion"
		assert.NotEmpty(t, "value", "msg with args %d %s", 42, "42")                                      // want "useless-assert: meaningless assertion"
		assert.NotEmptyf(t, "value", "msg")                                                               // want "useless-assert: meaningless assertion"
		assert.NotEmptyf(t, "value", "msg with arg %d", 42)                                               // want "useless-assert: meaningless assertion"
		assert.NotEmptyf(t, "value", "msg with args %d %s", 42, "42")                                     // want "useless-assert: meaningless assertion"
		assert.NotImplements(t, (*any)(nil), new(testing.T))                                              // want "useless-assert: meaningless assertion"
		assert.NotImplements(t, (*any)(nil), new(testing.T), "msg")                                       // want "useless-assert: meaningless assertion"
		assert.NotImplements(t, (*any)(nil), new(testing.T), "msg with arg %d", 42)                       // want "useless-assert: meaningless assertion"
		assert.NotImplements(t, (*any)(nil), new(testing.T), "msg with args %d %s", 42, "42")             // want "useless-assert: meaningless assertion"
		assert.NotImplementsf(t, (*any)(nil), new(testing.T), "msg")                                      // want "useless-assert: meaningless assertion"
		assert.NotImplementsf(t, (*any)(nil), new(testing.T), "msg with arg %d", 42)                      // want "useless-assert: meaningless assertion"
		assert.NotImplementsf(t, (*any)(nil), new(testing.T), "msg with args %d %s", 42, "42")            // want "useless-assert: meaningless assertion"
		assert.NotNil(t, nil)                                                                             // want "useless-assert: meaningless assertion"
		assert.NotNil(t, nil, "msg")                                                                      // want "useless-assert: meaningless assertion"
		assert.NotNil(t, nil, "msg with arg %d", 42)                                                      // want "useless-assert: meaningless assertion"
		assert.NotNil(t, nil, "msg with args %d %s", 42, "42")                                            // want "useless-assert: meaningless assertion"
		assert.NotNilf(t, nil, "msg")                                                                     // want "useless-assert: meaningless assertion"
		assert.NotNilf(t, nil, "msg with arg %d", 42)                                                     // want "useless-assert: meaningless assertion"
		assert.NotNilf(t, nil, "msg with args %d %s", 42, "42")                                           // want "useless-assert: meaningless assertion"
		assert.NotZero(t, 42)                                                                             // want "useless-assert: meaningless assertion"
		assert.NotZero(t, 42, "msg")                                                                      // want "useless-assert: meaningless assertion"
		assert.NotZero(t, 42, "msg with arg %d", 42)                                                      // want "useless-assert: meaningless assertion"
		assert.NotZero(t, 42, "msg with args %d %s", 42, "42")                                            // want "useless-assert: meaningless assertion"
		assert.NotZerof(t, 42, "msg")                                                                     // want "useless-assert: meaningless assertion"
		assert.NotZerof(t, 42, "msg with arg %d", 42)                                                     // want "useless-assert: meaningless assertion"
		assert.NotZerof(t, 42, "msg with args %d %s", 42, "42")                                           // want "useless-assert: meaningless assertion"
		assert.NotZero(t, 0)                                                                              // want "useless-assert: meaningless assertion"
		assert.NotZero(t, 0, "msg")                                                                       // want "useless-assert: meaningless assertion"
		assert.NotZero(t, 0, "msg with arg %d", 42)                                                       // want "useless-assert: meaningless assertion"
		assert.NotZero(t, 0, "msg with args %d %s", 42, "42")                                             // want "useless-assert: meaningless assertion"
		assert.NotZerof(t, 0, "msg")                                                                      // want "useless-assert: meaningless assertion"
		assert.NotZerof(t, 0, "msg with arg %d", 42)                                                      // want "useless-assert: meaningless assertion"
		assert.NotZerof(t, 0, "msg with args %d %s", 42, "42")                                            // want "useless-assert: meaningless assertion"
		assert.NotZero(t, -42)                                                                            // want "useless-assert: meaningless assertion"
		assert.NotZero(t, -42, "msg")                                                                     // want "useless-assert: meaningless assertion"
		assert.NotZero(t, -42, "msg with arg %d", 42)                                                     // want "useless-assert: meaningless assertion"
		assert.NotZero(t, -42, "msg with args %d %s", 42, "42")                                           // want "useless-assert: meaningless assertion"
		assert.NotZerof(t, -42, "msg")                                                                    // want "useless-assert: meaningless assertion"
		assert.NotZerof(t, -42, "msg with arg %d", 42)                                                    // want "useless-assert: meaningless assertion"
		assert.NotZerof(t, -42, "msg with args %d %s", 42, "42")                                          // want "useless-assert: meaningless assertion"
		assert.NotZero(t, "")                                                                             // want "useless-assert: meaningless assertion"
		assert.NotZero(t, "", "msg")                                                                      // want "useless-assert: meaningless assertion"
		assert.NotZero(t, "", "msg with arg %d", 42)                                                      // want "useless-assert: meaningless assertion"
		assert.NotZero(t, "", "msg with args %d %s", 42, "42")                                            // want "useless-assert: meaningless assertion"
		assert.NotZerof(t, "", "msg")                                                                     // want "useless-assert: meaningless assertion"
		assert.NotZerof(t, "", "msg with arg %d", 42)                                                     // want "useless-assert: meaningless assertion"
		assert.NotZerof(t, "", "msg with args %d %s", 42, "42")                                           // want "useless-assert: meaningless assertion"
		assert.NotZero(t, ``)                                                                             // want "useless-assert: meaningless assertion"
		assert.NotZero(t, ``, "msg")                                                                      // want "useless-assert: meaningless assertion"
		assert.NotZero(t, ``, "msg with arg %d", 42)                                                      // want "useless-assert: meaningless assertion"
		assert.NotZero(t, ``, "msg with args %d %s", 42, "42")                                            // want "useless-assert: meaningless assertion"
		assert.NotZerof(t, ``, "msg")                                                                     // want "useless-assert: meaningless assertion"
		assert.NotZerof(t, ``, "msg with arg %d", 42)                                                     // want "useless-assert: meaningless assertion"
		assert.NotZerof(t, ``, "msg with args %d %s", 42, "42")                                           // want "useless-assert: meaningless assertion"
		assert.NotZero(t, "value")                                                                        // want "useless-assert: meaningless assertion"
		assert.NotZero(t, "value", "msg")                                                                 // want "useless-assert: meaningless assertion"
		assert.NotZero(t, "value", "msg with arg %d", 42)                                                 // want "useless-assert: meaningless assertion"
		assert.NotZero(t, "value", "msg with args %d %s", 42, "42")                                       // want "useless-assert: meaningless assertion"
		assert.NotZerof(t, "value", "msg")                                                                // want "useless-assert: meaningless assertion"
		assert.NotZerof(t, "value", "msg with arg %d", 42)                                                // want "useless-assert: meaningless assertion"
		assert.NotZerof(t, "value", "msg with args %d %s", 42, "42")                                      // want "useless-assert: meaningless assertion"
		assert.NotZero(t, nil)                                                                            // want "useless-assert: meaningless assertion"
		assert.NotZero(t, nil, "msg")                                                                     // want "useless-assert: meaningless assertion"
		assert.NotZero(t, nil, "msg with arg %d", 42)                                                     // want "useless-assert: meaningless assertion"
		assert.NotZero(t, nil, "msg with args %d %s", 42, "42")                                           // want "useless-assert: meaningless assertion"
		assert.NotZerof(t, nil, "msg")                                                                    // want "useless-assert: meaningless assertion"
		assert.NotZerof(t, nil, "msg with arg %d", 42)                                                    // want "useless-assert: meaningless assertion"
		assert.NotZerof(t, nil, "msg with args %d %s", 42, "42")                                          // want "useless-assert: meaningless assertion"
		assert.NotZero(t, false)                                                                          // want "useless-assert: meaningless assertion"
		assert.NotZero(t, false, "msg")                                                                   // want "useless-assert: meaningless assertion"
		assert.NotZero(t, false, "msg with arg %d", 42)                                                   // want "useless-assert: meaningless assertion"
		assert.NotZero(t, false, "msg with args %d %s", 42, "42")                                         // want "useless-assert: meaningless assertion"
		assert.NotZerof(t, false, "msg")                                                                  // want "useless-assert: meaningless assertion"
		assert.NotZerof(t, false, "msg with arg %d", 42)                                                  // want "useless-assert: meaningless assertion"
		assert.NotZerof(t, false, "msg with args %d %s", 42, "42")                                        // want "useless-assert: meaningless assertion"
		assert.NotZero(t, true)                                                                           // want "useless-assert: meaningless assertion"
		assert.NotZero(t, true, "msg")                                                                    // want "useless-assert: meaningless assertion"
		assert.NotZero(t, true, "msg with arg %d", 42)                                                    // want "useless-assert: meaningless assertion"
		assert.NotZero(t, true, "msg with args %d %s", 42, "42")                                          // want "useless-assert: meaningless assertion"
		assert.NotZerof(t, true, "msg")                                                                   // want "useless-assert: meaningless assertion"
		assert.NotZerof(t, true, "msg with arg %d", 42)                                                   // want "useless-assert: meaningless assertion"
		assert.NotZerof(t, true, "msg with args %d %s", 42, "42")                                         // want "useless-assert: meaningless assertion"
		assert.Positive(t, 42)                                                                            // want "useless-assert: meaningless assertion"
		assert.Positive(t, 42, "msg")                                                                     // want "useless-assert: meaningless assertion"
		assert.Positive(t, 42, "msg with arg %d", 42)                                                     // want "useless-assert: meaningless assertion"
		assert.Positive(t, 42, "msg with args %d %s", 42, "42")                                           // want "useless-assert: meaningless assertion"
		assert.Positivef(t, 42, "msg")                                                                    // want "useless-assert: meaningless assertion"
		assert.Positivef(t, 42, "msg with arg %d", 42)                                                    // want "useless-assert: meaningless assertion"
		assert.Positivef(t, 42, "msg with args %d %s", 42, "42")                                          // want "useless-assert: meaningless assertion"
		assert.Positive(t, 0)                                                                             // want "useless-assert: meaningless assertion"
		assert.Positive(t, 0, "msg")                                                                      // want "useless-assert: meaningless assertion"
		assert.Positive(t, 0, "msg with arg %d", 42)                                                      // want "useless-assert: meaningless assertion"
		assert.Positive(t, 0, "msg with args %d %s", 42, "42")                                            // want "useless-assert: meaningless assertion"
		assert.Positivef(t, 0, "msg")                                                                     // want "useless-assert: meaningless assertion"
		assert.Positivef(t, 0, "msg with arg %d", 42)                                                     // want "useless-assert: meaningless assertion"
		assert.Positivef(t, 0, "msg with args %d %s", 42, "42")                                           // want "useless-assert: meaningless assertion"
		assert.Positive(t, -42)                                                                           // want "useless-assert: meaningless assertion"
		assert.Positive(t, -42, "msg")                                                                    // want "useless-assert: meaningless assertion"
		assert.Positive(t, -42, "msg with arg %d", 42)                                                    // want "useless-assert: meaningless assertion"
		assert.Positive(t, -42, "msg with args %d %s", 42, "42")                                          // want "useless-assert: meaningless assertion"
		assert.Positivef(t, -42, "msg")                                                                   // want "useless-assert: meaningless assertion"
		assert.Positivef(t, -42, "msg with arg %d", 42)                                                   // want "useless-assert: meaningless assertion"
		assert.Positivef(t, -42, "msg with args %d %s", 42, "42")                                         // want "useless-assert: meaningless assertion"
		assert.True(t, false)                                                                             // want "useless-assert: meaningless assertion"
		assert.True(t, false, "msg")                                                                      // want "useless-assert: meaningless assertion"
		assert.True(t, false, "msg with arg %d", 42)                                                      // want "useless-assert: meaningless assertion"
		assert.True(t, false, "msg with args %d %s", 42, "42")                                            // want "useless-assert: meaningless assertion"
		assert.Truef(t, false, "msg")                                                                     // want "useless-assert: meaningless assertion"
		assert.Truef(t, false, "msg with arg %d", 42)                                                     // want "useless-assert: meaningless assertion"
		assert.Truef(t, false, "msg with args %d %s", 42, "42")                                           // want "useless-assert: meaningless assertion"
		assert.True(t, true)                                                                              // want "useless-assert: meaningless assertion"
		assert.True(t, true, "msg")                                                                       // want "useless-assert: meaningless assertion"
		assert.True(t, true, "msg with arg %d", 42)                                                       // want "useless-assert: meaningless assertion"
		assert.True(t, true, "msg with args %d %s", 42, "42")                                             // want "useless-assert: meaningless assertion"
		assert.Truef(t, true, "msg")                                                                      // want "useless-assert: meaningless assertion"
		assert.Truef(t, true, "msg with arg %d", 42)                                                      // want "useless-assert: meaningless assertion"
		assert.Truef(t, true, "msg with args %d %s", 42, "42")                                            // want "useless-assert: meaningless assertion"
		assert.Zero(t, 42)                                                                                // want "useless-assert: meaningless assertion"
		assert.Zero(t, 42, "msg")                                                                         // want "useless-assert: meaningless assertion"
		assert.Zero(t, 42, "msg with arg %d", 42)                                                         // want "useless-assert: meaningless assertion"
		assert.Zero(t, 42, "msg with args %d %s", 42, "42")                                               // want "useless-assert: meaningless assertion"
		assert.Zerof(t, 42, "msg")                                                                        // want "useless-assert: meaningless assertion"
		assert.Zerof(t, 42, "msg with arg %d", 42)                                                        // want "useless-assert: meaningless assertion"
		assert.Zerof(t, 42, "msg with args %d %s", 42, "42")                                              // want "useless-assert: meaningless assertion"
		assert.Zero(t, 0)                                                                                 // want "useless-assert: meaningless assertion"
		assert.Zero(t, 0, "msg")                                                                          // want "useless-assert: meaningless assertion"
		assert.Zero(t, 0, "msg with arg %d", 42)                                                          // want "useless-assert: meaningless assertion"
		assert.Zero(t, 0, "msg with args %d %s", 42, "42")                                                // want "useless-assert: meaningless assertion"
		assert.Zerof(t, 0, "msg")                                                                         // want "useless-assert: meaningless assertion"
		assert.Zerof(t, 0, "msg with arg %d", 42)                                                         // want "useless-assert: meaningless assertion"
		assert.Zerof(t, 0, "msg with args %d %s", 42, "42")                                               // want "useless-assert: meaningless assertion"
		assert.Zero(t, -42)                                                                               // want "useless-assert: meaningless assertion"
		assert.Zero(t, -42, "msg")                                                                        // want "useless-assert: meaningless assertion"
		assert.Zero(t, -42, "msg with arg %d", 42)                                                        // want "useless-assert: meaningless assertion"
		assert.Zero(t, -42, "msg with args %d %s", 42, "42")                                              // want "useless-assert: meaningless assertion"
		assert.Zerof(t, -42, "msg")                                                                       // want "useless-assert: meaningless assertion"
		assert.Zerof(t, -42, "msg with arg %d", 42)                                                       // want "useless-assert: meaningless assertion"
		assert.Zerof(t, -42, "msg with args %d %s", 42, "42")                                             // want "useless-assert: meaningless assertion"
		assert.Zero(t, "")                                                                                // want "useless-assert: meaningless assertion"
		assert.Zero(t, "", "msg")                                                                         // want "useless-assert: meaningless assertion"
		assert.Zero(t, "", "msg with arg %d", 42)                                                         // want "useless-assert: meaningless assertion"
		assert.Zero(t, "", "msg with args %d %s", 42, "42")                                               // want "useless-assert: meaningless assertion"
		assert.Zerof(t, "", "msg")                                                                        // want "useless-assert: meaningless assertion"
		assert.Zerof(t, "", "msg with arg %d", 42)                                                        // want "useless-assert: meaningless assertion"
		assert.Zerof(t, "", "msg with args %d %s", 42, "42")                                              // want "useless-assert: meaningless assertion"
		assert.Zero(t, ``)                                                                                // want "useless-assert: meaningless assertion"
		assert.Zero(t, ``, "msg")                                                                         // want "useless-assert: meaningless assertion"
		assert.Zero(t, ``, "msg with arg %d", 42)                                                         // want "useless-assert: meaningless assertion"
		assert.Zero(t, ``, "msg with args %d %s", 42, "42")                                               // want "useless-assert: meaningless assertion"
		assert.Zerof(t, ``, "msg")                                                                        // want "useless-assert: meaningless assertion"
		assert.Zerof(t, ``, "msg with arg %d", 42)                                                        // want "useless-assert: meaningless assertion"
		assert.Zerof(t, ``, "msg with args %d %s", 42, "42")                                              // want "useless-assert: meaningless assertion"
		assert.Zero(t, "value")                                                                           // want "useless-assert: meaningless assertion"
		assert.Zero(t, "value", "msg")                                                                    // want "useless-assert: meaningless assertion"
		assert.Zero(t, "value", "msg with arg %d", 42)                                                    // want "useless-assert: meaningless assertion"
		assert.Zero(t, "value", "msg with args %d %s", 42, "42")                                          // want "useless-assert: meaningless assertion"
		assert.Zerof(t, "value", "msg")                                                                   // want "useless-assert: meaningless assertion"
		assert.Zerof(t, "value", "msg with arg %d", 42)                                                   // want "useless-assert: meaningless assertion"
		assert.Zerof(t, "value", "msg with args %d %s", 42, "42")                                         // want "useless-assert: meaningless assertion"
		assert.Zero(t, nil)                                                                               // want "useless-assert: meaningless assertion"
		assert.Zero(t, nil, "msg")                                                                        // want "useless-assert: meaningless assertion"
		assert.Zero(t, nil, "msg with arg %d", 42)                                                        // want "useless-assert: meaningless assertion"
		assert.Zero(t, nil, "msg with args %d %s", 42, "42")                                              // want "useless-assert: meaningless assertion"
		assert.Zerof(t, nil, "msg")                                                                       // want "useless-assert: meaningless assertion"
		assert.Zerof(t, nil, "msg with arg %d", 42)                                                       // want "useless-assert: meaningless assertion"
		assert.Zerof(t, nil, "msg with args %d %s", 42, "42")                                             // want "useless-assert: meaningless assertion"
		assert.Zero(t, false)                                                                             // want "useless-assert: meaningless assertion"
		assert.Zero(t, false, "msg")                                                                      // want "useless-assert: meaningless assertion"
		assert.Zero(t, false, "msg with arg %d", 42)                                                      // want "useless-assert: meaningless assertion"
		assert.Zero(t, false, "msg with args %d %s", 42, "42")                                            // want "useless-assert: meaningless assertion"
		assert.Zerof(t, false, "msg")                                                                     // want "useless-assert: meaningless assertion"
		assert.Zerof(t, false, "msg with arg %d", 42)                                                     // want "useless-assert: meaningless assertion"
		assert.Zerof(t, false, "msg with args %d %s", 42, "42")                                           // want "useless-assert: meaningless assertion"
		assert.Zero(t, true)                                                                              // want "useless-assert: meaningless assertion"
		assert.Zero(t, true, "msg")                                                                       // want "useless-assert: meaningless assertion"
		assert.Zero(t, true, "msg with arg %d", 42)                                                       // want "useless-assert: meaningless assertion"
		assert.Zero(t, true, "msg with args %d %s", 42, "42")                                             // want "useless-assert: meaningless assertion"
		assert.Zerof(t, true, "msg")                                                                      // want "useless-assert: meaningless assertion"
		assert.Zerof(t, true, "msg with arg %d", 42)                                                      // want "useless-assert: meaningless assertion"
		assert.Zerof(t, true, "msg with args %d %s", 42, "42")                                            // want "useless-assert: meaningless assertion"
		assert.Negative(t, len(x))                                                                        // want "useless-assert: meaningless assertion"
		assert.Negative(t, len(x), "msg")                                                                 // want "useless-assert: meaningless assertion"
		assert.Negative(t, len(x), "msg with arg %d", 42)                                                 // want "useless-assert: meaningless assertion"
		assert.Negative(t, len(x), "msg with args %d %s", 42, "42")                                       // want "useless-assert: meaningless assertion"
		assert.Negativef(t, len(x), "msg")                                                                // want "useless-assert: meaningless assertion"
		assert.Negativef(t, len(x), "msg with arg %d", 42)                                                // want "useless-assert: meaningless assertion"
		assert.Negativef(t, len(x), "msg with args %d %s", 42, "42")                                      // want "useless-assert: meaningless assertion"
		assert.Less(t, len(x), 0)                                                                         // want "useless-assert: meaningless assertion"
		assert.Less(t, len(x), 0, "msg")                                                                  // want "useless-assert: meaningless assertion"
		assert.Less(t, len(x), 0, "msg with arg %d", 42)                                                  // want "useless-assert: meaningless assertion"
		assert.Less(t, len(x), 0, "msg with args %d %s", 42, "42")                                        // want "useless-assert: meaningless assertion"
		assert.Lessf(t, len(x), 0, "msg")                                                                 // want "useless-assert: meaningless assertion"
		assert.Lessf(t, len(x), 0, "msg with arg %d", 42)                                                 // want "useless-assert: meaningless assertion"
		assert.Lessf(t, len(x), 0, "msg with args %d %s", 42, "42")                                       // want "useless-assert: meaningless assertion"
		assert.Greater(t, 0, len(x))                                                                      // want "useless-assert: meaningless assertion"
		assert.Greater(t, 0, len(x), "msg")                                                               // want "useless-assert: meaningless assertion"
		assert.Greater(t, 0, len(x), "msg with arg %d", 42)                                               // want "useless-assert: meaningless assertion"
		assert.Greater(t, 0, len(x), "msg with args %d %s", 42, "42")                                     // want "useless-assert: meaningless assertion"
		assert.Greaterf(t, 0, len(x), "msg")                                                              // want "useless-assert: meaningless assertion"
		assert.Greaterf(t, 0, len(x), "msg with arg %d", 42)                                              // want "useless-assert: meaningless assertion"
		assert.Greaterf(t, 0, len(x), "msg with args %d %s", 42, "42")                                    // want "useless-assert: meaningless assertion"
		assert.GreaterOrEqual(t, len(x), 0)                                                               // want "useless-assert: meaningless assertion"
		assert.GreaterOrEqual(t, len(x), 0, "msg")                                                        // want "useless-assert: meaningless assertion"
		assert.GreaterOrEqual(t, len(x), 0, "msg with arg %d", 42)                                        // want "useless-assert: meaningless assertion"
		assert.GreaterOrEqual(t, len(x), 0, "msg with args %d %s", 42, "42")                              // want "useless-assert: meaningless assertion"
		assert.GreaterOrEqualf(t, len(x), 0, "msg")                                                       // want "useless-assert: meaningless assertion"
		assert.GreaterOrEqualf(t, len(x), 0, "msg with arg %d", 42)                                       // want "useless-assert: meaningless assertion"
		assert.GreaterOrEqualf(t, len(x), 0, "msg with args %d %s", 42, "42")                             // want "useless-assert: meaningless assertion"
		assert.LessOrEqual(t, 0, len(x))                                                                  // want "useless-assert: meaningless assertion"
		assert.LessOrEqual(t, 0, len(x), "msg")                                                           // want "useless-assert: meaningless assertion"
		assert.LessOrEqual(t, 0, len(x), "msg with arg %d", 42)                                           // want "useless-assert: meaningless assertion"
		assert.LessOrEqual(t, 0, len(x), "msg with args %d %s", 42, "42")                                 // want "useless-assert: meaningless assertion"
		assert.LessOrEqualf(t, 0, len(x), "msg")                                                          // want "useless-assert: meaningless assertion"
		assert.LessOrEqualf(t, 0, len(x), "msg with arg %d", 42)                                          // want "useless-assert: meaningless assertion"
		assert.LessOrEqualf(t, 0, len(x), "msg with args %d %s", 42, "42")                                // want "useless-assert: meaningless assertion"
		assert.Negative(t, uint(42))                                                                      // want "useless-assert: meaningless assertion"
		assert.Negative(t, uint(42), "msg")                                                               // want "useless-assert: meaningless assertion"
		assert.Negative(t, uint(42), "msg with arg %d", 42)                                               // want "useless-assert: meaningless assertion"
		assert.Negative(t, uint(42), "msg with args %d %s", 42, "42")                                     // want "useless-assert: meaningless assertion"
		assert.Negativef(t, uint(42), "msg")                                                              // want "useless-assert: meaningless assertion"
		assert.Negativef(t, uint(42), "msg with arg %d", 42)                                              // want "useless-assert: meaningless assertion"
		assert.Negativef(t, uint(42), "msg with args %d %s", 42, "42")                                    // want "useless-assert: meaningless assertion"
		assert.Less(t, uint(42), 0)                                                                       // want "useless-assert: meaningless assertion"
		assert.Less(t, uint(42), 0, "msg")                                                                // want "useless-assert: meaningless assertion"
		assert.Less(t, uint(42), 0, "msg with arg %d", 42)                                                // want "useless-assert: meaningless assertion"
		assert.Less(t, uint(42), 0, "msg with args %d %s", 42, "42")                                      // want "useless-assert: meaningless assertion"
		assert.Lessf(t, uint(42), 0, "msg")                                                               // want "useless-assert: meaningless assertion"
		assert.Lessf(t, uint(42), 0, "msg with arg %d", 42)                                               // want "useless-assert: meaningless assertion"
		assert.Lessf(t, uint(42), 0, "msg with args %d %s", 42, "42")                                     // want "useless-assert: meaningless assertion"
		assert.Greater(t, 0, uint(42))                                                                    // want "useless-assert: meaningless assertion"
		assert.Greater(t, 0, uint(42), "msg")                                                             // want "useless-assert: meaningless assertion"
		assert.Greater(t, 0, uint(42), "msg with arg %d", 42)                                             // want "useless-assert: meaningless assertion"
		assert.Greater(t, 0, uint(42), "msg with args %d %s", 42, "42")                                   // want "useless-assert: meaningless assertion"
		assert.Greaterf(t, 0, uint(42), "msg")                                                            // want "useless-assert: meaningless assertion"
		assert.Greaterf(t, 0, uint(42), "msg with arg %d", 42)                                            // want "useless-assert: meaningless assertion"
		assert.Greaterf(t, 0, uint(42), "msg with args %d %s", 42, "42")                                  // want "useless-assert: meaningless assertion"
		assert.GreaterOrEqual(t, uint(42), 0)                                                             // want "useless-assert: meaningless assertion"
		assert.GreaterOrEqual(t, uint(42), 0, "msg")                                                      // want "useless-assert: meaningless assertion"
		assert.GreaterOrEqual(t, uint(42), 0, "msg with arg %d", 42)                                      // want "useless-assert: meaningless assertion"
		assert.GreaterOrEqual(t, uint(42), 0, "msg with args %d %s", 42, "42")                            // want "useless-assert: meaningless assertion"
		assert.GreaterOrEqualf(t, uint(42), 0, "msg")                                                     // want "useless-assert: meaningless assertion"
		assert.GreaterOrEqualf(t, uint(42), 0, "msg with arg %d", 42)                                     // want "useless-assert: meaningless assertion"
		assert.GreaterOrEqualf(t, uint(42), 0, "msg with args %d %s", 42, "42")                           // want "useless-assert: meaningless assertion"
		assert.LessOrEqual(t, 0, uint(42))                                                                // want "useless-assert: meaningless assertion"
		assert.LessOrEqual(t, 0, uint(42), "msg")                                                         // want "useless-assert: meaningless assertion"
		assert.LessOrEqual(t, 0, uint(42), "msg with arg %d", 42)                                         // want "useless-assert: meaningless assertion"
		assert.LessOrEqual(t, 0, uint(42), "msg with args %d %s", 42, "42")                               // want "useless-assert: meaningless assertion"
		assert.LessOrEqualf(t, 0, uint(42), "msg")                                                        // want "useless-assert: meaningless assertion"
		assert.LessOrEqualf(t, 0, uint(42), "msg with arg %d", 42)                                        // want "useless-assert: meaningless assertion"
		assert.LessOrEqualf(t, 0, uint(42), "msg with args %d %s", 42, "42")                              // want "useless-assert: meaningless assertion"
		assert.Contains(t, value, value)                                                                  // want "useless-assert: asserting of the same variable"
		assert.Containsf(t, value, value, "msg with args %d %s", 42, "42")                                // want "useless-assert: asserting of the same variable"
		assert.ElementsMatch(t, value, value)                                                             // want "useless-assert: asserting of the same variable"
		assert.ElementsMatchf(t, value, value, "msg with args %d %s", 42, "42")                           // want "useless-assert: asserting of the same variable"
		assert.Equal(t, value, value)                                                                     // want "useless-assert: asserting of the same variable"
		assert.Equalf(t, value, value, "msg with args %d %s", 42, "42")                                   // want "useless-assert: asserting of the same variable"
		assert.EqualExportedValues(t, value, value)                                                       // want "useless-assert: asserting of the same variable"
		assert.EqualExportedValuesf(t, value, value, "msg with args %d %s", 42, "42")                     // want "useless-assert: asserting of the same variable"
		assert.EqualValues(t, value, value)                                                               // want "useless-assert: asserting of the same variable"
		assert.EqualValuesf(t, value, value, "msg with args %d %s", 42, "42")                             // want "useless-assert: asserting of the same variable"
		assert.ErrorAs(t, err, err)                                                                       // want "useless-assert: asserting of the same variable"
		assert.ErrorAsf(t, err, err, "msg with args %d %s", 42, "42")                                     // want "useless-assert: asserting of the same variable"
		assert.ErrorIs(t, err, err)                                                                       // want "useless-assert: asserting of the same variable"
		assert.ErrorIsf(t, err, err, "msg with args %d %s", 42, "42")                                     // want "useless-assert: asserting of the same variable"
		assert.Exactly(t, value, value)                                                                   // want "useless-assert: asserting of the same variable"
		assert.Exactlyf(t, value, value, "msg with args %d %s", 42, "42")                                 // want "useless-assert: asserting of the same variable"
		assert.False(t, num != num)                                                                       // want "useless-assert: asserting of the same variable"
		assert.Falsef(t, num != num, "msg with args %d %s", 42, "42")                                     // want "useless-assert: asserting of the same variable"
		assert.False(t, num < num)                                                                        // want "useless-assert: asserting of the same variable"
		assert.Falsef(t, num < num, "msg with args %d %s", 42, "42")                                      // want "useless-assert: asserting of the same variable"
		assert.False(t, num <= num)                                                                       // want "useless-assert: asserting of the same variable"
		assert.Falsef(t, num <= num, "msg with args %d %s", 42, "42")                                     // want "useless-assert: asserting of the same variable"
		assert.False(t, num == num)                                                                       // want "useless-assert: asserting of the same variable"
		assert.Falsef(t, num == num, "msg with args %d %s", 42, "42")                                     // want "useless-assert: asserting of the same variable"
		assert.False(t, num > num)                                                                        // want "useless-assert: asserting of the same variable"
		assert.Falsef(t, num > num, "msg with args %d %s", 42, "42")                                      // want "useless-assert: asserting of the same variable"
		assert.False(t, num >= num)                                                                       // want "useless-assert: asserting of the same variable"
		assert.Falsef(t, num >= num, "msg with args %d %s", 42, "42")                                     // want "useless-assert: asserting of the same variable"
		assert.Greater(t, value, value)                                                                   // want "useless-assert: asserting of the same variable"
		assert.Greaterf(t, value, value, "msg with args %d %s", 42, "42")                                 // want "useless-assert: asserting of the same variable"
		assert.GreaterOrEqual(t, value, value)                                                            // want "useless-assert: asserting of the same variable"
		assert.GreaterOrEqualf(t, value, value, "msg with args %d %s", 42, "42")                          // want "useless-assert: asserting of the same variable"
		assert.Implements(t, value, value)                                                                // want "useless-assert: asserting of the same variable"
		assert.Implementsf(t, value, value, "msg with args %d %s", 42, "42")                              // want "useless-assert: asserting of the same variable"
		assert.InDelta(t, value, value, 0.01)                                                             // want "useless-assert: asserting of the same variable"
		assert.InDeltaf(t, value, value, 0.01, "msg with args %d %s", 42, "42")                           // want "useless-assert: asserting of the same variable"
		assert.InDeltaMapValues(t, value, value, 0.01)                                                    // want "useless-assert: asserting of the same variable"
		assert.InDeltaMapValuesf(t, value, value, 0.01, "msg with args %d %s", 42, "42")                  // want "useless-assert: asserting of the same variable"
		assert.InDeltaSlice(t, value, value, 0.01)                                                        // want "useless-assert: asserting of the same variable"
		assert.InDeltaSlicef(t, value, value, 0.01, "msg with args %d %s", 42, "42")                      // want "useless-assert: asserting of the same variable"
		assert.InEpsilon(t, value, value, 0.0001)                                                         // want "useless-assert: asserting of the same variable"
		assert.InEpsilonf(t, value, value, 0.0001, "msg with args %d %s", 42, "42")                       // want "useless-assert: asserting of the same variable"
		assert.InEpsilonSlice(t, value, value, 0.0001)                                                    // want "useless-assert: asserting of the same variable"
		assert.InEpsilonSlicef(t, value, value, 0.0001, "msg with args %d %s", 42, "42")                  // want "useless-assert: asserting of the same variable"
		assert.IsNotType(t, value, value)                                                                 // want "useless-assert: asserting of the same variable"
		assert.IsNotTypef(t, value, value, "msg with args %d %s", 42, "42")                               // want "useless-assert: asserting of the same variable"
		assert.IsType(t, value, value)                                                                    // want "useless-assert: asserting of the same variable"
		assert.IsTypef(t, value, value, "msg with args %d %s", 42, "42")                                  // want "useless-assert: asserting of the same variable"
		assert.JSONEq(t, str, str)                                                                        // want "useless-assert: asserting of the same variable"
		assert.JSONEqf(t, str, str, "msg with args %d %s", 42, "42")                                      // want "useless-assert: asserting of the same variable"
		assert.Less(t, value, value)                                                                      // want "useless-assert: asserting of the same variable"
		assert.Lessf(t, value, value, "msg with args %d %s", 42, "42")                                    // want "useless-assert: asserting of the same variable"
		assert.LessOrEqual(t, value, value)                                                               // want "useless-assert: asserting of the same variable"
		assert.LessOrEqualf(t, value, value, "msg with args %d %s", 42, "42")                             // want "useless-assert: asserting of the same variable"
		assert.NotElementsMatch(t, value, value)                                                          // want "useless-assert: asserting of the same variable"
		assert.NotElementsMatchf(t, value, value, "msg with args %d %s", 42, "42")                        // want "useless-assert: asserting of the same variable"
		assert.NotEqual(t, value, value)                                                                  // want "useless-assert: asserting of the same variable"
		assert.NotEqualf(t, value, value, "msg with args %d %s", 42, "42")                                // want "useless-assert: asserting of the same variable"
		assert.NotEqualValues(t, value, value)                                                            // want "useless-assert: asserting of the same variable"
		assert.NotEqualValuesf(t, value, value, "msg with args %d %s", 42, "42")                          // want "useless-assert: asserting of the same variable"
		assert.NotErrorAs(t, err, err)                                                                    // want "useless-assert: asserting of the same variable"
		assert.NotErrorAsf(t, err, err, "msg with args %d %s", 42, "42")                                  // want "useless-assert: asserting of the same variable"
		assert.NotErrorIs(t, err, err)                                                                    // want "useless-assert: asserting of the same variable"
		assert.NotErrorIsf(t, err, err, "msg with args %d %s", 42, "42")                                  // want "useless-assert: asserting of the same variable"
		assert.NotRegexp(t, value, value)                                                                 // want "useless-assert: asserting of the same variable"
		assert.NotRegexpf(t, value, value, "msg with args %d %s", 42, "42")                               // want "useless-assert: asserting of the same variable"
		assert.NotSame(t, value, value)                                                                   // want "useless-assert: asserting of the same variable"
		assert.NotSamef(t, value, value, "msg with args %d %s", 42, "42")                                 // want "useless-assert: asserting of the same variable"
		assert.NotSubset(t, value, value)                                                                 // want "useless-assert: asserting of the same variable"
		assert.NotSubsetf(t, value, value, "msg with args %d %s", 42, "42")                               // want "useless-assert: asserting of the same variable"
		assert.Regexp(t, value, value)                                                                    // want "useless-assert: asserting of the same variable"
		assert.Regexpf(t, value, value, "msg with args %d %s", 42, "42")                                  // want "useless-assert: asserting of the same variable"
		assert.Same(t, value, value)                                                                      // want "useless-assert: asserting of the same variable"
		assert.Samef(t, value, value, "msg with args %d %s", 42, "42")                                    // want "useless-assert: asserting of the same variable"
		assert.Subset(t, value, value)                                                                    // want "useless-assert: asserting of the same variable"
		assert.Subsetf(t, value, value, "msg with args %d %s", 42, "42")                                  // want "useless-assert: asserting of the same variable"
		assert.True(t, num != num)                                                                        // want "useless-assert: asserting of the same variable"
		assert.Truef(t, num != num, "msg with args %d %s", 42, "42")                                      // want "useless-assert: asserting of the same variable"
		assert.True(t, num < num)                                                                         // want "useless-assert: asserting of the same variable"
		assert.Truef(t, num < num, "msg with args %d %s", 42, "42")                                       // want "useless-assert: asserting of the same variable"
		assert.True(t, num <= num)                                                                        // want "useless-assert: asserting of the same variable"
		assert.Truef(t, num <= num, "msg with args %d %s", 42, "42")                                      // want "useless-assert: asserting of the same variable"
		assert.True(t, num == num)                                                                        // want "useless-assert: asserting of the same variable"
		assert.Truef(t, num == num, "msg with args %d %s", 42, "42")                                      // want "useless-assert: asserting of the same variable"
		assert.True(t, num > num)                                                                         // want "useless-assert: asserting of the same variable"
		assert.Truef(t, num > num, "msg with args %d %s", 42, "42")                                       // want "useless-assert: asserting of the same variable"
		assert.True(t, num >= num)                                                                        // want "useless-assert: asserting of the same variable"
		assert.Truef(t, num >= num, "msg with args %d %s", 42, "42")                                      // want "useless-assert: asserting of the same variable"
		assert.WithinDuration(t, elapsed, elapsed, time.Second)                                           // want "useless-assert: asserting of the same variable"
		assert.WithinDurationf(t, elapsed, elapsed, time.Second, "msg with args %d %s", 42, "42")         // want "useless-assert: asserting of the same variable"
		assert.YAMLEq(t, str, str)                                                                        // want "useless-assert: asserting of the same variable"
		assert.YAMLEqf(t, str, str, "msg with args %d %s", 42, "42")                                      // want "useless-assert: asserting of the same variable"
	}

	// Valid.
	{
		assert.Equal(t, value, 42)
		assert.Equal(t, value, 42, "msg")
		assert.Equal(t, value, 42, "msg with arg %d", 42)
		assert.Equal(t, value, 42, "msg with args %d %s", 42, "42")
		assert.Equalf(t, value, 42, "msg")
		assert.Equalf(t, value, 42, "msg with arg %d", 42)
		assert.Equalf(t, value, 42, "msg with args %d %s", 42, "42")
		assert.Equal(t, value, "value")
		assert.Equal(t, value, "value", "msg")
		assert.Equal(t, value, "value", "msg with arg %d", 42)
		assert.Equal(t, value, "value", "msg with args %d %s", 42, "42")
		assert.Equalf(t, value, "value", "msg")
		assert.Equalf(t, value, "value", "msg with arg %d", 42)
		assert.Equalf(t, value, "value", "msg with args %d %s", 42, "42")
		assert.Equal(t, tc.A(), "tc.A()")
		assert.Equal(t, tc.A(), "tc.A()", "msg")
		assert.Equal(t, tc.A(), "tc.A()", "msg with arg %d", 42)
		assert.Equal(t, tc.A(), "tc.A()", "msg with args %d %s", 42, "42")
		assert.Equalf(t, tc.A(), "tc.A()", "msg")
		assert.Equalf(t, tc.A(), "tc.A()", "msg with arg %d", 42)
		assert.Equalf(t, tc.A(), "tc.A()", "msg with args %d %s", 42, "42")
		assert.Equal(t, testCase{}.A().B().C(), tc.A().B().C())
		assert.Equal(t, testCase{}.A().B().C(), tc.A().B().C(), "msg")
		assert.Equal(t, testCase{}.A().B().C(), tc.A().B().C(), "msg with arg %d", 42)
		assert.Equal(t, testCase{}.A().B().C(), tc.A().B().C(), "msg with args %d %s", 42, "42")
		assert.Equalf(t, testCase{}.A().B().C(), tc.A().B().C(), "msg")
		assert.Equalf(t, testCase{}.A().B().C(), tc.A().B().C(), "msg with arg %d", 42)
		assert.Equalf(t, testCase{}.A().B().C(), tc.A().B().C(), "msg with args %d %s", 42, "42")
		assert.IsNotType(t, tc, testCase{})
		assert.IsNotType(t, tc, testCase{}, "msg")
		assert.IsNotType(t, tc, testCase{}, "msg with arg %d", 42)
		assert.IsNotType(t, tc, testCase{}, "msg with args %d %s", 42, "42")
		assert.IsNotTypef(t, tc, testCase{}, "msg")
		assert.IsNotTypef(t, tc, testCase{}, "msg with arg %d", 42)
		assert.IsNotTypef(t, tc, testCase{}, "msg with args %d %s", 42, "42")
		assert.IsType(t, tc, testCase{})
		assert.IsType(t, tc, testCase{}, "msg")
		assert.IsType(t, tc, testCase{}, "msg with arg %d", 42)
		assert.IsType(t, tc, testCase{}, "msg with args %d %s", 42, "42")
		assert.IsTypef(t, tc, testCase{}, "msg")
		assert.IsTypef(t, tc, testCase{}, "msg with arg %d", 42)
		assert.IsTypef(t, tc, testCase{}, "msg with args %d %s", 42, "42")
		assert.Empty(t, str)
		assert.Empty(t, str, "msg")
		assert.Empty(t, str, "msg with arg %d", 42)
		assert.Empty(t, str, "msg with args %d %s", 42, "42")
		assert.Emptyf(t, str, "msg")
		assert.Emptyf(t, str, "msg with arg %d", 42)
		assert.Emptyf(t, str, "msg with args %d %s", 42, "42")
		assert.Error(t, err)
		assert.Error(t, err, "msg")
		assert.Error(t, err, "msg with arg %d", 42)
		assert.Error(t, err, "msg with args %d %s", 42, "42")
		assert.Errorf(t, err, "msg")
		assert.Errorf(t, err, "msg with arg %d", 42)
		assert.Errorf(t, err, "msg with args %d %s", 42, "42")
		assert.False(t, b)
		assert.False(t, b, "msg")
		assert.False(t, b, "msg with arg %d", 42)
		assert.False(t, b, "msg with args %d %s", 42, "42")
		assert.Falsef(t, b, "msg")
		assert.Falsef(t, b, "msg with arg %d", 42)
		assert.Falsef(t, b, "msg with args %d %s", 42, "42")
		assert.Implements(t, (*testing.TB)(nil), new(testing.T))
		assert.Implements(t, (*testing.TB)(nil), new(testing.T), "msg")
		assert.Implements(t, (*testing.TB)(nil), new(testing.T), "msg with arg %d", 42)
		assert.Implements(t, (*testing.TB)(nil), new(testing.T), "msg with args %d %s", 42, "42")
		assert.Implementsf(t, (*testing.TB)(nil), new(testing.T), "msg")
		assert.Implementsf(t, (*testing.TB)(nil), new(testing.T), "msg with arg %d", 42)
		assert.Implementsf(t, (*testing.TB)(nil), new(testing.T), "msg with args %d %s", 42, "42")
		assert.Negative(t, num)
		assert.Negative(t, num, "msg")
		assert.Negative(t, num, "msg with arg %d", 42)
		assert.Negative(t, num, "msg with args %d %s", 42, "42")
		assert.Negativef(t, num, "msg")
		assert.Negativef(t, num, "msg with arg %d", 42)
		assert.Negativef(t, num, "msg with args %d %s", 42, "42")
		assert.Nil(t, new(testCase))
		assert.Nil(t, new(testCase), "msg")
		assert.Nil(t, new(testCase), "msg with arg %d", 42)
		assert.Nil(t, new(testCase), "msg with args %d %s", 42, "42")
		assert.Nilf(t, new(testCase), "msg")
		assert.Nilf(t, new(testCase), "msg with arg %d", 42)
		assert.Nilf(t, new(testCase), "msg with args %d %s", 42, "42")
		assert.NoError(t, err)
		assert.NoError(t, err, "msg")
		assert.NoError(t, err, "msg with arg %d", 42)
		assert.NoError(t, err, "msg with args %d %s", 42, "42")
		assert.NoErrorf(t, err, "msg")
		assert.NoErrorf(t, err, "msg with arg %d", 42)
		assert.NoErrorf(t, err, "msg with args %d %s", 42, "42")
		assert.NotEmpty(t, str)
		assert.NotEmpty(t, str, "msg")
		assert.NotEmpty(t, str, "msg with arg %d", 42)
		assert.NotEmpty(t, str, "msg with args %d %s", 42, "42")
		assert.NotEmptyf(t, str, "msg")
		assert.NotEmptyf(t, str, "msg with arg %d", 42)
		assert.NotEmptyf(t, str, "msg with args %d %s", 42, "42")
		assert.NotImplements(t, (*testing.TB)(nil), new(testing.T))
		assert.NotImplements(t, (*testing.TB)(nil), new(testing.T), "msg")
		assert.NotImplements(t, (*testing.TB)(nil), new(testing.T), "msg with arg %d", 42)
		assert.NotImplements(t, (*testing.TB)(nil), new(testing.T), "msg with args %d %s", 42, "42")
		assert.NotImplementsf(t, (*testing.TB)(nil), new(testing.T), "msg")
		assert.NotImplementsf(t, (*testing.TB)(nil), new(testing.T), "msg with arg %d", 42)
		assert.NotImplementsf(t, (*testing.TB)(nil), new(testing.T), "msg with args %d %s", 42, "42")
		assert.NotNil(t, new(testCase))
		assert.NotNil(t, new(testCase), "msg")
		assert.NotNil(t, new(testCase), "msg with arg %d", 42)
		assert.NotNil(t, new(testCase), "msg with args %d %s", 42, "42")
		assert.NotNilf(t, new(testCase), "msg")
		assert.NotNilf(t, new(testCase), "msg with arg %d", 42)
		assert.NotNilf(t, new(testCase), "msg with args %d %s", 42, "42")
		assert.NotZero(t, num)
		assert.NotZero(t, num, "msg")
		assert.NotZero(t, num, "msg with arg %d", 42)
		assert.NotZero(t, num, "msg with args %d %s", 42, "42")
		assert.NotZerof(t, num, "msg")
		assert.NotZerof(t, num, "msg with arg %d", 42)
		assert.NotZerof(t, num, "msg with args %d %s", 42, "42")
		assert.NotZero(t, str)
		assert.NotZero(t, str, "msg")
		assert.NotZero(t, str, "msg with arg %d", 42)
		assert.NotZero(t, str, "msg with args %d %s", 42, "42")
		assert.NotZerof(t, str, "msg")
		assert.NotZerof(t, str, "msg with arg %d", 42)
		assert.NotZerof(t, str, "msg with args %d %s", 42, "42")
		assert.NotZero(t, new(testCase))
		assert.NotZero(t, new(testCase), "msg")
		assert.NotZero(t, new(testCase), "msg with arg %d", 42)
		assert.NotZero(t, new(testCase), "msg with args %d %s", 42, "42")
		assert.NotZerof(t, new(testCase), "msg")
		assert.NotZerof(t, new(testCase), "msg with arg %d", 42)
		assert.NotZerof(t, new(testCase), "msg with args %d %s", 42, "42")
		assert.NotZero(t, b)
		assert.NotZero(t, b, "msg")
		assert.NotZero(t, b, "msg with arg %d", 42)
		assert.NotZero(t, b, "msg with args %d %s", 42, "42")
		assert.NotZerof(t, b, "msg")
		assert.NotZerof(t, b, "msg with arg %d", 42)
		assert.NotZerof(t, b, "msg with args %d %s", 42, "42")
		assert.Positive(t, num)
		assert.Positive(t, num, "msg")
		assert.Positive(t, num, "msg with arg %d", 42)
		assert.Positive(t, num, "msg with args %d %s", 42, "42")
		assert.Positivef(t, num, "msg")
		assert.Positivef(t, num, "msg with arg %d", 42)
		assert.Positivef(t, num, "msg with args %d %s", 42, "42")
		assert.True(t, b)
		assert.True(t, b, "msg")
		assert.True(t, b, "msg with arg %d", 42)
		assert.True(t, b, "msg with args %d %s", 42, "42")
		assert.Truef(t, b, "msg")
		assert.Truef(t, b, "msg with arg %d", 42)
		assert.Truef(t, b, "msg with args %d %s", 42, "42")
		assert.Zero(t, num)
		assert.Zero(t, num, "msg")
		assert.Zero(t, num, "msg with arg %d", 42)
		assert.Zero(t, num, "msg with args %d %s", 42, "42")
		assert.Zerof(t, num, "msg")
		assert.Zerof(t, num, "msg with arg %d", 42)
		assert.Zerof(t, num, "msg with args %d %s", 42, "42")
		assert.Zero(t, str)
		assert.Zero(t, str, "msg")
		assert.Zero(t, str, "msg with arg %d", 42)
		assert.Zero(t, str, "msg with args %d %s", 42, "42")
		assert.Zerof(t, str, "msg")
		assert.Zerof(t, str, "msg with arg %d", 42)
		assert.Zerof(t, str, "msg with args %d %s", 42, "42")
		assert.Zero(t, new(testCase))
		assert.Zero(t, new(testCase), "msg")
		assert.Zero(t, new(testCase), "msg with arg %d", 42)
		assert.Zero(t, new(testCase), "msg with args %d %s", 42, "42")
		assert.Zerof(t, new(testCase), "msg")
		assert.Zerof(t, new(testCase), "msg with arg %d", 42)
		assert.Zerof(t, new(testCase), "msg with args %d %s", 42, "42")
		assert.Zero(t, b)
		assert.Zero(t, b, "msg")
		assert.Zero(t, b, "msg with arg %d", 42)
		assert.Zero(t, b, "msg with args %d %s", 42, "42")
		assert.Zerof(t, b, "msg")
		assert.Zerof(t, b, "msg with arg %d", 42)
		assert.Zerof(t, b, "msg with args %d %s", 42, "42")
		assert.Positive(t, len(x))
		assert.Positive(t, len(x), "msg")
		assert.Positive(t, len(x), "msg with arg %d", 42)
		assert.Positive(t, len(x), "msg with args %d %s", 42, "42")
		assert.Positivef(t, len(x), "msg")
		assert.Positivef(t, len(x), "msg with arg %d", 42)
		assert.Positivef(t, len(x), "msg with args %d %s", 42, "42")
		assert.Positive(t, uint(42))
		assert.Positive(t, uint(42), "msg")
		assert.Positive(t, uint(42), "msg with arg %d", 42)
		assert.Positive(t, uint(42), "msg with args %d %s", 42, "42")
		assert.Positivef(t, uint(42), "msg")
		assert.Positivef(t, uint(42), "msg with arg %d", 42)
		assert.Positivef(t, uint(42), "msg with args %d %s", 42, "42")
		assert.Greater(t, len(x), 0)
		assert.Greater(t, len(x), 0, "msg")
		assert.Greater(t, len(x), 0, "msg with arg %d", 42)
		assert.Greater(t, len(x), 0, "msg with args %d %s", 42, "42")
		assert.Greaterf(t, len(x), 0, "msg")
		assert.Greaterf(t, len(x), 0, "msg with arg %d", 42)
		assert.Greaterf(t, len(x), 0, "msg with args %d %s", 42, "42")
		assert.Greater(t, uint(42), 0)
		assert.Greater(t, uint(42), 0, "msg")
		assert.Greater(t, uint(42), 0, "msg with arg %d", 42)
		assert.Greater(t, uint(42), 0, "msg with args %d %s", 42, "42")
		assert.Greaterf(t, uint(42), 0, "msg")
		assert.Greaterf(t, uint(42), 0, "msg with arg %d", 42)
		assert.Greaterf(t, uint(42), 0, "msg with args %d %s", 42, "42")
	}
}

type testCase struct{}

func (testCase) A() testCase { return testCase{} }
func (testCase) B() testCase { return testCase{} }
func (testCase) C() testCase { return testCase{} }
