it.facets.add(new Facet('facet.three', '3.0'))
        }
        withXml { it.asNode().appendNode('be', 'cool') }
      }
    }
  }
}
        """

        def facet = getFile([:], '.settings/org.eclipse.wst.common.project.facet.core.xml').text

        assert facet.contains('facet.one')
        assert facet.contains('facet.two')

    }

    def "created facets defaults to type 'installed'"() {
        when:
        eclipseFacet.facet.facet(name: 'fancyProject', version: '1.3')

        then:
        eclipseFacet.facet.facets == [new Facet(FacetType.installed, 'fancyProject', '1.3')]
    }

    def "can explicitly configure facet type'"() {
        when:
        eclipseFacet.facet.facet type: facetType, name: 'fancyProject'

        classpath.lib('lib1-impl-1.0.jar').assertIsDeployedTo('/lib')
        classpath.lib('lib2-impl-2.0.jar').assertIsDeployedTo('/')

        // Facets
        def facets = wtpFacets
        facets.assertHasFixedFacets('jst.ear')
        facets.assertHasInstalledFacets('jst.ear')
        facets.assertFacetVersion('jst.ear', '5.0')

        // Component
        def component = wtpComponent
        component.deployName == 'ear'

        model.wtp.facet == facet
        model.wtp.facet.facets.empty

        when: "configure wtp component and facet"
        model.wtp.component({ comp -> comp.deployName = 'name' } as Action<EclipseWtpComponent>)
        model.wtp.facet({ fac -> fac.facets.add(new Facet()) } as Action<EclipseWtpFacet>)

        then:
        model.wtp.component.deployName == 'name'
        model.wtp.facet.facets.size() == 1

                    @Override
                    public List<Facet> call() throws Exception {
                        return Lists.newArrayList(
                            new Facet(Facet.FacetType.fixed, "jst.java", null),
                            new Facet(Facet.FacetType.fixed, "jst.web", null),
                            new Facet(Facet.FacetType.installed, "jst.web", "2.4"),

        def webProject = project('web')
        def earProject = project('ear')

        // Classpath
        def javaClasspath = classpath('java')
        def webClasspath = classpath('web')

        // Facets
        def javaFacets = wtpFacets('java')
        def webFacets = wtpFacets('web')
        def earFacets = wtpFacets('ear')

        // Deployment
        def javaComponent = wtpComponent('java')

        webClasspath.lib('junit-4.13.jar').assertIsExcludedFromDeployment()
        webClasspath.lib('hamcrest-core-1.3.jar').assertIsExcludedFromDeployment()

        // Facets
        def javaFacets = wtpFacets('java')
        javaFacets.assertHasFixedFacets("jst.java")
        javaFacets.assertHasInstalledFacets("jst.utility", "jst.java")

        def webFacets = wtpFacets('web')

            example: ["timestamp:[now/d-1d TO *]"]
        - name: facet.size
          in: query
          description: Item size in facets returned by facet.field
          required: false
          schema:
            type: integer
            minimum: 0
            exclusiveMinimum: false
            default: 10
            example: 10
        - name: facet.minDocCount
          in: query

     * listeners assigned/removed directly to/from it.  This allows these "anonymous" broadcasters to specialize what
     * listeners receive messages.  Each call creates a new broadcaster, so that client code can create as many "facets"
     * of the listener as they need.  The client code must provide some way for its users to register listeners on the
     * specialized broadcasters.
     *
     * <p>The returned value is not thread-safe.</p>
     *

            return false;
        }
        Facet facet = (Facet) o;
        return type == facet.type && Objects.equal(name, facet.name) && Objects.equal(version, facet.version);
    }

    @Override
    public int hashCode() {
        return Objects.hashCode(type, name, version);
    }

    @Override
    public String toString() {