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;

import org.gradle.api.plugins.Convention
import org.gradle.api.reflect.HasPublicType
import org.gradle.api.reflect.TypeOf
import org.gradle.internal.reflect.Instantiator
import org.gradle.util.TestUtil
import org.junit.Before
import org.junit.Test

import static org.gradle.api.reflect.TypeOf.typeOf
import static org.hamcrest.CoreMatchers.equalTo
import static org.junit.Assert.assertEquals

            .thenReturn(convention)
        whenever(convention.findByType(any<TypeOf<*>>()))
            .thenReturn(null)
        whenever(convention.findPlugin(eq(CustomConvention::class.java)))
            .thenReturn(javaConvention)

        project.configure<CustomConvention> {}

        inOrder(convention) {
            verify(convention).findByType(any<TypeOf<CustomConvention>>())

	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HasDedicatedImageFs", reflect.TypeOf((*MockDiskInfoProvider)(nil).HasDedicatedImageFs), ctx)
}

// MockImageGC is a mock of ImageGC interface.
type MockImageGC struct {
	ctrl     *gomock.Controller
	recorder *MockImageGCMockRecorder
}

// MockImageGCMockRecorder is the mock recorder for MockImageGC.
type MockImageGCMockRecorder struct {
	mock *MockImageGC
}

}

// GetUIDTranslations mocks base method.
func (m *MockPodManager) GetUIDTranslations() (map[types0.ResolvedPodUID]types0.MirrorPodUID, map[types0.MirrorPodUID]types0.ResolvedPodUID) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetUIDTranslations")
	ret0, _ := ret[0].(map[types0.ResolvedPodUID]types0.MirrorPodUID)

}

// GetUIDTranslations mocks base method.
func (m *MockManager) GetUIDTranslations() (map[types0.ResolvedPodUID]types0.MirrorPodUID, map[types0.MirrorPodUID]types0.ResolvedPodUID) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetUIDTranslations")
	ret0, _ := ret[0].(map[types0.ResolvedPodUID]types0.MirrorPodUID)

}

// MockPodsProvider is a mock of PodsProvider interface.
type MockPodsProvider struct {
	ctrl     *gomock.Controller
	recorder *MockPodsProviderMockRecorder
}

// MockPodsProviderMockRecorder is the mock recorder for MockPodsProvider.
type MockPodsProviderMockRecorder struct {
	mock *MockPodsProvider
}

		GroupName:          GroupName,
		SchemeGroupVersion: SchemeGroupVersion,
		AddToScheme:        AddToScheme,
		AllowedTags: map[reflect.Type]bool{
			reflect.TypeOf(metav1.TypeMeta{}):              true,
			reflect.TypeOf(metav1.Duration{}):              true,
			reflect.TypeOf(logsapi.LoggingConfiguration{}): true,
		},
	}

	if err := componentconfigtesting.VerifyInternalTypePackage(pkginfo); err != nil {