then:
        3 * repositoryFactory.createMavenRepository() >>> [repo1, repo2, repo3]
        _ * repo1.getName() >> "Maven repo 1"
        _ * repo2.getName() >> "Maven repo 2"
        _ * repo3.getName() >> "Maven repo 3"
        _ * repo1.setName(_)
        _ * repo2.setName(_)
        _ * repo3.setName(_)
        1 * repo1.onAddToContainer(_)
        1 * repo2.onAddToContainer(_)
        1 * repo3.onAddToContainer(_)

        when:
        buildScript '''
            @Managed
            interface Person {
                String getName()
                void setName(String name)
            }

            @Managed
            interface Names {
                String getName()
                void setName(String name)
            }

            class RulePlugin extends RuleSource {
                @Model

- Method getZ() is not a valid method: it is both implemented by the view '${getName(TypeWithImplementedProperty)}' and the delegate type '${getName(DelegateTypeWithImplementedProperty)}'
- Method setZ(int) is not a valid method: it is both implemented by the view '${getName(TypeWithImplementedProperty)}' and the delegate type '${getName(DelegateTypeWithImplementedProperty)}'"""
    }

            interface Platform {
                OperatingSystem getOperatingSystem()
            }

            @Managed
            interface OperatingSystem {
                String getName()
                void setName(String name)
            }

            class RulePlugin extends RuleSource {
                @Model
                void platform(Platform platform) {

        variant.setDescription("Binary data file containing results of Jacoco test coverage reporting for the " + suite.getName() + " Test Suite's " + target.getName() + " target.");
        variant.setVisible(false);

        project.getComponents().withType(CppApplication.class).all(cppApplication -> {
            DefaultVisualStudioProject vsProject = extension.getProjectRegistry().createProject(project.getName(), cppApplication.getName());
            vsProject.getSourceFiles().from(cppApplication.getCppSource());
            vsProject.getHeaderFiles().from(cppApplication.getHeaderFiles());

                identifier = ResolvedCoordinates.create(dependency.getGroup(), dependency.getName(), null);
            }
            return moduleDependencyCoordinatesFor(identifier, ((ExternalDependency) dependency).getVersionConstraint());
        } else {
            throw new UnsupportedOperationException("Unsupported dependency type: " + dependency.getClass().getName());
        }
    }

            .forEach(configuration -> getOrConvert(configuration, uniquenessReport, project, convertedConfigurations));

        return new ConfigurationReportModel(project.getName(),
            convertedConfigurations.values().stream().sorted(Comparator.comparing(ReportConfiguration::getName)).collect(Collectors.toList()),
            attributesWithCompatibilityRules, attributesWithDisambiguationRules);
    }

        return testedBinary.getTargetMachine().getOperatingSystemFamily().getName().equals(testExecutable.getTargetMachine().getOperatingSystemFamily().getName())
                && testedBinary.getTargetMachine().getArchitecture().getName().equals(testExecutable.getTargetMachine().getArchitecture().getName())
                && !testedBinary.isOptimized()

            }

            @Managed
            interface Thing {
                String getName()
                void setName(String name)
                Address getAddress()
            }

            @Managed
            interface Address {
                String getName()
                void setName(String name)
            }

            class MyPlugin extends RuleSource {
                @Model