import java.lang.reflect.Modifier
import mockwebserver3.MockWebServer
import mockwebserver3.junit5.StartStop
import org.junit.jupiter.api.extension.BeforeAllCallback
import org.junit.jupiter.api.extension.BeforeEachCallback
import org.junit.jupiter.api.extension.ExtensionContext
import org.junit.jupiter.api.extension.ExtensionContext.Namespace
import org.junit.platform.commons.support.AnnotationSupport.findAnnotatedFields

        GradleDocumentationExtension extension = project.getExtensions().getByType(GradleDocumentationExtension.class);
        generateJavadocs(project, layout, tasks, extension);
    }

    private void generateJavadocs(Project project, ProjectLayout layout, TaskContainer tasks, GradleDocumentationExtension extension) {
        Javadocs javadocs = extension.getJavadocs();

 * <p>
 * It provides information about the file type (or extension) of the associated artifact,
 * its default classifier, and how the artifact will be used in the build when creating
 * class paths or module paths.
 * <p>
 * For example, the type {@code java-source} has a {@code jar} extension and a
 * {@code sources} classifier. The artifact and its dependencies should be added
 * to the build path.

 */
package org.apache.maven.cling.extensions;

import org.apache.maven.api.cli.extensions.CoreExtension;
import org.apache.maven.extension.internal.CoreExtensionEntry;

/**
 * Represents a core extension that has been selected to be loaded.
 * @param coreExtension The extension configuration entry with location tracking.
 * @param entry The loaded entry with descriptor.
 */

    <snapshotVersions>
      <snapshotVersion>
        <classifier>classifierA</classifier>
        <extension>jar</extension>
        <value>07.20.3-20120809.112124-88</value>
        <updated>20120809112124</updated>
      </snapshotVersion>
      <snapshotVersion>
        <classifier>classifierB</classifier>
        <extension>jar</extension>
        <value>07.20.3-20120809.112920-97</value>
        <updated>20120809112920</updated>

import assertk.assertThat
import assertk.assertions.hasMessage
import kotlin.test.assertFailsWith
import org.junit.jupiter.api.Test
import org.junit.jupiter.api.extension.BeforeEachCallback
import org.junit.jupiter.api.extension.ExtensionContext
import org.junit.jupiter.api.extension.RegisterExtension

class OkHttpClientTestRuleTest {
  lateinit var extensionContext: ExtensionContext

  @RegisterExtension @JvmField

                ArtifactHandler handler =
                        container.lookup(ArtifactHandlerManager.class).getArtifactHandler(type);
                assertEquals(handler.getExtension(), extension, type + " extension");
                // Packaging/Directory is Maven1 remnant!!!
                // assertEquals(handler.getPackaging(), packaging, type + " packaging");

import org.apache.maven.api.xml.XmlService;

/**
 * Creates an extension descriptor from some XML stream.
 *
 */
public class ExtensionDescriptorBuilder {

    /**
     * @since 3.3.0
     */
    public String getExtensionDescriptorLocation() {
        return "META-INF/maven/extension.xml";
    }

    /**
     * Extracts the extension descriptor (if any) from the specified JAR file.
     *

 *
 * When the target method of an extension functions is de-incubated, removing at a later point is a breaking change.
 * The corresponding extension function gets automatically de-incubated during source generation.
 * But the same applies to the implicit file class, and it has to be de-incubated when any
 * extension function it contains is de-incubated.
 */
private

 * information among plugins, is this more like an extension point - do we need a sort of bus for
 * application data - do we need a dictionary for our applications like Apple does. We could easily
 * hook into this and this is the model we need to follow - how many of our REST services do not map
 * directory to a method in the application interface?
 *
 * - research extension points versus plugins
 *