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

package empty

import (
	"testing"

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

func TestEmptyChecker(t *testing.T) {
	var (
		elems []any
		str   string
		b     []byte
	)

	// assert.Empty cases.
	{
		// Invalid.
		assert.Len(t, elems, 0)                                                           // want "empty: use assert\\.Empty"
		assert.Lenf(t, elems, 0, "msg with args %d %s", 42, "42")                         // want "empty: use assert\\.Emptyf"
		assert.Len(t, str, 0)                                                             // want "empty: use assert\\.Empty"
		assert.Lenf(t, str, 0, "msg with args %d %s", 42, "42")                           // want "empty: use assert\\.Emptyf"
		assert.Len(t, string(str), 0)                                                     // want "empty: use assert\\.Empty"
		assert.Lenf(t, string(str), 0, "msg with args %d %s", 42, "42")                   // want "empty: use assert\\.Emptyf"
		assert.Len(t, b, 0)                                                               // want "empty: use assert\\.Empty"
		assert.Lenf(t, b, 0, "msg with args %d %s", 42, "42")                             // want "empty: use assert\\.Emptyf"
		assert.Len(t, string(b), 0)                                                       // want "empty: use assert\\.Empty"
		assert.Lenf(t, string(b), 0, "msg with args %d %s", 42, "42")                     // want "empty: use assert\\.Emptyf"
		assert.Len(t, []string{"e"}, 0)                                                   // want "empty: use assert\\.Empty"
		assert.Lenf(t, []string{"e"}, 0, "msg with args %d %s", 42, "42")                 // want "empty: use assert\\.Emptyf"
		assert.Zero(t, len(elems))                                                        // want "empty: use assert\\.Empty"
		assert.Zerof(t, len(elems), "msg with args %d %s", 42, "42")                      // want "empty: use assert\\.Emptyf"
		assert.Zero(t, len(str))                                                          // want "empty: use assert\\.Empty"
		assert.Zerof(t, len(str), "msg with args %d %s", 42, "42")                        // want "empty: use assert\\.Emptyf"
		assert.Zero(t, len(string(str)))                                                  // want "empty: use assert\\.Empty"
		assert.Zerof(t, len(string(str)), "msg with args %d %s", 42, "42")                // want "empty: use assert\\.Emptyf"
		assert.Zero(t, len(b))                                                            // want "empty: use assert\\.Empty"
		assert.Zerof(t, len(b), "msg with args %d %s", 42, "42")                          // want "empty: use assert\\.Emptyf"
		assert.Zero(t, len(string(b)))                                                    // want "empty: use assert\\.Empty"
		assert.Zerof(t, len(string(b)), "msg with args %d %s", 42, "42")                  // want "empty: use assert\\.Emptyf"
		assert.Zero(t, len([]string{"e"}))                                                // want "empty: use assert\\.Empty"
		assert.Zerof(t, len([]string{"e"}), "msg with args %d %s", 42, "42")              // want "empty: use assert\\.Emptyf"
		assert.Equal(t, len(elems), 0)                                                    // want "empty: use assert\\.Empty"
		assert.Equalf(t, len(elems), 0, "msg with args %d %s", 42, "42")                  // want "empty: use assert\\.Emptyf"
		assert.Equal(t, len(str), 0)                                                      // want "empty: use assert\\.Empty"
		assert.Equalf(t, len(str), 0, "msg with args %d %s", 42, "42")                    // want "empty: use assert\\.Emptyf"
		assert.Equal(t, len(string(str)), 0)                                              // want "empty: use assert\\.Empty"
		assert.Equalf(t, len(string(str)), 0, "msg with args %d %s", 42, "42")            // want "empty: use assert\\.Emptyf"
		assert.Equal(t, len(b), 0)                                                        // want "empty: use assert\\.Empty"
		assert.Equalf(t, len(b), 0, "msg with args %d %s", 42, "42")                      // want "empty: use assert\\.Emptyf"
		assert.Equal(t, len(string(b)), 0)                                                // want "empty: use assert\\.Empty"
		assert.Equalf(t, len(string(b)), 0, "msg with args %d %s", 42, "42")              // want "empty: use assert\\.Emptyf"
		assert.Equal(t, len([]string{"e"}), 0)                                            // want "empty: use assert\\.Empty"
		assert.Equalf(t, len([]string{"e"}), 0, "msg with args %d %s", 42, "42")          // want "empty: use assert\\.Emptyf"
		assert.Equal(t, 0, len(elems))                                                    // want "empty: use assert\\.Empty"
		assert.Equalf(t, 0, len(elems), "msg with args %d %s", 42, "42")                  // want "empty: use assert\\.Emptyf"
		assert.Equal(t, 0, len(str))                                                      // want "empty: use assert\\.Empty"
		assert.Equalf(t, 0, len(str), "msg with args %d %s", 42, "42")                    // want "empty: use assert\\.Emptyf"
		assert.Equal(t, 0, len(string(str)))                                              // want "empty: use assert\\.Empty"
		assert.Equalf(t, 0, len(string(str)), "msg with args %d %s", 42, "42")            // want "empty: use assert\\.Emptyf"
		assert.Equal(t, 0, len(b))                                                        // want "empty: use assert\\.Empty"
		assert.Equalf(t, 0, len(b), "msg with args %d %s", 42, "42")                      // want "empty: use assert\\.Emptyf"
		assert.Equal(t, 0, len(string(b)))                                                // want "empty: use assert\\.Empty"
		assert.Equalf(t, 0, len(string(b)), "msg with args %d %s", 42, "42")              // want "empty: use assert\\.Emptyf"
		assert.Equal(t, 0, len([]string{"e"}))                                            // want "empty: use assert\\.Empty"
		assert.Equalf(t, 0, len([]string{"e"}), "msg with args %d %s", 42, "42")          // want "empty: use assert\\.Emptyf"
		assert.EqualValues(t, len(elems), 0)                                              // want "empty: use assert\\.Empty"
		assert.EqualValuesf(t, len(elems), 0, "msg with args %d %s", 42, "42")            // want "empty: use assert\\.Emptyf"
		assert.EqualValues(t, len(str), 0)                                                // want "empty: use assert\\.Empty"
		assert.EqualValuesf(t, len(str), 0, "msg with args %d %s", 42, "42")              // want "empty: use assert\\.Emptyf"
		assert.EqualValues(t, len(string(str)), 0)                                        // want "empty: use assert\\.Empty"
		assert.EqualValuesf(t, len(string(str)), 0, "msg with args %d %s", 42, "42")      // want "empty: use assert\\.Emptyf"
		assert.EqualValues(t, len(b), 0)                                                  // want "empty: use assert\\.Empty"
		assert.EqualValuesf(t, len(b), 0, "msg with args %d %s", 42, "42")                // want "empty: use assert\\.Emptyf"
		assert.EqualValues(t, len(string(b)), 0)                                          // want "empty: use assert\\.Empty"
		assert.EqualValuesf(t, len(string(b)), 0, "msg with args %d %s", 42, "42")        // want "empty: use assert\\.Emptyf"
		assert.EqualValues(t, len([]string{"e"}), 0)                                      // want "empty: use assert\\.Empty"
		assert.EqualValuesf(t, len([]string{"e"}), 0, "msg with args %d %s", 42, "42")    // want "empty: use assert\\.Emptyf"
		assert.EqualValues(t, 0, len(elems))                                              // want "empty: use assert\\.Empty"
		assert.EqualValuesf(t, 0, len(elems), "msg with args %d %s", 42, "42")            // want "empty: use assert\\.Emptyf"
		assert.EqualValues(t, 0, len(str))                                                // want "empty: use assert\\.Empty"
		assert.EqualValuesf(t, 0, len(str), "msg with args %d %s", 42, "42")              // want "empty: use assert\\.Emptyf"
		assert.EqualValues(t, 0, len(string(str)))                                        // want "empty: use assert\\.Empty"
		assert.EqualValuesf(t, 0, len(string(str)), "msg with args %d %s", 42, "42")      // want "empty: use assert\\.Emptyf"
		assert.EqualValues(t, 0, len(b))                                                  // want "empty: use assert\\.Empty"
		assert.EqualValuesf(t, 0, len(b), "msg with args %d %s", 42, "42")                // want "empty: use assert\\.Emptyf"
		assert.EqualValues(t, 0, len(string(b)))                                          // want "empty: use assert\\.Empty"
		assert.EqualValuesf(t, 0, len(string(b)), "msg with args %d %s", 42, "42")        // want "empty: use assert\\.Emptyf"
		assert.EqualValues(t, 0, len([]string{"e"}))                                      // want "empty: use assert\\.Empty"
		assert.EqualValuesf(t, 0, len([]string{"e"}), "msg with args %d %s", 42, "42")    // want "empty: use assert\\.Emptyf"
		assert.Exactly(t, len(elems), 0)                                                  // want "empty: use assert\\.Empty"
		assert.Exactlyf(t, len(elems), 0, "msg with args %d %s", 42, "42")                // want "empty: use assert\\.Emptyf"
		assert.Exactly(t, len(str), 0)                                                    // want "empty: use assert\\.Empty"
		assert.Exactlyf(t, len(str), 0, "msg with args %d %s", 42, "42")                  // want "empty: use assert\\.Emptyf"
		assert.Exactly(t, len(string(str)), 0)                                            // want "empty: use assert\\.Empty"
		assert.Exactlyf(t, len(string(str)), 0, "msg with args %d %s", 42, "42")          // want "empty: use assert\\.Emptyf"
		assert.Exactly(t, len(b), 0)                                                      // want "empty: use assert\\.Empty"
		assert.Exactlyf(t, len(b), 0, "msg with args %d %s", 42, "42")                    // want "empty: use assert\\.Emptyf"
		assert.Exactly(t, len(string(b)), 0)                                              // want "empty: use assert\\.Empty"
		assert.Exactlyf(t, len(string(b)), 0, "msg with args %d %s", 42, "42")            // want "empty: use assert\\.Emptyf"
		assert.Exactly(t, len([]string{"e"}), 0)                                          // want "empty: use assert\\.Empty"
		assert.Exactlyf(t, len([]string{"e"}), 0, "msg with args %d %s", 42, "42")        // want "empty: use assert\\.Emptyf"
		assert.Exactly(t, 0, len(elems))                                                  // want "empty: use assert\\.Empty"
		assert.Exactlyf(t, 0, len(elems), "msg with args %d %s", 42, "42")                // want "empty: use assert\\.Emptyf"
		assert.Exactly(t, 0, len(str))                                                    // want "empty: use assert\\.Empty"
		assert.Exactlyf(t, 0, len(str), "msg with args %d %s", 42, "42")                  // want "empty: use assert\\.Emptyf"
		assert.Exactly(t, 0, len(string(str)))                                            // want "empty: use assert\\.Empty"
		assert.Exactlyf(t, 0, len(string(str)), "msg with args %d %s", 42, "42")          // want "empty: use assert\\.Emptyf"
		assert.Exactly(t, 0, len(b))                                                      // want "empty: use assert\\.Empty"
		assert.Exactlyf(t, 0, len(b), "msg with args %d %s", 42, "42")                    // want "empty: use assert\\.Emptyf"
		assert.Exactly(t, 0, len(string(b)))                                              // want "empty: use assert\\.Empty"
		assert.Exactlyf(t, 0, len(string(b)), "msg with args %d %s", 42, "42")            // want "empty: use assert\\.Emptyf"
		assert.Exactly(t, 0, len([]string{"e"}))                                          // want "empty: use assert\\.Empty"
		assert.Exactlyf(t, 0, len([]string{"e"}), "msg with args %d %s", 42, "42")        // want "empty: use assert\\.Emptyf"
		assert.LessOrEqual(t, len(elems), 0)                                              // want "empty: use assert\\.Empty"
		assert.LessOrEqualf(t, len(elems), 0, "msg with args %d %s", 42, "42")            // want "empty: use assert\\.Emptyf"
		assert.LessOrEqual(t, len(str), 0)                                                // want "empty: use assert\\.Empty"
		assert.LessOrEqualf(t, len(str), 0, "msg with args %d %s", 42, "42")              // want "empty: use assert\\.Emptyf"
		assert.LessOrEqual(t, len(string(str)), 0)                                        // want "empty: use assert\\.Empty"
		assert.LessOrEqualf(t, len(string(str)), 0, "msg with args %d %s", 42, "42")      // want "empty: use assert\\.Emptyf"
		assert.LessOrEqual(t, len(b), 0)                                                  // want "empty: use assert\\.Empty"
		assert.LessOrEqualf(t, len(b), 0, "msg with args %d %s", 42, "42")                // want "empty: use assert\\.Emptyf"
		assert.LessOrEqual(t, len(string(b)), 0)                                          // want "empty: use assert\\.Empty"
		assert.LessOrEqualf(t, len(string(b)), 0, "msg with args %d %s", 42, "42")        // want "empty: use assert\\.Emptyf"
		assert.LessOrEqual(t, len([]string{"e"}), 0)                                      // want "empty: use assert\\.Empty"
		assert.LessOrEqualf(t, len([]string{"e"}), 0, "msg with args %d %s", 42, "42")    // want "empty: use assert\\.Emptyf"
		assert.GreaterOrEqual(t, 0, len(elems))                                           // want "empty: use assert\\.Empty"
		assert.GreaterOrEqualf(t, 0, len(elems), "msg with args %d %s", 42, "42")         // want "empty: use assert\\.Emptyf"
		assert.GreaterOrEqual(t, 0, len(str))                                             // want "empty: use assert\\.Empty"
		assert.GreaterOrEqualf(t, 0, len(str), "msg with args %d %s", 42, "42")           // want "empty: use assert\\.Emptyf"
		assert.GreaterOrEqual(t, 0, len(string(str)))                                     // want "empty: use assert\\.Empty"
		assert.GreaterOrEqualf(t, 0, len(string(str)), "msg with args %d %s", 42, "42")   // want "empty: use assert\\.Emptyf"
		assert.GreaterOrEqual(t, 0, len(b))                                               // want "empty: use assert\\.Empty"
		assert.GreaterOrEqualf(t, 0, len(b), "msg with args %d %s", 42, "42")             // want "empty: use assert\\.Emptyf"
		assert.GreaterOrEqual(t, 0, len(string(b)))                                       // want "empty: use assert\\.Empty"
		assert.GreaterOrEqualf(t, 0, len(string(b)), "msg with args %d %s", 42, "42")     // want "empty: use assert\\.Emptyf"
		assert.GreaterOrEqual(t, 0, len([]string{"e"}))                                   // want "empty: use assert\\.Empty"
		assert.GreaterOrEqualf(t, 0, len([]string{"e"}), "msg with args %d %s", 42, "42") // want "empty: use assert\\.Emptyf"
		assert.Less(t, len(elems), 1)                                                     // want "empty: use assert\\.Empty"
		assert.Lessf(t, len(elems), 1, "msg with args %d %s", 42, "42")                   // want "empty: use assert\\.Emptyf"
		assert.Less(t, len(str), 1)                                                       // want "empty: use assert\\.Empty"
		assert.Lessf(t, len(str), 1, "msg with args %d %s", 42, "42")                     // want "empty: use assert\\.Emptyf"
		assert.Less(t, len(string(str)), 1)                                               // want "empty: use assert\\.Empty"
		assert.Lessf(t, len(string(str)), 1, "msg with args %d %s", 42, "42")             // want "empty: use assert\\.Emptyf"
		assert.Less(t, len(b), 1)                                                         // want "empty: use assert\\.Empty"
		assert.Lessf(t, len(b), 1, "msg with args %d %s", 42, "42")                       // want "empty: use assert\\.Emptyf"
		assert.Less(t, len(string(b)), 1)                                                 // want "empty: use assert\\.Empty"
		assert.Lessf(t, len(string(b)), 1, "msg with args %d %s", 42, "42")               // want "empty: use assert\\.Emptyf"
		assert.Less(t, len([]string{"e"}), 1)                                             // want "empty: use assert\\.Empty"
		assert.Lessf(t, len([]string{"e"}), 1, "msg with args %d %s", 42, "42")           // want "empty: use assert\\.Emptyf"
		assert.Greater(t, 1, len(elems))                                                  // want "empty: use assert\\.Empty"
		assert.Greaterf(t, 1, len(elems), "msg with args %d %s", 42, "42")                // want "empty: use assert\\.Emptyf"
		assert.Greater(t, 1, len(str))                                                    // want "empty: use assert\\.Empty"
		assert.Greaterf(t, 1, len(str), "msg with args %d %s", 42, "42")                  // want "empty: use assert\\.Emptyf"
		assert.Greater(t, 1, len(string(str)))                                            // want "empty: use assert\\.Empty"
		assert.Greaterf(t, 1, len(string(str)), "msg with args %d %s", 42, "42")          // want "empty: use assert\\.Emptyf"
		assert.Greater(t, 1, len(b))                                                      // want "empty: use assert\\.Empty"
		assert.Greaterf(t, 1, len(b), "msg with args %d %s", 42, "42")                    // want "empty: use assert\\.Emptyf"
		assert.Greater(t, 1, len(string(b)))                                              // want "empty: use assert\\.Empty"
		assert.Greaterf(t, 1, len(string(b)), "msg with args %d %s", 42, "42")            // want "empty: use assert\\.Emptyf"
		assert.Greater(t, 1, len([]string{"e"}))                                          // want "empty: use assert\\.Empty"
		assert.Greaterf(t, 1, len([]string{"e"}), "msg with args %d %s", 42, "42")        // want "empty: use assert\\.Emptyf"
		assert.Equal(t, "", elems)                                                        // want "empty: use assert\\.Empty"
		assert.Equalf(t, "", elems, "msg with args %d %s", 42, "42")                      // want "empty: use assert\\.Emptyf"
		assert.Equal(t, "", str)                                                          // want "empty: use assert\\.Empty"
		assert.Equalf(t, "", str, "msg with args %d %s", 42, "42")                        // want "empty: use assert\\.Emptyf"
		assert.Equal(t, "", string(str))                                                  // want "empty: use assert\\.Empty"
		assert.Equalf(t, "", string(str), "msg with args %d %s", 42, "42")                // want "empty: use assert\\.Emptyf"
		assert.Equal(t, "", b)                                                            // want "empty: use assert\\.Empty"
		assert.Equalf(t, "", b, "msg with args %d %s", 42, "42")                          // want "empty: use assert\\.Emptyf"
		assert.Equal(t, "", string(b))                                                    // want "empty: use assert\\.Empty"
		assert.Equalf(t, "", string(b), "msg with args %d %s", 42, "42")                  // want "empty: use assert\\.Emptyf"
		assert.Equal(t, "", []string{"e"})                                                // want "empty: use assert\\.Empty"
		assert.Equalf(t, "", []string{"e"}, "msg with args %d %s", 42, "42")              // want "empty: use assert\\.Emptyf"
		assert.EqualValues(t, "", elems)                                                  // want "empty: use assert\\.Empty"
		assert.EqualValuesf(t, "", elems, "msg with args %d %s", 42, "42")                // want "empty: use assert\\.Emptyf"
		assert.EqualValues(t, "", str)                                                    // want "empty: use assert\\.Empty"
		assert.EqualValuesf(t, "", str, "msg with args %d %s", 42, "42")                  // want "empty: use assert\\.Emptyf"
		assert.EqualValues(t, "", string(str))                                            // want "empty: use assert\\.Empty"
		assert.EqualValuesf(t, "", string(str), "msg with args %d %s", 42, "42")          // want "empty: use assert\\.Emptyf"
		assert.EqualValues(t, "", b)                                                      // want "empty: use assert\\.Empty"
		assert.EqualValuesf(t, "", b, "msg with args %d %s", 42, "42")                    // want "empty: use assert\\.Emptyf"
		assert.EqualValues(t, "", string(b))                                              // want "empty: use assert\\.Empty"
		assert.EqualValuesf(t, "", string(b), "msg with args %d %s", 42, "42")            // want "empty: use assert\\.Emptyf"
		assert.EqualValues(t, "", []string{"e"})                                          // want "empty: use assert\\.Empty"
		assert.EqualValuesf(t, "", []string{"e"}, "msg with args %d %s", 42, "42")        // want "empty: use assert\\.Emptyf"
		assert.Exactly(t, "", elems)                                                      // want "empty: use assert\\.Empty"
		assert.Exactlyf(t, "", elems, "msg with args %d %s", 42, "42")                    // want "empty: use assert\\.Emptyf"
		assert.Exactly(t, "", str)                                                        // want "empty: use assert\\.Empty"
		assert.Exactlyf(t, "", str, "msg with args %d %s", 42, "42")                      // want "empty: use assert\\.Emptyf"
		assert.Exactly(t, "", string(str))                                                // want "empty: use assert\\.Empty"
		assert.Exactlyf(t, "", string(str), "msg with args %d %s", 42, "42")              // want "empty: use assert\\.Emptyf"
		assert.Exactly(t, "", b)                                                          // want "empty: use assert\\.Empty"
		assert.Exactlyf(t, "", b, "msg with args %d %s", 42, "42")                        // want "empty: use assert\\.Emptyf"
		assert.Exactly(t, "", string(b))                                                  // want "empty: use assert\\.Empty"
		assert.Exactlyf(t, "", string(b), "msg with args %d %s", 42, "42")                // want "empty: use assert\\.Emptyf"
		assert.Exactly(t, "", []string{"e"})                                              // want "empty: use assert\\.Empty"
		assert.Exactlyf(t, "", []string{"e"}, "msg with args %d %s", 42, "42")            // want "empty: use assert\\.Emptyf"
		assert.Equal(t, ``, elems)                                                        // want "empty: use assert\\.Empty"
		assert.Equalf(t, ``, elems, "msg with args %d %s", 42, "42")                      // want "empty: use assert\\.Emptyf"
		assert.Equal(t, ``, str)                                                          // want "empty: use assert\\.Empty"
		assert.Equalf(t, ``, str, "msg with args %d %s", 42, "42")                        // want "empty: use assert\\.Emptyf"
		assert.Equal(t, ``, string(str))                                                  // want "empty: use assert\\.Empty"
		assert.Equalf(t, ``, string(str), "msg with args %d %s", 42, "42")                // want "empty: use assert\\.Emptyf"
		assert.Equal(t, ``, b)                                                            // want "empty: use assert\\.Empty"
		assert.Equalf(t, ``, b, "msg with args %d %s", 42, "42")                          // want "empty: use assert\\.Emptyf"
		assert.Equal(t, ``, string(b))                                                    // want "empty: use assert\\.Empty"
		assert.Equalf(t, ``, string(b), "msg with args %d %s", 42, "42")                  // want "empty: use assert\\.Emptyf"
		assert.Equal(t, ``, []string{"e"})                                                // want "empty: use assert\\.Empty"
		assert.Equalf(t, ``, []string{"e"}, "msg with args %d %s", 42, "42")              // want "empty: use assert\\.Emptyf"
		assert.EqualValues(t, ``, elems)                                                  // want "empty: use assert\\.Empty"
		assert.EqualValuesf(t, ``, elems, "msg with args %d %s", 42, "42")                // want "empty: use assert\\.Emptyf"
		assert.EqualValues(t, ``, str)                                                    // want "empty: use assert\\.Empty"
		assert.EqualValuesf(t, ``, str, "msg with args %d %s", 42, "42")                  // want "empty: use assert\\.Emptyf"
		assert.EqualValues(t, ``, string(str))                                            // want "empty: use assert\\.Empty"
		assert.EqualValuesf(t, ``, string(str), "msg with args %d %s", 42, "42")          // want "empty: use assert\\.Emptyf"
		assert.EqualValues(t, ``, b)                                                      // want "empty: use assert\\.Empty"
		assert.EqualValuesf(t, ``, b, "msg with args %d %s", 42, "42")                    // want "empty: use assert\\.Emptyf"
		assert.EqualValues(t, ``, string(b))                                              // want "empty: use assert\\.Empty"
		assert.EqualValuesf(t, ``, string(b), "msg with args %d %s", 42, "42")            // want "empty: use assert\\.Emptyf"
		assert.EqualValues(t, ``, []string{"e"})                                          // want "empty: use assert\\.Empty"
		assert.EqualValuesf(t, ``, []string{"e"}, "msg with args %d %s", 42, "42")        // want "empty: use assert\\.Emptyf"
		assert.Exactly(t, ``, elems)                                                      // want "empty: use assert\\.Empty"
		assert.Exactlyf(t, ``, elems, "msg with args %d %s", 42, "42")                    // want "empty: use assert\\.Emptyf"
		assert.Exactly(t, ``, str)                                                        // want "empty: use assert\\.Empty"
		assert.Exactlyf(t, ``, str, "msg with args %d %s", 42, "42")                      // want "empty: use assert\\.Emptyf"
		assert.Exactly(t, ``, string(str))                                                // want "empty: use assert\\.Empty"
		assert.Exactlyf(t, ``, string(str), "msg with args %d %s", 42, "42")              // want "empty: use assert\\.Emptyf"
		assert.Exactly(t, ``, b)                                                          // want "empty: use assert\\.Empty"
		assert.Exactlyf(t, ``, b, "msg with args %d %s", 42, "42")                        // want "empty: use assert\\.Emptyf"
		assert.Exactly(t, ``, string(b))                                                  // want "empty: use assert\\.Empty"
		assert.Exactlyf(t, ``, string(b), "msg with args %d %s", 42, "42")                // want "empty: use assert\\.Emptyf"
		assert.Exactly(t, ``, []string{"e"})                                              // want "empty: use assert\\.Empty"
		assert.Exactlyf(t, ``, []string{"e"}, "msg with args %d %s", 42, "42")            // want "empty: use assert\\.Emptyf"
		assert.Empty(t, len(elems))                                                       // want "empty: remove unnecessary len"
		assert.Emptyf(t, len(elems), "msg with args %d %s", 42, "42")                     // want "empty: remove unnecessary len"
		assert.Empty(t, len(str))                                                         // want "empty: remove unnecessary len"
		assert.Emptyf(t, len(str), "msg with args %d %s", 42, "42")                       // want "empty: remove unnecessary len"
		assert.Empty(t, len(string(str)))                                                 // want "empty: remove unnecessary len"
		assert.Emptyf(t, len(string(str)), "msg with args %d %s", 42, "42")               // want "empty: remove unnecessary len"
		assert.Empty(t, len(b))                                                           // want "empty: remove unnecessary len"
		assert.Emptyf(t, len(b), "msg with args %d %s", 42, "42")                         // want "empty: remove unnecessary len"
		assert.Empty(t, len(string(b)))                                                   // want "empty: remove unnecessary len"
		assert.Emptyf(t, len(string(b)), "msg with args %d %s", 42, "42")                 // want "empty: remove unnecessary len"
		assert.Empty(t, len([]string{"e"}))                                               // want "empty: remove unnecessary len"
		assert.Emptyf(t, len([]string{"e"}), "msg with args %d %s", 42, "42")             // want "empty: remove unnecessary len"
		assert.Zero(t, str)                                                               // want "empty: use assert\\.Empty"
		assert.Zerof(t, str, "msg with args %d %s", 42, "42")                             // want "empty: use assert\\.Emptyf"
		assert.Zero(t, string(str))                                                       // want "empty: use assert\\.Empty"
		assert.Zerof(t, string(str), "msg with args %d %s", 42, "42")                     // want "empty: use assert\\.Emptyf"
		assert.Zero(t, string(b))                                                         // want "empty: use assert\\.Empty"
		assert.Zerof(t, string(b), "msg with args %d %s", 42, "42")                       // want "empty: use assert\\.Emptyf"

		// Valid.
		assert.Empty(t, elems)
		assert.Emptyf(t, elems, "msg with args %d %s", 42, "42")
		assert.Empty(t, str)
		assert.Emptyf(t, str, "msg with args %d %s", 42, "42")
		assert.Empty(t, string(str))
		assert.Emptyf(t, string(str), "msg with args %d %s", 42, "42")
		assert.Empty(t, b)
		assert.Emptyf(t, b, "msg with args %d %s", 42, "42")
		assert.Empty(t, string(b))
		assert.Emptyf(t, string(b), "msg with args %d %s", 42, "42")
		assert.Empty(t, []string{"e"})
		assert.Emptyf(t, []string{"e"}, "msg with args %d %s", 42, "42")
	}

	// assert.NotEmpty cases.
	{
		// Invalid.
		assert.Positive(t, len(elems))                                                    // want "empty: use assert\\.NotEmpty"
		assert.Positivef(t, len(elems), "msg with args %d %s", 42, "42")                  // want "empty: use assert\\.NotEmptyf"
		assert.Positive(t, len(str))                                                      // want "empty: use assert\\.NotEmpty"
		assert.Positivef(t, len(str), "msg with args %d %s", 42, "42")                    // want "empty: use assert\\.NotEmptyf"
		assert.Positive(t, len(string(str)))                                              // want "empty: use assert\\.NotEmpty"
		assert.Positivef(t, len(string(str)), "msg with args %d %s", 42, "42")            // want "empty: use assert\\.NotEmptyf"
		assert.Positive(t, len(b))                                                        // want "empty: use assert\\.NotEmpty"
		assert.Positivef(t, len(b), "msg with args %d %s", 42, "42")                      // want "empty: use assert\\.NotEmptyf"
		assert.Positive(t, len(string(b)))                                                // want "empty: use assert\\.NotEmpty"
		assert.Positivef(t, len(string(b)), "msg with args %d %s", 42, "42")              // want "empty: use assert\\.NotEmptyf"
		assert.Positive(t, len([]string{"e"}))                                            // want "empty: use assert\\.NotEmpty"
		assert.Positivef(t, len([]string{"e"}), "msg with args %d %s", 42, "42")          // want "empty: use assert\\.NotEmptyf"
		assert.NotEqual(t, len(elems), 0)                                                 // want "empty: use assert\\.NotEmpty"
		assert.NotEqualf(t, len(elems), 0, "msg with args %d %s", 42, "42")               // want "empty: use assert\\.NotEmptyf"
		assert.NotEqual(t, len(str), 0)                                                   // want "empty: use assert\\.NotEmpty"
		assert.NotEqualf(t, len(str), 0, "msg with args %d %s", 42, "42")                 // want "empty: use assert\\.NotEmptyf"
		assert.NotEqual(t, len(string(str)), 0)                                           // want "empty: use assert\\.NotEmpty"
		assert.NotEqualf(t, len(string(str)), 0, "msg with args %d %s", 42, "42")         // want "empty: use assert\\.NotEmptyf"
		assert.NotEqual(t, len(b), 0)                                                     // want "empty: use assert\\.NotEmpty"
		assert.NotEqualf(t, len(b), 0, "msg with args %d %s", 42, "42")                   // want "empty: use assert\\.NotEmptyf"
		assert.NotEqual(t, len(string(b)), 0)                                             // want "empty: use assert\\.NotEmpty"
		assert.NotEqualf(t, len(string(b)), 0, "msg with args %d %s", 42, "42")           // want "empty: use assert\\.NotEmptyf"
		assert.NotEqual(t, len([]string{"e"}), 0)                                         // want "empty: use assert\\.NotEmpty"
		assert.NotEqualf(t, len([]string{"e"}), 0, "msg with args %d %s", 42, "42")       // want "empty: use assert\\.NotEmptyf"
		assert.NotEqual(t, 0, len(elems))                                                 // want "empty: use assert\\.NotEmpty"
		assert.NotEqualf(t, 0, len(elems), "msg with args %d %s", 42, "42")               // want "empty: use assert\\.NotEmptyf"
		assert.NotEqual(t, 0, len(str))                                                   // want "empty: use assert\\.NotEmpty"
		assert.NotEqualf(t, 0, len(str), "msg with args %d %s", 42, "42")                 // want "empty: use assert\\.NotEmptyf"
		assert.NotEqual(t, 0, len(string(str)))                                           // want "empty: use assert\\.NotEmpty"
		assert.NotEqualf(t, 0, len(string(str)), "msg with args %d %s", 42, "42")         // want "empty: use assert\\.NotEmptyf"
		assert.NotEqual(t, 0, len(b))                                                     // want "empty: use assert\\.NotEmpty"
		assert.NotEqualf(t, 0, len(b), "msg with args %d %s", 42, "42")                   // want "empty: use assert\\.NotEmptyf"
		assert.NotEqual(t, 0, len(string(b)))                                             // want "empty: use assert\\.NotEmpty"
		assert.NotEqualf(t, 0, len(string(b)), "msg with args %d %s", 42, "42")           // want "empty: use assert\\.NotEmptyf"
		assert.NotEqual(t, 0, len([]string{"e"}))                                         // want "empty: use assert\\.NotEmpty"
		assert.NotEqualf(t, 0, len([]string{"e"}), "msg with args %d %s", 42, "42")       // want "empty: use assert\\.NotEmptyf"
		assert.NotEqualValues(t, len(elems), 0)                                           // want "empty: use assert\\.NotEmpty"
		assert.NotEqualValuesf(t, len(elems), 0, "msg with args %d %s", 42, "42")         // want "empty: use assert\\.NotEmptyf"
		assert.NotEqualValues(t, len(str), 0)                                             // want "empty: use assert\\.NotEmpty"
		assert.NotEqualValuesf(t, len(str), 0, "msg with args %d %s", 42, "42")           // want "empty: use assert\\.NotEmptyf"
		assert.NotEqualValues(t, len(string(str)), 0)                                     // want "empty: use assert\\.NotEmpty"
		assert.NotEqualValuesf(t, len(string(str)), 0, "msg with args %d %s", 42, "42")   // want "empty: use assert\\.NotEmptyf"
		assert.NotEqualValues(t, len(b), 0)                                               // want "empty: use assert\\.NotEmpty"
		assert.NotEqualValuesf(t, len(b), 0, "msg with args %d %s", 42, "42")             // want "empty: use assert\\.NotEmptyf"
		assert.NotEqualValues(t, len(string(b)), 0)                                       // want "empty: use assert\\.NotEmpty"
		assert.NotEqualValuesf(t, len(string(b)), 0, "msg with args %d %s", 42, "42")     // want "empty: use assert\\.NotEmptyf"
		assert.NotEqualValues(t, len([]string{"e"}), 0)                                   // want "empty: use assert\\.NotEmpty"
		assert.NotEqualValuesf(t, len([]string{"e"}), 0, "msg with args %d %s", 42, "42") // want "empty: use assert\\.NotEmptyf"
		assert.NotEqualValues(t, 0, len(elems))                                           // want "empty: use assert\\.NotEmpty"
		assert.NotEqualValuesf(t, 0, len(elems), "msg with args %d %s", 42, "42")         // want "empty: use assert\\.NotEmptyf"
		assert.NotEqualValues(t, 0, len(str))                                             // want "empty: use assert\\.NotEmpty"
		assert.NotEqualValuesf(t, 0, len(str), "msg with args %d %s", 42, "42")           // want "empty: use assert\\.NotEmptyf"
		assert.NotEqualValues(t, 0, len(string(str)))                                     // want "empty: use assert\\.NotEmpty"
		assert.NotEqualValuesf(t, 0, len(string(str)), "msg with args %d %s", 42, "42")   // want "empty: use assert\\.NotEmptyf"
		assert.NotEqualValues(t, 0, len(b))                                               // want "empty: use assert\\.NotEmpty"
		assert.NotEqualValuesf(t, 0, len(b), "msg with args %d %s", 42, "42")             // want "empty: use assert\\.NotEmptyf"
		assert.NotEqualValues(t, 0, len(string(b)))                                       // want "empty: use assert\\.NotEmpty"
		assert.NotEqualValuesf(t, 0, len(string(b)), "msg with args %d %s", 42, "42")     // want "empty: use assert\\.NotEmptyf"
		assert.NotEqualValues(t, 0, len([]string{"e"}))                                   // want "empty: use assert\\.NotEmpty"
		assert.NotEqualValuesf(t, 0, len([]string{"e"}), "msg with args %d %s", 42, "42") // want "empty: use assert\\.NotEmptyf"
		assert.Greater(t, len(elems), 0)                                                  // want "empty: use assert\\.NotEmpty"
		assert.Greaterf(t, len(elems), 0, "msg with args %d %s", 42, "42")                // want "empty: use assert\\.NotEmptyf"
		assert.Greater(t, len(str), 0)                                                    // want "empty: use assert\\.NotEmpty"
		assert.Greaterf(t, len(str), 0, "msg with args %d %s", 42, "42")                  // want "empty: use assert\\.NotEmptyf"
		assert.Greater(t, len(string(str)), 0)                                            // want "empty: use assert\\.NotEmpty"
		assert.Greaterf(t, len(string(str)), 0, "msg with args %d %s", 42, "42")          // want "empty: use assert\\.NotEmptyf"
		assert.Greater(t, len(b), 0)                                                      // want "empty: use assert\\.NotEmpty"
		assert.Greaterf(t, len(b), 0, "msg with args %d %s", 42, "42")                    // want "empty: use assert\\.NotEmptyf"
		assert.Greater(t, len(string(b)), 0)                                              // want "empty: use assert\\.NotEmpty"
		assert.Greaterf(t, len(string(b)), 0, "msg with args %d %s", 42, "42")            // want "empty: use assert\\.NotEmptyf"
		assert.Greater(t, len([]string{"e"}), 0)                                          // want "empty: use assert\\.NotEmpty"
		assert.Greaterf(t, len([]string{"e"}), 0, "msg with args %d %s", 42, "42")        // want "empty: use assert\\.NotEmptyf"
		assert.Less(t, 0, len(elems))                                                     // want "empty: use assert\\.NotEmpty"
		assert.Lessf(t, 0, len(elems), "msg with args %d %s", 42, "42")                   // want "empty: use assert\\.NotEmptyf"
		assert.Less(t, 0, len(str))                                                       // want "empty: use assert\\.NotEmpty"
		assert.Lessf(t, 0, len(str), "msg with args %d %s", 42, "42")                     // want "empty: use assert\\.NotEmptyf"
		assert.Less(t, 0, len(string(str)))                                               // want "empty: use assert\\.NotEmpty"
		assert.Lessf(t, 0, len(string(str)), "msg with args %d %s", 42, "42")             // want "empty: use assert\\.NotEmptyf"
		assert.Less(t, 0, len(b))                                                         // want "empty: use assert\\.NotEmpty"
		assert.Lessf(t, 0, len(b), "msg with args %d %s", 42, "42")                       // want "empty: use assert\\.NotEmptyf"
		assert.Less(t, 0, len(string(b)))                                                 // want "empty: use assert\\.NotEmpty"
		assert.Lessf(t, 0, len(string(b)), "msg with args %d %s", 42, "42")               // want "empty: use assert\\.NotEmptyf"
		assert.Less(t, 0, len([]string{"e"}))                                             // want "empty: use assert\\.NotEmpty"
		assert.Lessf(t, 0, len([]string{"e"}), "msg with args %d %s", 42, "42")           // want "empty: use assert\\.NotEmptyf"
		assert.NotEqual(t, "", elems)                                                     // want "empty: use assert\\.NotEmpty"
		assert.NotEqualf(t, "", elems, "msg with args %d %s", 42, "42")                   // want "empty: use assert\\.NotEmptyf"
		assert.NotEqual(t, "", str)                                                       // want "empty: use assert\\.NotEmpty"
		assert.NotEqualf(t, "", str, "msg with args %d %s", 42, "42")                     // want "empty: use assert\\.NotEmptyf"
		assert.NotEqual(t, "", string(str))                                               // want "empty: use assert\\.NotEmpty"
		assert.NotEqualf(t, "", string(str), "msg with args %d %s", 42, "42")             // want "empty: use assert\\.NotEmptyf"
		assert.NotEqual(t, "", b)                                                         // want "empty: use assert\\.NotEmpty"
		assert.NotEqualf(t, "", b, "msg with args %d %s", 42, "42")                       // want "empty: use assert\\.NotEmptyf"
		assert.NotEqual(t, "", string(b))                                                 // want "empty: use assert\\.NotEmpty"
		assert.NotEqualf(t, "", string(b), "msg with args %d %s", 42, "42")               // want "empty: use assert\\.NotEmptyf"
		assert.NotEqual(t, "", []string{"e"})                                             // want "empty: use assert\\.NotEmpty"
		assert.NotEqualf(t, "", []string{"e"}, "msg with args %d %s", 42, "42")           // want "empty: use assert\\.NotEmptyf"
		assert.NotEqualValues(t, "", elems)                                               // want "empty: use assert\\.NotEmpty"
		assert.NotEqualValuesf(t, "", elems, "msg with args %d %s", 42, "42")             // want "empty: use assert\\.NotEmptyf"
		assert.NotEqualValues(t, "", str)                                                 // want "empty: use assert\\.NotEmpty"
		assert.NotEqualValuesf(t, "", str, "msg with args %d %s", 42, "42")               // want "empty: use assert\\.NotEmptyf"
		assert.NotEqualValues(t, "", string(str))                                         // want "empty: use assert\\.NotEmpty"
		assert.NotEqualValuesf(t, "", string(str), "msg with args %d %s", 42, "42")       // want "empty: use assert\\.NotEmptyf"
		assert.NotEqualValues(t, "", b)                                                   // want "empty: use assert\\.NotEmpty"
		assert.NotEqualValuesf(t, "", b, "msg with args %d %s", 42, "42")                 // want "empty: use assert\\.NotEmptyf"
		assert.NotEqualValues(t, "", string(b))                                           // want "empty: use assert\\.NotEmpty"
		assert.NotEqualValuesf(t, "", string(b), "msg with args %d %s", 42, "42")         // want "empty: use assert\\.NotEmptyf"
		assert.NotEqualValues(t, "", []string{"e"})                                       // want "empty: use assert\\.NotEmpty"
		assert.NotEqualValuesf(t, "", []string{"e"}, "msg with args %d %s", 42, "42")     // want "empty: use assert\\.NotEmptyf"
		assert.NotEqual(t, ``, elems)                                                     // want "empty: use assert\\.NotEmpty"
		assert.NotEqualf(t, ``, elems, "msg with args %d %s", 42, "42")                   // want "empty: use assert\\.NotEmptyf"
		assert.NotEqual(t, ``, str)                                                       // want "empty: use assert\\.NotEmpty"
		assert.NotEqualf(t, ``, str, "msg with args %d %s", 42, "42")                     // want "empty: use assert\\.NotEmptyf"
		assert.NotEqual(t, ``, string(str))                                               // want "empty: use assert\\.NotEmpty"
		assert.NotEqualf(t, ``, string(str), "msg with args %d %s", 42, "42")             // want "empty: use assert\\.NotEmptyf"
		assert.NotEqual(t, ``, b)                                                         // want "empty: use assert\\.NotEmpty"
		assert.NotEqualf(t, ``, b, "msg with args %d %s", 42, "42")                       // want "empty: use assert\\.NotEmptyf"
		assert.NotEqual(t, ``, string(b))                                                 // want "empty: use assert\\.NotEmpty"
		assert.NotEqualf(t, ``, string(b), "msg with args %d %s", 42, "42")               // want "empty: use assert\\.NotEmptyf"
		assert.NotEqual(t, ``, []string{"e"})                                             // want "empty: use assert\\.NotEmpty"
		assert.NotEqualf(t, ``, []string{"e"}, "msg with args %d %s", 42, "42")           // want "empty: use assert\\.NotEmptyf"
		assert.NotEqualValues(t, ``, elems)                                               // want "empty: use assert\\.NotEmpty"
		assert.NotEqualValuesf(t, ``, elems, "msg with args %d %s", 42, "42")             // want "empty: use assert\\.NotEmptyf"
		assert.NotEqualValues(t, ``, str)                                                 // want "empty: use assert\\.NotEmpty"
		assert.NotEqualValuesf(t, ``, str, "msg with args %d %s", 42, "42")               // want "empty: use assert\\.NotEmptyf"
		assert.NotEqualValues(t, ``, string(str))                                         // want "empty: use assert\\.NotEmpty"
		assert.NotEqualValuesf(t, ``, string(str), "msg with args %d %s", 42, "42")       // want "empty: use assert\\.NotEmptyf"
		assert.NotEqualValues(t, ``, b)                                                   // want "empty: use assert\\.NotEmpty"
		assert.NotEqualValuesf(t, ``, b, "msg with args %d %s", 42, "42")                 // want "empty: use assert\\.NotEmptyf"
		assert.NotEqualValues(t, ``, string(b))                                           // want "empty: use assert\\.NotEmpty"
		assert.NotEqualValuesf(t, ``, string(b), "msg with args %d %s", 42, "42")         // want "empty: use assert\\.NotEmptyf"
		assert.NotEqualValues(t, ``, []string{"e"})                                       // want "empty: use assert\\.NotEmpty"
		assert.NotEqualValuesf(t, ``, []string{"e"}, "msg with args %d %s", 42, "42")     // want "empty: use assert\\.NotEmptyf"
		assert.NotEmpty(t, len(elems))                                                    // want "empty: remove unnecessary len"
		assert.NotEmptyf(t, len(elems), "msg with args %d %s", 42, "42")                  // want "empty: remove unnecessary len"
		assert.NotEmpty(t, len(str))                                                      // want "empty: remove unnecessary len"
		assert.NotEmptyf(t, len(str), "msg with args %d %s", 42, "42")                    // want "empty: remove unnecessary len"
		assert.NotEmpty(t, len(string(str)))                                              // want "empty: remove unnecessary len"
		assert.NotEmptyf(t, len(string(str)), "msg with args %d %s", 42, "42")            // want "empty: remove unnecessary len"
		assert.NotEmpty(t, len(b))                                                        // want "empty: remove unnecessary len"
		assert.NotEmptyf(t, len(b), "msg with args %d %s", 42, "42")                      // want "empty: remove unnecessary len"
		assert.NotEmpty(t, len(string(b)))                                                // want "empty: remove unnecessary len"
		assert.NotEmptyf(t, len(string(b)), "msg with args %d %s", 42, "42")              // want "empty: remove unnecessary len"
		assert.NotEmpty(t, len([]string{"e"}))                                            // want "empty: remove unnecessary len"
		assert.NotEmptyf(t, len([]string{"e"}), "msg with args %d %s", 42, "42")          // want "empty: remove unnecessary len"
		assert.NotZero(t, str)                                                            // want "empty: use assert\\.NotEmpty"
		assert.NotZerof(t, str, "msg with args %d %s", 42, "42")                          // want "empty: use assert\\.NotEmptyf"
		assert.NotZero(t, string(str))                                                    // want "empty: use assert\\.NotEmpty"
		assert.NotZerof(t, string(str), "msg with args %d %s", 42, "42")                  // want "empty: use assert\\.NotEmptyf"
		assert.NotZero(t, string(b))                                                      // want "empty: use assert\\.NotEmpty"
		assert.NotZerof(t, string(b), "msg with args %d %s", 42, "42")                    // want "empty: use assert\\.NotEmptyf"

		// Valid.
		assert.NotEmpty(t, elems)
		assert.NotEmptyf(t, elems, "msg with args %d %s", 42, "42")
		assert.NotEmpty(t, str)
		assert.NotEmptyf(t, str, "msg with args %d %s", 42, "42")
		assert.NotEmpty(t, string(str))
		assert.NotEmptyf(t, string(str), "msg with args %d %s", 42, "42")
		assert.NotEmpty(t, b)
		assert.NotEmptyf(t, b, "msg with args %d %s", 42, "42")
		assert.NotEmpty(t, string(b))
		assert.NotEmptyf(t, string(b), "msg with args %d %s", 42, "42")
		assert.NotEmpty(t, []string{"e"})
		assert.NotEmptyf(t, []string{"e"}, "msg with args %d %s", 42, "42")
	}
}

func TestEmptyChecker_LenVarIndependence(t *testing.T) {
	var (
		elems  []any
		arr    [0]int
		arrPtr *[0]int
		sl     []int
		mp     map[int]int
		str    string
		b      []byte
		ch     chan int
	)

	assert.Equal(t, 0, len(elems))         // want "empty: use assert\\.Empty"
	assert.Equal(t, 0, len(arr))           // want "empty: use assert\\.Empty"
	assert.Equal(t, 0, len(arrPtr))        // want "empty: use assert\\.Empty"
	assert.Equal(t, 0, len(sl))            // want "empty: use assert\\.Empty"
	assert.Equal(t, 0, len(mp))            // want "empty: use assert\\.Empty"
	assert.Equal(t, 0, len(str))           // want "empty: use assert\\.Empty"
	assert.Equal(t, 0, len(b))             // want "empty: use assert\\.Empty"
	assert.Equal(t, 0, len(ch))            // want "empty: use assert\\.Empty"
	assert.Equal(t, 0, len([]byte(str)))   // want "empty: use assert\\.Empty"
	assert.Equal(t, 0, len(string(str)))   // want "empty: use assert\\.Empty"
	assert.Equal(t, 0, len([]string{"e"})) // want "empty: use assert\\.Empty"
}

func TestEmptyChecker_Ignored(t *testing.T) {
	var (
		err    error
		arr    [0]int
		arrPtr *[0]int
		mp     map[int]int
		i      int
		ch     chan int
		elems  []any
		b      []byte
	)

	assert.Len(t, elems, len(elems))
	assert.Lenf(t, elems, len(elems), "msg with args %d %s", 42, "42")
	assert.Len(t, elems, 1)
	assert.Lenf(t, elems, 1, "msg with args %d %s", 42, "42")
	assert.Equal(t, len(elems), len(elems))
	assert.Equalf(t, len(elems), len(elems), "msg with args %d %s", 42, "42")
	assert.Equal(t, len(elems), 1)
	assert.Equalf(t, len(elems), 1, "msg with args %d %s", 42, "42")
	assert.Equal(t, 1, len(elems))
	assert.Equalf(t, 1, len(elems), "msg with args %d %s", 42, "42")
	assert.Equal(t, nil, elems)
	assert.Equalf(t, nil, elems, "msg with args %d %s", 42, "42")
	assert.Equal(t, nil, b)
	assert.Equalf(t, nil, b, "msg with args %d %s", 42, "42")
	assert.Nil(t, elems)
	assert.Nilf(t, elems, "msg with args %d %s", 42, "42")
	assert.Nil(t, b)
	assert.Nilf(t, b, "msg with args %d %s", 42, "42")
	assert.Equal(t, []byte(nil), b)
	assert.Equalf(t, []byte(nil), b, "msg with args %d %s", 42, "42")
	assert.NotEqual(t, len(elems), len(elems))
	assert.NotEqualf(t, len(elems), len(elems), "msg with args %d %s", 42, "42")
	assert.NotEqual(t, len(elems), 1)
	assert.NotEqualf(t, len(elems), 1, "msg with args %d %s", 42, "42")
	assert.NotEqual(t, 1, len(elems))
	assert.NotEqualf(t, 1, len(elems), "msg with args %d %s", 42, "42")
	assert.NotEqual(t, nil, elems)
	assert.NotEqualf(t, nil, elems, "msg with args %d %s", 42, "42")
	assert.NotEqual(t, nil, b)
	assert.NotEqualf(t, nil, b, "msg with args %d %s", 42, "42")
	assert.NotNil(t, elems)
	assert.NotNilf(t, elems, "msg with args %d %s", 42, "42")
	assert.NotNil(t, b)
	assert.NotNilf(t, b, "msg with args %d %s", 42, "42")
	assert.NotEqual(t, []byte(nil), b)
	assert.NotEqualf(t, []byte(nil), b, "msg with args %d %s", 42, "42")
	assert.Greater(t, len(elems), len(elems))
	assert.Greaterf(t, len(elems), len(elems), "msg with args %d %s", 42, "42")
	assert.Greater(t, len(elems), 2)
	assert.Greaterf(t, len(elems), 2, "msg with args %d %s", 42, "42")
	assert.Greater(t, 2, len(elems))
	assert.Greaterf(t, 2, len(elems), "msg with args %d %s", 42, "42")
	assert.GreaterOrEqual(t, len(elems), len(elems))
	assert.GreaterOrEqualf(t, len(elems), len(elems), "msg with args %d %s", 42, "42")
	assert.GreaterOrEqual(t, len(elems), 0)
	assert.GreaterOrEqualf(t, len(elems), 0, "msg with args %d %s", 42, "42")
	assert.GreaterOrEqual(t, len(elems), 2)
	assert.GreaterOrEqualf(t, len(elems), 2, "msg with args %d %s", 42, "42")
	assert.GreaterOrEqual(t, 2, len(elems))
	assert.GreaterOrEqualf(t, 2, len(elems), "msg with args %d %s", 42, "42")
	assert.Less(t, len(elems), len(elems))
	assert.Lessf(t, len(elems), len(elems), "msg with args %d %s", 42, "42")
	assert.Less(t, len(elems), 2)
	assert.Lessf(t, len(elems), 2, "msg with args %d %s", 42, "42")
	assert.Less(t, 2, len(elems))
	assert.Lessf(t, 2, len(elems), "msg with args %d %s", 42, "42")
	assert.LessOrEqual(t, len(elems), len(elems))
	assert.LessOrEqualf(t, len(elems), len(elems), "msg with args %d %s", 42, "42")
	assert.LessOrEqual(t, 0, len(elems))
	assert.LessOrEqualf(t, 0, len(elems), "msg with args %d %s", 42, "42")
	assert.LessOrEqual(t, len(elems), 2)
	assert.LessOrEqualf(t, len(elems), 2, "msg with args %d %s", 42, "42")
	assert.LessOrEqual(t, 2, len(elems))
	assert.LessOrEqualf(t, 2, len(elems), "msg with args %d %s", 42, "42")
	assert.Equal(t, 0, i)
	assert.Equalf(t, 0, i, "msg with args %d %s", 42, "42")
	assert.NotEqual(t, 0, i)
	assert.NotEqualf(t, 0, i, "msg with args %d %s", 42, "42")
	assert.Empty(t, err)
	assert.Emptyf(t, err, "msg with args %d %s", 42, "42")
	assert.NotEmpty(t, err)
	assert.NotEmptyf(t, err, "msg with args %d %s", 42, "42")
	assert.Zero(t, elems)
	assert.Zerof(t, elems, "msg with args %d %s", 42, "42")
	assert.Zero(t, arr)
	assert.Zerof(t, arr, "msg with args %d %s", 42, "42")
	assert.Zero(t, arrPtr)
	assert.Zerof(t, arrPtr, "msg with args %d %s", 42, "42")
	assert.Zero(t, mp)
	assert.Zerof(t, mp, "msg with args %d %s", 42, "42")
	assert.Zero(t, b)
	assert.Zerof(t, b, "msg with args %d %s", 42, "42")
	assert.Zero(t, i)
	assert.Zerof(t, i, "msg with args %d %s", 42, "42")
	assert.Zero(t, ch)
	assert.Zerof(t, ch, "msg with args %d %s", 42, "42")
	assert.Zero(t, []string{"e"})
	assert.Zerof(t, []string{"e"}, "msg with args %d %s", 42, "42")
	assert.NotZero(t, elems)
	assert.NotZerof(t, elems, "msg with args %d %s", 42, "42")
	assert.NotZero(t, arr)
	assert.NotZerof(t, arr, "msg with args %d %s", 42, "42")
	assert.NotZero(t, arrPtr)
	assert.NotZerof(t, arrPtr, "msg with args %d %s", 42, "42")
	assert.NotZero(t, mp)
	assert.NotZerof(t, mp, "msg with args %d %s", 42, "42")
	assert.NotZero(t, b)
	assert.NotZerof(t, b, "msg with args %d %s", 42, "42")
	assert.NotZero(t, i)
	assert.NotZerof(t, i, "msg with args %d %s", 42, "42")
	assert.NotZero(t, ch)
	assert.NotZerof(t, ch, "msg with args %d %s", 42, "42")
	assert.NotZero(t, []string{"e"})
	assert.NotZerof(t, []string{"e"}, "msg with args %d %s", 42, "42")
	assert.Greater(t, len(elems), 1)
	assert.Greaterf(t, len(elems), 1, "msg with args %d %s", 42, "42")
	assert.Less(t, 1, len(elems))
	assert.Lessf(t, 1, len(elems), "msg with args %d %s", 42, "42")
	assert.GreaterOrEqual(t, len(elems), 1)
	assert.GreaterOrEqualf(t, len(elems), 1, "msg with args %d %s", 42, "42")
	assert.LessOrEqual(t, 1, len(elems))
	assert.LessOrEqualf(t, 1, len(elems), "msg with args %d %s", 42, "42")
}
