}

    @Override
    public <T> T getModel(Class<T> modelType) throws UnknownModelException {
        return getModel(null, modelType);
    }

    @Override
    public <T> T findModel(Class<T> modelType) {
        return findModel(null, modelType);
    }

    @Override
    public GradleBuild getBuildModel() {
        return getModel(null, GradleBuild.class);
    }

    @Override

}

// GetPods mocks base method.
func (m *MockRuntimeCache) GetPods(arg0 context.Context) ([]*container.Pod, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPods", arg0)
	ret0, _ := ret[0].([]*container.Pod)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetPods indicates an expected call of GetPods.
func (mr *MockRuntimeCacheMockRecorder) GetPods(arg0 any) *gomock.Call {

        IdeaProject ideaProject = controller.getModel(IdeaProject.class);
        for (IdeaModule ideaModule : ideaProject.getModules()) {
            visit(ideaModule, controller, new HashMap<String, CustomModel>());
        }

        // Use an EclipseProject to reference a project
        EclipseProject eclipseProject = controller.getModel(EclipseProject.class);

        def model = new Object()
        def modelType = Object
        def buildResult = Stub(BuildResult) {
            getModel() >> model
        }

        when:
        def result = controller.getModel(null, modelType, null, null)

        then:
        1 * delegate.getModel(null, {it.name == Object.name}) >> buildResult
        0 * delegate._

        and:
        result == model
    }

task test1(group:'task group 1')
task test2(group:'task group 2')
'''

        when:
        def gradleProject = withConnection { ProjectConnection connection ->
            connection.getModel(GradleProject)
        }

        then:
        gradleProject != null
        gradleProject.tasks.findAll { it.name.startsWith('test') }.each {
            assert it.group == "task group ${it.name-'test'}"
        }

    def "unpacks unsupported model exception"() {
        def failure = new RuntimeException()

        given:
        _ * delegate.getModel(null, _, null) >> { throw new InternalUnsupportedModelException().initCause(failure) }

        when:
        controller.getModel(String)

        then:
        UnknownModelException e = thrown()
        e.message == /No model of type 'String' is available in this build./

     * @throws UnknownModelException When the default project does not support the requested model.
     * @since 1.8
     */
    <T> T getModel(Class<T> modelType) throws UnknownModelException;

    /**
     * Fetches a snapshot of the model of the given type, if available.
     *
     * <p>See {@link #getModel(Class)} for more details.</p>
     *
     * @param modelType The model type.
     * @param <T> The model type.

class CompositeBuildCrossVersionSpec extends ToolingApiSpecification {
    def "includes buildSrc builds in model"() {
        buildsWithBuildSrc()

        given:
        def model = withConnection {
            it.getModel(GradleBuild)
        }

        expect:
        model.includedBuilds.size() == 1

        def included = model.includedBuilds[0]
        included.buildIdentifier.rootDir == file("child")

            "project.description = java.lang.management.ManagementFactory.runtimeMXBean.inputArguments.join('##')"

        when:
        BuildEnvironment env = withConnection { it.getModel(BuildEnvironment.class) }
        GradleProject project = withConnection { it.getModel(GradleProject.class) }

        then:
        def inputArgsInBuild = project.description.split('##') as List
        env.java.jvmArguments.each { inputArgsInBuild.contains(it) }

import (
	"context"
	"sync"
	"time"
)

// RuntimeCache is in interface for obtaining cached Pods.
type RuntimeCache interface {
	GetPods(context.Context) ([]*Pod, error)
	ForceUpdateIfOlder(context.Context, time.Time) error
}

type podsGetter interface {
	GetPods(context.Context, bool) ([]*Pod, error)
}

// NewRuntimeCache creates a container runtime cache.