?: return None

            return when (methodJsonNode.get("name")?.asText()) {
                null -> None
                None::class.simpleName -> None
                TestDistribution::class.simpleName -> TestDistribution
                TestDistributionAlpine::class.simpleName -> TestDistributionAlpine

private
fun makePropagatedEnvironment(): MutableMap<String, String> {
    val result = HashMap<String, String>()
    for (key in propagatedEnvironmentVariables) {
        val value = System.getenv(key)
        if (value != null) {
            result[key] = value
        }
    }
    return result

 *
 */
public class NoGoalSpecifiedException extends Exception {

    /**
     * Creates a new exception.
     *
     * @param message The detail message, may be {@code null}.
     */
    public NoGoalSpecifiedException(String message) {
        super(message);
    }

 */
package org.apache.maven.api.annotations;

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

/**
 * The annotated element can be {@code null}.
 *
 * @see Nonnull
 * @since 4.0.0
 */
@Experimental
@Documented
@Retention(RetentionPolicy.RUNTIME)

        List<MavenOptions> o = options.stream().filter(Objects::nonNull).toList();
        if (o.isEmpty()) {
            throw new IllegalArgumentException("No options specified (or all were null)");
        } else if (o.size() == 1) {
            return o.get(0);
        } else {
            return new LayeredMavenOptions<>(o);
        }
    }

    protected LayeredMavenOptions(List<O> options) {

        val fileName = artifact.get().asFile.name
        val artifactName = extractArtifactName(fileName)
        val classesFilter = keepClassesByArtifacts[artifactName]
        if (classesFilter != null) {
            val nameWithoutExtension = Files.getNameWithoutExtension(fileName)
            minify(artifact.get().asFile, classesFilter, outputs.file("$nameWithoutExtension-min.jar"))
        } else {

        Assertions.assertEquals(TaskOutcome.SUCCESS, result.task(":verifyAcceptedApiChangesOrdering")!!.outcome)
    }

    protected
    fun assertHasMisorderedChanges(changes: List<Change>? = null) {
        val standardError = StringWriter()
        run(":verifyAcceptedApiChangesOrdering")
            .forwardStdError(standardError)
            .buildAndFail()

        return new ProjectModelResolver(
                repoSession,
                null,
                getContainer().lookup(RepositorySystem.class),
                getContainer().lookup(RemoteRepositoryManager.class),
                this.getRemoteRepositories(),
                ProjectBuildingRequest.RepositoryMerging.REQUEST_DOMINANT,
                null);
    }

                                "anyOf": [{"type": "integer"}, {"type": "null"}],
                                "title": "Id",
                            },
                            "name": {"type": "string", "title": "Name"},
                            "age": {
                                "anyOf": [{"type": "integer"}, {"type": "null"}],
                                "title": "Age",
                            },

        is JApiBehavior -> this.getjApiClass()
        else -> error("Unsupported japicmp member type '${this::class}'")
    }


internal
val JApiClass.isKotlin: Boolean
    get() = newClass.orElse(null)?.isKotlin ?: false


internal
val JApiClass.simpleName: String
    get() = fullyQualifiedName.substringAfterLast(".")


internal
val JApiClass.packagePath: String
    get() = packageName.replace(".", "/")