/*
  Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.

  Licensed under the Apache License, Version 2.0 (the "License").
  You may not use this file except in compliance with the License.
  You may obtain a copy of the License at

  http://www.apache.org/licenses/LICENSE-2.0

  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions and
  limitations under the License.
*/

// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/aws/aws-advanced-go-wrapper/awssql/utils/telemetry (interfaces: TelemetryCounter,TelemetryGauge,TelemetryContext,TelemetryFactory)

// Package mock_telemetry is a generated GoMock package.
package mock_telemetry

import (
	context "context"
	reflect "reflect"

	telemetry "github.com/aws/aws-advanced-go-wrapper/awssql/utils/telemetry"
	gomock "github.com/golang/mock/gomock"
)

// MockTelemetryCounter is a mock of TelemetryCounter interface.
type MockTelemetryCounter struct {
	ctrl     *gomock.Controller
	recorder *MockTelemetryCounterMockRecorder
}

// MockTelemetryCounterMockRecorder is the mock recorder for MockTelemetryCounter.
type MockTelemetryCounterMockRecorder struct {
	mock *MockTelemetryCounter
}

// NewMockTelemetryCounter creates a new mock instance.
func NewMockTelemetryCounter(ctrl *gomock.Controller) *MockTelemetryCounter {
	mock := &MockTelemetryCounter{ctrl: ctrl}
	mock.recorder = &MockTelemetryCounterMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockTelemetryCounter) EXPECT() *MockTelemetryCounterMockRecorder {
	return m.recorder
}

// Add mocks base method.
func (m *MockTelemetryCounter) Add(arg0 context.Context, arg1 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Add", arg0, arg1)
}

// Add indicates an expected call of Add.
func (mr *MockTelemetryCounterMockRecorder) Add(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Add", reflect.TypeOf((*MockTelemetryCounter)(nil).Add), arg0, arg1)
}

// Inc mocks base method.
func (m *MockTelemetryCounter) Inc(arg0 context.Context) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Inc", arg0)
}

// Inc indicates an expected call of Inc.
func (mr *MockTelemetryCounterMockRecorder) Inc(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Inc", reflect.TypeOf((*MockTelemetryCounter)(nil).Inc), arg0)
}

// MockTelemetryGauge is a mock of TelemetryGauge interface.
type MockTelemetryGauge struct {
	ctrl     *gomock.Controller
	recorder *MockTelemetryGaugeMockRecorder
}

// MockTelemetryGaugeMockRecorder is the mock recorder for MockTelemetryGauge.
type MockTelemetryGaugeMockRecorder struct {
	mock *MockTelemetryGauge
}

// NewMockTelemetryGauge creates a new mock instance.
func NewMockTelemetryGauge(ctrl *gomock.Controller) *MockTelemetryGauge {
	mock := &MockTelemetryGauge{ctrl: ctrl}
	mock.recorder = &MockTelemetryGaugeMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockTelemetryGauge) EXPECT() *MockTelemetryGaugeMockRecorder {
	return m.recorder
}

// MockTelemetryContext is a mock of TelemetryContext interface.
type MockTelemetryContext struct {
	ctrl     *gomock.Controller
	recorder *MockTelemetryContextMockRecorder
}

// MockTelemetryContextMockRecorder is the mock recorder for MockTelemetryContext.
type MockTelemetryContextMockRecorder struct {
	mock *MockTelemetryContext
}

// NewMockTelemetryContext creates a new mock instance.
func NewMockTelemetryContext(ctrl *gomock.Controller) *MockTelemetryContext {
	mock := &MockTelemetryContext{ctrl: ctrl}
	mock.recorder = &MockTelemetryContextMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockTelemetryContext) EXPECT() *MockTelemetryContextMockRecorder {
	return m.recorder
}

// CloseContext mocks base method.
func (m *MockTelemetryContext) CloseContext() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "CloseContext")
}

// CloseContext indicates an expected call of CloseContext.
func (mr *MockTelemetryContextMockRecorder) CloseContext() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseContext", reflect.TypeOf((*MockTelemetryContext)(nil).CloseContext))
}

// GetName mocks base method.
func (m *MockTelemetryContext) GetName() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetName")
	ret0, _ := ret[0].(string)
	return ret0
}

// GetName indicates an expected call of GetName.
func (mr *MockTelemetryContextMockRecorder) GetName() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetName", reflect.TypeOf((*MockTelemetryContext)(nil).GetName))
}

// SetAttribute mocks base method.
func (m *MockTelemetryContext) SetAttribute(arg0, arg1 string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetAttribute", arg0, arg1)
}

// SetAttribute indicates an expected call of SetAttribute.
func (mr *MockTelemetryContextMockRecorder) SetAttribute(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetAttribute", reflect.TypeOf((*MockTelemetryContext)(nil).SetAttribute), arg0, arg1)
}

// SetError mocks base method.
func (m *MockTelemetryContext) SetError(arg0 error) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetError", arg0)
}

// SetError indicates an expected call of SetError.
func (mr *MockTelemetryContextMockRecorder) SetError(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetError", reflect.TypeOf((*MockTelemetryContext)(nil).SetError), arg0)
}

// SetSuccess mocks base method.
func (m *MockTelemetryContext) SetSuccess(arg0 bool) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetSuccess", arg0)
}

// SetSuccess indicates an expected call of SetSuccess.
func (mr *MockTelemetryContextMockRecorder) SetSuccess(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSuccess", reflect.TypeOf((*MockTelemetryContext)(nil).SetSuccess), arg0)
}

// MockTelemetryFactory is a mock of TelemetryFactory interface.
type MockTelemetryFactory struct {
	ctrl     *gomock.Controller
	recorder *MockTelemetryFactoryMockRecorder
}

// MockTelemetryFactoryMockRecorder is the mock recorder for MockTelemetryFactory.
type MockTelemetryFactoryMockRecorder struct {
	mock *MockTelemetryFactory
}

// NewMockTelemetryFactory creates a new mock instance.
func NewMockTelemetryFactory(ctrl *gomock.Controller) *MockTelemetryFactory {
	mock := &MockTelemetryFactory{ctrl: ctrl}
	mock.recorder = &MockTelemetryFactoryMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockTelemetryFactory) EXPECT() *MockTelemetryFactoryMockRecorder {
	return m.recorder
}

// CreateCounter mocks base method.
func (m *MockTelemetryFactory) CreateCounter(arg0 string) (telemetry.TelemetryCounter, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateCounter", arg0)
	ret0, _ := ret[0].(telemetry.TelemetryCounter)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateCounter indicates an expected call of CreateCounter.
func (mr *MockTelemetryFactoryMockRecorder) CreateCounter(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCounter", reflect.TypeOf((*MockTelemetryFactory)(nil).CreateCounter), arg0)
}

// CreateGauge mocks base method.
func (m *MockTelemetryFactory) CreateGauge(arg0 string) (telemetry.TelemetryGauge, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateGauge", arg0)
	ret0, _ := ret[0].(telemetry.TelemetryGauge)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateGauge indicates an expected call of CreateGauge.
func (mr *MockTelemetryFactoryMockRecorder) CreateGauge(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateGauge", reflect.TypeOf((*MockTelemetryFactory)(nil).CreateGauge), arg0)
}

// OpenTelemetryContext mocks base method.
func (m *MockTelemetryFactory) OpenTelemetryContext(arg0 string, arg1 telemetry.TelemetryTraceLevel, arg2 context.Context) (telemetry.TelemetryContext, context.Context) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "OpenTelemetryContext", arg0, arg1, arg2)
	ret0, _ := ret[0].(telemetry.TelemetryContext)
	ret1, _ := ret[1].(context.Context)
	return ret0, ret1
}

// OpenTelemetryContext indicates an expected call of OpenTelemetryContext.
func (mr *MockTelemetryFactoryMockRecorder) OpenTelemetryContext(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OpenTelemetryContext", reflect.TypeOf((*MockTelemetryFactory)(nil).OpenTelemetryContext), arg0, arg1, arg2)
}

// PostCopy mocks base method.
func (m *MockTelemetryFactory) PostCopy(arg0 telemetry.TelemetryContext, arg1 telemetry.TelemetryTraceLevel) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PostCopy", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// PostCopy indicates an expected call of PostCopy.
func (mr *MockTelemetryFactoryMockRecorder) PostCopy(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostCopy", reflect.TypeOf((*MockTelemetryFactory)(nil).PostCopy), arg0, arg1)
}
