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

	// If we're being notified, then the signal should not be ignored.
	if Ignored(syscall.SIGWINCH) {
		t.Errorf("expected SIGWINCH to not be ignored.")
	}
	Stop(c)
	Ignore(syscall.SIGWINCH)

	// We're no longer paying attention to this signal.
	if !Ignored(syscall.SIGWINCH) {
		t.Errorf("expected SIGWINCH to be ignored when explicitly ignoring it.")
	}

	Reset()
}

public class IgnoringResourceEntryFilter implements ResourceEntryFilter {
    private final ImmutableSet<String> ignores;

    public IgnoringResourceEntryFilter(ImmutableSet<String> ignores) {
        this.ignores = ignores;
    }

    @Override
    public boolean shouldBeIgnored(String entry) {
        return ignores.contains(entry);
    }

    @Override
    public void appendConfigurationToHasher(Hasher hasher) {

        defaultCachedState.resourceFilterState.forEach(resourceFilter::ignore);
        defaultCachedState.manifestAttributesFilterState.forEach(manifestAttributeResourceFilter::ignore);
        defaultCachedState.propertiesFileFiltersState.forEach((pattern, ignores) -> {
            propertyFileFilters.configure(pattern, normalization -> ignores.forEach(normalization::ignoreProperty));
        });
    }

Guillaume Nodet <******@****.***> 1669127925 +0100

        }
    }

    def 'paths ignored in file system checks are included in the configuration cache fingerprint'() {
        when:
        configurationCacheRun()
        configurationCacheRun("-D$IGNORE_FS_CHECKS_PROPERTY=test")

        then:
        outputContains("the set of paths ignored in file-system-check input tracking has changed")
    }

	if logIgnoreError(err) {
		return
	}
	for _, ignore := range ignored {
		if errors.Is(err, ignore) {
			return
		}
	}
	logIf(ctx, subsystem, err)
}

func errToEntry(ctx context.Context, subsystem string, err error, errKind ...interface{}) log.Entry {
	var l string
	if anonFlag {
		l = reflect.TypeOf(err).String()
	} else {
		l = fmt.Sprintf("%v (%T)", err, err)
	}

     *
     * <p>This method ignores tests defined in included builds.</p>
     *
     * @param testClasses The class names of the tests to be executed.
     * @return this
     * @since 2.6
     */
    TestLauncher withJvmTestClasses(String... testClasses);


    /**
     * <p>Adds tests to be executed declared by class name.</p>
     *
     * <p>This method ignores tests defined in included builds.</p>
     *

	return func() {
		initialStackSnapShot.DetectLeak(t)
	}
}

// list of functions to be ignored from the stack trace.
// Leak detection is done when tests are run, should ignore the tests related functions,
// and other runtime functions while identifying leaks.
var ignoredStackFns = []string{
	"",
	// Below are the stacks ignored by the upstream leaktest code.
	"testing.Main(",
	"testing.tRunner(",
	"testing.tRunner(",

            } catch (final Exception e) {
                // ignore
            }
        }
        final Integer id = fessConfig.getAvailableSmbSidType(type);
        if (id != null) {
            return createSearchRole(id, sid.getAccountName());
        }
        if (logger.isDebugEnabled()) {
            logger.debug("Ignored SID: {} {}", type, sid);
        }
        return null;
    }