when:
        withConnection {
            it.action(new BrokenAction()).run()
        }

        then:
        BuildActionFailureException e = thrown()
        e.message == /The supplied build action failed with an exception./
        e.cause instanceof BrokenAction.CustomException

        and:
        failure.assertHasDescription('this is a custom exception')
        assertHasConfigureFailedLogging()

     * This method is intended to be used for user supplied java homes.
     *
     * @param javaHome - location of your jdk or jre (jdk is safer), cannot be null
     * @return jvm for given java home
     * @throws org.gradle.internal.jvm.JavaHomeException when supplied javaHome does not seem to be a valid jdk or jre location
     * @throws IllegalArgumentException when supplied javaHome is not a valid folder
     */

 * limitations under the License.
 */

package org.gradle.internal.cc.impl.models

import org.gradle.internal.extensions.stdlib.uncheckedCast


/**
 * Model built by a build action supplied via Tooling API
 */
sealed class BuildTreeModel {

    abstract fun <T> result(): T?

    object NullModel : BuildTreeModel() {
        override fun <T> result(): T? = null
    }

     * Called when the current process starts receiving user input from the client.
     */
    void startInput();

    void putInput(UserInput input);

    /**
     * Returns a {@link TextResponse} containing text supplied by the user, or {@link #END_OF_INPUT} if interrupted.
     */
    UserInput readInput();

    abstract class UserInput {
        abstract String getText();
    }

    UserInput END_OF_INPUT = new UserInput() {

                .build()

            collectOutputs(action)
            action.run()
        }

        then:
        BuildActionFailureException e = thrown()
        e.message == "The supplied phased action failed with an exception."
        e.cause instanceof RuntimeException
        e.cause.message == "actionFailure"
        projectsLoadedHandler.getResult() == null

import org.jetbrains.kotlin.utils.addToStdlib.partitionIsInstance

/**
 * With each call to [merge], [SublistMerger] can merge all elements of a specific (reified) type into a single element using a supplied
 * constructor and then add it to [destination]. Unmerged elements are added to [destination] using [finish].
 *

        def jvm = Jvm.current()

        then:
        jvm.isIbmJvm()

        where:
        vendorProperty << ['java.vendor', 'java.vm.vendor']
    }

    def "finds executable for java home supplied"() {
        System.properties['java.vm.vendor'] = 'Sun'

        when:
        def home = tmpDir.createDir("home")
        home.create {
            jre {
                bin {

 */
object OriginReplacement {
    /**
     * Replaces receivers matching a predicate with a replacement receiver.  The replacement returns a deep copy of the receiver hierarchy of the
     * supplied {@link ObjectOrigin} with the given replacement applied.
     */
    fun replaceReceivers(replaceIn: ObjectOrigin, predicate: (ObjectOrigin.ReceiverOrigin) -> Boolean, replacement: ObjectOrigin.ReceiverOrigin): ObjectOrigin =

/**
 * Renders the properties and the textual representation of a callable's return type specified via `// callable: ID`. The varying
 * [TestModuleKind][org.jetbrains.kotlin.analysis.test.framework.test.configurators.TestModuleKind] supplied by generated tests applies to
 * the expansion-site module instead of the use-site module in these tests, as we want to check the `KaType` when it's built with an

            } catch (RuntimeException e) {
                throw exceptionTransformer.transform(e);
            }
        } catch (InternalBuildActionFailureException e) {
            throw new BuildActionFailureException("The supplied build action failed with an exception.", e.getCause());
        }
        return result.getModel();
    }

    @SuppressWarnings("deprecation")