import org.slf4j.Logger
import spock.lang.Specification

class OutputEventListenerBackedLoggerDefaultConfigurationTest extends Specification {

    @Rule RedirectStdOutAndErr outputs = new RedirectStdOutAndErr()

    String getOut() {
        outputs.stdOut
    }

    String getErr() {
        outputs.stdErr
    }

    def context

    Logger logger() {
        if (context == null) {

        // Value taken from p1
        // ----------------------------------------------------------------------

        assertEquals("scm-url/p2/p3/p4", p4.getScm().getUrl());

        // ----------------------------------------------------------------------
        // Value taken from p4
        // ----------------------------------------------------------------------

        if (model == null) {
            return null;
        }

        Model.Builder builder = Model.newBuilder(model);
        builder.url(normalize(model.getUrl()));

        Scm scm = model.getScm();
        if (scm != null) {
            builder.scm(Scm.newBuilder(scm)
                    .url(normalize(scm.getUrl()))
                    .connection(normalize(scm.getConnection()))

        this.jvm = jvm;
        this.effectiveJvmOptions = effectiveJvmOptions;
    }

    public JvmOptions getJvmOptions() {
        return effectiveJvmOptions;
    }

    public JavaInfo getJvm() {
        return jvm;
    }

    public boolean isLowMemoryProcess() {
        return Runtime.getRuntime().maxMemory() <= 64L * 1024 * 1024; // 64MB is our default for a launcher process
    }

        artifact(classifier: "javadoc")
        return this
    }

    MavenHttpModule withNoPom() {
        backingModule.withNoPom()
        return this
    }

    PomHttpArtifact getPom() {
        return new PomHttpArtifact(server, uriPath, backingModule)
    }

    @Override
    HttpArtifact getModuleMetadata() {
        return getArtifact(type: 'module')
    }

          new_results.push_back(element_op.getOut());
        }
      }
    }
    for (auto res : llvm::zip(op->getResults(), new_results)) {
      auto casted = builder.create<CastOp>(
          op->getLoc(), std::get<0>(res).getType(), std::get<1>(res));
      std::get<0>(res).replaceAllUsesWith(casted.getOut());
    }

    // Copy all the unregisted attributes to the new op.

    @Override
    public ModuleArtifact getArtifact(String relativePath) {
        return backingModule.getArtifact(relativePath);
    }

    @Override
    public ModuleArtifact getPom() {
        return backingModule.getPom();
    }

    @Override
    public ModuleArtifact getModuleMetadata() {
        return backingModule.getModuleMetadata();
    }

    @Override
    public String getArtifactId() {

        super(backingModule)
        this.bucket = bucket
        this.server = server
        this.backingModule = backingModule
        this.repositoryPath = repositoryPath
    }

    GcsArtifact getPom() {
        return new GcsArtifact(server, pomFile, repositoryPath, bucket)
    }

    GcsArtifact getModuleMetadata() {
        return new GcsArtifact(server, backingModule.moduleMetadata.file, repositoryPath, bucket)

        }
    }

    class SummaryRecord {
        final Node recordNode

        SummaryRecord(Node recordNode) {
            this.recordNode = recordNode
        }

        int getRun() {
            recordNode.RUN.text() as int
        }

        int getSucceeded() {
            recordNode.SUCCEEDED.text() as int
        }

        int getFailed() {

import org.gradle.api.tasks.TaskProvider;

public interface MavenPublicationInternal extends MavenPublication, PublicationInternal<MavenArtifact> {

    @Override
    MavenPomInternal getPom();

    void setPomGenerator(TaskProvider<? extends Task> pomGenerator);

    void setModuleDescriptorGenerator(TaskProvider<? extends Task> moduleMetadataGenerator);