}

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

// Type indicates an expected call of Type.
func (mr *MockRuntimeMockRecorder) Type() *gomock.Call {
	mr.mock.ctrl.T.Helper()

import org.gradle.api.Project;
import org.gradle.api.file.CopySpec;
import org.gradle.api.reflect.HasPublicType;
import org.gradle.api.reflect.TypeOf;
import org.gradle.internal.deprecation.DeprecationLogger;

import javax.inject.Inject;
import java.util.ArrayList;

import static org.gradle.api.reflect.TypeOf.typeOf;

@SuppressWarnings("deprecation")

	v2 "github.com/google/cadvisor/info/v2"
	gomock "go.uber.org/mock/gomock"
	v10 "k8s.io/api/core/v1"
	types "k8s.io/apimachinery/pkg/types"
	v1alpha1 "k8s.io/kubelet/pkg/apis/stats/v1alpha1"
	cm "k8s.io/kubernetes/pkg/kubelet/cm"
	volume "k8s.io/kubernetes/pkg/volume"
)

// MockProvider is a mock of Provider interface.
type MockProvider struct {
	ctrl     *gomock.Controller
	recorder *MockProviderMockRecorder
}

            }
        })
        if (value == null) throw annotationMemberValueNotFound(typeOf<Array<String>>())
        return value!!
    }


private
fun <T> annotationMemberValueNotFound(type: TypeOf<T>) =
    IllegalStateException("Annotation member value '${type.simpleName}' not found")


private
open class MemberValueVisitorAdapter : MemberValueVisitor {

            verifyNoMoreInteractions()
        }
    }

    @Test
    fun `can get generic extension by type`() {

        val extensionAware = mock<ExtensionAware>()
        val extensions = mock<ExtensionContainer>()
        val extension = mock<NamedDomainObjectContainer<List<String>>>()
        val extensionType = typeOf<NamedDomainObjectContainer<List<String>>>()

        whenever(extensionAware.extensions)

            foo = "typed access"
        }
        container.named("bar", DomainObject::class) {
            bar = "typed configuration"
        }

        assertThat(container["foo"].foo, equalTo("reified access"))
        assertThat(container["foo"].bar, equalTo("reified configuration"))

        assertThat(container["bar"].foo, equalTo("typed access"))

    @Inject
    public DefaultBasePluginConvention(BasePluginExtension extension) {
        this.extension = extension;
    }
    @Override
    public TypeOf<?> getPublicType() {
        return TypeOf.typeOf(org.gradle.api.plugins.BasePluginConvention.class);
    }

    @Override
    public DirectoryProperty getDistsDirectory() {
        return extension.getDistsDirectory();
    }

    @Override

	switch nativeType {
	case reflect.TypeOf(""):
		return apiservercel.StringType
	case reflect.TypeOf([]string{}):
		return apiservercel.NewListType(apiservercel.StringType, -1)
	case reflect.TypeOf(map[string]v1.ExtraValue{}):
		return apiservercel.NewMapType(apiservercel.StringType, apiservercel.NewListType(apiservercel.StringType, -1), -1)
	case reflect.TypeOf(&v1.ResourceAttributes{}):

		{TypeOf(float32(0)), ""},
		{TypeOf(float64(0)), ""},
		{TypeOf(complex64(0)), ""},
		{TypeOf(complex128(0)), ""},
		{TypeOf(byte(0)), ""},
		{TypeOf(rune(0)), ""},
		{TypeOf([]byte(nil)), ""},
		{TypeOf([]rune(nil)), ""},
		{TypeOf(string("")), ""},
		{TypeOf((*any)(nil)).Elem(), ""},
		{TypeOf((*byte)(nil)), ""},
		{TypeOf((*rune)(nil)), ""},
		{TypeOf((*int64)(nil)), ""},
		{TypeOf(map[string]int{}), ""},

import org.gradle.api.model.ObjectFactory;
import org.gradle.api.reflect.TypeOf;
import org.gradle.api.tasks.SourceSet;
import org.gradle.api.tasks.SourceSetContainer;
import org.gradle.internal.reflect.Instantiator;

import javax.inject.Inject;

import static org.gradle.api.reflect.TypeOf.typeOf;