}

    def "replace transformation runs eagerly"() {
        given:
        Transformer<Provider<String>, Provider<String>> transform = Mock()
        def property = property().value(someValue())

        when:
        property.replace(transform)

        then:
        1 * transform.transform(_)
    }

import org.gradle.internal.operations.CallableBuildOperation;
import org.gradle.internal.scan.UsedByScanPlugin;
import org.gradle.operations.dependencies.transforms.ExecutePlannedTransformStepBuildOperationType;
import org.gradle.operations.dependencies.transforms.PlannedTransformStepIdentity;
import org.gradle.operations.dependencies.variants.Capability;
import org.gradle.operations.dependencies.variants.ComponentIdentifier;

        assertTrue(transformer.isValidUrl("http://www.example.com"));
        assertTrue(transformer.isValidUrl("http://www.example.com/aaa"));
        assertTrue(transformer.isValidUrl("https://www.example.com"));
        assertTrue(transformer.isValidUrl("://www.example.com"));
        assertTrue(transformer.isValidUrl("//www.example.com"));

        assertFalse(transformer.isValidUrl(null));

					t.Fatalf("envelopeTransformer transformed data incorrectly. Expected: %v, got %v", originalText, untransformedData)
				}
			}
		})
	}
}

// Makes Envelope transformer hit cache limit, throws error if it misbehaves.
func TestEnvelopeCacheLimit(t *testing.T) {
	cbcTransformer := func(block cipher.Block) (value.Transformer, error) {
		return aestransformer.NewCBCTransformer(block), nil
	}

            }
        }
    }

    private <T extends NativeCompileSpec> Transformer<T, T> pchSpecTransforms(final Class<T> type) {
        return new Transformer<T, T>() {
            @Override
            public T transform(T original) {
                List<Transformer<T, T>> transformers = new ArrayList<>();
                transformers.add(PCHUtils.getHeaderToSourceFileTransformer(type));

        e.message == toPlatformLineSeparators("""Found multiple transforms that can produce a variant of <component> with requested attributes:
  - artifactType 'dll'
Found the following transforms:
  - From '<variant1>':
      - With source attributes: artifactType 'jar'
      - Candidate transform(s):
          - Transform '' producing attributes: artifactType 'dll'
  - From '<variant2>':

	// requires.
	RequiresExactMatch(field string) (value string, found bool)

	// Transform returns a new copy of the selector after TransformFunc has been
	// applied to the entire selector, or an error if fn returns an error.
	// If for a given requirement both field and value are transformed to empty
	// string, the requirement is skipped.
	Transform(fn TransformFunc) (Selector, error)

    }

    @ToBeFixedForIsolatedProjects(because = "allprojects, extensive cross-project access")
    def "artifact transforms are sensitive to empty directories by default"() {
        // Immutable artifact transforms are cached to the GradleUserHome,
        // so to avoid flakiness we need to request own GradleUserHome
        executer.requireOwnGradleUserHomeDir()

== Invalid use of an output property on an artifact transforms

This error indicates that you have annotated a property of an artifact transform with an output annotation, which is not the correct way to register outputs for artifact transforms.

To fix this problem, you must remove the property and use the `TransformOutputs` parameter instead.

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