/**
     * 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.
     */
    boolean canTransform(Object[] args);

@ThreadSafe
public interface TransformInvocationFactory {
    /**
     * Returns an invocation which allows invoking the actual transformer.
     */
    Deferrable<Try<ImmutableList<File>>> createInvocation(
        Transform transform,
        File inputArtifact,
        TransformDependencies dependencies,
        TransformStepSubject subject,
        InputFingerprinter inputFingerprinter);

        assertEquals("SourceTest.java", mapper.transform("Source.java"));
        assertEquals("SecondTest.java", mapper.transform("Second.java"));
    }

    @Test
    public void testRenameNoMatch() {
        RegExpNameMapper mapper = new RegExpNameMapper("(.+).java", "$1Test.java");
        String noMatch = "NoMatch";
        assertEquals(noMatch, mapper.transform(noMatch));
    }

        action.execute(details);

        then:
        1 * transformer.transform('b') >> 'c'
        1 * details.setRelativePath(new RelativePath(true, "a", "c"))
    }

    def 'does not transform last segment of path with null input'() {
        when:
        action.execute(details);

        then:
        1 * transformer.transform('b') >> null
        0 * details.setRelativePath(new RelativePath(true, "a", "b"))
    }

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package gradlebuild.binarycompatibility

import groovy.transform.Immutable
import groovy.transform.ToString

@Immutable @ToString
class AcceptedApiChange {
    String type
    String member
    String acceptation
    List<String> changes

    ApiChange toApiChange() {

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.tooling.events.transform;

import org.gradle.tooling.events.FinishEvent;

/**
 * An event that informs about a transform operation having finished its execution.
 *
 * @since 5.1
 */
public interface TransformFinishEvent extends TransformProgressEvent, FinishEvent {
    @Override

 * limitations under the License.
 */

package org.gradle.api.internal.artifacts.transform;

/**
 * Companion type to {@link TransformStepNode} that knows how to compute extra dependent nodes aside from the to be transformed artifact.
 * Instances of this type should not be shared beyond a single transform chain.
 *
 * @see TransformUpstreamDependenciesResolverFactory
 */

#
# Usage:
#    make

all: transform

# .base -> .in pattern rule
%.in: %.base
	sed -f transforms2salt.sed $< | sed s/__SOURCE_FILENAME__/$</g > $@

# .base -> .sed pattern rule
%.sed: %.base
	sed -f transforms2sed.sed $<  | sed s/__SOURCE_FILENAME__/$</g > $@

transform: kube-dns.yaml.in kube-dns.yaml.sed

 * limitations under the License.
 */

package org.gradle.api.internal.initialization.transform.utils;

import org.gradle.api.internal.initialization.transform.InstrumentationArtifactMetadata;
import org.gradle.api.internal.initialization.transform.InstrumentationDependencyAnalysis;

import java.io.File;
import java.util.Map;
import java.util.Set;

    }

    public static InternalTransformer<ArgWriter, PrintWriter> unixStyleFactory() {
        return new InternalTransformer<ArgWriter, PrintWriter>() {
            @Override
            public ArgWriter transform(PrintWriter original) {
                return unixStyle(original);
            }
        };
    }

    /**