Matthew Dempsky <******@****.***> 1646087539 -0800

	pkg := mustTypecheck(src, nil, nil)

	// get original error.Error method
	eface := Universe.Lookup("error")
	orig, _, _ := LookupFieldOrMethod(eface.Type(), false, nil, "Error")
	if orig == nil {
		t.Fatalf("original error.Error not found")
	}

	// get embedded error.Error method
	iface := pkg.Scope().Lookup("I")
	embed, _, _ := LookupFieldOrMethod(iface.Type(), false, nil, "Error")
	if embed == nil {

Michael Anthony Knyszek <******@****.***> 1711143722 +0000

	pkg := mustTypecheck(src, nil, nil)

	// get original error.Error method
	eface := Universe.Lookup("error")
	orig, _, _ := LookupFieldOrMethod(eface.Type(), false, nil, "Error")
	if orig == nil {
		t.Fatalf("original error.Error not found")
	}

	// get embedded error.Error method
	iface := pkg.Scope().Lookup("I")
	embed, _, _ := LookupFieldOrMethod(iface.Type(), false, nil, "Error")
	if embed == nil {

	return *(*string)(p) == *(*string)(q)
}
func interequal(p, q unsafe.Pointer) bool {
	x := *(*iface)(p)
	y := *(*iface)(q)
	return x.tab == y.tab && ifaceeq(x.tab, x.data, y.data)
}
func nilinterequal(p, q unsafe.Pointer) bool {
	x := *(*eface)(p)
	y := *(*eface)(q)
	return x._type == y._type && efaceeq(x._type, x.data, y.data)
}
func efaceeq(t *_type, x, y unsafe.Pointer) bool {

		if !strings.HasPrefix(line, "iface.") || strings.Contains(line, "<empty>") {
			continue
		}
		iface := strings.Fields(line)
		if len(iface) != 3 || iface[1] != "=" {
			return nil, fmt.Errorf("error: invalid iface setting: %v", iface)
		}
		// iscsi_ifacename is immutable once the iface is created
		if iface[0] == "iface.iscsi_ifacename" {
			continue
		}
		params[iface[0]] = iface[2]
	}
	return params, nil

		# chop at first space.
		pc = int(str(pc).split(None, 1)[0], 16)
	return pc


#
#  For reference, this is what we're trying to do:
#  eface: p *(*(struct 'runtime.rtype'*)'main.e'->type_->data)->string
#  iface: p *(*(struct 'runtime.rtype'*)'main.s'->tab->Type->data)->string
#
# interface types can't be recognized by their name, instead we check

                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')

        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)