// those that match focus and do not match the ignore regular
// expression.
func (p *Profile) FilterSamplesByTag(focus, ignore TagMatch) (fm, im bool) {
	samples := make([]*Sample, 0, len(p.Sample))
	for _, s := range p.Sample {
		focused, ignored := focusedSample(s, focus, ignore)
		fm = fm || focused
		im = im || ignored
		if focused && !ignored {
			samples = append(samples, s)
		}
	}
	p.Sample = samples

public class ATestClassWithIgnoredMethod {
    @Test
    @Ignore
    public void ignored() {
    }
}

public class ATestClassWithFailedTestAssumption {
    @Test
    public void assumed() {
        assumeTrue(false)
    }
}

@Ignore
public class AnIgnoredTestClass {
    @Test
    public void ignored() {
    }

    @Test
    public void ignored2() {
    }
}

public class ABrokenTestClass {

// expression.
func (p *Profile) FilterSamplesByTag(focus, ignore TagMatch) (fm, im bool) {
	samples := make([]*Sample, 0, len(p.Sample))
	for _, s := range p.Sample {
		focused, ignored := true, false
		if focus != nil {
			focused = focus(s)
		}
		if ignore != nil {
			ignored = ignore(s)
		}
		fm = fm || focused
		im = im || ignored
		if focused && !ignored {

    private final Set<String> ignores;
    private final ImmutableSet<PathMatcher> ignoreMatchers;

    public IgnoringResourceFilter(ImmutableSet<String> ignores) {
        this.ignores = ignores;
        ImmutableSet.Builder<PathMatcher> builder = ImmutableSet.builder();
        for (String ignore : ignores) {
            PathMatcher matcher = PatternMatcherFactory.compile(true, ignore);
            builder.add(matcher);
        }

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

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

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

John Howard <******@****.***> 1597787025 -0700