class TransformedClassPathTest extends Specification {
    def "transformed jars are returned when present"() {
        given:
        TransformedClassPath cp = transformedClassPath("original.jar": "transformed.jar")

        expect:
        cp.findTransformedEntryFor(file("original.jar")) == file("transformed.jar")
    }

    def "transformed jars are returned in the list of transformed files"() {
        given:

        Set<File> thisClassPathFiles = ImmutableSet.copyOf(originalClassPath.getAsFiles());
        mergedTransforms.putAll(transforms);
        for (Map.Entry<File, File> appendedTransform : classPath.transforms.entrySet()) {
            // If the file is already present on this classpath, it keeps its transform (or lack thereof).

    /**
     * Returns the subject of this transform operation.
     */
    SubjectDescriptor getSubject();

    /**
     * Returns the dependencies (other transforms and tasks) of this transform operation.
     */
    Set<? extends OperationDescriptor> getDependencies();

    /**
     * Describes the transformer of a transform operation.
     *
     * @since 5.1
     */
    interface TransformerDescriptor {

Jiyoun (Jen) Ha <******@****.***> 1708476873 -0800

        Action<XmlProvider> elementAction = Mock()
        Action<XmlProvider> stringAction2 = Mock()
        transformer.addAction(stringAction)
        transformer.addAction(elementAction)
        transformer.addAction(nodeAction)
        transformer.addAction(stringAction2)

        when:
        def result = transformer.transform('<root/>')

        then:
        stringAction.execute(_) >> { XmlProvider provider ->

        spec.optimized >> optimize

        expect:
        def args = transformer.transform(spec)
        args.containsAll(expected)

        where:
        debug | optimize | expected
        true  | false    | ["/Zi"]
        false | true     | ["/O2"]
        true  | true     | ["/Zi", "/O2"]
    }

    def "transforms system header and include args correctly"() {
        def spec = Stub(NativeCompileSpec)

// Transform.
func (c Caser) Reset() { c.t.Reset() }

// Transform implements the transform.Transformer interface and transforms the
// given input to the case form implemented by c.
func (c Caser) Transform(dst, src []byte, atEOF bool) (nDst, nSrc int, err error) {
	return c.t.Transform(dst, src, atEOF)
}

// Span implements the transform.SpanningTransformer interface.

/**
 * Potentially transforms arguments to call a method with.
 */
public interface MethodArgumentsTransformer {

    /**
     * Transforms an argument list to call a method with.
     *
     * May return {@code args} if no transform is necessary.
     */
    Object[] transform(CachedClass[] types, Object[] args);

    /*
     * Returns Whether the transformer can transform
     * these arguments at all.

    public MappingProvider(@Nullable Class<OUT> type, ProviderInternal<? extends IN> provider, Transformer<? extends OUT, ? super IN> transformer) {
        super(type, provider, transformer);
    }

    @Override
    public boolean calculatePresence(ValueConsumer consumer) {
        // Rely on MappingProvider contract with regard to the transform always returning value
        try (EvaluationContext.ScopeContext ignored = openScope()) {

        def outputJar = testDir.file("transformed.jar")
        return new JarTestFixture(transform(factory, originalJar, outputJar), 'UTF-8', null, /* checkManifest */ false)
    }

    private TestFile transformDirectory(TransformFactoryType factory, File originalDir) {
        def outputDir = testDir.file("transformed")
        return new TestFile(transform(factory, originalDir, outputDir))
    }