@Input
                abstract Property<String> getString()

                @TaskAction
                void printText() {
                    println getString().get()
                }
            }

            abstract class StringListTask extends DefaultTask {
                @Input
                abstract ListProperty<String> getStrings()

                @TaskAction
                void printText() {

        schema.getProperty('parent').schema == schema
    }

    @Managed
    interface SomeType {
        String getReadOnlyString()

        List<String> getStrings()
        void setStrings(List<String> strings)
    }

    @Managed
    interface Person {
        Person getParent()
    }

        schema.properties.isEmpty()
    }

    static abstract class SomeRules extends RuleSource {
        abstract String getReadOnlyString()
        abstract List<String> getStrings()
        abstract void setStrings(List<String> strings)
    }

    def "assembles schema for RuleSource subtype"() {
        expect:
        def schema = store.getSchema(ModelType.of(SomeRules))

        schema.properties*.name == ['parent']
        schema.getProperty('parent').schema == schema
    }

    interface SomeType {
        String getReadOnlyString()

        List<String> getStrings()
        void setStrings(List<String> strings)
    }

    @UnmanagedStruct
    interface SomeStruct {
        String getReadOnlyString()
    }

    interface Person {
        Person getParent()
    }

    }

    def "can use a mapped value provider"() {
        buildFile """
            abstract class MyTask extends DefaultTask {
                @Input
                abstract ListProperty<String> getStrings()

                @OutputFile
                abstract RegularFileProperty getOutput()

                @TaskAction
                def action() {
                    def outputFile = output.get().asFile

        replaceVisitedExpressionWith(expr);
    }

    @Override
    @SuppressWarnings("unchecked")
    public void visitGStringExpression(GStringExpression expr) {
        replaceAllExprs(expr.getStrings());
        replaceAllExprs(expr.getValues());
    }

    @Override
    public void visitArgumentlistExpression(ArgumentListExpression expr) {
        visitTupleExpression(expr);

                    println "setStrings: " + $.setStrings.keySet()
                  }
                }
              }
            }
        '''

        then:
        succeeds "print"

        and:
        output.contains "mapThings: []"
        output.contains "setThings: []"
        output.contains "setStrings: []"
    }

                        performanceResults.setOperatingSystem(testExecutions.getString(5));
                        performanceResults.setJvm(testExecutions.getString(6));
                        performanceResults.setVcsBranch(testExecutions.getString(7).trim());
                        performanceResults.setVcsCommits(split(testExecutions.getString(8)));

                "@${Managed.name} interface SomeThing { SomeThing getThing() }",
                "@${Managed.name} interface SomeThing { ${ModelSet.name}<SomeThing> getThings() }",
                "@${Managed.name} interface SomeThing { @${Managed.name} static interface Child {}; ${ModelSet.name}<Child> getThings() }",
        ]
    }

    def "does not hold strong reference to a managed #type type"() {
        given:

		m.File, err = getString(p.stringTable, &m.fileX, err)
		m.BuildID, err = getString(p.stringTable, &m.buildIDX, err)
		mappings[m.ID] = m
	}

	functions := make(map[uint64]*Function)
	for _, f := range p.Function {
		f.Name, err = getString(p.stringTable, &f.nameX, err)
		f.SystemName, err = getString(p.stringTable, &f.systemNameX, err)
		f.Filename, err = getString(p.stringTable, &f.filenameX, err)