diff --git a/README.md b/README.md
index 247134d..5da4083 100644
--- a/README.md
+++ b/README.md
@@ -105,6 +105,17 @@ mc := minimock.NewController(t)
 readCloserMock := NewReadCloserMock(mc).ReadMock.Expect([]byte(1,2,3)).Return(3, nil).CloseMock.Return(nil)
 ```
 
+But what if we don't want to check all arguments of the read method?
+Let's say we just want to check that the second element of the given slice "p" is 2.
+This is where "Inspect" helper comes into play:
+```go
+mc := minimock.NewController(t)
+readCloserMock := NewReadCloserMock(mc).ReadMock.Inspect(func(p []byte){
+  assert.Equal(mc, 2, p[1])
+}).Return(3, nil).CloseMock.Return(nil)
+
+```
+
 ### Setting up a mock using When/Then helpers:
 ```go
 mc := minimock.NewController(t)
diff --git a/template.go b/template.go
index 9ee806b..e784a3f 100644
--- a/template.go
+++ b/template.go
@@ -30,6 +30,7 @@ const (
 			t minimock.Tester
 			{{ range $method := $.Interface.Methods }}
 				func{{$method.Name}} func{{ $method.Signature }}
+				inspectFunc{{$method.Name}} func({{ $method.Params}})
 				after{{$method.Name}}Counter uint64
 				before{{$method.Name}}Counter uint64
 				{{$method.Name}}Mock m{{$mock}}{{$method.Name}}
@@ -101,6 +102,17 @@ const (
 				return {{$m}}
 			}
 
+			// Inspect accepts an inspector function that has same arguments as the {{$.Interface.Name}}.{{$method.Name}}
+			func ({{$m}} *m{{$mock}}{{$method.Name}}) Inspect(f func({{$method.Params}})) *m{{$mock}}{{$method.Name}} {
+				if {{$m}}.mock.inspectFunc{{$method.Name}} != nil {
+					{{$m}}.mock.t.Fatalf("Inspect function is already set for {{$mock}}.{{$method.Name}}")
+				}
+
+				{{$m}}.mock.inspectFunc{{$method.Name}} = f
+
+				return {{$m}}
+			}
+
 			// Return sets up results that will be returned by {{$.Interface.Name}}.{{$method.Name}}
 			func ({{$m}} *m{{$mock}}{{$method.Name}}) Return({{$method.Results}}) *{{$mock}} {
 				if {{$m}}.mock.func{{$method.Name}} != nil {
@@ -156,12 +168,16 @@ const (
 				mm_atomic.AddUint64(&{{$m}}.before{{$method.Name}}Counter, 1)
 				defer mm_atomic.AddUint64(&{{$m}}.after{{$method.Name}}Counter, 1)
 
+				if {{$m}}.inspectFunc{{$method.Name}} != nil {
+					{{$m}}.inspectFunc{{$method.Name}}({{$method.Params.Pass}})
+				}
+
 				{{if $method.HasParams}}
 					params := &{{$mock}}{{$method.Name}}Params{ {{$method.ParamsNames}} }
 
 					// Record call args
 					{{$m}}.{{$method.Name}}Mock.mutex.Lock()
-				{{$m}}	.{{$method.Name}}Mock.callArgs = append({{$m}}.{{$method.Name}}Mock.callArgs, params)
+					{{$m}}.{{$method.Name}}Mock.callArgs = append({{$m}}.{{$method.Name}}Mock.callArgs, params)
 					{{$m}}.{{$method.Name}}Mock.mutex.Unlock()
 
 					for _, e := range {{$m}}.{{$method.Name}}Mock.expectations {
diff --git a/tests/formatter_mock.go b/tests/formatter_mock.go
index 989e7df..010e961 100644
--- a/tests/formatter_mock.go
+++ b/tests/formatter_mock.go
@@ -17,6 +17,7 @@ type FormatterMock struct {
 	t minimock.Tester
 
 	funcFormat          func(s1 string, p1 ...interface{}) (s2 string)
+	inspectFuncFormat   func(s1 string, p1 ...interface{})
 	afterFormatCounter  uint64
 	beforeFormatCounter uint64
 	FormatMock          mFormatterMockFormat
@@ -83,6 +84,17 @@ func (mmFormat *mFormatterMockFormat) Expect(s1 string, p1 ...interface{}) *mFor
 	return mmFormat
 }
 
+// Inspect accepts an inspector function that has same arguments as the Formatter.Format
+func (mmFormat *mFormatterMockFormat) Inspect(f func(s1 string, p1 ...interface{})) *mFormatterMockFormat {
+	if mmFormat.mock.inspectFuncFormat != nil {
+		mmFormat.mock.t.Fatalf("Inspect function is already set for FormatterMock.Format")
+	}
+
+	mmFormat.mock.inspectFuncFormat = f
+
+	return mmFormat
+}
+
 // Return sets up results that will be returned by Formatter.Format
 func (mmFormat *mFormatterMockFormat) Return(s2 string) *FormatterMock {
 	if mmFormat.mock.funcFormat != nil {
@@ -136,6 +148,10 @@ func (mmFormat *FormatterMock) Format(s1 string, p1 ...interface{}) (s2 string)
 	mm_atomic.AddUint64(&mmFormat.beforeFormatCounter, 1)
 	defer mm_atomic.AddUint64(&mmFormat.afterFormatCounter, 1)
 
+	if mmFormat.inspectFuncFormat != nil {
+		mmFormat.inspectFuncFormat(s1, p1...)
+	}
+
 	params := &FormatterMockFormatParams{s1, p1}
 
 	// Record call args
diff --git a/tests/tester_mock_test.go b/tests/tester_mock_test.go
index 101e479..63775e2 100644
--- a/tests/tester_mock_test.go
+++ b/tests/tester_mock_test.go
@@ -17,26 +17,31 @@ type TesterMock struct {
 	t minimock.Tester
 
 	funcError          func(p1 ...interface{})
+	inspectFuncError   func(p1 ...interface{})
 	afterErrorCounter  uint64
 	beforeErrorCounter uint64
 	ErrorMock          mTesterMockError
 
 	funcErrorf          func(format string, args ...interface{})
+	inspectFuncErrorf   func(format string, args ...interface{})
 	afterErrorfCounter  uint64
 	beforeErrorfCounter uint64
 	ErrorfMock          mTesterMockErrorf
 
 	funcFailNow          func()
+	inspectFuncFailNow   func()
 	afterFailNowCounter  uint64
 	beforeFailNowCounter uint64
 	FailNowMock          mTesterMockFailNow
 
 	funcFatal          func(args ...interface{})
+	inspectFuncFatal   func(args ...interface{})
 	afterFatalCounter  uint64
 	beforeFatalCounter uint64
 	FatalMock          mTesterMockFatal
 
 	funcFatalf          func(format string, args ...interface{})
+	inspectFuncFatalf   func(format string, args ...interface{})
 	afterFatalfCounter  uint64
 	beforeFatalfCounter uint64
 	FatalfMock          mTesterMockFatalf
@@ -108,6 +113,17 @@ func (mmError *mTesterMockError) Expect(p1 ...interface{}) *mTesterMockError {
 	return mmError
 }
 
+// Inspect accepts an inspector function that has same arguments as the Tester.Error
+func (mmError *mTesterMockError) Inspect(f func(p1 ...interface{})) *mTesterMockError {
+	if mmError.mock.inspectFuncError != nil {
+		mmError.mock.t.Fatalf("Inspect function is already set for TesterMock.Error")
+	}
+
+	mmError.mock.inspectFuncError = f
+
+	return mmError
+}
+
 // Return sets up results that will be returned by Tester.Error
 func (mmError *mTesterMockError) Return() *TesterMock {
 	if mmError.mock.funcError != nil {
@@ -140,6 +156,10 @@ func (mmError *TesterMock) Error(p1 ...interface{}) {
 	mm_atomic.AddUint64(&mmError.beforeErrorCounter, 1)
 	defer mm_atomic.AddUint64(&mmError.afterErrorCounter, 1)
 
+	if mmError.inspectFuncError != nil {
+		mmError.inspectFuncError(p1...)
+	}
+
 	params := &TesterMockErrorParams{p1}
 
 	// Record call args
@@ -281,6 +301,17 @@ func (mmErrorf *mTesterMockErrorf) Expect(format string, args ...interface{}) *m
 	return mmErrorf
 }
 
+// Inspect accepts an inspector function that has same arguments as the Tester.Errorf
+func (mmErrorf *mTesterMockErrorf) Inspect(f func(format string, args ...interface{})) *mTesterMockErrorf {
+	if mmErrorf.mock.inspectFuncErrorf != nil {
+		mmErrorf.mock.t.Fatalf("Inspect function is already set for TesterMock.Errorf")
+	}
+
+	mmErrorf.mock.inspectFuncErrorf = f
+
+	return mmErrorf
+}
+
 // Return sets up results that will be returned by Tester.Errorf
 func (mmErrorf *mTesterMockErrorf) Return() *TesterMock {
 	if mmErrorf.mock.funcErrorf != nil {
@@ -313,6 +344,10 @@ func (mmErrorf *TesterMock) Errorf(format string, args ...interface{}) {
 	mm_atomic.AddUint64(&mmErrorf.beforeErrorfCounter, 1)
 	defer mm_atomic.AddUint64(&mmErrorf.afterErrorfCounter, 1)
 
+	if mmErrorf.inspectFuncErrorf != nil {
+		mmErrorf.inspectFuncErrorf(format, args...)
+	}
+
 	params := &TesterMockErrorfParams{format, args}
 
 	// Record call args
@@ -437,6 +472,17 @@ func (mmFailNow *mTesterMockFailNow) Expect() *mTesterMockFailNow {
 	return mmFailNow
 }
 
+// Inspect accepts an inspector function that has same arguments as the Tester.FailNow
+func (mmFailNow *mTesterMockFailNow) Inspect(f func()) *mTesterMockFailNow {
+	if mmFailNow.mock.inspectFuncFailNow != nil {
+		mmFailNow.mock.t.Fatalf("Inspect function is already set for TesterMock.FailNow")
+	}
+
+	mmFailNow.mock.inspectFuncFailNow = f
+
+	return mmFailNow
+}
+
 // Return sets up results that will be returned by Tester.FailNow
 func (mmFailNow *mTesterMockFailNow) Return() *TesterMock {
 	if mmFailNow.mock.funcFailNow != nil {
@@ -469,6 +515,10 @@ func (mmFailNow *TesterMock) FailNow() {
 	mm_atomic.AddUint64(&mmFailNow.beforeFailNowCounter, 1)
 	defer mm_atomic.AddUint64(&mmFailNow.afterFailNowCounter, 1)
 
+	if mmFailNow.inspectFuncFailNow != nil {
+		mmFailNow.inspectFuncFailNow()
+	}
+
 	if mmFailNow.FailNowMock.defaultExpectation != nil {
 		mm_atomic.AddUint64(&mmFailNow.FailNowMock.defaultExpectation.Counter, 1)
 
@@ -573,6 +623,17 @@ func (mmFatal *mTesterMockFatal) Expect(args ...interface{}) *mTesterMockFatal {
 	return mmFatal
 }
 
+// Inspect accepts an inspector function that has same arguments as the Tester.Fatal
+func (mmFatal *mTesterMockFatal) Inspect(f func(args ...interface{})) *mTesterMockFatal {
+	if mmFatal.mock.inspectFuncFatal != nil {
+		mmFatal.mock.t.Fatalf("Inspect function is already set for TesterMock.Fatal")
+	}
+
+	mmFatal.mock.inspectFuncFatal = f
+
+	return mmFatal
+}
+
 // Return sets up results that will be returned by Tester.Fatal
 func (mmFatal *mTesterMockFatal) Return() *TesterMock {
 	if mmFatal.mock.funcFatal != nil {
@@ -605,6 +666,10 @@ func (mmFatal *TesterMock) Fatal(args ...interface{}) {
 	mm_atomic.AddUint64(&mmFatal.beforeFatalCounter, 1)
 	defer mm_atomic.AddUint64(&mmFatal.afterFatalCounter, 1)
 
+	if mmFatal.inspectFuncFatal != nil {
+		mmFatal.inspectFuncFatal(args...)
+	}
+
 	params := &TesterMockFatalParams{args}
 
 	// Record call args
@@ -746,6 +811,17 @@ func (mmFatalf *mTesterMockFatalf) Expect(format string, args ...interface{}) *m
 	return mmFatalf
 }
 
+// Inspect accepts an inspector function that has same arguments as the Tester.Fatalf
+func (mmFatalf *mTesterMockFatalf) Inspect(f func(format string, args ...interface{})) *mTesterMockFatalf {
+	if mmFatalf.mock.inspectFuncFatalf != nil {
+		mmFatalf.mock.t.Fatalf("Inspect function is already set for TesterMock.Fatalf")
+	}
+
+	mmFatalf.mock.inspectFuncFatalf = f
+
+	return mmFatalf
+}
+
 // Return sets up results that will be returned by Tester.Fatalf
 func (mmFatalf *mTesterMockFatalf) Return() *TesterMock {
 	if mmFatalf.mock.funcFatalf != nil {
@@ -778,6 +854,10 @@ func (mmFatalf *TesterMock) Fatalf(format string, args ...interface{}) {
 	mm_atomic.AddUint64(&mmFatalf.beforeFatalfCounter, 1)
 	defer mm_atomic.AddUint64(&mmFatalf.afterFatalfCounter, 1)
 
+	if mmFatalf.inspectFuncFatalf != nil {
+		mmFatalf.inspectFuncFatalf(format, args...)
+	}
+
 	params := &TesterMockFatalfParams{format, args}
 
 	// Record call args