then:
        project.projectNatures.size() == 1
        project.projectNatures[0].id.contains('javanature')
        project.buildCommands.size() == 1
        project.buildCommands[0].name.contains('javabuilder')
    }

    def "EclipseProject attributes defined"() {
        buildFile <<
        """apply plugin: 'java'
           apply plugin: 'eclipse'
           import org.gradle.plugins.ide.eclipse.model.BuildCommand

    static final def JAVA_BUILD_COMMANDS = ['org.eclipse.jdt.core.javabuilder']
    static final def WTP_BUILD_COMMANDS = ['org.eclipse.wst.common.project.facet.core.builder', 'org.eclipse.wst.validation.validationbuilder']

    def "Eclipse wtp natures are added to web projects"() {
        given:

        """<?xml version="1.0" encoding="UTF-8"?>
<projectDescription>
  <name>org.gradle.toolingapi</name><comment/><projects/>
  <buildSpec>
    <buildCommand><name>org.eclipse.jdt.core.javabuilder</name><arguments/></buildCommand>
    <buildCommand><name>org.eclipse.pde.ManifestBuilder</name><arguments/></buildCommand>
    <buildCommand><name>org.eclipse.pde.SchemaBuilder</name><arguments/></buildCommand>
  </buildSpec>

    void assertHasNatures(String... natures) {
        assert this.project.natures.nature*.text() == natures as List
    }

    void assertHasJavaFacetBuilders() {
        assertHasBuilders("org.eclipse.jdt.core.javabuilder",
            "org.eclipse.wst.common.project.facet.core.builder",
            "org.eclipse.wst.validation.validationbuilder"
        )
    }

    void assertHasBuilders(String... builders) {

     * For example, if the project applies the 'java' plugin the result will contain the
     * {@code "org.eclipse.jdt.core.javabuilder"} build command. Note, that the exact list of automatically
     * added build commands is not part of the API and can vary between Gradle releases.
     * <p>

            @Override
            public void execute(JavaBasePlugin javaBasePlugin) {
                if (!project.getPlugins().hasPlugin(EarPlugin.class)) {
                    projectModel.buildCommand("org.eclipse.jdt.core.javabuilder");
                }

                projectModel.natures("org.eclipse.jdt.core.javanature");
                convention.map("linkedResources", new Callable<Set<Link>>() {
                    @Override

	// if s.bullet == 0 {
	// 	buf.WriteString(s.prefix)
	// }
	b.Text.printMarkdown(buf, s)
}

type paraBuilder struct {
	text  []string
	table *tableBuilder
}

func (b *paraBuilder) extend(p *parseState, s line) (line, bool) {
	return s, false
}

func (b *paraBuilder) build(p buildState) Block {
	if b.table != nil {
		return b.table.build(p)
	}

	s := strings.Join(b.text, "\n")

     * or specifying the lack thereof ({@link JarBuilder#withoutManifest()}.
     */
    static class JarBuilder {
        /**
         * @see org.gradle.api.internal.file.archive.ZipCopyAction#CONSTANT_TIME_FOR_ZIP_ENTRIES
         */

}

func (p *parseState) doneBlock(b Block) {
	p.trimStack(p.lineDepth + 1)
	ob := &p.stack[len(p.stack)-1]
	ob.inner = append(ob.inner, b)
}

func (p *parseState) para() *paraBuilder {
	if b, ok := p.stack[len(p.stack)-1].builder.(*paraBuilder); ok {
		return b
	}
	return nil
}

func (p *parseState) closeBlock() Block {
	b := &p.stack[len(p.stack)-1]
	if b.builder == nil {

        """
        file("$folderName/settings.gradle") << "rootProject.name = 'included'"
        settingsFile << """
            includeBuild("./$folderName")
        """
    }

    def javaBuild(String projectName = "included", Action<String> init) {
        file("$projectName/build.gradle") << """
            plugins {
                id("java-library")
            }
            group = "org.test"