docs: Format examples in README

README.md

@@ -38,30 +38,27 @@ See it in action:
 package yours
 
 import (
-  "testing"
+	"testing"
-  "github.com/stretchr/testify/assert"
+
+	"github.com/stretchr/testify/assert"
 )
 
 func TestSomething(t *testing.T) {
+	// assert equality
+	assert.Equal(t, 123, 123, "they should be equal")
 
-  // assert equality
+	// assert inequality
-  assert.Equal(t, 123, 123, "they should be equal")
+	assert.NotEqual(t, 123, 456, "they should not be equal")
 
-  // assert inequality
+	// assert for nil (good for errors)
-  assert.NotEqual(t, 123, 456, "they should not be equal")
+	assert.Nil(t, object)
-
-  // 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)
+	}
 }
 ```
 
@@ -74,29 +71,29 @@ if you assert many times, use the below:
 package yours
 
 import (
-  "testing"
+	"testing"
-  "github.com/stretchr/testify/assert"
+
+	"github.com/stretchr/testify/assert"
 )
 
 func TestSomething(t *testing.T) {
-  assert := assert.New(t)
+	assert := assert.New(t)
 
-  // assert equality
+	// assert equality
-  assert.Equal(123, 123, "they should be equal")
+	assert.Equal(123, 123, "they should be equal")
 
-  // assert inequality
+	// assert inequality
-  assert.NotEqual(123, 456, "they should not be equal")
+	assert.NotEqual(123, 456, "they should not be equal")
 
-  // assert for nil (good for errors)
+	// assert for nil (good for errors)
-  assert.Nil(object)
+	assert.Nil(object)
 
-  // assert for not nil (good when you expect something)
+	// assert for not nil (good when you expect something)
-  if assert.NotNil(object) {
+	if assert.NotNil(object) {
-
+		// now we know that object isn't nil, we are safe to make
-    // now we know that object isn't nil, we are safe to make
+		// further assertions without causing any errors
-    // further assertions without causing any errors
+		assert.Equal("Something", object.Value)
-    assert.Equal("Something", object.Value)
+	}
-  }
 }
 ```
 
@@ -120,8 +117,9 @@ An example test function that tests a piece of code that relies on an external o
 package yours
 
 import (
-  "testing"
+	"testing"
-  "github.com/stretchr/testify/mock"
+
+	"github.com/stretchr/testify/mock"
 )
 
 /*
@@ -130,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{
+type MyMockedObject struct {
-  mock.Mock
+	mock.Mock
 }
 
 // DoSomething is a method on MyMockedObject that implements some interface
@@ -142,10 +140,8 @@ 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)
-  args := m.Called(number)
+	return args.Bool(0), args.Error(1)
-  return args.Bool(0), args.Error(1)
-
 }
 
 /*
@@ -155,20 +151,17 @@ 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)
 
-  // create an instance of our test object
+	// set up expectations
-  testObj := new(MyMockedObject)
+	testObj.On("DoSomething", 123).Return(true, nil)
-
-  // set up 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
@@ -177,45 +170,42 @@ 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)
 
-  // create an instance of our test object
+	// set up expectations with a placeholder in the argument list
-  testObj := new(MyMockedObject)
+	testObj.On("DoSomething", mock.Anything).Return(true, nil)
 
-  // set up expectations with a placeholder in the argument list
+	// call the code we are testing
-  testObj.On("DoSomething", mock.Anything).Return(true, nil)
+	targetFuncThatDoesSomethingWithObj(testObj)
-
-  // call the code we are testing
-  targetFuncThatDoesSomethingWithObj(testObj)
-
-  // assert that the expectations were met
-  testObj.AssertExpectations(t)
 
+	// assert that the expectations were met
+	testObj.AssertExpectations(t)
 
 }
 
 // TestSomethingElse2 is a third example that shows how you can use
 // the Unset method to cleanup handlers and then add new ones.
 func TestSomethingElse2(t *testing.T) {
+	// create an instance of our test object
+	testObj := new(MyMockedObject)
 
-  // create an instance of our test object
+	// set up expectations with a placeholder in the argument list
-  testObj := new(MyMockedObject)
+	mockCall := testObj.On("DoSomething", mock.Anything).Return(true, nil)
 
-  // set up expectations with a placeholder in the argument list
+	// call the code we are testing
-  mockCall := testObj.On("DoSomething", mock.Anything).Return(true, nil)
+	targetFuncThatDoesSomethingWithObj(testObj)
 
-  // call the code we are testing
+	// assert that the expectations were met
-  targetFuncThatDoesSomethingWithObj(testObj)
+	testObj.AssertExpectations(t)
 
-  // assert that the expectations were met
+	// remove the handler now so we can add another one that takes precedence
-  testObj.AssertExpectations(t)
+	mockCall.Unset()
 
-  // remove the handler now so we can add another one that takes precedence
+	// return false now instead of true
-  mockCall.Unset()
+	testObj.On("DoSomething", mock.Anything).Return(false, nil)
 
-  // return false now instead of true
+	testObj.AssertExpectations(t)
-  testObj.On("DoSomething", mock.Anything).Return(false, nil)
-
-  testObj.AssertExpectations(t)
 }
 ```
 
@@ -235,35 +225,36 @@ An example suite is shown below:
 ```go
 // Basic imports
 import (
-    "testing"
+	"testing"
-    "github.com/stretchr/testify/assert"
+
-    "github.com/stretchr/testify/suite"
+	"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
+	suite.Suite
-    VariableThatShouldStartAtFive int
+	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))
 }
 ```
 
@@ -276,33 +267,34 @@ For more information on writing suites, check out the [API documentation for the
 ```go
 // Basic imports
 import (
-    "testing"
+	"testing"
-    "github.com/stretchr/testify/suite"
+
+	"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
+	suite.Suite
-    VariableThatShouldStartAtFive int
+	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))
 }
 ```
 
@@ -329,14 +321,13 @@ Import the `testify/assert` package into your code using this template:
 package yours
 
 import (
-  "testing"
+	"testing"
-  "github.com/stretchr/testify/assert"
+
+	"github.com/stretchr/testify/assert"
 )
 
 func TestSomething(t *testing.T) {
-
+	assert.True(t, true, "True is true!")
-  assert.True(t, true, "True is true!")
-
 }
 ```