val testNameParameterName = "testName"
    val testTaskOptionsParameterName = "testTaskOptions"
    val daemon = true
    applyDefaultSettings(os, arch, buildJvm = BuildToolBuildJvm, timeout = 0)

    // Show all failed tests here, since that is what we are interested in
    failureConditions.supportTestRetry = false

            """
            addSuperInterface(notASub())
            addSuperClass(notASub())
            """.trimIndent()
        )

        assertEquals(2, result.errors.size)
        assertTrue { result.errors.all { it.errorReason is ErrorReason.UnresolvedFunctionCallSignature } }
    }
}


private
abstract class TopLevelForSubtyping {
    @get:Restricted
    abstract var superClassProp: SuperClass

        try {
            return ClassLoader.getSystemClassLoader().loadClass(agentClassName);
        } catch (ClassNotFoundException e) {
            // This typically means that the agent is not loaded at all.
            // For now, this happens when running in a no-daemon mode, or when the Gradle distribution is not available.
            LoggerFactory.getLogger(AgentControl.class).debug("Agent {} is not loaded", agentClassName);

* For new features, the feature should be mentioned in the [Release Notes](platforms/documentation/docs/src/docs/release/notes.md).

Your code needs to run on [all versions of Java that Gradle supports](platforms/documentation/docs/src/docs/userguide/releases/compatibility.adoc) and across all supported operating systems (macOS, Windows, Linux). The [Gradle CI system](http://builds.gradle.org/) will verify this, but here are some pointers that will avoid surprises:

    }

    /**
     * Converts all line separators in the specified string to the specified line separator.
     */
    @Nullable
    public static String convertLineSeparators(@Nullable String str, String sep) {
        return str == null ? null : replaceLineSeparatorsOf(str, sep);
    }

    /**
     * Converts all line separators in the specified non-null string to the Unix line separator {@code \n}.

            .findFirst().orElseThrow(IllegalStateException::new);
    }

    private String suggestDependencyInsight() {
        return "Use the dependencyInsight report with the --all-variants option to view all variants of the ambiguous dependency.  This report is described at " + getDocumentationRegistry().getDocumentationFor("viewing_debugging_dependencies", "sec:identifying_reason_dependency_selection") + ".";
    }

        metadata.selectLegacyConfigurations(fromConfig2, toComponent, resolutionFailureHandler).variants == [toConfig2]
    }

    def "configuration mapping can use wildcard on RHS to select all public configurations"() {
        def resolutionFailureHandler = Stub(ResolutionFailureHandler)
        def toComponent = Stub(ComponentGraphResolveState)
        def fromConfig = Stub(ModuleConfigurationMetadata)

        buildFile << """
            testing {
                suites {
                    test {
                        useJUnit()
                        targets {
                            all {
                                testTask.configure {
                                    doLast {
                                        assert testFramework instanceof ${JUnitTestFramework.canonicalName}

                resolvedProjectConfigurations.add(new ResolvedProjectConfiguration(projectComponentId.getIdentityPath(), node.getMetadata().getName()));
            }
        }
    }

    /**
     * Mark all configurations corresponding to visited project variant nodes as observed.
     */
    public void complete(ConfigurationInternal.InternalState requestedState) {

     * We currently allow a configuration that has been partially observed for resolution to be modified
     * in a beforeResolve callback.
     *
     * To reduce the number of instances of root component metadata we create, we mark all configurations
     * as dirty and in need of re-evaluation when we see certain types of modifications to a configuration.
     *