import org.apache.maven.model.building.ModelBuildingException;
import org.apache.maven.project.MavenProject;
import org.eclipse.aether.RepositorySystemSession;

/**
 * Transformed artifact is derived with some transformation from source artifact.
 *
 * @since TBD
 */
class TransformedArtifact extends DefaultArtifact {

    private static final int SHA1_BUFFER_SIZE = 8192;

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * Marker annotation attached to rule block closures at compile time to indicate they have been transformed.
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface RulesBlock {

    /**
     * <p>Expands property references in each file as it is copied. More specifically, each file is transformed using
     * Groovy's {@link groovy.text.SimpleTemplateEngine}. This means you can use simple property references, such as
     * <code>$property</code> or <code>${property}</code> in the file. You can also include arbitrary Groovy code in the

        Model actual = transform(initial);
        assertTrue(equalsDeep(expected, actual));
    }

    Model transform(Model model) {
        Model transformed = model.clone();
        new BuildModelSourceTransformer().transform(pomFile, context, transformed);
        return transformed;
    }

    public static boolean equalsDeep(Object m1, Object m2) {
        try {
            if (m1 == m2) {
                return true;

    ImmutableAttributes getToAttributes();

    /**
     * Whether the transformer requires dependencies of the transformed artifact to be injected.
     */
    boolean requiresDependencies();

    /**
     * Whether the transformer requires {@link InputChanges} to be injected.
     */
    boolean requiresInputChanges();

    /**
     * Whether the transformer is cacheable.
     */
    boolean isCacheable();

        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        InputStream transformed = filterChain.transform(new ByteArrayInputStream(input.getBytes(charset.name())));
        // We read byte-by-byte to trigger edge cases in the downstream implementations.
        int read;
        while ((read = transformed.read()) != -1) {
            baos.write(read);
        }

 */

package org.gradle.model.dsl.internal.transform;

import org.gradle.model.dsl.internal.inputs.PotentialInputs;

import javax.annotation.Nullable;

/**
 * Implemented by transformed rules closure.
 */
public interface TransformedClosure {
    /**
     * Returns the input references for this closure.
     */
    InputReferences inputReferences();

    /**

 * 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
 */
public interface TransformUpstreamDependenciesResolver {
    /**

import org.gradle.api.artifacts.component.ModuleComponentSelector;

/**
 * Represents dependency information as stored in an external descriptor file (POM or IVY.XML).
 * This information is able to be transformed into a `ModuleDependencyMetadata` instance.
 */
public abstract class ExternalDependencyDescriptor {

    public abstract ModuleComponentSelector getSelector();

    public abstract boolean isOptional();

     *
     * @param problem the problem to transform
     * @param id the operation id associated with the problem
     * @return the transformed problem
     */
    Problem transform(Problem problem, OperationIdentifier id);