failures.add(failedTest);
        if (parent != null) {
            parent.failed(failedTest);
        }
    }

    protected void ignored(TestResult ignoredTest) {
        ignored.add(ignoredTest);
        if (parent != null) {
            parent.ignored(ignoredTest);
        }
    }

    protected TestResult addTest(TestResult test) {
        tests++;
        duration += test.getDuration();

        </xs:sequence>
    </xs:complexType>
    <xs:complexType name="ignored-keyType">
        <xs:attribute type="xs:string" name="id" use="required"/>
        <xs:attribute type="xs:string" name="reason"/>
    </xs:complexType>
    <xs:complexType name="ignored-keysType">
        <xs:sequence>
            <xs:element type="ignored-keyType" name="ignored-key"/>
        </xs:sequence>
    </xs:complexType>

				recover()
			}()
			defer utilruntime.HandleCrash(
				func(r interface{}) {
					if r == nil {
						return
					}
					if ignoreClientCallFailures {
						// if failures are supposed to ignored, ignore it
						klog.Warningf("Panic calling webhook, failing open %v: %v", hookName, r)
						admissionmetrics.Metrics.ObserveWebhookFailOpen(ctx, hookName, "validating")

	if err := c.ClusterDiff(); err != nil {
		return err
	}
	if err := c.ListenerDiff(); err != nil {
		return err
	}
	return c.RouteDiff()
}

// nonstrictResolver is an AnyResolver that ignores unknown proto messages
type nonstrictResolver struct{}

var envoyResolver nonstrictResolver

func (m *nonstrictResolver) Resolve(typeURL string) (legacyproto.Message, error) {

    }

    // instance method ignored
    public Object badIgnored() {
      return new BadEquals();
    }

    // primitive ignored
    public int returnsInt() {
      throw new UnsupportedOperationException();
    }

    // void ignored
    public void voidMethod() {
      throw new UnsupportedOperationException();
    }

    // non-public method ignored
    static Object badButNotPublic() {

// if there is no matching file. The syntax of patterns is the same
// as in [path.Match]. The pattern may describe hierarchical names such as
// usr/*/bin/ed.
//
// Glob ignores file system errors such as I/O errors reading directories.
// The only possible returned error is [path.ErrBadPattern], reporting that
// the pattern is malformed.
//
// If fs implements [GlobFS], Glob calls fs.Glob.

// FailurePolicyType specifies a failure policy that defines how unrecognized errors from the admission endpoint are handled.
// +enum
type FailurePolicyType string

const (
	// Ignore means that an error calling the webhook is ignored.
	Ignore FailurePolicyType = "Ignore"
	// Fail means that an error calling the webhook causes the admission to fail.
	Fail FailurePolicyType = "Fail"
)

        </xs:sequence>
    </xs:complexType>
    <xs:complexType name="ignored-keyType">
        <xs:attribute type="xs:string" name="id" use="required"/>
        <xs:attribute type="xs:string" name="reason"/>
    </xs:complexType>
    <xs:complexType name="ignored-keysType">
        <xs:sequence>
            <xs:element type="ignored-keyType" name="ignored-key" minOccurs="0" maxOccurs="unbounded"/>
        </xs:sequence>

                    module("org:external:1.0")
                }
            }
        }
    }

    @ToBeFixedForConfigurationCache(because = "task uses Configuration API")
    def "resolution result ignores an ignored available-at variant"() {
        given:
        repository {
            'org:moduleA:1.0' {
                variants(["api", "runtime"]) {

        given:
        buildFile << """

def prop = project.objects.fileProperty()

task thing {
    ${registrationMethod}(prop)
    prop.set(file("file-1"))
    def other = file("ignored")
    doLast {
        prop.set(other)
        println "prop = " + prop.get()
    }
}
"""
        file("file-1").createFile()

        when:
        fails("thing")

        then: