Remove ineffective inline code blocks

Godoc does not have inline code blocks. Look to the standaed library for conventions for inline references to code.

Author: brackendawson

assert/assertion_format.go

@@ -1630,7 +1630,7 @@ func InEpsilonSlice(t TestingT, expected, actual interface{}, epsilon float64, m
 	Errors
 */
 
-// NoError asserts that a function returned no error (i.e. `nil`).
+// NoError asserts that a function returned a nil error (ie. no error).
 //
 //	  actualObj, err := SomeFunction()
 //	  if assert.NoError(t, err) {
@@ -1647,7 +1647,7 @@ func NoError(t TestingT, err error, msgAndArgs ...interface{}) bool {
 	return true
 }
 
-// Error asserts that a function returned an error (i.e. not `nil`).
+// Error asserts that a function returned a non-nil error (ie. an error).
 //
 //	actualObj, err := SomeFunction()
 //	assert.Error(t, err)
@@ -1662,7 +1662,7 @@ func Error(t TestingT, err error, msgAndArgs ...interface{}) bool {
 	return true
 }
 
-// EqualError asserts that a function returned an error (i.e. not `nil`)
+// EqualError asserts that a function returned a non-nil error (i.e. an error)
 // and that it is equal to the provided error.
 //
 //	actualObj, err := SomeFunction()
@@ -1685,8 +1685,8 @@ func EqualError(t TestingT, theError error, errString string, msgAndArgs ...inte
 	return true
 }
 
-// ErrorContains asserts that a function returned an error (i.e. not `nil`)
-// and that the error contains the specified substring.
+// ErrorContains asserts that a function returned a non-nil error (i.e. an
+// error) and that the error contains the specified substring.
 //
 //	actualObj, err := SomeFunction()
 //	assert.ErrorContains(t, err,  expectedErrorSubString)

assert/assertion_forward.go

@@ -40,8 +40,8 @@
 //
 // # 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
+// 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
 // testing framework. This allows the assertion funcs to write the failings and other details to
 // the correct place.
 //

assert/assertions.go

@@ -712,8 +712,8 @@ func (m *Mock) AssertNotCalled(t TestingT, methodName string, arguments ...inter
 	return true
 }
 
-// IsMethodCallable checking that the method can be called
-// If the method was called more than `Repeatability` return false
+// IsMethodCallable returns true if given methodName and arguments have an
+// unsatisfied expected call registered in the Mock.
 func (m *Mock) IsMethodCallable(t TestingT, methodName string, arguments ...interface{}) bool {
 	if h, ok := t.(tHelper); ok {
 		h.Helper()

assert/doc.go

@@ -1,4 +1,4 @@
-// Package require implements the same assertions as the `assert` package but
+// Package require implements the same assertions as the assert package but
 // stops test execution when a test fails.
 //
 // # Example Usage
@@ -21,8 +21,8 @@
 //
 // # Assertions
 //
-// The `require` package have same global functions as in the `assert` package,
-// but instead of returning a boolean result they call `t.FailNow()`.
+// 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.
 //

mock/mock.go

@@ -63,11 +63,15 @@ func (suite *Suite) Require() *require.Assertions {
 	return suite.require
 }
 
-// Assert returns an assert context for suite.  Normally, you can call
-// `suite.NoError(expected, actual)`, but for situations where the embedded
-// methods are overridden (for example, you might want to override
-// assert.Assertions with require.Assertions), this method is provided so you
-// can call `suite.Assert().NoError()`.
+// Assert returns an assert context for suite. Normally, you can call:
+//
+//	suite.NoError(err)
+//
+// But for situations where the embedded methods are overridden (for example,
+// you might want to override assert.Assertions with require.Assertions), this
+// method is provided so you can call:
+//
+//	suite.Assert().NoError(err)
 func (suite *Suite) Assert() *assert.Assertions {
 	suite.mu.Lock()
 	defer suite.mu.Unlock()