// NewMockClusterRoleBindingInterface creates a new mock instance
483882
func NewMockClusterRoleBindingInterface(ctrl *gomock.Controller) *MockClusterRoleBindingInterface {
	mock := &MockClusterRoleBindingInterface{ctrl: ctrl}
	mock.recorder = &MockClusterRoleBindingInterfaceMockRecorder{mock}
	return mock
}
1164004
func NewMockStatsClient(ctrl *gomock.Controller) *MockStatsClient {
	mock := &MockStatsClient{ctrl: ctrl}
	mock.recorder = &MockStatsClientMockRecorder{mock}
	return mock
}
349627
func NewClusterOperationInstance(clusterOpID string, initialTask *automationpb.TaskContainer, taskIDGenerator *IDGenerator) ClusterOperationInstance {
	c := ClusterOperationInstance{
		automationpb.ClusterOperation{
			Id:          clusterOpID,
			SerialTasks: []*automationpb.TaskContainer{},
			State:       automationpb.ClusterOperationState_CLUSTER_OPERATION_NOT_STARTED,
		},
		taskIDGenerator,
	}
	c.InsertTaskContainers([]*automationpb.TaskContainer{initialTask}, 0)
	return c
}
937447
func (s *ClusterService) AddCluster(p *AddClusterParams) (*AddClusterResponse, error) {
	resp, err := s.cs.newRequest("addCluster", p.toURLValues())
	if err != nil {
		return nil, err
	}

	var r AddClusterResponse
	if err := json.Unmarshal(resp, &r); err != nil {
		return nil, err
	}

	return &r, nil
}
635015
func NewCmdCreateClusterRoleBinding(f cmdutil.Factory, ioStreams genericclioptions.IOStreams) *cobra.Command {
	o := &ClusterRoleBindingOpts{
		CreateSubcommandOptions: NewCreateSubcommandOptions(ioStreams),
	}

	cmd := &cobra.Command{
		Use:                   "clusterrolebinding NAME --clusterrole=NAME [--user=username] [--group=groupname] [--serviceaccount=namespace:serviceaccountname] [--dry-run]",
		DisableFlagsInUseLine: true,
		Short:                 i18n.T("Create a ClusterRoleBinding for a particular ClusterRole"),
		Long:                  clusterRoleBindingLong,
		Example:               clusterRoleBindingExample,
		Run: func(cmd *cobra.Command, args []string) {
			cmdutil.CheckErr(o.Complete(f, cmd, args))
			cmdutil.CheckErr(o.Run())
		},
	}

	o.CreateSubcommandOptions.PrintFlags.AddFlags(cmd)

	cmdutil.AddApplyAnnotationFlags(cmd)
	cmdutil.AddValidateFlags(cmd)
	cmdutil.AddGeneratorFlags(cmd, generateversioned.ClusterRoleBindingV1GeneratorName)
	cmd.Flags().String("clusterrole", "", i18n.T("ClusterRole this ClusterRoleBinding should reference"))
	cmd.MarkFlagCustom("clusterrole", "__kubectl_get_resource_clusterrole")
	cmd.Flags().StringArray("user", []string{}, "Usernames to bind to the clusterrole")
	cmd.Flags().StringArray("group", []string{}, "Groups to bind to the clusterrole")
	cmd.Flags().StringArray("serviceaccount", []string{}, "Service accounts to bind to the clusterrole, in the format <namespace>:<name>")
	return cmd
}
1175016
func NewMockStatefulSetInterface(ctrl *gomock.Controller) *MockStatefulSetInterface {
	mock := &MockStatefulSetInterface{ctrl: ctrl}
	mock.recorder = &MockStatefulSetInterfaceMockRecorder{mock}
	return mock
}
1299438
func NewMockDeploymentInterface(ctrl *gomock.Controller) *MockDeploymentInterface {
	mock := &MockDeploymentInterface{ctrl: ctrl}
	mock.recorder = &MockDeploymentInterfaceMockRecorder{mock}
	return mock
}
833121
func NewMockBuildsClient(ctrl *gomock.Controller) *MockBuildsClient {
	mock := &MockBuildsClient{ctrl: ctrl}
	mock.recorder = &MockBuildsClientMockRecorder{mock}
	return mock
}
1349695
func NewMockStatefulPeer(name, url string, opts ...MockPeerOpt) *MockPeer {
	p := &MockPeer{
		MockPeer: fabmocks.NewMockPeer(name, url),
	}
	for _, opt := range opts {
		opt(p)
	}
	return p
}
954587
func NewMockPodInterface(ctrl *gomock.Controller) *MockPodInterface {
	mock := &MockPodInterface{ctrl: ctrl}
	mock.recorder = &MockPodInterfaceMockRecorder{mock}
	return mock
}
1251953
func NewMockConnector(ctrl *gomock.Controller) *MockConnector {
	mock := &MockConnector{ctrl: ctrl}
	mock.recorder = &MockConnectorMockRecorder{mock}
	return mock
}
161411
func NewMockServer() *grpc.Server {
	mock := &mockServer{}
	serv := grpc.NewServer()
	pb.RegisterAgentServiceServer(serv, mock)
	pb.RegisterHealthServer(serv, mock)

	return serv
}
1222416
func NewMockInstanceConnector(ctrl *gomock.Controller) *MockInstanceConnector {
	mock := &MockInstanceConnector{ctrl: ctrl}
	mock.recorder = &MockInstanceConnectorMockRecorder{mock}
	return mock
}
828747
func NewMockBrokerListener(t TestReporter, brokerID int32, listener net.Listener) *MockBroker {
	var err error

	broker := &MockBroker{
		closing:      make(chan none),
		stopper:      make(chan none),
		t:            t,
		brokerID:     brokerID,
		expectations: make(chan encoder, 512),
		listener:     listener,
	}
	broker.handler = broker.defaultRequestHandler

	Logger.Printf("*** mockbroker/%d listening on %s\n", brokerID, broker.listener.Addr().String())
	_, portStr, err := net.SplitHostPort(broker.listener.Addr().String())
	if err != nil {
		t.Fatal(err)
	}
	tmp, err := strconv.ParseInt(portStr, 10, 32)
	if err != nil {
		t.Fatal(err)
	}
	broker.port = int32(tmp)

	go broker.serverLoop()

	return broker
}
747400
func NewMockInstanceBroker(ctrl *gomock.Controller) *MockInstanceBroker {
	mock := &MockInstanceBroker{ctrl: ctrl}
	mock.recorder = &MockInstanceBrokerMockRecorder{mock}
	return mock
}
1162408
func (v *version) ClusterRoleBindings() ClusterRoleBindingInformer {
	return &clusterRoleBindingInformer{factory: v.factory, tweakListOptions: v.tweakListOptions}
}
33972
func NewMockGitilesServer(ctrl *gomock.Controller) *MockGitilesServer {
	mock := &MockGitilesServer{ctrl: ctrl}
	mock.recorder = &MockGitilesServerMockRecorder{mock}
	return mock
}