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

package basetests

import (
	"testing"

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

func TestBase(t *testing.T) {
	var predicate bool

	assert.Equal(t, true, predicate)                                   // want "bool-compare: use assert\\.True"
	assert.Equal(t, true, predicate, "msg")                            // want "bool-compare: use assert\\.True"
	assert.Equal(t, true, predicate, "msg with arg %d", 42)            // want "bool-compare: use assert\\.True"
	assert.Equal(t, true, predicate, "msg with args %d %s", 42, "42")  // want "bool-compare: use assert\\.True"
	assert.Equalf(t, true, predicate, "msg")                           // want "bool-compare: use assert\\.Truef"
	assert.Equalf(t, true, predicate, "msg with arg %d", 42)           // want "bool-compare: use assert\\.Truef"
	assert.Equalf(t, true, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use assert\\.Truef"

	assert.True(t, predicate)
	assert.True(t, predicate, "msg")
	assert.True(t, predicate, "msg with arg %d", 42)
	assert.True(t, predicate, "msg with args %d %s", 42, "42")
	assert.Truef(t, predicate, "msg")
	assert.Truef(t, predicate, "msg with arg %d", 42)
	assert.Truef(t, predicate, "msg with args %d %s", 42, "42")

	require.Equal(t, true, predicate)                                   // want "bool-compare: use require\\.True"
	require.Equal(t, true, predicate, "msg")                            // want "bool-compare: use require\\.True"
	require.Equal(t, true, predicate, "msg with arg %d", 42)            // want "bool-compare: use require\\.True"
	require.Equal(t, true, predicate, "msg with args %d %s", 42, "42")  // want "bool-compare: use require\\.True"
	require.Equalf(t, true, predicate, "msg")                           // want "bool-compare: use require\\.Truef"
	require.Equalf(t, true, predicate, "msg with arg %d", 42)           // want "bool-compare: use require\\.Truef"
	require.Equalf(t, true, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use require\\.Truef"

	require.True(t, predicate)
	require.True(t, predicate, "msg")
	require.True(t, predicate, "msg with arg %d", 42)
	require.True(t, predicate, "msg with args %d %s", 42, "42")
	require.Truef(t, predicate, "msg")
	require.Truef(t, predicate, "msg with arg %d", 42)
	require.Truef(t, predicate, "msg with args %d %s", 42, "42")

	assertObj, requireObj := assert.New(t), require.New(t)

	assert.New(t).Equal(true, predicate)                                   // want "bool-compare: use assert\\.New\\(t\\)\\.True"
	assert.New(t).Equal(true, predicate, "msg")                            // want "bool-compare: use assert\\.New\\(t\\)\\.True"
	assert.New(t).Equal(true, predicate, "msg with arg %d", 42)            // want "bool-compare: use assert\\.New\\(t\\)\\.True"
	assert.New(t).Equal(true, predicate, "msg with args %d %s", 42, "42")  // want "bool-compare: use assert\\.New\\(t\\)\\.True"
	assert.New(t).Equalf(true, predicate, "msg")                           // want "bool-compare: use assert\\.New\\(t\\)\\.Truef"
	assert.New(t).Equalf(true, predicate, "msg with arg %d", 42)           // want "bool-compare: use assert\\.New\\(t\\)\\.Truef"
	assert.New(t).Equalf(true, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use assert\\.New\\(t\\)\\.Truef"

	assert.New(t).True(predicate)
	assert.New(t).True(predicate, "msg")
	assert.New(t).True(predicate, "msg with arg %d", 42)
	assert.New(t).True(predicate, "msg with args %d %s", 42, "42")
	assert.New(t).Truef(predicate, "msg")
	assert.New(t).Truef(predicate, "msg with arg %d", 42)
	assert.New(t).Truef(predicate, "msg with args %d %s", 42, "42")

	assertObj.Equal(true, predicate)                                   // want "bool-compare: use assertObj\\.True"
	assertObj.Equal(true, predicate, "msg")                            // want "bool-compare: use assertObj\\.True"
	assertObj.Equal(true, predicate, "msg with arg %d", 42)            // want "bool-compare: use assertObj\\.True"
	assertObj.Equal(true, predicate, "msg with args %d %s", 42, "42")  // want "bool-compare: use assertObj\\.True"
	assertObj.Equalf(true, predicate, "msg")                           // want "bool-compare: use assertObj\\.Truef"
	assertObj.Equalf(true, predicate, "msg with arg %d", 42)           // want "bool-compare: use assertObj\\.Truef"
	assertObj.Equalf(true, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use assertObj\\.Truef"

	assertObj.True(predicate)
	assertObj.True(predicate, "msg")
	assertObj.True(predicate, "msg with arg %d", 42)
	assertObj.True(predicate, "msg with args %d %s", 42, "42")
	assertObj.Truef(predicate, "msg")
	assertObj.Truef(predicate, "msg with arg %d", 42)
	assertObj.Truef(predicate, "msg with args %d %s", 42, "42")

	require.New(t).Equal(true, predicate)                                   // want "bool-compare: use require\\.New\\(t\\)\\.True"
	require.New(t).Equal(true, predicate, "msg")                            // want "bool-compare: use require\\.New\\(t\\)\\.True"
	require.New(t).Equal(true, predicate, "msg with arg %d", 42)            // want "bool-compare: use require\\.New\\(t\\)\\.True"
	require.New(t).Equal(true, predicate, "msg with args %d %s", 42, "42")  // want "bool-compare: use require\\.New\\(t\\)\\.True"
	require.New(t).Equalf(true, predicate, "msg")                           // want "bool-compare: use require\\.New\\(t\\)\\.Truef"
	require.New(t).Equalf(true, predicate, "msg with arg %d", 42)           // want "bool-compare: use require\\.New\\(t\\)\\.Truef"
	require.New(t).Equalf(true, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use require\\.New\\(t\\)\\.Truef"

	require.New(t).True(predicate)
	require.New(t).True(predicate, "msg")
	require.New(t).True(predicate, "msg with arg %d", 42)
	require.New(t).True(predicate, "msg with args %d %s", 42, "42")
	require.New(t).Truef(predicate, "msg")
	require.New(t).Truef(predicate, "msg with arg %d", 42)
	require.New(t).Truef(predicate, "msg with args %d %s", 42, "42")

	requireObj.Equal(true, predicate)                                   // want "bool-compare: use requireObj\\.True"
	requireObj.Equal(true, predicate, "msg")                            // want "bool-compare: use requireObj\\.True"
	requireObj.Equal(true, predicate, "msg with arg %d", 42)            // want "bool-compare: use requireObj\\.True"
	requireObj.Equal(true, predicate, "msg with args %d %s", 42, "42")  // want "bool-compare: use requireObj\\.True"
	requireObj.Equalf(true, predicate, "msg")                           // want "bool-compare: use requireObj\\.Truef"
	requireObj.Equalf(true, predicate, "msg with arg %d", 42)           // want "bool-compare: use requireObj\\.Truef"
	requireObj.Equalf(true, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use requireObj\\.Truef"

	requireObj.True(predicate)
	requireObj.True(predicate, "msg")
	requireObj.True(predicate, "msg with arg %d", 42)
	requireObj.True(predicate, "msg with args %d %s", 42, "42")
	requireObj.Truef(predicate, "msg")
	requireObj.Truef(predicate, "msg with arg %d", 42)
	requireObj.Truef(predicate, "msg with args %d %s", 42, "42")

	t.Run("subtest1", func(t *testing.T) {
		assert.Equal(t, true, predicate)                                   // want "bool-compare: use assert\\.True"
		assert.Equal(t, true, predicate, "msg")                            // want "bool-compare: use assert\\.True"
		assert.Equal(t, true, predicate, "msg with arg %d", 42)            // want "bool-compare: use assert\\.True"
		assert.Equal(t, true, predicate, "msg with args %d %s", 42, "42")  // want "bool-compare: use assert\\.True"
		assert.Equalf(t, true, predicate, "msg")                           // want "bool-compare: use assert\\.Truef"
		assert.Equalf(t, true, predicate, "msg with arg %d", 42)           // want "bool-compare: use assert\\.Truef"
		assert.Equalf(t, true, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use assert\\.Truef"

		assert.True(t, predicate)
		assert.True(t, predicate, "msg")
		assert.True(t, predicate, "msg with arg %d", 42)
		assert.True(t, predicate, "msg with args %d %s", 42, "42")
		assert.Truef(t, predicate, "msg")
		assert.Truef(t, predicate, "msg with arg %d", 42)
		assert.Truef(t, predicate, "msg with args %d %s", 42, "42")

		require.Equal(t, true, predicate)                                   // want "bool-compare: use require\\.True"
		require.Equal(t, true, predicate, "msg")                            // want "bool-compare: use require\\.True"
		require.Equal(t, true, predicate, "msg with arg %d", 42)            // want "bool-compare: use require\\.True"
		require.Equal(t, true, predicate, "msg with args %d %s", 42, "42")  // want "bool-compare: use require\\.True"
		require.Equalf(t, true, predicate, "msg")                           // want "bool-compare: use require\\.Truef"
		require.Equalf(t, true, predicate, "msg with arg %d", 42)           // want "bool-compare: use require\\.Truef"
		require.Equalf(t, true, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use require\\.Truef"

		require.True(t, predicate)
		require.True(t, predicate, "msg")
		require.True(t, predicate, "msg with arg %d", 42)
		require.True(t, predicate, "msg with args %d %s", 42, "42")
		require.Truef(t, predicate, "msg")
		require.Truef(t, predicate, "msg with arg %d", 42)
		require.Truef(t, predicate, "msg with args %d %s", 42, "42")

		assertObj, requireObj := assert.New(t), require.New(t)

		assert.New(t).Equal(true, predicate)                                   // want "bool-compare: use assert\\.New\\(t\\)\\.True"
		assert.New(t).Equal(true, predicate, "msg")                            // want "bool-compare: use assert\\.New\\(t\\)\\.True"
		assert.New(t).Equal(true, predicate, "msg with arg %d", 42)            // want "bool-compare: use assert\\.New\\(t\\)\\.True"
		assert.New(t).Equal(true, predicate, "msg with args %d %s", 42, "42")  // want "bool-compare: use assert\\.New\\(t\\)\\.True"
		assert.New(t).Equalf(true, predicate, "msg")                           // want "bool-compare: use assert\\.New\\(t\\)\\.Truef"
		assert.New(t).Equalf(true, predicate, "msg with arg %d", 42)           // want "bool-compare: use assert\\.New\\(t\\)\\.Truef"
		assert.New(t).Equalf(true, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use assert\\.New\\(t\\)\\.Truef"

		assert.New(t).True(predicate)
		assert.New(t).True(predicate, "msg")
		assert.New(t).True(predicate, "msg with arg %d", 42)
		assert.New(t).True(predicate, "msg with args %d %s", 42, "42")
		assert.New(t).Truef(predicate, "msg")
		assert.New(t).Truef(predicate, "msg with arg %d", 42)
		assert.New(t).Truef(predicate, "msg with args %d %s", 42, "42")

		assertObj.Equal(true, predicate)                                   // want "bool-compare: use assertObj\\.True"
		assertObj.Equal(true, predicate, "msg")                            // want "bool-compare: use assertObj\\.True"
		assertObj.Equal(true, predicate, "msg with arg %d", 42)            // want "bool-compare: use assertObj\\.True"
		assertObj.Equal(true, predicate, "msg with args %d %s", 42, "42")  // want "bool-compare: use assertObj\\.True"
		assertObj.Equalf(true, predicate, "msg")                           // want "bool-compare: use assertObj\\.Truef"
		assertObj.Equalf(true, predicate, "msg with arg %d", 42)           // want "bool-compare: use assertObj\\.Truef"
		assertObj.Equalf(true, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use assertObj\\.Truef"

		assertObj.True(predicate)
		assertObj.True(predicate, "msg")
		assertObj.True(predicate, "msg with arg %d", 42)
		assertObj.True(predicate, "msg with args %d %s", 42, "42")
		assertObj.Truef(predicate, "msg")
		assertObj.Truef(predicate, "msg with arg %d", 42)
		assertObj.Truef(predicate, "msg with args %d %s", 42, "42")

		require.New(t).Equal(true, predicate)                                   // want "bool-compare: use require\\.New\\(t\\)\\.True"
		require.New(t).Equal(true, predicate, "msg")                            // want "bool-compare: use require\\.New\\(t\\)\\.True"
		require.New(t).Equal(true, predicate, "msg with arg %d", 42)            // want "bool-compare: use require\\.New\\(t\\)\\.True"
		require.New(t).Equal(true, predicate, "msg with args %d %s", 42, "42")  // want "bool-compare: use require\\.New\\(t\\)\\.True"
		require.New(t).Equalf(true, predicate, "msg")                           // want "bool-compare: use require\\.New\\(t\\)\\.Truef"
		require.New(t).Equalf(true, predicate, "msg with arg %d", 42)           // want "bool-compare: use require\\.New\\(t\\)\\.Truef"
		require.New(t).Equalf(true, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use require\\.New\\(t\\)\\.Truef"

		require.New(t).True(predicate)
		require.New(t).True(predicate, "msg")
		require.New(t).True(predicate, "msg with arg %d", 42)
		require.New(t).True(predicate, "msg with args %d %s", 42, "42")
		require.New(t).Truef(predicate, "msg")
		require.New(t).Truef(predicate, "msg with arg %d", 42)
		require.New(t).Truef(predicate, "msg with args %d %s", 42, "42")

		requireObj.Equal(true, predicate)                                   // want "bool-compare: use requireObj\\.True"
		requireObj.Equal(true, predicate, "msg")                            // want "bool-compare: use requireObj\\.True"
		requireObj.Equal(true, predicate, "msg with arg %d", 42)            // want "bool-compare: use requireObj\\.True"
		requireObj.Equal(true, predicate, "msg with args %d %s", 42, "42")  // want "bool-compare: use requireObj\\.True"
		requireObj.Equalf(true, predicate, "msg")                           // want "bool-compare: use requireObj\\.Truef"
		requireObj.Equalf(true, predicate, "msg with arg %d", 42)           // want "bool-compare: use requireObj\\.Truef"
		requireObj.Equalf(true, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use requireObj\\.Truef"

		requireObj.True(predicate)
		requireObj.True(predicate, "msg")
		requireObj.True(predicate, "msg with arg %d", 42)
		requireObj.True(predicate, "msg with args %d %s", 42, "42")
		requireObj.Truef(predicate, "msg")
		requireObj.Truef(predicate, "msg with arg %d", 42)
		requireObj.Truef(predicate, "msg with args %d %s", 42, "42")

		for range []struct{}{} {
			t.Run("nested test", func(t *testing.T) {
				assert.Equal(t, true, predicate)                                   // want "bool-compare: use assert\\.True"
				assert.Equal(t, true, predicate, "msg")                            // want "bool-compare: use assert\\.True"
				assert.Equal(t, true, predicate, "msg with arg %d", 42)            // want "bool-compare: use assert\\.True"
				assert.Equal(t, true, predicate, "msg with args %d %s", 42, "42")  // want "bool-compare: use assert\\.True"
				assert.Equalf(t, true, predicate, "msg")                           // want "bool-compare: use assert\\.Truef"
				assert.Equalf(t, true, predicate, "msg with arg %d", 42)           // want "bool-compare: use assert\\.Truef"
				assert.Equalf(t, true, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use assert\\.Truef"

				assert.True(t, predicate)
				assert.True(t, predicate, "msg")
				assert.True(t, predicate, "msg with arg %d", 42)
				assert.True(t, predicate, "msg with args %d %s", 42, "42")
				assert.Truef(t, predicate, "msg")
				assert.Truef(t, predicate, "msg with arg %d", 42)
				assert.Truef(t, predicate, "msg with args %d %s", 42, "42")

				require.Equal(t, true, predicate)                                   // want "bool-compare: use require\\.True"
				require.Equal(t, true, predicate, "msg")                            // want "bool-compare: use require\\.True"
				require.Equal(t, true, predicate, "msg with arg %d", 42)            // want "bool-compare: use require\\.True"
				require.Equal(t, true, predicate, "msg with args %d %s", 42, "42")  // want "bool-compare: use require\\.True"
				require.Equalf(t, true, predicate, "msg")                           // want "bool-compare: use require\\.Truef"
				require.Equalf(t, true, predicate, "msg with arg %d", 42)           // want "bool-compare: use require\\.Truef"
				require.Equalf(t, true, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use require\\.Truef"

				require.True(t, predicate)
				require.True(t, predicate, "msg")
				require.True(t, predicate, "msg with arg %d", 42)
				require.True(t, predicate, "msg with args %d %s", 42, "42")
				require.Truef(t, predicate, "msg")
				require.Truef(t, predicate, "msg with arg %d", 42)
				require.Truef(t, predicate, "msg with args %d %s", 42, "42")

				assertObj, requireObj := assert.New(t), require.New(t)

				assert.New(t).Equal(true, predicate)                                   // want "bool-compare: use assert\\.New\\(t\\)\\.True"
				assert.New(t).Equal(true, predicate, "msg")                            // want "bool-compare: use assert\\.New\\(t\\)\\.True"
				assert.New(t).Equal(true, predicate, "msg with arg %d", 42)            // want "bool-compare: use assert\\.New\\(t\\)\\.True"
				assert.New(t).Equal(true, predicate, "msg with args %d %s", 42, "42")  // want "bool-compare: use assert\\.New\\(t\\)\\.True"
				assert.New(t).Equalf(true, predicate, "msg")                           // want "bool-compare: use assert\\.New\\(t\\)\\.Truef"
				assert.New(t).Equalf(true, predicate, "msg with arg %d", 42)           // want "bool-compare: use assert\\.New\\(t\\)\\.Truef"
				assert.New(t).Equalf(true, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use assert\\.New\\(t\\)\\.Truef"

				assert.New(t).True(predicate)
				assert.New(t).True(predicate, "msg")
				assert.New(t).True(predicate, "msg with arg %d", 42)
				assert.New(t).True(predicate, "msg with args %d %s", 42, "42")
				assert.New(t).Truef(predicate, "msg")
				assert.New(t).Truef(predicate, "msg with arg %d", 42)
				assert.New(t).Truef(predicate, "msg with args %d %s", 42, "42")

				assertObj.Equal(true, predicate)                                   // want "bool-compare: use assertObj\\.True"
				assertObj.Equal(true, predicate, "msg")                            // want "bool-compare: use assertObj\\.True"
				assertObj.Equal(true, predicate, "msg with arg %d", 42)            // want "bool-compare: use assertObj\\.True"
				assertObj.Equal(true, predicate, "msg with args %d %s", 42, "42")  // want "bool-compare: use assertObj\\.True"
				assertObj.Equalf(true, predicate, "msg")                           // want "bool-compare: use assertObj\\.Truef"
				assertObj.Equalf(true, predicate, "msg with arg %d", 42)           // want "bool-compare: use assertObj\\.Truef"
				assertObj.Equalf(true, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use assertObj\\.Truef"

				assertObj.True(predicate)
				assertObj.True(predicate, "msg")
				assertObj.True(predicate, "msg with arg %d", 42)
				assertObj.True(predicate, "msg with args %d %s", 42, "42")
				assertObj.Truef(predicate, "msg")
				assertObj.Truef(predicate, "msg with arg %d", 42)
				assertObj.Truef(predicate, "msg with args %d %s", 42, "42")

				require.New(t).Equal(true, predicate)                                   // want "bool-compare: use require\\.New\\(t\\)\\.True"
				require.New(t).Equal(true, predicate, "msg")                            // want "bool-compare: use require\\.New\\(t\\)\\.True"
				require.New(t).Equal(true, predicate, "msg with arg %d", 42)            // want "bool-compare: use require\\.New\\(t\\)\\.True"
				require.New(t).Equal(true, predicate, "msg with args %d %s", 42, "42")  // want "bool-compare: use require\\.New\\(t\\)\\.True"
				require.New(t).Equalf(true, predicate, "msg")                           // want "bool-compare: use require\\.New\\(t\\)\\.Truef"
				require.New(t).Equalf(true, predicate, "msg with arg %d", 42)           // want "bool-compare: use require\\.New\\(t\\)\\.Truef"
				require.New(t).Equalf(true, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use require\\.New\\(t\\)\\.Truef"

				require.New(t).True(predicate)
				require.New(t).True(predicate, "msg")
				require.New(t).True(predicate, "msg with arg %d", 42)
				require.New(t).True(predicate, "msg with args %d %s", 42, "42")
				require.New(t).Truef(predicate, "msg")
				require.New(t).Truef(predicate, "msg with arg %d", 42)
				require.New(t).Truef(predicate, "msg with args %d %s", 42, "42")

				requireObj.Equal(true, predicate)                                   // want "bool-compare: use requireObj\\.True"
				requireObj.Equal(true, predicate, "msg")                            // want "bool-compare: use requireObj\\.True"
				requireObj.Equal(true, predicate, "msg with arg %d", 42)            // want "bool-compare: use requireObj\\.True"
				requireObj.Equal(true, predicate, "msg with args %d %s", 42, "42")  // want "bool-compare: use requireObj\\.True"
				requireObj.Equalf(true, predicate, "msg")                           // want "bool-compare: use requireObj\\.Truef"
				requireObj.Equalf(true, predicate, "msg with arg %d", 42)           // want "bool-compare: use requireObj\\.Truef"
				requireObj.Equalf(true, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use requireObj\\.Truef"

				requireObj.True(predicate)
				requireObj.True(predicate, "msg")
				requireObj.True(predicate, "msg with arg %d", 42)
				requireObj.True(predicate, "msg with args %d %s", 42, "42")
				requireObj.Truef(predicate, "msg")
				requireObj.Truef(predicate, "msg with arg %d", 42)
				requireObj.Truef(predicate, "msg with args %d %s", 42, "42")
			})
		}
	})

	t.Run("subtest2", func(t *testing.T) {
		assert.Equal(t, true, predicate)                                   // want "bool-compare: use assert\\.True"
		assert.Equal(t, true, predicate, "msg")                            // want "bool-compare: use assert\\.True"
		assert.Equal(t, true, predicate, "msg with arg %d", 42)            // want "bool-compare: use assert\\.True"
		assert.Equal(t, true, predicate, "msg with args %d %s", 42, "42")  // want "bool-compare: use assert\\.True"
		assert.Equalf(t, true, predicate, "msg")                           // want "bool-compare: use assert\\.Truef"
		assert.Equalf(t, true, predicate, "msg with arg %d", 42)           // want "bool-compare: use assert\\.Truef"
		assert.Equalf(t, true, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use assert\\.Truef"

		assert.True(t, predicate)
		assert.True(t, predicate, "msg")
		assert.True(t, predicate, "msg with arg %d", 42)
		assert.True(t, predicate, "msg with args %d %s", 42, "42")
		assert.Truef(t, predicate, "msg")
		assert.Truef(t, predicate, "msg with arg %d", 42)
		assert.Truef(t, predicate, "msg with args %d %s", 42, "42")

		require.Equal(t, true, predicate)                                   // want "bool-compare: use require\\.True"
		require.Equal(t, true, predicate, "msg")                            // want "bool-compare: use require\\.True"
		require.Equal(t, true, predicate, "msg with arg %d", 42)            // want "bool-compare: use require\\.True"
		require.Equal(t, true, predicate, "msg with args %d %s", 42, "42")  // want "bool-compare: use require\\.True"
		require.Equalf(t, true, predicate, "msg")                           // want "bool-compare: use require\\.Truef"
		require.Equalf(t, true, predicate, "msg with arg %d", 42)           // want "bool-compare: use require\\.Truef"
		require.Equalf(t, true, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use require\\.Truef"

		require.True(t, predicate)
		require.True(t, predicate, "msg")
		require.True(t, predicate, "msg with arg %d", 42)
		require.True(t, predicate, "msg with args %d %s", 42, "42")
		require.Truef(t, predicate, "msg")
		require.Truef(t, predicate, "msg with arg %d", 42)
		require.Truef(t, predicate, "msg with args %d %s", 42, "42")

		assertObj, requireObj := assert.New(t), require.New(t)

		assert.New(t).Equal(true, predicate)                                   // want "bool-compare: use assert\\.New\\(t\\)\\.True"
		assert.New(t).Equal(true, predicate, "msg")                            // want "bool-compare: use assert\\.New\\(t\\)\\.True"
		assert.New(t).Equal(true, predicate, "msg with arg %d", 42)            // want "bool-compare: use assert\\.New\\(t\\)\\.True"
		assert.New(t).Equal(true, predicate, "msg with args %d %s", 42, "42")  // want "bool-compare: use assert\\.New\\(t\\)\\.True"
		assert.New(t).Equalf(true, predicate, "msg")                           // want "bool-compare: use assert\\.New\\(t\\)\\.Truef"
		assert.New(t).Equalf(true, predicate, "msg with arg %d", 42)           // want "bool-compare: use assert\\.New\\(t\\)\\.Truef"
		assert.New(t).Equalf(true, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use assert\\.New\\(t\\)\\.Truef"

		assert.New(t).True(predicate)
		assert.New(t).True(predicate, "msg")
		assert.New(t).True(predicate, "msg with arg %d", 42)
		assert.New(t).True(predicate, "msg with args %d %s", 42, "42")
		assert.New(t).Truef(predicate, "msg")
		assert.New(t).Truef(predicate, "msg with arg %d", 42)
		assert.New(t).Truef(predicate, "msg with args %d %s", 42, "42")

		assertObj.Equal(true, predicate)                                   // want "bool-compare: use assertObj\\.True"
		assertObj.Equal(true, predicate, "msg")                            // want "bool-compare: use assertObj\\.True"
		assertObj.Equal(true, predicate, "msg with arg %d", 42)            // want "bool-compare: use assertObj\\.True"
		assertObj.Equal(true, predicate, "msg with args %d %s", 42, "42")  // want "bool-compare: use assertObj\\.True"
		assertObj.Equalf(true, predicate, "msg")                           // want "bool-compare: use assertObj\\.Truef"
		assertObj.Equalf(true, predicate, "msg with arg %d", 42)           // want "bool-compare: use assertObj\\.Truef"
		assertObj.Equalf(true, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use assertObj\\.Truef"

		assertObj.True(predicate)
		assertObj.True(predicate, "msg")
		assertObj.True(predicate, "msg with arg %d", 42)
		assertObj.True(predicate, "msg with args %d %s", 42, "42")
		assertObj.Truef(predicate, "msg")
		assertObj.Truef(predicate, "msg with arg %d", 42)
		assertObj.Truef(predicate, "msg with args %d %s", 42, "42")

		require.New(t).Equal(true, predicate)                                   // want "bool-compare: use require\\.New\\(t\\)\\.True"
		require.New(t).Equal(true, predicate, "msg")                            // want "bool-compare: use require\\.New\\(t\\)\\.True"
		require.New(t).Equal(true, predicate, "msg with arg %d", 42)            // want "bool-compare: use require\\.New\\(t\\)\\.True"
		require.New(t).Equal(true, predicate, "msg with args %d %s", 42, "42")  // want "bool-compare: use require\\.New\\(t\\)\\.True"
		require.New(t).Equalf(true, predicate, "msg")                           // want "bool-compare: use require\\.New\\(t\\)\\.Truef"
		require.New(t).Equalf(true, predicate, "msg with arg %d", 42)           // want "bool-compare: use require\\.New\\(t\\)\\.Truef"
		require.New(t).Equalf(true, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use require\\.New\\(t\\)\\.Truef"

		require.New(t).True(predicate)
		require.New(t).True(predicate, "msg")
		require.New(t).True(predicate, "msg with arg %d", 42)
		require.New(t).True(predicate, "msg with args %d %s", 42, "42")
		require.New(t).Truef(predicate, "msg")
		require.New(t).Truef(predicate, "msg with arg %d", 42)
		require.New(t).Truef(predicate, "msg with args %d %s", 42, "42")

		requireObj.Equal(true, predicate)                                   // want "bool-compare: use requireObj\\.True"
		requireObj.Equal(true, predicate, "msg")                            // want "bool-compare: use requireObj\\.True"
		requireObj.Equal(true, predicate, "msg with arg %d", 42)            // want "bool-compare: use requireObj\\.True"
		requireObj.Equal(true, predicate, "msg with args %d %s", 42, "42")  // want "bool-compare: use requireObj\\.True"
		requireObj.Equalf(true, predicate, "msg")                           // want "bool-compare: use requireObj\\.Truef"
		requireObj.Equalf(true, predicate, "msg with arg %d", 42)           // want "bool-compare: use requireObj\\.Truef"
		requireObj.Equalf(true, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use requireObj\\.Truef"

		requireObj.True(predicate)
		requireObj.True(predicate, "msg")
		requireObj.True(predicate, "msg with arg %d", 42)
		requireObj.True(predicate, "msg with args %d %s", 42, "42")
		requireObj.Truef(predicate, "msg")
		requireObj.Truef(predicate, "msg with arg %d", 42)
		requireObj.Truef(predicate, "msg with args %d %s", 42, "42")
	})
}

type BaseTestsSuite struct {
	suite.Suite
}

func TestBaseTestsSuite(t *testing.T) {
	suite.Run(t, new(BaseTestsSuite))
}

func (s *BaseTestsSuite) TestAll() {
	var predicate bool

	assert.Equal(s.T(), true, predicate)                                   // want "bool-compare: use assert\\.True"
	assert.Equal(s.T(), true, predicate, "msg")                            // want "bool-compare: use assert\\.True"
	assert.Equal(s.T(), true, predicate, "msg with arg %d", 42)            // want "bool-compare: use assert\\.True"
	assert.Equal(s.T(), true, predicate, "msg with args %d %s", 42, "42")  // want "bool-compare: use assert\\.True"
	assert.Equalf(s.T(), true, predicate, "msg")                           // want "bool-compare: use assert\\.Truef"
	assert.Equalf(s.T(), true, predicate, "msg with arg %d", 42)           // want "bool-compare: use assert\\.Truef"
	assert.Equalf(s.T(), true, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use assert\\.Truef"

	assert.True(s.T(), predicate)
	assert.True(s.T(), predicate, "msg")
	assert.True(s.T(), predicate, "msg with arg %d", 42)
	assert.True(s.T(), predicate, "msg with args %d %s", 42, "42")
	assert.Truef(s.T(), predicate, "msg")
	assert.Truef(s.T(), predicate, "msg with arg %d", 42)
	assert.Truef(s.T(), predicate, "msg with args %d %s", 42, "42")

	require.Equal(s.T(), true, predicate)                                   // want "bool-compare: use require\\.True"
	require.Equal(s.T(), true, predicate, "msg")                            // want "bool-compare: use require\\.True"
	require.Equal(s.T(), true, predicate, "msg with arg %d", 42)            // want "bool-compare: use require\\.True"
	require.Equal(s.T(), true, predicate, "msg with args %d %s", 42, "42")  // want "bool-compare: use require\\.True"
	require.Equalf(s.T(), true, predicate, "msg")                           // want "bool-compare: use require\\.Truef"
	require.Equalf(s.T(), true, predicate, "msg with arg %d", 42)           // want "bool-compare: use require\\.Truef"
	require.Equalf(s.T(), true, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use require\\.Truef"

	require.True(s.T(), predicate)
	require.True(s.T(), predicate, "msg")
	require.True(s.T(), predicate, "msg with arg %d", 42)
	require.True(s.T(), predicate, "msg with args %d %s", 42, "42")
	require.Truef(s.T(), predicate, "msg")
	require.Truef(s.T(), predicate, "msg with arg %d", 42)
	require.Truef(s.T(), predicate, "msg with args %d %s", 42, "42")

	assertObj, requireObj := assert.New(s.T()), require.New(s.T())
	suiteAssertObj, suiteRequireObj := s.Assert(), s.Require()
	s.Equal(true, predicate)                                   // want "bool-compare: use s\\.True"
	s.Equal(true, predicate, "msg")                            // want "bool-compare: use s\\.True"
	s.Equal(true, predicate, "msg with arg %d", 42)            // want "bool-compare: use s\\.True"
	s.Equal(true, predicate, "msg with args %d %s", 42, "42")  // want "bool-compare: use s\\.True"
	s.Equalf(true, predicate, "msg")                           // want "bool-compare: use s\\.Truef"
	s.Equalf(true, predicate, "msg with arg %d", 42)           // want "bool-compare: use s\\.Truef"
	s.Equalf(true, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use s\\.Truef"

	s.True(predicate)
	s.True(predicate, "msg")
	s.True(predicate, "msg with arg %d", 42)
	s.True(predicate, "msg with args %d %s", 42, "42")
	s.Truef(predicate, "msg")
	s.Truef(predicate, "msg with arg %d", 42)
	s.Truef(predicate, "msg with args %d %s", 42, "42")

	s.Assert().Equal(true, predicate)                                   // want "bool-compare: use s\\.Assert\\(\\)\\.True"
	s.Assert().Equal(true, predicate, "msg")                            // want "bool-compare: use s\\.Assert\\(\\)\\.True"
	s.Assert().Equal(true, predicate, "msg with arg %d", 42)            // want "bool-compare: use s\\.Assert\\(\\)\\.True"
	s.Assert().Equal(true, predicate, "msg with args %d %s", 42, "42")  // want "bool-compare: use s\\.Assert\\(\\)\\.True"
	s.Assert().Equalf(true, predicate, "msg")                           // want "bool-compare: use s\\.Assert\\(\\)\\.Truef"
	s.Assert().Equalf(true, predicate, "msg with arg %d", 42)           // want "bool-compare: use s\\.Assert\\(\\)\\.Truef"
	s.Assert().Equalf(true, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use s\\.Assert\\(\\)\\.Truef"

	s.Assert().True(predicate)
	s.Assert().True(predicate, "msg")
	s.Assert().True(predicate, "msg with arg %d", 42)
	s.Assert().True(predicate, "msg with args %d %s", 42, "42")
	s.Assert().Truef(predicate, "msg")
	s.Assert().Truef(predicate, "msg with arg %d", 42)
	s.Assert().Truef(predicate, "msg with args %d %s", 42, "42")

	assertObj.Equal(true, predicate)                                   // want "bool-compare: use assertObj\\.True"
	assertObj.Equal(true, predicate, "msg")                            // want "bool-compare: use assertObj\\.True"
	assertObj.Equal(true, predicate, "msg with arg %d", 42)            // want "bool-compare: use assertObj\\.True"
	assertObj.Equal(true, predicate, "msg with args %d %s", 42, "42")  // want "bool-compare: use assertObj\\.True"
	assertObj.Equalf(true, predicate, "msg")                           // want "bool-compare: use assertObj\\.Truef"
	assertObj.Equalf(true, predicate, "msg with arg %d", 42)           // want "bool-compare: use assertObj\\.Truef"
	assertObj.Equalf(true, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use assertObj\\.Truef"

	assertObj.True(predicate)
	assertObj.True(predicate, "msg")
	assertObj.True(predicate, "msg with arg %d", 42)
	assertObj.True(predicate, "msg with args %d %s", 42, "42")
	assertObj.Truef(predicate, "msg")
	assertObj.Truef(predicate, "msg with arg %d", 42)
	assertObj.Truef(predicate, "msg with args %d %s", 42, "42")

	suiteAssertObj.Equal(true, predicate)                                   // want "bool-compare: use suiteAssertObj\\.True"
	suiteAssertObj.Equal(true, predicate, "msg")                            // want "bool-compare: use suiteAssertObj\\.True"
	suiteAssertObj.Equal(true, predicate, "msg with arg %d", 42)            // want "bool-compare: use suiteAssertObj\\.True"
	suiteAssertObj.Equal(true, predicate, "msg with args %d %s", 42, "42")  // want "bool-compare: use suiteAssertObj\\.True"
	suiteAssertObj.Equalf(true, predicate, "msg")                           // want "bool-compare: use suiteAssertObj\\.Truef"
	suiteAssertObj.Equalf(true, predicate, "msg with arg %d", 42)           // want "bool-compare: use suiteAssertObj\\.Truef"
	suiteAssertObj.Equalf(true, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use suiteAssertObj\\.Truef"

	suiteAssertObj.True(predicate)
	suiteAssertObj.True(predicate, "msg")
	suiteAssertObj.True(predicate, "msg with arg %d", 42)
	suiteAssertObj.True(predicate, "msg with args %d %s", 42, "42")
	suiteAssertObj.Truef(predicate, "msg")
	suiteAssertObj.Truef(predicate, "msg with arg %d", 42)
	suiteAssertObj.Truef(predicate, "msg with args %d %s", 42, "42")

	s.Require().Equal(true, predicate)                                   // want "bool-compare: use s\\.Require\\(\\)\\.True"
	s.Require().Equal(true, predicate, "msg")                            // want "bool-compare: use s\\.Require\\(\\)\\.True"
	s.Require().Equal(true, predicate, "msg with arg %d", 42)            // want "bool-compare: use s\\.Require\\(\\)\\.True"
	s.Require().Equal(true, predicate, "msg with args %d %s", 42, "42")  // want "bool-compare: use s\\.Require\\(\\)\\.True"
	s.Require().Equalf(true, predicate, "msg")                           // want "bool-compare: use s\\.Require\\(\\)\\.Truef"
	s.Require().Equalf(true, predicate, "msg with arg %d", 42)           // want "bool-compare: use s\\.Require\\(\\)\\.Truef"
	s.Require().Equalf(true, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use s\\.Require\\(\\)\\.Truef"

	s.Require().True(predicate)
	s.Require().True(predicate, "msg")
	s.Require().True(predicate, "msg with arg %d", 42)
	s.Require().True(predicate, "msg with args %d %s", 42, "42")
	s.Require().Truef(predicate, "msg")
	s.Require().Truef(predicate, "msg with arg %d", 42)
	s.Require().Truef(predicate, "msg with args %d %s", 42, "42")

	requireObj.Equal(true, predicate)                                   // want "bool-compare: use requireObj\\.True"
	requireObj.Equal(true, predicate, "msg")                            // want "bool-compare: use requireObj\\.True"
	requireObj.Equal(true, predicate, "msg with arg %d", 42)            // want "bool-compare: use requireObj\\.True"
	requireObj.Equal(true, predicate, "msg with args %d %s", 42, "42")  // want "bool-compare: use requireObj\\.True"
	requireObj.Equalf(true, predicate, "msg")                           // want "bool-compare: use requireObj\\.Truef"
	requireObj.Equalf(true, predicate, "msg with arg %d", 42)           // want "bool-compare: use requireObj\\.Truef"
	requireObj.Equalf(true, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use requireObj\\.Truef"

	requireObj.True(predicate)
	requireObj.True(predicate, "msg")
	requireObj.True(predicate, "msg with arg %d", 42)
	requireObj.True(predicate, "msg with args %d %s", 42, "42")
	requireObj.Truef(predicate, "msg")
	requireObj.Truef(predicate, "msg with arg %d", 42)
	requireObj.Truef(predicate, "msg with args %d %s", 42, "42")

	suiteRequireObj.Equal(true, predicate)                                   // want "bool-compare: use suiteRequireObj\\.True"
	suiteRequireObj.Equal(true, predicate, "msg")                            // want "bool-compare: use suiteRequireObj\\.True"
	suiteRequireObj.Equal(true, predicate, "msg with arg %d", 42)            // want "bool-compare: use suiteRequireObj\\.True"
	suiteRequireObj.Equal(true, predicate, "msg with args %d %s", 42, "42")  // want "bool-compare: use suiteRequireObj\\.True"
	suiteRequireObj.Equalf(true, predicate, "msg")                           // want "bool-compare: use suiteRequireObj\\.Truef"
	suiteRequireObj.Equalf(true, predicate, "msg with arg %d", 42)           // want "bool-compare: use suiteRequireObj\\.Truef"
	suiteRequireObj.Equalf(true, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use suiteRequireObj\\.Truef"

	suiteRequireObj.True(predicate)
	suiteRequireObj.True(predicate, "msg")
	suiteRequireObj.True(predicate, "msg with arg %d", 42)
	suiteRequireObj.True(predicate, "msg with args %d %s", 42, "42")
	suiteRequireObj.Truef(predicate, "msg")
	suiteRequireObj.Truef(predicate, "msg with arg %d", 42)
	suiteRequireObj.Truef(predicate, "msg with args %d %s", 42, "42")

	assert.New(s.T()).Equal(true, predicate)                                   // want "bool-compare: use assert\\.New\\(s\\.T\\(\\)\\)\\.True"
	assert.New(s.T()).Equal(true, predicate, "msg")                            // want "bool-compare: use assert\\.New\\(s\\.T\\(\\)\\)\\.True"
	assert.New(s.T()).Equal(true, predicate, "msg with arg %d", 42)            // want "bool-compare: use assert\\.New\\(s\\.T\\(\\)\\)\\.True"
	assert.New(s.T()).Equal(true, predicate, "msg with args %d %s", 42, "42")  // want "bool-compare: use assert\\.New\\(s\\.T\\(\\)\\)\\.True"
	assert.New(s.T()).Equalf(true, predicate, "msg")                           // want "bool-compare: use assert\\.New\\(s\\.T\\(\\)\\)\\.Truef"
	assert.New(s.T()).Equalf(true, predicate, "msg with arg %d", 42)           // want "bool-compare: use assert\\.New\\(s\\.T\\(\\)\\)\\.Truef"
	assert.New(s.T()).Equalf(true, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use assert\\.New\\(s\\.T\\(\\)\\)\\.Truef"

	assert.New(s.T()).True(predicate)
	assert.New(s.T()).True(predicate, "msg")
	assert.New(s.T()).True(predicate, "msg with arg %d", 42)
	assert.New(s.T()).True(predicate, "msg with args %d %s", 42, "42")
	assert.New(s.T()).Truef(predicate, "msg")
	assert.New(s.T()).Truef(predicate, "msg with arg %d", 42)
	assert.New(s.T()).Truef(predicate, "msg with args %d %s", 42, "42")

	require.New(s.T()).Equal(true, predicate)                                   // want "bool-compare: use require\\.New\\(s\\.T\\(\\)\\)\\.True"
	require.New(s.T()).Equal(true, predicate, "msg")                            // want "bool-compare: use require\\.New\\(s\\.T\\(\\)\\)\\.True"
	require.New(s.T()).Equal(true, predicate, "msg with arg %d", 42)            // want "bool-compare: use require\\.New\\(s\\.T\\(\\)\\)\\.True"
	require.New(s.T()).Equal(true, predicate, "msg with args %d %s", 42, "42")  // want "bool-compare: use require\\.New\\(s\\.T\\(\\)\\)\\.True"
	require.New(s.T()).Equalf(true, predicate, "msg")                           // want "bool-compare: use require\\.New\\(s\\.T\\(\\)\\)\\.Truef"
	require.New(s.T()).Equalf(true, predicate, "msg with arg %d", 42)           // want "bool-compare: use require\\.New\\(s\\.T\\(\\)\\)\\.Truef"
	require.New(s.T()).Equalf(true, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use require\\.New\\(s\\.T\\(\\)\\)\\.Truef"

	require.New(s.T()).True(predicate)
	require.New(s.T()).True(predicate, "msg")
	require.New(s.T()).True(predicate, "msg with arg %d", 42)
	require.New(s.T()).True(predicate, "msg with args %d %s", 42, "42")
	require.New(s.T()).Truef(predicate, "msg")
	require.New(s.T()).Truef(predicate, "msg with arg %d", 42)
	require.New(s.T()).Truef(predicate, "msg with args %d %s", 42, "42")

	s.Run("subtest1", func() {
		assert.Equal(s.T(), true, predicate)                                   // want "bool-compare: use assert\\.True"
		assert.Equal(s.T(), true, predicate, "msg")                            // want "bool-compare: use assert\\.True"
		assert.Equal(s.T(), true, predicate, "msg with arg %d", 42)            // want "bool-compare: use assert\\.True"
		assert.Equal(s.T(), true, predicate, "msg with args %d %s", 42, "42")  // want "bool-compare: use assert\\.True"
		assert.Equalf(s.T(), true, predicate, "msg")                           // want "bool-compare: use assert\\.Truef"
		assert.Equalf(s.T(), true, predicate, "msg with arg %d", 42)           // want "bool-compare: use assert\\.Truef"
		assert.Equalf(s.T(), true, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use assert\\.Truef"

		assert.True(s.T(), predicate)
		assert.True(s.T(), predicate, "msg")
		assert.True(s.T(), predicate, "msg with arg %d", 42)
		assert.True(s.T(), predicate, "msg with args %d %s", 42, "42")
		assert.Truef(s.T(), predicate, "msg")
		assert.Truef(s.T(), predicate, "msg with arg %d", 42)
		assert.Truef(s.T(), predicate, "msg with args %d %s", 42, "42")

		require.Equal(s.T(), true, predicate)                                   // want "bool-compare: use require\\.True"
		require.Equal(s.T(), true, predicate, "msg")                            // want "bool-compare: use require\\.True"
		require.Equal(s.T(), true, predicate, "msg with arg %d", 42)            // want "bool-compare: use require\\.True"
		require.Equal(s.T(), true, predicate, "msg with args %d %s", 42, "42")  // want "bool-compare: use require\\.True"
		require.Equalf(s.T(), true, predicate, "msg")                           // want "bool-compare: use require\\.Truef"
		require.Equalf(s.T(), true, predicate, "msg with arg %d", 42)           // want "bool-compare: use require\\.Truef"
		require.Equalf(s.T(), true, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use require\\.Truef"

		require.True(s.T(), predicate)
		require.True(s.T(), predicate, "msg")
		require.True(s.T(), predicate, "msg with arg %d", 42)
		require.True(s.T(), predicate, "msg with args %d %s", 42, "42")
		require.Truef(s.T(), predicate, "msg")
		require.Truef(s.T(), predicate, "msg with arg %d", 42)
		require.Truef(s.T(), predicate, "msg with args %d %s", 42, "42")

		assertObj, requireObj := assert.New(s.T()), require.New(s.T())
		suiteAssertObj, suiteRequireObj := s.Assert(), s.Require()
		s.Equal(true, predicate)                                   // want "bool-compare: use s\\.True"
		s.Equal(true, predicate, "msg")                            // want "bool-compare: use s\\.True"
		s.Equal(true, predicate, "msg with arg %d", 42)            // want "bool-compare: use s\\.True"
		s.Equal(true, predicate, "msg with args %d %s", 42, "42")  // want "bool-compare: use s\\.True"
		s.Equalf(true, predicate, "msg")                           // want "bool-compare: use s\\.Truef"
		s.Equalf(true, predicate, "msg with arg %d", 42)           // want "bool-compare: use s\\.Truef"
		s.Equalf(true, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use s\\.Truef"

		s.True(predicate)
		s.True(predicate, "msg")
		s.True(predicate, "msg with arg %d", 42)
		s.True(predicate, "msg with args %d %s", 42, "42")
		s.Truef(predicate, "msg")
		s.Truef(predicate, "msg with arg %d", 42)
		s.Truef(predicate, "msg with args %d %s", 42, "42")

		s.Assert().Equal(true, predicate)                                   // want "bool-compare: use s\\.Assert\\(\\)\\.True"
		s.Assert().Equal(true, predicate, "msg")                            // want "bool-compare: use s\\.Assert\\(\\)\\.True"
		s.Assert().Equal(true, predicate, "msg with arg %d", 42)            // want "bool-compare: use s\\.Assert\\(\\)\\.True"
		s.Assert().Equal(true, predicate, "msg with args %d %s", 42, "42")  // want "bool-compare: use s\\.Assert\\(\\)\\.True"
		s.Assert().Equalf(true, predicate, "msg")                           // want "bool-compare: use s\\.Assert\\(\\)\\.Truef"
		s.Assert().Equalf(true, predicate, "msg with arg %d", 42)           // want "bool-compare: use s\\.Assert\\(\\)\\.Truef"
		s.Assert().Equalf(true, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use s\\.Assert\\(\\)\\.Truef"

		s.Assert().True(predicate)
		s.Assert().True(predicate, "msg")
		s.Assert().True(predicate, "msg with arg %d", 42)
		s.Assert().True(predicate, "msg with args %d %s", 42, "42")
		s.Assert().Truef(predicate, "msg")
		s.Assert().Truef(predicate, "msg with arg %d", 42)
		s.Assert().Truef(predicate, "msg with args %d %s", 42, "42")

		assertObj.Equal(true, predicate)                                   // want "bool-compare: use assertObj\\.True"
		assertObj.Equal(true, predicate, "msg")                            // want "bool-compare: use assertObj\\.True"
		assertObj.Equal(true, predicate, "msg with arg %d", 42)            // want "bool-compare: use assertObj\\.True"
		assertObj.Equal(true, predicate, "msg with args %d %s", 42, "42")  // want "bool-compare: use assertObj\\.True"
		assertObj.Equalf(true, predicate, "msg")                           // want "bool-compare: use assertObj\\.Truef"
		assertObj.Equalf(true, predicate, "msg with arg %d", 42)           // want "bool-compare: use assertObj\\.Truef"
		assertObj.Equalf(true, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use assertObj\\.Truef"

		assertObj.True(predicate)
		assertObj.True(predicate, "msg")
		assertObj.True(predicate, "msg with arg %d", 42)
		assertObj.True(predicate, "msg with args %d %s", 42, "42")
		assertObj.Truef(predicate, "msg")
		assertObj.Truef(predicate, "msg with arg %d", 42)
		assertObj.Truef(predicate, "msg with args %d %s", 42, "42")

		suiteAssertObj.Equal(true, predicate)                                   // want "bool-compare: use suiteAssertObj\\.True"
		suiteAssertObj.Equal(true, predicate, "msg")                            // want "bool-compare: use suiteAssertObj\\.True"
		suiteAssertObj.Equal(true, predicate, "msg with arg %d", 42)            // want "bool-compare: use suiteAssertObj\\.True"
		suiteAssertObj.Equal(true, predicate, "msg with args %d %s", 42, "42")  // want "bool-compare: use suiteAssertObj\\.True"
		suiteAssertObj.Equalf(true, predicate, "msg")                           // want "bool-compare: use suiteAssertObj\\.Truef"
		suiteAssertObj.Equalf(true, predicate, "msg with arg %d", 42)           // want "bool-compare: use suiteAssertObj\\.Truef"
		suiteAssertObj.Equalf(true, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use suiteAssertObj\\.Truef"

		suiteAssertObj.True(predicate)
		suiteAssertObj.True(predicate, "msg")
		suiteAssertObj.True(predicate, "msg with arg %d", 42)
		suiteAssertObj.True(predicate, "msg with args %d %s", 42, "42")
		suiteAssertObj.Truef(predicate, "msg")
		suiteAssertObj.Truef(predicate, "msg with arg %d", 42)
		suiteAssertObj.Truef(predicate, "msg with args %d %s", 42, "42")

		s.Require().Equal(true, predicate)                                   // want "bool-compare: use s\\.Require\\(\\)\\.True"
		s.Require().Equal(true, predicate, "msg")                            // want "bool-compare: use s\\.Require\\(\\)\\.True"
		s.Require().Equal(true, predicate, "msg with arg %d", 42)            // want "bool-compare: use s\\.Require\\(\\)\\.True"
		s.Require().Equal(true, predicate, "msg with args %d %s", 42, "42")  // want "bool-compare: use s\\.Require\\(\\)\\.True"
		s.Require().Equalf(true, predicate, "msg")                           // want "bool-compare: use s\\.Require\\(\\)\\.Truef"
		s.Require().Equalf(true, predicate, "msg with arg %d", 42)           // want "bool-compare: use s\\.Require\\(\\)\\.Truef"
		s.Require().Equalf(true, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use s\\.Require\\(\\)\\.Truef"

		s.Require().True(predicate)
		s.Require().True(predicate, "msg")
		s.Require().True(predicate, "msg with arg %d", 42)
		s.Require().True(predicate, "msg with args %d %s", 42, "42")
		s.Require().Truef(predicate, "msg")
		s.Require().Truef(predicate, "msg with arg %d", 42)
		s.Require().Truef(predicate, "msg with args %d %s", 42, "42")

		requireObj.Equal(true, predicate)                                   // want "bool-compare: use requireObj\\.True"
		requireObj.Equal(true, predicate, "msg")                            // want "bool-compare: use requireObj\\.True"
		requireObj.Equal(true, predicate, "msg with arg %d", 42)            // want "bool-compare: use requireObj\\.True"
		requireObj.Equal(true, predicate, "msg with args %d %s", 42, "42")  // want "bool-compare: use requireObj\\.True"
		requireObj.Equalf(true, predicate, "msg")                           // want "bool-compare: use requireObj\\.Truef"
		requireObj.Equalf(true, predicate, "msg with arg %d", 42)           // want "bool-compare: use requireObj\\.Truef"
		requireObj.Equalf(true, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use requireObj\\.Truef"

		requireObj.True(predicate)
		requireObj.True(predicate, "msg")
		requireObj.True(predicate, "msg with arg %d", 42)
		requireObj.True(predicate, "msg with args %d %s", 42, "42")
		requireObj.Truef(predicate, "msg")
		requireObj.Truef(predicate, "msg with arg %d", 42)
		requireObj.Truef(predicate, "msg with args %d %s", 42, "42")

		suiteRequireObj.Equal(true, predicate)                                   // want "bool-compare: use suiteRequireObj\\.True"
		suiteRequireObj.Equal(true, predicate, "msg")                            // want "bool-compare: use suiteRequireObj\\.True"
		suiteRequireObj.Equal(true, predicate, "msg with arg %d", 42)            // want "bool-compare: use suiteRequireObj\\.True"
		suiteRequireObj.Equal(true, predicate, "msg with args %d %s", 42, "42")  // want "bool-compare: use suiteRequireObj\\.True"
		suiteRequireObj.Equalf(true, predicate, "msg")                           // want "bool-compare: use suiteRequireObj\\.Truef"
		suiteRequireObj.Equalf(true, predicate, "msg with arg %d", 42)           // want "bool-compare: use suiteRequireObj\\.Truef"
		suiteRequireObj.Equalf(true, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use suiteRequireObj\\.Truef"

		suiteRequireObj.True(predicate)
		suiteRequireObj.True(predicate, "msg")
		suiteRequireObj.True(predicate, "msg with arg %d", 42)
		suiteRequireObj.True(predicate, "msg with args %d %s", 42, "42")
		suiteRequireObj.Truef(predicate, "msg")
		suiteRequireObj.Truef(predicate, "msg with arg %d", 42)
		suiteRequireObj.Truef(predicate, "msg with args %d %s", 42, "42")

		assert.New(s.T()).Equal(true, predicate)                                   // want "bool-compare: use assert\\.New\\(s\\.T\\(\\)\\)\\.True"
		assert.New(s.T()).Equal(true, predicate, "msg")                            // want "bool-compare: use assert\\.New\\(s\\.T\\(\\)\\)\\.True"
		assert.New(s.T()).Equal(true, predicate, "msg with arg %d", 42)            // want "bool-compare: use assert\\.New\\(s\\.T\\(\\)\\)\\.True"
		assert.New(s.T()).Equal(true, predicate, "msg with args %d %s", 42, "42")  // want "bool-compare: use assert\\.New\\(s\\.T\\(\\)\\)\\.True"
		assert.New(s.T()).Equalf(true, predicate, "msg")                           // want "bool-compare: use assert\\.New\\(s\\.T\\(\\)\\)\\.Truef"
		assert.New(s.T()).Equalf(true, predicate, "msg with arg %d", 42)           // want "bool-compare: use assert\\.New\\(s\\.T\\(\\)\\)\\.Truef"
		assert.New(s.T()).Equalf(true, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use assert\\.New\\(s\\.T\\(\\)\\)\\.Truef"

		assert.New(s.T()).True(predicate)
		assert.New(s.T()).True(predicate, "msg")
		assert.New(s.T()).True(predicate, "msg with arg %d", 42)
		assert.New(s.T()).True(predicate, "msg with args %d %s", 42, "42")
		assert.New(s.T()).Truef(predicate, "msg")
		assert.New(s.T()).Truef(predicate, "msg with arg %d", 42)
		assert.New(s.T()).Truef(predicate, "msg with args %d %s", 42, "42")

		require.New(s.T()).Equal(true, predicate)                                   // want "bool-compare: use require\\.New\\(s\\.T\\(\\)\\)\\.True"
		require.New(s.T()).Equal(true, predicate, "msg")                            // want "bool-compare: use require\\.New\\(s\\.T\\(\\)\\)\\.True"
		require.New(s.T()).Equal(true, predicate, "msg with arg %d", 42)            // want "bool-compare: use require\\.New\\(s\\.T\\(\\)\\)\\.True"
		require.New(s.T()).Equal(true, predicate, "msg with args %d %s", 42, "42")  // want "bool-compare: use require\\.New\\(s\\.T\\(\\)\\)\\.True"
		require.New(s.T()).Equalf(true, predicate, "msg")                           // want "bool-compare: use require\\.New\\(s\\.T\\(\\)\\)\\.Truef"
		require.New(s.T()).Equalf(true, predicate, "msg with arg %d", 42)           // want "bool-compare: use require\\.New\\(s\\.T\\(\\)\\)\\.Truef"
		require.New(s.T()).Equalf(true, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use require\\.New\\(s\\.T\\(\\)\\)\\.Truef"

		require.New(s.T()).True(predicate)
		require.New(s.T()).True(predicate, "msg")
		require.New(s.T()).True(predicate, "msg with arg %d", 42)
		require.New(s.T()).True(predicate, "msg with args %d %s", 42, "42")
		require.New(s.T()).Truef(predicate, "msg")
		require.New(s.T()).Truef(predicate, "msg with arg %d", 42)
		require.New(s.T()).Truef(predicate, "msg with args %d %s", 42, "42")

		for range []struct{}{} {
			s.Run("nested test", func() {
				assert.Equal(s.T(), true, predicate)                                   // want "bool-compare: use assert\\.True"
				assert.Equal(s.T(), true, predicate, "msg")                            // want "bool-compare: use assert\\.True"
				assert.Equal(s.T(), true, predicate, "msg with arg %d", 42)            // want "bool-compare: use assert\\.True"
				assert.Equal(s.T(), true, predicate, "msg with args %d %s", 42, "42")  // want "bool-compare: use assert\\.True"
				assert.Equalf(s.T(), true, predicate, "msg")                           // want "bool-compare: use assert\\.Truef"
				assert.Equalf(s.T(), true, predicate, "msg with arg %d", 42)           // want "bool-compare: use assert\\.Truef"
				assert.Equalf(s.T(), true, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use assert\\.Truef"

				assert.True(s.T(), predicate)
				assert.True(s.T(), predicate, "msg")
				assert.True(s.T(), predicate, "msg with arg %d", 42)
				assert.True(s.T(), predicate, "msg with args %d %s", 42, "42")
				assert.Truef(s.T(), predicate, "msg")
				assert.Truef(s.T(), predicate, "msg with arg %d", 42)
				assert.Truef(s.T(), predicate, "msg with args %d %s", 42, "42")

				require.Equal(s.T(), true, predicate)                                   // want "bool-compare: use require\\.True"
				require.Equal(s.T(), true, predicate, "msg")                            // want "bool-compare: use require\\.True"
				require.Equal(s.T(), true, predicate, "msg with arg %d", 42)            // want "bool-compare: use require\\.True"
				require.Equal(s.T(), true, predicate, "msg with args %d %s", 42, "42")  // want "bool-compare: use require\\.True"
				require.Equalf(s.T(), true, predicate, "msg")                           // want "bool-compare: use require\\.Truef"
				require.Equalf(s.T(), true, predicate, "msg with arg %d", 42)           // want "bool-compare: use require\\.Truef"
				require.Equalf(s.T(), true, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use require\\.Truef"

				require.True(s.T(), predicate)
				require.True(s.T(), predicate, "msg")
				require.True(s.T(), predicate, "msg with arg %d", 42)
				require.True(s.T(), predicate, "msg with args %d %s", 42, "42")
				require.Truef(s.T(), predicate, "msg")
				require.Truef(s.T(), predicate, "msg with arg %d", 42)
				require.Truef(s.T(), predicate, "msg with args %d %s", 42, "42")

				assertObj, requireObj := assert.New(s.T()), require.New(s.T())
				suiteAssertObj, suiteRequireObj := s.Assert(), s.Require()
				s.Equal(true, predicate)                                   // want "bool-compare: use s\\.True"
				s.Equal(true, predicate, "msg")                            // want "bool-compare: use s\\.True"
				s.Equal(true, predicate, "msg with arg %d", 42)            // want "bool-compare: use s\\.True"
				s.Equal(true, predicate, "msg with args %d %s", 42, "42")  // want "bool-compare: use s\\.True"
				s.Equalf(true, predicate, "msg")                           // want "bool-compare: use s\\.Truef"
				s.Equalf(true, predicate, "msg with arg %d", 42)           // want "bool-compare: use s\\.Truef"
				s.Equalf(true, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use s\\.Truef"

				s.True(predicate)
				s.True(predicate, "msg")
				s.True(predicate, "msg with arg %d", 42)
				s.True(predicate, "msg with args %d %s", 42, "42")
				s.Truef(predicate, "msg")
				s.Truef(predicate, "msg with arg %d", 42)
				s.Truef(predicate, "msg with args %d %s", 42, "42")

				s.Assert().Equal(true, predicate)                                   // want "bool-compare: use s\\.Assert\\(\\)\\.True"
				s.Assert().Equal(true, predicate, "msg")                            // want "bool-compare: use s\\.Assert\\(\\)\\.True"
				s.Assert().Equal(true, predicate, "msg with arg %d", 42)            // want "bool-compare: use s\\.Assert\\(\\)\\.True"
				s.Assert().Equal(true, predicate, "msg with args %d %s", 42, "42")  // want "bool-compare: use s\\.Assert\\(\\)\\.True"
				s.Assert().Equalf(true, predicate, "msg")                           // want "bool-compare: use s\\.Assert\\(\\)\\.Truef"
				s.Assert().Equalf(true, predicate, "msg with arg %d", 42)           // want "bool-compare: use s\\.Assert\\(\\)\\.Truef"
				s.Assert().Equalf(true, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use s\\.Assert\\(\\)\\.Truef"

				s.Assert().True(predicate)
				s.Assert().True(predicate, "msg")
				s.Assert().True(predicate, "msg with arg %d", 42)
				s.Assert().True(predicate, "msg with args %d %s", 42, "42")
				s.Assert().Truef(predicate, "msg")
				s.Assert().Truef(predicate, "msg with arg %d", 42)
				s.Assert().Truef(predicate, "msg with args %d %s", 42, "42")

				assertObj.Equal(true, predicate)                                   // want "bool-compare: use assertObj\\.True"
				assertObj.Equal(true, predicate, "msg")                            // want "bool-compare: use assertObj\\.True"
				assertObj.Equal(true, predicate, "msg with arg %d", 42)            // want "bool-compare: use assertObj\\.True"
				assertObj.Equal(true, predicate, "msg with args %d %s", 42, "42")  // want "bool-compare: use assertObj\\.True"
				assertObj.Equalf(true, predicate, "msg")                           // want "bool-compare: use assertObj\\.Truef"
				assertObj.Equalf(true, predicate, "msg with arg %d", 42)           // want "bool-compare: use assertObj\\.Truef"
				assertObj.Equalf(true, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use assertObj\\.Truef"

				assertObj.True(predicate)
				assertObj.True(predicate, "msg")
				assertObj.True(predicate, "msg with arg %d", 42)
				assertObj.True(predicate, "msg with args %d %s", 42, "42")
				assertObj.Truef(predicate, "msg")
				assertObj.Truef(predicate, "msg with arg %d", 42)
				assertObj.Truef(predicate, "msg with args %d %s", 42, "42")

				suiteAssertObj.Equal(true, predicate)                                   // want "bool-compare: use suiteAssertObj\\.True"
				suiteAssertObj.Equal(true, predicate, "msg")                            // want "bool-compare: use suiteAssertObj\\.True"
				suiteAssertObj.Equal(true, predicate, "msg with arg %d", 42)            // want "bool-compare: use suiteAssertObj\\.True"
				suiteAssertObj.Equal(true, predicate, "msg with args %d %s", 42, "42")  // want "bool-compare: use suiteAssertObj\\.True"
				suiteAssertObj.Equalf(true, predicate, "msg")                           // want "bool-compare: use suiteAssertObj\\.Truef"
				suiteAssertObj.Equalf(true, predicate, "msg with arg %d", 42)           // want "bool-compare: use suiteAssertObj\\.Truef"
				suiteAssertObj.Equalf(true, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use suiteAssertObj\\.Truef"

				suiteAssertObj.True(predicate)
				suiteAssertObj.True(predicate, "msg")
				suiteAssertObj.True(predicate, "msg with arg %d", 42)
				suiteAssertObj.True(predicate, "msg with args %d %s", 42, "42")
				suiteAssertObj.Truef(predicate, "msg")
				suiteAssertObj.Truef(predicate, "msg with arg %d", 42)
				suiteAssertObj.Truef(predicate, "msg with args %d %s", 42, "42")

				s.Require().Equal(true, predicate)                                   // want "bool-compare: use s\\.Require\\(\\)\\.True"
				s.Require().Equal(true, predicate, "msg")                            // want "bool-compare: use s\\.Require\\(\\)\\.True"
				s.Require().Equal(true, predicate, "msg with arg %d", 42)            // want "bool-compare: use s\\.Require\\(\\)\\.True"
				s.Require().Equal(true, predicate, "msg with args %d %s", 42, "42")  // want "bool-compare: use s\\.Require\\(\\)\\.True"
				s.Require().Equalf(true, predicate, "msg")                           // want "bool-compare: use s\\.Require\\(\\)\\.Truef"
				s.Require().Equalf(true, predicate, "msg with arg %d", 42)           // want "bool-compare: use s\\.Require\\(\\)\\.Truef"
				s.Require().Equalf(true, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use s\\.Require\\(\\)\\.Truef"

				s.Require().True(predicate)
				s.Require().True(predicate, "msg")
				s.Require().True(predicate, "msg with arg %d", 42)
				s.Require().True(predicate, "msg with args %d %s", 42, "42")
				s.Require().Truef(predicate, "msg")
				s.Require().Truef(predicate, "msg with arg %d", 42)
				s.Require().Truef(predicate, "msg with args %d %s", 42, "42")

				requireObj.Equal(true, predicate)                                   // want "bool-compare: use requireObj\\.True"
				requireObj.Equal(true, predicate, "msg")                            // want "bool-compare: use requireObj\\.True"
				requireObj.Equal(true, predicate, "msg with arg %d", 42)            // want "bool-compare: use requireObj\\.True"
				requireObj.Equal(true, predicate, "msg with args %d %s", 42, "42")  // want "bool-compare: use requireObj\\.True"
				requireObj.Equalf(true, predicate, "msg")                           // want "bool-compare: use requireObj\\.Truef"
				requireObj.Equalf(true, predicate, "msg with arg %d", 42)           // want "bool-compare: use requireObj\\.Truef"
				requireObj.Equalf(true, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use requireObj\\.Truef"

				requireObj.True(predicate)
				requireObj.True(predicate, "msg")
				requireObj.True(predicate, "msg with arg %d", 42)
				requireObj.True(predicate, "msg with args %d %s", 42, "42")
				requireObj.Truef(predicate, "msg")
				requireObj.Truef(predicate, "msg with arg %d", 42)
				requireObj.Truef(predicate, "msg with args %d %s", 42, "42")

				suiteRequireObj.Equal(true, predicate)                                   // want "bool-compare: use suiteRequireObj\\.True"
				suiteRequireObj.Equal(true, predicate, "msg")                            // want "bool-compare: use suiteRequireObj\\.True"
				suiteRequireObj.Equal(true, predicate, "msg with arg %d", 42)            // want "bool-compare: use suiteRequireObj\\.True"
				suiteRequireObj.Equal(true, predicate, "msg with args %d %s", 42, "42")  // want "bool-compare: use suiteRequireObj\\.True"
				suiteRequireObj.Equalf(true, predicate, "msg")                           // want "bool-compare: use suiteRequireObj\\.Truef"
				suiteRequireObj.Equalf(true, predicate, "msg with arg %d", 42)           // want "bool-compare: use suiteRequireObj\\.Truef"
				suiteRequireObj.Equalf(true, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use suiteRequireObj\\.Truef"

				suiteRequireObj.True(predicate)
				suiteRequireObj.True(predicate, "msg")
				suiteRequireObj.True(predicate, "msg with arg %d", 42)
				suiteRequireObj.True(predicate, "msg with args %d %s", 42, "42")
				suiteRequireObj.Truef(predicate, "msg")
				suiteRequireObj.Truef(predicate, "msg with arg %d", 42)
				suiteRequireObj.Truef(predicate, "msg with args %d %s", 42, "42")

				assert.New(s.T()).Equal(true, predicate)                                   // want "bool-compare: use assert\\.New\\(s\\.T\\(\\)\\)\\.True"
				assert.New(s.T()).Equal(true, predicate, "msg")                            // want "bool-compare: use assert\\.New\\(s\\.T\\(\\)\\)\\.True"
				assert.New(s.T()).Equal(true, predicate, "msg with arg %d", 42)            // want "bool-compare: use assert\\.New\\(s\\.T\\(\\)\\)\\.True"
				assert.New(s.T()).Equal(true, predicate, "msg with args %d %s", 42, "42")  // want "bool-compare: use assert\\.New\\(s\\.T\\(\\)\\)\\.True"
				assert.New(s.T()).Equalf(true, predicate, "msg")                           // want "bool-compare: use assert\\.New\\(s\\.T\\(\\)\\)\\.Truef"
				assert.New(s.T()).Equalf(true, predicate, "msg with arg %d", 42)           // want "bool-compare: use assert\\.New\\(s\\.T\\(\\)\\)\\.Truef"
				assert.New(s.T()).Equalf(true, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use assert\\.New\\(s\\.T\\(\\)\\)\\.Truef"

				assert.New(s.T()).True(predicate)
				assert.New(s.T()).True(predicate, "msg")
				assert.New(s.T()).True(predicate, "msg with arg %d", 42)
				assert.New(s.T()).True(predicate, "msg with args %d %s", 42, "42")
				assert.New(s.T()).Truef(predicate, "msg")
				assert.New(s.T()).Truef(predicate, "msg with arg %d", 42)
				assert.New(s.T()).Truef(predicate, "msg with args %d %s", 42, "42")

				require.New(s.T()).Equal(true, predicate)                                   // want "bool-compare: use require\\.New\\(s\\.T\\(\\)\\)\\.True"
				require.New(s.T()).Equal(true, predicate, "msg")                            // want "bool-compare: use require\\.New\\(s\\.T\\(\\)\\)\\.True"
				require.New(s.T()).Equal(true, predicate, "msg with arg %d", 42)            // want "bool-compare: use require\\.New\\(s\\.T\\(\\)\\)\\.True"
				require.New(s.T()).Equal(true, predicate, "msg with args %d %s", 42, "42")  // want "bool-compare: use require\\.New\\(s\\.T\\(\\)\\)\\.True"
				require.New(s.T()).Equalf(true, predicate, "msg")                           // want "bool-compare: use require\\.New\\(s\\.T\\(\\)\\)\\.Truef"
				require.New(s.T()).Equalf(true, predicate, "msg with arg %d", 42)           // want "bool-compare: use require\\.New\\(s\\.T\\(\\)\\)\\.Truef"
				require.New(s.T()).Equalf(true, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use require\\.New\\(s\\.T\\(\\)\\)\\.Truef"

				require.New(s.T()).True(predicate)
				require.New(s.T()).True(predicate, "msg")
				require.New(s.T()).True(predicate, "msg with arg %d", 42)
				require.New(s.T()).True(predicate, "msg with args %d %s", 42, "42")
				require.New(s.T()).Truef(predicate, "msg")
				require.New(s.T()).Truef(predicate, "msg with arg %d", 42)
				require.New(s.T()).Truef(predicate, "msg with args %d %s", 42, "42")
			})
		}
	})

	s.Run("subtest2", func() {
		assert.Equal(s.T(), true, predicate)                                   // want "bool-compare: use assert\\.True"
		assert.Equal(s.T(), true, predicate, "msg")                            // want "bool-compare: use assert\\.True"
		assert.Equal(s.T(), true, predicate, "msg with arg %d", 42)            // want "bool-compare: use assert\\.True"
		assert.Equal(s.T(), true, predicate, "msg with args %d %s", 42, "42")  // want "bool-compare: use assert\\.True"
		assert.Equalf(s.T(), true, predicate, "msg")                           // want "bool-compare: use assert\\.Truef"
		assert.Equalf(s.T(), true, predicate, "msg with arg %d", 42)           // want "bool-compare: use assert\\.Truef"
		assert.Equalf(s.T(), true, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use assert\\.Truef"

		assert.True(s.T(), predicate)
		assert.True(s.T(), predicate, "msg")
		assert.True(s.T(), predicate, "msg with arg %d", 42)
		assert.True(s.T(), predicate, "msg with args %d %s", 42, "42")
		assert.Truef(s.T(), predicate, "msg")
		assert.Truef(s.T(), predicate, "msg with arg %d", 42)
		assert.Truef(s.T(), predicate, "msg with args %d %s", 42, "42")

		require.Equal(s.T(), true, predicate)                                   // want "bool-compare: use require\\.True"
		require.Equal(s.T(), true, predicate, "msg")                            // want "bool-compare: use require\\.True"
		require.Equal(s.T(), true, predicate, "msg with arg %d", 42)            // want "bool-compare: use require\\.True"
		require.Equal(s.T(), true, predicate, "msg with args %d %s", 42, "42")  // want "bool-compare: use require\\.True"
		require.Equalf(s.T(), true, predicate, "msg")                           // want "bool-compare: use require\\.Truef"
		require.Equalf(s.T(), true, predicate, "msg with arg %d", 42)           // want "bool-compare: use require\\.Truef"
		require.Equalf(s.T(), true, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use require\\.Truef"

		require.True(s.T(), predicate)
		require.True(s.T(), predicate, "msg")
		require.True(s.T(), predicate, "msg with arg %d", 42)
		require.True(s.T(), predicate, "msg with args %d %s", 42, "42")
		require.Truef(s.T(), predicate, "msg")
		require.Truef(s.T(), predicate, "msg with arg %d", 42)
		require.Truef(s.T(), predicate, "msg with args %d %s", 42, "42")

		assertObj, requireObj := assert.New(s.T()), require.New(s.T())
		suiteAssertObj, suiteRequireObj := s.Assert(), s.Require()
		s.Equal(true, predicate)                                   // want "bool-compare: use s\\.True"
		s.Equal(true, predicate, "msg")                            // want "bool-compare: use s\\.True"
		s.Equal(true, predicate, "msg with arg %d", 42)            // want "bool-compare: use s\\.True"
		s.Equal(true, predicate, "msg with args %d %s", 42, "42")  // want "bool-compare: use s\\.True"
		s.Equalf(true, predicate, "msg")                           // want "bool-compare: use s\\.Truef"
		s.Equalf(true, predicate, "msg with arg %d", 42)           // want "bool-compare: use s\\.Truef"
		s.Equalf(true, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use s\\.Truef"

		s.True(predicate)
		s.True(predicate, "msg")
		s.True(predicate, "msg with arg %d", 42)
		s.True(predicate, "msg with args %d %s", 42, "42")
		s.Truef(predicate, "msg")
		s.Truef(predicate, "msg with arg %d", 42)
		s.Truef(predicate, "msg with args %d %s", 42, "42")

		s.Assert().Equal(true, predicate)                                   // want "bool-compare: use s\\.Assert\\(\\)\\.True"
		s.Assert().Equal(true, predicate, "msg")                            // want "bool-compare: use s\\.Assert\\(\\)\\.True"
		s.Assert().Equal(true, predicate, "msg with arg %d", 42)            // want "bool-compare: use s\\.Assert\\(\\)\\.True"
		s.Assert().Equal(true, predicate, "msg with args %d %s", 42, "42")  // want "bool-compare: use s\\.Assert\\(\\)\\.True"
		s.Assert().Equalf(true, predicate, "msg")                           // want "bool-compare: use s\\.Assert\\(\\)\\.Truef"
		s.Assert().Equalf(true, predicate, "msg with arg %d", 42)           // want "bool-compare: use s\\.Assert\\(\\)\\.Truef"
		s.Assert().Equalf(true, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use s\\.Assert\\(\\)\\.Truef"

		s.Assert().True(predicate)
		s.Assert().True(predicate, "msg")
		s.Assert().True(predicate, "msg with arg %d", 42)
		s.Assert().True(predicate, "msg with args %d %s", 42, "42")
		s.Assert().Truef(predicate, "msg")
		s.Assert().Truef(predicate, "msg with arg %d", 42)
		s.Assert().Truef(predicate, "msg with args %d %s", 42, "42")

		assertObj.Equal(true, predicate)                                   // want "bool-compare: use assertObj\\.True"
		assertObj.Equal(true, predicate, "msg")                            // want "bool-compare: use assertObj\\.True"
		assertObj.Equal(true, predicate, "msg with arg %d", 42)            // want "bool-compare: use assertObj\\.True"
		assertObj.Equal(true, predicate, "msg with args %d %s", 42, "42")  // want "bool-compare: use assertObj\\.True"
		assertObj.Equalf(true, predicate, "msg")                           // want "bool-compare: use assertObj\\.Truef"
		assertObj.Equalf(true, predicate, "msg with arg %d", 42)           // want "bool-compare: use assertObj\\.Truef"
		assertObj.Equalf(true, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use assertObj\\.Truef"

		assertObj.True(predicate)
		assertObj.True(predicate, "msg")
		assertObj.True(predicate, "msg with arg %d", 42)
		assertObj.True(predicate, "msg with args %d %s", 42, "42")
		assertObj.Truef(predicate, "msg")
		assertObj.Truef(predicate, "msg with arg %d", 42)
		assertObj.Truef(predicate, "msg with args %d %s", 42, "42")

		suiteAssertObj.Equal(true, predicate)                                   // want "bool-compare: use suiteAssertObj\\.True"
		suiteAssertObj.Equal(true, predicate, "msg")                            // want "bool-compare: use suiteAssertObj\\.True"
		suiteAssertObj.Equal(true, predicate, "msg with arg %d", 42)            // want "bool-compare: use suiteAssertObj\\.True"
		suiteAssertObj.Equal(true, predicate, "msg with args %d %s", 42, "42")  // want "bool-compare: use suiteAssertObj\\.True"
		suiteAssertObj.Equalf(true, predicate, "msg")                           // want "bool-compare: use suiteAssertObj\\.Truef"
		suiteAssertObj.Equalf(true, predicate, "msg with arg %d", 42)           // want "bool-compare: use suiteAssertObj\\.Truef"
		suiteAssertObj.Equalf(true, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use suiteAssertObj\\.Truef"

		suiteAssertObj.True(predicate)
		suiteAssertObj.True(predicate, "msg")
		suiteAssertObj.True(predicate, "msg with arg %d", 42)
		suiteAssertObj.True(predicate, "msg with args %d %s", 42, "42")
		suiteAssertObj.Truef(predicate, "msg")
		suiteAssertObj.Truef(predicate, "msg with arg %d", 42)
		suiteAssertObj.Truef(predicate, "msg with args %d %s", 42, "42")

		s.Require().Equal(true, predicate)                                   // want "bool-compare: use s\\.Require\\(\\)\\.True"
		s.Require().Equal(true, predicate, "msg")                            // want "bool-compare: use s\\.Require\\(\\)\\.True"
		s.Require().Equal(true, predicate, "msg with arg %d", 42)            // want "bool-compare: use s\\.Require\\(\\)\\.True"
		s.Require().Equal(true, predicate, "msg with args %d %s", 42, "42")  // want "bool-compare: use s\\.Require\\(\\)\\.True"
		s.Require().Equalf(true, predicate, "msg")                           // want "bool-compare: use s\\.Require\\(\\)\\.Truef"
		s.Require().Equalf(true, predicate, "msg with arg %d", 42)           // want "bool-compare: use s\\.Require\\(\\)\\.Truef"
		s.Require().Equalf(true, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use s\\.Require\\(\\)\\.Truef"

		s.Require().True(predicate)
		s.Require().True(predicate, "msg")
		s.Require().True(predicate, "msg with arg %d", 42)
		s.Require().True(predicate, "msg with args %d %s", 42, "42")
		s.Require().Truef(predicate, "msg")
		s.Require().Truef(predicate, "msg with arg %d", 42)
		s.Require().Truef(predicate, "msg with args %d %s", 42, "42")

		requireObj.Equal(true, predicate)                                   // want "bool-compare: use requireObj\\.True"
		requireObj.Equal(true, predicate, "msg")                            // want "bool-compare: use requireObj\\.True"
		requireObj.Equal(true, predicate, "msg with arg %d", 42)            // want "bool-compare: use requireObj\\.True"
		requireObj.Equal(true, predicate, "msg with args %d %s", 42, "42")  // want "bool-compare: use requireObj\\.True"
		requireObj.Equalf(true, predicate, "msg")                           // want "bool-compare: use requireObj\\.Truef"
		requireObj.Equalf(true, predicate, "msg with arg %d", 42)           // want "bool-compare: use requireObj\\.Truef"
		requireObj.Equalf(true, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use requireObj\\.Truef"

		requireObj.True(predicate)
		requireObj.True(predicate, "msg")
		requireObj.True(predicate, "msg with arg %d", 42)
		requireObj.True(predicate, "msg with args %d %s", 42, "42")
		requireObj.Truef(predicate, "msg")
		requireObj.Truef(predicate, "msg with arg %d", 42)
		requireObj.Truef(predicate, "msg with args %d %s", 42, "42")

		suiteRequireObj.Equal(true, predicate)                                   // want "bool-compare: use suiteRequireObj\\.True"
		suiteRequireObj.Equal(true, predicate, "msg")                            // want "bool-compare: use suiteRequireObj\\.True"
		suiteRequireObj.Equal(true, predicate, "msg with arg %d", 42)            // want "bool-compare: use suiteRequireObj\\.True"
		suiteRequireObj.Equal(true, predicate, "msg with args %d %s", 42, "42")  // want "bool-compare: use suiteRequireObj\\.True"
		suiteRequireObj.Equalf(true, predicate, "msg")                           // want "bool-compare: use suiteRequireObj\\.Truef"
		suiteRequireObj.Equalf(true, predicate, "msg with arg %d", 42)           // want "bool-compare: use suiteRequireObj\\.Truef"
		suiteRequireObj.Equalf(true, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use suiteRequireObj\\.Truef"

		suiteRequireObj.True(predicate)
		suiteRequireObj.True(predicate, "msg")
		suiteRequireObj.True(predicate, "msg with arg %d", 42)
		suiteRequireObj.True(predicate, "msg with args %d %s", 42, "42")
		suiteRequireObj.Truef(predicate, "msg")
		suiteRequireObj.Truef(predicate, "msg with arg %d", 42)
		suiteRequireObj.Truef(predicate, "msg with args %d %s", 42, "42")

		assert.New(s.T()).Equal(true, predicate)                                   // want "bool-compare: use assert\\.New\\(s\\.T\\(\\)\\)\\.True"
		assert.New(s.T()).Equal(true, predicate, "msg")                            // want "bool-compare: use assert\\.New\\(s\\.T\\(\\)\\)\\.True"
		assert.New(s.T()).Equal(true, predicate, "msg with arg %d", 42)            // want "bool-compare: use assert\\.New\\(s\\.T\\(\\)\\)\\.True"
		assert.New(s.T()).Equal(true, predicate, "msg with args %d %s", 42, "42")  // want "bool-compare: use assert\\.New\\(s\\.T\\(\\)\\)\\.True"
		assert.New(s.T()).Equalf(true, predicate, "msg")                           // want "bool-compare: use assert\\.New\\(s\\.T\\(\\)\\)\\.Truef"
		assert.New(s.T()).Equalf(true, predicate, "msg with arg %d", 42)           // want "bool-compare: use assert\\.New\\(s\\.T\\(\\)\\)\\.Truef"
		assert.New(s.T()).Equalf(true, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use assert\\.New\\(s\\.T\\(\\)\\)\\.Truef"

		assert.New(s.T()).True(predicate)
		assert.New(s.T()).True(predicate, "msg")
		assert.New(s.T()).True(predicate, "msg with arg %d", 42)
		assert.New(s.T()).True(predicate, "msg with args %d %s", 42, "42")
		assert.New(s.T()).Truef(predicate, "msg")
		assert.New(s.T()).Truef(predicate, "msg with arg %d", 42)
		assert.New(s.T()).Truef(predicate, "msg with args %d %s", 42, "42")

		require.New(s.T()).Equal(true, predicate)                                   // want "bool-compare: use require\\.New\\(s\\.T\\(\\)\\)\\.True"
		require.New(s.T()).Equal(true, predicate, "msg")                            // want "bool-compare: use require\\.New\\(s\\.T\\(\\)\\)\\.True"
		require.New(s.T()).Equal(true, predicate, "msg with arg %d", 42)            // want "bool-compare: use require\\.New\\(s\\.T\\(\\)\\)\\.True"
		require.New(s.T()).Equal(true, predicate, "msg with args %d %s", 42, "42")  // want "bool-compare: use require\\.New\\(s\\.T\\(\\)\\)\\.True"
		require.New(s.T()).Equalf(true, predicate, "msg")                           // want "bool-compare: use require\\.New\\(s\\.T\\(\\)\\)\\.Truef"
		require.New(s.T()).Equalf(true, predicate, "msg with arg %d", 42)           // want "bool-compare: use require\\.New\\(s\\.T\\(\\)\\)\\.Truef"
		require.New(s.T()).Equalf(true, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use require\\.New\\(s\\.T\\(\\)\\)\\.Truef"

		require.New(s.T()).True(predicate)
		require.New(s.T()).True(predicate, "msg")
		require.New(s.T()).True(predicate, "msg with arg %d", 42)
		require.New(s.T()).True(predicate, "msg with args %d %s", 42, "42")
		require.New(s.T()).Truef(predicate, "msg")
		require.New(s.T()).Truef(predicate, "msg with arg %d", 42)
		require.New(s.T()).Truef(predicate, "msg with args %d %s", 42, "42")
	})

	s.T().Run("subtest3", func(t *testing.T) {
		assert.Equal(t, true, predicate)                                   // want "bool-compare: use assert\\.True"
		assert.Equal(t, true, predicate, "msg")                            // want "bool-compare: use assert\\.True"
		assert.Equal(t, true, predicate, "msg with arg %d", 42)            // want "bool-compare: use assert\\.True"
		assert.Equal(t, true, predicate, "msg with args %d %s", 42, "42")  // want "bool-compare: use assert\\.True"
		assert.Equalf(t, true, predicate, "msg")                           // want "bool-compare: use assert\\.Truef"
		assert.Equalf(t, true, predicate, "msg with arg %d", 42)           // want "bool-compare: use assert\\.Truef"
		assert.Equalf(t, true, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use assert\\.Truef"

		assert.True(t, predicate)
		assert.True(t, predicate, "msg")
		assert.True(t, predicate, "msg with arg %d", 42)
		assert.True(t, predicate, "msg with args %d %s", 42, "42")
		assert.Truef(t, predicate, "msg")
		assert.Truef(t, predicate, "msg with arg %d", 42)
		assert.Truef(t, predicate, "msg with args %d %s", 42, "42")

		require.Equal(t, true, predicate)                                   // want "bool-compare: use require\\.True"
		require.Equal(t, true, predicate, "msg")                            // want "bool-compare: use require\\.True"
		require.Equal(t, true, predicate, "msg with arg %d", 42)            // want "bool-compare: use require\\.True"
		require.Equal(t, true, predicate, "msg with args %d %s", 42, "42")  // want "bool-compare: use require\\.True"
		require.Equalf(t, true, predicate, "msg")                           // want "bool-compare: use require\\.Truef"
		require.Equalf(t, true, predicate, "msg with arg %d", 42)           // want "bool-compare: use require\\.Truef"
		require.Equalf(t, true, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use require\\.Truef"

		require.True(t, predicate)
		require.True(t, predicate, "msg")
		require.True(t, predicate, "msg with arg %d", 42)
		require.True(t, predicate, "msg with args %d %s", 42, "42")
		require.Truef(t, predicate, "msg")
		require.Truef(t, predicate, "msg with arg %d", 42)
		require.Truef(t, predicate, "msg with args %d %s", 42, "42")

		assertObj, requireObj := assert.New(t), require.New(t)
		suiteAssertObj, suiteRequireObj := s.Assert(), s.Require()
		s.Equal(true, predicate)                                   // want "bool-compare: use s\\.True"
		s.Equal(true, predicate, "msg")                            // want "bool-compare: use s\\.True"
		s.Equal(true, predicate, "msg with arg %d", 42)            // want "bool-compare: use s\\.True"
		s.Equal(true, predicate, "msg with args %d %s", 42, "42")  // want "bool-compare: use s\\.True"
		s.Equalf(true, predicate, "msg")                           // want "bool-compare: use s\\.Truef"
		s.Equalf(true, predicate, "msg with arg %d", 42)           // want "bool-compare: use s\\.Truef"
		s.Equalf(true, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use s\\.Truef"

		s.True(predicate)
		s.True(predicate, "msg")
		s.True(predicate, "msg with arg %d", 42)
		s.True(predicate, "msg with args %d %s", 42, "42")
		s.Truef(predicate, "msg")
		s.Truef(predicate, "msg with arg %d", 42)
		s.Truef(predicate, "msg with args %d %s", 42, "42")

		s.Assert().Equal(true, predicate)                                   // want "bool-compare: use s\\.Assert\\(\\)\\.True"
		s.Assert().Equal(true, predicate, "msg")                            // want "bool-compare: use s\\.Assert\\(\\)\\.True"
		s.Assert().Equal(true, predicate, "msg with arg %d", 42)            // want "bool-compare: use s\\.Assert\\(\\)\\.True"
		s.Assert().Equal(true, predicate, "msg with args %d %s", 42, "42")  // want "bool-compare: use s\\.Assert\\(\\)\\.True"
		s.Assert().Equalf(true, predicate, "msg")                           // want "bool-compare: use s\\.Assert\\(\\)\\.Truef"
		s.Assert().Equalf(true, predicate, "msg with arg %d", 42)           // want "bool-compare: use s\\.Assert\\(\\)\\.Truef"
		s.Assert().Equalf(true, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use s\\.Assert\\(\\)\\.Truef"

		s.Assert().True(predicate)
		s.Assert().True(predicate, "msg")
		s.Assert().True(predicate, "msg with arg %d", 42)
		s.Assert().True(predicate, "msg with args %d %s", 42, "42")
		s.Assert().Truef(predicate, "msg")
		s.Assert().Truef(predicate, "msg with arg %d", 42)
		s.Assert().Truef(predicate, "msg with args %d %s", 42, "42")

		assertObj.Equal(true, predicate)                                   // want "bool-compare: use assertObj\\.True"
		assertObj.Equal(true, predicate, "msg")                            // want "bool-compare: use assertObj\\.True"
		assertObj.Equal(true, predicate, "msg with arg %d", 42)            // want "bool-compare: use assertObj\\.True"
		assertObj.Equal(true, predicate, "msg with args %d %s", 42, "42")  // want "bool-compare: use assertObj\\.True"
		assertObj.Equalf(true, predicate, "msg")                           // want "bool-compare: use assertObj\\.Truef"
		assertObj.Equalf(true, predicate, "msg with arg %d", 42)           // want "bool-compare: use assertObj\\.Truef"
		assertObj.Equalf(true, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use assertObj\\.Truef"

		assertObj.True(predicate)
		assertObj.True(predicate, "msg")
		assertObj.True(predicate, "msg with arg %d", 42)
		assertObj.True(predicate, "msg with args %d %s", 42, "42")
		assertObj.Truef(predicate, "msg")
		assertObj.Truef(predicate, "msg with arg %d", 42)
		assertObj.Truef(predicate, "msg with args %d %s", 42, "42")

		suiteAssertObj.Equal(true, predicate)                                   // want "bool-compare: use suiteAssertObj\\.True"
		suiteAssertObj.Equal(true, predicate, "msg")                            // want "bool-compare: use suiteAssertObj\\.True"
		suiteAssertObj.Equal(true, predicate, "msg with arg %d", 42)            // want "bool-compare: use suiteAssertObj\\.True"
		suiteAssertObj.Equal(true, predicate, "msg with args %d %s", 42, "42")  // want "bool-compare: use suiteAssertObj\\.True"
		suiteAssertObj.Equalf(true, predicate, "msg")                           // want "bool-compare: use suiteAssertObj\\.Truef"
		suiteAssertObj.Equalf(true, predicate, "msg with arg %d", 42)           // want "bool-compare: use suiteAssertObj\\.Truef"
		suiteAssertObj.Equalf(true, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use suiteAssertObj\\.Truef"

		suiteAssertObj.True(predicate)
		suiteAssertObj.True(predicate, "msg")
		suiteAssertObj.True(predicate, "msg with arg %d", 42)
		suiteAssertObj.True(predicate, "msg with args %d %s", 42, "42")
		suiteAssertObj.Truef(predicate, "msg")
		suiteAssertObj.Truef(predicate, "msg with arg %d", 42)
		suiteAssertObj.Truef(predicate, "msg with args %d %s", 42, "42")

		s.Require().Equal(true, predicate)                                   // want "bool-compare: use s\\.Require\\(\\)\\.True"
		s.Require().Equal(true, predicate, "msg")                            // want "bool-compare: use s\\.Require\\(\\)\\.True"
		s.Require().Equal(true, predicate, "msg with arg %d", 42)            // want "bool-compare: use s\\.Require\\(\\)\\.True"
		s.Require().Equal(true, predicate, "msg with args %d %s", 42, "42")  // want "bool-compare: use s\\.Require\\(\\)\\.True"
		s.Require().Equalf(true, predicate, "msg")                           // want "bool-compare: use s\\.Require\\(\\)\\.Truef"
		s.Require().Equalf(true, predicate, "msg with arg %d", 42)           // want "bool-compare: use s\\.Require\\(\\)\\.Truef"
		s.Require().Equalf(true, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use s\\.Require\\(\\)\\.Truef"

		s.Require().True(predicate)
		s.Require().True(predicate, "msg")
		s.Require().True(predicate, "msg with arg %d", 42)
		s.Require().True(predicate, "msg with args %d %s", 42, "42")
		s.Require().Truef(predicate, "msg")
		s.Require().Truef(predicate, "msg with arg %d", 42)
		s.Require().Truef(predicate, "msg with args %d %s", 42, "42")

		requireObj.Equal(true, predicate)                                   // want "bool-compare: use requireObj\\.True"
		requireObj.Equal(true, predicate, "msg")                            // want "bool-compare: use requireObj\\.True"
		requireObj.Equal(true, predicate, "msg with arg %d", 42)            // want "bool-compare: use requireObj\\.True"
		requireObj.Equal(true, predicate, "msg with args %d %s", 42, "42")  // want "bool-compare: use requireObj\\.True"
		requireObj.Equalf(true, predicate, "msg")                           // want "bool-compare: use requireObj\\.Truef"
		requireObj.Equalf(true, predicate, "msg with arg %d", 42)           // want "bool-compare: use requireObj\\.Truef"
		requireObj.Equalf(true, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use requireObj\\.Truef"

		requireObj.True(predicate)
		requireObj.True(predicate, "msg")
		requireObj.True(predicate, "msg with arg %d", 42)
		requireObj.True(predicate, "msg with args %d %s", 42, "42")
		requireObj.Truef(predicate, "msg")
		requireObj.Truef(predicate, "msg with arg %d", 42)
		requireObj.Truef(predicate, "msg with args %d %s", 42, "42")

		suiteRequireObj.Equal(true, predicate)                                   // want "bool-compare: use suiteRequireObj\\.True"
		suiteRequireObj.Equal(true, predicate, "msg")                            // want "bool-compare: use suiteRequireObj\\.True"
		suiteRequireObj.Equal(true, predicate, "msg with arg %d", 42)            // want "bool-compare: use suiteRequireObj\\.True"
		suiteRequireObj.Equal(true, predicate, "msg with args %d %s", 42, "42")  // want "bool-compare: use suiteRequireObj\\.True"
		suiteRequireObj.Equalf(true, predicate, "msg")                           // want "bool-compare: use suiteRequireObj\\.Truef"
		suiteRequireObj.Equalf(true, predicate, "msg with arg %d", 42)           // want "bool-compare: use suiteRequireObj\\.Truef"
		suiteRequireObj.Equalf(true, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use suiteRequireObj\\.Truef"

		suiteRequireObj.True(predicate)
		suiteRequireObj.True(predicate, "msg")
		suiteRequireObj.True(predicate, "msg with arg %d", 42)
		suiteRequireObj.True(predicate, "msg with args %d %s", 42, "42")
		suiteRequireObj.Truef(predicate, "msg")
		suiteRequireObj.Truef(predicate, "msg with arg %d", 42)
		suiteRequireObj.Truef(predicate, "msg with args %d %s", 42, "42")

		assert.New(t).Equal(true, predicate)                                   // want "bool-compare: use assert\\.New\\(t\\)\\.True"
		assert.New(t).Equal(true, predicate, "msg")                            // want "bool-compare: use assert\\.New\\(t\\)\\.True"
		assert.New(t).Equal(true, predicate, "msg with arg %d", 42)            // want "bool-compare: use assert\\.New\\(t\\)\\.True"
		assert.New(t).Equal(true, predicate, "msg with args %d %s", 42, "42")  // want "bool-compare: use assert\\.New\\(t\\)\\.True"
		assert.New(t).Equalf(true, predicate, "msg")                           // want "bool-compare: use assert\\.New\\(t\\)\\.Truef"
		assert.New(t).Equalf(true, predicate, "msg with arg %d", 42)           // want "bool-compare: use assert\\.New\\(t\\)\\.Truef"
		assert.New(t).Equalf(true, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use assert\\.New\\(t\\)\\.Truef"

		assert.New(t).True(predicate)
		assert.New(t).True(predicate, "msg")
		assert.New(t).True(predicate, "msg with arg %d", 42)
		assert.New(t).True(predicate, "msg with args %d %s", 42, "42")
		assert.New(t).Truef(predicate, "msg")
		assert.New(t).Truef(predicate, "msg with arg %d", 42)
		assert.New(t).Truef(predicate, "msg with args %d %s", 42, "42")

		require.New(t).Equal(true, predicate)                                   // want "bool-compare: use require\\.New\\(t\\)\\.True"
		require.New(t).Equal(true, predicate, "msg")                            // want "bool-compare: use require\\.New\\(t\\)\\.True"
		require.New(t).Equal(true, predicate, "msg with arg %d", 42)            // want "bool-compare: use require\\.New\\(t\\)\\.True"
		require.New(t).Equal(true, predicate, "msg with args %d %s", 42, "42")  // want "bool-compare: use require\\.New\\(t\\)\\.True"
		require.New(t).Equalf(true, predicate, "msg")                           // want "bool-compare: use require\\.New\\(t\\)\\.Truef"
		require.New(t).Equalf(true, predicate, "msg with arg %d", 42)           // want "bool-compare: use require\\.New\\(t\\)\\.Truef"
		require.New(t).Equalf(true, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use require\\.New\\(t\\)\\.Truef"

		require.New(t).True(predicate)
		require.New(t).True(predicate, "msg")
		require.New(t).True(predicate, "msg with arg %d", 42)
		require.New(t).True(predicate, "msg with args %d %s", 42, "42")
		require.New(t).Truef(predicate, "msg")
		require.New(t).Truef(predicate, "msg with arg %d", 42)
		require.New(t).Truef(predicate, "msg with args %d %s", 42, "42")

		for range []struct{}{} {
			s.T().Run("nested test", func(t *testing.T) {
				assert.Equal(t, true, predicate)                                   // want "bool-compare: use assert\\.True"
				assert.Equal(t, true, predicate, "msg")                            // want "bool-compare: use assert\\.True"
				assert.Equal(t, true, predicate, "msg with arg %d", 42)            // want "bool-compare: use assert\\.True"
				assert.Equal(t, true, predicate, "msg with args %d %s", 42, "42")  // want "bool-compare: use assert\\.True"
				assert.Equalf(t, true, predicate, "msg")                           // want "bool-compare: use assert\\.Truef"
				assert.Equalf(t, true, predicate, "msg with arg %d", 42)           // want "bool-compare: use assert\\.Truef"
				assert.Equalf(t, true, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use assert\\.Truef"

				assert.True(t, predicate)
				assert.True(t, predicate, "msg")
				assert.True(t, predicate, "msg with arg %d", 42)
				assert.True(t, predicate, "msg with args %d %s", 42, "42")
				assert.Truef(t, predicate, "msg")
				assert.Truef(t, predicate, "msg with arg %d", 42)
				assert.Truef(t, predicate, "msg with args %d %s", 42, "42")

				require.Equal(t, true, predicate)                                   // want "bool-compare: use require\\.True"
				require.Equal(t, true, predicate, "msg")                            // want "bool-compare: use require\\.True"
				require.Equal(t, true, predicate, "msg with arg %d", 42)            // want "bool-compare: use require\\.True"
				require.Equal(t, true, predicate, "msg with args %d %s", 42, "42")  // want "bool-compare: use require\\.True"
				require.Equalf(t, true, predicate, "msg")                           // want "bool-compare: use require\\.Truef"
				require.Equalf(t, true, predicate, "msg with arg %d", 42)           // want "bool-compare: use require\\.Truef"
				require.Equalf(t, true, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use require\\.Truef"

				require.True(t, predicate)
				require.True(t, predicate, "msg")
				require.True(t, predicate, "msg with arg %d", 42)
				require.True(t, predicate, "msg with args %d %s", 42, "42")
				require.Truef(t, predicate, "msg")
				require.Truef(t, predicate, "msg with arg %d", 42)
				require.Truef(t, predicate, "msg with args %d %s", 42, "42")

				assertObj, requireObj := assert.New(t), require.New(t)
				suiteAssertObj, suiteRequireObj := s.Assert(), s.Require()
				s.Equal(true, predicate)                                   // want "bool-compare: use s\\.True"
				s.Equal(true, predicate, "msg")                            // want "bool-compare: use s\\.True"
				s.Equal(true, predicate, "msg with arg %d", 42)            // want "bool-compare: use s\\.True"
				s.Equal(true, predicate, "msg with args %d %s", 42, "42")  // want "bool-compare: use s\\.True"
				s.Equalf(true, predicate, "msg")                           // want "bool-compare: use s\\.Truef"
				s.Equalf(true, predicate, "msg with arg %d", 42)           // want "bool-compare: use s\\.Truef"
				s.Equalf(true, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use s\\.Truef"

				s.True(predicate)
				s.True(predicate, "msg")
				s.True(predicate, "msg with arg %d", 42)
				s.True(predicate, "msg with args %d %s", 42, "42")
				s.Truef(predicate, "msg")
				s.Truef(predicate, "msg with arg %d", 42)
				s.Truef(predicate, "msg with args %d %s", 42, "42")

				s.Assert().Equal(true, predicate)                                   // want "bool-compare: use s\\.Assert\\(\\)\\.True"
				s.Assert().Equal(true, predicate, "msg")                            // want "bool-compare: use s\\.Assert\\(\\)\\.True"
				s.Assert().Equal(true, predicate, "msg with arg %d", 42)            // want "bool-compare: use s\\.Assert\\(\\)\\.True"
				s.Assert().Equal(true, predicate, "msg with args %d %s", 42, "42")  // want "bool-compare: use s\\.Assert\\(\\)\\.True"
				s.Assert().Equalf(true, predicate, "msg")                           // want "bool-compare: use s\\.Assert\\(\\)\\.Truef"
				s.Assert().Equalf(true, predicate, "msg with arg %d", 42)           // want "bool-compare: use s\\.Assert\\(\\)\\.Truef"
				s.Assert().Equalf(true, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use s\\.Assert\\(\\)\\.Truef"

				s.Assert().True(predicate)
				s.Assert().True(predicate, "msg")
				s.Assert().True(predicate, "msg with arg %d", 42)
				s.Assert().True(predicate, "msg with args %d %s", 42, "42")
				s.Assert().Truef(predicate, "msg")
				s.Assert().Truef(predicate, "msg with arg %d", 42)
				s.Assert().Truef(predicate, "msg with args %d %s", 42, "42")

				assertObj.Equal(true, predicate)                                   // want "bool-compare: use assertObj\\.True"
				assertObj.Equal(true, predicate, "msg")                            // want "bool-compare: use assertObj\\.True"
				assertObj.Equal(true, predicate, "msg with arg %d", 42)            // want "bool-compare: use assertObj\\.True"
				assertObj.Equal(true, predicate, "msg with args %d %s", 42, "42")  // want "bool-compare: use assertObj\\.True"
				assertObj.Equalf(true, predicate, "msg")                           // want "bool-compare: use assertObj\\.Truef"
				assertObj.Equalf(true, predicate, "msg with arg %d", 42)           // want "bool-compare: use assertObj\\.Truef"
				assertObj.Equalf(true, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use assertObj\\.Truef"

				assertObj.True(predicate)
				assertObj.True(predicate, "msg")
				assertObj.True(predicate, "msg with arg %d", 42)
				assertObj.True(predicate, "msg with args %d %s", 42, "42")
				assertObj.Truef(predicate, "msg")
				assertObj.Truef(predicate, "msg with arg %d", 42)
				assertObj.Truef(predicate, "msg with args %d %s", 42, "42")

				suiteAssertObj.Equal(true, predicate)                                   // want "bool-compare: use suiteAssertObj\\.True"
				suiteAssertObj.Equal(true, predicate, "msg")                            // want "bool-compare: use suiteAssertObj\\.True"
				suiteAssertObj.Equal(true, predicate, "msg with arg %d", 42)            // want "bool-compare: use suiteAssertObj\\.True"
				suiteAssertObj.Equal(true, predicate, "msg with args %d %s", 42, "42")  // want "bool-compare: use suiteAssertObj\\.True"
				suiteAssertObj.Equalf(true, predicate, "msg")                           // want "bool-compare: use suiteAssertObj\\.Truef"
				suiteAssertObj.Equalf(true, predicate, "msg with arg %d", 42)           // want "bool-compare: use suiteAssertObj\\.Truef"
				suiteAssertObj.Equalf(true, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use suiteAssertObj\\.Truef"

				suiteAssertObj.True(predicate)
				suiteAssertObj.True(predicate, "msg")
				suiteAssertObj.True(predicate, "msg with arg %d", 42)
				suiteAssertObj.True(predicate, "msg with args %d %s", 42, "42")
				suiteAssertObj.Truef(predicate, "msg")
				suiteAssertObj.Truef(predicate, "msg with arg %d", 42)
				suiteAssertObj.Truef(predicate, "msg with args %d %s", 42, "42")

				s.Require().Equal(true, predicate)                                   // want "bool-compare: use s\\.Require\\(\\)\\.True"
				s.Require().Equal(true, predicate, "msg")                            // want "bool-compare: use s\\.Require\\(\\)\\.True"
				s.Require().Equal(true, predicate, "msg with arg %d", 42)            // want "bool-compare: use s\\.Require\\(\\)\\.True"
				s.Require().Equal(true, predicate, "msg with args %d %s", 42, "42")  // want "bool-compare: use s\\.Require\\(\\)\\.True"
				s.Require().Equalf(true, predicate, "msg")                           // want "bool-compare: use s\\.Require\\(\\)\\.Truef"
				s.Require().Equalf(true, predicate, "msg with arg %d", 42)           // want "bool-compare: use s\\.Require\\(\\)\\.Truef"
				s.Require().Equalf(true, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use s\\.Require\\(\\)\\.Truef"

				s.Require().True(predicate)
				s.Require().True(predicate, "msg")
				s.Require().True(predicate, "msg with arg %d", 42)
				s.Require().True(predicate, "msg with args %d %s", 42, "42")
				s.Require().Truef(predicate, "msg")
				s.Require().Truef(predicate, "msg with arg %d", 42)
				s.Require().Truef(predicate, "msg with args %d %s", 42, "42")

				requireObj.Equal(true, predicate)                                   // want "bool-compare: use requireObj\\.True"
				requireObj.Equal(true, predicate, "msg")                            // want "bool-compare: use requireObj\\.True"
				requireObj.Equal(true, predicate, "msg with arg %d", 42)            // want "bool-compare: use requireObj\\.True"
				requireObj.Equal(true, predicate, "msg with args %d %s", 42, "42")  // want "bool-compare: use requireObj\\.True"
				requireObj.Equalf(true, predicate, "msg")                           // want "bool-compare: use requireObj\\.Truef"
				requireObj.Equalf(true, predicate, "msg with arg %d", 42)           // want "bool-compare: use requireObj\\.Truef"
				requireObj.Equalf(true, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use requireObj\\.Truef"

				requireObj.True(predicate)
				requireObj.True(predicate, "msg")
				requireObj.True(predicate, "msg with arg %d", 42)
				requireObj.True(predicate, "msg with args %d %s", 42, "42")
				requireObj.Truef(predicate, "msg")
				requireObj.Truef(predicate, "msg with arg %d", 42)
				requireObj.Truef(predicate, "msg with args %d %s", 42, "42")

				suiteRequireObj.Equal(true, predicate)                                   // want "bool-compare: use suiteRequireObj\\.True"
				suiteRequireObj.Equal(true, predicate, "msg")                            // want "bool-compare: use suiteRequireObj\\.True"
				suiteRequireObj.Equal(true, predicate, "msg with arg %d", 42)            // want "bool-compare: use suiteRequireObj\\.True"
				suiteRequireObj.Equal(true, predicate, "msg with args %d %s", 42, "42")  // want "bool-compare: use suiteRequireObj\\.True"
				suiteRequireObj.Equalf(true, predicate, "msg")                           // want "bool-compare: use suiteRequireObj\\.Truef"
				suiteRequireObj.Equalf(true, predicate, "msg with arg %d", 42)           // want "bool-compare: use suiteRequireObj\\.Truef"
				suiteRequireObj.Equalf(true, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use suiteRequireObj\\.Truef"

				suiteRequireObj.True(predicate)
				suiteRequireObj.True(predicate, "msg")
				suiteRequireObj.True(predicate, "msg with arg %d", 42)
				suiteRequireObj.True(predicate, "msg with args %d %s", 42, "42")
				suiteRequireObj.Truef(predicate, "msg")
				suiteRequireObj.Truef(predicate, "msg with arg %d", 42)
				suiteRequireObj.Truef(predicate, "msg with args %d %s", 42, "42")

				assert.New(t).Equal(true, predicate)                                   // want "bool-compare: use assert\\.New\\(t\\)\\.True"
				assert.New(t).Equal(true, predicate, "msg")                            // want "bool-compare: use assert\\.New\\(t\\)\\.True"
				assert.New(t).Equal(true, predicate, "msg with arg %d", 42)            // want "bool-compare: use assert\\.New\\(t\\)\\.True"
				assert.New(t).Equal(true, predicate, "msg with args %d %s", 42, "42")  // want "bool-compare: use assert\\.New\\(t\\)\\.True"
				assert.New(t).Equalf(true, predicate, "msg")                           // want "bool-compare: use assert\\.New\\(t\\)\\.Truef"
				assert.New(t).Equalf(true, predicate, "msg with arg %d", 42)           // want "bool-compare: use assert\\.New\\(t\\)\\.Truef"
				assert.New(t).Equalf(true, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use assert\\.New\\(t\\)\\.Truef"

				assert.New(t).True(predicate)
				assert.New(t).True(predicate, "msg")
				assert.New(t).True(predicate, "msg with arg %d", 42)
				assert.New(t).True(predicate, "msg with args %d %s", 42, "42")
				assert.New(t).Truef(predicate, "msg")
				assert.New(t).Truef(predicate, "msg with arg %d", 42)
				assert.New(t).Truef(predicate, "msg with args %d %s", 42, "42")

				require.New(t).Equal(true, predicate)                                   // want "bool-compare: use require\\.New\\(t\\)\\.True"
				require.New(t).Equal(true, predicate, "msg")                            // want "bool-compare: use require\\.New\\(t\\)\\.True"
				require.New(t).Equal(true, predicate, "msg with arg %d", 42)            // want "bool-compare: use require\\.New\\(t\\)\\.True"
				require.New(t).Equal(true, predicate, "msg with args %d %s", 42, "42")  // want "bool-compare: use require\\.New\\(t\\)\\.True"
				require.New(t).Equalf(true, predicate, "msg")                           // want "bool-compare: use require\\.New\\(t\\)\\.Truef"
				require.New(t).Equalf(true, predicate, "msg with arg %d", 42)           // want "bool-compare: use require\\.New\\(t\\)\\.Truef"
				require.New(t).Equalf(true, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use require\\.New\\(t\\)\\.Truef"

				require.New(t).True(predicate)
				require.New(t).True(predicate, "msg")
				require.New(t).True(predicate, "msg with arg %d", 42)
				require.New(t).True(predicate, "msg with args %d %s", 42, "42")
				require.New(t).Truef(predicate, "msg")
				require.New(t).Truef(predicate, "msg with arg %d", 42)
				require.New(t).Truef(predicate, "msg with args %d %s", 42, "42")
			})
		}
	})

	s.T().Run("subtest4", func(t *testing.T) {
		assert.Equal(t, true, predicate)                                   // want "bool-compare: use assert\\.True"
		assert.Equal(t, true, predicate, "msg")                            // want "bool-compare: use assert\\.True"
		assert.Equal(t, true, predicate, "msg with arg %d", 42)            // want "bool-compare: use assert\\.True"
		assert.Equal(t, true, predicate, "msg with args %d %s", 42, "42")  // want "bool-compare: use assert\\.True"
		assert.Equalf(t, true, predicate, "msg")                           // want "bool-compare: use assert\\.Truef"
		assert.Equalf(t, true, predicate, "msg with arg %d", 42)           // want "bool-compare: use assert\\.Truef"
		assert.Equalf(t, true, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use assert\\.Truef"

		assert.True(t, predicate)
		assert.True(t, predicate, "msg")
		assert.True(t, predicate, "msg with arg %d", 42)
		assert.True(t, predicate, "msg with args %d %s", 42, "42")
		assert.Truef(t, predicate, "msg")
		assert.Truef(t, predicate, "msg with arg %d", 42)
		assert.Truef(t, predicate, "msg with args %d %s", 42, "42")

		require.Equal(t, true, predicate)                                   // want "bool-compare: use require\\.True"
		require.Equal(t, true, predicate, "msg")                            // want "bool-compare: use require\\.True"
		require.Equal(t, true, predicate, "msg with arg %d", 42)            // want "bool-compare: use require\\.True"
		require.Equal(t, true, predicate, "msg with args %d %s", 42, "42")  // want "bool-compare: use require\\.True"
		require.Equalf(t, true, predicate, "msg")                           // want "bool-compare: use require\\.Truef"
		require.Equalf(t, true, predicate, "msg with arg %d", 42)           // want "bool-compare: use require\\.Truef"
		require.Equalf(t, true, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use require\\.Truef"

		require.True(t, predicate)
		require.True(t, predicate, "msg")
		require.True(t, predicate, "msg with arg %d", 42)
		require.True(t, predicate, "msg with args %d %s", 42, "42")
		require.Truef(t, predicate, "msg")
		require.Truef(t, predicate, "msg with arg %d", 42)
		require.Truef(t, predicate, "msg with args %d %s", 42, "42")

		assertObj, requireObj := assert.New(t), require.New(t)
		suiteAssertObj, suiteRequireObj := s.Assert(), s.Require()
		s.Equal(true, predicate)                                   // want "bool-compare: use s\\.True"
		s.Equal(true, predicate, "msg")                            // want "bool-compare: use s\\.True"
		s.Equal(true, predicate, "msg with arg %d", 42)            // want "bool-compare: use s\\.True"
		s.Equal(true, predicate, "msg with args %d %s", 42, "42")  // want "bool-compare: use s\\.True"
		s.Equalf(true, predicate, "msg")                           // want "bool-compare: use s\\.Truef"
		s.Equalf(true, predicate, "msg with arg %d", 42)           // want "bool-compare: use s\\.Truef"
		s.Equalf(true, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use s\\.Truef"

		s.True(predicate)
		s.True(predicate, "msg")
		s.True(predicate, "msg with arg %d", 42)
		s.True(predicate, "msg with args %d %s", 42, "42")
		s.Truef(predicate, "msg")
		s.Truef(predicate, "msg with arg %d", 42)
		s.Truef(predicate, "msg with args %d %s", 42, "42")

		s.Assert().Equal(true, predicate)                                   // want "bool-compare: use s\\.Assert\\(\\)\\.True"
		s.Assert().Equal(true, predicate, "msg")                            // want "bool-compare: use s\\.Assert\\(\\)\\.True"
		s.Assert().Equal(true, predicate, "msg with arg %d", 42)            // want "bool-compare: use s\\.Assert\\(\\)\\.True"
		s.Assert().Equal(true, predicate, "msg with args %d %s", 42, "42")  // want "bool-compare: use s\\.Assert\\(\\)\\.True"
		s.Assert().Equalf(true, predicate, "msg")                           // want "bool-compare: use s\\.Assert\\(\\)\\.Truef"
		s.Assert().Equalf(true, predicate, "msg with arg %d", 42)           // want "bool-compare: use s\\.Assert\\(\\)\\.Truef"
		s.Assert().Equalf(true, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use s\\.Assert\\(\\)\\.Truef"

		s.Assert().True(predicate)
		s.Assert().True(predicate, "msg")
		s.Assert().True(predicate, "msg with arg %d", 42)
		s.Assert().True(predicate, "msg with args %d %s", 42, "42")
		s.Assert().Truef(predicate, "msg")
		s.Assert().Truef(predicate, "msg with arg %d", 42)
		s.Assert().Truef(predicate, "msg with args %d %s", 42, "42")

		assertObj.Equal(true, predicate)                                   // want "bool-compare: use assertObj\\.True"
		assertObj.Equal(true, predicate, "msg")                            // want "bool-compare: use assertObj\\.True"
		assertObj.Equal(true, predicate, "msg with arg %d", 42)            // want "bool-compare: use assertObj\\.True"
		assertObj.Equal(true, predicate, "msg with args %d %s", 42, "42")  // want "bool-compare: use assertObj\\.True"
		assertObj.Equalf(true, predicate, "msg")                           // want "bool-compare: use assertObj\\.Truef"
		assertObj.Equalf(true, predicate, "msg with arg %d", 42)           // want "bool-compare: use assertObj\\.Truef"
		assertObj.Equalf(true, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use assertObj\\.Truef"

		assertObj.True(predicate)
		assertObj.True(predicate, "msg")
		assertObj.True(predicate, "msg with arg %d", 42)
		assertObj.True(predicate, "msg with args %d %s", 42, "42")
		assertObj.Truef(predicate, "msg")
		assertObj.Truef(predicate, "msg with arg %d", 42)
		assertObj.Truef(predicate, "msg with args %d %s", 42, "42")

		suiteAssertObj.Equal(true, predicate)                                   // want "bool-compare: use suiteAssertObj\\.True"
		suiteAssertObj.Equal(true, predicate, "msg")                            // want "bool-compare: use suiteAssertObj\\.True"
		suiteAssertObj.Equal(true, predicate, "msg with arg %d", 42)            // want "bool-compare: use suiteAssertObj\\.True"
		suiteAssertObj.Equal(true, predicate, "msg with args %d %s", 42, "42")  // want "bool-compare: use suiteAssertObj\\.True"
		suiteAssertObj.Equalf(true, predicate, "msg")                           // want "bool-compare: use suiteAssertObj\\.Truef"
		suiteAssertObj.Equalf(true, predicate, "msg with arg %d", 42)           // want "bool-compare: use suiteAssertObj\\.Truef"
		suiteAssertObj.Equalf(true, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use suiteAssertObj\\.Truef"

		suiteAssertObj.True(predicate)
		suiteAssertObj.True(predicate, "msg")
		suiteAssertObj.True(predicate, "msg with arg %d", 42)
		suiteAssertObj.True(predicate, "msg with args %d %s", 42, "42")
		suiteAssertObj.Truef(predicate, "msg")
		suiteAssertObj.Truef(predicate, "msg with arg %d", 42)
		suiteAssertObj.Truef(predicate, "msg with args %d %s", 42, "42")

		s.Require().Equal(true, predicate)                                   // want "bool-compare: use s\\.Require\\(\\)\\.True"
		s.Require().Equal(true, predicate, "msg")                            // want "bool-compare: use s\\.Require\\(\\)\\.True"
		s.Require().Equal(true, predicate, "msg with arg %d", 42)            // want "bool-compare: use s\\.Require\\(\\)\\.True"
		s.Require().Equal(true, predicate, "msg with args %d %s", 42, "42")  // want "bool-compare: use s\\.Require\\(\\)\\.True"
		s.Require().Equalf(true, predicate, "msg")                           // want "bool-compare: use s\\.Require\\(\\)\\.Truef"
		s.Require().Equalf(true, predicate, "msg with arg %d", 42)           // want "bool-compare: use s\\.Require\\(\\)\\.Truef"
		s.Require().Equalf(true, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use s\\.Require\\(\\)\\.Truef"

		s.Require().True(predicate)
		s.Require().True(predicate, "msg")
		s.Require().True(predicate, "msg with arg %d", 42)
		s.Require().True(predicate, "msg with args %d %s", 42, "42")
		s.Require().Truef(predicate, "msg")
		s.Require().Truef(predicate, "msg with arg %d", 42)
		s.Require().Truef(predicate, "msg with args %d %s", 42, "42")

		requireObj.Equal(true, predicate)                                   // want "bool-compare: use requireObj\\.True"
		requireObj.Equal(true, predicate, "msg")                            // want "bool-compare: use requireObj\\.True"
		requireObj.Equal(true, predicate, "msg with arg %d", 42)            // want "bool-compare: use requireObj\\.True"
		requireObj.Equal(true, predicate, "msg with args %d %s", 42, "42")  // want "bool-compare: use requireObj\\.True"
		requireObj.Equalf(true, predicate, "msg")                           // want "bool-compare: use requireObj\\.Truef"
		requireObj.Equalf(true, predicate, "msg with arg %d", 42)           // want "bool-compare: use requireObj\\.Truef"
		requireObj.Equalf(true, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use requireObj\\.Truef"

		requireObj.True(predicate)
		requireObj.True(predicate, "msg")
		requireObj.True(predicate, "msg with arg %d", 42)
		requireObj.True(predicate, "msg with args %d %s", 42, "42")
		requireObj.Truef(predicate, "msg")
		requireObj.Truef(predicate, "msg with arg %d", 42)
		requireObj.Truef(predicate, "msg with args %d %s", 42, "42")

		suiteRequireObj.Equal(true, predicate)                                   // want "bool-compare: use suiteRequireObj\\.True"
		suiteRequireObj.Equal(true, predicate, "msg")                            // want "bool-compare: use suiteRequireObj\\.True"
		suiteRequireObj.Equal(true, predicate, "msg with arg %d", 42)            // want "bool-compare: use suiteRequireObj\\.True"
		suiteRequireObj.Equal(true, predicate, "msg with args %d %s", 42, "42")  // want "bool-compare: use suiteRequireObj\\.True"
		suiteRequireObj.Equalf(true, predicate, "msg")                           // want "bool-compare: use suiteRequireObj\\.Truef"
		suiteRequireObj.Equalf(true, predicate, "msg with arg %d", 42)           // want "bool-compare: use suiteRequireObj\\.Truef"
		suiteRequireObj.Equalf(true, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use suiteRequireObj\\.Truef"

		suiteRequireObj.True(predicate)
		suiteRequireObj.True(predicate, "msg")
		suiteRequireObj.True(predicate, "msg with arg %d", 42)
		suiteRequireObj.True(predicate, "msg with args %d %s", 42, "42")
		suiteRequireObj.Truef(predicate, "msg")
		suiteRequireObj.Truef(predicate, "msg with arg %d", 42)
		suiteRequireObj.Truef(predicate, "msg with args %d %s", 42, "42")

		assert.New(t).Equal(true, predicate)                                   // want "bool-compare: use assert\\.New\\(t\\)\\.True"
		assert.New(t).Equal(true, predicate, "msg")                            // want "bool-compare: use assert\\.New\\(t\\)\\.True"
		assert.New(t).Equal(true, predicate, "msg with arg %d", 42)            // want "bool-compare: use assert\\.New\\(t\\)\\.True"
		assert.New(t).Equal(true, predicate, "msg with args %d %s", 42, "42")  // want "bool-compare: use assert\\.New\\(t\\)\\.True"
		assert.New(t).Equalf(true, predicate, "msg")                           // want "bool-compare: use assert\\.New\\(t\\)\\.Truef"
		assert.New(t).Equalf(true, predicate, "msg with arg %d", 42)           // want "bool-compare: use assert\\.New\\(t\\)\\.Truef"
		assert.New(t).Equalf(true, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use assert\\.New\\(t\\)\\.Truef"

		assert.New(t).True(predicate)
		assert.New(t).True(predicate, "msg")
		assert.New(t).True(predicate, "msg with arg %d", 42)
		assert.New(t).True(predicate, "msg with args %d %s", 42, "42")
		assert.New(t).Truef(predicate, "msg")
		assert.New(t).Truef(predicate, "msg with arg %d", 42)
		assert.New(t).Truef(predicate, "msg with args %d %s", 42, "42")

		require.New(t).Equal(true, predicate)                                   // want "bool-compare: use require\\.New\\(t\\)\\.True"
		require.New(t).Equal(true, predicate, "msg")                            // want "bool-compare: use require\\.New\\(t\\)\\.True"
		require.New(t).Equal(true, predicate, "msg with arg %d", 42)            // want "bool-compare: use require\\.New\\(t\\)\\.True"
		require.New(t).Equal(true, predicate, "msg with args %d %s", 42, "42")  // want "bool-compare: use require\\.New\\(t\\)\\.True"
		require.New(t).Equalf(true, predicate, "msg")                           // want "bool-compare: use require\\.New\\(t\\)\\.Truef"
		require.New(t).Equalf(true, predicate, "msg with arg %d", 42)           // want "bool-compare: use require\\.New\\(t\\)\\.Truef"
		require.New(t).Equalf(true, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use require\\.New\\(t\\)\\.Truef"

		require.New(t).True(predicate)
		require.New(t).True(predicate, "msg")
		require.New(t).True(predicate, "msg with arg %d", 42)
		require.New(t).True(predicate, "msg with args %d %s", 42, "42")
		require.New(t).Truef(predicate, "msg")
		require.New(t).Truef(predicate, "msg with arg %d", 42)
		require.New(t).Truef(predicate, "msg with args %d %s", 42, "42")
	})
}
