//
    /**
     * <b>Warning</b>: ignored.
     */
    @Override
    public void returnComponentLogger(String role) {}

    /**
     * <b>Warning</b>: ignored.
     */
    @Override
    public void returnComponentLogger(String role, String hint) {}

    /**
     * <b>Warning</b>: ignored (always return <code>0</code>).
     */
    @Override
    public int getThreshold() {

func TestIsErrIgnored(t *testing.T) {
	errIgnored := fmt.Errorf("ignored error")
	testCases := []struct {
		err     error
		ignored bool
	}{
		{
			err:     nil,
			ignored: false,
		},
		{
			err:     errIgnored,
			ignored: true,
		},
		{
			err:     errFaultyDisk,
			ignored: true,
		},
	}
	for i, testCase := range testCases {

		{Name: "Name", DBName: "company_name", BindNames: []string{"Base", "Name"}, DataType: schema.String, TagSettings: map[string]string{"EMBEDDED": "EMBEDDED", "EMBEDDEDPREFIX": "company_"}},
		{Name: "Ignored", BindNames: []string{"Base", "Ignored"}, TagSettings: map[string]string{"-": "-", "EMBEDDED": "EMBEDDED", "EMBEDDEDPREFIX": "company_"}},

    }

    /**
     * <b>Warning</b>: ignored (always return <code>0 == Logger.LEVEL_DEBUG</code>).
     */
    @Override
    public int getThreshold() {
        return 0;
    }

    /**
     * <b>Warning</b>: ignored.
     */
    @Override
    public void setThreshold(int threshold) {}

    /**
     * <b>Warning</b>: ignored (always return <code>null</code>).
     */
    @Override

	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 ...any) log.Entry {
	var l string
	if anonFlag {
		l = reflect.TypeOf(err).String()
	} else {
		l = fmt.Sprintf("%v (%T)", err, err)
	}

			wantResp:       []string{"AccessDenied"},
		},
		{
			name:   "version as user with policy ignores resource want success",
			method: http.MethodGet,
			path:   kmsVersionPath,
			asRoot: false,

			policy: `{"Effect": "Allow",
				"Action": ["kms:Version"],
				"Resource": ["arn:minio:kms:::does-not-matter-it-is-ignored"] }`,

			wantStatusCode: http.StatusOK,
			wantResp:       []string{"version"},
		},

	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(",

// functionality to handle SSE-C copy requests.
var SSECopy = ssecCopy{}

type ssecCopy struct{}

// IsRequested returns true if the HTTP headers contains
// at least one SSE-C copy header. Regular SSE-C headers
// are ignored.
func (ssecCopy) IsRequested(h http.Header) bool {
	if _, ok := h[xhttp.AmzServerSideEncryptionCopyCustomerAlgorithm]; ok {
		return true
	}
	if _, ok := h[xhttp.AmzServerSideEncryptionCopyCustomerKey]; ok {
		return true

// domain is "SSE-C".
func (ssec) String() string { return "SSE-C" }

// IsRequested returns true if the HTTP headers contains
// at least one SSE-C header. SSE-C copy headers are ignored.
func (ssec) IsRequested(h http.Header) bool {
	if _, ok := h[xhttp.AmzServerSideEncryptionCustomerAlgorithm]; ok {
		return true
	}
	if _, ok := h[xhttp.AmzServerSideEncryptionCustomerKey]; ok {
		return true
	}

                    artifacts.addAll(descriptor.getExportedArtifacts());
                    packages.addAll(descriptor.getExportedPackages());
                }
            }
        } catch (IOException ignored) {
            // exports descriptors are entirely optional
        }

        return new CoreExtensionEntry(loader, artifacts, packages, null, null);
    }

    public static CoreExtensionEntry discoverFrom(