<dependencies>
    <dependency>
      <groupId>org.apache.maven</groupId>
      <artifactId>maven-api-meta</artifactId>
    </dependency>
  </dependencies>

  <build>
    <plugins>
      <plugin>
        <groupId>org.codehaus.modello</groupId>
        <artifactId>modello-maven-plugin</artifactId>
        <executions>
          <execution>
            <id>plugin</id>

 * Throwing this exception causes a "BUILD ERROR" message to be displayed.
 *
 */
public class MojoExecutionException extends AbstractMojoExecutionException {
    /**
     * Construct a new <code>MojoExecutionException</code> exception providing the source and a short and long message:
     * these messages are used to improve the message written at the end of Maven build.
     *
     * @param source
     * @param shortMessage

         * The class realm for the public API of the Maven core.
         */
        Core,

        /**
         * A class realm for a project to aggregates its build extensions.
         */
        Project,

        /**
         * A class realm for a build extension.
         */
        Extension,

        /**
         * A class realm for a plugin.
         */
        Plugin,
    }

    /**

                ProtoLookup.builder().addMapping(ClassWorld.class, classWorld).build());
    }

    @Override
    protected EncryptInvokerRequest parseArguments(String[] args) throws ParserException, IOException {
        return new DefaultEncryptParser()
                .parse(ParserRequest.mvnenc(args, new ProtoLogger(), new JLineMessageBuilderFactory())
                        .build());
    }

      HttpLoggingInterceptor.androidLogging(tag = "testHttpLoggingInterceptor").apply {
        level = HttpLoggingInterceptor.Level.BASIC
      }

    val client = clientBuilder.addInterceptor(interceptor).build()

    try {
      client.newCall(request).execute()
    } catch (uhe: UnknownHostException) {
      // expected
    }

    val logs = ShadowLog.getLogsForTag("testHttpLoggingInterceptor")

import gradlebuild.buildutils.tasks.UpdateInitPluginTemplateVersionFile

tasks {
    register<UpdateInitPluginTemplateVersionFile>("updateInitPluginTemplateVersionFile") {
        group = "Build init"
        libraryVersionFile = layout.projectDirectory.file(
            "src/main/resources/org/gradle/buildinit/tasks/templates/library-versions.properties"
        )
    }

import java.util.function.Predicate;

import static java.util.stream.Collectors.toSet;

/**
 * Container for storing the request from the user to activate or de-activate certain profiles and optionally fail the
 * build if those profiles do not exist.
 */
public class ProfileActivation {
    private final Map<String, ActivationSettings> activations = new HashMap<>();

    /**
     * Mimics the pre-Maven 4 "active profiles" list.

        val sortingResult = run(":sortAcceptedApiChanges").build()
        assertEquals(TaskOutcome.SUCCESS, sortingResult.task(":sortAcceptedApiChanges")!!.outcome)

        val finalVerifyResult = run(":verifyAcceptedApiChangesOrdering").build()
        assertEquals(TaskOutcome.SUCCESS, finalVerifyResult.task(":verifyAcceptedApiChangesOrdering")!!.outcome)

        this.body(body)
        this.socketPolicy = socketPolicy
      },
  )

  private constructor(builder: Builder) {
    this.status = builder.status
    this.headers = builder.headers.build()
    this.trailers = builder.trailers.build()
    this.body = builder.body
    this.streamHandler = builder.streamHandler
    this.webSocketListener = builder.webSocketListener
    this.inTunnel = builder.inTunnel

    //                                                                               Build
    //                                                                               =====

    @Override
    public SearchRequestBuilder build(SearchRequestBuilder builder) {
        if (_conditionQuery != null) {
            QueryBuilder queryBuilder = _conditionQuery.getQuery();