static class B extends RuleSource {}

        static class A extends RuleSource {}
    }

    def "find model rule sources - #clazz"() {
        expect:
        detector.getDeclaredSources(clazz).toList() == expected

        where:
        clazz         | expected
        String        | []
        HasOneSource  | [HasOneSource.Source]
        HasTwoSources | [HasTwoSources.SourceOne, HasTwoSources.SourceTwo]

import org.gradle.internal.SystemProperties
import org.gradle.internal.logging.text.TestStyledTextOutputFactory
import org.gradle.util.Path
import spock.lang.Specification

import static org.gradle.util.internal.WrapUtil.toList

class DryRunBuildExecutionActionTest extends Specification {
    private static final String EOL = SystemProperties.instance.lineSeparator
    def delegate = Mock(BuildWorkExecutor)

    }

    public List<ReportConfiguration> getPurelyConsumableConfigs() {
        return allConfigs.stream().filter(ReportConfiguration::isPurelyConsumable).collect(Collectors.toList());
    }

    public Optional<ReportConfiguration> getConfigNamed(String configName) {
        return allConfigs.stream().filter(config -> config.getName().equals(configName)).findFirst();
    }

						" length != 3: %v", name)
				}
				toList := strings.Split(toPat, ":")
				if len(toList) != 3 {
					return nil, fmt.Errorf("failed to split the rename-to string,"+
						" length != 3: %v", toPat)
				}

				// Use the old name if toList has "*" or ""
				// Otherwise, use the name in toList
				newList := make([]string, 3)
				for i := range toList {
					if toList[i] == "" || toList[i] == "*" {

        return containingType + "#" + propertyName;
    }

    private static List<UpgradedProperty> toPropertyEntries(Map<String, List<CallInterceptionRequest>> requests) {
        return requests.entrySet().stream()
            .sorted(Map.Entry.comparingByKey())
            .map(e -> toPropertyEntry(e.getValue()))
            .collect(Collectors.toList());
    }

    @SuppressWarnings("OptionalGetWithoutIsPresent")

    }

    @Override
    public void save(ArchRule rule, List<String> violations) {
        List<String> violationsWithoutLineNumbers = violations.stream()
            .map(it -> it.replaceAll("\\.(java|kt):\\d+", ".$1:0"))
            .collect(toList());
        delegate.save(rule, violationsWithoutLineNumbers);
    }

    @Override
    public List<String> getViolations(ArchRule rule) {

        List<JvmBytecodeCallInterceptor.Factory> factories = provider.getInterceptorFactories().stream()
            .filter(filter::matches)
            .collect(Collectors.toList());
        return new JvmBytecodeInterceptorSet() {
            @Override
            public List<JvmBytecodeCallInterceptor> getInterceptors(MethodVisitor methodVisitor, ClassData classData) {

        Class<?> cls = key.getRawType();

        List<Constructor<?>> constructors = Arrays.asList(cls.getDeclaredConstructors());
        List<Constructor<?>> injectConstructors = constructors.stream()
                .filter(c -> c.isAnnotationPresent(Inject.class))
                .collect(toList());

        List<Method> factoryMethods = Arrays.stream(cls.getDeclaredMethods())

        builder.dependencies(target.getDependencies().stream()
                .map(d -> mergeDependency(d, sourceIterator.next(), sourceDominant, context))
                .collect(Collectors.toList()));
    }

    @Override
    protected void mergeDependency_Exclusions(
            Dependency.Builder builder,
            Dependency target,
            Dependency source,
            boolean sourceDominant,

     *     withInstallations(jvm1, jvm2).run(":task")
     * </pre>
     */
    AbstractIntegrationSpec withInstallations(Jvm jvm, Jvm... rest) {
        return withInstallations([jvm] + rest.toList())
    }

    AbstractIntegrationSpec withInstallations(List<Jvm> jvms) {
        def installationPaths = jvms.collect { it.javaHome.absolutePath }.join(",")
        executer