add csi-test to vendor

vendor/github.com/golang/mock/mockgen/tests/aux_imports_embedded_interface/README.md

@@ -0,0 +1,36 @@
+Embedded interfaces in `aux_files` generate `unknown embedded interface XXX` errors.
+See below for example of the problem:
+```
+// source
+import (
+    alias "some.org/package/imported"
+)
+
+type Source interface {
+    alias.Foreign
+}
+```
+
+```
+// some.org/package/imported
+type Foreign interface {
+    Embedded
+}
+
+type Embedded interface {}
+```
+
+Attempting to generate a mock will result in an `unknown embedded interface Embedded`.
+The issue is that the `fileParser` stores `auxInterfaces` underneath the package name
+explicitly specified in the `aux_files` flag.
+
+In the `parseInterface` method, there is an incorrect assumption about an embedded interface
+always being in the source file.
+```
+case *ast.Ident:
+        // Embedded interface in this package.
+        ei := p.auxInterfaces[""][v.String()]
+        if ei == nil {
+                return nil, p.errorf(v.Pos(), "unknown embedded interface %s", v.String())
+        }
+```

vendor/github.com/golang/mock/mockgen/tests/aux_imports_embedded_interface/bugreport.go

@@ -0,0 +1,18 @@
+//go:generate mockgen -aux_files faux=faux/faux.go -destination bugreport_mock.go -package bugreport -source=bugreport.go Example
+
+package bugreport
+
+import (
+	"log"
+
+	"github.com/golang/mock/mockgen/tests/aux_imports_embedded_interface/faux"
+)
+
+// Source is an interface w/ an embedded foreign interface
+type Source interface {
+	faux.Foreign
+}
+
+func CallForeignMethod(s Source) {
+	log.Println(s.Method())
+}

vendor/github.com/golang/mock/mockgen/tests/aux_imports_embedded_interface/bugreport_mock.go

@@ -0,0 +1,46 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: bugreport.go
+
+// Package bugreport is a generated GoMock package.
+package bugreport
+
+import (
+	gomock "github.com/golang/mock/gomock"
+	faux "github.com/golang/mock/mockgen/tests/aux_imports_embedded_interface/faux"
+	reflect "reflect"
+)
+
+// MockSource is a mock of Source interface
+type MockSource struct {
+	ctrl     *gomock.Controller
+	recorder *MockSourceMockRecorder
+}
+
+// MockSourceMockRecorder is the mock recorder for MockSource
+type MockSourceMockRecorder struct {
+	mock *MockSource
+}
+
+// NewMockSource creates a new mock instance
+func NewMockSource(ctrl *gomock.Controller) *MockSource {
+	mock := &MockSource{ctrl: ctrl}
+	mock.recorder = &MockSourceMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use
+func (m *MockSource) EXPECT() *MockSourceMockRecorder {
+	return m.recorder
+}
+
+// Method mocks base method
+func (m *MockSource) Method() faux.Return {
+	ret := m.ctrl.Call(m, "Method")
+	ret0, _ := ret[0].(faux.Return)
+	return ret0
+}
+
+// Method indicates an expected call of Method
+func (mr *MockSourceMockRecorder) Method() *gomock.Call {
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Method", reflect.TypeOf((*MockSource)(nil).Method))
+}

vendor/github.com/golang/mock/mockgen/tests/aux_imports_embedded_interface/bugreport_test.go

@@ -0,0 +1,18 @@
+package bugreport
+
+import (
+	"testing"
+
+	"github.com/golang/mock/gomock"
+)
+
+// TestValidInterface assesses whether or not the generated mock is valid
+func TestValidInterface(t *testing.T) {
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+
+	s := NewMockSource(ctrl)
+	s.EXPECT().Method().Return("")
+
+	CallForeignMethod(s)
+}

vendor/github.com/golang/mock/mockgen/tests/aux_imports_embedded_interface/faux/faux.go

@@ -0,0 +1,10 @@
+package faux
+
+type Foreign interface {
+	Method() Return
+	Embedded
+}
+
+type Embedded interface{}
+
+type Return interface{}

vendor/github.com/golang/mock/mockgen/tests/custom_package_name/README.md

@@ -0,0 +1,22 @@
+# Tests for custom package names
+
+This directory contains test for mockgen generating mocks when imported package
+name does not match import path suffix. For example, package with name "client"
+is located under import path "github.com/golang/mock/mockgen/tests/custom_package_name/client/v1".
+
+Prior to this patch:
+
+    $ go generate greeter/greeter.go
+    2018/03/05 22:44:52 Loading input failed: greeter.go:17:11: failed parsing returns: greeter.go:17:14: unknown package "client"
+    greeter/greeter.go:1: running "mockgen": exit status 1
+
+This can be fixed by manually providing `-imports` flag, like `-imports client=github.com/golang/mock/mockgen/tests/custom_package_name/client/v1`.
+But, mockgen should be able to automatically resolve package names in such situations.
+
+With this patch applied:
+
+    $ go generate greeter/greeter.go
+    $ echo $?
+    0
+
+Mockgen runs successfully, produced output is equal to [greeter_mock_test.go](greeter/greeter_mock_test.go) content.

vendor/github.com/golang/mock/mockgen/tests/custom_package_name/client/v1/client.go

@@ -0,0 +1,13 @@
+package client
+
+import "fmt"
+
+type Client struct{}
+
+func (c *Client) Greet(in GreetInput) string {
+	return fmt.Sprintf("Hello, %s!", in.Name)
+}
+
+type GreetInput struct {
+	Name string
+}

vendor/github.com/golang/mock/mockgen/tests/custom_package_name/greeter/greeter.go

@@ -0,0 +1,31 @@
+//go:generate mockgen -source greeter.go -destination greeter_mock_test.go -package greeter
+
+package greeter
+
+import (
+	// stdlib import
+	"fmt"
+
+	// non-matching import suffix and package name
+	"github.com/golang/mock/mockgen/tests/custom_package_name/client/v1"
+
+	//  matching import suffix and package name
+	"github.com/golang/mock/mockgen/tests/custom_package_name/validator"
+)
+
+type InputMaker interface {
+	MakeInput() client.GreetInput
+}
+
+type Greeter struct {
+	InputMaker InputMaker
+	Client     *client.Client
+}
+
+func (g *Greeter) Greet() (string, error) {
+	in := g.InputMaker.MakeInput()
+	if err := validator.Validate(in.Name); err != nil {
+		return "", fmt.Errorf("validation failed: %v", err)
+	}
+	return g.Client.Greet(in), nil
+}

vendor/github.com/golang/mock/mockgen/tests/custom_package_name/greeter/greeter_mock_test.go

@@ -0,0 +1,46 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: greeter.go
+
+// Package greeter is a generated GoMock package.
+package greeter
+
+import (
+	gomock "github.com/golang/mock/gomock"
+	v1 "github.com/golang/mock/mockgen/tests/custom_package_name/client/v1"
+	reflect "reflect"
+)
+
+// MockInputMaker is a mock of InputMaker interface
+type MockInputMaker struct {
+	ctrl     *gomock.Controller
+	recorder *MockInputMakerMockRecorder
+}
+
+// MockInputMakerMockRecorder is the mock recorder for MockInputMaker
+type MockInputMakerMockRecorder struct {
+	mock *MockInputMaker
+}
+
+// NewMockInputMaker creates a new mock instance
+func NewMockInputMaker(ctrl *gomock.Controller) *MockInputMaker {
+	mock := &MockInputMaker{ctrl: ctrl}
+	mock.recorder = &MockInputMakerMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use
+func (m *MockInputMaker) EXPECT() *MockInputMakerMockRecorder {
+	return m.recorder
+}
+
+// MakeInput mocks base method
+func (m *MockInputMaker) MakeInput() v1.GreetInput {
+	ret := m.ctrl.Call(m, "MakeInput")
+	ret0, _ := ret[0].(v1.GreetInput)
+	return ret0
+}
+
+// MakeInput indicates an expected call of MakeInput
+func (mr *MockInputMakerMockRecorder) MakeInput() *gomock.Call {
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MakeInput", reflect.TypeOf((*MockInputMaker)(nil).MakeInput))
+}

vendor/github.com/golang/mock/mockgen/tests/custom_package_name/greeter/greeter_test.go

@@ -0,0 +1,37 @@
+package greeter
+
+import (
+	"testing"
+
+	"github.com/golang/mock/gomock"
+	"github.com/golang/mock/mockgen/tests/custom_package_name/client/v1"
+)
+
+func TestGreeter_Greet(t *testing.T) {
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+
+	input := client.GreetInput{
+		Name: "Foo",
+	}
+
+	inputMaker := NewMockInputMaker(ctrl)
+	inputMaker.EXPECT().
+		MakeInput().
+		Return(input)
+
+	g := &Greeter{
+		InputMaker: inputMaker,
+		Client:     &client.Client{},
+	}
+
+	greeting, err := g.Greet()
+	if err != nil {
+		t.Fatalf("Unexpected error: %v", err)
+	}
+
+	expected := "Hello, Foo!"
+	if greeting != expected {
+		t.Fatalf("Expected greeting to be %v but got %v", expected, greeting)
+	}
+}

vendor/github.com/golang/mock/mockgen/tests/custom_package_name/validator/validate.go

@@ -0,0 +1,5 @@
+package validator
+
+func Validate(s string) error {
+	return nil
+}

vendor/github.com/golang/mock/mockgen/tests/empty_interface/input.go

@@ -0,0 +1,4 @@
+//go:generate mockgen -package empty_interface -destination mock.go -source input.go
+package empty_interface
+
+type Empty interface{}

vendor/github.com/golang/mock/mockgen/tests/empty_interface/mock.go

@@ -0,0 +1,32 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: input.go
+
+// Package empty_interface is a generated GoMock package.
+package empty_interface
+
+import (
+	gomock "github.com/golang/mock/gomock"
+)
+
+// MockEmpty is a mock of Empty interface
+type MockEmpty struct {
+	ctrl     *gomock.Controller
+	recorder *MockEmptyMockRecorder
+}
+
+// MockEmptyMockRecorder is the mock recorder for MockEmpty
+type MockEmptyMockRecorder struct {
+	mock *MockEmpty
+}
+
+// NewMockEmpty creates a new mock instance
+func NewMockEmpty(ctrl *gomock.Controller) *MockEmpty {
+	mock := &MockEmpty{ctrl: ctrl}
+	mock.recorder = &MockEmptyMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use
+func (m *MockEmpty) EXPECT() *MockEmptyMockRecorder {
+	return m.recorder
+}

vendor/github.com/golang/mock/mockgen/tests/generated_identifier_conflict/README.md

@@ -0,0 +1,26 @@
+The generated mock methods use some hardcoded variable/receiver names that can
+have conflicts with the argument names that are defined by the code for which
+the mock is generated when using the source generation method.
+
+Example:
+
+```go
+type Example interface {
+	Method(_m, _mr, m, mr int)
+}
+```
+
+```go
+// Method mocks base method
+func (_m *MockExample) Method(_m int, _mr int, m int, mr int) {
+	_m.ctrl.Call(_m, "Method", _m, _mr, m, mr)
+}
+```
+
+In the above example one of the interface method parameters is called `_m`
+but unfortunately the generated receiver name is also called `_m` so the
+mock code won't compile.
+
+The generator has to make sure that generated identifiers (e.g.: the receiver
+names) are always different from the arg names that might come from external
+sources.

vendor/github.com/golang/mock/mockgen/tests/generated_identifier_conflict/bugreport.go

@@ -0,0 +1,16 @@
+//go:generate mockgen -destination bugreport_mock.go -package bugreport -source=bugreport.go
+
+package bugreport
+
+type Example interface {
+	// _m and _mr were used by the buggy code: the '_' prefix was there hoping
+	// that no one will use method argument names starting with '_' reducing
+	// the chance of collision with generated identifiers.
+	// m and mr are used by the bugfixed new code, the '_' prefix has been
+	// removed because the new code generator changes the names of the
+	// generated identifiers in case they would collide with identifiers
+	// coming from argument names.
+	Method(_m, _mr, m, mr int)
+
+	VarargMethod(_s, _x, a, ret int, varargs ...int)
+}

vendor/github.com/golang/mock/mockgen/tests/generated_identifier_conflict/bugreport_mock.go

@@ -0,0 +1,58 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: bugreport.go
+
+// Package bugreport is a generated GoMock package.
+package bugreport
+
+import (
+	gomock "github.com/golang/mock/gomock"
+	reflect "reflect"
+)
+
+// MockExample is a mock of Example interface
+type MockExample struct {
+	ctrl     *gomock.Controller
+	recorder *MockExampleMockRecorder
+}
+
+// MockExampleMockRecorder is the mock recorder for MockExample
+type MockExampleMockRecorder struct {
+	mock *MockExample
+}
+
+// NewMockExample creates a new mock instance
+func NewMockExample(ctrl *gomock.Controller) *MockExample {
+	mock := &MockExample{ctrl: ctrl}
+	mock.recorder = &MockExampleMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use
+func (m *MockExample) EXPECT() *MockExampleMockRecorder {
+	return m.recorder
+}
+
+// Method mocks base method
+func (m_2 *MockExample) Method(_m, _mr, m, mr int) {
+	m_2.ctrl.Call(m_2, "Method", _m, _mr, m, mr)
+}
+
+// Method indicates an expected call of Method
+func (mr_2 *MockExampleMockRecorder) Method(_m, _mr, m, mr interface{}) *gomock.Call {
+	return mr_2.mock.ctrl.RecordCallWithMethodType(mr_2.mock, "Method", reflect.TypeOf((*MockExample)(nil).Method), _m, _mr, m, mr)
+}
+
+// VarargMethod mocks base method
+func (m *MockExample) VarargMethod(_s, _x, a, ret int, varargs ...int) {
+	varargs_2 := []interface{}{_s, _x, a, ret}
+	for _, a_2 := range varargs {
+		varargs_2 = append(varargs_2, a_2)
+	}
+	m.ctrl.Call(m, "VarargMethod", varargs_2...)
+}
+
+// VarargMethod indicates an expected call of VarargMethod
+func (mr *MockExampleMockRecorder) VarargMethod(_s, _x, a, ret interface{}, varargs ...interface{}) *gomock.Call {
+	varargs_2 := append([]interface{}{_s, _x, a, ret}, varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VarargMethod", reflect.TypeOf((*MockExample)(nil).VarargMethod), varargs_2...)
+}

vendor/github.com/golang/mock/mockgen/tests/generated_identifier_conflict/bugreport_test.go

@@ -0,0 +1,26 @@
+package bugreport
+
+import (
+	"github.com/golang/mock/gomock"
+	"testing"
+)
+
+func TestExample_Method(t *testing.T) {
+	ctrl := gomock.NewController(t)
+	m := NewMockExample(ctrl)
+	m.EXPECT().Method(1, 2, 3, 4)
+
+	m.Method(1, 2, 3, 4)
+
+	ctrl.Finish()
+}
+
+func TestExample_VarargMethod(t *testing.T) {
+	ctrl := gomock.NewController(t)
+	m := NewMockExample(ctrl)
+	m.EXPECT().VarargMethod(1, 2, 3, 4, 6, 7)
+
+	m.VarargMethod(1, 2, 3, 4, 6, 7)
+
+	ctrl.Finish()
+}

vendor/github.com/golang/mock/mockgen/tests/import_source/Readme.md

@@ -0,0 +1,3 @@
+Test the case where the generated code uses a type defined in the source package (in source mode). There are two test cases:
+- the output is in a new package
+- the output is in the same package as the input

vendor/github.com/golang/mock/mockgen/tests/import_source/definition/source.go

@@ -0,0 +1,9 @@
+//go:generate mockgen -destination ../source_mock.go -source=source.go
+//go:generate mockgen -package source -destination source_mock.go -source=source.go
+package source
+
+type X struct{}
+
+type S interface {
+	F(X)
+}

vendor/github.com/golang/mock/mockgen/tests/import_source/definition/source_mock.go

@@ -0,0 +1,43 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: source.go
+
+// Package source is a generated GoMock package.
+package source
+
+import (
+	gomock "github.com/golang/mock/gomock"
+	reflect "reflect"
+)
+
+// MockS is a mock of S interface
+type MockS struct {
+	ctrl     *gomock.Controller
+	recorder *MockSMockRecorder
+}
+
+// MockSMockRecorder is the mock recorder for MockS
+type MockSMockRecorder struct {
+	mock *MockS
+}
+
+// NewMockS creates a new mock instance
+func NewMockS(ctrl *gomock.Controller) *MockS {
+	mock := &MockS{ctrl: ctrl}
+	mock.recorder = &MockSMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use
+func (m *MockS) EXPECT() *MockSMockRecorder {
+	return m.recorder
+}
+
+// F mocks base method
+func (m *MockS) F(arg0 X) {
+	m.ctrl.Call(m, "F", arg0)
+}
+
+// F indicates an expected call of F
+func (mr *MockSMockRecorder) F(arg0 interface{}) *gomock.Call {
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "F", reflect.TypeOf((*MockS)(nil).F), arg0)
+}

vendor/github.com/golang/mock/mockgen/tests/import_source/source_mock.go

@@ -0,0 +1,44 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: source.go
+
+// Package mock_source is a generated GoMock package.
+package mock_source
+
+import (
+	gomock "github.com/golang/mock/gomock"
+	definition "github.com/golang/mock/mockgen/tests/import_source/definition"
+	reflect "reflect"
+)
+
+// MockS is a mock of S interface
+type MockS struct {
+	ctrl     *gomock.Controller
+	recorder *MockSMockRecorder
+}
+
+// MockSMockRecorder is the mock recorder for MockS
+type MockSMockRecorder struct {
+	mock *MockS
+}
+
+// NewMockS creates a new mock instance
+func NewMockS(ctrl *gomock.Controller) *MockS {
+	mock := &MockS{ctrl: ctrl}
+	mock.recorder = &MockSMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use
+func (m *MockS) EXPECT() *MockSMockRecorder {
+	return m.recorder
+}
+
+// F mocks base method
+func (m *MockS) F(arg0 definition.X) {
+	m.ctrl.Call(m, "F", arg0)
+}
+
+// F indicates an expected call of F
+func (mr *MockSMockRecorder) F(arg0 interface{}) *gomock.Call {
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "F", reflect.TypeOf((*MockS)(nil).F), arg0)
+}

vendor/github.com/golang/mock/mockgen/tests/internal_pkg/generate.go

@@ -0,0 +1,3 @@
+//go:generate mockgen -destination subdir/internal/pkg/reflect_output/mock.go github.com/golang/mock/mockgen/tests/internal_pkg/subdir/internal/pkg Intf
+//go:generate mockgen -source subdir/internal/pkg/input.go -destination subdir/internal/pkg/source_output/mock.go
+package test

vendor/github.com/golang/mock/mockgen/tests/internal_pkg/subdir/internal/pkg/input.go

@@ -0,0 +1,9 @@
+package pkg
+
+type Arg interface {
+	Foo() int
+}
+
+type Intf interface {
+	F() Arg
+}

vendor/github.com/golang/mock/mockgen/tests/internal_pkg/subdir/internal/pkg/reflect_output/mock.go

@@ -0,0 +1,46 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: github.com/golang/mock/mockgen/tests/internal_pkg/subdir/internal/pkg (interfaces: Intf)
+
+// Package mock_pkg is a generated GoMock package.
+package mock_pkg
+
+import (
+	gomock "github.com/golang/mock/gomock"
+	pkg "github.com/golang/mock/mockgen/tests/internal_pkg/subdir/internal/pkg"
+	reflect "reflect"
+)
+
+// MockIntf is a mock of Intf interface
+type MockIntf struct {
+	ctrl     *gomock.Controller
+	recorder *MockIntfMockRecorder
+}
+
+// MockIntfMockRecorder is the mock recorder for MockIntf
+type MockIntfMockRecorder struct {
+	mock *MockIntf
+}
+
+// NewMockIntf creates a new mock instance
+func NewMockIntf(ctrl *gomock.Controller) *MockIntf {
+	mock := &MockIntf{ctrl: ctrl}
+	mock.recorder = &MockIntfMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use
+func (m *MockIntf) EXPECT() *MockIntfMockRecorder {
+	return m.recorder
+}
+
+// F mocks base method
+func (m *MockIntf) F() pkg.Arg {
+	ret := m.ctrl.Call(m, "F")
+	ret0, _ := ret[0].(pkg.Arg)
+	return ret0
+}
+
+// F indicates an expected call of F
+func (mr *MockIntfMockRecorder) F() *gomock.Call {
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "F", reflect.TypeOf((*MockIntf)(nil).F))
+}

vendor/github.com/golang/mock/mockgen/tests/internal_pkg/subdir/internal/pkg/source_output/mock.go

@@ -0,0 +1,81 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: subdir/internal/pkg/input.go
+
+// Package mock_pkg is a generated GoMock package.
+package mock_pkg
+
+import (
+	gomock "github.com/golang/mock/gomock"
+	pkg "github.com/golang/mock/mockgen/tests/internal_pkg/subdir/internal/pkg"
+	reflect "reflect"
+)
+
+// MockArg is a mock of Arg interface
+type MockArg struct {
+	ctrl     *gomock.Controller
+	recorder *MockArgMockRecorder
+}
+
+// MockArgMockRecorder is the mock recorder for MockArg
+type MockArgMockRecorder struct {
+	mock *MockArg
+}
+
+// NewMockArg creates a new mock instance
+func NewMockArg(ctrl *gomock.Controller) *MockArg {
+	mock := &MockArg{ctrl: ctrl}
+	mock.recorder = &MockArgMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use
+func (m *MockArg) EXPECT() *MockArgMockRecorder {
+	return m.recorder
+}
+
+// Foo mocks base method
+func (m *MockArg) Foo() int {
+	ret := m.ctrl.Call(m, "Foo")
+	ret0, _ := ret[0].(int)
+	return ret0
+}
+
+// Foo indicates an expected call of Foo
+func (mr *MockArgMockRecorder) Foo() *gomock.Call {
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Foo", reflect.TypeOf((*MockArg)(nil).Foo))
+}
+
+// MockIntf is a mock of Intf interface
+type MockIntf struct {
+	ctrl     *gomock.Controller
+	recorder *MockIntfMockRecorder
+}
+
+// MockIntfMockRecorder is the mock recorder for MockIntf
+type MockIntfMockRecorder struct {
+	mock *MockIntf
+}
+
+// NewMockIntf creates a new mock instance
+func NewMockIntf(ctrl *gomock.Controller) *MockIntf {
+	mock := &MockIntf{ctrl: ctrl}
+	mock.recorder = &MockIntfMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use
+func (m *MockIntf) EXPECT() *MockIntfMockRecorder {
+	return m.recorder
+}
+
+// F mocks base method
+func (m *MockIntf) F() pkg.Arg {
+	ret := m.ctrl.Call(m, "F")
+	ret0, _ := ret[0].(pkg.Arg)
+	return ret0
+}
+
+// F indicates an expected call of F
+func (mr *MockIntfMockRecorder) F() *gomock.Call {
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "F", reflect.TypeOf((*MockIntf)(nil).F))
+}

vendor/github.com/golang/mock/mockgen/tests/unexported_method/README.md

@@ -0,0 +1 @@
+From #52, this tests an unexported method in the mocked interface.

vendor/github.com/golang/mock/mockgen/tests/unexported_method/bugreport.go

@@ -0,0 +1,15 @@
+//go:generate mockgen -destination bugreport_mock.go -package bugreport -source=bugreport.go Example
+
+package bugreport
+
+import "fmt"
+
+// Example is an interface with a non exported method
+type Example interface {
+	someMethod(string) string
+}
+
+// CallExample is a simple function that uses the interface
+func CallExample(e Example) {
+	fmt.Println(e.someMethod("test"))
+}

vendor/github.com/golang/mock/mockgen/tests/unexported_method/bugreport_mock.go

@@ -0,0 +1,45 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: bugreport.go
+
+// Package bugreport is a generated GoMock package.
+package bugreport
+
+import (
+	gomock "github.com/golang/mock/gomock"
+	reflect "reflect"
+)
+
+// MockExample is a mock of Example interface
+type MockExample struct {
+	ctrl     *gomock.Controller
+	recorder *MockExampleMockRecorder
+}
+
+// MockExampleMockRecorder is the mock recorder for MockExample
+type MockExampleMockRecorder struct {
+	mock *MockExample
+}
+
+// NewMockExample creates a new mock instance
+func NewMockExample(ctrl *gomock.Controller) *MockExample {
+	mock := &MockExample{ctrl: ctrl}
+	mock.recorder = &MockExampleMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use
+func (m *MockExample) EXPECT() *MockExampleMockRecorder {
+	return m.recorder
+}
+
+// someMethod mocks base method
+func (m *MockExample) someMethod(arg0 string) string {
+	ret := m.ctrl.Call(m, "someMethod", arg0)
+	ret0, _ := ret[0].(string)
+	return ret0
+}
+
+// someMethod indicates an expected call of someMethod
+func (mr *MockExampleMockRecorder) someMethod(arg0 interface{}) *gomock.Call {
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "someMethod", reflect.TypeOf((*MockExample)(nil).someMethod), arg0)
+}

vendor/github.com/golang/mock/mockgen/tests/unexported_method/bugreport_test.go

@@ -0,0 +1,17 @@
+package bugreport
+
+import (
+	"testing"
+
+	"github.com/golang/mock/gomock"
+)
+
+func TestCallExample(t *testing.T) {
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+
+	e := NewMockExample(ctrl)
+	e.EXPECT().someMethod(gomock.Any()).Return("it works!")
+
+	CallExample(e)
+}

vendor/github.com/golang/mock/mockgen/tests/vendor_dep/README.md

@@ -0,0 +1,2 @@
+Test for [Issue#4](https://github.com/golang/mock/issues/4).
+Also see discussion on [#28](https://github.com/golang/mock/pull/28).

vendor/github.com/golang/mock/mockgen/tests/vendor_dep/doc.go

@@ -0,0 +1,4 @@
+package vendor_dep
+
+//go:generate mockgen -package vendor_dep -destination mock.go github.com/golang/mock/mockgen/tests/vendor_dep VendorsDep
+//go:generate mockgen -destination source_mock_package/mock.go -source=vendor_dep.go

vendor/github.com/golang/mock/mockgen/tests/vendor_dep/mock.go

@@ -0,0 +1,46 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: github.com/golang/mock/mockgen/tests/vendor_dep (interfaces: VendorsDep)
+
+// Package vendor_dep is a generated GoMock package.
+package vendor_dep
+
+import (
+	a "a"
+	gomock "github.com/golang/mock/gomock"
+	reflect "reflect"
+)
+
+// MockVendorsDep is a mock of VendorsDep interface
+type MockVendorsDep struct {
+	ctrl     *gomock.Controller
+	recorder *MockVendorsDepMockRecorder
+}
+
+// MockVendorsDepMockRecorder is the mock recorder for MockVendorsDep
+type MockVendorsDepMockRecorder struct {
+	mock *MockVendorsDep
+}
+
+// NewMockVendorsDep creates a new mock instance
+func NewMockVendorsDep(ctrl *gomock.Controller) *MockVendorsDep {
+	mock := &MockVendorsDep{ctrl: ctrl}
+	mock.recorder = &MockVendorsDepMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use
+func (m *MockVendorsDep) EXPECT() *MockVendorsDepMockRecorder {
+	return m.recorder
+}
+
+// Foo mocks base method
+func (m *MockVendorsDep) Foo() a.Ifc {
+	ret := m.ctrl.Call(m, "Foo")
+	ret0, _ := ret[0].(a.Ifc)
+	return ret0
+}
+
+// Foo indicates an expected call of Foo
+func (mr *MockVendorsDepMockRecorder) Foo() *gomock.Call {
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Foo", reflect.TypeOf((*MockVendorsDep)(nil).Foo))
+}

vendor/github.com/golang/mock/mockgen/tests/vendor_dep/source_mock_package/mock.go

@@ -0,0 +1,46 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: vendor_dep.go
+
+// Package mock_vendor_dep is a generated GoMock package.
+package mock_vendor_dep
+
+import (
+	a "a"
+	gomock "github.com/golang/mock/gomock"
+	reflect "reflect"
+)
+
+// MockVendorsDep is a mock of VendorsDep interface
+type MockVendorsDep struct {
+	ctrl     *gomock.Controller
+	recorder *MockVendorsDepMockRecorder
+}
+
+// MockVendorsDepMockRecorder is the mock recorder for MockVendorsDep
+type MockVendorsDepMockRecorder struct {
+	mock *MockVendorsDep
+}
+
+// NewMockVendorsDep creates a new mock instance
+func NewMockVendorsDep(ctrl *gomock.Controller) *MockVendorsDep {
+	mock := &MockVendorsDep{ctrl: ctrl}
+	mock.recorder = &MockVendorsDepMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use
+func (m *MockVendorsDep) EXPECT() *MockVendorsDepMockRecorder {
+	return m.recorder
+}
+
+// Foo mocks base method
+func (m *MockVendorsDep) Foo() a.Ifc {
+	ret := m.ctrl.Call(m, "Foo")
+	ret0, _ := ret[0].(a.Ifc)
+	return ret0
+}
+
+// Foo indicates an expected call of Foo
+func (mr *MockVendorsDepMockRecorder) Foo() *gomock.Call {
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Foo", reflect.TypeOf((*MockVendorsDep)(nil).Foo))
+}

vendor/github.com/golang/mock/mockgen/tests/vendor_dep/vendor_dep.go

@@ -0,0 +1,7 @@
+package vendor_dep
+
+import "a"
+
+type VendorsDep interface {
+	Foo() a.Ifc
+}

vendor/github.com/golang/mock/mockgen/tests/vendor_pkg/README.md

@@ -0,0 +1 @@
+Test for [Issue#4](https://github.com/golang/mock/issues/4).

vendor/github.com/golang/mock/mockgen/tests/vendor_pkg/doc.go

@@ -0,0 +1,3 @@
+package vendor_pkg
+
+//go:generate mockgen -destination mock.go -package vendor_pkg a Ifc

vendor/github.com/golang/mock/mockgen/tests/vendor_pkg/mock.go

@@ -0,0 +1,99 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: a (interfaces: Ifc)
+
+// Package vendor_pkg is a generated GoMock package.
+package vendor_pkg
+
+import (
+	gomock "github.com/golang/mock/gomock"
+	reflect "reflect"
+)
+
+// MockIfc is a mock of Ifc interface
+type MockIfc struct {
+	ctrl     *gomock.Controller
+	recorder *MockIfcMockRecorder
+}
+
+// MockIfcMockRecorder is the mock recorder for MockIfc
+type MockIfcMockRecorder struct {
+	mock *MockIfc
+}
+
+// NewMockIfc creates a new mock instance
+func NewMockIfc(ctrl *gomock.Controller) *MockIfc {
+	mock := &MockIfc{ctrl: ctrl}
+	mock.recorder = &MockIfcMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use
+func (m *MockIfc) EXPECT() *MockIfcMockRecorder {
+	return m.recorder
+}
+
+// A mocks base method
+func (m *MockIfc) A(arg0 string) string {
+	ret := m.ctrl.Call(m, "A", arg0)
+	ret0, _ := ret[0].(string)
+	return ret0
+}
+
+// A indicates an expected call of A
+func (mr *MockIfcMockRecorder) A(arg0 interface{}) *gomock.Call {
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "A", reflect.TypeOf((*MockIfc)(nil).A), arg0)
+}
+
+// B mocks base method
+func (m *MockIfc) B(arg0 int) int {
+	ret := m.ctrl.Call(m, "B", arg0)
+	ret0, _ := ret[0].(int)
+	return ret0
+}
+
+// B indicates an expected call of B
+func (mr *MockIfcMockRecorder) B(arg0 interface{}) *gomock.Call {
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "B", reflect.TypeOf((*MockIfc)(nil).B), arg0)
+}
+
+// C mocks base method
+func (m *MockIfc) C(arg0 chan int) chan int {
+	ret := m.ctrl.Call(m, "C", arg0)
+	ret0, _ := ret[0].(chan int)
+	return ret0
+}
+
+// C indicates an expected call of C
+func (mr *MockIfcMockRecorder) C(arg0 interface{}) *gomock.Call {
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "C", reflect.TypeOf((*MockIfc)(nil).C), arg0)
+}
+
+// D mocks base method
+func (m *MockIfc) D(arg0 interface{}) {
+	m.ctrl.Call(m, "D", arg0)
+}
+
+// D indicates an expected call of D
+func (mr *MockIfcMockRecorder) D(arg0 interface{}) *gomock.Call {
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "D", reflect.TypeOf((*MockIfc)(nil).D), arg0)
+}
+
+// E mocks base method
+func (m *MockIfc) E(arg0 map[string]interface{}) {
+	m.ctrl.Call(m, "E", arg0)
+}
+
+// E indicates an expected call of E
+func (mr *MockIfcMockRecorder) E(arg0 interface{}) *gomock.Call {
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "E", reflect.TypeOf((*MockIfc)(nil).E), arg0)
+}
+
+// F mocks base method
+func (m *MockIfc) F(arg0 []float64) {
+	m.ctrl.Call(m, "F", arg0)
+}
+
+// F indicates an expected call of F
+func (mr *MockIfcMockRecorder) F(arg0 interface{}) *gomock.Call {
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "F", reflect.TypeOf((*MockIfc)(nil).F), arg0)
+}