31 changed files with 558 additions and 1475 deletions
--- a/.ci.readme.fmt.sh
+++ b/.ci.readme.fmt.sh
@ -1,12 +0,0 @@
-#!/bin/bash
-
-# Verify that the code snippets in README.md are formatted.
-# The tool https://github.com/hougesen/mdsf is used.
-
-if [ -n "$(mdsf verify --config .mdsf.json --log-level error README.md 2>&1)" ]; then
-  echo "Go code in the README.md is not formatted."
-  echo "Did you forget to run 'mdsf format --config .mdsf.json README.md'?"
-  mdsf format --config .mdsf.json README.md
-  git diff
-  exit 1
-fi
--- a/.github/workflows/main.yml
+++ b/.github/workflows/main.yml
@ -15,10 +15,8 @@ jobs:
        uses: actions/setup-go@v5
        with:
          go-version: ${{ matrix.go_version }}
-      - run: npm install -g mdsf-cli
      - run: ./.ci.gogenerate.sh
      - run: ./.ci.gofmt.sh
-      - run: ./.ci.readme.fmt.sh
      - run: ./.ci.govet.sh
      - run: go test -v -race ./...
  test:
@ -31,7 +29,6 @@ jobs:
          - "1.19"
          - "1.20"
          - "1.21"
-          - "1.22"
    steps:
      - uses: actions/checkout@v4
      - name: Setup Go
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@ -16,6 +16,6 @@ jobs:
        uses: actions/checkout@v4

      - name: Create GitHub release from tag
-        uses: softprops/action-gh-release@v2
+        uses: softprops/action-gh-release@v1
        with:
          generate_release_notes: true
--- a/.gitignore
+++ b/.gitignore
@ -22,9 +22,3 @@ _testmain.go
 *.exe

 .DS_Store
-
-# Output of "go test -c"
-/assert/assert.test
-/require/require.test
-/suite/suite.test
-/mock/mock.test
--- a/.mdsf.json
+++ b/.mdsf.json
@ -1,12 +0,0 @@
-{
-  "$schema": "https://raw.githubusercontent.com/hougesen/mdsf/main/schemas/v0.8.2/mdsf.schema.json",
-  "format_finished_document": false,
-  "languages": {
-    "go": [
-      [
-        "gofmt",
-        "goimports"
-      ]
-    ]
-  }
-}
--- a/MAINTAINERS.md
+++ b/MAINTAINERS.md
@ -6,12 +6,5 @@ pull requests.
  * @boyan-soubachov
  * @dolmen
  * @MovieStoreGuy
-  * @brackendawson
-
-## Approvers
-
-The individuals listed below are active in the project and have the ability to approve pull
-requests.
-
  * @arjunmahishi
-  * @ccoVeille
+  * @brackendawson
--- a/README.md
+++ b/README.md
@ -1,9 +1,7 @@
 Testify - Thou Shalt Write Tests
 ================================

-> [!NOTE]
-> Testify is being maintained at v1, no breaking changes will be accepted in this repo.  
-> [See discussion about v2](https://github.com/stretchr/testify/discussions/1560).
+ℹ️ We are working on testify v2 and would love to hear what you'd like to see in it, have your say here: https://cutt.ly/testify

 [![Build Status](https://github.com/stretchr/testify/actions/workflows/main.yml/badge.svg?branch=master)](https://github.com/stretchr/testify/actions/workflows/main.yml) [![Go Report Card](https://goreportcard.com/badge/github.com/stretchr/testify)](https://goreportcard.com/report/github.com/stretchr/testify) [![PkgGoDev](https://pkg.go.dev/badge/github.com/stretchr/testify)](https://pkg.go.dev/github.com/stretchr/testify)

@ -20,9 +18,10 @@ Get started:
  * Install testify with [one line of code](#installation), or [update it with another](#staying-up-to-date)
  * For an introduction to writing test code in Go, see https://go.dev/doc/code#Testing
  * Check out the API Documentation https://pkg.go.dev/github.com/stretchr/testify
-  * Use [testifylint](https://github.com/Antonboom/testifylint) (via [golangci-lint](https://golangci-lint.run/)) to avoid common mistakes
  * A little about [Test-Driven Development (TDD)](https://en.wikipedia.org/wiki/Test-driven_development)

+
+
 [`assert`](https://pkg.go.dev/github.com/stretchr/testify/assert "API documentation") package
 -------------------------------------------------------------------------------------------

@ -39,11 +38,11 @@ package yours

 import (
  "testing"
-
  "github.com/stretchr/testify/assert"
 )

 func TestSomething(t *testing.T) {
+
  // assert equality
  assert.Equal(t, 123, 123, "they should be equal")

@ -55,10 +54,13 @@ func TestSomething(t *testing.T) {

  // assert for not nil (good when you expect something)
  if assert.NotNil(t, object) {
+
    // now we know that object isn't nil, we are safe to make
    // further assertions without causing any errors
    assert.Equal(t, "Something", object.Value)
+
  }
+
 }
 ```

@ -72,7 +74,6 @@ package yours

 import (
  "testing"
-
  "github.com/stretchr/testify/assert"
 )

@ -90,6 +91,7 @@ func TestSomething(t *testing.T) {

  // assert for not nil (good when you expect something)
  if assert.NotNil(object) {
+
    // now we know that object isn't nil, we are safe to make
    // further assertions without causing any errors
    assert.Equal("Something", object.Value)
@ -118,7 +120,6 @@ package yours

 import (
  "testing"
-
  "github.com/stretchr/testify/mock"
 )

@ -128,7 +129,7 @@ import (

 // MyMockedObject is a mocked object that implements an interface
 // that describes an object that the code I am testing relies on.
-type MyMockedObject struct {
+type MyMockedObject struct{
  mock.Mock
 }

@ -140,8 +141,10 @@ type MyMockedObject struct {
 //
 // NOTE: This method is not being tested here, code that uses this object is.
 func (m *MyMockedObject) DoSomething(number int) (bool, error) {
+
  args := m.Called(number)
  return args.Bool(0), args.Error(1)
+
 }

 /*
@ -151,6 +154,7 @@ func (m *MyMockedObject) DoSomething(number int) (bool, error) {
 // TestSomething is an example of how to use our test object to
 // make assertions about some target code we are testing.
 func TestSomething(t *testing.T) {
+
  // create an instance of our test object
  testObj := new(MyMockedObject)

@ -162,6 +166,8 @@ func TestSomething(t *testing.T) {

  // assert that the expectations were met
  testObj.AssertExpectations(t)
+
+
 }

 // TestSomethingWithPlaceholder is a second example of how to use our test object to
@ -170,6 +176,7 @@ func TestSomething(t *testing.T) {
 // data being passed in is normally dynamically generated and cannot be
 // predicted beforehand (eg. containing hashes that are time sensitive)
 func TestSomethingWithPlaceholder(t *testing.T) {
+
  // create an instance of our test object
  testObj := new(MyMockedObject)

@ -182,11 +189,13 @@ func TestSomethingWithPlaceholder(t *testing.T) {
  // assert that the expectations were met
  testObj.AssertExpectations(t)

+
 }

 // TestSomethingElse2 is a third example that shows how you can use
 // the Unset method to cleanup handlers and then add new ones.
 func TestSomethingElse2(t *testing.T) {
+
  // create an instance of our test object
  testObj := new(MyMockedObject)

@ -215,8 +224,6 @@ You can use the [mockery tool](https://vektra.github.io/mockery/latest/) to auto

 [`suite`](https://pkg.go.dev/github.com/stretchr/testify/suite "API documentation") package
 -----------------------------------------------------------------------------------------
-> [!WARNING]
-> The suite package does not support parallel tests. See [#934](https://github.com/stretchr/testify/issues/934).

 The `suite` package provides functionality that you might be used to from more common object-oriented languages.  With it, you can build a testing suite as a struct, build setup/teardown methods and testing methods on your struct, and run them with 'go test' as per normal.

@ -226,7 +233,6 @@ An example suite is shown below:
 // Basic imports
 import (
    "testing"
-
    "github.com/stretchr/testify/assert"
    "github.com/stretchr/testify/suite"
 )
@ -268,7 +274,6 @@ For more information on writing suites, check out the [API documentation for the
 // Basic imports
 import (
    "testing"
-
    "github.com/stretchr/testify/suite"
 )

@ -322,12 +327,13 @@ package yours

 import (
  "testing"
-
  "github.com/stretchr/testify/assert"
 )

 func TestSomething(t *testing.T) {
+
  assert.True(t, true, "True is true!")
+
 }
 ```

--- a/_codegen/main.go
+++ b/_codegen/main.go
@ -16,6 +16,7 @@ import (
 	"go/token"
 	"go/types"
 	"io"
+	"io/ioutil"
 	"log"
 	"os"
 	"path"
@ -100,15 +101,13 @@ func parseTemplates() (*template.Template, *template.Template, error) {
 		return nil, nil, err
 	}
 	if *tmplFile != "" {
-		f, err := os.ReadFile(*tmplFile)
+		f, err := ioutil.ReadFile(*tmplFile)
 		if err != nil {
 			return nil, nil, err
 		}
 		funcTemplate = string(f)
 	}
-	tmpl, err := template.New("function").Funcs(template.FuncMap{
-		"replace": strings.ReplaceAll,
-	}).Parse(funcTemplate)
+	tmpl, err := template.New("function").Parse(funcTemplate)
 	if err != nil {
 		return nil, nil, err
 	}
@ -182,7 +181,7 @@ func parsePackageSource(pkg string) (*types.Scope, *doc.Package, error) {
 	files := make(map[string]*ast.File)
 	fileList := make([]*ast.File, len(pd.GoFiles))
 	for i, fname := range pd.GoFiles {
-		src, err := os.ReadFile(path.Join(pd.Dir, fname))
+		src, err := ioutil.ReadFile(path.Join(pd.Dir, fname))
 		if err != nil {
 			return nil, nil, err
 		}
--- a/assert/assertion_compare.go
+++ b/assert/assertion_compare.go
@ -7,13 +7,10 @@ import (
 	"time"
 )

-// Deprecated: CompareType has only ever been for internal use and has accidentally been published since v1.6.0. Do not use it.
-type CompareType = compareResult
-
-type compareResult int
+type CompareType int

 const (
-	compareLess compareResult = iota - 1
+	compareLess CompareType = iota - 1
 	compareEqual
 	compareGreater
 )
@ -42,7 +39,7 @@ var (
 	bytesType = reflect.TypeOf([]byte{})
 )

-func compare(obj1, obj2 interface{}, kind reflect.Kind) (compareResult, bool) {
+func compare(obj1, obj2 interface{}, kind reflect.Kind) (CompareType, bool) {
 	obj1Value := reflect.ValueOf(obj1)
 	obj2Value := reflect.ValueOf(obj2)

@ -328,13 +325,7 @@ func compare(obj1, obj2 interface{}, kind reflect.Kind) (compareResult, bool) {
 				timeObj2 = obj2Value.Convert(timeType).Interface().(time.Time)
 			}

-			if timeObj1.Before(timeObj2) {
-				return compareLess, true
-			}
-			if timeObj1.Equal(timeObj2) {
-				return compareEqual, true
-			}
-			return compareGreater, true
+			return compare(timeObj1.UnixNano(), timeObj2.UnixNano(), reflect.Int64)
 		}
 	case reflect.Slice:
 		{
@ -354,7 +345,7 @@ func compare(obj1, obj2 interface{}, kind reflect.Kind) (compareResult, bool) {
 				bytesObj2 = obj2Value.Convert(bytesType).Interface().([]byte)
 			}

-			return compareResult(bytes.Compare(bytesObj1, bytesObj2)), true
+			return CompareType(bytes.Compare(bytesObj1, bytesObj2)), true
 		}
 	case reflect.Uintptr:
 		{
@ -390,8 +381,7 @@ func Greater(t TestingT, e1 interface{}, e2 interface{}, msgAndArgs ...interface
 	if h, ok := t.(tHelper); ok {
 		h.Helper()
 	}
-	failMessage := fmt.Sprintf("\"%v\" is not greater than \"%v\"", e1, e2)
-	return compareTwoValues(t, e1, e2, []compareResult{compareGreater}, failMessage, msgAndArgs...)
+	return compareTwoValues(t, e1, e2, []CompareType{compareGreater}, "\"%v\" is not greater than \"%v\"", msgAndArgs...)
 }

 // GreaterOrEqual asserts that the first element is greater than or equal to the second
@ -404,8 +394,7 @@ func GreaterOrEqual(t TestingT, e1 interface{}, e2 interface{}, msgAndArgs ...in
 	if h, ok := t.(tHelper); ok {
 		h.Helper()
 	}
-	failMessage := fmt.Sprintf("\"%v\" is not greater than or equal to \"%v\"", e1, e2)
-	return compareTwoValues(t, e1, e2, []compareResult{compareGreater, compareEqual}, failMessage, msgAndArgs...)
+	return compareTwoValues(t, e1, e2, []CompareType{compareGreater, compareEqual}, "\"%v\" is not greater than or equal to \"%v\"", msgAndArgs...)
 }

 // Less asserts that the first element is less than the second
@ -417,8 +406,7 @@ func Less(t TestingT, e1 interface{}, e2 interface{}, msgAndArgs ...interface{})
 	if h, ok := t.(tHelper); ok {
 		h.Helper()
 	}
-	failMessage := fmt.Sprintf("\"%v\" is not less than \"%v\"", e1, e2)
-	return compareTwoValues(t, e1, e2, []compareResult{compareLess}, failMessage, msgAndArgs...)
+	return compareTwoValues(t, e1, e2, []CompareType{compareLess}, "\"%v\" is not less than \"%v\"", msgAndArgs...)
 }

 // LessOrEqual asserts that the first element is less than or equal to the second
@ -431,8 +419,7 @@ func LessOrEqual(t TestingT, e1 interface{}, e2 interface{}, msgAndArgs ...inter
 	if h, ok := t.(tHelper); ok {
 		h.Helper()
 	}
-	failMessage := fmt.Sprintf("\"%v\" is not less than or equal to \"%v\"", e1, e2)
-	return compareTwoValues(t, e1, e2, []compareResult{compareLess, compareEqual}, failMessage, msgAndArgs...)
+	return compareTwoValues(t, e1, e2, []CompareType{compareLess, compareEqual}, "\"%v\" is not less than or equal to \"%v\"", msgAndArgs...)
 }

 // Positive asserts that the specified element is positive
@ -444,8 +431,7 @@ func Positive(t TestingT, e interface{}, msgAndArgs ...interface{}) bool {
 		h.Helper()
 	}
 	zero := reflect.Zero(reflect.TypeOf(e))
-	failMessage := fmt.Sprintf("\"%v\" is not positive", e)
-	return compareTwoValues(t, e, zero.Interface(), []compareResult{compareGreater}, failMessage, msgAndArgs...)
+	return compareTwoValues(t, e, zero.Interface(), []CompareType{compareGreater}, "\"%v\" is not positive", msgAndArgs...)
 }

 // Negative asserts that the specified element is negative
@ -457,11 +443,10 @@ func Negative(t TestingT, e interface{}, msgAndArgs ...interface{}) bool {
 		h.Helper()
 	}
 	zero := reflect.Zero(reflect.TypeOf(e))
-	failMessage := fmt.Sprintf("\"%v\" is not negative", e)
-	return compareTwoValues(t, e, zero.Interface(), []compareResult{compareLess}, failMessage, msgAndArgs...)
+	return compareTwoValues(t, e, zero.Interface(), []CompareType{compareLess}, "\"%v\" is not negative", msgAndArgs...)
 }

-func compareTwoValues(t TestingT, e1 interface{}, e2 interface{}, allowedComparesResults []compareResult, failMessage string, msgAndArgs ...interface{}) bool {
+func compareTwoValues(t TestingT, e1 interface{}, e2 interface{}, allowedComparesResults []CompareType, failMessage string, msgAndArgs ...interface{}) bool {
 	if h, ok := t.(tHelper); ok {
 		h.Helper()
 	}
@ -474,17 +459,17 @@ func compareTwoValues(t TestingT, e1 interface{}, e2 interface{}, allowedCompare

 	compareResult, isComparable := compare(e1, e2, e1Kind)
 	if !isComparable {
-		return Fail(t, fmt.Sprintf(`Can not compare type "%T"`, e1), msgAndArgs...)
+		return Fail(t, fmt.Sprintf("Can not compare type \"%s\"", reflect.TypeOf(e1)), msgAndArgs...)
 	}

 	if !containsValue(allowedComparesResults, compareResult) {
-		return Fail(t, failMessage, msgAndArgs...)
+		return Fail(t, fmt.Sprintf(failMessage, e1, e2), msgAndArgs...)
 	}

 	return true
 }

-func containsValue(values []compareResult, value compareResult) bool {
+func containsValue(values []CompareType, value CompareType) bool {
 	for _, v := range values {
 		if v == value {
 			return true
--- a/assert/assertion_compare_test.go
+++ b/assert/assertion_compare_test.go
@ -59,7 +59,6 @@ func TestCompare(t *testing.T) {
 		{less: uintptr(1), greater: uintptr(2), cType: "uintptr"},
 		{less: customUintptr(1), greater: customUintptr(2), cType: "uint64"},
 		{less: time.Now(), greater: time.Now().Add(time.Hour), cType: "time.Time"},
-		{less: time.Date(2024, 0, 0, 0, 0, 0, 0, time.Local), greater: time.Date(2263, 0, 0, 0, 0, 0, 0, time.Local), cType: "time.Time"},
 		{less: customTime(time.Now()), greater: customTime(time.Now().Add(time.Hour)), cType: "time.Time"},
 		{less: []byte{1, 1}, greater: []byte{1, 2}, cType: "[]byte"},
 		{less: customBytes([]byte{1, 1}), greater: customBytes([]byte{1, 2}), cType: "[]byte"},
@ -393,8 +392,8 @@ func Test_compareTwoValuesDifferentValuesTypes(t *testing.T) {
 		{v1: float64(12), v2: "123"},
 		{v1: "float(12)", v2: float64(1)},
 	} {
-		result := compareTwoValues(mockT, currCase.v1, currCase.v2, []compareResult{compareLess, compareEqual, compareGreater}, "testFailMessage")
-		False(t, result)
+		compareResult := compareTwoValues(mockT, currCase.v1, currCase.v2, []CompareType{compareLess, compareEqual, compareGreater}, "testFailMessage")
+		False(t, compareResult)
 	}
 }

@ -412,8 +411,8 @@ func Test_compareTwoValuesNotComparableValues(t *testing.T) {
 		{v1: map[string]int{}, v2: map[string]int{}},
 		{v1: make([]int, 5), v2: make([]int, 5)},
 	} {
-		result := compareTwoValues(mockT, currCase.v1, currCase.v2, []compareResult{compareLess, compareEqual, compareGreater}, "testFailMessage")
-		False(t, result)
+		compareResult := compareTwoValues(mockT, currCase.v1, currCase.v2, []CompareType{compareLess, compareEqual, compareGreater}, "testFailMessage")
+		False(t, compareResult)
 	}
 }

@ -423,33 +422,33 @@ func Test_compareTwoValuesCorrectCompareResult(t *testing.T) {
 	for _, currCase := range []struct {
 		v1           interface{}
 		v2           interface{}
-		allowedResults []compareResult
+		compareTypes []CompareType
 	}{
-		{v1: 1, v2: 2, allowedResults: []compareResult{compareLess}},
-		{v1: 1, v2: 2, allowedResults: []compareResult{compareLess, compareEqual}},
-		{v1: 2, v2: 2, allowedResults: []compareResult{compareGreater, compareEqual}},
-		{v1: 2, v2: 2, allowedResults: []compareResult{compareEqual}},
-		{v1: 2, v2: 1, allowedResults: []compareResult{compareEqual, compareGreater}},
-		{v1: 2, v2: 1, allowedResults: []compareResult{compareGreater}},
+		{v1: 1, v2: 2, compareTypes: []CompareType{compareLess}},
+		{v1: 1, v2: 2, compareTypes: []CompareType{compareLess, compareEqual}},
+		{v1: 2, v2: 2, compareTypes: []CompareType{compareGreater, compareEqual}},
+		{v1: 2, v2: 2, compareTypes: []CompareType{compareEqual}},
+		{v1: 2, v2: 1, compareTypes: []CompareType{compareEqual, compareGreater}},
+		{v1: 2, v2: 1, compareTypes: []CompareType{compareGreater}},
 	} {
-		result := compareTwoValues(mockT, currCase.v1, currCase.v2, currCase.allowedResults, "testFailMessage")
-		True(t, result)
+		compareResult := compareTwoValues(mockT, currCase.v1, currCase.v2, currCase.compareTypes, "testFailMessage")
+		True(t, compareResult)
 	}
 }

 func Test_containsValue(t *testing.T) {
 	for _, currCase := range []struct {
-		values []compareResult
-		value  compareResult
+		values []CompareType
+		value  CompareType
 		result bool
 	}{
-		{values: []compareResult{compareGreater}, value: compareGreater, result: true},
-		{values: []compareResult{compareGreater, compareLess}, value: compareGreater, result: true},
-		{values: []compareResult{compareGreater, compareLess}, value: compareLess, result: true},
-		{values: []compareResult{compareGreater, compareLess}, value: compareEqual, result: false},
+		{values: []CompareType{compareGreater}, value: compareGreater, result: true},
+		{values: []CompareType{compareGreater, compareLess}, value: compareGreater, result: true},
+		{values: []CompareType{compareGreater, compareLess}, value: compareLess, result: true},
+		{values: []CompareType{compareGreater, compareLess}, value: compareEqual, result: false},
 	} {
-		result := containsValue(currCase.values, currCase.value)
-		Equal(t, currCase.result, result)
+		compareResult := containsValue(currCase.values, currCase.value)
+		Equal(t, currCase.result, compareResult)
 	}
 }

--- a/assert/assertion_format.go
+++ b/assert/assertion_format.go
@ -104,8 +104,8 @@ func EqualExportedValuesf(t TestingT, expected interface{}, actual interface{},
 	return EqualExportedValues(t, expected, actual, append([]interface{}{msg}, args...)...)
 }

-// EqualValuesf asserts that two objects are equal or convertible to the larger
-// type and equal.
+// EqualValuesf asserts that two objects are equal or convertible to the same types
+// and equal.
 //
 //	assert.EqualValuesf(t, uint32(123), int32(123), "error message %s", "formatted")
 func EqualValuesf(t TestingT, expected interface{}, actual interface{}, msg string, args ...interface{}) bool {
@ -186,7 +186,7 @@ func Eventuallyf(t TestingT, condition func() bool, waitFor time.Duration, tick
 //	assert.EventuallyWithTf(t, func(c *assert.CollectT, "error message %s", "formatted") {
 //		// add assertions as needed; any assertion failure will fail the current tick
 //		assert.True(c, externalValue, "expected 'externalValue' to be true")
-//	}, 10*time.Second, 1*time.Second, "external state has not changed to 'true'; still false")
+//	}, 1*time.Second, 10*time.Second, "external state has not changed to 'true'; still false")
 func EventuallyWithTf(t TestingT, condition func(collect *CollectT), waitFor time.Duration, tick time.Duration, msg string, args ...interface{}) bool {
 	if h, ok := t.(tHelper); ok {
 		h.Helper()
@ -568,23 +568,6 @@ func NotContainsf(t TestingT, s interface{}, contains interface{}, msg string, a
 	return NotContains(t, s, contains, append([]interface{}{msg}, args...)...)
 }

-// NotElementsMatchf asserts that the specified listA(array, slice...) is NOT equal to specified
-// listB(array, slice...) ignoring the order of the elements. If there are duplicate elements,
-// the number of appearances of each of them in both lists should not match.
-// This is an inverse of ElementsMatch.
-//
-// assert.NotElementsMatchf(t, [1, 1, 2, 3], [1, 1, 2, 3], "error message %s", "formatted") -> false
-//
-// assert.NotElementsMatchf(t, [1, 1, 2, 3], [1, 2, 3], "error message %s", "formatted") -> true
-//
-// assert.NotElementsMatchf(t, [1, 2, 3], [1, 2, 4], "error message %s", "formatted") -> true
-func NotElementsMatchf(t TestingT, listA interface{}, listB interface{}, msg string, args ...interface{}) bool {
-	if h, ok := t.(tHelper); ok {
-		h.Helper()
-	}
-	return NotElementsMatch(t, listA, listB, append([]interface{}{msg}, args...)...)
-}
-
 // NotEmptyf asserts that the specified object is NOT empty.  I.e. not nil, "", false, 0 or either
 // a slice or a channel with len == 0.
 //
@ -621,16 +604,7 @@ func NotEqualValuesf(t TestingT, expected interface{}, actual interface{}, msg s
 	return NotEqualValues(t, expected, actual, append([]interface{}{msg}, args...)...)
 }

-// NotErrorAsf asserts that none of the errors in err's chain matches target,
-// but if so, sets target to that error value.
-func NotErrorAsf(t TestingT, err error, target interface{}, msg string, args ...interface{}) bool {
-	if h, ok := t.(tHelper); ok {
-		h.Helper()
-	}
-	return NotErrorAs(t, err, target, append([]interface{}{msg}, args...)...)
-}
-
-// NotErrorIsf asserts that none of the errors in err's chain matches target.
+// NotErrorIsf asserts that at none of the errors in err's chain matches target.
 // This is a wrapper for errors.Is.
 func NotErrorIsf(t TestingT, err error, target error, msg string, args ...interface{}) bool {
 	if h, ok := t.(tHelper); ok {
--- a/assert/assertion_forward.go
+++ b/assert/assertion_forward.go
@ -186,8 +186,8 @@ func (a *Assertions) EqualExportedValuesf(expected interface{}, actual interface
 	return EqualExportedValuesf(a.t, expected, actual, msg, args...)
 }

-// EqualValues asserts that two objects are equal or convertible to the larger
-// type and equal.
+// EqualValues asserts that two objects are equal or convertible to the same types
+// and equal.
 //
 //	a.EqualValues(uint32(123), int32(123))
 func (a *Assertions) EqualValues(expected interface{}, actual interface{}, msgAndArgs ...interface{}) bool {
@ -197,8 +197,8 @@ func (a *Assertions) EqualValues(expected interface{}, actual interface{}, msgAn
 	return EqualValues(a.t, expected, actual, msgAndArgs...)
 }

-// EqualValuesf asserts that two objects are equal or convertible to the larger
-// type and equal.
+// EqualValuesf asserts that two objects are equal or convertible to the same types
+// and equal.
 //
 //	a.EqualValuesf(uint32(123), int32(123), "error message %s", "formatted")
 func (a *Assertions) EqualValuesf(expected interface{}, actual interface{}, msg string, args ...interface{}) bool {
@ -336,7 +336,7 @@ func (a *Assertions) Eventually(condition func() bool, waitFor time.Duration, ti
 //	a.EventuallyWithT(func(c *assert.CollectT) {
 //		// add assertions as needed; any assertion failure will fail the current tick
 //		assert.True(c, externalValue, "expected 'externalValue' to be true")
-//	}, 10*time.Second, 1*time.Second, "external state has not changed to 'true'; still false")
+//	}, 1*time.Second, 10*time.Second, "external state has not changed to 'true'; still false")
 func (a *Assertions) EventuallyWithT(condition func(collect *CollectT), waitFor time.Duration, tick time.Duration, msgAndArgs ...interface{}) bool {
 	if h, ok := a.t.(tHelper); ok {
 		h.Helper()
@ -361,7 +361,7 @@ func (a *Assertions) EventuallyWithT(condition func(collect *CollectT), waitFor
 //	a.EventuallyWithTf(func(c *assert.CollectT, "error message %s", "formatted") {
 //		// add assertions as needed; any assertion failure will fail the current tick
 //		assert.True(c, externalValue, "expected 'externalValue' to be true")
-//	}, 10*time.Second, 1*time.Second, "external state has not changed to 'true'; still false")
+//	}, 1*time.Second, 10*time.Second, "external state has not changed to 'true'; still false")
 func (a *Assertions) EventuallyWithTf(condition func(collect *CollectT), waitFor time.Duration, tick time.Duration, msg string, args ...interface{}) bool {
 	if h, ok := a.t.(tHelper); ok {
 		h.Helper()
@ -1128,40 +1128,6 @@ func (a *Assertions) NotContainsf(s interface{}, contains interface{}, msg strin
 	return NotContainsf(a.t, s, contains, msg, args...)
 }

-// NotElementsMatch asserts that the specified listA(array, slice...) is NOT equal to specified
-// listB(array, slice...) ignoring the order of the elements. If there are duplicate elements,
-// the number of appearances of each of them in both lists should not match.
-// This is an inverse of ElementsMatch.
-//
-// a.NotElementsMatch([1, 1, 2, 3], [1, 1, 2, 3]) -> false
-//
-// a.NotElementsMatch([1, 1, 2, 3], [1, 2, 3]) -> true
-//
-// a.NotElementsMatch([1, 2, 3], [1, 2, 4]) -> true
-func (a *Assertions) NotElementsMatch(listA interface{}, listB interface{}, msgAndArgs ...interface{}) bool {
-	if h, ok := a.t.(tHelper); ok {
-		h.Helper()
-	}
-	return NotElementsMatch(a.t, listA, listB, msgAndArgs...)
-}
-
-// NotElementsMatchf asserts that the specified listA(array, slice...) is NOT equal to specified
-// listB(array, slice...) ignoring the order of the elements. If there are duplicate elements,
-// the number of appearances of each of them in both lists should not match.
-// This is an inverse of ElementsMatch.
-//
-// a.NotElementsMatchf([1, 1, 2, 3], [1, 1, 2, 3], "error message %s", "formatted") -> false
-//
-// a.NotElementsMatchf([1, 1, 2, 3], [1, 2, 3], "error message %s", "formatted") -> true
-//
-// a.NotElementsMatchf([1, 2, 3], [1, 2, 4], "error message %s", "formatted") -> true
-func (a *Assertions) NotElementsMatchf(listA interface{}, listB interface{}, msg string, args ...interface{}) bool {
-	if h, ok := a.t.(tHelper); ok {
-		h.Helper()
-	}
-	return NotElementsMatchf(a.t, listA, listB, msg, args...)
-}
-
 // NotEmpty asserts that the specified object is NOT empty.  I.e. not nil, "", false, 0 or either
 // a slice or a channel with len == 0.
 //
@ -1234,25 +1200,7 @@ func (a *Assertions) NotEqualf(expected interface{}, actual interface{}, msg str
 	return NotEqualf(a.t, expected, actual, msg, args...)
 }

-// NotErrorAs asserts that none of the errors in err's chain matches target,
-// but if so, sets target to that error value.
-func (a *Assertions) NotErrorAs(err error, target interface{}, msgAndArgs ...interface{}) bool {
-	if h, ok := a.t.(tHelper); ok {
-		h.Helper()
-	}
-	return NotErrorAs(a.t, err, target, msgAndArgs...)
-}
-
-// NotErrorAsf asserts that none of the errors in err's chain matches target,
-// but if so, sets target to that error value.
-func (a *Assertions) NotErrorAsf(err error, target interface{}, msg string, args ...interface{}) bool {
-	if h, ok := a.t.(tHelper); ok {
-		h.Helper()
-	}
-	return NotErrorAsf(a.t, err, target, msg, args...)
-}
-
-// NotErrorIs asserts that none of the errors in err's chain matches target.
+// NotErrorIs asserts that at none of the errors in err's chain matches target.
 // This is a wrapper for errors.Is.
 func (a *Assertions) NotErrorIs(err error, target error, msgAndArgs ...interface{}) bool {
 	if h, ok := a.t.(tHelper); ok {
@ -1261,7 +1209,7 @@ func (a *Assertions) NotErrorIs(err error, target error, msgAndArgs ...interface
 	return NotErrorIs(a.t, err, target, msgAndArgs...)
 }

-// NotErrorIsf asserts that none of the errors in err's chain matches target.
+// NotErrorIsf asserts that at none of the errors in err's chain matches target.
 // This is a wrapper for errors.Is.
 func (a *Assertions) NotErrorIsf(err error, target error, msg string, args ...interface{}) bool {
 	if h, ok := a.t.(tHelper); ok {
--- a/assert/assertion_order.go
+++ b/assert/assertion_order.go
@ -6,7 +6,7 @@ import (
 )

 // isOrdered checks that collection contains orderable elements.
-func isOrdered(t TestingT, object interface{}, allowedComparesResults []compareResult, failMessage string, msgAndArgs ...interface{}) bool {
+func isOrdered(t TestingT, object interface{}, allowedComparesResults []CompareType, failMessage string, msgAndArgs ...interface{}) bool {
 	objKind := reflect.TypeOf(object).Kind()
 	if objKind != reflect.Slice && objKind != reflect.Array {
 		return false
@ -33,7 +33,7 @@ func isOrdered(t TestingT, object interface{}, allowedComparesResults []compareR
 		compareResult, isComparable := compare(prevValueInterface, valueInterface, firstValueKind)

 		if !isComparable {
-			return Fail(t, fmt.Sprintf(`Can not compare type "%T" and "%T"`, value, prevValue), msgAndArgs...)
+			return Fail(t, fmt.Sprintf("Can not compare type \"%s\" and \"%s\"", reflect.TypeOf(value), reflect.TypeOf(prevValue)), msgAndArgs...)
 		}

 		if !containsValue(allowedComparesResults, compareResult) {
@ -50,7 +50,7 @@ func isOrdered(t TestingT, object interface{}, allowedComparesResults []compareR
 //	assert.IsIncreasing(t, []float{1, 2})
 //	assert.IsIncreasing(t, []string{"a", "b"})
 func IsIncreasing(t TestingT, object interface{}, msgAndArgs ...interface{}) bool {
-	return isOrdered(t, object, []compareResult{compareLess}, "\"%v\" is not less than \"%v\"", msgAndArgs...)
+	return isOrdered(t, object, []CompareType{compareLess}, "\"%v\" is not less than \"%v\"", msgAndArgs...)
 }

 // IsNonIncreasing asserts that the collection is not increasing
@ -59,7 +59,7 @@ func IsIncreasing(t TestingT, object interface{}, msgAndArgs ...interface{}) boo
 //	assert.IsNonIncreasing(t, []float{2, 1})
 //	assert.IsNonIncreasing(t, []string{"b", "a"})
 func IsNonIncreasing(t TestingT, object interface{}, msgAndArgs ...interface{}) bool {
-	return isOrdered(t, object, []compareResult{compareEqual, compareGreater}, "\"%v\" is not greater than or equal to \"%v\"", msgAndArgs...)
+	return isOrdered(t, object, []CompareType{compareEqual, compareGreater}, "\"%v\" is not greater than or equal to \"%v\"", msgAndArgs...)
 }

 // IsDecreasing asserts that the collection is decreasing
@ -68,7 +68,7 @@ func IsNonIncreasing(t TestingT, object interface{}, msgAndArgs ...interface{})
 //	assert.IsDecreasing(t, []float{2, 1})
 //	assert.IsDecreasing(t, []string{"b", "a"})
 func IsDecreasing(t TestingT, object interface{}, msgAndArgs ...interface{}) bool {
-	return isOrdered(t, object, []compareResult{compareGreater}, "\"%v\" is not greater than \"%v\"", msgAndArgs...)
+	return isOrdered(t, object, []CompareType{compareGreater}, "\"%v\" is not greater than \"%v\"", msgAndArgs...)
 }

 // IsNonDecreasing asserts that the collection is not decreasing
@ -77,5 +77,5 @@ func IsDecreasing(t TestingT, object interface{}, msgAndArgs ...interface{}) boo
 //	assert.IsNonDecreasing(t, []float{1, 2})
 //	assert.IsNonDecreasing(t, []string{"a", "b"})
 func IsNonDecreasing(t TestingT, object interface{}, msgAndArgs ...interface{}) bool {
-	return isOrdered(t, object, []compareResult{compareLess, compareEqual}, "\"%v\" is not less than or equal to \"%v\"", msgAndArgs...)
+	return isOrdered(t, object, []CompareType{compareLess, compareEqual}, "\"%v\" is not less than or equal to \"%v\"", msgAndArgs...)
 }
--- a/assert/assertions.go
+++ b/assert/assertions.go
@ -19,13 +19,9 @@ import (

 	"github.com/davecgh/go-spew/spew"
 	"github.com/pmezard/go-difflib/difflib"
-
-	// Wrapper around gopkg.in/yaml.v3
-	"github.com/stretchr/testify/assert/yaml"
+	"gopkg.in/yaml.v3"
 )

-const stackFrameBufferSize = 10
-
 //go:generate sh -c "cd ../_codegen && go build && cd - && ../_codegen/_codegen -output-package=assert -template=assertion_format.go.tmpl"

 // TestingT is an interface wrapper around *testing.T
@ -49,10 +45,6 @@ type BoolAssertionFunc func(TestingT, bool, ...interface{}) bool
 // for table driven tests.
 type ErrorAssertionFunc func(TestingT, error, ...interface{}) bool

-// PanicAssertionFunc is a common function prototype when validating a panic value.  Can be useful
-// for table driven tests.
-type PanicAssertionFunc = func(t TestingT, f PanicTestFunc, msgAndArgs ...interface{}) bool
-
 // Comparison is a custom function that returns true on success and false on failure
 type Comparison func() (success bool)

@ -214,29 +206,20 @@ the problem actually occurred in calling code.*/
 func CallerInfo() []string {

 	var pc uintptr
+	var ok bool
 	var file string
 	var line int
 	var name string

 	callers := []string{}
-	pcs := make([]uintptr, stackFrameBufferSize)
-	offset := 1
-
-	for {
-		n := runtime.Callers(offset, pcs)
-
-		if n == 0 {
+	for i := 0; ; i++ {
+		pc, file, line, ok = runtime.Caller(i)
+		if !ok {
+			// The breaks below failed to terminate the loop, and we ran off the
+			// end of the call stack.
 			break
 		}

-		frames := runtime.CallersFrames(pcs[:n])
-
-		for {
-			frame, more := frames.Next()
-			pc = frame.PC
-			file = frame.File
-			line = frame.Line
-
 		// This is a huge edge case, but it will panic if this is the case, see #180
 		if file == "<autogenerated>" {
 			break
@ -274,13 +257,6 @@ func CallerInfo() []string {
 			isTest(name, "Example") {
 			break
 		}
-			if !more {
-				break
-			}
-		}
-		// We know we already have less than a buffer's worth of frames
-		offset += stackFrameBufferSize
-
 	}

 	return callers
@ -462,7 +438,7 @@ func IsType(t TestingT, expectedType interface{}, object interface{}, msgAndArgs
 	}

 	if !ObjectsAreEqual(reflect.TypeOf(object), reflect.TypeOf(expectedType)) {
-		return Fail(t, fmt.Sprintf("Object expected to be of type %T, but was %T", expectedType, object), msgAndArgs...)
+		return Fail(t, fmt.Sprintf("Object expected to be of type %v, but was %v", reflect.TypeOf(expectedType), reflect.TypeOf(object)), msgAndArgs...)
 	}

 	return true
@ -520,13 +496,7 @@ func Same(t TestingT, expected, actual interface{}, msgAndArgs ...interface{}) b
 		h.Helper()
 	}

-	same, ok := samePointers(expected, actual)
-	if !ok {
-		return Fail(t, "Both arguments must be pointers", msgAndArgs...)
-	}
-
-	if !same {
-		// both are pointers but not the same type & pointing to the same address
+	if !samePointers(expected, actual) {
 		return Fail(t, fmt.Sprintf("Not same: \n"+
 			"expected: %p %#v\n"+
 			"actual  : %p %#v", expected, expected, actual, actual), msgAndArgs...)
@ -546,13 +516,7 @@ func NotSame(t TestingT, expected, actual interface{}, msgAndArgs ...interface{}
 		h.Helper()
 	}

-	same, ok := samePointers(expected, actual)
-	if !ok {
-		//fails when the arguments are not pointers
-		return !(Fail(t, "Both arguments must be pointers", msgAndArgs...))
-	}
-
-	if same {
+	if samePointers(expected, actual) {
 		return Fail(t, fmt.Sprintf(
 			"Expected and actual point to the same object: %p %#v",
 			expected, expected), msgAndArgs...)
@ -560,23 +524,21 @@ func NotSame(t TestingT, expected, actual interface{}, msgAndArgs ...interface{}
 	return true
 }

-// samePointers checks if two generic interface objects are pointers of the same
-// type pointing to the same object. It returns two values: same indicating if
-// they are the same type and point to the same object, and ok indicating that
-// both inputs are pointers.
-func samePointers(first, second interface{}) (same bool, ok bool) {
+// samePointers compares two generic interface objects and returns whether
+// they point to the same object
+func samePointers(first, second interface{}) bool {
 	firstPtr, secondPtr := reflect.ValueOf(first), reflect.ValueOf(second)
 	if firstPtr.Kind() != reflect.Ptr || secondPtr.Kind() != reflect.Ptr {
-		return false, false //not both are pointers
+		return false
 	}

 	firstType, secondType := reflect.TypeOf(first), reflect.TypeOf(second)
 	if firstType != secondType {
-		return false, true // both are pointers, but of different types
+		return false
 	}

 	// compare pointer addresses
-	return first == second, true
+	return first == second
 }

 // formatUnequalValues takes two values of arbitrary types and returns string
@ -610,8 +572,8 @@ func truncatingFormat(data interface{}) string {
 	return value
 }

-// EqualValues asserts that two objects are equal or convertible to the larger
-// type and equal.
+// EqualValues asserts that two objects are equal or convertible to the same types
+// and equal.
 //
 //	assert.EqualValues(t, uint32(123), int32(123))
 func EqualValues(t TestingT, expected, actual interface{}, msgAndArgs ...interface{}) bool {
@ -653,6 +615,21 @@ func EqualExportedValues(t TestingT, expected, actual interface{}, msgAndArgs ..
 		return Fail(t, fmt.Sprintf("Types expected to match exactly\n\t%v != %v", aType, bType), msgAndArgs...)
 	}

+	if aType.Kind() == reflect.Ptr {
+		aType = aType.Elem()
+	}
+	if bType.Kind() == reflect.Ptr {
+		bType = bType.Elem()
+	}
+
+	if aType.Kind() != reflect.Struct {
+		return Fail(t, fmt.Sprintf("Types expected to both be struct or pointer to struct \n\t%v != %v", aType.Kind(), reflect.Struct), msgAndArgs...)
+	}
+
+	if bType.Kind() != reflect.Struct {
+		return Fail(t, fmt.Sprintf("Types expected to both be struct or pointer to struct \n\t%v != %v", bType.Kind(), reflect.Struct), msgAndArgs...)
+	}
+
 	expected = copyExportedFields(expected)
 	actual = copyExportedFields(actual)

@ -1087,7 +1064,7 @@ func NotSubset(t TestingT, list, subset interface{}, msgAndArgs ...interface{})
 		element := subsetList.Index(i).Interface()
 		ok, found := containsElement(list, element)
 		if !ok {
-			return Fail(t, fmt.Sprintf("%q could not be applied builtin len()", list), msgAndArgs...)
+			return Fail(t, fmt.Sprintf("\"%s\" could not be applied builtin len()", list), msgAndArgs...)
 		}
 		if !found {
 			return true
@ -1193,39 +1170,6 @@ func formatListDiff(listA, listB interface{}, extraA, extraB []interface{}) stri
 	return msg.String()
 }

-// NotElementsMatch asserts that the specified listA(array, slice...) is NOT equal to specified
-// listB(array, slice...) ignoring the order of the elements. If there are duplicate elements,
-// the number of appearances of each of them in both lists should not match.
-// This is an inverse of ElementsMatch.
-//
-// assert.NotElementsMatch(t, [1, 1, 2, 3], [1, 1, 2, 3]) -> false
-//
-// assert.NotElementsMatch(t, [1, 1, 2, 3], [1, 2, 3]) -> true
-//
-// assert.NotElementsMatch(t, [1, 2, 3], [1, 2, 4]) -> true
-func NotElementsMatch(t TestingT, listA, listB interface{}, msgAndArgs ...interface{}) (ok bool) {
-	if h, ok := t.(tHelper); ok {
-		h.Helper()
-	}
-	if isEmpty(listA) && isEmpty(listB) {
-		return Fail(t, "listA and listB contain the same elements", msgAndArgs)
-	}
-
-	if !isList(t, listA, msgAndArgs...) {
-		return Fail(t, "listA is not a list type", msgAndArgs...)
-	}
-	if !isList(t, listB, msgAndArgs...) {
-		return Fail(t, "listB is not a list type", msgAndArgs...)
-	}
-
-	extraA, extraB := diffLists(listA, listB)
-	if len(extraA) == 0 && len(extraB) == 0 {
-		return Fail(t, "listA and listB contain the same elements", msgAndArgs)
-	}
-
-	return true
-}
-
 // Condition uses a Comparison to assert a complex condition.
 func Condition(t TestingT, comp Comparison, msgAndArgs ...interface{}) bool {
 	if h, ok := t.(tHelper); ok {
@ -1544,9 +1488,6 @@ func InEpsilon(t TestingT, expected, actual interface{}, epsilon float64, msgAnd
 	if err != nil {
 		return Fail(t, err.Error(), msgAndArgs...)
 	}
-	if math.IsNaN(actualEpsilon) {
-		return Fail(t, "relative error is NaN", msgAndArgs...)
-	}
 	if actualEpsilon > epsilon {
 		return Fail(t, fmt.Sprintf("Relative error is too high: %#v (expected)\n"+
 			"        < %#v (actual)", epsilon, actualEpsilon), msgAndArgs...)
@ -1670,6 +1611,7 @@ func ErrorContains(t TestingT, theError error, contains string, msgAndArgs ...in

 // matchRegexp return true if a specified regexp matches a string.
 func matchRegexp(rx interface{}, str interface{}) bool {
+
 	var r *regexp.Regexp
 	if rr, ok := rx.(*regexp.Regexp); ok {
 		r = rr
@ -1677,14 +1619,7 @@ func matchRegexp(rx interface{}, str interface{}) bool {
 		r = regexp.MustCompile(fmt.Sprint(rx))
 	}

-	switch v := str.(type) {
-	case []byte:
-		return r.Match(v)
-	case string:
-		return r.MatchString(v)
-	default:
-		return r.MatchString(fmt.Sprint(v))
-	}
+	return (r.FindStringIndex(fmt.Sprint(str)) != nil)

 }

@ -1937,7 +1872,7 @@ var spewConfigStringerEnabled = spew.ConfigState{
 	MaxDepth:                10,
 }

-type tHelper = interface {
+type tHelper interface {
 	Helper()
 }

@ -1976,9 +1911,6 @@ func Eventually(t TestingT, condition func() bool, waitFor time.Duration, tick t

 // CollectT implements the TestingT interface and collects all errors.
 type CollectT struct {
-	// A slice of errors. Non-nil slice denotes a failure.
-	// If it's non-nil but len(c.errors) == 0, this is also a failure
-	// obtained by direct c.FailNow() call.
 	errors []error
 }

@ -1987,10 +1919,9 @@ func (c *CollectT) Errorf(format string, args ...interface{}) {
 	c.errors = append(c.errors, fmt.Errorf(format, args...))
 }

-// FailNow stops execution by calling runtime.Goexit.
-func (c *CollectT) FailNow() {
-	c.fail()
-	runtime.Goexit()
+// FailNow panics.
+func (*CollectT) FailNow() {
+	panic("Assertion failed")
 }

 // Deprecated: That was a method for internal usage that should not have been published. Now just panics.
@ -2003,16 +1934,6 @@ func (*CollectT) Copy(TestingT) {
 	panic("Copy() is deprecated")
 }

-func (c *CollectT) fail() {
-	if !c.failed() {
-		c.errors = []error{} // Make it non-nil to mark a failure.
-	}
-}
-
-func (c *CollectT) failed() bool {
-	return c.errors != nil
-}
-
 // EventuallyWithT asserts that given condition will be met in waitFor time,
 // periodically checking target function each tick. In contrast to Eventually,
 // it supplies a CollectT to the condition function, so that the condition
@ -2030,14 +1951,14 @@ func (c *CollectT) failed() bool {
 //	assert.EventuallyWithT(t, func(c *assert.CollectT) {
 //		// add assertions as needed; any assertion failure will fail the current tick
 //		assert.True(c, externalValue, "expected 'externalValue' to be true")
-//	}, 10*time.Second, 1*time.Second, "external state has not changed to 'true'; still false")
+//	}, 1*time.Second, 10*time.Second, "external state has not changed to 'true'; still false")
 func EventuallyWithT(t TestingT, condition func(collect *CollectT), waitFor time.Duration, tick time.Duration, msgAndArgs ...interface{}) bool {
 	if h, ok := t.(tHelper); ok {
 		h.Helper()
 	}

 	var lastFinishedTickErrs []error
-	ch := make(chan *CollectT, 1)
+	ch := make(chan []error, 1)

 	timer := time.NewTimer(waitFor)
 	defer timer.Stop()
@ -2057,16 +1978,16 @@ func EventuallyWithT(t TestingT, condition func(collect *CollectT), waitFor time
 			go func() {
 				collect := new(CollectT)
 				defer func() {
-					ch <- collect
+					ch <- collect.errors
 				}()
 				condition(collect)
 			}()
-		case collect := <-ch:
-			if !collect.failed() {
+		case errs := <-ch:
+			if len(errs) == 0 {
 				return true
 			}
 			// Keep the errors from the last ended condition, so that they can be copied to t if timeout is reached.
-			lastFinishedTickErrs = collect.errors
+			lastFinishedTickErrs = errs
 			tick = ticker.C
 		}
 	}
@ -2120,7 +2041,7 @@ func ErrorIs(t TestingT, err, target error, msgAndArgs ...interface{}) bool {
 		expectedText = target.Error()
 	}

-	chain := buildErrorChainString(err, false)
+	chain := buildErrorChainString(err)

 	return Fail(t, fmt.Sprintf("Target error should be in err chain:\n"+
 		"expected: %q\n"+
@ -2128,7 +2049,7 @@ func ErrorIs(t TestingT, err, target error, msgAndArgs ...interface{}) bool {
 	), msgAndArgs...)
 }

-// NotErrorIs asserts that none of the errors in err's chain matches target.
+// NotErrorIs asserts that at none of the errors in err's chain matches target.
 // This is a wrapper for errors.Is.
 func NotErrorIs(t TestingT, err, target error, msgAndArgs ...interface{}) bool {
 	if h, ok := t.(tHelper); ok {
@ -2143,7 +2064,7 @@ func NotErrorIs(t TestingT, err, target error, msgAndArgs ...interface{}) bool {
 		expectedText = target.Error()
 	}

-	chain := buildErrorChainString(err, false)
+	chain := buildErrorChainString(err)

 	return Fail(t, fmt.Sprintf("Target error should not be in err chain:\n"+
 		"found: %q\n"+
@ -2161,64 +2082,24 @@ func ErrorAs(t TestingT, err error, target interface{}, msgAndArgs ...interface{
 		return true
 	}

-	chain := buildErrorChainString(err, true)
+	chain := buildErrorChainString(err)

 	return Fail(t, fmt.Sprintf("Should be in error chain:\n"+
-		"expected: %s\n"+
-		"in chain: %s", reflect.ValueOf(target).Elem().Type(), chain,
+		"expected: %q\n"+
+		"in chain: %s", target, chain,
 	), msgAndArgs...)
 }

-// NotErrorAs asserts that none of the errors in err's chain matches target,
-// but if so, sets target to that error value.
-func NotErrorAs(t TestingT, err error, target interface{}, msgAndArgs ...interface{}) bool {
-	if h, ok := t.(tHelper); ok {
-		h.Helper()
-	}
-	if !errors.As(err, target) {
-		return true
-	}
-
-	chain := buildErrorChainString(err, true)
-
-	return Fail(t, fmt.Sprintf("Target error should not be in err chain:\n"+
-		"found: %s\n"+
-		"in chain: %s", reflect.ValueOf(target).Elem().Type(), chain,
-	), msgAndArgs...)
-}
-
-func unwrapAll(err error) (errs []error) {
-	errs = append(errs, err)
-	switch x := err.(type) {
-	case interface{ Unwrap() error }:
-		err = x.Unwrap()
-		if err == nil {
-			return
-		}
-		errs = append(errs, unwrapAll(err)...)
-	case interface{ Unwrap() []error }:
-		for _, err := range x.Unwrap() {
-			errs = append(errs, unwrapAll(err)...)
-		}
-	}
-	return
-}
-
-func buildErrorChainString(err error, withType bool) string {
+func buildErrorChainString(err error) string {
 	if err == nil {
 		return ""
 	}

-	var chain string
-	errs := unwrapAll(err)
-	for i := range errs {
-		if i != 0 {
-			chain += "\n\t"
-		}
-		chain += fmt.Sprintf("%q", errs[i].Error())
-		if withType {
-			chain += fmt.Sprintf(" (%T)", errs[i])
-		}
+	e := errors.Unwrap(err)
+	chain := fmt.Sprintf("%q", err.Error())
+	for e != nil {
+		chain += fmt.Sprintf("\n\t%q", e.Error())
+		e = errors.Unwrap(e)
 	}
 	return chain
 }
--- a/assert/assertions_test.go
+++ b/assert/assertions_test.go
@ -449,56 +449,6 @@ func TestEqualExportedValues(t *testing.T) {
 	            	+  Exported: (int) 1,
 	            	   notExported: (interface {}) <nil>`,
 		},
-		{
-			value1:        []int{1, 2},
-			value2:        []int{1, 2},
-			expectedEqual: true,
-		},
-		{
-			value1:        []int{1, 2},
-			value2:        []int{1, 3},
-			expectedEqual: false,
-			expectedFail: `
-	            	Diff:
-	            	--- Expected
-	            	+++ Actual
-	            	@@ -2,3 +2,3 @@
-	            	  (int) 1,
-	            	- (int) 2
-	            	+ (int) 3
-	            	 }`,
-		},
-		{
-			value1: []*Nested{
-				{1, 2},
-				{3, 4},
-			},
-			value2: []*Nested{
-				{1, "a"},
-				{3, "b"},
-			},
-			expectedEqual: true,
-		},
-		{
-			value1: []*Nested{
-				{1, 2},
-				{3, 4},
-			},
-			value2: []*Nested{
-				{1, "a"},
-				{2, "b"},
-			},
-			expectedEqual: false,
-			expectedFail: `
-	            	Diff:
-	            	--- Expected
-	            	+++ Actual
-	            	@@ -6,3 +6,3 @@
-	            	  (*assert.Nested)({
-	            	-  Exported: (int) 3,
-	            	+  Exported: (int) 2,
-	            	   notExported: (interface {}) <nil>`,
-		},
 	}

 	for _, c := range cases {
@ -657,57 +607,37 @@ func Test_samePointers(t *testing.T) {
 	tests := []struct {
 		name      string
 		args      args
-		same BoolAssertionFunc
-		ok   BoolAssertionFunc
+		assertion BoolAssertionFunc
 	}{
 		{
 			name:      "1 != 2",
 			args:      args{first: 1, second: 2},
-			same: False,
-			ok:   False,
+			assertion: False,
 		},
 		{
 			name:      "1 != 1 (not same ptr)",
 			args:      args{first: 1, second: 1},
-			same: False,
-			ok:   False,
+			assertion: False,
 		},
 		{
 			name:      "ptr(1) == ptr(1)",
 			args:      args{first: p, second: p},
-			same: True,
-			ok:   True,
+			assertion: True,
 		},
 		{
 			name:      "int(1) != float32(1)",
 			args:      args{first: int(1), second: float32(1)},
-			same: False,
-			ok:   False,
+			assertion: False,
 		},
 		{
 			name:      "array != slice",
 			args:      args{first: [2]int{1, 2}, second: []int{1, 2}},
-			same: False,
-			ok:   False,
-		},
-		{
-			name: "non-pointer vs pointer (1 != ptr(2))",
-			args: args{first: 1, second: p},
-			same: False,
-			ok:   False,
-		},
-		{
-			name: "pointer vs non-pointer (ptr(2) != 1)",
-			args: args{first: p, second: 1},
-			same: False,
-			ok:   False,
+			assertion: False,
 		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			same, ok := samePointers(tt.args.first, tt.args.second)
-			tt.same(t, same)
-			tt.ok(t, ok)
+			tt.assertion(t, samePointers(tt.args.first, tt.args.second))
 		})
 	}
 }
@ -1389,52 +1319,6 @@ func TestDiffLists(t *testing.T) {
 	}
 }

-func TestNotElementsMatch(t *testing.T) {
-	mockT := new(testing.T)
-
-	cases := []struct {
-		expected interface{}
-		actual   interface{}
-		result   bool
-	}{
-		// not matching
-		{[]int{1}, []int{}, true},
-		{[]int{}, []int{2}, true},
-		{[]int{1}, []int{2}, true},
-		{[]int{1}, []int{1, 1}, true},
-		{[]int{1, 2}, []int{3, 4}, true},
-		{[]int{3, 4}, []int{1, 2}, true},
-		{[]int{1, 1, 2, 3}, []int{1, 2, 3}, true},
-		{[]string{"hello"}, []string{"world"}, true},
-		{[]string{"hello", "hello"}, []string{"world", "world"}, true},
-		{[3]string{"hello", "hello", "hello"}, [3]string{"world", "world", "world"}, true},
-
-		// matching
-		{nil, nil, false},
-		{[]int{}, nil, false},
-		{[]int{}, []int{}, false},
-		{[]int{1}, []int{1}, false},
-		{[]int{1, 1}, []int{1, 1}, false},
-		{[]int{1, 2}, []int{2, 1}, false},
-		{[2]int{1, 2}, [2]int{2, 1}, false},
-		{[]int{1, 1, 2}, []int{1, 2, 1}, false},
-		{[]string{"hello", "world"}, []string{"world", "hello"}, false},
-		{[]string{"hello", "hello"}, []string{"hello", "hello"}, false},
-		{[]string{"hello", "hello", "world"}, []string{"hello", "world", "hello"}, false},
-		{[3]string{"hello", "hello", "world"}, [3]string{"hello", "world", "hello"}, false},
-	}
-
-	for _, c := range cases {
-		t.Run(fmt.Sprintf("NotElementsMatch(%#v, %#v)", c.expected, c.actual), func(t *testing.T) {
-			res := NotElementsMatch(mockT, c.actual, c.expected)
-
-			if res != c.result {
-				t.Errorf("NotElementsMatch(%#v, %#v) should return %v", c.actual, c.expected, c.result)
-			}
-		})
-	}
-}
-
 func TestCondition(t *testing.T) {
 	mockT := new(testing.T)

@ -2056,14 +1940,6 @@ func TestInEpsilon(t *testing.T) {
 		{math.NaN(), 0, 1},
 		{0, math.NaN(), 1},
 		{0, 0, math.NaN()},
-		{math.Inf(1), 1, 1},
-		{math.Inf(-1), 1, 1},
-		{1, math.Inf(1), 1},
-		{1, math.Inf(-1), 1},
-		{math.Inf(1), math.Inf(1), 1},
-		{math.Inf(1), math.Inf(-1), 1},
-		{math.Inf(-1), math.Inf(1), 1},
-		{math.Inf(-1), math.Inf(-1), 1},
 	}

 	for _, tc := range cases {
@ -2096,16 +1972,13 @@ func TestRegexp(t *testing.T) {
 	}{
 		{"^start", "start of the line"},
 		{"end$", "in the end"},
-		{"end$", "in the end"},
 		{"[0-9]{3}[.-]?[0-9]{2}[.-]?[0-9]{2}", "My phone number is 650.12.34"},
 	}

 	for _, tc := range cases {
 		True(t, Regexp(mockT, tc.rx, tc.str))
 		True(t, Regexp(mockT, regexp.MustCompile(tc.rx), tc.str))
-		True(t, Regexp(mockT, regexp.MustCompile(tc.rx), []byte(tc.str)))
 		False(t, NotRegexp(mockT, tc.rx, tc.str))
-		False(t, NotRegexp(mockT, tc.rx, []byte(tc.str)))
 		False(t, NotRegexp(mockT, regexp.MustCompile(tc.rx), tc.str))
 	}

@ -2118,11 +1991,9 @@ func TestRegexp(t *testing.T) {
 	}

 	for _, tc := range cases {
-		False(t, Regexp(mockT, tc.rx, tc.str), "Expected %q to not match %q", tc.rx, tc.str)
+		False(t, Regexp(mockT, tc.rx, tc.str), "Expected \"%s\" to not match \"%s\"", tc.rx, tc.str)
 		False(t, Regexp(mockT, regexp.MustCompile(tc.rx), tc.str))
-		False(t, Regexp(mockT, regexp.MustCompile(tc.rx), []byte(tc.str)))
 		True(t, NotRegexp(mockT, tc.rx, tc.str))
-		True(t, NotRegexp(mockT, tc.rx, []byte(tc.str)))
 		True(t, NotRegexp(mockT, regexp.MustCompile(tc.rx), tc.str))
 	}
 }
@ -2151,11 +2022,11 @@ func TestZero(t *testing.T) {
 	mockT := new(testing.T)

 	for _, test := range zeros {
-		True(t, Zero(mockT, test, "%#v is not the %T zero value", test, test))
+		True(t, Zero(mockT, test, "%#v is not the %v zero value", test, reflect.TypeOf(test)))
 	}

 	for _, test := range nonZeros {
-		False(t, Zero(mockT, test, "%#v is not the %T zero value", test, test))
+		False(t, Zero(mockT, test, "%#v is not the %v zero value", test, reflect.TypeOf(test)))
 	}
 }

@ -2163,11 +2034,11 @@ func TestNotZero(t *testing.T) {
 	mockT := new(testing.T)

 	for _, test := range zeros {
-		False(t, NotZero(mockT, test, "%#v is not the %T zero value", test, test))
+		False(t, NotZero(mockT, test, "%#v is not the %v zero value", test, reflect.TypeOf(test)))
 	}

 	for _, test := range nonZeros {
-		True(t, NotZero(mockT, test, "%#v is not the %T zero value", test, test))
+		True(t, NotZero(mockT, test, "%#v is not the %v zero value", test, reflect.TypeOf(test)))
 	}
 }

@ -2918,42 +2789,6 @@ func TestErrorAssertionFunc(t *testing.T) {
 	}
 }

-func ExamplePanicAssertionFunc() {
-	t := &testing.T{} // provided by test
-
-	tests := []struct {
-		name      string
-		panicFn   PanicTestFunc
-		assertion PanicAssertionFunc
-	}{
-		{"with panic", func() { panic(nil) }, Panics},
-		{"without panic", func() {}, NotPanics},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			tt.assertion(t, tt.panicFn)
-		})
-	}
-}
-
-func TestPanicAssertionFunc(t *testing.T) {
-	tests := []struct {
-		name      string
-		panicFn   PanicTestFunc
-		assertion PanicAssertionFunc
-	}{
-		{"not panic", func() {}, NotPanics},
-		{"panic", func() { panic(nil) }, Panics},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			tt.assertion(t, tt.panicFn)
-		})
-	}
-}
-
 func TestEventuallyFalse(t *testing.T) {
 	mockT := new(testing.T)

@ -3001,15 +2836,16 @@ func TestEventuallyWithTFalse(t *testing.T) {
 func TestEventuallyWithTTrue(t *testing.T) {
 	mockT := new(errorsCapturingT)

-	counter := 0
+	state := 0
 	condition := func(collect *CollectT) {
-		counter += 1
-		True(collect, counter == 2)
+		defer func() {
+			state += 1
+		}()
+		True(collect, state == 2)
 	}

 	True(t, EventuallyWithT(mockT, condition, 100*time.Millisecond, 20*time.Millisecond))
 	Len(t, mockT.errors, 0)
-	Equal(t, 2, counter, "Condition is expected to be called 2 times")
 }

 func TestEventuallyWithT_ConcurrencySafe(t *testing.T) {
@ -3047,17 +2883,6 @@ func TestEventuallyWithT_ReturnsTheLatestFinishedConditionErrors(t *testing.T) {
 	Len(t, mockT.errors, 2)
 }

-func TestEventuallyWithTFailNow(t *testing.T) {
-	mockT := new(CollectT)
-
-	condition := func(collect *CollectT) {
-		collect.FailNow()
-	}
-
-	False(t, EventuallyWithT(mockT, condition, 100*time.Millisecond, 20*time.Millisecond))
-	Len(t, mockT.errors, 1)
-}
-
 func TestNeverFalse(t *testing.T) {
 	condition := func() bool {
 		return false
@ -3175,13 +3000,11 @@ func parseLabeledOutput(output string) []labeledContent {
 }

 type captureTestingT struct {
-	failed bool
 	msg string
 }

 func (ctt *captureTestingT) Errorf(format string, args ...interface{}) {
 	ctt.msg = fmt.Sprintf(format, args...)
-	ctt.failed = true
 }

 func (ctt *captureTestingT) checkResultAndErrMsg(t *testing.T, expectedRes, res bool, expectedErrMsg string) {
@ -3190,10 +3013,6 @@ func (ctt *captureTestingT) checkResultAndErrMsg(t *testing.T, expectedRes, res
 		t.Errorf("Should return %t", expectedRes)
 		return
 	}
-	if res == ctt.failed {
-		t.Errorf("The test result (%t) should be reflected in the testing.T type (%t)", res, !ctt.failed)
-		return
-	}
 	contents := parseLabeledOutput(ctt.msg)
 	if res == true {
 		if contents != nil {
@ -3353,83 +3172,23 @@ func TestNotErrorIs(t *testing.T) {
 }

 func TestErrorAs(t *testing.T) {
+	mockT := new(testing.T)
 	tests := []struct {
 		err    error
 		result bool
-		resultErrMsg string
 	}{
-		{
-			err:    fmt.Errorf("wrap: %w", &customError{}),
-			result: true,
-		},
-		{
-			err:    io.EOF,
-			result: false,
-			resultErrMsg: "" +
-				"Should be in error chain:\n" +
-				"expected: *assert.customError\n" +
-				"in chain: \"EOF\" (*errors.errorString)\n",
-		},
-		{
-			err:    nil,
-			result: false,
-			resultErrMsg: "" +
-				"Should be in error chain:\n" +
-				"expected: *assert.customError\n" +
-				"in chain: \n",
-		},
-		{
-			err:    fmt.Errorf("abc: %w", errors.New("def")),
-			result: false,
-			resultErrMsg: "" +
-				"Should be in error chain:\n" +
-				"expected: *assert.customError\n" +
-				"in chain: \"abc: def\" (*fmt.wrapError)\n" +
-				"\t\"def\" (*errors.errorString)\n",
-		},
+		{fmt.Errorf("wrap: %w", &customError{}), true},
+		{io.EOF, false},
+		{nil, false},
 	}
 	for _, tt := range tests {
 		tt := tt
 		var target *customError
 		t.Run(fmt.Sprintf("ErrorAs(%#v,%#v)", tt.err, target), func(t *testing.T) {
-			mockT := new(captureTestingT)
 			res := ErrorAs(mockT, tt.err, &target)
-			mockT.checkResultAndErrMsg(t, tt.result, res, tt.resultErrMsg)
-		})
-	}
-}
-
-func TestNotErrorAs(t *testing.T) {
-	tests := []struct {
-		err          error
-		result       bool
-		resultErrMsg string
-	}{
-		{
-			err:    fmt.Errorf("wrap: %w", &customError{}),
-			result: false,
-			resultErrMsg: "" +
-				"Target error should not be in err chain:\n" +
-				"found: *assert.customError\n" +
-				"in chain: \"wrap: fail\" (*fmt.wrapError)\n" +
-				"\t\"fail\" (*assert.customError)\n",
-		},
-		{
-			err:    io.EOF,
-			result: true,
-		},
-		{
-			err:    nil,
-			result: true,
-		},
-	}
-	for _, tt := range tests {
-		tt := tt
-		var target *customError
-		t.Run(fmt.Sprintf("NotErrorAs(%#v,%#v)", tt.err, target), func(t *testing.T) {
-			mockT := new(captureTestingT)
-			res := NotErrorAs(mockT, tt.err, &target)
-			mockT.checkResultAndErrMsg(t, tt.result, res, tt.resultErrMsg)
+			if res != tt.result {
+				t.Errorf("ErrorAs(%#v,%#v) should return %t)", tt.err, target, tt.result)
+			}
 		})
 	}
 }
--- a/assert/forward_assertions_test.go
+++ b/assert/forward_assertions_test.go
@ -546,7 +546,7 @@ func TestRegexpWrapper(t *testing.T) {
 	}

 	for _, tc := range cases {
-		False(t, assert.Regexp(tc.rx, tc.str), "Expected %q to not match %q", tc.rx, tc.str)
+		False(t, assert.Regexp(tc.rx, tc.str), "Expected \"%s\" to not match \"%s\"", tc.rx, tc.str)
 		False(t, assert.Regexp(regexp.MustCompile(tc.rx), tc.str))
 		True(t, assert.NotRegexp(tc.rx, tc.str))
 		True(t, assert.NotRegexp(regexp.MustCompile(tc.rx), tc.str))
--- a/assert/http_assertions.go
+++ b/assert/http_assertions.go
@ -138,7 +138,7 @@ func HTTPBodyContains(t TestingT, handler http.HandlerFunc, method, url string,

 	contains := strings.Contains(body, fmt.Sprint(str))
 	if !contains {
-		Fail(t, fmt.Sprintf("Expected response body for %q to contain %q but found %q", url+"?"+values.Encode(), str, body), msgAndArgs...)
+		Fail(t, fmt.Sprintf("Expected response body for \"%s\" to contain \"%s\" but found \"%s\"", url+"?"+values.Encode(), str, body), msgAndArgs...)
 	}

 	return contains
@ -158,7 +158,7 @@ func HTTPBodyNotContains(t TestingT, handler http.HandlerFunc, method, url strin

 	contains := strings.Contains(body, fmt.Sprint(str))
 	if contains {
-		Fail(t, fmt.Sprintf("Expected response body for %q to NOT contain %q but found %q", url+"?"+values.Encode(), str, body), msgAndArgs...)
+		Fail(t, fmt.Sprintf("Expected response body for \"%s\" to NOT contain \"%s\" but found \"%s\"", url+"?"+values.Encode(), str, body), msgAndArgs...)
 	}

 	return !contains
--- a/assert/yaml/yaml_custom.go
+++ b/assert/yaml/yaml_custom.go
@ -1,25 +0,0 @@
-//go:build testify_yaml_custom && !testify_yaml_fail && !testify_yaml_default
-// +build testify_yaml_custom,!testify_yaml_fail,!testify_yaml_default
-
-// Package yaml is an implementation of YAML functions that calls a pluggable implementation.
-//
-// This implementation is selected with the testify_yaml_custom build tag.
-//
-//	go test -tags testify_yaml_custom
-//
-// This implementation can be used at build time to replace the default implementation
-// to avoid linking with [gopkg.in/yaml.v3].
-//
-// In your test package:
-//
-//		import assertYaml "github.com/stretchr/testify/assert/yaml"
-//
-//		func init() {
-//			assertYaml.Unmarshal = func (in []byte, out interface{}) error {
-//				// ...
-//	     			return nil
-//			}
-//		}
-package yaml
-
-var Unmarshal func(in []byte, out interface{}) error
--- a/assert/yaml/yaml_default.go
+++ b/assert/yaml/yaml_default.go
@ -1,37 +0,0 @@
-//go:build !testify_yaml_fail && !testify_yaml_custom
-// +build !testify_yaml_fail,!testify_yaml_custom
-
-// Package yaml is just an indirection to handle YAML deserialization.
-//
-// This package is just an indirection that allows the builder to override the
-// indirection with an alternative implementation of this package that uses
-// another implementation of YAML deserialization. This allows to not either not
-// use YAML deserialization at all, or to use another implementation than
-// [gopkg.in/yaml.v3] (for example for license compatibility reasons, see [PR #1120]).
-//
-// Alternative implementations are selected using build tags:
-//
-//   - testify_yaml_fail: [Unmarshal] always fails with an error
-//   - testify_yaml_custom: [Unmarshal] is a variable. Caller must initialize it
-//     before calling any of [github.com/stretchr/testify/assert.YAMLEq] or
-//     [github.com/stretchr/testify/assert.YAMLEqf].
-//
-// Usage:
-//
-//	go test -tags testify_yaml_fail
-//
-// You can check with "go list" which implementation is linked:
-//
-//	go list -f '{{.Imports}}' github.com/stretchr/testify/assert/yaml
-//	go list -tags testify_yaml_fail -f '{{.Imports}}' github.com/stretchr/testify/assert/yaml
-//	go list -tags testify_yaml_custom -f '{{.Imports}}' github.com/stretchr/testify/assert/yaml
-//
-// [PR #1120]: https://github.com/stretchr/testify/pull/1120
-package yaml
-
-import goyaml "gopkg.in/yaml.v3"
-
-// Unmarshal is just a wrapper of [gopkg.in/yaml.v3.Unmarshal].
-func Unmarshal(in []byte, out interface{}) error {
-	return goyaml.Unmarshal(in, out)
-}
--- a/assert/yaml/yaml_fail.go
+++ b/assert/yaml/yaml_fail.go
@ -1,18 +0,0 @@
-//go:build testify_yaml_fail && !testify_yaml_custom && !testify_yaml_default
-// +build testify_yaml_fail,!testify_yaml_custom,!testify_yaml_default
-
-// Package yaml is an implementation of YAML functions that always fail.
-//
-// This implementation can be used at build time to replace the default implementation
-// to avoid linking with [gopkg.in/yaml.v3]:
-//
-//	go test -tags testify_yaml_fail
-package yaml
-
-import "errors"
-
-var errNotImplemented = errors.New("YAML functions are not available (see https://pkg.go.dev/github.com/stretchr/testify/assert/yaml)")
-
-func Unmarshal([]byte, interface{}) error {
-	return errNotImplemented
-}
--- a/doc.go
+++ b/doc.go
@ -1,3 +1,4 @@
+// ** We are working on testify v2 and would love to hear what you'd like to see in it, have your say here: https://cutt.ly/testify **
 // Package testify is a set of packages that provide many tools for testifying that your code will behave as you intend.
 //
 // testify contains the following packages:
@ -7,9 +8,4 @@
 // The mock package provides a system by which it is possible to mock your objects and verify calls are happening as expected.
 //
 // The suite package provides a basic structure for using structs as testing suites, and methods on those structs as tests.  It includes setup/teardown functionality in the way of interfaces.
-//
-// A [golangci-lint] compatible linter for testify is available called [testifylint].
-//
-// [golangci-lint]: https://golangci-lint.run/
-// [testifylint]: https://github.com/Antonboom/testifylint
 package testify
--- a/mock/mock.go
+++ b/mock/mock.go
@ -80,12 +80,12 @@ type Call struct {
 	requires []*Call
 }

-func newCall(parent *Mock, methodName string, callerInfo []string, methodArguments Arguments, returnArguments Arguments) *Call {
+func newCall(parent *Mock, methodName string, callerInfo []string, methodArguments ...interface{}) *Call {
 	return &Call{
 		Parent:          parent,
 		Method:          methodName,
 		Arguments:       methodArguments,
-		ReturnArguments: returnArguments,
+		ReturnArguments: make([]interface{}, 0),
 		callerInfo:      callerInfo,
 		Repeatability:   0,
 		WaitFor:         nil,
@ -208,16 +208,9 @@ func (c *Call) On(methodName string, arguments ...interface{}) *Call {
 	return c.Parent.On(methodName, arguments...)
 }

-// Unset removes all mock handlers that satisfy the call instance arguments from being
-// called. Only supported on call instances with static input arguments.
+// Unset removes a mock handler from being called.
 //
-// For example, the only handler remaining after the following would be "MyMethod(2, 2)":
-//
-//	Mock.
-//	   On("MyMethod", 2, 2).Return(0).
-//	   On("MyMethod", 3, 3).Return(0).
-//	   On("MyMethod", Anything, Anything).Return(0)
-//	Mock.On("MyMethod", 3, 3).Unset()
+//	test.On("func", mock.Anything).Unset()
 func (c *Call) Unset() *Call {
 	var unlockOnce sync.Once

@ -263,7 +256,7 @@ func (c *Call) Unset() *Call {
 // calls have been called as expected. The referenced calls may be from the
 // same mock instance and/or other mock instances.
 //
-//	Mock.On("Do").Return(nil).NotBefore(
+//	Mock.On("Do").Return(nil).Notbefore(
 //	    Mock.On("Init").Return(nil)
 //	)
 func (c *Call) NotBefore(calls ...*Call) *Call {
@ -280,20 +273,6 @@ func (c *Call) NotBefore(calls ...*Call) *Call {
 	return c
 }

-// InOrder defines the order in which the calls should be made
-//
-//	For example:
-//
-//	InOrder(
-//		Mock.On("init").Return(nil),
-//		Mock.On("Do").Return(nil),
-//	)
-func InOrder(calls ...*Call) {
-	for i := 1; i < len(calls); i++ {
-		calls[i].NotBefore(calls[i-1])
-	}
-}
-
 // Mock is the workhorse used to track activity on another object.
 // For an example of its usage, refer to the "Example Usage" section at the top
 // of this document.
@ -338,10 +317,7 @@ func (m *Mock) TestData() objx.Map {
 	Setting expectations
 */

-// Test sets the [TestingT] on which errors will be reported, otherwise errors
-// will cause a panic.
-// Test should not be called on an object that is going to be used in a
-// goroutine other than the one running the test function.
+// Test sets the test struct variable of the mock object
 func (m *Mock) Test(t TestingT) {
 	m.mutex.Lock()
 	defer m.mutex.Unlock()
@ -375,8 +351,7 @@ func (m *Mock) On(methodName string, arguments ...interface{}) *Call {

 	m.mutex.Lock()
 	defer m.mutex.Unlock()
-
-	c := newCall(m, methodName, assert.CallerInfo(), arguments, make([]interface{}, 0))
+	c := newCall(m, methodName, assert.CallerInfo(), arguments...)
 	m.ExpectedCalls = append(m.ExpectedCalls, c)
 	return c
 }
@ -504,7 +479,7 @@ func (m *Mock) MethodCalled(methodName string, arguments ...interface{}) Argumen
 		// expected call found, but it has already been called with repeatable times
 		if call != nil {
 			m.mutex.Unlock()
-			m.fail("\nassert: mock: The method has been called over %d times.\n\tEither do one more Mock.On(%#v).Return(...), or remove extra call.\n\tThis call was unexpected:\n\t\t%s\n\tat: %s", call.totalCalls, methodName, callString(methodName, arguments, true), assert.CallerInfo())
+			m.fail("\nassert: mock: The method has been called over %d times.\n\tEither do one more Mock.On(\"%s\").Return(...), or remove extra call.\n\tThis call was unexpected:\n\t\t%s\n\tat: %s", call.totalCalls, methodName, callString(methodName, arguments, true), assert.CallerInfo())
 		}
 		// we have to fail here - because we don't know what to do
 		// as the return arguments.  This is because:
@ -516,15 +491,14 @@ func (m *Mock) MethodCalled(methodName string, arguments ...interface{}) Argumen
 		m.mutex.Unlock()

 		if closestCall != nil {
-			m.fail("\n\nmock: Unexpected Method Call\n-----------------------------\n\n%s\n\nThe closest call I have is: \n\n%s\n\n%s\nDiff: %s\nat: %s\n",
+			m.fail("\n\nmock: Unexpected Method Call\n-----------------------------\n\n%s\n\nThe closest call I have is: \n\n%s\n\n%s\nDiff: %s",
 				callString(methodName, arguments, true),
 				callString(methodName, closestCall.Arguments, true),
 				diffArguments(closestCall.Arguments, arguments),
 				strings.TrimSpace(mismatch),
-				assert.CallerInfo(),
 			)
 		} else {
-			m.fail("\nassert: mock: I don't know what to return because the method call was unexpected.\n\tEither do Mock.On(%#v).Return(...) first, or remove the %s() call.\n\tThis method was unexpected:\n\t\t%s\n\tat: %s", methodName, methodName, callString(methodName, arguments, true), assert.CallerInfo())
+			m.fail("\nassert: mock: I don't know what to return because the method call was unexpected.\n\tEither do Mock.On(\"%s\").Return(...) first, or remove the %s() call.\n\tThis method was unexpected:\n\t\t%s\n\tat: %s", methodName, methodName, callString(methodName, arguments, true), assert.CallerInfo())
 		}
 	}

@ -555,7 +529,7 @@ func (m *Mock) MethodCalled(methodName string, arguments ...interface{}) Argumen
 	call.totalCalls++

 	// add the call
-	m.Calls = append(m.Calls, *newCall(m, methodName, assert.CallerInfo(), arguments, call.ReturnArguments))
+	m.Calls = append(m.Calls, *newCall(m, methodName, assert.CallerInfo(), arguments...))
 	m.mutex.Unlock()

 	// block if specified
@ -790,17 +764,9 @@ const (
 )

 // AnythingOfTypeArgument contains the type of an argument
-// for use when type checking.  Used in [Arguments.Diff] and [Arguments.Assert].
+// for use when type checking.  Used in Diff and Assert.
 //
-// Deprecated: this is an implementation detail that must not be used. Use the [AnythingOfType] constructor instead, example:
-//
-//	m.On("Do", mock.AnythingOfType("string"))
-//
-// All explicit type declarations can be replaced with interface{} as is expected by [Mock.On], example:
-//
-//	func anyString interface{} {
-//		return mock.AnythingOfType("string")
-//	}
+// Deprecated: this is an implementation detail that must not be used. Use [AnythingOfType] instead.
 type AnythingOfTypeArgument = anythingOfTypeArgument

 // anythingOfTypeArgument is a string that contains the type of an argument
@ -814,54 +780,53 @@ type anythingOfTypeArgument string
 //
 // For example:
 //
-//	args.Assert(t, AnythingOfType("string"), AnythingOfType("int"))
+//	Assert(t, AnythingOfType("string"), AnythingOfType("int"))
 func AnythingOfType(t string) AnythingOfTypeArgument {
 	return anythingOfTypeArgument(t)
 }

 // IsTypeArgument is a struct that contains the type of an argument
-// for use when type checking.  This is an alternative to [AnythingOfType].
-// Used in [Arguments.Diff] and [Arguments.Assert].
+// for use when type checking.  This is an alternative to AnythingOfType.
+// Used in Diff and Assert.
 type IsTypeArgument struct {
 	t reflect.Type
 }

 // IsType returns an IsTypeArgument object containing the type to check for.
 // You can provide a zero-value of the type to check.  This is an
-// alternative to [AnythingOfType].  Used in [Arguments.Diff] and [Arguments.Assert].
+// alternative to AnythingOfType.  Used in Diff and Assert.
 //
 // For example:
-//
-//	args.Assert(t, IsType(""), IsType(0))
+// Assert(t, IsType(""), IsType(0))
 func IsType(t interface{}) *IsTypeArgument {
 	return &IsTypeArgument{t: reflect.TypeOf(t)}
 }

-// FunctionalOptionsArgument contains a list of functional options arguments
-// expected for use when matching a list of arguments.
+// FunctionalOptionsArgument is a struct that contains the type and value of an functional option argument
+// for use when type checking.
 type FunctionalOptionsArgument struct {
-	values []interface{}
+	value interface{}
 }

 // String returns the string representation of FunctionalOptionsArgument
 func (f *FunctionalOptionsArgument) String() string {
 	var name string
-	if len(f.values) > 0 {
-		name = "[]" + reflect.TypeOf(f.values[0]).String()
+	tValue := reflect.ValueOf(f.value)
+	if tValue.Len() > 0 {
+		name = "[]" + reflect.TypeOf(tValue.Index(0).Interface()).String()
 	}

-	return strings.Replace(fmt.Sprintf("%#v", f.values), "[]interface {}", name, 1)
+	return strings.Replace(fmt.Sprintf("%#v", f.value), "[]interface {}", name, 1)
 }

-// FunctionalOptions returns an [FunctionalOptionsArgument] object containing
-// the expected functional-options to check for.
+// FunctionalOptions returns an FunctionalOptionsArgument object containing the functional option type
+// and the values to check of
 //
 // For example:
-//
-//	args.Assert(t, FunctionalOptions(foo.Opt1("strValue"), foo.Opt2(613)))
-func FunctionalOptions(values ...interface{}) *FunctionalOptionsArgument {
+// Assert(t, FunctionalOptions("[]foo.FunctionalOption", foo.Opt1(), foo.Opt2()))
+func FunctionalOptions(value ...interface{}) *FunctionalOptionsArgument {
 	return &FunctionalOptionsArgument{
-		values: values,
+		value: value,
 	}
 }

@ -908,11 +873,10 @@ func (f argumentMatcher) String() string {
 // and false otherwise.
 //
 // Example:
-//
 // m.On("Do", MatchedBy(func(req *http.Request) bool { return req.Host == "example.com" }))
 //
-// fn must be a function accepting a single argument (of the expected type)
-// which returns a bool. If fn doesn't match the required signature,
+// |fn|, must be a function accepting a single argument (of the expected type)
+// which returns a bool. If |fn| doesn't match the required signature,
 // MatchedBy() panics.
 func MatchedBy(fn interface{}) argumentMatcher {
 	fnType := reflect.TypeOf(fn)
@ -1015,17 +979,20 @@ func (args Arguments) Diff(objects []interface{}) (string, int) {
 					output = fmt.Sprintf("%s\t%d: FAIL:  type %s != type %s - %s\n", output, i, expected.t.Name(), actualT.Name(), actualFmt)
 				}
 			case *FunctionalOptionsArgument:
+				t := expected.value
+
 				var name string
-				if len(expected.values) > 0 {
-					name = "[]" + reflect.TypeOf(expected.values[0]).String()
+				tValue := reflect.ValueOf(t)
+				if tValue.Len() > 0 {
+					name = "[]" + reflect.TypeOf(tValue.Index(0).Interface()).String()
 				}

-				const tName = "[]interface{}"
-				if name != reflect.TypeOf(actual).String() && len(expected.values) != 0 {
+				tName := reflect.TypeOf(t).Name()
+				if name != reflect.TypeOf(actual).String() && tValue.Len() != 0 {
 					differences++
 					output = fmt.Sprintf("%s\t%d: FAIL:  type %s != type %s - %s\n", output, i, tName, reflect.TypeOf(actual).Name(), actualFmt)
 				} else {
-					if ef, af := assertOpts(expected.values, actual); ef == "" && af == "" {
+					if ef, af := assertOpts(t, actual); ef == "" && af == "" {
 						// match
 						output = fmt.Sprintf("%s\t%d: PASS:  %s == %s\n", output, i, tName, tName)
 					} else {
@ -1125,7 +1092,7 @@ func (args Arguments) Error(index int) error {
 		return nil
 	}
 	if s, ok = obj.(error); !ok {
-		panic(fmt.Sprintf("assert: arguments: Error(%d) failed because object wasn't correct type: %v", index, obj))
+		panic(fmt.Sprintf("assert: arguments: Error(%d) failed because object wasn't correct type: %v", index, args.Get(index)))
 	}
 	return s
 }
@ -1214,38 +1181,32 @@ type tHelper interface {
 func assertOpts(expected, actual interface{}) (expectedFmt, actualFmt string) {
 	expectedOpts := reflect.ValueOf(expected)
 	actualOpts := reflect.ValueOf(actual)
-
-	var expectedFuncs []*runtime.Func
 	var expectedNames []string
 	for i := 0; i < expectedOpts.Len(); i++ {
-		f := runtimeFunc(expectedOpts.Index(i).Interface())
-		expectedFuncs = append(expectedFuncs, f)
-		expectedNames = append(expectedNames, funcName(f))
+		expectedNames = append(expectedNames, funcName(expectedOpts.Index(i).Interface()))
 	}
-	var actualFuncs []*runtime.Func
 	var actualNames []string
 	for i := 0; i < actualOpts.Len(); i++ {
-		f := runtimeFunc(actualOpts.Index(i).Interface())
-		actualFuncs = append(actualFuncs, f)
-		actualNames = append(actualNames, funcName(f))
+		actualNames = append(actualNames, funcName(actualOpts.Index(i).Interface()))
 	}
-
-	if expectedOpts.Len() != actualOpts.Len() {
+	if !assert.ObjectsAreEqual(expectedNames, actualNames) {
 		expectedFmt = fmt.Sprintf("%v", expectedNames)
 		actualFmt = fmt.Sprintf("%v", actualNames)
 		return
 	}

 	for i := 0; i < expectedOpts.Len(); i++ {
-		if !isFuncSame(expectedFuncs[i], actualFuncs[i]) {
-			expectedFmt = expectedNames[i]
-			actualFmt = actualNames[i]
-			return
-		}
-
 		expectedOpt := expectedOpts.Index(i).Interface()
 		actualOpt := actualOpts.Index(i).Interface()

+		expectedFunc := expectedNames[i]
+		actualFunc := actualNames[i]
+		if expectedFunc != actualFunc {
+			expectedFmt = expectedFunc
+			actualFmt = actualFunc
+			return
+		}
+
 		ot := reflect.TypeOf(expectedOpt)
 		var expectedValues []reflect.Value
 		var actualValues []reflect.Value
@ -1263,9 +1224,9 @@ func assertOpts(expected, actual interface{}) (expectedFmt, actualFmt string) {
 		reflect.ValueOf(actualOpt).Call(actualValues)

 		for i := 0; i < ot.NumIn(); i++ {
-			if expectedArg, actualArg := expectedValues[i].Interface(), actualValues[i].Interface(); !assert.ObjectsAreEqual(expectedArg, actualArg) {
-				expectedFmt = fmt.Sprintf("%s(%T) -> %#v", expectedNames[i], expectedArg, expectedArg)
-				actualFmt = fmt.Sprintf("%s(%T) -> %#v", expectedNames[i], actualArg, actualArg)
+			if !assert.ObjectsAreEqual(expectedValues[i].Interface(), actualValues[i].Interface()) {
+				expectedFmt = fmt.Sprintf("%s %+v", expectedNames[i], expectedValues[i].Interface())
+				actualFmt = fmt.Sprintf("%s %+v", expectedNames[i], actualValues[i].Interface())
 				return
 			}
 		}
@ -1274,25 +1235,7 @@ func assertOpts(expected, actual interface{}) (expectedFmt, actualFmt string) {
 	return "", ""
 }

-func runtimeFunc(opt interface{}) *runtime.Func {
-	return runtime.FuncForPC(reflect.ValueOf(opt).Pointer())
-}
-
-func funcName(f *runtime.Func) string {
-	name := f.Name()
-	trimmed := strings.TrimSuffix(path.Base(name), path.Ext(name))
-	splitted := strings.Split(trimmed, ".")
-
-	if len(splitted) == 0 {
-		return trimmed
-	}
-
-	return splitted[len(splitted)-1]
-}
-
-func isFuncSame(f1, f2 *runtime.Func) bool {
-	f1File, f1Loc := f1.FileLine(f1.Entry())
-	f2File, f2Loc := f2.FileLine(f2.Entry())
-
-	return f1File == f2File && f1Loc == f2Loc
+func funcName(opt interface{}) string {
+	n := runtime.FuncForPC(reflect.ValueOf(opt).Pointer()).Name()
+	return strings.TrimSuffix(path.Base(n), path.Ext(n))
 }
--- a/mock/mock_test.go
+++ b/mock/mock_test.go
@ -50,22 +50,11 @@ func OpStr(s string) OptionFn {
 		o.str = s
 	}
 }
-
-func OpBytes(b []byte) OptionFn {
-	return func(m *options) {
-		m.str = string(b)
-	}
-}
-
 func (i *TestExampleImplementation) TheExampleMethodFunctionalOptions(x string, opts ...OptionFn) error {
 	args := i.Called(x, opts)
 	return args.Error(0)
 }

-func TheExampleMethodFunctionalOptionsIndirect(i *TestExampleImplementation) {
-	i.TheExampleMethodFunctionalOptions("test", OpNum(1), OpStr("foo"))
-}
-
 //go:noinline
 func (i *TestExampleImplementation) TheExampleMethod2(yesorno bool) {
 	i.Called(yesorno)
@ -948,26 +937,6 @@ func Test_Mock_Return_NotBefore_In_Order(t *testing.T) {
 	})
 }

-func Test_Mock_Return_InOrder_Uses_NotBefore(t *testing.T) {
-	var mockedService = new(TestExampleImplementation)
-
-	InOrder(
-		mockedService.
-			On("TheExampleMethod", 1, 2, 3).
-			Return(4, nil),
-		mockedService.
-			On("TheExampleMethod2", true).
-			Return(),
-	)
-
-	require.NotPanics(t, func() {
-		mockedService.TheExampleMethod(1, 2, 3)
-	})
-	require.NotPanics(t, func() {
-		mockedService.TheExampleMethod2(true)
-	})
-}
-
 func Test_Mock_Return_NotBefore_Out_Of_Order(t *testing.T) {
 	var mockedService = new(TestExampleImplementation)

@ -998,35 +967,6 @@ TheExampleMethod(int,int,int)
 	})
 }

-func Test_Mock_Return_InOrder_Uses_NotBefore_Out_Of_Order(t *testing.T) {
-	var mockedService = new(TestExampleImplementation)
-
-	InOrder(
-		mockedService.
-			On("TheExampleMethod", 1, 2, 3).
-			Return(4, nil).Twice(),
-		mockedService.
-			On("TheExampleMethod2", true).
-			Return(),
-	)
-
-	expectedPanicString := `mock: Unexpected Method Call
-----------------------------
-
-TheExampleMethod2(bool)
-		0: true
-
-Must not be called before:
-
-TheExampleMethod(int,int,int)
-		0: 1
-		1: 2
-		2: 3`
-	require.PanicsWithValue(t, expectedPanicString, func() {
-		mockedService.TheExampleMethod2(true)
-	})
-}
-
 func Test_Mock_Return_NotBefore_Not_Enough_Times(t *testing.T) {
 	var mockedService = new(TestExampleImplementation)

@ -1082,7 +1022,6 @@ func Test_Mock_Return_NotBefore_Different_Mock_In_Order(t *testing.T) {
 		mockedService2.TheExampleMethod2(true)
 	})
 }
-
 func Test_Mock_Return_NotBefore_Different_Mock_Out_Of_Order(t *testing.T) {
 	var (
 		mockedService1 = new(TestExampleImplementation)
@ -1267,7 +1206,7 @@ func Test_Mock_Called_blocks(t *testing.T) {

 	var mockedService = new(TestExampleImplementation)

-	mockedService.Mock.On("asyncCall", 1, 2, 3).Return(5, "6", true).After(20 * time.Millisecond)
+	mockedService.Mock.On("asyncCall", 1, 2, 3).Return(5, "6", true).After(2 * time.Millisecond)

 	ch := make(chan Arguments)

@ -1276,7 +1215,7 @@ func Test_Mock_Called_blocks(t *testing.T) {
 	select {
 	case <-ch:
 		t.Fatal("should have waited")
-	case <-time.After(10 * time.Millisecond):
+	case <-time.After(1 * time.Millisecond):
 	}

 	returnArguments := <-ch
@ -1533,51 +1472,6 @@ func Test_Mock_AssertExpectationsFunctionalOptionsType_Empty(t *testing.T) {

 }

-func Test_Mock_AssertExpectationsFunctionalOptionsType_Indirectly(t *testing.T) {
-
-	var mockedService = new(TestExampleImplementation)
-
-	mockedService.On("TheExampleMethodFunctionalOptions", "test", FunctionalOptions(OpNum(1), OpStr("foo"))).Return(nil).Once()
-
-	tt := new(testing.T)
-	assert.False(t, mockedService.AssertExpectations(tt))
-
-	// make the call now
-	TheExampleMethodFunctionalOptionsIndirect(mockedService)
-
-	// now assert expectations
-	assert.True(t, mockedService.AssertExpectations(tt))
-
-}
-
-func Test_Mock_AssertExpectationsFunctionalOptionsType_Diff_Func(t *testing.T) {
-
-	var mockedService = new(TestExampleImplementation)
-
-	mockedService.On("TheExampleMethodFunctionalOptions", "test", FunctionalOptions(OpStr("this"))).Return(nil).Once()
-
-	tt := new(testing.T)
-	assert.False(t, mockedService.AssertExpectations(tt))
-
-	assert.Panics(t, func() {
-		mockedService.TheExampleMethodFunctionalOptions("test", OpBytes([]byte("this")))
-	})
-}
-
-func Test_Mock_AssertExpectationsFunctionalOptionsType_Diff_Arg(t *testing.T) {
-
-	var mockedService = new(TestExampleImplementation)
-
-	mockedService.On("TheExampleMethodFunctionalOptions", "test", FunctionalOptions(OpStr("this"))).Return(nil).Once()
-
-	tt := new(testing.T)
-	assert.False(t, mockedService.AssertExpectations(tt))
-
-	assert.Panics(t, func() {
-		mockedService.TheExampleMethodFunctionalOptions("test", OpStr("that"))
-	})
-}
-
 func Test_Mock_AssertExpectations_With_Repeatability(t *testing.T) {

 	var mockedService = new(TestExampleImplementation)
@ -2086,7 +1980,7 @@ func TestArgumentMatcherToPrintMismatch(t *testing.T) {
 	defer func() {
 		if r := recover(); r != nil {
 			matchingExp := regexp.MustCompile(
-				`\s+mock: Unexpected Method Call\s+-*\s+GetTime\(int\)\s+0: 1\s+The closest call I have is:\s+GetTime\(mock.argumentMatcher\)\s+0: mock.argumentMatcher\{.*?\}\s+Diff:.*\(int=1\) not matched by func\(int\) bool\nat: \[[^\]]+mock\/mock_test.go`)
+				`\s+mock: Unexpected Method Call\s+-*\s+GetTime\(int\)\s+0: 1\s+The closest call I have is:\s+GetTime\(mock.argumentMatcher\)\s+0: mock.argumentMatcher\{.*?\}\s+Diff:.*\(int=1\) not matched by func\(int\) bool`)
 			assert.Regexp(t, matchingExp, r)
 		}
 	}()
@ -2103,7 +1997,7 @@ func TestArgumentMatcherToPrintMismatchWithReferenceType(t *testing.T) {
 	defer func() {
 		if r := recover(); r != nil {
 			matchingExp := regexp.MustCompile(
-				`\s+mock: Unexpected Method Call\s+-*\s+GetTimes\(\[\]int\)\s+0: \[\]int\{1\}\s+The closest call I have is:\s+GetTimes\(mock.argumentMatcher\)\s+0: mock.argumentMatcher\{.*?\}\s+Diff:.*\(\[\]int=\[1\]\) not matched by func\(\[\]int\) bool\nat: \[[^\]]+mock\/mock_test.go`)
+				`\s+mock: Unexpected Method Call\s+-*\s+GetTimes\(\[\]int\)\s+0: \[\]int\{1\}\s+The closest call I have is:\s+GetTimes\(mock.argumentMatcher\)\s+0: mock.argumentMatcher\{.*?\}\s+Diff:.*\(\[\]int=\[1\]\) not matched by func\(\[\]int\) bool`)
 			assert.Regexp(t, matchingExp, r)
 		}
 	}()
@ -2134,7 +2028,7 @@ func TestClosestCallMismatchedArgumentInformationShowsTheClosest(t *testing.T) {
 func TestClosestCallFavorsFirstMock(t *testing.T) {
 	defer func() {
 		if r := recover(); r != nil {
-			diffRegExp := `Difference found in argument 0:\s+--- Expected\s+\+\+\+ Actual\s+@@ -2,4 \+2,4 @@\s+\(bool\) true,\s+- \(bool\) true,\s+- \(bool\) true\s+\+ \(bool\) false,\s+\+ \(bool\) false\s+}\s+Diff: 0: FAIL:  \(\[\]bool=\[(true\s?|false\s?){3}]\) != \(\[\]bool=\[(true\s?|false\s?){3}\]\)`
+			diffRegExp := `Difference found in argument 0:\s+--- Expected\s+\+\+\+ Actual\s+@@ -2,4 \+2,4 @@\s+\(bool\) true,\s+- \(bool\) true,\s+- \(bool\) true\s+\+ \(bool\) false,\s+\+ \(bool\) false\s+}\s+`
 			matchingExp := regexp.MustCompile(unexpectedCallRegex(`TheExampleMethod7([]bool)`, `0: \[\]bool{true, false, false}`, `0: \[\]bool{true, true, true}`, diffRegExp))
 			assert.Regexp(t, matchingExp, r)
 		}
@ -2150,7 +2044,7 @@ func TestClosestCallFavorsFirstMock(t *testing.T) {
 func TestClosestCallUsesRepeatabilityToFindClosest(t *testing.T) {
 	defer func() {
 		if r := recover(); r != nil {
-			diffRegExp := `Difference found in argument 0:\s+--- Expected\s+\+\+\+ Actual\s+@@ -1,4 \+1,4 @@\s+\(\[\]bool\) \(len=3\) {\s+- \(bool\) false,\s+- \(bool\) false,\s+\+ \(bool\) true,\s+\+ \(bool\) true,\s+\(bool\) false\s+Diff: 0: FAIL:  \(\[\]bool=\[(true\s?|false\s?){3}]\) != \(\[\]bool=\[(true\s?|false\s?){3}\]\)`
+			diffRegExp := `Difference found in argument 0:\s+--- Expected\s+\+\+\+ Actual\s+@@ -1,4 \+1,4 @@\s+\(\[\]bool\) \(len=3\) {\s+- \(bool\) false,\s+- \(bool\) false,\s+\+ \(bool\) true,\s+\+ \(bool\) true,\s+\(bool\) false\s+`
 			matchingExp := regexp.MustCompile(unexpectedCallRegex(`TheExampleMethod7([]bool)`, `0: \[\]bool{true, true, false}`, `0: \[\]bool{false, false, false}`, diffRegExp))
 			assert.Regexp(t, matchingExp, r)
 		}
@ -2207,7 +2101,7 @@ func Test_isBetterMatchThanReturnsFalseIfRepeatabilityIsLessThanOrEqualToOther(t

 func unexpectedCallRegex(method, calledArg, expectedArg, diff string) string {
 	rMethod := regexp.QuoteMeta(method)
-	return fmt.Sprintf(`\s+mock: Unexpected Method Call\s+-*\s+%s\s+%s\s+The closest call I have is:\s+%s\s+%s\s+%s\nat: \[[^\]]+mock\/mock_test.go`,
+	return fmt.Sprintf(`\s+mock: Unexpected Method Call\s+-*\s+%s\s+%s\s+The closest call I have is:\s+%s\s+%s\s+%s`,
 		rMethod, calledArg, rMethod, expectedArg, diff)
 }

--- a/require/doc.go
+++ b/require/doc.go
@ -23,8 +23,6 @@
 //
 // The `require` package have same global functions as in the `assert` package,
 // but instead of returning a boolean result they call `t.FailNow()`.
-// A consequence of this is that it must be called from the goroutine running
-// the test function, not from other goroutines created during the test.
 //
 // Every assertion function also takes an optional string message as the final argument,
 // allowing custom error messages to be appended to the message the assertion method outputs.
--- a/require/require.go
+++ b/require/require.go
--- a/require/require.go.tmpl
+++ b/require/require.go.tmpl
@ -1,4 +1,4 @@
-{{ replace .Comment "assert." "require."}}
+{{.Comment}}
 func {{.DocInfo.Name}}(t TestingT, {{.Params}}) {
 	if h, ok := t.(tHelper); ok { h.Helper() }
 	if assert.{{.DocInfo.Name}}(t, {{.ForwardedParams}}) { return }
--- a/require/require_forward.go
+++ b/require/require_forward.go
@ -187,8 +187,8 @@ func (a *Assertions) EqualExportedValuesf(expected interface{}, actual interface
 	EqualExportedValuesf(a.t, expected, actual, msg, args...)
 }

-// EqualValues asserts that two objects are equal or convertible to the larger
-// type and equal.
+// EqualValues asserts that two objects are equal or convertible to the same types
+// and equal.
 //
 //	a.EqualValues(uint32(123), int32(123))
 func (a *Assertions) EqualValues(expected interface{}, actual interface{}, msgAndArgs ...interface{}) {
@ -198,8 +198,8 @@ func (a *Assertions) EqualValues(expected interface{}, actual interface{}, msgAn
 	EqualValues(a.t, expected, actual, msgAndArgs...)
 }

-// EqualValuesf asserts that two objects are equal or convertible to the larger
-// type and equal.
+// EqualValuesf asserts that two objects are equal or convertible to the same types
+// and equal.
 //
 //	a.EqualValuesf(uint32(123), int32(123), "error message %s", "formatted")
 func (a *Assertions) EqualValuesf(expected interface{}, actual interface{}, msg string, args ...interface{}) {
@ -337,7 +337,7 @@ func (a *Assertions) Eventually(condition func() bool, waitFor time.Duration, ti
 //	a.EventuallyWithT(func(c *assert.CollectT) {
 //		// add assertions as needed; any assertion failure will fail the current tick
 //		assert.True(c, externalValue, "expected 'externalValue' to be true")
-//	}, 10*time.Second, 1*time.Second, "external state has not changed to 'true'; still false")
+//	}, 1*time.Second, 10*time.Second, "external state has not changed to 'true'; still false")
 func (a *Assertions) EventuallyWithT(condition func(collect *assert.CollectT), waitFor time.Duration, tick time.Duration, msgAndArgs ...interface{}) {
 	if h, ok := a.t.(tHelper); ok {
 		h.Helper()
@ -362,7 +362,7 @@ func (a *Assertions) EventuallyWithT(condition func(collect *assert.CollectT), w
 //	a.EventuallyWithTf(func(c *assert.CollectT, "error message %s", "formatted") {
 //		// add assertions as needed; any assertion failure will fail the current tick
 //		assert.True(c, externalValue, "expected 'externalValue' to be true")
-//	}, 10*time.Second, 1*time.Second, "external state has not changed to 'true'; still false")
+//	}, 1*time.Second, 10*time.Second, "external state has not changed to 'true'; still false")
 func (a *Assertions) EventuallyWithTf(condition func(collect *assert.CollectT), waitFor time.Duration, tick time.Duration, msg string, args ...interface{}) {
 	if h, ok := a.t.(tHelper); ok {
 		h.Helper()
@ -1129,40 +1129,6 @@ func (a *Assertions) NotContainsf(s interface{}, contains interface{}, msg strin
 	NotContainsf(a.t, s, contains, msg, args...)
 }

-// NotElementsMatch asserts that the specified listA(array, slice...) is NOT equal to specified
-// listB(array, slice...) ignoring the order of the elements. If there are duplicate elements,
-// the number of appearances of each of them in both lists should not match.
-// This is an inverse of ElementsMatch.
-//
-// a.NotElementsMatch([1, 1, 2, 3], [1, 1, 2, 3]) -> false
-//
-// a.NotElementsMatch([1, 1, 2, 3], [1, 2, 3]) -> true
-//
-// a.NotElementsMatch([1, 2, 3], [1, 2, 4]) -> true
-func (a *Assertions) NotElementsMatch(listA interface{}, listB interface{}, msgAndArgs ...interface{}) {
-	if h, ok := a.t.(tHelper); ok {
-		h.Helper()
-	}
-	NotElementsMatch(a.t, listA, listB, msgAndArgs...)
-}
-
-// NotElementsMatchf asserts that the specified listA(array, slice...) is NOT equal to specified
-// listB(array, slice...) ignoring the order of the elements. If there are duplicate elements,
-// the number of appearances of each of them in both lists should not match.
-// This is an inverse of ElementsMatch.
-//
-// a.NotElementsMatchf([1, 1, 2, 3], [1, 1, 2, 3], "error message %s", "formatted") -> false
-//
-// a.NotElementsMatchf([1, 1, 2, 3], [1, 2, 3], "error message %s", "formatted") -> true
-//
-// a.NotElementsMatchf([1, 2, 3], [1, 2, 4], "error message %s", "formatted") -> true
-func (a *Assertions) NotElementsMatchf(listA interface{}, listB interface{}, msg string, args ...interface{}) {
-	if h, ok := a.t.(tHelper); ok {
-		h.Helper()
-	}
-	NotElementsMatchf(a.t, listA, listB, msg, args...)
-}
-
 // NotEmpty asserts that the specified object is NOT empty.  I.e. not nil, "", false, 0 or either
 // a slice or a channel with len == 0.
 //
@ -1235,25 +1201,7 @@ func (a *Assertions) NotEqualf(expected interface{}, actual interface{}, msg str
 	NotEqualf(a.t, expected, actual, msg, args...)
 }

-// NotErrorAs asserts that none of the errors in err's chain matches target,
-// but if so, sets target to that error value.
-func (a *Assertions) NotErrorAs(err error, target interface{}, msgAndArgs ...interface{}) {
-	if h, ok := a.t.(tHelper); ok {
-		h.Helper()
-	}
-	NotErrorAs(a.t, err, target, msgAndArgs...)
-}
-
-// NotErrorAsf asserts that none of the errors in err's chain matches target,
-// but if so, sets target to that error value.
-func (a *Assertions) NotErrorAsf(err error, target interface{}, msg string, args ...interface{}) {
-	if h, ok := a.t.(tHelper); ok {
-		h.Helper()
-	}
-	NotErrorAsf(a.t, err, target, msg, args...)
-}
-
-// NotErrorIs asserts that none of the errors in err's chain matches target.
+// NotErrorIs asserts that at none of the errors in err's chain matches target.
 // This is a wrapper for errors.Is.
 func (a *Assertions) NotErrorIs(err error, target error, msgAndArgs ...interface{}) {
 	if h, ok := a.t.(tHelper); ok {
@ -1262,7 +1210,7 @@ func (a *Assertions) NotErrorIs(err error, target error, msgAndArgs ...interface
 	NotErrorIs(a.t, err, target, msgAndArgs...)
 }

-// NotErrorIsf asserts that none of the errors in err's chain matches target.
+// NotErrorIsf asserts that at none of the errors in err's chain matches target.
 // This is a wrapper for errors.Is.
 func (a *Assertions) NotErrorIsf(err error, target error, msg string, args ...interface{}) {
 	if h, ok := a.t.(tHelper); ok {
--- a/require/requirements.go
+++ b/require/requirements.go
@ -6,7 +6,7 @@ type TestingT interface {
 	FailNow()
 }

-type tHelper = interface {
+type tHelper interface {
 	Helper()
 }

--- a/require/requirements_test.go
+++ b/require/requirements_test.go
@ -5,8 +5,6 @@ import (
 	"errors"
 	"testing"
 	"time"
-
-	"github.com/stretchr/testify/assert"
 )

 // AssertionTesterInterface defines an interface to be used for testing assertion methods
@ -683,30 +681,3 @@ func TestErrorAssertionFunc(t *testing.T) {
 		})
 	}
 }
-
-func TestEventuallyWithTFalse(t *testing.T) {
-	mockT := new(MockT)
-
-	condition := func(collect *assert.CollectT) {
-		True(collect, false)
-	}
-
-	EventuallyWithT(mockT, condition, 100*time.Millisecond, 20*time.Millisecond)
-	True(t, mockT.Failed, "Check should fail")
-}
-
-func TestEventuallyWithTTrue(t *testing.T) {
-	mockT := new(MockT)
-
-	counter := 0
-	condition := func(collect *assert.CollectT) {
-		defer func() {
-			counter += 1
-		}()
-		True(collect, counter == 1)
-	}
-
-	EventuallyWithT(mockT, condition, 100*time.Millisecond, 20*time.Millisecond)
-	False(t, mockT.Failed, "Check should pass")
-	Equal(t, 2, counter, "Condition is expected to be called 2 times")
-}
--- a/suite/doc.go
+++ b/suite/doc.go
@ -5,8 +5,6 @@
 // or individual tests (depending on which interface(s) you
 // implement).
 //
-// The suite package does not support parallel tests. See [issue 934].
-//
 // A testing suite is usually built by first extending the built-in
 // suite functionality from suite.Suite in testify.  Alternatively,
 // you could reproduce that logic on your own if you wanted (you
@ -65,6 +63,4 @@
 //	func TestExampleTestSuite(t *testing.T) {
 //	    suite.Run(t, new(ExampleTestSuite))
 //	}
-//
-// [issue 934]: https://github.com/stretchr/testify/issues/934
 package suite
--- a/suite/suite_test.go
+++ b/suite/suite_test.go
@ -4,7 +4,7 @@ import (
 	"bytes"
 	"errors"
 	"flag"
-	"io"
+	"io/ioutil"
 	"math/rand"
 	"os"
 	"os/exec"
@ -440,7 +440,7 @@ func (sc *StdoutCapture) StopCapture() (string, error) {
 	}
 	os.Stdout.Close()
 	os.Stdout = sc.oldStdout
-	bytes, err := io.ReadAll(sc.readPipe)
+	bytes, err := ioutil.ReadAll(sc.readPipe)
 	if err != nil {
 		return "", err
 	}
@ -604,44 +604,14 @@ func TestFailfastSuite(t *testing.T) {
 		}},
 	)
 	assert.False(t, ok)
-	var expect []string
 	if failFast {
 		// Test A Fails and because we are running with failfast Test B never runs and we proceed straight to TearDownSuite
-		expect = []string{"SetupSuite", "SetupTest", "Test A Fails", "TearDownTest", "TearDownSuite"}
+		assert.Equal(t, "SetupSuite;SetupTest;Test A Fails;TearDownTest;TearDownSuite", strings.Join(s.callOrder, ";"))
 	} else {
 		// Test A Fails and because we are running without failfast we continue and run Test B and then proceed to TearDownSuite
-		expect = []string{"SetupSuite", "SetupTest", "Test A Fails", "TearDownTest", "SetupTest", "Test B Passes", "TearDownTest", "TearDownSuite"}
+		assert.Equal(t, "SetupSuite;SetupTest;Test A Fails;TearDownTest;SetupTest;Test B Passes;TearDownTest;TearDownSuite", strings.Join(s.callOrder, ";"))
 	}
-	callOrderAssert(t, expect, s.callOrder)
 }
-
-type tHelper interface {
-	Helper()
-}
-
-// callOrderAssert is a help with confirms that asserts that expect
-// matches one or more times in callOrder. This makes it compatible
-// with go test flag -count=X where X > 1.
-func callOrderAssert(t *testing.T, expect, callOrder []string) {
-	var ti interface{} = t
-	if h, ok := ti.(tHelper); ok {
-		h.Helper()
-	}
-
-	callCount := len(callOrder)
-	expectCount := len(expect)
-	if callCount > expectCount && callCount%expectCount == 0 {
-		// Command line flag -count=X where X > 1.
-		for len(callOrder) >= expectCount {
-			assert.Equal(t, expect, callOrder[:expectCount])
-			callOrder = callOrder[expectCount:]
-		}
-		return
-	}
-
-	assert.Equal(t, expect, callOrder)
-}
-
 func TestFailfastSuiteFailFastOn(t *testing.T) {
 	// To test this with failfast on (and isolated from other intended test failures in our test suite) we launch it in its own process
 	cmd := exec.Command("go", "test", "-v", "-race", "-run", "TestFailfastSuite", "-failfast")