projectFile.projectConfigurations.values().each {
            assert it.macros == "TEST;foo=bar"
            assert it.includePath == filePath("src/main/headers")
            assert it.buildCommand.endsWith("gradle\" :install${it.name.capitalize()}")
            assert it.outputFile == OperatingSystem.current().getExecutableName("build/install/main/${it.name.toLowerCase()}/lib/app")
        }

        and:

    @Override
    public void setNatures(List<String> natures) {
        delegate.setNatures(natures);
    }

    @Override
    public List<BuildCommand> getBuildCommands() {
        return delegate.getBuildCommands();
    }

    @Override
    public void setBuildCommands(List<BuildCommand> buildCommands) {
        delegate.setBuildCommands(buildCommands);
    }

    @Override
    public Set<Link> getLinkedResources() {

                    @Override
                    public boolean apply(BuildCommand buildCommand) {
                        return buildCommand.getName().equals("org.eclipse.jdt.core.javabuilder");
                    }

                }), new BuildCommand("org.scala-ide.sdt.core.scalabuilder"));

        given:
        buildFile << """
            apply plugin: 'eclipse'
            eclipse {
                project {
                    buildCommand 'buildCommandWithoutArguments'
                    buildCommand 'buildCommandWithArguments', argumentOneKey: "argumentOneValue", argumentTwoKey: "argumentTwoValue"
                }
            }
        """

import org.junit.Rule
import spock.lang.Specification

class ProjectTest extends Specification {
    def static final CUSTOM_REFERENCED_PROJECTS = ['refProject'] as LinkedHashSet
    def static final CUSTOM_BUILD_COMMANDS = [new BuildCommand('org.eclipse.jdt.core.scalabuilder', [climate: 'cold'])]
    def static final CUSTOM_NATURES = ['org.eclipse.jdt.core.scalanature']

        given:
        buildFile << """
            apply plugin: 'eclipse'
            eclipse {
                project {
                    name = "\${'root'}"
                    buildCommand 'buildCommandWithArguments', argumentKey: "\${'argumentValue'}"
                }
            }
        """
        settingsFile << "rootProject.name = 'root'"

        when:

        assert projectFile.sourceFiles == ['../../../build.gradle'] + app.sourceFiles*.withPath("../../../src/main").sort()
        projectFile.projectConfigurations.values().each {
            assert it.buildCommand == "\"../../../${hostGradleWrapperFile.name}\" -p \"../../..\" :installMain${it.name.capitalize()}Executable"

        exeProject.projectConfigurations.values().each {
            assert it.includePath == filePath("src/main/headers", "../lib/src/main/public")
            assert it.buildCommand.endsWith("gradle\" -p \"..\" :exe:install${it.name.capitalize()}")
        }

        and:
        final dllProject = projectFile("lib/libDll.vcxproj")

            </thead>
            <tr>
                <td>natures</td>
            </tr>
            <tr>
                <td>referencedProjects</td>
            </tr>
            <tr>
                <td>buildCommand</td>
            </tr>
            <tr>
                <td>linkedResource</td>
            </tr>
            <tr>
                <td>file</td>
            </tr>
            <tr>

        Action<Object> action = new Action<Object>() {
            @Override
            public void execute(Object ignored) {
                model.getProject().buildCommand("org.eclipse.wst.common.project.facet.core.builder");
                model.getProject().buildCommand("org.eclipse.wst.validation.validationbuilder");
                model.getProject().natures("org.eclipse.wst.common.project.facet.core.nature");