* limitations under the License.
 */
package org.gradle.api.internal.tasks.userinput;

import org.apache.commons.lang.BooleanUtils;
import org.gradle.api.Transformer;
import org.gradle.internal.logging.events.BooleanQuestionPromptEvent;
import org.gradle.internal.logging.events.IntQuestionPromptEvent;
import org.gradle.internal.logging.events.OutputEventListener;

        errorprone.enabled = false
    }
}

dependencies {
    api(project(":base-services")) {
        because("Part of the public API, used by spock AST transformer")
    }
    api(project(":build-cache-base"))
    api(project(":build-operations"))
    api(project(":concurrent"))
    api(project(":core"))
    api(project(":core-api"))
    api(project(":dependency-management"))

 * limitations under the License.
 */

package org.gradle.tooling.internal.provider.serialization;

import com.google.common.collect.ImmutableList;
import org.gradle.api.Transformer;
import org.gradle.internal.UncheckedException;
import org.gradle.internal.classloader.ClassLoaderSpec;
import org.gradle.internal.classloader.ClassLoaderVisitor;
import org.gradle.internal.classloader.SystemClassLoaderSpec;

        def transformer = Mock(Transformer)
        def property = propertyWithNoValue()

        when:
        def provider = property.map(transformer)

        then:
        0 * _

        when:
        property.set(someValue())
        def r1 = provider.get()

        then:
        r1 == someOtherValue()
        1 * transformer.transform(someValue()) >> someOtherValue()

    def mapping = Mock(ModelMapping)
    def transformer = CancellationExceptionTransformer.transformerFor(VersionDetails.from("4.8"))
    def builder = Mock(InternalCancellableConnection)

    def modelProducer

    def setup() {
        _ * versionDetails.getVersion() >> "1.0"
        modelProducer = new CancellableModelBuilderBackedModelProducer(adapter, versionDetails, mapping, builder, transformer)
    }

        buildFile """
interface Transformer {}

class Impl implements Transformer {}

class MyTask extends DefaultTask {
    public void transform(Class<? extends Transformer> c) {
        logger.lifecycle("transform(Class)")
    }

    public void transform(Transformer t) {
        logger.lifecycle("transform(Transformer)")
    }
}

task print(type: MyTask) {

import com.google.common.primitives.Longs;
import org.gradle.api.Transformer;
import org.gradle.internal.service.scopes.Scope;
import org.gradle.internal.service.scopes.ServiceScope;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

@ServiceScope(Scope.Global.class)
public class VersionParser implements Transformer<Version, String> {

    }

    public static boolean installTransformer(ClassFileTransformer transformer) {
        Method installTransformer = findAgentMethod(INSTRUMENTATION_AGENT_CLASS_NAME, "installTransformer", ClassFileTransformer.class);
        if (installTransformer == null) {
            return false;
        }
        return callStaticAgentMethod(installTransformer, transformer);
    }

    @Nullable

              <models>
                <model>src/main/mdo/settings.mdo</model>
              </models>
              <templates>
                <template>merger.vm</template>
                <template>transformer.vm</template>
                <template>reader-stax.vm</template>
                <template>writer-stax.vm</template>
              </templates>
              <params>

 * limitations under the License.
 */

package org.gradle.workers.internal;

import com.google.common.annotations.VisibleForTesting;
import org.gradle.api.Transformer;
import org.gradle.api.logging.LogLevel;
import org.gradle.api.logging.Logger;
import org.gradle.api.logging.Logging;
import org.gradle.internal.concurrent.Stoppable;
import org.gradle.internal.event.ListenerManager;