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) {

    }

    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;

		once.Do(func() {
			stopCompactor()
			stopDBSizeMonitor()
			client.Close()
		})
	}
	transformer := c.Transformer
	if transformer == nil {
		transformer = identity.NewEncryptCheckTransformer()
	}
	return etcd3.New(client, c.Codec, newFunc, newListFunc, c.Prefix, resourcePrefix, c.GroupResource, transformer, c.LeaseManagerConfig), destroyFunc, nil
}

 * limitations under the License.
 */

package org.gradle.api.internal.provider;

import com.google.common.base.Preconditions;
import org.gradle.api.Transformer;
import org.gradle.api.provider.Property;
import org.gradle.api.provider.Provider;
import org.gradle.internal.Cast;

import javax.annotation.Nullable;

/**

	// in this case, leading whitespace
	revertTransformer := store.UpdatePrefixTransformer(
		func(transformer *PrefixTransformer) value.Transformer {
			transformer.prefix = []byte(string(transformer.prefix) + " ")
			return transformer
		})
	_, initial := testPropagateStore(ctx, t, store, input)
	revertTransformer()

            });
        }
    }

    private static Provider<Boolean> getCommentsProperty(Project project) {
        return project.getProviders().gradleProperty(COMMENTS_PROPERTY).map(SerializableLambdas.transformer(Boolean::parseBoolean));
    }