import org.gradle.tooling.model.idea.BasicIdeaProject;
import org.gradle.tooling.model.idea.IdeaProject;

import javax.annotation.Nullable;
import java.util.HashMap;
import java.util.Map;

public class ModelMapping {
    private static final Map<Class<?>, String> MODEL_VERSIONS = new HashMap<Class<?>, String>();

    static {
        addModelVersions(MODEL_VERSIONS);
    }

    private final ProtocolToModelAdapter adapter;
    private final ObjectGraphAdapter resultAdapter;
    private final ModelMapping modelMapping;
    protected final VersionDetails gradleVersion;
    private final File rootDir;

    public UnparameterizedBuildController(ProtocolToModelAdapter adapter, ModelMapping modelMapping, VersionDetails gradleVersion, File rootDir) {
        this.adapter = adapter;

            ProtocolToModelAdapter adapter = new ProtocolToModelAdapter(new ConsumerTargetTypeProvider());
            ModelMapping modelMapping = new ModelMapping();
            if (connection instanceof InternalStopWhenIdleConnection) {
                return createConnection(new StopWhenIdleConsumerConnection(connection, modelMapping, adapter), connectionParameters);
            } else if (connection instanceof InternalInvalidatableVirtualFileSystemConnection) {

 */
public class ShutdownAwareConsumerConnection extends CancellableConsumerConnection {
    public ShutdownAwareConsumerConnection(ConnectionVersion4 delegate, ModelMapping modelMapping, ProtocolToModelAdapter adapter) {
        super(delegate, modelMapping, adapter);
    }

    @Override
    public void stop() {
        ((StoppableConnection) getDelegate()).shutdown(new ShutdownParameters() { });
    }

 */
public class StopWhenIdleConsumerConnection extends NotifyDaemonsAboutChangedPathsConsumerConnection {
    public StopWhenIdleConsumerConnection(ConnectionVersion4 delegate, ModelMapping modelMapping, ProtocolToModelAdapter adapter) {
        super(delegate, modelMapping, adapter);
    }

    @Override
    public void stopWhenIdle(ConsumerOperationParameters operationParameters) {

    public ParameterAwareBuildControllerAdapter(InternalBuildControllerVersion2 buildController, ProtocolToModelAdapter adapter, ModelMapping modelMapping, VersionDetails gradleVersion, File rootDir) {
        super(adapter, modelMapping, gradleVersion, rootDir);
        this.buildController = buildController;
    }

    @Override

    def version = Mock(VersionDetails)
    def delegate = Mock(InternalBuildController)
    def modelMapping = new ModelMapping()
    def controller = new BuildControllerWithoutParameterSupport(delegate, new ProtocolToModelAdapter(), modelMapping, new File("root dir"), version)

    def "delegates when no parameter is given"() {
        def model = new Object()
        def modelType = Object

    protected final VersionDetails versionDetails;
    protected final ModelMapping modelMapping;
    private final InternalCancellableConnection builder;
    protected final CancellationExceptionTransformer exceptionTransformer;

        modelProducer = createModelProducer(connection, modelMapping, adapter, exceptionTransformer);
        actionRunner = new CancellableActionRunner(connection, exceptionTransformer, getVersionDetails());
    }

    private ModelProducer createModelProducer(InternalCancellableConnection connection, ModelMapping modelMapping, ProtocolToModelAdapter adapter, CancellationExceptionTransformer exceptionTransformer) {

        getMetaData() >> Stub(ConnectionMetaDataVersion1) {
            getVersion() >> "4.4"
        }
    }
    final adapter = Mock(ProtocolToModelAdapter)
    final modelMapping = Mock(ModelMapping)
    final connection = new ParameterAcceptingConsumerConnection(target, modelMapping, adapter)

    def "describes capabilities of provider"() {
        given:
        def details = connection.versionDetails

        expect: