inputDir.file('.gitignore').text = "some ignored file"
        inputDir.file('#ignored#').text = "some ignored file"
        inputDir.file('.git/any-name.txt').text = "some ignored file"
        inputDir.file('something/.git/deeper/dir/structure/any-name.txt').text = "some ignored file"
        inputDir.file('._ignored').text = "some ignored file"
        inputDir.file('some-file.txt~').text = "some ignored file"

        run 'myTask', "--info"

            twiceIgnoredProperty: [(TYPE): Ignored]
        ], [
            strict(ignoredAnnotatedPropertyMessage { property('twiceIgnoredProperty').ignoring('Ignored').alsoAnnotatedWith('Ignored2').includeLink() })
        ]
    }

    @SuppressWarnings("unused")
    interface TypeWithIgnoredPropertyWithMultipleIgnoreAnnotations {
        @Ignored
        @Ignored2
        String getTwiceIgnoredProperty()
    }

      command: ['curl']
---
apiVersion: v1
kind: Service
metadata:
  name: details
  labels:
    app: details
  annotations:
    # Annotation that Istio doesn't know about, but isn't an Istio annotation, thus ignored
    kubernetes.io/psp: my-privileged-psp
spec:
  ports:
  - name: http
    port: 80
    targetPort: 9080
  selector:
    app: details
---
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:

	}

	aom, bom := ao.ToMap(), bo.ToMap()
	return manifestDiff(aom, bom, nil, verbose)
}

// ManifestDiffWithSelect checks the manifest differences with selected and ignored resources.
// The selected filter will apply before the ignored filter.
func ManifestDiffWithRenameSelectIgnore(a, b, renameResources, selectResources, ignoreResources string, verbose bool) (string, error) {
	rnm := getKeyValueMap(renameResources)

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

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

        }
    }

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

	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;
    }