* If a subtype doesn't override a super-type defined category, the corresponding annotation in that category gets inherited.
 * Subtypes can mark methods to be ignored by using an ignore annotation.
 * Ignored methods don't inherit super-type annotations.
 * </p>
 *
 * <strong>Boolean properties</strong>
 *
 * <p>

        </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>

        1 * registry.markState(address, Canceled)
    }

    def "ignores empty cache on marking busy"() {
        given:
        updater.onStart(address)
        registry.markState(address, Busy) >> { throw new EmptyRegistryException("") }

        when:
        updater.onStartActivity()

        then:
        noExceptionThrown()
    }

    def "ignores empty cache on stopping"() {
        given:

		stmp, e := ListxattrNS(file, nsid, dest[pos:])

		/* Errors accessing system attrs are ignored so that
		 * we can implement the Linux-like behavior of omitting errors that
		 * we don't have read permissions on
		 *
		 * Linux will still error if we ask for user attributes on a file that
		 * we don't have read permissions on, so don't ignore those errors
		 */
		if e != nil {
			if e == EPERM && nsid != EXTATTR_NAMESPACE_USER {

        }
    }

    @Override
    public void testIgnored(Description description) throws Exception {
        if (methodName(description) == null) {
            // An @Ignored class, ignore the event. We don't get testIgnored events for each method, so we have
            // generate them on our own
            processIgnoredClass(description);
        } else {

        </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>

    private final GradleDistribution distribution;
    private final String ignored;

    public GradleDistributionTool(GradleDistribution distribution) {
        this(distribution, null);
    }

    public GradleDistributionTool(GradleDistribution distribution, String ignored) {
        this.distribution = distribution;
        this.ignored = ignored;
    }

    @Override
    public boolean matches(String criteria) {

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

        return failures;
    }

    public boolean isIgnored() {
        return ignored;
    }

    public void addFailure(TestFailure failure) {
        classResults.failed(this);
        failures.add(failure);
    }

    public void setIgnored() {
        classResults.ignored(this);
        ignored = true;
    }

    @Override
    public int compareTo(TestResult testResult) {

    new_field.has_alias = field.has_alias  # type: ignore[attr-defined]
    new_field.alias = field.alias  # type: ignore[misc]
    new_field.class_validators = field.class_validators  # type: ignore[attr-defined]
    new_field.default = field.default  # type: ignore[misc]
    new_field.required = field.required  # type: ignore[misc]
    new_field.model_config = field.model_config  # type: ignore[attr-defined]
    new_field.field_info = field.field_info