49 changed files with 1598 additions and 4952 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/ISSUE_TEMPLATE/bug_report.md
+++ b/.github/ISSUE_TEMPLATE/bug_report.md
@ -1,23 +0,0 @@
---
-name: Bug report
-about: Format to report a bug
-title: ''
-labels: bug
-assignees: ''
-
---
-
-<!-- If this is a question, consider using the discussion section of this repo -->
-<!-- Here: https://github.com/stretchr/testify/discussions/new?category=q-a -->
-
-## Description
-<!-- A detailed description of the bug -->
-
-## Step To Reproduce
-<!-- Steps or code snippet to reproduce the behavior -->
-
-## Expected behavior
-<!-- A clear and concise description of what you expected to happen -->
-
-## Actual behavior
-<!-- What testify does -->
--- a/.github/ISSUE_TEMPLATE/feature_request.md
+++ b/.github/ISSUE_TEMPLATE/feature_request.md
@ -1,20 +0,0 @@
---
-name: Feature request
-about: Propose a new feature
-title: ''
-labels: enhancement
-assignees: ''
-
---
-
-<!-- If this is a question, consider using the discussion section of this repo -->
-<!-- Here: https://github.com/stretchr/testify/discussions/new?category=q-a -->
-
-## Description
-<!-- A clear and concise description of what feature you are proposing -->
-
-## Proposed solution
-<!-- Optionally a suggested implementation -->
-
-## Use case
-<!-- What is the motivation? What workarounds have you used? -->
--- a/.github/workflows/main.yml
+++ b/.github/workflows/main.yml
@ -6,36 +6,14 @@ jobs:
    runs-on: ubuntu-latest
    strategy:
      matrix:
-        go_version:
-          - stable
-          - oldstable
+        go_version: ["1.18.1", "1.17.6", "1.16.5"]
    steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v3
      - name: Setup Go
-        uses: actions/setup-go@v5
+        uses: actions/setup-go@v3.2.0
        with:
          go-version: ${{ matrix.go_version }}
-      - run: npm install -g mdsf-cli
-      - run: ./.ci.gogenerate.sh
+      - run: ./.ci.gogenerate.sh    
      - run: ./.ci.gofmt.sh
-      - run: ./.ci.readme.fmt.sh
      - run: ./.ci.govet.sh
      - run: go test -v -race ./...
-  test:
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        go_version:
-          - "1.17"
-          - "1.18"
-          - "1.19"
-          - "1.20"
-          - "1.21"
-          - "1.22"
-    steps:
-      - uses: actions/checkout@v4
-      - name: Setup Go
-        uses: actions/setup-go@v5
-        with:
-          go-version: ${{ matrix.go_version }}
-      - run: go test -v -race ./...
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@ -1,21 +0,0 @@
-name: Create release from new tag
-
-# this flow will be run only when new tags are pushed that match our pattern
-on:
-  push:
-    tags:
-      - "v[0-9]+.[0-9]+.[0-9]+"
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    permissions:
-      contents: write
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-
-      - name: Create GitHub release from tag
-        uses: softprops/action-gh-release@v2
-        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/EMERITUS.md
+++ b/EMERITUS.md
@ -1,12 +0,0 @@
-# Emeritus
-
-We would like to acknowledge previous testify maintainers and their huge contributions to our collective success:
-
-  * @matryer
-  * @glesica
-  * @ernesto-jimenez
-  * @mvdkleijn
-  * @georgelesica-wf
-  * @bencampbell-wf
-
-We thank these members for their service to this community.
--- a/MAINTAINERS.md
+++ b/MAINTAINERS.md
@ -3,15 +3,7 @@
 The individuals listed below are active in the project and have the ability to approve and merge
 pull requests.

+  * @glesica
  * @boyan-soubachov
-  * @dolmen
-  * @MovieStoreGuy
-  * @brackendawson
+  * @mvdkleijn

-## Approvers
-
-The individuals listed below are active in the project and have the ability to approve pull
-requests.
-
-  * @arjunmahishi
-  * @ccoVeille
--- a/README.md
+++ b/README.md
@ -1,11 +1,9 @@
 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)
+[![Build Status](https://travis-ci.org/stretchr/testify.svg)](https://travis-ci.org/stretchr/testify) [![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)

 Go code (golang) set of packages that provide many tools for testifying that your code will behave as you intend.

@ -18,12 +16,14 @@ Features include:
 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)
+  * For an introduction to writing test code in Go, see http://golang.org/doc/code.html#Testing
+  * Check out the API Documentation http://godoc.org/github.com/stretchr/testify
+  * To make your testing life easier, check out our other project, [gorc](http://github.com/stretchr/gorc)
+  * A little about [Test-Driven Development (TDD)](http://en.wikipedia.org/wiki/Test-driven_development)

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

 The `assert` package provides some helpful methods that allow you to write better test code in Go.
@ -38,27 +38,30 @@ See it in action:
 package yours

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

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

-	// assert inequality
-	assert.NotEqual(t, 123, 456, "they should not be equal")
+  // assert equality
+  assert.Equal(t, 123, 123, "they should be equal")

-	// assert for nil (good for errors)
-	assert.Nil(t, object)
+  // assert inequality
+  assert.NotEqual(t, 123, 456, "they should not be equal")
+
+  // assert for nil (good for errors)
+  assert.Nil(t, object)
+
+  // 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)
+
+  }

-	// 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)
-	}
 }
 ```

@ -71,55 +74,52 @@ if you assert many times, use the below:
 package yours

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

 func TestSomething(t *testing.T) {
-	assert := assert.New(t)
+  assert := assert.New(t)

-	// assert equality
-	assert.Equal(123, 123, "they should be equal")
+  // assert equality
+  assert.Equal(123, 123, "they should be equal")

-	// assert inequality
-	assert.NotEqual(123, 456, "they should not be equal")
+  // assert inequality
+  assert.NotEqual(123, 456, "they should not be equal")

-	// assert for nil (good for errors)
-	assert.Nil(object)
+  // assert for nil (good for errors)
+  assert.Nil(object)

-	// 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)
-	}
+  // 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)
+  }
 }
 ```

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

 The `require` package provides same global functions as the `assert` package, but instead of returning a boolean result they terminate current test.
-These functions must be called from the goroutine running the test or benchmark function, not from other goroutines created during the test.
-Otherwise race conditions may occur.

-See [t.FailNow](https://pkg.go.dev/testing#T.FailNow) for details.
+See [t.FailNow](http://golang.org/pkg/testing/#T.FailNow) for details.

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

 The `mock` package provides a mechanism for easily writing mock objects that can be used in place of real objects when writing test code.

-An example test function that tests a piece of code that relies on an external object `testObj`, can set up expectations (testify) and assert that they indeed happened:
+An example test function that tests a piece of code that relies on an external object `testObj`, can setup expectations (testify) and assert that they indeed happened:

 ```go
 package yours

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

 /*
@ -128,8 +128,8 @@ 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 {
-	mock.Mock
+type MyMockedObject struct{
+  mock.Mock
 }

 // DoSomething is a method on MyMockedObject that implements some interface
@ -140,8 +140,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)
+
+  args := m.Called(number)
+  return args.Bool(0), args.Error(1)
+
 }

 /*
@ -151,17 +153,20 @@ 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)

-	// set up expectations
-	testObj.On("DoSomething", 123).Return(true, nil)
+  // create an instance of our test object
+  testObj := new(MyMockedObject)
+
+  // setup expectations
+  testObj.On("DoSomething", 123).Return(true, nil)
+
+  // call the code we are testing
+  targetFuncThatDoesSomethingWithObj(testObj)
+
+  // assert that the expectations were met
+  testObj.AssertExpectations(t)

-	// call the code we are testing
-	targetFuncThatDoesSomethingWithObj(testObj)

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

 // TestSomethingWithPlaceholder is a second example of how to use our test object to
@ -170,131 +175,105 @@ 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)

-	// set up expectations with a placeholder in the argument list
-	testObj.On("DoSomething", mock.Anything).Return(true, nil)
+  // create an instance of our test object
+  testObj := new(MyMockedObject)

-	// call the code we are testing
-	targetFuncThatDoesSomethingWithObj(testObj)
+  // setup expectations with a placeholder in the argument list
+  testObj.On("DoSomething", mock.Anything).Return(true, nil)

-	// assert that the expectations were met
-	testObj.AssertExpectations(t)
+  // call the code we are testing
+  targetFuncThatDoesSomethingWithObj(testObj)

-}
+  // 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)

-	// set up expectations with a placeholder in the argument list
-	mockCall := testObj.On("DoSomething", mock.Anything).Return(true, nil)
-
-	// call the code we are testing
-	targetFuncThatDoesSomethingWithObj(testObj)
-
-	// assert that the expectations were met
-	testObj.AssertExpectations(t)
-
-	// remove the handler now so we can add another one that takes precedence
-	mockCall.Unset()
-
-	// return false now instead of true
-	testObj.On("DoSomething", mock.Anything).Return(false, nil)
-
-	testObj.AssertExpectations(t)
 }
 ```

-For more information on how to write mock code, check out the [API documentation for the `mock` package](https://pkg.go.dev/github.com/stretchr/testify/mock).
+For more information on how to write mock code, check out the [API documentation for the `mock` package](http://godoc.org/github.com/stretchr/testify/mock).

-You can use the [mockery tool](https://vektra.github.io/mockery/latest/) to autogenerate the mock code against an interface as well, making using mocks much quicker.
+You can use the [mockery tool](http://github.com/vektra/mockery) to autogenerate the mock code against an interface as well, making using mocks much quicker.

-[`suite`](https://pkg.go.dev/github.com/stretchr/testify/suite "API documentation") package
+[`suite`](http://godoc.org/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.
+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.

 An example suite is shown below:

 ```go
 // Basic imports
 import (
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/suite"
+    "testing"
+    "github.com/stretchr/testify/assert"
+    "github.com/stretchr/testify/suite"
 )

 // Define the suite, and absorb the built-in basic suite
 // functionality from testify - including a T() method which
 // returns the current testing context
 type ExampleTestSuite struct {
-	suite.Suite
-	VariableThatShouldStartAtFive int
+    suite.Suite
+    VariableThatShouldStartAtFive int
 }

 // Make sure that VariableThatShouldStartAtFive is set to five
 // before each test
 func (suite *ExampleTestSuite) SetupTest() {
-	suite.VariableThatShouldStartAtFive = 5
+    suite.VariableThatShouldStartAtFive = 5
 }

 // All methods that begin with "Test" are run as tests within a
 // suite.
 func (suite *ExampleTestSuite) TestExample() {
-	assert.Equal(suite.T(), 5, suite.VariableThatShouldStartAtFive)
+    assert.Equal(suite.T(), 5, suite.VariableThatShouldStartAtFive)
 }

 // In order for 'go test' to run this suite, we need to create
 // a normal test function and pass our suite to suite.Run
 func TestExampleTestSuite(t *testing.T) {
-	suite.Run(t, new(ExampleTestSuite))
+    suite.Run(t, new(ExampleTestSuite))
 }
 ```

 For a more complete example, using all of the functionality provided by the suite package, look at our [example testing suite](https://github.com/stretchr/testify/blob/master/suite/suite_test.go)

-For more information on writing suites, check out the [API documentation for the `suite` package](https://pkg.go.dev/github.com/stretchr/testify/suite).
+For more information on writing suites, check out the [API documentation for the `suite` package](http://godoc.org/github.com/stretchr/testify/suite).

 `Suite` object has assertion methods:

 ```go
 // Basic imports
 import (
-	"testing"
-
-	"github.com/stretchr/testify/suite"
+    "testing"
+    "github.com/stretchr/testify/suite"
 )

 // Define the suite, and absorb the built-in basic suite
 // functionality from testify - including assertion methods.
 type ExampleTestSuite struct {
-	suite.Suite
-	VariableThatShouldStartAtFive int
+    suite.Suite
+    VariableThatShouldStartAtFive int
 }

 // Make sure that VariableThatShouldStartAtFive is set to five
 // before each test
 func (suite *ExampleTestSuite) SetupTest() {
-	suite.VariableThatShouldStartAtFive = 5
+    suite.VariableThatShouldStartAtFive = 5
 }

 // All methods that begin with "Test" are run as tests within a
 // suite.
 func (suite *ExampleTestSuite) TestExample() {
-	suite.Equal(suite.VariableThatShouldStartAtFive, 5)
+    suite.Equal(suite.VariableThatShouldStartAtFive, 5)
 }

 // In order for 'go test' to run this suite, we need to create
 // a normal test function and pass our suite to suite.Run
 func TestExampleTestSuite(t *testing.T) {
-	suite.Run(t, new(ExampleTestSuite))
+    suite.Run(t, new(ExampleTestSuite))
 }
 ```

@ -321,13 +300,14 @@ Import the `testify/assert` package into your code using this template:
 package yours

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

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

@ -343,7 +323,7 @@ To update Testify to the latest version, use `go get -u github.com/stretchr/test
 Supported go versions
 ==================

-We currently support the most recent major Go versions from 1.19 onward.
+We currently support the most recent major Go versions from 1.13 onward.

 ------

@ -354,7 +334,7 @@ Please feel free to submit issues, fork the repository and send pull requests!

 When submitting an issue, we ask that you please include a complete test function that demonstrates the issue. Extra credit for those using Testify to write the test code that demonstrates it.

-Code generation is used. [Look for `Code generated with`](https://github.com/search?q=repo%3Astretchr%2Ftestify%20%22Code%20generated%20with%22&type=code) at the top of some files. Run `go generate ./...` to update generated files.
+Code generation is used. Look for `CODE GENERATED AUTOMATICALLY` at the top of some files. Run `go generate ./...` to update generated files.

 We also chat on the [Gophers Slack](https://gophers.slack.com) group in the `#testify` and `#testify-dev` channels.

--- 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
 		}
@ -298,8 +297,10 @@ func (f *testFunc) CommentWithoutT(receiver string) string {
 	return strings.Replace(f.Comment(), search, replace, -1)
 }

-// Standard header https://go.dev/s/generatedcode.
-var headerTemplate = `// Code generated with github.com/stretchr/testify/_codegen; DO NOT EDIT.
+var headerTemplate = `/*
+* CODE GENERATED AUTOMATICALLY WITH github.com/stretchr/testify/_codegen
+* THIS FILE MUST NOT BE EDITED BY HAND
+*/

 package {{.Name}}

--- a/assert/assertion_compare.go
+++ b/assert/assertion_compare.go
@ -1,19 +1,15 @@
 package assert

 import (
-	"bytes"
 	"fmt"
 	"reflect"
 	"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
 )
@ -31,18 +27,15 @@ var (
 	uint32Type = reflect.TypeOf(uint32(1))
 	uint64Type = reflect.TypeOf(uint64(1))

-	uintptrType = reflect.TypeOf(uintptr(1))
-
 	float32Type = reflect.TypeOf(float32(1))
 	float64Type = reflect.TypeOf(float64(1))

 	stringType = reflect.TypeOf("")

-	timeType  = reflect.TypeOf(time.Time{})
-	bytesType = reflect.TypeOf([]byte{})
+	timeType = reflect.TypeOf(time.Time{})
 )

-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)

@ -313,11 +306,11 @@ func compare(obj1, obj2 interface{}, kind reflect.Kind) (compareResult, bool) {
 	case reflect.Struct:
 		{
 			// All structs enter here. We're not interested in most types.
-			if !obj1Value.CanConvert(timeType) {
+			if !canConvert(obj1Value, timeType) {
 				break
 			}

-			// time.Time can be compared!
+			// time.Time can compared!
 			timeObj1, ok := obj1.(time.Time)
 			if !ok {
 				timeObj1 = obj1Value.Convert(timeType).Interface().(time.Time)
@ -328,53 +321,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
-		}
-	case reflect.Slice:
-		{
-			// We only care about the []byte type.
-			if !obj1Value.CanConvert(bytesType) {
-				break
-			}
-
-			// []byte can be compared!
-			bytesObj1, ok := obj1.([]byte)
-			if !ok {
-				bytesObj1 = obj1Value.Convert(bytesType).Interface().([]byte)
-
-			}
-			bytesObj2, ok := obj2.([]byte)
-			if !ok {
-				bytesObj2 = obj2Value.Convert(bytesType).Interface().([]byte)
-			}
-
-			return compareResult(bytes.Compare(bytesObj1, bytesObj2)), true
-		}
-	case reflect.Uintptr:
-		{
-			uintptrObj1, ok := obj1.(uintptr)
-			if !ok {
-				uintptrObj1 = obj1Value.Convert(uintptrType).Interface().(uintptr)
-			}
-			uintptrObj2, ok := obj2.(uintptr)
-			if !ok {
-				uintptrObj2 = obj2Value.Convert(uintptrType).Interface().(uintptr)
-			}
-			if uintptrObj1 > uintptrObj2 {
-				return compareGreater, true
-			}
-			if uintptrObj1 == uintptrObj2 {
-				return compareEqual, true
-			}
-			if uintptrObj1 < uintptrObj2 {
-				return compareLess, true
-			}
+			return compare(timeObj1.UnixNano(), timeObj2.UnixNano(), reflect.Int64)
 		}
 	}

@ -383,85 +330,79 @@ func compare(obj1, obj2 interface{}, kind reflect.Kind) (compareResult, bool) {

 // Greater asserts that the first element is greater than the second
 //
-//	assert.Greater(t, 2, 1)
-//	assert.Greater(t, float64(2), float64(1))
-//	assert.Greater(t, "b", "a")
+//    assert.Greater(t, 2, 1)
+//    assert.Greater(t, float64(2), float64(1))
+//    assert.Greater(t, "b", "a")
 func Greater(t TestingT, e1 interface{}, e2 interface{}, msgAndArgs ...interface{}) bool {
 	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
 //
-//	assert.GreaterOrEqual(t, 2, 1)
-//	assert.GreaterOrEqual(t, 2, 2)
-//	assert.GreaterOrEqual(t, "b", "a")
-//	assert.GreaterOrEqual(t, "b", "b")
+//    assert.GreaterOrEqual(t, 2, 1)
+//    assert.GreaterOrEqual(t, 2, 2)
+//    assert.GreaterOrEqual(t, "b", "a")
+//    assert.GreaterOrEqual(t, "b", "b")
 func GreaterOrEqual(t TestingT, e1 interface{}, e2 interface{}, msgAndArgs ...interface{}) bool {
 	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
 //
-//	assert.Less(t, 1, 2)
-//	assert.Less(t, float64(1), float64(2))
-//	assert.Less(t, "a", "b")
+//    assert.Less(t, 1, 2)
+//    assert.Less(t, float64(1), float64(2))
+//    assert.Less(t, "a", "b")
 func Less(t TestingT, e1 interface{}, e2 interface{}, msgAndArgs ...interface{}) bool {
 	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
 //
-//	assert.LessOrEqual(t, 1, 2)
-//	assert.LessOrEqual(t, 2, 2)
-//	assert.LessOrEqual(t, "a", "b")
-//	assert.LessOrEqual(t, "b", "b")
+//    assert.LessOrEqual(t, 1, 2)
+//    assert.LessOrEqual(t, 2, 2)
+//    assert.LessOrEqual(t, "a", "b")
+//    assert.LessOrEqual(t, "b", "b")
 func LessOrEqual(t TestingT, e1 interface{}, e2 interface{}, msgAndArgs ...interface{}) bool {
 	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
 //
-//	assert.Positive(t, 1)
-//	assert.Positive(t, 1.23)
+//    assert.Positive(t, 1)
+//    assert.Positive(t, 1.23)
 func Positive(t TestingT, e interface{}, msgAndArgs ...interface{}) bool {
 	if h, ok := t.(tHelper); ok {
 		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
 //
-//	assert.Negative(t, -1)
-//	assert.Negative(t, -1.23)
+//    assert.Negative(t, -1)
+//    assert.Negative(t, -1.23)
 func Negative(t TestingT, e interface{}, msgAndArgs ...interface{}) bool {
 	if h, ok := t.(tHelper); ok {
 		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 +415,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_can_convert.go
+++ b/assert/assertion_compare_can_convert.go
@ -0,0 +1,16 @@
+//go:build go1.17
+// +build go1.17
+
+// TODO: once support for Go 1.16 is dropped, this file can be
+//       merged/removed with assertion_compare_go1.17_test.go and
+//       assertion_compare_legacy.go
+
+package assert
+
+import "reflect"
+
+// Wrapper around reflect.Value.CanConvert, for compatibility
+// reasons.
+func canConvert(value reflect.Value, to reflect.Type) bool {
+	return value.CanConvert(to)
+}
--- a/assert/assertion_compare_go1.17_test.go
+++ b/assert/assertion_compare_go1.17_test.go
@ -0,0 +1,54 @@
+//go:build go1.17
+// +build go1.17
+
+// TODO: once support for Go 1.16 is dropped, this file can be
+//       merged/removed with assertion_compare_can_convert.go and
+//       assertion_compare_legacy.go
+
+package assert
+
+import (
+	"reflect"
+	"testing"
+	"time"
+)
+
+func TestCompare17(t *testing.T) {
+	type customTime time.Time
+	for _, currCase := range []struct {
+		less    interface{}
+		greater interface{}
+		cType   string
+	}{
+		{less: time.Now(), greater: time.Now().Add(time.Hour), cType: "time.Time"},
+		{less: customTime(time.Now()), greater: customTime(time.Now().Add(time.Hour)), cType: "time.Time"},
+	} {
+		resLess, isComparable := compare(currCase.less, currCase.greater, reflect.ValueOf(currCase.less).Kind())
+		if !isComparable {
+			t.Error("object should be comparable for type " + currCase.cType)
+		}
+
+		if resLess != compareLess {
+			t.Errorf("object less (%v) should be less than greater (%v) for type "+currCase.cType,
+				currCase.less, currCase.greater)
+		}
+
+		resGreater, isComparable := compare(currCase.greater, currCase.less, reflect.ValueOf(currCase.less).Kind())
+		if !isComparable {
+			t.Error("object are comparable for type " + currCase.cType)
+		}
+
+		if resGreater != compareGreater {
+			t.Errorf("object greater should be greater than less for type " + currCase.cType)
+		}
+
+		resEqual, isComparable := compare(currCase.less, currCase.less, reflect.ValueOf(currCase.less).Kind())
+		if !isComparable {
+			t.Error("object are comparable for type " + currCase.cType)
+		}
+
+		if resEqual != 0 {
+			t.Errorf("objects should be equal for type " + currCase.cType)
+		}
+	}
+}
--- a/assert/assertion_compare_legacy.go
+++ b/assert/assertion_compare_legacy.go
@ -0,0 +1,16 @@
+//go:build !go1.17
+// +build !go1.17
+
+// TODO: once support for Go 1.16 is dropped, this file can be
+//       merged/removed with assertion_compare_go1.17_test.go and
+//       assertion_compare_can_convert.go
+
+package assert
+
+import "reflect"
+
+// Older versions of Go does not have the reflect.Value.CanConvert
+// method.
+func canConvert(value reflect.Value, to reflect.Type) bool {
+	return false
+}
--- a/assert/assertion_compare_test.go
+++ b/assert/assertion_compare_test.go
@ -6,11 +6,9 @@ import (
 	"reflect"
 	"runtime"
 	"testing"
-	"time"
 )

 func TestCompare(t *testing.T) {
-	type customString string
 	type customInt int
 	type customInt8 int8
 	type customInt16 int16
@ -23,9 +21,7 @@ func TestCompare(t *testing.T) {
 	type customUInt64 uint64
 	type customFloat32 float32
 	type customFloat64 float64
-	type customUintptr uintptr
-	type customTime time.Time
-	type customBytes []byte
+	type customString string
 	for _, currCase := range []struct {
 		less    interface{}
 		greater interface{}
@ -56,13 +52,6 @@ func TestCompare(t *testing.T) {
 		{less: customFloat32(1.23), greater: customFloat32(2.23), cType: "float32"},
 		{less: float64(1.23), greater: float64(2.34), cType: "float64"},
 		{less: customFloat64(1.23), greater: customFloat64(2.34), cType: "float64"},
-		{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"},
 	} {
 		resLess, isComparable := compare(currCase.less, currCase.greater, reflect.ValueOf(currCase.less).Kind())
 		if !isComparable {
@ -159,9 +148,6 @@ func TestGreater(t *testing.T) {
 		{less: uint64(1), greater: uint64(2), msg: `"1" is not greater than "2"`},
 		{less: float32(1.23), greater: float32(2.34), msg: `"1.23" is not greater than "2.34"`},
 		{less: float64(1.23), greater: float64(2.34), msg: `"1.23" is not greater than "2.34"`},
-		{less: uintptr(1), greater: uintptr(2), msg: `"1" is not greater than "2"`},
-		{less: time.Time{}, greater: time.Time{}.Add(time.Hour), msg: `"0001-01-01 00:00:00 +0000 UTC" is not greater than "0001-01-01 01:00:00 +0000 UTC"`},
-		{less: []byte{1, 1}, greater: []byte{1, 2}, msg: `"[1 1]" is not greater than "[1 2]"`},
 	} {
 		out := &outputT{buf: bytes.NewBuffer(nil)}
 		False(t, Greater(out, currCase.less, currCase.greater))
@ -203,9 +189,6 @@ func TestGreaterOrEqual(t *testing.T) {
 		{less: uint64(1), greater: uint64(2), msg: `"1" is not greater than or equal to "2"`},
 		{less: float32(1.23), greater: float32(2.34), msg: `"1.23" is not greater than or equal to "2.34"`},
 		{less: float64(1.23), greater: float64(2.34), msg: `"1.23" is not greater than or equal to "2.34"`},
-		{less: uintptr(1), greater: uintptr(2), msg: `"1" is not greater than or equal to "2"`},
-		{less: time.Time{}, greater: time.Time{}.Add(time.Hour), msg: `"0001-01-01 00:00:00 +0000 UTC" is not greater than or equal to "0001-01-01 01:00:00 +0000 UTC"`},
-		{less: []byte{1, 1}, greater: []byte{1, 2}, msg: `"[1 1]" is not greater than or equal to "[1 2]"`},
 	} {
 		out := &outputT{buf: bytes.NewBuffer(nil)}
 		False(t, GreaterOrEqual(out, currCase.less, currCase.greater))
@ -247,9 +230,6 @@ func TestLess(t *testing.T) {
 		{less: uint64(1), greater: uint64(2), msg: `"2" is not less than "1"`},
 		{less: float32(1.23), greater: float32(2.34), msg: `"2.34" is not less than "1.23"`},
 		{less: float64(1.23), greater: float64(2.34), msg: `"2.34" is not less than "1.23"`},
-		{less: uintptr(1), greater: uintptr(2), msg: `"2" is not less than "1"`},
-		{less: time.Time{}, greater: time.Time{}.Add(time.Hour), msg: `"0001-01-01 01:00:00 +0000 UTC" is not less than "0001-01-01 00:00:00 +0000 UTC"`},
-		{less: []byte{1, 1}, greater: []byte{1, 2}, msg: `"[1 2]" is not less than "[1 1]"`},
 	} {
 		out := &outputT{buf: bytes.NewBuffer(nil)}
 		False(t, Less(out, currCase.greater, currCase.less))
@ -291,9 +271,6 @@ func TestLessOrEqual(t *testing.T) {
 		{less: uint64(1), greater: uint64(2), msg: `"2" is not less than or equal to "1"`},
 		{less: float32(1.23), greater: float32(2.34), msg: `"2.34" is not less than or equal to "1.23"`},
 		{less: float64(1.23), greater: float64(2.34), msg: `"2.34" is not less than or equal to "1.23"`},
-		{less: uintptr(1), greater: uintptr(2), msg: `"2" is not less than or equal to "1"`},
-		{less: time.Time{}, greater: time.Time{}.Add(time.Hour), msg: `"0001-01-01 01:00:00 +0000 UTC" is not less than or equal to "0001-01-01 00:00:00 +0000 UTC"`},
-		{less: []byte{1, 1}, greater: []byte{1, 2}, msg: `"[1 2]" is not less than or equal to "[1 1]"`},
 	} {
 		out := &outputT{buf: bytes.NewBuffer(nil)}
 		False(t, LessOrEqual(out, currCase.greater, currCase.less))
@ -393,8 +370,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 +389,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)
 	}
 }

@ -421,35 +398,35 @@ func Test_compareTwoValuesCorrectCompareResult(t *testing.T) {
 	mockT := new(testing.T)

 	for _, currCase := range []struct {
-		v1             interface{}
-		v2             interface{}
-		allowedResults []compareResult
+		v1           interface{}
+		v2           interface{}
+		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
@ -1,4 +1,7 @@
-// Code generated with github.com/stretchr/testify/_codegen; DO NOT EDIT.
+/*
+* CODE GENERATED AUTOMATICALLY WITH github.com/stretchr/testify/_codegen
+* THIS FILE MUST NOT BE EDITED BY HAND
+ */

 package assert

@ -19,9 +22,9 @@ func Conditionf(t TestingT, comp Comparison, msg string, args ...interface{}) bo
 // Containsf asserts that the specified string, list(array, slice...) or map contains the
 // specified substring or element.
 //
-//	assert.Containsf(t, "Hello World", "World", "error message %s", "formatted")
-//	assert.Containsf(t, ["Hello", "World"], "World", "error message %s", "formatted")
-//	assert.Containsf(t, {"Hello": "World"}, "Hello", "error message %s", "formatted")
+//    assert.Containsf(t, "Hello World", "World", "error message %s", "formatted")
+//    assert.Containsf(t, ["Hello", "World"], "World", "error message %s", "formatted")
+//    assert.Containsf(t, {"Hello": "World"}, "Hello", "error message %s", "formatted")
 func Containsf(t TestingT, s interface{}, contains interface{}, msg string, args ...interface{}) bool {
 	if h, ok := t.(tHelper); ok {
 		h.Helper()
@ -53,7 +56,7 @@ func ElementsMatchf(t TestingT, listA interface{}, listB interface{}, msg string
 // Emptyf asserts that the specified object is empty.  I.e. nil, "", false, 0 or either
 // a slice or a channel with len == 0.
 //
-//	assert.Emptyf(t, obj, "error message %s", "formatted")
+//  assert.Emptyf(t, obj, "error message %s", "formatted")
 func Emptyf(t TestingT, object interface{}, msg string, args ...interface{}) bool {
 	if h, ok := t.(tHelper); ok {
 		h.Helper()
@ -63,7 +66,7 @@ func Emptyf(t TestingT, object interface{}, msg string, args ...interface{}) boo

 // Equalf asserts that two objects are equal.
 //
-//	assert.Equalf(t, 123, 123, "error message %s", "formatted")
+//    assert.Equalf(t, 123, 123, "error message %s", "formatted")
 //
 // Pointer variable equality is determined based on the equality of the
 // referenced values (as opposed to the memory addresses). Function equality
@ -78,8 +81,8 @@ func Equalf(t TestingT, expected interface{}, actual interface{}, msg string, ar
 // EqualErrorf asserts that a function returned an error (i.e. not `nil`)
 // and that it is equal to the provided error.
 //
-//	actualObj, err := SomeFunction()
-//	assert.EqualErrorf(t, err,  expectedErrorString, "error message %s", "formatted")
+//   actualObj, err := SomeFunction()
+//   assert.EqualErrorf(t, err,  expectedErrorString, "error message %s", "formatted")
 func EqualErrorf(t TestingT, theError error, errString string, msg string, args ...interface{}) bool {
 	if h, ok := t.(tHelper); ok {
 		h.Helper()
@ -87,27 +90,10 @@ func EqualErrorf(t TestingT, theError error, errString string, msg string, args
 	return EqualError(t, theError, errString, append([]interface{}{msg}, args...)...)
 }

-// EqualExportedValuesf asserts that the types of two objects are equal and their public
-// fields are also equal. This is useful for comparing structs that have private fields
-// that could potentially differ.
+// EqualValuesf asserts that two objects are equal or convertable to the same types
+// and equal.
 //
-//	 type S struct {
-//		Exported     	int
-//		notExported   	int
-//	 }
-//	 assert.EqualExportedValuesf(t, S{1, 2}, S{1, 3}, "error message %s", "formatted") => true
-//	 assert.EqualExportedValuesf(t, S{1, 2}, S{2, 3}, "error message %s", "formatted") => false
-func EqualExportedValuesf(t TestingT, expected interface{}, actual interface{}, msg string, args ...interface{}) bool {
-	if h, ok := t.(tHelper); ok {
-		h.Helper()
-	}
-	return EqualExportedValues(t, expected, actual, append([]interface{}{msg}, args...)...)
-}
-
-// EqualValuesf asserts that two objects are equal or convertible to the larger
-// type and equal.
-//
-//	assert.EqualValuesf(t, uint32(123), int32(123), "error message %s", "formatted")
+//    assert.EqualValuesf(t, uint32(123), int32(123), "error message %s", "formatted")
 func EqualValuesf(t TestingT, expected interface{}, actual interface{}, msg string, args ...interface{}) bool {
 	if h, ok := t.(tHelper); ok {
 		h.Helper()
@ -117,10 +103,10 @@ func EqualValuesf(t TestingT, expected interface{}, actual interface{}, msg stri

 // Errorf asserts that a function returned an error (i.e. not `nil`).
 //
-//	  actualObj, err := SomeFunction()
-//	  if assert.Errorf(t, err, "error message %s", "formatted") {
-//		   assert.Equal(t, expectedErrorf, err)
-//	  }
+//   actualObj, err := SomeFunction()
+//   if assert.Errorf(t, err, "error message %s", "formatted") {
+// 	   assert.Equal(t, expectedErrorf, err)
+//   }
 func Errorf(t TestingT, err error, msg string, args ...interface{}) bool {
 	if h, ok := t.(tHelper); ok {
 		h.Helper()
@ -140,8 +126,8 @@ func ErrorAsf(t TestingT, err error, target interface{}, msg string, args ...int
 // ErrorContainsf asserts that a function returned an error (i.e. not `nil`)
 // and that the error contains the specified substring.
 //
-//	actualObj, err := SomeFunction()
-//	assert.ErrorContainsf(t, err,  expectedErrorSubString, "error message %s", "formatted")
+//   actualObj, err := SomeFunction()
+//   assert.ErrorContainsf(t, err,  expectedErrorSubString, "error message %s", "formatted")
 func ErrorContainsf(t TestingT, theError error, contains string, msg string, args ...interface{}) bool {
 	if h, ok := t.(tHelper); ok {
 		h.Helper()
@ -161,7 +147,7 @@ func ErrorIsf(t TestingT, err error, target error, msg string, args ...interface
 // Eventuallyf asserts that given condition will be met in waitFor time,
 // periodically checking target function each tick.
 //
-//	assert.Eventuallyf(t, func() bool { return true; }, time.Second, 10*time.Millisecond, "error message %s", "formatted")
+//    assert.Eventuallyf(t, func() bool { return true; }, time.Second, 10*time.Millisecond, "error message %s", "formatted")
 func Eventuallyf(t TestingT, condition func() bool, waitFor time.Duration, tick time.Duration, msg string, args ...interface{}) bool {
 	if h, ok := t.(tHelper); ok {
 		h.Helper()
@ -169,34 +155,9 @@ func Eventuallyf(t TestingT, condition func() bool, waitFor time.Duration, tick
 	return Eventually(t, condition, waitFor, tick, append([]interface{}{msg}, args...)...)
 }

-// EventuallyWithTf 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
-// function can use the CollectT to call other assertions.
-// The condition is considered "met" if no errors are raised in a tick.
-// The supplied CollectT collects all errors from one tick (if there are any).
-// If the condition is not met before waitFor, the collected errors of
-// the last tick are copied to t.
-//
-//	externalValue := false
-//	go func() {
-//		time.Sleep(8*time.Second)
-//		externalValue = true
-//	}()
-//	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")
-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()
-	}
-	return EventuallyWithT(t, condition, waitFor, tick, append([]interface{}{msg}, args...)...)
-}
-
 // Exactlyf asserts that two objects are equal in value and type.
 //
-//	assert.Exactlyf(t, int32(123), int64(123), "error message %s", "formatted")
+//    assert.Exactlyf(t, int32(123), int64(123), "error message %s", "formatted")
 func Exactlyf(t TestingT, expected interface{}, actual interface{}, msg string, args ...interface{}) bool {
 	if h, ok := t.(tHelper); ok {
 		h.Helper()
@ -222,7 +183,7 @@ func FailNowf(t TestingT, failureMessage string, msg string, args ...interface{}

 // Falsef asserts that the specified value is false.
 //
-//	assert.Falsef(t, myBool, "error message %s", "formatted")
+//    assert.Falsef(t, myBool, "error message %s", "formatted")
 func Falsef(t TestingT, value bool, msg string, args ...interface{}) bool {
 	if h, ok := t.(tHelper); ok {
 		h.Helper()
@ -241,9 +202,9 @@ func FileExistsf(t TestingT, path string, msg string, args ...interface{}) bool

 // Greaterf asserts that the first element is greater than the second
 //
-//	assert.Greaterf(t, 2, 1, "error message %s", "formatted")
-//	assert.Greaterf(t, float64(2), float64(1), "error message %s", "formatted")
-//	assert.Greaterf(t, "b", "a", "error message %s", "formatted")
+//    assert.Greaterf(t, 2, 1, "error message %s", "formatted")
+//    assert.Greaterf(t, float64(2), float64(1), "error message %s", "formatted")
+//    assert.Greaterf(t, "b", "a", "error message %s", "formatted")
 func Greaterf(t TestingT, e1 interface{}, e2 interface{}, msg string, args ...interface{}) bool {
 	if h, ok := t.(tHelper); ok {
 		h.Helper()
@ -253,10 +214,10 @@ func Greaterf(t TestingT, e1 interface{}, e2 interface{}, msg string, args ...in

 // GreaterOrEqualf asserts that the first element is greater than or equal to the second
 //
-//	assert.GreaterOrEqualf(t, 2, 1, "error message %s", "formatted")
-//	assert.GreaterOrEqualf(t, 2, 2, "error message %s", "formatted")
-//	assert.GreaterOrEqualf(t, "b", "a", "error message %s", "formatted")
-//	assert.GreaterOrEqualf(t, "b", "b", "error message %s", "formatted")
+//    assert.GreaterOrEqualf(t, 2, 1, "error message %s", "formatted")
+//    assert.GreaterOrEqualf(t, 2, 2, "error message %s", "formatted")
+//    assert.GreaterOrEqualf(t, "b", "a", "error message %s", "formatted")
+//    assert.GreaterOrEqualf(t, "b", "b", "error message %s", "formatted")
 func GreaterOrEqualf(t TestingT, e1 interface{}, e2 interface{}, msg string, args ...interface{}) bool {
 	if h, ok := t.(tHelper); ok {
 		h.Helper()
@ -267,7 +228,7 @@ func GreaterOrEqualf(t TestingT, e1 interface{}, e2 interface{}, msg string, arg
 // HTTPBodyContainsf asserts that a specified handler returns a
 // body that contains a string.
 //
-//	assert.HTTPBodyContainsf(t, myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky", "error message %s", "formatted")
+//  assert.HTTPBodyContainsf(t, myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky", "error message %s", "formatted")
 //
 // Returns whether the assertion was successful (true) or not (false).
 func HTTPBodyContainsf(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msg string, args ...interface{}) bool {
@ -280,7 +241,7 @@ func HTTPBodyContainsf(t TestingT, handler http.HandlerFunc, method string, url
 // HTTPBodyNotContainsf asserts that a specified handler returns a
 // body that does not contain a string.
 //
-//	assert.HTTPBodyNotContainsf(t, myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky", "error message %s", "formatted")
+//  assert.HTTPBodyNotContainsf(t, myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky", "error message %s", "formatted")
 //
 // Returns whether the assertion was successful (true) or not (false).
 func HTTPBodyNotContainsf(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msg string, args ...interface{}) bool {
@ -292,7 +253,7 @@ func HTTPBodyNotContainsf(t TestingT, handler http.HandlerFunc, method string, u

 // HTTPErrorf asserts that a specified handler returns an error status code.
 //
-//	assert.HTTPErrorf(t, myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}}
+//  assert.HTTPErrorf(t, myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}}
 //
 // Returns whether the assertion was successful (true) or not (false).
 func HTTPErrorf(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, msg string, args ...interface{}) bool {
@ -304,7 +265,7 @@ func HTTPErrorf(t TestingT, handler http.HandlerFunc, method string, url string,

 // HTTPRedirectf asserts that a specified handler returns a redirect status code.
 //
-//	assert.HTTPRedirectf(t, myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}}
+//  assert.HTTPRedirectf(t, myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}}
 //
 // Returns whether the assertion was successful (true) or not (false).
 func HTTPRedirectf(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, msg string, args ...interface{}) bool {
@ -316,7 +277,7 @@ func HTTPRedirectf(t TestingT, handler http.HandlerFunc, method string, url stri

 // HTTPStatusCodef asserts that a specified handler returns a specified status code.
 //
-//	assert.HTTPStatusCodef(t, myHandler, "GET", "/notImplemented", nil, 501, "error message %s", "formatted")
+//  assert.HTTPStatusCodef(t, myHandler, "GET", "/notImplemented", nil, 501, "error message %s", "formatted")
 //
 // Returns whether the assertion was successful (true) or not (false).
 func HTTPStatusCodef(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, statuscode int, msg string, args ...interface{}) bool {
@ -328,7 +289,7 @@ func HTTPStatusCodef(t TestingT, handler http.HandlerFunc, method string, url st

 // HTTPSuccessf asserts that a specified handler returns a success status code.
 //
-//	assert.HTTPSuccessf(t, myHandler, "POST", "http://www.google.com", nil, "error message %s", "formatted")
+//  assert.HTTPSuccessf(t, myHandler, "POST", "http://www.google.com", nil, "error message %s", "formatted")
 //
 // Returns whether the assertion was successful (true) or not (false).
 func HTTPSuccessf(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, msg string, args ...interface{}) bool {
@ -340,7 +301,7 @@ func HTTPSuccessf(t TestingT, handler http.HandlerFunc, method string, url strin

 // Implementsf asserts that an object is implemented by the specified interface.
 //
-//	assert.Implementsf(t, (*MyInterface)(nil), new(MyObject), "error message %s", "formatted")
+//    assert.Implementsf(t, (*MyInterface)(nil), new(MyObject), "error message %s", "formatted")
 func Implementsf(t TestingT, interfaceObject interface{}, object interface{}, msg string, args ...interface{}) bool {
 	if h, ok := t.(tHelper); ok {
 		h.Helper()
@ -350,7 +311,7 @@ func Implementsf(t TestingT, interfaceObject interface{}, object interface{}, ms

 // InDeltaf asserts that the two numerals are within delta of each other.
 //
-//	assert.InDeltaf(t, math.Pi, 22/7.0, 0.01, "error message %s", "formatted")
+// 	 assert.InDeltaf(t, math.Pi, 22/7.0, 0.01, "error message %s", "formatted")
 func InDeltaf(t TestingT, expected interface{}, actual interface{}, delta float64, msg string, args ...interface{}) bool {
 	if h, ok := t.(tHelper); ok {
 		h.Helper()
@ -392,9 +353,9 @@ func InEpsilonSlicef(t TestingT, expected interface{}, actual interface{}, epsil

 // IsDecreasingf asserts that the collection is decreasing
 //
-//	assert.IsDecreasingf(t, []int{2, 1, 0}, "error message %s", "formatted")
-//	assert.IsDecreasingf(t, []float{2, 1}, "error message %s", "formatted")
-//	assert.IsDecreasingf(t, []string{"b", "a"}, "error message %s", "formatted")
+//    assert.IsDecreasingf(t, []int{2, 1, 0}, "error message %s", "formatted")
+//    assert.IsDecreasingf(t, []float{2, 1}, "error message %s", "formatted")
+//    assert.IsDecreasingf(t, []string{"b", "a"}, "error message %s", "formatted")
 func IsDecreasingf(t TestingT, object interface{}, msg string, args ...interface{}) bool {
 	if h, ok := t.(tHelper); ok {
 		h.Helper()
@ -404,9 +365,9 @@ func IsDecreasingf(t TestingT, object interface{}, msg string, args ...interface

 // IsIncreasingf asserts that the collection is increasing
 //
-//	assert.IsIncreasingf(t, []int{1, 2, 3}, "error message %s", "formatted")
-//	assert.IsIncreasingf(t, []float{1, 2}, "error message %s", "formatted")
-//	assert.IsIncreasingf(t, []string{"a", "b"}, "error message %s", "formatted")
+//    assert.IsIncreasingf(t, []int{1, 2, 3}, "error message %s", "formatted")
+//    assert.IsIncreasingf(t, []float{1, 2}, "error message %s", "formatted")
+//    assert.IsIncreasingf(t, []string{"a", "b"}, "error message %s", "formatted")
 func IsIncreasingf(t TestingT, object interface{}, msg string, args ...interface{}) bool {
 	if h, ok := t.(tHelper); ok {
 		h.Helper()
@ -416,9 +377,9 @@ func IsIncreasingf(t TestingT, object interface{}, msg string, args ...interface

 // IsNonDecreasingf asserts that the collection is not decreasing
 //
-//	assert.IsNonDecreasingf(t, []int{1, 1, 2}, "error message %s", "formatted")
-//	assert.IsNonDecreasingf(t, []float{1, 2}, "error message %s", "formatted")
-//	assert.IsNonDecreasingf(t, []string{"a", "b"}, "error message %s", "formatted")
+//    assert.IsNonDecreasingf(t, []int{1, 1, 2}, "error message %s", "formatted")
+//    assert.IsNonDecreasingf(t, []float{1, 2}, "error message %s", "formatted")
+//    assert.IsNonDecreasingf(t, []string{"a", "b"}, "error message %s", "formatted")
 func IsNonDecreasingf(t TestingT, object interface{}, msg string, args ...interface{}) bool {
 	if h, ok := t.(tHelper); ok {
 		h.Helper()
@ -428,9 +389,9 @@ func IsNonDecreasingf(t TestingT, object interface{}, msg string, args ...interf

 // IsNonIncreasingf asserts that the collection is not increasing
 //
-//	assert.IsNonIncreasingf(t, []int{2, 1, 1}, "error message %s", "formatted")
-//	assert.IsNonIncreasingf(t, []float{2, 1}, "error message %s", "formatted")
-//	assert.IsNonIncreasingf(t, []string{"b", "a"}, "error message %s", "formatted")
+//    assert.IsNonIncreasingf(t, []int{2, 1, 1}, "error message %s", "formatted")
+//    assert.IsNonIncreasingf(t, []float{2, 1}, "error message %s", "formatted")
+//    assert.IsNonIncreasingf(t, []string{"b", "a"}, "error message %s", "formatted")
 func IsNonIncreasingf(t TestingT, object interface{}, msg string, args ...interface{}) bool {
 	if h, ok := t.(tHelper); ok {
 		h.Helper()
@ -448,7 +409,7 @@ func IsTypef(t TestingT, expectedType interface{}, object interface{}, msg strin

 // JSONEqf asserts that two JSON strings are equivalent.
 //
-//	assert.JSONEqf(t, `{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`, "error message %s", "formatted")
+//  assert.JSONEqf(t, `{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`, "error message %s", "formatted")
 func JSONEqf(t TestingT, expected string, actual string, msg string, args ...interface{}) bool {
 	if h, ok := t.(tHelper); ok {
 		h.Helper()
@ -459,7 +420,7 @@ func JSONEqf(t TestingT, expected string, actual string, msg string, args ...int
 // Lenf asserts that the specified object has specific length.
 // Lenf also fails if the object has a type that len() not accept.
 //
-//	assert.Lenf(t, mySlice, 3, "error message %s", "formatted")
+//    assert.Lenf(t, mySlice, 3, "error message %s", "formatted")
 func Lenf(t TestingT, object interface{}, length int, msg string, args ...interface{}) bool {
 	if h, ok := t.(tHelper); ok {
 		h.Helper()
@ -469,9 +430,9 @@ func Lenf(t TestingT, object interface{}, length int, msg string, args ...interf

 // Lessf asserts that the first element is less than the second
 //
-//	assert.Lessf(t, 1, 2, "error message %s", "formatted")
-//	assert.Lessf(t, float64(1), float64(2), "error message %s", "formatted")
-//	assert.Lessf(t, "a", "b", "error message %s", "formatted")
+//    assert.Lessf(t, 1, 2, "error message %s", "formatted")
+//    assert.Lessf(t, float64(1), float64(2), "error message %s", "formatted")
+//    assert.Lessf(t, "a", "b", "error message %s", "formatted")
 func Lessf(t TestingT, e1 interface{}, e2 interface{}, msg string, args ...interface{}) bool {
 	if h, ok := t.(tHelper); ok {
 		h.Helper()
@ -481,10 +442,10 @@ func Lessf(t TestingT, e1 interface{}, e2 interface{}, msg string, args ...inter

 // LessOrEqualf asserts that the first element is less than or equal to the second
 //
-//	assert.LessOrEqualf(t, 1, 2, "error message %s", "formatted")
-//	assert.LessOrEqualf(t, 2, 2, "error message %s", "formatted")
-//	assert.LessOrEqualf(t, "a", "b", "error message %s", "formatted")
-//	assert.LessOrEqualf(t, "b", "b", "error message %s", "formatted")
+//    assert.LessOrEqualf(t, 1, 2, "error message %s", "formatted")
+//    assert.LessOrEqualf(t, 2, 2, "error message %s", "formatted")
+//    assert.LessOrEqualf(t, "a", "b", "error message %s", "formatted")
+//    assert.LessOrEqualf(t, "b", "b", "error message %s", "formatted")
 func LessOrEqualf(t TestingT, e1 interface{}, e2 interface{}, msg string, args ...interface{}) bool {
 	if h, ok := t.(tHelper); ok {
 		h.Helper()
@ -494,8 +455,8 @@ func LessOrEqualf(t TestingT, e1 interface{}, e2 interface{}, msg string, args .

 // Negativef asserts that the specified element is negative
 //
-//	assert.Negativef(t, -1, "error message %s", "formatted")
-//	assert.Negativef(t, -1.23, "error message %s", "formatted")
+//    assert.Negativef(t, -1, "error message %s", "formatted")
+//    assert.Negativef(t, -1.23, "error message %s", "formatted")
 func Negativef(t TestingT, e interface{}, msg string, args ...interface{}) bool {
 	if h, ok := t.(tHelper); ok {
 		h.Helper()
@ -506,7 +467,7 @@ func Negativef(t TestingT, e interface{}, msg string, args ...interface{}) bool
 // Neverf asserts that the given condition doesn't satisfy in waitFor time,
 // periodically checking the target function each tick.
 //
-//	assert.Neverf(t, func() bool { return false; }, time.Second, 10*time.Millisecond, "error message %s", "formatted")
+//    assert.Neverf(t, func() bool { return false; }, time.Second, 10*time.Millisecond, "error message %s", "formatted")
 func Neverf(t TestingT, condition func() bool, waitFor time.Duration, tick time.Duration, msg string, args ...interface{}) bool {
 	if h, ok := t.(tHelper); ok {
 		h.Helper()
@ -516,7 +477,7 @@ func Neverf(t TestingT, condition func() bool, waitFor time.Duration, tick time.

 // Nilf asserts that the specified object is nil.
 //
-//	assert.Nilf(t, err, "error message %s", "formatted")
+//    assert.Nilf(t, err, "error message %s", "formatted")
 func Nilf(t TestingT, object interface{}, msg string, args ...interface{}) bool {
 	if h, ok := t.(tHelper); ok {
 		h.Helper()
@ -535,10 +496,10 @@ func NoDirExistsf(t TestingT, path string, msg string, args ...interface{}) bool

 // NoErrorf asserts that a function returned no error (i.e. `nil`).
 //
-//	  actualObj, err := SomeFunction()
-//	  if assert.NoErrorf(t, err, "error message %s", "formatted") {
-//		   assert.Equal(t, expectedObj, actualObj)
-//	  }
+//   actualObj, err := SomeFunction()
+//   if assert.NoErrorf(t, err, "error message %s", "formatted") {
+// 	   assert.Equal(t, expectedObj, actualObj)
+//   }
 func NoErrorf(t TestingT, err error, msg string, args ...interface{}) bool {
 	if h, ok := t.(tHelper); ok {
 		h.Helper()
@ -558,9 +519,9 @@ func NoFileExistsf(t TestingT, path string, msg string, args ...interface{}) boo
 // NotContainsf asserts that the specified string, list(array, slice...) or map does NOT contain the
 // specified substring or element.
 //
-//	assert.NotContainsf(t, "Hello World", "Earth", "error message %s", "formatted")
-//	assert.NotContainsf(t, ["Hello", "World"], "Earth", "error message %s", "formatted")
-//	assert.NotContainsf(t, {"Hello": "World"}, "Earth", "error message %s", "formatted")
+//    assert.NotContainsf(t, "Hello World", "Earth", "error message %s", "formatted")
+//    assert.NotContainsf(t, ["Hello", "World"], "Earth", "error message %s", "formatted")
+//    assert.NotContainsf(t, {"Hello": "World"}, "Earth", "error message %s", "formatted")
 func NotContainsf(t TestingT, s interface{}, contains interface{}, msg string, args ...interface{}) bool {
 	if h, ok := t.(tHelper); ok {
 		h.Helper()
@ -568,29 +529,12 @@ 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.
 //
-//	if assert.NotEmptyf(t, obj, "error message %s", "formatted") {
-//	  assert.Equal(t, "two", obj[1])
-//	}
+//  if assert.NotEmptyf(t, obj, "error message %s", "formatted") {
+//    assert.Equal(t, "two", obj[1])
+//  }
 func NotEmptyf(t TestingT, object interface{}, msg string, args ...interface{}) bool {
 	if h, ok := t.(tHelper); ok {
 		h.Helper()
@ -600,7 +544,7 @@ func NotEmptyf(t TestingT, object interface{}, msg string, args ...interface{})

 // NotEqualf asserts that the specified values are NOT equal.
 //
-//	assert.NotEqualf(t, obj1, obj2, "error message %s", "formatted")
+//    assert.NotEqualf(t, obj1, obj2, "error message %s", "formatted")
 //
 // Pointer variable equality is determined based on the equality of the
 // referenced values (as opposed to the memory addresses).
@ -613,7 +557,7 @@ func NotEqualf(t TestingT, expected interface{}, actual interface{}, msg string,

 // NotEqualValuesf asserts that two objects are not equal even when converted to the same type
 //
-//	assert.NotEqualValuesf(t, obj1, obj2, "error message %s", "formatted")
+//    assert.NotEqualValuesf(t, obj1, obj2, "error message %s", "formatted")
 func NotEqualValuesf(t TestingT, expected interface{}, actual interface{}, msg string, args ...interface{}) bool {
 	if h, ok := t.(tHelper); ok {
 		h.Helper()
@ -621,16 +565,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 {
@ -639,19 +574,9 @@ func NotErrorIsf(t TestingT, err error, target error, msg string, args ...interf
 	return NotErrorIs(t, err, target, append([]interface{}{msg}, args...)...)
 }

-// NotImplementsf asserts that an object does not implement the specified interface.
-//
-//	assert.NotImplementsf(t, (*MyInterface)(nil), new(MyObject), "error message %s", "formatted")
-func NotImplementsf(t TestingT, interfaceObject interface{}, object interface{}, msg string, args ...interface{}) bool {
-	if h, ok := t.(tHelper); ok {
-		h.Helper()
-	}
-	return NotImplements(t, interfaceObject, object, append([]interface{}{msg}, args...)...)
-}
-
 // NotNilf asserts that the specified object is not nil.
 //
-//	assert.NotNilf(t, err, "error message %s", "formatted")
+//    assert.NotNilf(t, err, "error message %s", "formatted")
 func NotNilf(t TestingT, object interface{}, msg string, args ...interface{}) bool {
 	if h, ok := t.(tHelper); ok {
 		h.Helper()
@ -661,7 +586,7 @@ func NotNilf(t TestingT, object interface{}, msg string, args ...interface{}) bo

 // NotPanicsf asserts that the code inside the specified PanicTestFunc does NOT panic.
 //
-//	assert.NotPanicsf(t, func(){ RemainCalm() }, "error message %s", "formatted")
+//   assert.NotPanicsf(t, func(){ RemainCalm() }, "error message %s", "formatted")
 func NotPanicsf(t TestingT, f PanicTestFunc, msg string, args ...interface{}) bool {
 	if h, ok := t.(tHelper); ok {
 		h.Helper()
@ -671,8 +596,8 @@ func NotPanicsf(t TestingT, f PanicTestFunc, msg string, args ...interface{}) bo

 // NotRegexpf asserts that a specified regexp does not match a string.
 //
-//	assert.NotRegexpf(t, regexp.MustCompile("starts"), "it's starting", "error message %s", "formatted")
-//	assert.NotRegexpf(t, "^start", "it's not starting", "error message %s", "formatted")
+//  assert.NotRegexpf(t, regexp.MustCompile("starts"), "it's starting", "error message %s", "formatted")
+//  assert.NotRegexpf(t, "^start", "it's not starting", "error message %s", "formatted")
 func NotRegexpf(t TestingT, rx interface{}, str interface{}, msg string, args ...interface{}) bool {
 	if h, ok := t.(tHelper); ok {
 		h.Helper()
@ -682,7 +607,7 @@ func NotRegexpf(t TestingT, rx interface{}, str interface{}, msg string, args ..

 // NotSamef asserts that two pointers do not reference the same object.
 //
-//	assert.NotSamef(t, ptr1, ptr2, "error message %s", "formatted")
+//    assert.NotSamef(t, ptr1, ptr2, "error message %s", "formatted")
 //
 // Both arguments must be pointer variables. Pointer variable sameness is
 // determined based on the equality of both type and value.
@ -693,12 +618,10 @@ func NotSamef(t TestingT, expected interface{}, actual interface{}, msg string,
 	return NotSame(t, expected, actual, append([]interface{}{msg}, args...)...)
 }

-// NotSubsetf asserts that the specified list(array, slice...) or map does NOT
-// contain all elements given in the specified subset list(array, slice...) or
-// map.
+// NotSubsetf asserts that the specified list(array, slice...) contains not all
+// elements given in the specified subset(array, slice...).
 //
-//	assert.NotSubsetf(t, [1, 3, 4], [1, 2], "error message %s", "formatted")
-//	assert.NotSubsetf(t, {"x": 1, "y": 2}, {"z": 3}, "error message %s", "formatted")
+//    assert.NotSubsetf(t, [1, 3, 4], [1, 2], "But [1, 3, 4] does not contain [1, 2]", "error message %s", "formatted")
 func NotSubsetf(t TestingT, list interface{}, subset interface{}, msg string, args ...interface{}) bool {
 	if h, ok := t.(tHelper); ok {
 		h.Helper()
@ -716,7 +639,7 @@ func NotZerof(t TestingT, i interface{}, msg string, args ...interface{}) bool {

 // Panicsf asserts that the code inside the specified PanicTestFunc panics.
 //
-//	assert.Panicsf(t, func(){ GoCrazy() }, "error message %s", "formatted")
+//   assert.Panicsf(t, func(){ GoCrazy() }, "error message %s", "formatted")
 func Panicsf(t TestingT, f PanicTestFunc, msg string, args ...interface{}) bool {
 	if h, ok := t.(tHelper); ok {
 		h.Helper()
@ -728,7 +651,7 @@ func Panicsf(t TestingT, f PanicTestFunc, msg string, args ...interface{}) bool
 // panics, and that the recovered panic value is an error that satisfies the
 // EqualError comparison.
 //
-//	assert.PanicsWithErrorf(t, "crazy error", func(){ GoCrazy() }, "error message %s", "formatted")
+//   assert.PanicsWithErrorf(t, "crazy error", func(){ GoCrazy() }, "error message %s", "formatted")
 func PanicsWithErrorf(t TestingT, errString string, f PanicTestFunc, msg string, args ...interface{}) bool {
 	if h, ok := t.(tHelper); ok {
 		h.Helper()
@ -739,7 +662,7 @@ func PanicsWithErrorf(t TestingT, errString string, f PanicTestFunc, msg string,
 // PanicsWithValuef asserts that the code inside the specified PanicTestFunc panics, and that
 // the recovered panic value equals the expected panic value.
 //
-//	assert.PanicsWithValuef(t, "crazy error", func(){ GoCrazy() }, "error message %s", "formatted")
+//   assert.PanicsWithValuef(t, "crazy error", func(){ GoCrazy() }, "error message %s", "formatted")
 func PanicsWithValuef(t TestingT, expected interface{}, f PanicTestFunc, msg string, args ...interface{}) bool {
 	if h, ok := t.(tHelper); ok {
 		h.Helper()
@ -749,8 +672,8 @@ func PanicsWithValuef(t TestingT, expected interface{}, f PanicTestFunc, msg str

 // Positivef asserts that the specified element is positive
 //
-//	assert.Positivef(t, 1, "error message %s", "formatted")
-//	assert.Positivef(t, 1.23, "error message %s", "formatted")
+//    assert.Positivef(t, 1, "error message %s", "formatted")
+//    assert.Positivef(t, 1.23, "error message %s", "formatted")
 func Positivef(t TestingT, e interface{}, msg string, args ...interface{}) bool {
 	if h, ok := t.(tHelper); ok {
 		h.Helper()
@ -760,8 +683,8 @@ func Positivef(t TestingT, e interface{}, msg string, args ...interface{}) bool

 // Regexpf asserts that a specified regexp matches a string.
 //
-//	assert.Regexpf(t, regexp.MustCompile("start"), "it's starting", "error message %s", "formatted")
-//	assert.Regexpf(t, "start...$", "it's not starting", "error message %s", "formatted")
+//  assert.Regexpf(t, regexp.MustCompile("start"), "it's starting", "error message %s", "formatted")
+//  assert.Regexpf(t, "start...$", "it's not starting", "error message %s", "formatted")
 func Regexpf(t TestingT, rx interface{}, str interface{}, msg string, args ...interface{}) bool {
 	if h, ok := t.(tHelper); ok {
 		h.Helper()
@ -771,7 +694,7 @@ func Regexpf(t TestingT, rx interface{}, str interface{}, msg string, args ...in

 // Samef asserts that two pointers reference the same object.
 //
-//	assert.Samef(t, ptr1, ptr2, "error message %s", "formatted")
+//    assert.Samef(t, ptr1, ptr2, "error message %s", "formatted")
 //
 // Both arguments must be pointer variables. Pointer variable sameness is
 // determined based on the equality of both type and value.
@ -782,11 +705,10 @@ func Samef(t TestingT, expected interface{}, actual interface{}, msg string, arg
 	return Same(t, expected, actual, append([]interface{}{msg}, args...)...)
 }

-// Subsetf asserts that the specified list(array, slice...) or map contains all
-// elements given in the specified subset list(array, slice...) or map.
+// Subsetf asserts that the specified list(array, slice...) contains all
+// elements given in the specified subset(array, slice...).
 //
-//	assert.Subsetf(t, [1, 2, 3], [1, 2], "error message %s", "formatted")
-//	assert.Subsetf(t, {"x": 1, "y": 2}, {"x": 1}, "error message %s", "formatted")
+//    assert.Subsetf(t, [1, 2, 3], [1, 2], "But [1, 2, 3] does contain [1, 2]", "error message %s", "formatted")
 func Subsetf(t TestingT, list interface{}, subset interface{}, msg string, args ...interface{}) bool {
 	if h, ok := t.(tHelper); ok {
 		h.Helper()
@ -796,7 +718,7 @@ func Subsetf(t TestingT, list interface{}, subset interface{}, msg string, args

 // Truef asserts that the specified value is true.
 //
-//	assert.Truef(t, myBool, "error message %s", "formatted")
+//    assert.Truef(t, myBool, "error message %s", "formatted")
 func Truef(t TestingT, value bool, msg string, args ...interface{}) bool {
 	if h, ok := t.(tHelper); ok {
 		h.Helper()
@ -806,7 +728,7 @@ func Truef(t TestingT, value bool, msg string, args ...interface{}) bool {

 // WithinDurationf asserts that the two times are within duration delta of each other.
 //
-//	assert.WithinDurationf(t, time.Now(), time.Now(), 10*time.Second, "error message %s", "formatted")
+//   assert.WithinDurationf(t, time.Now(), time.Now(), 10*time.Second, "error message %s", "formatted")
 func WithinDurationf(t TestingT, expected time.Time, actual time.Time, delta time.Duration, msg string, args ...interface{}) bool {
 	if h, ok := t.(tHelper); ok {
 		h.Helper()
@ -814,16 +736,6 @@ func WithinDurationf(t TestingT, expected time.Time, actual time.Time, delta tim
 	return WithinDuration(t, expected, actual, delta, append([]interface{}{msg}, args...)...)
 }

-// WithinRangef asserts that a time is within a time range (inclusive).
-//
-//	assert.WithinRangef(t, time.Now(), time.Now().Add(-time.Second), time.Now().Add(time.Second), "error message %s", "formatted")
-func WithinRangef(t TestingT, actual time.Time, start time.Time, end time.Time, msg string, args ...interface{}) bool {
-	if h, ok := t.(tHelper); ok {
-		h.Helper()
-	}
-	return WithinRange(t, actual, start, end, append([]interface{}{msg}, args...)...)
-}
-
 // YAMLEqf asserts that two YAML strings are equivalent.
 func YAMLEqf(t TestingT, expected string, actual string, msg string, args ...interface{}) bool {
 	if h, ok := t.(tHelper); ok {
--- a/assert/assertion_forward.go
+++ b/assert/assertion_forward.go
--- 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) {
@ -46,36 +46,36 @@ func isOrdered(t TestingT, object interface{}, allowedComparesResults []compareR

 // IsIncreasing asserts that the collection is increasing
 //
-//	assert.IsIncreasing(t, []int{1, 2, 3})
-//	assert.IsIncreasing(t, []float{1, 2})
-//	assert.IsIncreasing(t, []string{"a", "b"})
+//    assert.IsIncreasing(t, []int{1, 2, 3})
+//    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
 //
-//	assert.IsNonIncreasing(t, []int{2, 1, 1})
-//	assert.IsNonIncreasing(t, []float{2, 1})
-//	assert.IsNonIncreasing(t, []string{"b", "a"})
+//    assert.IsNonIncreasing(t, []int{2, 1, 1})
+//    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
 //
-//	assert.IsDecreasing(t, []int{2, 1, 0})
-//	assert.IsDecreasing(t, []float{2, 1})
-//	assert.IsDecreasing(t, []string{"b", "a"})
+//    assert.IsDecreasing(t, []int{2, 1, 0})
+//    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
 //
-//	assert.IsNonDecreasing(t, []int{1, 1, 2})
-//	assert.IsNonDecreasing(t, []float{1, 2})
-//	assert.IsNonDecreasing(t, []string{"a", "b"})
+//    assert.IsNonDecreasing(t, []int{1, 1, 2})
+//    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
--- a/assert/assertions_test.go
+++ b/assert/assertions_test.go
--- a/assert/doc.go
+++ b/assert/doc.go
@ -1,40 +1,39 @@
 // Package assert provides a set of comprehensive testing tools for use with the normal Go testing system.
 //
-// # Example Usage
+// Example Usage
 //
 // The following is a complete example using assert in a standard test function:
+//    import (
+//      "testing"
+//      "github.com/stretchr/testify/assert"
+//    )
 //
-//	import (
-//	  "testing"
-//	  "github.com/stretchr/testify/assert"
-//	)
+//    func TestSomething(t *testing.T) {
 //
-//	func TestSomething(t *testing.T) {
+//      var a string = "Hello"
+//      var b string = "Hello"
 //
-//	  var a string = "Hello"
-//	  var b string = "Hello"
+//      assert.Equal(t, a, b, "The two words should be the same.")
 //
-//	  assert.Equal(t, a, b, "The two words should be the same.")
-//
-//	}
+//    }
 //
 // if you assert many times, use the format below:
 //
-//	import (
-//	  "testing"
-//	  "github.com/stretchr/testify/assert"
-//	)
+//    import (
+//      "testing"
+//      "github.com/stretchr/testify/assert"
+//    )
 //
-//	func TestSomething(t *testing.T) {
-//	  assert := assert.New(t)
+//    func TestSomething(t *testing.T) {
+//      assert := assert.New(t)
 //
-//	  var a string = "Hello"
-//	  var b string = "Hello"
+//      var a string = "Hello"
+//      var b string = "Hello"
 //
-//	  assert.Equal(a, b, "The two words should be the same.")
-//	}
+//      assert.Equal(a, b, "The two words should be the same.")
+//    }
 //
-// # Assertions
+// Assertions
 //
 // Assertions allow you to easily write test code, and are global funcs in the `assert` package.
 // All assertion functions take, as the first argument, the `*testing.T` object provided by the
--- 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
@ -12,7 +12,7 @@ import (
 // an error if building a new request fails.
 func httpCode(handler http.HandlerFunc, method, url string, values url.Values) (int, error) {
 	w := httptest.NewRecorder()
-	req, err := http.NewRequest(method, url, http.NoBody)
+	req, err := http.NewRequest(method, url, nil)
 	if err != nil {
 		return -1, err
 	}
@ -23,7 +23,7 @@ func httpCode(handler http.HandlerFunc, method, url string, values url.Values) (

 // HTTPSuccess asserts that a specified handler returns a success status code.
 //
-//	assert.HTTPSuccess(t, myHandler, "POST", "http://www.google.com", nil)
+//  assert.HTTPSuccess(t, myHandler, "POST", "http://www.google.com", nil)
 //
 // Returns whether the assertion was successful (true) or not (false).
 func HTTPSuccess(t TestingT, handler http.HandlerFunc, method, url string, values url.Values, msgAndArgs ...interface{}) bool {
@ -32,12 +32,12 @@ func HTTPSuccess(t TestingT, handler http.HandlerFunc, method, url string, value
 	}
 	code, err := httpCode(handler, method, url, values)
 	if err != nil {
-		Fail(t, fmt.Sprintf("Failed to build test request, got error: %s", err), msgAndArgs...)
+		Fail(t, fmt.Sprintf("Failed to build test request, got error: %s", err))
 	}

 	isSuccessCode := code >= http.StatusOK && code <= http.StatusPartialContent
 	if !isSuccessCode {
-		Fail(t, fmt.Sprintf("Expected HTTP success status code for %q but received %d", url+"?"+values.Encode(), code), msgAndArgs...)
+		Fail(t, fmt.Sprintf("Expected HTTP success status code for %q but received %d", url+"?"+values.Encode(), code))
 	}

 	return isSuccessCode
@ -45,7 +45,7 @@ func HTTPSuccess(t TestingT, handler http.HandlerFunc, method, url string, value

 // HTTPRedirect asserts that a specified handler returns a redirect status code.
 //
-//	assert.HTTPRedirect(t, myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}}
+//  assert.HTTPRedirect(t, myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}}
 //
 // Returns whether the assertion was successful (true) or not (false).
 func HTTPRedirect(t TestingT, handler http.HandlerFunc, method, url string, values url.Values, msgAndArgs ...interface{}) bool {
@ -54,12 +54,12 @@ func HTTPRedirect(t TestingT, handler http.HandlerFunc, method, url string, valu
 	}
 	code, err := httpCode(handler, method, url, values)
 	if err != nil {
-		Fail(t, fmt.Sprintf("Failed to build test request, got error: %s", err), msgAndArgs...)
+		Fail(t, fmt.Sprintf("Failed to build test request, got error: %s", err))
 	}

 	isRedirectCode := code >= http.StatusMultipleChoices && code <= http.StatusTemporaryRedirect
 	if !isRedirectCode {
-		Fail(t, fmt.Sprintf("Expected HTTP redirect status code for %q but received %d", url+"?"+values.Encode(), code), msgAndArgs...)
+		Fail(t, fmt.Sprintf("Expected HTTP redirect status code for %q but received %d", url+"?"+values.Encode(), code))
 	}

 	return isRedirectCode
@ -67,7 +67,7 @@ func HTTPRedirect(t TestingT, handler http.HandlerFunc, method, url string, valu

 // HTTPError asserts that a specified handler returns an error status code.
 //
-//	assert.HTTPError(t, myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}}
+//  assert.HTTPError(t, myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}}
 //
 // Returns whether the assertion was successful (true) or not (false).
 func HTTPError(t TestingT, handler http.HandlerFunc, method, url string, values url.Values, msgAndArgs ...interface{}) bool {
@ -76,12 +76,12 @@ func HTTPError(t TestingT, handler http.HandlerFunc, method, url string, values
 	}
 	code, err := httpCode(handler, method, url, values)
 	if err != nil {
-		Fail(t, fmt.Sprintf("Failed to build test request, got error: %s", err), msgAndArgs...)
+		Fail(t, fmt.Sprintf("Failed to build test request, got error: %s", err))
 	}

 	isErrorCode := code >= http.StatusBadRequest
 	if !isErrorCode {
-		Fail(t, fmt.Sprintf("Expected HTTP error status code for %q but received %d", url+"?"+values.Encode(), code), msgAndArgs...)
+		Fail(t, fmt.Sprintf("Expected HTTP error status code for %q but received %d", url+"?"+values.Encode(), code))
 	}

 	return isErrorCode
@ -89,7 +89,7 @@ func HTTPError(t TestingT, handler http.HandlerFunc, method, url string, values

 // HTTPStatusCode asserts that a specified handler returns a specified status code.
 //
-//	assert.HTTPStatusCode(t, myHandler, "GET", "/notImplemented", nil, 501)
+//  assert.HTTPStatusCode(t, myHandler, "GET", "/notImplemented", nil, 501)
 //
 // Returns whether the assertion was successful (true) or not (false).
 func HTTPStatusCode(t TestingT, handler http.HandlerFunc, method, url string, values url.Values, statuscode int, msgAndArgs ...interface{}) bool {
@ -98,12 +98,12 @@ func HTTPStatusCode(t TestingT, handler http.HandlerFunc, method, url string, va
 	}
 	code, err := httpCode(handler, method, url, values)
 	if err != nil {
-		Fail(t, fmt.Sprintf("Failed to build test request, got error: %s", err), msgAndArgs...)
+		Fail(t, fmt.Sprintf("Failed to build test request, got error: %s", err))
 	}

 	successful := code == statuscode
 	if !successful {
-		Fail(t, fmt.Sprintf("Expected HTTP status code %d for %q but received %d", statuscode, url+"?"+values.Encode(), code), msgAndArgs...)
+		Fail(t, fmt.Sprintf("Expected HTTP status code %d for %q but received %d", statuscode, url+"?"+values.Encode(), code))
 	}

 	return successful
@ -113,10 +113,7 @@ func HTTPStatusCode(t TestingT, handler http.HandlerFunc, method, url string, va
 // empty string if building a new request fails.
 func HTTPBody(handler http.HandlerFunc, method, url string, values url.Values) string {
 	w := httptest.NewRecorder()
-	if len(values) > 0 {
-		url += "?" + values.Encode()
-	}
-	req, err := http.NewRequest(method, url, http.NoBody)
+	req, err := http.NewRequest(method, url+"?"+values.Encode(), nil)
 	if err != nil {
 		return ""
 	}
@ -127,7 +124,7 @@ func HTTPBody(handler http.HandlerFunc, method, url string, values url.Values) s
 // HTTPBodyContains asserts that a specified handler returns a
 // body that contains a string.
 //
-//	assert.HTTPBodyContains(t, myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky")
+//  assert.HTTPBodyContains(t, myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky")
 //
 // Returns whether the assertion was successful (true) or not (false).
 func HTTPBodyContains(t TestingT, handler http.HandlerFunc, method, url string, values url.Values, str interface{}, msgAndArgs ...interface{}) bool {
@ -138,7 +135,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))
 	}

 	return contains
@ -147,7 +144,7 @@ func HTTPBodyContains(t TestingT, handler http.HandlerFunc, method, url string,
 // HTTPBodyNotContains asserts that a specified handler returns a
 // body that does not contain a string.
 //
-//	assert.HTTPBodyNotContains(t, myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky")
+//  assert.HTTPBodyNotContains(t, myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky")
 //
 // Returns whether the assertion was successful (true) or not (false).
 func HTTPBodyNotContains(t TestingT, handler http.HandlerFunc, method, url string, values url.Values, str interface{}, msgAndArgs ...interface{}) bool {
@ -158,7 +155,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))
 	}

 	return !contains
--- a/assert/http_assertions_test.go
+++ b/assert/http_assertions_test.go
@ -2,7 +2,6 @@ package assert

 import (
 	"fmt"
-	"io"
 	"net/http"
 	"net/url"
 	"testing"
@ -12,12 +11,6 @@ func httpOK(w http.ResponseWriter, r *http.Request) {
 	w.WriteHeader(http.StatusOK)
 }

-func httpReadBody(w http.ResponseWriter, r *http.Request) {
-	_, _ = io.Copy(io.Discard, r.Body)
-	w.WriteHeader(http.StatusOK)
-	_, _ = w.Write([]byte("hello"))
-}
-
 func httpRedirect(w http.ResponseWriter, r *http.Request) {
 	w.WriteHeader(http.StatusTemporaryRedirect)
 }
@ -41,33 +34,21 @@ func TestHTTPSuccess(t *testing.T) {
 	assert.Equal(HTTPSuccess(mockT2, httpRedirect, "GET", "/", nil), false)
 	assert.True(mockT2.Failed())

-	mockT3 := new(mockTestingT)
-	assert.Equal(HTTPSuccess(
-		mockT3, httpError, "GET", "/", nil,
-		"was not expecting a failure here",
-	), false)
+	mockT3 := new(testing.T)
+	assert.Equal(HTTPSuccess(mockT3, httpError, "GET", "/", nil), false)
 	assert.True(mockT3.Failed())
-	assert.Contains(mockT3.errorString(), "was not expecting a failure here")

 	mockT4 := new(testing.T)
 	assert.Equal(HTTPSuccess(mockT4, httpStatusCode, "GET", "/", nil), false)
 	assert.True(mockT4.Failed())
-
-	mockT5 := new(testing.T)
-	assert.Equal(HTTPSuccess(mockT5, httpReadBody, "POST", "/", nil), true)
-	assert.False(mockT5.Failed())
 }

 func TestHTTPRedirect(t *testing.T) {
 	assert := New(t)

-	mockT1 := new(mockTestingT)
-	assert.Equal(HTTPRedirect(
-		mockT1, httpOK, "GET", "/", nil,
-		"was expecting a 3xx status code. Got 200.",
-	), false)
+	mockT1 := new(testing.T)
+	assert.Equal(HTTPRedirect(mockT1, httpOK, "GET", "/", nil), false)
 	assert.True(mockT1.Failed())
-	assert.Contains(mockT1.errorString(), "was expecting a 3xx status code. Got 200.")

 	mockT2 := new(testing.T)
 	assert.Equal(HTTPRedirect(mockT2, httpRedirect, "GET", "/", nil), true)
@ -89,13 +70,9 @@ func TestHTTPError(t *testing.T) {
 	assert.Equal(HTTPError(mockT1, httpOK, "GET", "/", nil), false)
 	assert.True(mockT1.Failed())

-	mockT2 := new(mockTestingT)
-	assert.Equal(HTTPError(
-		mockT2, httpRedirect, "GET", "/", nil,
-		"Expected this request to error out. But it didn't",
-	), false)
+	mockT2 := new(testing.T)
+	assert.Equal(HTTPError(mockT2, httpRedirect, "GET", "/", nil), false)
 	assert.True(mockT2.Failed())
-	assert.Contains(mockT2.errorString(), "Expected this request to error out. But it didn't")

 	mockT3 := new(testing.T)
 	assert.Equal(HTTPError(mockT3, httpError, "GET", "/", nil), true)
@ -117,13 +94,9 @@ func TestHTTPStatusCode(t *testing.T) {
 	assert.Equal(HTTPStatusCode(mockT2, httpRedirect, "GET", "/", nil, http.StatusSwitchingProtocols), false)
 	assert.True(mockT2.Failed())

-	mockT3 := new(mockTestingT)
-	assert.Equal(HTTPStatusCode(
-		mockT3, httpError, "GET", "/", nil, http.StatusSwitchingProtocols,
-		"Expected the status code to be %d", http.StatusSwitchingProtocols,
-	), false)
+	mockT3 := new(testing.T)
+	assert.Equal(HTTPStatusCode(mockT3, httpError, "GET", "/", nil, http.StatusSwitchingProtocols), false)
 	assert.True(mockT3.Failed())
-	assert.Contains(mockT3.errorString(), "Expected the status code to be 101")

 	mockT4 := new(testing.T)
 	assert.Equal(HTTPStatusCode(mockT4, httpStatusCode, "GET", "/", nil, http.StatusSwitchingProtocols), true)
@ -149,7 +122,7 @@ func TestHTTPStatusesWrapper(t *testing.T) {

 func httpHelloName(w http.ResponseWriter, r *http.Request) {
 	name := r.FormValue("name")
-	_, _ = fmt.Fprintf(w, "Hello, %s!", name)
+	_, _ = w.Write([]byte(fmt.Sprintf("Hello, %s!", name)))
 }

 func TestHTTPRequestWithNoParams(t *testing.T) {
@ -183,21 +156,15 @@ func TestHTTPRequestWithParams(t *testing.T) {

 func TestHttpBody(t *testing.T) {
 	assert := New(t)
-	mockT := new(mockTestingT)
+	mockT := new(testing.T)

 	assert.True(HTTPBodyContains(mockT, httpHelloName, "GET", "/", url.Values{"name": []string{"World"}}, "Hello, World!"))
 	assert.True(HTTPBodyContains(mockT, httpHelloName, "GET", "/", url.Values{"name": []string{"World"}}, "World"))
 	assert.False(HTTPBodyContains(mockT, httpHelloName, "GET", "/", url.Values{"name": []string{"World"}}, "world"))

 	assert.False(HTTPBodyNotContains(mockT, httpHelloName, "GET", "/", url.Values{"name": []string{"World"}}, "Hello, World!"))
-	assert.False(HTTPBodyNotContains(
-		mockT, httpHelloName, "GET", "/", url.Values{"name": []string{"World"}}, "World",
-		"Expected the request body to not contain 'World'. But it did.",
-	))
+	assert.False(HTTPBodyNotContains(mockT, httpHelloName, "GET", "/", url.Values{"name": []string{"World"}}, "World"))
 	assert.True(HTTPBodyNotContains(mockT, httpHelloName, "GET", "/", url.Values{"name": []string{"World"}}, "world"))
-	assert.Contains(mockT.errorString(), "Expected the request body to not contain 'World'. But it did.")
-
-	assert.True(HTTPBodyContains(mockT, httpReadBody, "GET", "/", nil, "hello"))
 }

 func TestHttpBodyWrappers(t *testing.T) {
@ -211,4 +178,5 @@ func TestHttpBodyWrappers(t *testing.T) {
 	assert.False(mockAssert.HTTPBodyNotContains(httpHelloName, "GET", "/", url.Values{"name": []string{"World"}}, "Hello, World!"))
 	assert.False(mockAssert.HTTPBodyNotContains(httpHelloName, "GET", "/", url.Values{"name": []string{"World"}}, "World"))
 	assert.True(mockAssert.HTTPBodyNotContains(httpHelloName, "GET", "/", url.Values{"name": []string{"World"}}, "world"))
+
 }
--- a/assert/internal/unsafetests/doc.go
+++ b/assert/internal/unsafetests/doc.go
@ -1,4 +0,0 @@
-// This package exists just to isolate tests that reference the [unsafe] package.
-//
-// The tests in this package are totally safe.
-package unsafetests
--- a/assert/internal/unsafetests/unsafetests_test.go
+++ b/assert/internal/unsafetests/unsafetests_test.go
@ -1,34 +0,0 @@
-package unsafetests_test
-
-import (
-	"fmt"
-	"testing"
-	"unsafe"
-
-	"github.com/stretchr/testify/assert"
-)
-
-type ignoreTestingT struct{}
-
-var _ assert.TestingT = ignoreTestingT{}
-
-func (ignoreTestingT) Helper() {}
-
-func (ignoreTestingT) Errorf(format string, args ...interface{}) {
-	// Run the formatting, but ignore the result
-	msg := fmt.Sprintf(format, args...)
-	_ = msg
-}
-
-func TestUnsafePointers(t *testing.T) {
-	var ignore ignoreTestingT
-
-	assert.True(t, assert.Nil(t, unsafe.Pointer(nil), "unsafe.Pointer(nil) is nil"))
-	assert.False(t, assert.NotNil(ignore, unsafe.Pointer(nil), "unsafe.Pointer(nil) is nil"))
-
-	assert.True(t, assert.Nil(t, unsafe.Pointer((*int)(nil)), "unsafe.Pointer((*int)(nil)) is nil"))
-	assert.False(t, assert.NotNil(ignore, unsafe.Pointer((*int)(nil)), "unsafe.Pointer((*int)(nil)) is nil"))
-
-	assert.False(t, assert.Nil(ignore, unsafe.Pointer(new(int)), "unsafe.Pointer(new(int)) is NOT nil"))
-	assert.True(t, assert.NotNil(t, unsafe.Pointer(new(int)), "unsafe.Pointer(new(int)) is NOT nil"))
-}
--- 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,15 +1,23 @@
+// ** 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:
 //
 // The assert package provides a comprehensive set of assertion functions that tie in to the Go testing system.
 //
+// The http package contains tools to make it easier to test http activity using the Go testing system.
+//
 // 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
+
+// blank imports help docs.
+import (
+	// assert package
+	_ "github.com/stretchr/testify/assert"
+	// http package
+	_ "github.com/stretchr/testify/http"
+	// mock package
+	_ "github.com/stretchr/testify/mock"
+)
--- a/go.mod
+++ b/go.mod
@ -1,16 +1,10 @@
 module github.com/stretchr/testify

-// This should match the minimum supported version that is tested in
-// .github/workflows/main.yml
-go 1.17
+go 1.13

 require (
 	github.com/davecgh/go-spew v1.1.1
 	github.com/pmezard/go-difflib v1.0.0
-	github.com/stretchr/objx v0.5.2
+	github.com/stretchr/objx v0.4.0
 	gopkg.in/yaml.v3 v3.0.1
 )
-
-// Break dependency cycle with objx.
-// See https://github.com/stretchr/objx/pull/140
-exclude github.com/stretchr/testify v1.8.2
--- a/go.sum
+++ b/go.sum
@ -4,13 +4,9 @@ github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSs
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/objx v0.4.0 h1:M2gUjqZET1qApGOWNSnZ49BAIMX4F/1plDv3+l31EJ4=
 github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
-github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
-github.com/stretchr/objx v0.5.2 h1:xuMeJ0Sdp5ZMRXx/aWO6RZxdr3beISkG5/G/aIRr3pY=
-github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA=
 github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
-github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
-github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
--- a/http/doc.go
+++ b/http/doc.go
@ -1,2 +1,2 @@
-// Deprecated: Use [net/http/httptest] instead.
+// Package http DEPRECATED USE net/http/httptest
 package http
--- a/http/test_response_writer.go
+++ b/http/test_response_writer.go
@ -4,7 +4,7 @@ import (
 	"net/http"
 )

-// Deprecated: Use [net/http/httptest] instead.
+// TestResponseWriter DEPRECATED: We recommend you use http://golang.org/pkg/net/http/httptest instead.
 type TestResponseWriter struct {

 	// StatusCode is the last int written by the call to WriteHeader(int)
@ -17,7 +17,7 @@ type TestResponseWriter struct {
 	header http.Header
 }

-// Deprecated: Use [net/http/httptest] instead.
+// Header DEPRECATED: We recommend you use http://golang.org/pkg/net/http/httptest instead.
 func (rw *TestResponseWriter) Header() http.Header {

 	if rw.header == nil {
@ -27,7 +27,7 @@ func (rw *TestResponseWriter) Header() http.Header {
 	return rw.header
 }

-// Deprecated: Use [net/http/httptest] instead.
+// Write DEPRECATED: We recommend you use http://golang.org/pkg/net/http/httptest instead.
 func (rw *TestResponseWriter) Write(bytes []byte) (int, error) {

 	// assume 200 success if no header has been set
@ -43,7 +43,7 @@ func (rw *TestResponseWriter) Write(bytes []byte) (int, error) {

 }

-// Deprecated: Use [net/http/httptest] instead.
+// WriteHeader DEPRECATED: We recommend you use http://golang.org/pkg/net/http/httptest instead.
 func (rw *TestResponseWriter) WriteHeader(i int) {
 	rw.StatusCode = i
 }
--- a/http/test_round_tripper.go
+++ b/http/test_round_tripper.go
@ -6,12 +6,12 @@ import (
 	"github.com/stretchr/testify/mock"
 )

-// Deprecated: Use [net/http/httptest] instead.
+// TestRoundTripper DEPRECATED USE net/http/httptest
 type TestRoundTripper struct {
 	mock.Mock
 }

-// Deprecated: Use [net/http/httptest] instead.
+// RoundTrip DEPRECATED USE net/http/httptest
 func (t *TestRoundTripper) RoundTrip(req *http.Request) (*http.Response, error) {
 	args := t.Called(req)
 	return args.Get(0).(*http.Response), args.Error(1)
--- a/mock/doc.go
+++ b/mock/doc.go
@ -1,17 +1,17 @@
 // Package mock provides a system by which it is possible to mock your objects
 // and verify calls are happening as expected.
 //
-// # Example Usage
+// Example Usage
 //
 // The mock package provides an object, Mock, that tracks activity on another object.  It is usually
 // embedded into a test object as shown below:
 //
-//	type MyTestObject struct {
-//	  // add a Mock object instance
-//	  mock.Mock
+//   type MyTestObject struct {
+//     // add a Mock object instance
+//     mock.Mock
 //
-//	  // other fields go here as normal
-//	}
+//     // other fields go here as normal
+//   }
 //
 // When implementing the methods of an interface, you wire your functions up
 // to call the Mock.Called(args...) method, and return the appropriate values.
@ -19,25 +19,25 @@
 // For example, to mock a method that saves the name and age of a person and returns
 // the year of their birth or an error, you might write this:
 //
-//	func (o *MyTestObject) SavePersonDetails(firstname, lastname string, age int) (int, error) {
-//	  args := o.Called(firstname, lastname, age)
-//	  return args.Int(0), args.Error(1)
-//	}
+//     func (o *MyTestObject) SavePersonDetails(firstname, lastname string, age int) (int, error) {
+//       args := o.Called(firstname, lastname, age)
+//       return args.Int(0), args.Error(1)
+//     }
 //
 // The Int, Error and Bool methods are examples of strongly typed getters that take the argument
 // index position. Given this argument list:
 //
-//	(12, true, "Something")
+//     (12, true, "Something")
 //
 // You could read them out strongly typed like this:
 //
-//	args.Int(0)
-//	args.Bool(1)
-//	args.String(2)
+//     args.Int(0)
+//     args.Bool(1)
+//     args.String(2)
 //
 // For objects of your own type, use the generic Arguments.Get(index) method and make a type assertion:
 //
-//	return args.Get(0).(*MyObject), args.Get(1).(*AnotherObjectOfMine)
+//     return args.Get(0).(*MyObject), args.Get(1).(*AnotherObjectOfMine)
 //
 // This may cause a panic if the object you are getting is nil (the type assertion will fail), in those
 // cases you should check for nil first.
--- a/mock/mock.go
+++ b/mock/mock.go
@ -3,7 +3,6 @@ package mock
 import (
 	"errors"
 	"fmt"
-	"path"
 	"reflect"
 	"regexp"
 	"runtime"
@ -14,13 +13,9 @@ import (
 	"github.com/davecgh/go-spew/spew"
 	"github.com/pmezard/go-difflib/difflib"
 	"github.com/stretchr/objx"
-
 	"github.com/stretchr/testify/assert"
 )

-// regex for GCCGO functions
-var gccgoRE = regexp.MustCompile(`\.pN\d+_`)
-
 // TestingT is an interface wrapper around *testing.T
 type TestingT interface {
 	Logf(format string, args ...interface{})
@ -75,17 +70,14 @@ type Call struct {
 	//  if the PanicMsg is set to a non nil string the function call will panic
 	// irrespective of other settings
 	PanicMsg *string
-
-	// Calls which must be satisfied before this call can be
-	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,
@ -104,7 +96,7 @@ func (c *Call) unlock() {

 // Return specifies the return arguments for the expectation.
 //
-//	Mock.On("DoSomething").Return(errors.New("failed"))
+//    Mock.On("DoSomething").Return(errors.New("failed"))
 func (c *Call) Return(returnArguments ...interface{}) *Call {
 	c.lock()
 	defer c.unlock()
@ -114,9 +106,9 @@ func (c *Call) Return(returnArguments ...interface{}) *Call {
 	return c
 }

-// Panic specifies if the function call should fail and the panic message
+// Panic specifies if the functon call should fail and the panic message
 //
-//	Mock.On("DoSomething").Panic("test panic")
+//    Mock.On("DoSomething").Panic("test panic")
 func (c *Call) Panic(msg string) *Call {
 	c.lock()
 	defer c.unlock()
@ -126,24 +118,24 @@ func (c *Call) Panic(msg string) *Call {
 	return c
 }

-// Once indicates that the mock should only return the value once.
+// Once indicates that that the mock should only return the value once.
 //
-//	Mock.On("MyMethod", arg1, arg2).Return(returnArg1, returnArg2).Once()
+//    Mock.On("MyMethod", arg1, arg2).Return(returnArg1, returnArg2).Once()
 func (c *Call) Once() *Call {
 	return c.Times(1)
 }

-// Twice indicates that the mock should only return the value twice.
+// Twice indicates that that the mock should only return the value twice.
 //
-//	Mock.On("MyMethod", arg1, arg2).Return(returnArg1, returnArg2).Twice()
+//    Mock.On("MyMethod", arg1, arg2).Return(returnArg1, returnArg2).Twice()
 func (c *Call) Twice() *Call {
 	return c.Times(2)
 }

-// Times indicates that the mock should only return the indicated number
+// Times indicates that that the mock should only return the indicated number
 // of times.
 //
-//	Mock.On("MyMethod", arg1, arg2).Return(returnArg1, returnArg2).Times(5)
+//    Mock.On("MyMethod", arg1, arg2).Return(returnArg1, returnArg2).Times(5)
 func (c *Call) Times(i int) *Call {
 	c.lock()
 	defer c.unlock()
@ -154,7 +146,7 @@ func (c *Call) Times(i int) *Call {
 // WaitUntil sets the channel that will block the mock's return until its closed
 // or a message is received.
 //
-//	Mock.On("MyMethod", arg1, arg2).WaitUntil(time.After(time.Second))
+//    Mock.On("MyMethod", arg1, arg2).WaitUntil(time.After(time.Second))
 func (c *Call) WaitUntil(w <-chan time.Time) *Call {
 	c.lock()
 	defer c.unlock()
@ -164,7 +156,7 @@ func (c *Call) WaitUntil(w <-chan time.Time) *Call {

 // After sets how long to block until the call returns
 //
-//	Mock.On("MyMethod", arg1, arg2).After(time.Second)
+//    Mock.On("MyMethod", arg1, arg2).After(time.Second)
 func (c *Call) After(d time.Duration) *Call {
 	c.lock()
 	defer c.unlock()
@ -176,10 +168,10 @@ func (c *Call) After(d time.Duration) *Call {
 // mocking a method (such as an unmarshaler) that takes a pointer to a struct and
 // sets properties in such struct
 //
-//	Mock.On("Unmarshal", AnythingOfType("*map[string]interface{}")).Return().Run(func(args Arguments) {
-//		arg := args.Get(0).(*map[string]interface{})
-//		arg["foo"] = "bar"
-//	})
+//    Mock.On("Unmarshal", AnythingOfType("*map[string]interface{}")).Return().Run(func(args Arguments) {
+//    	arg := args.Get(0).(*map[string]interface{})
+//    	arg["foo"] = "bar"
+//    })
 func (c *Call) Run(fn func(args Arguments)) *Call {
 	c.lock()
 	defer c.unlock()
@ -199,101 +191,14 @@ func (c *Call) Maybe() *Call {
 // On chains a new expectation description onto the mocked interface. This
 // allows syntax like.
 //
-//	Mock.
-//	   On("MyMethod", 1).Return(nil).
-//	   On("MyOtherMethod", 'a', 'b', 'c').Return(errors.New("Some Error"))
-//
+//    Mock.
+//       On("MyMethod", 1).Return(nil).
+//       On("MyOtherMethod", 'a', 'b', 'c').Return(errors.New("Some Error"))
 //go:noinline
 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.
-//
-// 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()
-func (c *Call) Unset() *Call {
-	var unlockOnce sync.Once
-
-	for _, arg := range c.Arguments {
-		if v := reflect.ValueOf(arg); v.Kind() == reflect.Func {
-			panic(fmt.Sprintf("cannot use Func in expectations. Use mock.AnythingOfType(\"%T\")", arg))
-		}
-	}
-
-	c.lock()
-	defer unlockOnce.Do(c.unlock)
-
-	foundMatchingCall := false
-
-	// in-place filter slice for calls to be removed - iterate from 0'th to last skipping unnecessary ones
-	var index int // write index
-	for _, call := range c.Parent.ExpectedCalls {
-		if call.Method == c.Method {
-			_, diffCount := call.Arguments.Diff(c.Arguments)
-			if diffCount == 0 {
-				foundMatchingCall = true
-				// Remove from ExpectedCalls - just skip it
-				continue
-			}
-		}
-		c.Parent.ExpectedCalls[index] = call
-		index++
-	}
-	// trim slice up to last copied index
-	c.Parent.ExpectedCalls = c.Parent.ExpectedCalls[:index]
-
-	if !foundMatchingCall {
-		unlockOnce.Do(c.unlock)
-		c.Parent.fail("\n\nmock: Could not find expected call\n-----------------------------\n\n%s\n\n",
-			callString(c.Method, c.Arguments, true),
-		)
-	}
-
-	return c
-}
-
-// NotBefore indicates that the mock should only be called after the referenced
-// 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("Init").Return(nil)
-//	)
-func (c *Call) NotBefore(calls ...*Call) *Call {
-	c.lock()
-	defer c.unlock()
-
-	for _, call := range calls {
-		if call.Parent == nil {
-			panic("not before calls must be created with Mock.On()")
-		}
-	}
-
-	c.requires = append(c.requires, calls...)
-	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.
@ -313,7 +218,7 @@ type Mock struct {
 	// this data completely allowing you to do whatever you like with it.
 	testData objx.Map

-	mutex sync.Mutex
+	mutex *sync.Mutex
 }

 // String provides a %v format string for Mock.
@ -338,11 +243,12 @@ 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) {
+	if m.mutex == nil {
+		m.mutex = &sync.Mutex{}
+	}
+
 	m.mutex.Lock()
 	defer m.mutex.Unlock()
 	m.test = t
@ -365,7 +271,7 @@ func (m *Mock) fail(format string, args ...interface{}) {
 // On starts a description of an expectation of the specified method
 // being called.
 //
-//	Mock.On("MyMethod", arg1, arg2)
+//     Mock.On("MyMethod", arg1, arg2)
 func (m *Mock) On(methodName string, arguments ...interface{}) *Call {
 	for _, arg := range arguments {
 		if v := reflect.ValueOf(arg); v.Kind() == reflect.Func {
@ -373,10 +279,12 @@ func (m *Mock) On(methodName string, arguments ...interface{}) *Call {
 		}
 	}

+	// Since we start mocks with the .On() function, m.mutex should be reset
+	m.mutex = &sync.Mutex{}
+
 	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
 }
@ -456,10 +364,6 @@ func callString(method string, arguments Arguments, includeArgumentValues bool)
 	if includeArgumentValues {
 		var argVals []string
 		for argIndex, arg := range arguments {
-			if _, ok := arg.(*FunctionalOptionsArgument); ok {
-				argVals = append(argVals, fmt.Sprintf("%d: %s", argIndex, arg))
-				continue
-			}
 			argVals = append(argVals, fmt.Sprintf("%d: %#v", argIndex, arg))
 		}
 		argValsString = fmt.Sprintf("\n\t\t%s", strings.Join(argVals, "\n\t\t"))
@ -483,8 +387,9 @@ func (m *Mock) Called(arguments ...interface{}) Arguments {
 	// For Ex:  github_com_docker_libkv_store_mock.WatchTree.pN39_github_com_docker_libkv_store_mock.Mock
 	// uses interface information unlike golang github.com/docker/libkv/store/mock.(*Mock).WatchTree
 	// With GCCGO we need to remove interface information starting from pN<dd>.
-	if gccgoRE.MatchString(functionPath) {
-		functionPath = gccgoRE.Split(functionPath, -1)[0]
+	re := regexp.MustCompile("\\.pN\\d+_")
+	if re.MatchString(functionPath) {
+		functionPath = re.Split(functionPath, -1)[0]
 	}
 	parts := strings.Split(functionPath, ".")
 	functionName := parts[len(parts)-1]
@ -501,10 +406,10 @@ func (m *Mock) MethodCalled(methodName string, arguments ...interface{}) Argumen
 	found, call := m.findExpectedCall(methodName, arguments...)

 	if found < 0 {
-		// expected call found, but it has already been called with repeatable times
+		// 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,34 +421,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())
-		}
-	}
-
-	for _, requirement := range call.requires {
-		if satisfied, _ := requirement.Parent.checkExpectation(requirement); !satisfied {
-			m.mutex.Unlock()
-			m.fail("mock: Unexpected Method Call\n-----------------------------\n\n%s\n\nMust not be called before%s:\n\n%s",
-				callString(call.Method, call.Arguments, true),
-				func() (s string) {
-					if requirement.totalCalls > 0 {
-						s = " another call of"
-					}
-					if call.Parent != requirement.Parent {
-						s += " method from another mock instance"
-					}
-					return
-				}(),
-				callString(requirement.Method, requirement.Arguments, true),
-			)
+			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 +440,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
@ -591,7 +476,7 @@ func (m *Mock) MethodCalled(methodName string, arguments ...interface{}) Argumen
 	Assertions
 */

-type assertExpectationiser interface {
+type assertExpectationser interface {
 	AssertExpectations(TestingT) bool
 }

@ -604,11 +489,11 @@ func AssertExpectationsForObjects(t TestingT, testObjects ...interface{}) bool {
 		h.Helper()
 	}
 	for _, obj := range testObjects {
-		if m, ok := obj.(*Mock); ok {
+		if m, ok := obj.(Mock); ok {
 			t.Logf("Deprecated mock.AssertExpectationsForObjects(myMock.Mock) use mock.AssertExpectationsForObjects(myMock)")
-			obj = m
+			obj = &m
 		}
-		m := obj.(assertExpectationiser)
+		m := obj.(assertExpectationser)
 		if !m.AssertExpectations(t) {
 			t.Logf("Expectations didn't match for Mock: %+v", reflect.TypeOf(m))
 			return false
@ -620,42 +505,41 @@ func AssertExpectationsForObjects(t TestingT, testObjects ...interface{}) bool {
 // AssertExpectations asserts that everything specified with On and Return was
 // in fact called as expected.  Calls may have occurred in any order.
 func (m *Mock) AssertExpectations(t TestingT) bool {
-	if s, ok := t.(interface{ Skipped() bool }); ok && s.Skipped() {
-		return true
-	}
 	if h, ok := t.(tHelper); ok {
 		h.Helper()
 	}
+	if m.mutex == nil {
+		m.mutex = &sync.Mutex{}
+	}

 	m.mutex.Lock()
 	defer m.mutex.Unlock()
+	var somethingMissing bool
 	var failedExpectations int

 	// iterate through each expectation
 	expectedCalls := m.expectedCalls()
 	for _, expectedCall := range expectedCalls {
-		satisfied, reason := m.checkExpectation(expectedCall)
-		if !satisfied {
+		if !expectedCall.optional && !m.methodWasCalled(expectedCall.Method, expectedCall.Arguments) && expectedCall.totalCalls == 0 {
+			somethingMissing = true
 			failedExpectations++
-			t.Logf(reason)
+			t.Logf("FAIL:\t%s(%s)\n\t\tat: %s", expectedCall.Method, expectedCall.Arguments.String(), expectedCall.callerInfo)
+		} else {
+			if expectedCall.Repeatability > 0 {
+				somethingMissing = true
+				failedExpectations++
+				t.Logf("FAIL:\t%s(%s)\n\t\tat: %s", expectedCall.Method, expectedCall.Arguments.String(), expectedCall.callerInfo)
+			} else {
+				t.Logf("PASS:\t%s(%s)", expectedCall.Method, expectedCall.Arguments.String())
+			}
 		}
 	}

-	if failedExpectations != 0 {
+	if somethingMissing {
 		t.Errorf("FAIL: %d out of %d expectation(s) were met.\n\tThe code you are testing needs to make %d more call(s).\n\tat: %s", len(expectedCalls)-failedExpectations, len(expectedCalls), failedExpectations, assert.CallerInfo())
 	}

-	return failedExpectations == 0
-}
-
-func (m *Mock) checkExpectation(call *Call) (bool, string) {
-	if !call.optional && !m.methodWasCalled(call.Method, call.Arguments) && call.totalCalls == 0 {
-		return false, fmt.Sprintf("FAIL:\t%s(%s)\n\t\tat: %s", call.Method, call.Arguments.String(), call.callerInfo)
-	}
-	if call.Repeatability > 0 {
-		return false, fmt.Sprintf("FAIL:\t%s(%s)\n\t\tat: %s", call.Method, call.Arguments.String(), call.callerInfo)
-	}
-	return true, fmt.Sprintf("PASS:\t%s(%s)", call.Method, call.Arguments.String())
+	return !somethingMissing
 }

 // AssertNumberOfCalls asserts that the method was called expectedCalls times.
@ -789,80 +673,34 @@ const (
 	Anything = "mock.Anything"
 )

-// AnythingOfTypeArgument contains the type of an argument
-// for use when type checking.  Used in [Arguments.Diff] and [Arguments.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")
-//	}
-type AnythingOfTypeArgument = anythingOfTypeArgument
-
-// anythingOfTypeArgument is a string that contains the type of an argument
+// AnythingOfTypeArgument is a string that contains the type of an argument
 // for use when type checking.  Used in Diff and Assert.
-type anythingOfTypeArgument string
+type AnythingOfTypeArgument string

-// AnythingOfType returns a special value containing the
-// name of the type to check for. The type name will be matched against the type name returned by [reflect.Type.String].
-//
-// Used in Diff and Assert.
+// AnythingOfType returns an AnythingOfTypeArgument object containing the
+// name of the type to check for.  Used in Diff and Assert.
 //
 // For example:
-//
-//	args.Assert(t, AnythingOfType("string"), AnythingOfType("int"))
+//	Assert(t, AnythingOfType("string"), AnythingOfType("int"))
 func AnythingOfType(t string) AnythingOfTypeArgument {
-	return anythingOfTypeArgument(t)
+	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
+	t interface{}
 }

 // 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.
-type FunctionalOptionsArgument struct {
-	values []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()
-	}
-
-	return strings.Replace(fmt.Sprintf("%#v", f.values), "[]interface {}", name, 1)
-}
-
-// FunctionalOptions returns an [FunctionalOptionsArgument] object containing
-// the expected functional-options to check for.
-//
-// For example:
-//
-//	args.Assert(t, FunctionalOptions(foo.Opt1("strValue"), foo.Opt2(613)))
-func FunctionalOptions(values ...interface{}) *FunctionalOptionsArgument {
-	return &FunctionalOptionsArgument{
-		values: values,
-	}
+	return &IsTypeArgument{t: t}
 }

 // argumentMatcher performs custom argument matching, returning whether or
@ -908,11 +746,10 @@ func (f argumentMatcher) String() string {
 // and false otherwise.
 //
 // Example:
+// m.On("Do", MatchedBy(func(req *http.Request) bool { return req.Host == "example.com" }))
 //
-//	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)
@ -984,66 +821,35 @@ func (args Arguments) Diff(objects []interface{}) (string, int) {
 		}

 		if matcher, ok := expected.(argumentMatcher); ok {
-			var matches bool
-			func() {
-				defer func() {
-					if r := recover(); r != nil {
-						actualFmt = fmt.Sprintf("panic in argument matcher: %v", r)
-					}
-				}()
-				matches = matcher.Matches(actual)
-			}()
-			if matches {
+			if matcher.Matches(actual) {
 				output = fmt.Sprintf("%s\t%d: PASS:  %s matched by %s\n", output, i, actualFmt, matcher)
 			} else {
 				differences++
 				output = fmt.Sprintf("%s\t%d: FAIL:  %s not matched by %s\n", output, i, actualFmt, matcher)
 			}
+		} else if reflect.TypeOf(expected) == reflect.TypeOf((*AnythingOfTypeArgument)(nil)).Elem() {
+			// type checking
+			if reflect.TypeOf(actual).Name() != string(expected.(AnythingOfTypeArgument)) && reflect.TypeOf(actual).String() != string(expected.(AnythingOfTypeArgument)) {
+				// not match
+				differences++
+				output = fmt.Sprintf("%s\t%d: FAIL:  type %s != type %s - %s\n", output, i, expected, reflect.TypeOf(actual).Name(), actualFmt)
+			}
+		} else if reflect.TypeOf(expected) == reflect.TypeOf((*IsTypeArgument)(nil)) {
+			t := expected.(*IsTypeArgument).t
+			if reflect.TypeOf(t) != reflect.TypeOf(actual) {
+				differences++
+				output = fmt.Sprintf("%s\t%d: FAIL:  type %s != type %s - %s\n", output, i, reflect.TypeOf(t).Name(), reflect.TypeOf(actual).Name(), actualFmt)
+			}
 		} else {
-			switch expected := expected.(type) {
-			case anythingOfTypeArgument:
-				// type checking
-				if reflect.TypeOf(actual).Name() != string(expected) && reflect.TypeOf(actual).String() != string(expected) {
-					// not match
-					differences++
-					output = fmt.Sprintf("%s\t%d: FAIL:  type %s != type %s - %s\n", output, i, expected, reflect.TypeOf(actual).Name(), actualFmt)
-				}
-			case *IsTypeArgument:
-				actualT := reflect.TypeOf(actual)
-				if actualT != expected.t {
-					differences++
-					output = fmt.Sprintf("%s\t%d: FAIL:  type %s != type %s - %s\n", output, i, expected.t.Name(), actualT.Name(), actualFmt)
-				}
-			case *FunctionalOptionsArgument:
-				var name string
-				if len(expected.values) > 0 {
-					name = "[]" + reflect.TypeOf(expected.values[0]).String()
-				}
+			// normal checking

-				const tName = "[]interface{}"
-				if name != reflect.TypeOf(actual).String() && len(expected.values) != 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 == "" {
-						// match
-						output = fmt.Sprintf("%s\t%d: PASS:  %s == %s\n", output, i, tName, tName)
-					} else {
-						// not match
-						differences++
-						output = fmt.Sprintf("%s\t%d: FAIL:  %s != %s\n", output, i, af, ef)
-					}
-				}
-
-			default:
-				if assert.ObjectsAreEqual(expected, Anything) || assert.ObjectsAreEqual(actual, Anything) || assert.ObjectsAreEqual(actual, expected) {
-					// match
-					output = fmt.Sprintf("%s\t%d: PASS:  %s == %s\n", output, i, actualFmt, expectedFmt)
-				} else {
-					// not match
-					differences++
-					output = fmt.Sprintf("%s\t%d: FAIL:  %s != %s\n", output, i, actualFmt, expectedFmt)
-				}
+			if assert.ObjectsAreEqual(expected, Anything) || assert.ObjectsAreEqual(actual, Anything) || assert.ObjectsAreEqual(actual, expected) {
+				// match
+				output = fmt.Sprintf("%s\t%d: PASS:  %s == %s\n", output, i, actualFmt, expectedFmt)
+			} else {
+				// not match
+				differences++
+				output = fmt.Sprintf("%s\t%d: FAIL:  %s != %s\n", output, i, actualFmt, expectedFmt)
 			}
 		}

@ -1125,7 +931,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
 }
@ -1210,89 +1016,3 @@ var spewConfig = spew.ConfigState{
 type tHelper interface {
 	Helper()
 }
-
-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))
-	}
-	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))
-	}
-
-	if expectedOpts.Len() != actualOpts.Len() {
-		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()
-
-		ot := reflect.TypeOf(expectedOpt)
-		var expectedValues []reflect.Value
-		var actualValues []reflect.Value
-		if ot.NumIn() == 0 {
-			return
-		}
-
-		for i := 0; i < ot.NumIn(); i++ {
-			vt := ot.In(i).Elem()
-			expectedValues = append(expectedValues, reflect.New(vt))
-			actualValues = append(actualValues, reflect.New(vt))
-		}
-
-		reflect.ValueOf(expectedOpt).Call(expectedValues)
-		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)
-				return
-			}
-		}
-	}
-
-	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
-}
--- a/mock/mock_test.go
+++ b/mock/mock_test.go
@ -32,40 +32,6 @@ func (i *TestExampleImplementation) TheExampleMethod(a, b, c int) (int, error) {
 	return args.Int(0), errors.New("Whoops")
 }

-type options struct {
-	num int
-	str string
-}
-
-type OptionFn func(*options)
-
-func OpNum(n int) OptionFn {
-	return func(o *options) {
-		o.num = n
-	}
-}
-
-func OpStr(s string) OptionFn {
-	return func(o *options) {
-		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)
@ -147,7 +113,7 @@ func (m *MockTestingT) Errorf(string, ...interface{}) {
 // the execution stops.
 // When expecting this method, the call that invokes it should use the following code:
 //
-//	assert.PanicsWithValue(t, mockTestingTFailNowCalled, func() {...})
+//     assert.PanicsWithValue(t, mockTestingTFailNowCalled, func() {...})
 func (m *MockTestingT) FailNow() {
 	m.failNowCount++

@ -185,7 +151,7 @@ func Test_Mock_Chained_On(t *testing.T) {
 	var mockedService = new(TestExampleImplementation)

 	// determine our current line number so we can assert the expected calls callerInfo properly
-	_, filename, line, _ := runtime.Caller(0)
+	_, _, line, _ := runtime.Caller(0)
 	mockedService.
 		On("TheExampleMethod", 1, 2, 3).
 		Return(0).
@ -198,14 +164,14 @@ func Test_Mock_Chained_On(t *testing.T) {
 			Method:          "TheExampleMethod",
 			Arguments:       []interface{}{1, 2, 3},
 			ReturnArguments: []interface{}{0},
-			callerInfo:      []string{fmt.Sprintf("%s:%d", filename, line+2)},
+			callerInfo:      []string{fmt.Sprintf("mock_test.go:%d", line+2)},
 		},
 		{
 			Parent:          &mockedService.Mock,
 			Method:          "TheExampleMethod3",
 			Arguments:       []interface{}{AnythingOfType("*mock.ExampleType")},
 			ReturnArguments: []interface{}{nil},
-			callerInfo:      []string{fmt.Sprintf("%s:%d", filename, line+4)},
+			callerInfo:      []string{fmt.Sprintf("mock_test.go:%d", line+4)},
 		},
 	}
 	assert.Equal(t, expectedCalls, mockedService.ExpectedCalls)
@ -267,32 +233,6 @@ func Test_Mock_On_WithIntArgMatcher(t *testing.T) {
 	})
 }

-func Test_Mock_On_WithArgMatcherThatPanics(t *testing.T) {
-	var mockedService TestExampleImplementation
-
-	mockedService.On("TheExampleMethod2", MatchedBy(func(_ interface{}) bool {
-		panic("try to lock mockedService")
-	})).Return()
-
-	defer func() {
-		assertedExpectations := make(chan struct{})
-		go func() {
-			tt := new(testing.T)
-			mockedService.AssertExpectations(tt)
-			close(assertedExpectations)
-		}()
-		select {
-		case <-assertedExpectations:
-		case <-time.After(time.Second):
-			t.Fatal("AssertExpectations() deadlocked, did the panic leave mockedService locked?")
-		}
-	}()
-
-	assert.Panics(t, func() {
-		mockedService.TheExampleMethod2(false)
-	})
-}
-
 func TestMock_WithTest(t *testing.T) {
 	var (
 		mockedService TestExampleImplementation
@ -522,161 +462,6 @@ func Test_Mock_On_WithFuncTypeArg(t *testing.T) {
 	})
 }

-func Test_Mock_Unset(t *testing.T) {
-	// make a test impl object
-	var mockedService = new(TestExampleImplementation)
-
-	call := mockedService.
-		On("TheExampleMethodFuncType", "argA").
-		Return("blah")
-
-	found, foundCall := mockedService.findExpectedCall("TheExampleMethodFuncType", "argA")
-	require.NotEqual(t, -1, found)
-	require.Equal(t, foundCall, call)
-
-	call.Unset()
-
-	found, foundCall = mockedService.findExpectedCall("TheExampleMethodFuncType", "argA")
-	require.Equal(t, -1, found)
-
-	var expectedCall *Call
-	require.Equal(t, expectedCall, foundCall)
-
-	fn := func(string) error { return nil }
-	assert.Panics(t, func() {
-		mockedService.TheExampleMethodFuncType(fn)
-	})
-}
-
-// Since every time you call On it creates a new object
-// the last time you call Unset it will only unset the last call
-func Test_Mock_Chained_UnsetOnlyUnsetsLastCall(t *testing.T) {
-	// make a test impl object
-	var mockedService = new(TestExampleImplementation)
-
-	// determine our current line number so we can assert the expected calls callerInfo properly
-	_, filename, line, _ := runtime.Caller(0)
-	mockedService.
-		On("TheExampleMethod1", 1, 1).
-		Return(0).
-		On("TheExampleMethod2", 2, 2).
-		On("TheExampleMethod3", 3, 3, 3).
-		Return(nil).
-		Unset()
-
-	expectedCalls := []*Call{
-		{
-			Parent:          &mockedService.Mock,
-			Method:          "TheExampleMethod1",
-			Arguments:       []interface{}{1, 1},
-			ReturnArguments: []interface{}{0},
-			callerInfo:      []string{fmt.Sprintf("%s:%d", filename, line+2)},
-		},
-		{
-			Parent:          &mockedService.Mock,
-			Method:          "TheExampleMethod2",
-			Arguments:       []interface{}{2, 2},
-			ReturnArguments: []interface{}{},
-			callerInfo:      []string{fmt.Sprintf("%s:%d", filename, line+4)},
-		},
-	}
-	assert.Equal(t, 2, len(expectedCalls))
-	assert.Equal(t, expectedCalls, mockedService.ExpectedCalls)
-}
-
-func Test_Mock_UnsetIfAlreadyUnsetFails(t *testing.T) {
-	// make a test impl object
-	var mockedService = new(TestExampleImplementation)
-
-	mock1 := mockedService.
-		On("TheExampleMethod1", 1, 1).
-		Return(1)
-
-	assert.Equal(t, 1, len(mockedService.ExpectedCalls))
-	mock1.Unset()
-	assert.Equal(t, 0, len(mockedService.ExpectedCalls))
-
-	assert.Panics(t, func() {
-		mock1.Unset()
-	})
-
-	assert.Equal(t, 0, len(mockedService.ExpectedCalls))
-}
-
-func Test_Mock_UnsetByOnMethodSpec(t *testing.T) {
-	// make a test impl object
-	var mockedService = new(TestExampleImplementation)
-
-	mock1 := mockedService.
-		On("TheExampleMethod", 1, 2, 3).
-		Return(0, nil)
-
-	assert.Equal(t, 1, len(mockedService.ExpectedCalls))
-	mock1.On("TheExampleMethod", 1, 2, 3).
-		Return(0, nil).Unset()
-
-	assert.Equal(t, 0, len(mockedService.ExpectedCalls))
-
-	assert.Panics(t, func() {
-		mock1.Unset()
-	})
-
-	assert.Equal(t, 0, len(mockedService.ExpectedCalls))
-}
-
-func Test_Mock_UnsetByOnMethodSpecAmongOthers(t *testing.T) {
-	// make a test impl object
-	var mockedService = new(TestExampleImplementation)
-
-	_, filename, line, _ := runtime.Caller(0)
-	mock1 := mockedService.
-		On("TheExampleMethod", 1, 2, 3).
-		Return(0, nil).
-		On("TheExampleMethodVariadic", 1, 2, 3, 4, 5).Once().
-		Return(nil)
-	mock1.
-		On("TheExampleMethodFuncType", Anything).
-		Return(nil)
-
-	assert.Equal(t, 3, len(mockedService.ExpectedCalls))
-	mock1.On("TheExampleMethod", 1, 2, 3).
-		Return(0, nil).Unset()
-
-	assert.Equal(t, 2, len(mockedService.ExpectedCalls))
-
-	expectedCalls := []*Call{
-		{
-			Parent:          &mockedService.Mock,
-			Method:          "TheExampleMethodVariadic",
-			Repeatability:   1,
-			Arguments:       []interface{}{1, 2, 3, 4, 5},
-			ReturnArguments: []interface{}{nil},
-			callerInfo:      []string{fmt.Sprintf("%s:%d", filename, line+4)},
-		},
-		{
-			Parent:          &mockedService.Mock,
-			Method:          "TheExampleMethodFuncType",
-			Arguments:       []interface{}{Anything},
-			ReturnArguments: []interface{}{nil},
-			callerInfo:      []string{fmt.Sprintf("%s:%d", filename, line+7)},
-		},
-	}
-
-	assert.Equal(t, 2, len(mockedService.ExpectedCalls))
-	assert.Equal(t, expectedCalls, mockedService.ExpectedCalls)
-}
-
-func Test_Mock_Unset_WithFuncPanics(t *testing.T) {
-	// make a test impl object
-	var mockedService = new(TestExampleImplementation)
-	mock1 := mockedService.On("TheExampleMethod", 1)
-	mock1.Arguments = append(mock1.Arguments, func(string) error { return nil })
-
-	assert.Panics(t, func() {
-		mock1.Unset()
-	})
-}
-
 func Test_Mock_Return(t *testing.T) {

 	// make a test impl object
@ -928,245 +713,6 @@ func Test_Mock_Return_Nothing(t *testing.T) {
 	assert.Equal(t, 0, len(call.ReturnArguments))
 }

-func Test_Mock_Return_NotBefore_In_Order(t *testing.T) {
-	var mockedService = new(TestExampleImplementation)
-
-	b := mockedService.
-		On("TheExampleMethod", 1, 2, 3).
-		Return(4, nil)
-	c := mockedService.
-		On("TheExampleMethod2", true).
-		Return().
-		NotBefore(b)
-
-	require.Equal(t, []*Call{b, c}, mockedService.ExpectedCalls)
-	require.NotPanics(t, func() {
-		mockedService.TheExampleMethod(1, 2, 3)
-	})
-	require.NotPanics(t, func() {
-		mockedService.TheExampleMethod2(true)
-	})
-}
-
-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)
-
-	b := mockedService.
-		On("TheExampleMethod", 1, 2, 3).
-		Return(4, nil).Twice()
-	c := mockedService.
-		On("TheExampleMethod2", true).
-		Return().
-		NotBefore(b)
-
-	require.Equal(t, []*Call{b, c}, mockedService.ExpectedCalls)
-
-	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_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)
-
-	b := mockedService.
-		On("TheExampleMethod", 1, 2, 3).
-		Return(4, nil).Twice()
-	c := mockedService.
-		On("TheExampleMethod2", true).
-		Return().
-		NotBefore(b)
-
-	require.Equal(t, []*Call{b, c}, mockedService.ExpectedCalls)
-
-	require.NotPanics(t, func() {
-		mockedService.TheExampleMethod(1, 2, 3)
-	})
-	expectedPanicString := `mock: Unexpected Method Call
-----------------------------
-
-TheExampleMethod2(bool)
-		0: true
-
-Must not be called before another call of:
-
-TheExampleMethod(int,int,int)
-		0: 1
-		1: 2
-		2: 3`
-	require.PanicsWithValue(t, expectedPanicString, func() {
-		mockedService.TheExampleMethod2(true)
-	})
-}
-
-func Test_Mock_Return_NotBefore_Different_Mock_In_Order(t *testing.T) {
-	var (
-		mockedService1 = new(TestExampleImplementation)
-		mockedService2 = new(TestExampleImplementation)
-	)
-
-	b := mockedService1.
-		On("TheExampleMethod", 1, 2, 3).
-		Return(4, nil)
-	c := mockedService2.
-		On("TheExampleMethod2", true).
-		Return().
-		NotBefore(b)
-
-	require.Equal(t, []*Call{c}, mockedService2.ExpectedCalls)
-	require.NotPanics(t, func() {
-		mockedService1.TheExampleMethod(1, 2, 3)
-	})
-	require.NotPanics(t, func() {
-		mockedService2.TheExampleMethod2(true)
-	})
-}
-
-func Test_Mock_Return_NotBefore_Different_Mock_Out_Of_Order(t *testing.T) {
-	var (
-		mockedService1 = new(TestExampleImplementation)
-		mockedService2 = new(TestExampleImplementation)
-	)
-
-	b := mockedService1.
-		On("TheExampleMethod", 1, 2, 3).
-		Return(4, nil)
-	c := mockedService2.
-		On("TheExampleMethod2", true).
-		Return().
-		NotBefore(b)
-
-	require.Equal(t, []*Call{c}, mockedService2.ExpectedCalls)
-
-	expectedPanicString := `mock: Unexpected Method Call
-----------------------------
-
-TheExampleMethod2(bool)
-		0: true
-
-Must not be called before method from another mock instance:
-
-TheExampleMethod(int,int,int)
-		0: 1
-		1: 2
-		2: 3`
-	require.PanicsWithValue(t, expectedPanicString, func() {
-		mockedService2.TheExampleMethod2(true)
-	})
-}
-
-func Test_Mock_Return_NotBefore_In_Order_With_Non_Dependant(t *testing.T) {
-	var mockedService = new(TestExampleImplementation)
-
-	a := mockedService.
-		On("TheExampleMethod", 1, 2, 3).
-		Return(4, nil)
-	b := mockedService.
-		On("TheExampleMethod", 4, 5, 6).
-		Return(4, nil)
-	c := mockedService.
-		On("TheExampleMethod2", true).
-		Return().
-		NotBefore(a, b)
-	d := mockedService.
-		On("TheExampleMethod7", []bool{}).Return(nil)
-
-	require.Equal(t, []*Call{a, b, c, d}, mockedService.ExpectedCalls)
-	require.NotPanics(t, func() {
-		mockedService.TheExampleMethod7([]bool{})
-	})
-	require.NotPanics(t, func() {
-		mockedService.TheExampleMethod(1, 2, 3)
-	})
-	require.NotPanics(t, func() {
-		mockedService.TheExampleMethod7([]bool{})
-	})
-	require.NotPanics(t, func() {
-		mockedService.TheExampleMethod(4, 5, 6)
-	})
-	require.NotPanics(t, func() {
-		mockedService.TheExampleMethod7([]bool{})
-	})
-	require.NotPanics(t, func() {
-		mockedService.TheExampleMethod2(true)
-	})
-	require.NotPanics(t, func() {
-		mockedService.TheExampleMethod7([]bool{})
-	})
-}
-
-func Test_Mock_Return_NotBefore_Orphan_Call(t *testing.T) {
-	var mockedService = new(TestExampleImplementation)
-
-	require.PanicsWithValue(t, "not before calls must be created with Mock.On()", func() {
-		mockedService.
-			On("TheExampleMethod2", true).
-			Return().
-			NotBefore(&Call{Method: "Not", Arguments: Arguments{"how", "it's"}, ReturnArguments: Arguments{"done"}})
-	})
-}
-
 func Test_Mock_findExpectedCall(t *testing.T) {

 	m := new(Mock)
@ -1267,7 +813,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 +822,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
@ -1499,85 +1045,6 @@ func Test_Mock_AssertExpectationsCustomType(t *testing.T) {

 }

-func Test_Mock_AssertExpectationsFunctionalOptionsType(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
-	mockedService.TheExampleMethodFunctionalOptions("test", OpNum(1), OpStr("foo"))
-
-	// now assert expectations
-	assert.True(t, mockedService.AssertExpectations(tt))
-
-}
-
-func Test_Mock_AssertExpectationsFunctionalOptionsType_Empty(t *testing.T) {
-
-	var mockedService = new(TestExampleImplementation)
-
-	mockedService.On("TheExampleMethodFunctionalOptions", "test", FunctionalOptions()).Return(nil).Once()
-
-	tt := new(testing.T)
-	assert.False(t, mockedService.AssertExpectations(tt))
-
-	// make the call now
-	mockedService.TheExampleMethodFunctionalOptions("test")
-
-	// now assert expectations
-	assert.True(t, mockedService.AssertExpectations(tt))
-
-}
-
-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)
@ -1599,16 +1066,6 @@ func Test_Mock_AssertExpectations_With_Repeatability(t *testing.T) {

 }

-func Test_Mock_AssertExpectations_Skipped_Test(t *testing.T) {
-
-	var mockedService = new(TestExampleImplementation)
-
-	mockedService.On("Test_Mock_AssertExpectations_Skipped_Test", 1, 2, 3).Return(5, 6, 7)
-	defer mockedService.AssertExpectations(t)
-
-	t.Skip("skipping test to ensure AssertExpectations does not fail")
-}
-
 func Test_Mock_TwoCallsWithDifferentArguments(t *testing.T) {

 	var mockedService = new(TestExampleImplementation)
@ -1732,14 +1189,17 @@ func Test_Mock_IsMethodCallable(t *testing.T) {

 func TestIsArgsEqual(t *testing.T) {
 	var expected = Arguments{5, 3, 4, 6, 7, 2}
-
-	// Copy elements 1 to 5
-	args := append(([]interface{})(nil), expected[1:]...)
+	var args = make([]interface{}, 5)
+	for i := 1; i < len(expected); i++ {
+		args[i-1] = expected[i]
+	}
 	args[2] = expected[1]
 	assert.False(t, isArgsEqual(expected, args))

-	// Clone
-	arr := append(([]interface{})(nil), expected...)
+	var arr = make([]interface{}, 6)
+	for i := 0; i < len(expected); i++ {
+		arr[i] = expected[i]
+	}
 	assert.True(t, isArgsEqual(expected, arr))
 }

@ -1769,7 +1229,7 @@ func Test_Mock_AssertOptional(t *testing.T) {
 }

 /*
-Arguments helper methods
+	Arguments helper methods
 */
 func Test_Arguments_Get(t *testing.T) {

@ -2075,7 +1535,7 @@ func TestAfterTotalWaitTimeWhileExecution(t *testing.T) {

 	end := time.Now()
 	elapsedTime := end.Sub(start)
-	assert.True(t, elapsedTime > waitMs, fmt.Sprintf("Total elapsed time:%v should be at least greater than %v", elapsedTime, waitMs))
+	assert.True(t, elapsedTime > waitMs, fmt.Sprintf("Total elapsed time:%v should be atleast greater than %v", elapsedTime, waitMs))
 	assert.Equal(t, total, len(results))
 	for i := range results {
 		assert.Equal(t, fmt.Sprintf("Time%d", i), results[i], "Return value of method should be same")
@ -2086,7 +1546,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 +1563,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 +1594,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 +1610,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 +1667,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
@ -1,30 +1,27 @@
 // Package require implements the same assertions as the `assert` package but
 // stops test execution when a test fails.
 //
-// # Example Usage
+// Example Usage
 //
 // The following is a complete example using require in a standard test function:
+//    import (
+//      "testing"
+//      "github.com/stretchr/testify/require"
+//    )
 //
-//	import (
-//	  "testing"
-//	  "github.com/stretchr/testify/require"
-//	)
+//    func TestSomething(t *testing.T) {
 //
-//	func TestSomething(t *testing.T) {
+//      var a string = "Hello"
+//      var b string = "Hello"
 //
-//	  var a string = "Hello"
-//	  var b string = "Hello"
+//      require.Equal(t, a, b, "The two words should be the same.")
 //
-//	  require.Equal(t, a, b, "The two words should be the same.")
+//    }
 //
-//	}
-//
-// # Assertions
+// Assertions
 //
 // 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
--- 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
@ -31,40 +29,37 @@
 // Suite object has assertion methods.
 //
 // A crude example:
+//     // Basic imports
+//     import (
+//         "testing"
+//         "github.com/stretchr/testify/assert"
+//         "github.com/stretchr/testify/suite"
+//     )
 //
-//	// Basic imports
-//	import (
-//	    "testing"
-//	    "github.com/stretchr/testify/assert"
-//	    "github.com/stretchr/testify/suite"
-//	)
+//     // Define the suite, and absorb the built-in basic suite
+//     // functionality from testify - including a T() method which
+//     // returns the current testing context
+//     type ExampleTestSuite struct {
+//         suite.Suite
+//         VariableThatShouldStartAtFive int
+//     }
 //
-//	// Define the suite, and absorb the built-in basic suite
-//	// functionality from testify - including a T() method which
-//	// returns the current testing context
-//	type ExampleTestSuite struct {
-//	    suite.Suite
-//	    VariableThatShouldStartAtFive int
-//	}
+//     // Make sure that VariableThatShouldStartAtFive is set to five
+//     // before each test
+//     func (suite *ExampleTestSuite) SetupTest() {
+//         suite.VariableThatShouldStartAtFive = 5
+//     }
 //
-//	// Make sure that VariableThatShouldStartAtFive is set to five
-//	// before each test
-//	func (suite *ExampleTestSuite) SetupTest() {
-//	    suite.VariableThatShouldStartAtFive = 5
-//	}
+//     // All methods that begin with "Test" are run as tests within a
+//     // suite.
+//     func (suite *ExampleTestSuite) TestExample() {
+//         assert.Equal(suite.T(), 5, suite.VariableThatShouldStartAtFive)
+//         suite.Equal(5, suite.VariableThatShouldStartAtFive)
+//     }
 //
-//	// All methods that begin with "Test" are run as tests within a
-//	// suite.
-//	func (suite *ExampleTestSuite) TestExample() {
-//	    assert.Equal(suite.T(), 5, suite.VariableThatShouldStartAtFive)
-//	    suite.Equal(5, suite.VariableThatShouldStartAtFive)
-//	}
-//
-//	// In order for 'go test' to run this suite, we need to create
-//	// a normal test function and pass our suite to suite.Run
-//	func TestExampleTestSuite(t *testing.T) {
-//	    suite.Run(t, new(ExampleTestSuite))
-//	}
-//
-// [issue 934]: https://github.com/stretchr/testify/issues/934
+//     // In order for 'go test' to run this suite, we need to create
+//     // a normal test function and pass our suite to suite.Run
+//     func TestExampleTestSuite(t *testing.T) {
+//         suite.Run(t, new(ExampleTestSuite))
+//     }
 package suite
--- a/suite/interfaces.go
+++ b/suite/interfaces.go
@ -7,7 +7,6 @@ import "testing"
 type TestingSuite interface {
 	T() *testing.T
 	SetT(*testing.T)
-	SetS(suite TestingSuite)
 }

 // SetupAllSuite has a SetupSuite method, which will run before the
@ -52,15 +51,3 @@ type AfterTest interface {
 type WithStats interface {
 	HandleStats(suiteName string, stats *SuiteInformation)
 }
-
-// SetupSubTest has a SetupSubTest method, which will run before each
-// subtest in the suite.
-type SetupSubTest interface {
-	SetupSubTest()
-}
-
-// TearDownSubTest has a TearDownSubTest method, which will run after
-// each subtest in the suite have been run.
-type TearDownSubTest interface {
-	TearDownSubTest()
-}
--- a/suite/suite.go
+++ b/suite/suite.go
@ -22,13 +22,9 @@ var matchMethod = flag.String("testify.m", "", "regular expression to select tes
 // retrieving the current *testing.T context.
 type Suite struct {
 	*assert.Assertions
-
 	mu      sync.RWMutex
 	require *require.Assertions
 	t       *testing.T
-
-	// Parent suite to have access to the implemented methods of parent struct
-	s TestingSuite
 }

 // T retrieves the current *testing.T context.
@ -47,18 +43,12 @@ func (suite *Suite) SetT(t *testing.T) {
 	suite.require = require.New(t)
 }

-// SetS needs to set the current test suite as parent
-// to get access to the parent methods
-func (suite *Suite) SetS(s TestingSuite) {
-	suite.s = s
-}
-
 // Require returns a require context for suite.
 func (suite *Suite) Require() *require.Assertions {
 	suite.mu.Lock()
 	defer suite.mu.Unlock()
 	if suite.require == nil {
-		panic("'Require' must not be called before 'Run' or 'SetT'")
+		suite.require = require.New(suite.T())
 	}
 	return suite.require
 }
@ -72,19 +62,13 @@ func (suite *Suite) Assert() *assert.Assertions {
 	suite.mu.Lock()
 	defer suite.mu.Unlock()
 	if suite.Assertions == nil {
-		panic("'Assert' must not be called before 'Run' or 'SetT'")
+		suite.Assertions = assert.New(suite.T())
 	}
 	return suite.Assertions
 }

-func recoverAndFailOnPanic(t *testing.T) {
-	t.Helper()
+func failOnPanic(t *testing.T) {
 	r := recover()
-	failOnPanic(t, r)
-}
-
-func failOnPanic(t *testing.T, r interface{}) {
-	t.Helper()
 	if r != nil {
 		t.Errorf("test panicked: %v\n%s", r, debug.Stack())
 		t.FailNow()
@ -97,21 +81,9 @@ func failOnPanic(t *testing.T, r interface{}) {
 // Provides compatibility with go test pkg -run TestSuite/TestName/SubTestName.
 func (suite *Suite) Run(name string, subtest func()) bool {
 	oldT := suite.T()
-
+	defer suite.SetT(oldT)
 	return oldT.Run(name, func(t *testing.T) {
 		suite.SetT(t)
-		defer suite.SetT(oldT)
-
-		defer recoverAndFailOnPanic(t)
-
-		if setupSubTest, ok := suite.s.(SetupSubTest); ok {
-			setupSubTest.SetupSubTest()
-		}
-
-		if tearDownSubTest, ok := suite.s.(TearDownSubTest); ok {
-			defer tearDownSubTest.TearDownSubTest()
-		}
-
 		subtest()
 	})
 }
@ -119,10 +91,9 @@ func (suite *Suite) Run(name string, subtest func()) bool {
 // Run takes a testing suite and runs all of the tests attached
 // to it.
 func Run(t *testing.T, suite TestingSuite) {
-	defer recoverAndFailOnPanic(t)
+	defer failOnPanic(t)

 	suite.SetT(t)
-	suite.SetS(suite)

 	var suiteSetupDone bool

@ -165,14 +136,10 @@ func Run(t *testing.T, suite TestingSuite) {
 			F: func(t *testing.T) {
 				parentT := suite.T()
 				suite.SetT(t)
-				defer recoverAndFailOnPanic(t)
+				defer failOnPanic(t)
 				defer func() {
-					t.Helper()
-
-					r := recover()
-
 					if stats != nil {
-						passed := !t.Failed() && r == nil
+						passed := !t.Failed()
 						stats.end(method.Name, passed)
 					}

@ -185,7 +152,6 @@ func Run(t *testing.T, suite TestingSuite) {
 					}

 					suite.SetT(parentT)
-					failOnPanic(t, r)
 				}()

 				if setupTestSuite, ok := suite.(SetupTestSuite); ok {
--- 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"
@ -21,20 +21,20 @@ import (
 type SuiteRequireTwice struct{ Suite }

 // TestSuiteRequireTwice checks for regressions of issue #149 where
-// suite.requirements was not initialized in suite.SetT()
+// suite.requirements was not initialised in suite.SetT()
 // A regression would result on these tests panicking rather than failing.
 func TestSuiteRequireTwice(t *testing.T) {
 	ok := testing.RunTests(
 		allTestsFilter,
 		[]testing.InternalTest{{
-			Name: t.Name() + "/SuiteRequireTwice",
+			Name: "TestSuiteRequireTwice",
 			F: func(t *testing.T) {
 				suite := new(SuiteRequireTwice)
 				Run(t, suite)
 			},
 		}},
 	)
-	assert.False(t, ok)
+	assert.Equal(t, false, ok)
 }

 func (s *SuiteRequireTwice) TestRequireOne() {
@ -104,31 +104,31 @@ func TestSuiteRecoverPanic(t *testing.T) {
 	ok := true
 	panickingTests := []testing.InternalTest{
 		{
-			Name: t.Name() + "/InSetupSuite",
+			Name: "TestPanicInSetupSuite",
 			F:    func(t *testing.T) { Run(t, &panickingSuite{panicInSetupSuite: true}) },
 		},
 		{
-			Name: t.Name() + "/InSetupTest",
+			Name: "TestPanicInSetupTest",
 			F:    func(t *testing.T) { Run(t, &panickingSuite{panicInSetupTest: true}) },
 		},
 		{
-			Name: t.Name() + "InBeforeTest",
+			Name: "TestPanicInBeforeTest",
 			F:    func(t *testing.T) { Run(t, &panickingSuite{panicInBeforeTest: true}) },
 		},
 		{
-			Name: t.Name() + "/InTest",
+			Name: "TestPanicInTest",
 			F:    func(t *testing.T) { Run(t, &panickingSuite{panicInTest: true}) },
 		},
 		{
-			Name: t.Name() + "/InAfterTest",
+			Name: "TestPanicInAfterTest",
 			F:    func(t *testing.T) { Run(t, &panickingSuite{panicInAfterTest: true}) },
 		},
 		{
-			Name: t.Name() + "/InTearDownTest",
+			Name: "TestPanicInTearDownTest",
 			F:    func(t *testing.T) { Run(t, &panickingSuite{panicInTearDownTest: true}) },
 		},
 		{
-			Name: t.Name() + "/InTearDownSuite",
+			Name: "TestPanicInTearDownSuite",
 			F:    func(t *testing.T) { Run(t, &panickingSuite{panicInTearDownSuite: true}) },
 		},
 	}
@ -151,19 +151,14 @@ type SuiteTester struct {
 	Suite

 	// Keep counts of how many times each method is run.
-	SetupSuiteRunCount      int
-	TearDownSuiteRunCount   int
-	SetupTestRunCount       int
-	TearDownTestRunCount    int
-	TestOneRunCount         int
-	TestTwoRunCount         int
-	TestSubtestRunCount     int
-	NonTestMethodRunCount   int
-	SetupSubTestRunCount    int
-	TearDownSubTestRunCount int
-
-	SetupSubTestNames    []string
-	TearDownSubTestNames []string
+	SetupSuiteRunCount    int
+	TearDownSuiteRunCount int
+	SetupTestRunCount     int
+	TearDownTestRunCount  int
+	TestOneRunCount       int
+	TestTwoRunCount       int
+	TestSubtestRunCount   int
+	NonTestMethodRunCount int

 	SuiteNameBefore []string
 	TestNameBefore  []string
@ -260,16 +255,6 @@ func (suite *SuiteTester) TestSubtest() {
 	}
 }

-func (suite *SuiteTester) TearDownSubTest() {
-	suite.TearDownSubTestNames = append(suite.TearDownSubTestNames, suite.T().Name())
-	suite.TearDownSubTestRunCount++
-}
-
-func (suite *SuiteTester) SetupSubTest() {
-	suite.SetupSubTestNames = append(suite.SetupSubTestNames, suite.T().Name())
-	suite.SetupSubTestRunCount++
-}
-
 type SuiteSkipTester struct {
 	// Include our basic suite logic.
 	Suite
@ -306,13 +291,13 @@ func TestRunSuite(t *testing.T) {

 	// The suite was only run once, so the SetupSuite and TearDownSuite
 	// methods should have each been run only once.
-	assert.Equal(t, 1, suiteTester.SetupSuiteRunCount)
-	assert.Equal(t, 1, suiteTester.TearDownSuiteRunCount)
+	assert.Equal(t, suiteTester.SetupSuiteRunCount, 1)
+	assert.Equal(t, suiteTester.TearDownSuiteRunCount, 1)

-	assert.Len(t, suiteTester.SuiteNameAfter, 4)
-	assert.Len(t, suiteTester.SuiteNameBefore, 4)
-	assert.Len(t, suiteTester.TestNameAfter, 4)
-	assert.Len(t, suiteTester.TestNameBefore, 4)
+	assert.Equal(t, len(suiteTester.SuiteNameAfter), 4)
+	assert.Equal(t, len(suiteTester.SuiteNameBefore), 4)
+	assert.Equal(t, len(suiteTester.TestNameAfter), 4)
+	assert.Equal(t, len(suiteTester.TestNameBefore), 4)

 	assert.Contains(t, suiteTester.TestNameAfter, "TestOne")
 	assert.Contains(t, suiteTester.TestNameAfter, "TestTwo")
@ -324,12 +309,6 @@ func TestRunSuite(t *testing.T) {
 	assert.Contains(t, suiteTester.TestNameBefore, "TestSkip")
 	assert.Contains(t, suiteTester.TestNameBefore, "TestSubtest")

-	assert.Contains(t, suiteTester.SetupSubTestNames, "TestRunSuite/TestSubtest/first")
-	assert.Contains(t, suiteTester.SetupSubTestNames, "TestRunSuite/TestSubtest/second")
-
-	assert.Contains(t, suiteTester.TearDownSubTestNames, "TestRunSuite/TestSubtest/first")
-	assert.Contains(t, suiteTester.TearDownSubTestNames, "TestRunSuite/TestSubtest/second")
-
 	for _, suiteName := range suiteTester.SuiteNameAfter {
 		assert.Equal(t, "SuiteTester", suiteName)
 	}
@ -349,20 +328,17 @@ func TestRunSuite(t *testing.T) {
 	// There are four test methods (TestOne, TestTwo, TestSkip, and TestSubtest), so
 	// the SetupTest and TearDownTest methods (which should be run once for
 	// each test) should have been run four times.
-	assert.Equal(t, 4, suiteTester.SetupTestRunCount)
-	assert.Equal(t, 4, suiteTester.TearDownTestRunCount)
+	assert.Equal(t, suiteTester.SetupTestRunCount, 4)
+	assert.Equal(t, suiteTester.TearDownTestRunCount, 4)

 	// Each test should have been run once.
-	assert.Equal(t, 1, suiteTester.TestOneRunCount)
-	assert.Equal(t, 1, suiteTester.TestTwoRunCount)
-	assert.Equal(t, 1, suiteTester.TestSubtestRunCount)
-
-	assert.Equal(t, 2, suiteTester.TearDownSubTestRunCount)
-	assert.Equal(t, 2, suiteTester.SetupSubTestRunCount)
+	assert.Equal(t, suiteTester.TestOneRunCount, 1)
+	assert.Equal(t, suiteTester.TestTwoRunCount, 1)
+	assert.Equal(t, suiteTester.TestSubtestRunCount, 1)

 	// Methods that don't match the test method identifier shouldn't
 	// have been run at all.
-	assert.Equal(t, 0, suiteTester.NonTestMethodRunCount)
+	assert.Equal(t, suiteTester.NonTestMethodRunCount, 0)

 	suiteSkipTester := new(SuiteSkipTester)
 	Run(t, suiteSkipTester)
@ -370,8 +346,8 @@ func TestRunSuite(t *testing.T) {
 	// The suite was only run once, so the SetupSuite and TearDownSuite
 	// methods should have each been run only once, even though SetupSuite
 	// called Skip()
-	assert.Equal(t, 1, suiteSkipTester.SetupSuiteRunCount)
-	assert.Equal(t, 1, suiteSkipTester.TearDownSuiteRunCount)
+	assert.Equal(t, suiteSkipTester.SetupSuiteRunCount, 1)
+	assert.Equal(t, suiteSkipTester.TearDownSuiteRunCount, 1)

 }

@ -440,7 +416,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
 	}
@ -451,7 +427,7 @@ func TestSuiteLogging(t *testing.T) {
 	suiteLoggingTester := new(SuiteLoggingTester)
 	capture := StdoutCapture{}
 	internalTest := testing.InternalTest{
-		Name: t.Name() + "/SuiteLoggingTester",
+		Name: "SomeTest",
 		F: func(subT *testing.T) {
 			Run(subT, suiteLoggingTester)
 		},
@ -492,7 +468,7 @@ func (s *CallOrderSuite) SetupSuite() {

 func (s *CallOrderSuite) TearDownSuite() {
 	s.call("TearDownSuite")
-	assert.Equal(s.T(), "SetupSuite;SetupTest;Test A;SetupSubTest;SubTest A1;TearDownSubTest;SetupSubTest;SubTest A2;TearDownSubTest;TearDownTest;SetupTest;Test B;SetupSubTest;SubTest B1;TearDownSubTest;SetupSubTest;SubTest B2;TearDownSubTest;TearDownTest;TearDownSuite", strings.Join(s.callOrder, ";"))
+	assert.Equal(s.T(), "SetupSuite;SetupTest;Test A;TearDownTest;SetupTest;Test B;TearDownTest;TearDownSuite", strings.Join(s.callOrder, ";"))
 }
 func (s *CallOrderSuite) SetupTest() {
 	s.call("SetupTest")
@ -502,32 +478,12 @@ func (s *CallOrderSuite) TearDownTest() {
 	s.call("TearDownTest")
 }

-func (s *CallOrderSuite) SetupSubTest() {
-	s.call("SetupSubTest")
-}
-
-func (s *CallOrderSuite) TearDownSubTest() {
-	s.call("TearDownSubTest")
-}
-
 func (s *CallOrderSuite) Test_A() {
 	s.call("Test A")
-	s.Run("SubTest A1", func() {
-		s.call("SubTest A1")
-	})
-	s.Run("SubTest A2", func() {
-		s.call("SubTest A2")
-	})
 }

 func (s *CallOrderSuite) Test_B() {
 	s.call("Test B")
-	s.Run("SubTest B1", func() {
-		s.call("SubTest B1")
-	})
-	s.Run("SubTest B2", func() {
-		s.call("SubTest B2")
-	})
 }

 type suiteWithStats struct {
@ -545,37 +501,19 @@ func (s *suiteWithStats) TestSomething() {
 	s.Equal(1, 1)
 }

-func (s *suiteWithStats) TestPanic() {
-	panic("oops")
-}
-
 func TestSuiteWithStats(t *testing.T) {
 	suiteWithStats := new(suiteWithStats)
-
-	suiteSuccess := testing.RunTests(allTestsFilter, []testing.InternalTest{
-		{
-			Name: t.Name() + "/suiteWithStats",
-			F: func(t *testing.T) {
-				Run(t, suiteWithStats)
-			},
-		},
-	})
-	require.False(t, suiteSuccess, "suiteWithStats should report test failure because of panic in TestPanic")
+	Run(t, suiteWithStats)

 	assert.True(t, suiteWithStats.wasCalled)
 	assert.NotZero(t, suiteWithStats.stats.Start)
 	assert.NotZero(t, suiteWithStats.stats.End)
-	assert.False(t, suiteWithStats.stats.Passed())
+	assert.True(t, suiteWithStats.stats.Passed())

-	testStats := suiteWithStats.stats.TestStats
-
-	assert.NotZero(t, testStats["TestSomething"].Start)
-	assert.NotZero(t, testStats["TestSomething"].End)
-	assert.True(t, testStats["TestSomething"].Passed)
-
-	assert.NotZero(t, testStats["TestPanic"].Start)
-	assert.NotZero(t, testStats["TestPanic"].End)
-	assert.False(t, testStats["TestPanic"].Passed)
+	testStats := suiteWithStats.stats.TestStats["TestSomething"]
+	assert.NotZero(t, testStats.Start)
+	assert.NotZero(t, testStats.End)
+	assert.True(t, testStats.Passed)
 }

 // FailfastSuite will test the behavior when running with the failfast flag
@ -597,51 +535,21 @@ func TestFailfastSuite(t *testing.T) {
 	ok := testing.RunTests(
 		allTestsFilter,
 		[]testing.InternalTest{{
-			Name: t.Name() + "/FailfastSuite",
+			Name: "TestFailfastSuite",
 			F: func(t *testing.T) {
 				Run(t, s)
 			},
 		}},
 	)
-	assert.False(t, ok)
-	var expect []string
+	assert.Equal(t, false, ok)
 	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")
@ -679,70 +587,3 @@ func (s *FailfastSuite) Test_B_Passes() {
 	s.call("Test B Passes")
 	s.Require().True(true)
 }
-
-type subtestPanicSuite struct {
-	Suite
-	inTearDownSuite   bool
-	inTearDownTest    bool
-	inTearDownSubTest bool
-}
-
-func (s *subtestPanicSuite) TearDownSuite() {
-	s.inTearDownSuite = true
-}
-
-func (s *subtestPanicSuite) TearDownTest() {
-	s.inTearDownTest = true
-}
-
-func (s *subtestPanicSuite) TearDownSubTest() {
-	s.inTearDownSubTest = true
-}
-
-func (s *subtestPanicSuite) TestSubtestPanic() {
-	ok := s.Run("subtest", func() {
-		panic("panic")
-	})
-	s.False(ok, "subtest failure is expected")
-}
-
-func TestSubtestPanic(t *testing.T) {
-	suite := new(subtestPanicSuite)
-	ok := testing.RunTests(
-		allTestsFilter,
-		[]testing.InternalTest{{
-			Name: t.Name() + "/subtestPanicSuite",
-			F: func(t *testing.T) {
-				Run(t, suite)
-			},
-		}},
-	)
-	assert.False(t, ok, "TestSubtestPanic/subtest should make the testsuite fail")
-	assert.True(t, suite.inTearDownSubTest)
-	assert.True(t, suite.inTearDownTest)
-	assert.True(t, suite.inTearDownSuite)
-}
-
-type unInitializedSuite struct {
-	Suite
-}
-
-// TestUnInitializedSuites asserts the behavior of the suite methods when the
-// suite is not initialized
-func TestUnInitializedSuites(t *testing.T) {
-	t.Run("should panic on Require", func(t *testing.T) {
-		suite := new(unInitializedSuite)
-
-		assert.Panics(t, func() {
-			suite.Require().True(true)
-		})
-	})
-
-	t.Run("should panic on Assert", func(t *testing.T) {
-		suite := new(unInitializedSuite)
-
-		assert.Panics(t, func() {
-			suite.Assert().True(true)
-		})
-	})
-}