Do not rely on `@NullMarked` annotations.
Only enable checks for a project if all its dependencies have checks enabled, in order to avoid back-and-forth when refining the annotations.

Avoid writing the so-called `PolyNull` or `ParametricNull` methods (where nullability of the result depends on the nullability of the type argument).

     */
    public PasswordBasedExtractor() {
        super();
    }

    /**
     * Adds a password for files matching the given regular expression pattern.
     * @param regex the regular expression pattern to match against URLs or resource names
     * @param password the password to use for matching files
     */
    public void addPassword(final String regex, final String password) {

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *

	for range n {
		l, err := net.Listen("tcp", "127.0.0.1:0")
		if err != nil {
			if l, err = net.Listen("tcp6", "[::1]:0"); err != nil {
				return nil, nil, fmt.Errorf("httptest: failed to listen on a port: %v", err)
			}
		}
		addr := l.Addr()
		hosts = append(hosts, "http://"+addr.String())
		listeners = append(listeners, l)
	}
	return hosts, listeners, err
}

            file.writeText(lines.joinToString("\n"))
        }
    }

    private fun removeDependencies(dependenciesToRemove: Map<String, List<String>>) {
        dependenciesToRemove.forEach { (filePath, dependencies) ->
            val file = File(filePath)
            if (!file.exists()) return@forEach

            val lines = file.readLines().filter { line -> dependencies.none { line.contains(it) } }

    assertThat(decompressed.header("Content-Encoding")).isNull()

    assertFailsWith<IOException> {
      decompressed.body.string()
    }.also { ioe ->
      assertThat(ioe).hasMessage("zstd decompress failed: Unknown frame descriptor")
    }
  }

  @Test
  fun testSkipDecompressNoContentResponse() {
    val response =
      response("https://example.com/", EMPTY) {
        header("Content-Encoding", "zstd")

			echo "no minio process running anymore, proceed."
		fi
	fi
}

function fail() {
	for i in $(seq 1 3); do
		echo "server$i log:"
		cat "${WORK_DIR}/dist-minio-server$i.log"
	done
	echo "FAILED"
	purge "$WORK_DIR"
	exit 1
}

function check_online() {
	if ! grep -q 'API:' ${WORK_DIR}/dist-minio-*.log; then
		echo "1"
	fi
}

function purge() {
	echo rm -rf "$1"
}

	for _, rule := range lc.Rules {
		if rule.Status == Disabled {
			continue
		}
		if !strings.HasPrefix(obj.Name, rule.GetPrefix()) {
			continue
		}
		if !rule.Filter.TestTags(obj.UserTags) {
			continue
		}
		if !obj.DeleteMarker && !rule.Filter.BySize(obj.Size) {
			continue
		}
		rules = append(rules, rule)
	}
	return rules
}

// ObjectOpts provides information to deduce the lifecycle actions

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *

import java.util.Set;
import org.jspecify.annotations.NullUnmarked;
import org.jspecify.annotations.Nullable;

/**
 * {@link Set} implementation that asserts that a given lock is held whenever one of its methods is
 * called.
 */
@NullUnmarked
class LockHeldAssertingSet<E> extends ForwardingSet<E> implements Serializable {
  final Set<E> delegate;
  final Object mutex;

  LockHeldAssertingSet(Set<E> delegate, Object mutex) {