}

    def "throws exception when single values are not found"() {
        when:
        checkValidCombinations(["nonexistent1", "nonexistent2"])

        then:
        final ex = thrown(IllegalArgumentException)
        ex.message.startsWith("Requested requirements [nonexistent1, nonexistent2] were not in the list of accepted combinations.")
    }

     *     <li>Resolvers based on the entries of the `pluginRepositories` block</li>
     *     <li>{@link org.gradle.plugin.use.resolve.internal.ArtifactRepositoriesPluginResolver} - from Gradle Plugin Portal if no `pluginRepositories` were defined</li>
     * </ol>
     * <p>
     * This order is optimized for both performance and to allow resolvers earlier in the order
     * to mask plugins which would have been found later in the order.
     */

     * Reads the specified number of bytes into the given buffer. Can read any byte values that were written using one of the raw byte methods on {@link Encoder}, such as {@link
     * Encoder#writeBytes(byte[])} or {@link Encoder#getOutputStream()}
     *
     * @throws EOFException when the end of the byte stream is reached before the specified number of bytes were read.
     */

        val problem = problemFactory.problem {
            text("Project ")
            reference(referrerProject.identityPath.toString())
            text(" cannot access the tasks in the task graph that were created by other projects")
        }.exception { message ->
            // As the exception message is not used for grouping, we can safely add the exact task name to it:

                    String.format(typeValidationContext.getProblems().size() == 1
                            ? "A problem was found with the %s plugin."
                            : "Some problems were found with the %s plugin.",
                        getPluginObjectDisplayName(plugin)),
                    typeValidationContext.getProblems().stream()

    private final Daemon daemon;
    private final ExplainingSpec<DaemonContext> compatibilitySpec;

    public static final String EXPIRATION_REASON = "other compatible daemons were started";

    CompatibleDaemonExpirationStrategy(Daemon daemon, ExplainingSpec<DaemonContext> compatibilitySpec) {
        this.daemon = daemon;
        this.compatibilitySpec = compatibilitySpec;
    }

            pos = matcher.end();
        }
        builder.append(Pattern.quote(name.substring(pos)));
        return Pattern.compile(builder.toString());
    }

    /**
     * Returns all matches, when there were more than 1.
     *
     * @return The matches. Returns an empty set when there are no matches.
     */
    public Set<String> getMatches() {
        return matches;
    }

    /**

        DeprecationLogger.reportSuppressedDeprecations()

        then:
        def events = outputEventListener.events
        events.size() == 1
        events[0].message == """
Deprecated Gradle features were used in this build, making it incompatible with ${DefaultGradleVersion.current().nextMajorVersion}.

        val messages = formattedMismatches.map {
            "API changes in file '${it.key.name}' should be in alphabetical order (by type and member), yet these changes were not:\n" +
                "$formattedMismatches\n"
        }.joinToString(separator = "\n")

        return "$messages\nTo automatically alphabetize these changes run: 'gradlew :architecture-test:sortAcceptedApiChanges'"
    }

            throw new GradleException(prepareMessage(output, startupArgs));
        }
        String[] lines = output.split("\n");
        //Assuming that the diagnostics were printed out to the last line. It's not bullet-proof but seems to be doing fine.
        String lastLine = lines[lines.length - 1];
        return startupCommunication.readDiagnostics(lastLine);
    }