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() {

        then:
        new Facet(rootNode.fixed[0]) == createFixedFacet()
    }

    def equality() {
        Facet facet = createFacet()
        facet.name += 'x'

        expect:
        facet != createFacet()
    }

    def fixedEquality() {
        Facet facet = createFixedFacet()
        facet.name += 'x'

        expect:
        facet != createFixedFacet()
    }

                new Facet(FacetType.fixed, "jst.java", null),
                new Facet(FacetType.fixed, "jst.web", null),
                new Facet(FacetType.installed, "jst.web", "4.0"),
                new Facet(FacetType.installed, "jst.java", "1.4")])
    }

    @Issue('gradle/gradle#17681')
    def "add 'jst.ejb' facet should remove incompatible 'jst.utility' facet"() {
        when:
        project.apply(plugin: 'java')

     */
    public void facet(Map<String, ?> args) {
        Facet newFacet = ConfigureUtil.configureByMap(args, new Facet());
        List<Facet> newFacets;
        if ("jst.ejb".equals(newFacet.getName())) {
            newFacets = Arrays.asList(new Facet(Facet.FacetType.fixed, "jst.ejb", null), newFacet);
        } else {

        getXmlTransformer().setIndentation("\t");
        facet = getInstantiator().newInstance(EclipseWtpFacet.class, new XmlFileContentMerger(getXmlTransformer()));
    }

    @Inject
    public GenerateEclipseWtpFacet(EclipseWtpFacet facet) {
        this.facet = facet;
    }

    @Override
    protected WtpFacet create() {
        return new WtpFacet(getXmlTransformer());
    }

    @Override

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

        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

        when:
        facet.load(customFacetReader)
        facet.configure(constructorFacets + [CUSTOM_FACETS[0]])

        then:
        facet.facets == CUSTOM_FACETS + constructorFacets
    }

    def "load defaults"() {
        when:
        facet.loadDefaults()

        then:
        facet.xml != null
        facet.facets == []
    }

    def "roundtripping the facet file leaves it unchanged"() {

        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'

        then:
        eclipseFacet.facet.facets[0].type == FacetType.valueOf(facetType)

        }
        return facet;
    }

    public void setFacet(EclipseWtpFacet facet) {
        this.facet = facet;
    }

    /**
     * Configures wtp facet.
     * <p>
     * For examples see docs for {@link EclipseWtpFacet}
     */
    public void facet(@DelegatesTo(EclipseWtpFacet.class) Closure action) {
        configure(action, getFacet());
    }

    /**