void setLongPropertyFromInt(Long value)

                Long getLongPropertyFromInteger()
                void setLongPropertyFromInteger(Long value)
            }

            class RulePlugin extends RuleSource {
                @Model
                void createPrimitiveTypes(PrimitiveTypes primitiveTypes) {
                    primitiveTypes.longPropertyFromInt = 123

        class DefaultSomeBinary extends BaseBinarySpec implements SomeBinary {}
        class Rules1 extends RuleSource {
            @ComponentType
            void register(TypeBuilder<SomeBinary> builder) {
                builder.defaultImplementation(DefaultSomeBinary)
            }
        }
        class Rules2 extends RuleSource {
            @ComponentType
            void register(TypeBuilder<SomeBinary> builder) {

                    }
                }
            }
        """
    }

    void withBinaries() {
        withCustomBinaryType()
        buildFile << """
            class ComponentBinaryRules extends RuleSource {
                @ComponentBinaries
                void addBinaries(ModelMap<CustomBinary> binaries, CustomComponent component) {
                    binaries.create("b1", CustomBinary)

            }

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

            class RulePlugin extends RuleSource {
                @Model
                void name(Names names) {
                    assert names == names
                    assert names.name == null

                    names.name = "foo"

        buildScript """
            class Plugin1 {
                static class Rules extends RuleSource {
                    @Model
                    String s1() {
                        "foo"
                    }
                }
            }

            class Plugin2 {
                static class Rules extends RuleSource {
                    @Model
                    String s2() {

              String getValue()
            }

            @Managed
            interface Container {
              ModelMap<Thing> getThings();
            }

            class Rules extends RuleSource {

              @Model
              void container(Container container) {
                container.things.create("a") { value = "1" }
                container.things.create("b") { value = "2" }
              }

    def "can create a top level functional source set with a rule"() {
        buildScript """
        apply plugin: 'language-base'

        class Rules extends RuleSource {
            @Model
            void fss(FunctionalSourceSet sources) {
            }

            @Mutate void printTask(ModelMap<Task> tasks, FunctionalSourceSet sources) {
                tasks.create("printTask") {

            class DefaultCustomLanguageSourceSet extends BaseLanguageSourceSet implements CustomLanguageSourceSet {
                final String data = "foo"
            }

            class TestSuiteTypeRules extends RuleSource {
                @ComponentType
                void registerCustomTestSuiteType(TypeBuilder<CustomTestSuite> builder) {
                    builder.defaultImplementation(DefaultCustomTestSuite)
                }

        given:
        buildScript """

        @Managed
        interface Container {
            $type<String> getItems()
        }

        class Rules extends RuleSource {
            @Model
            void createContainer(Container c) {}

            @Mutate
            void addItems(Container c) {
                c.items.add 'foo'
            }

            @Mutate

            }

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

            class RulePlugin extends RuleSource {
                @Model
                void platform(Platform platform) {
                    platform.operatingSystem.name = "windows"
                }

                @Mutate