public void test_discardOnNonExistentKey() {
        String key = "non_existent";
        crawlerStatsHelper.discard(key);

        assertNull(localLogMsg.get());
    }

    static class TestUrlQueue implements UrlQueue<String> {
        private String id;
        private String url;

        public TestUrlQueue(String id, String url) {
            this.id = id;
            this.url = url;
        }

 * {@code Throwable.addSuppressed(Throwable)}.
 *
 * @author Colin Decker
 * @since 14.0
 */
// Coffee's for {@link Closer closers} only.
@J2ktIncompatible
@GwtIncompatible
public final class Closer implements Closeable {
  /** Creates a new {@link Closer}. */
  public static Closer create() {
    return new Closer(SUPPRESSING_SUPPRESSOR);
  }

  @VisibleForTesting final Suppressor suppressor;

package jcifs.smb1.smb1;

import java.io.IOException;
import java.util.HashMap;
import java.util.Iterator;

import jcifs.smb1.Config;
import jcifs.smb1.UniAddress;
import jcifs.smb1.util.LogStream;

/**
 * Implements DFS (Distributed File System) referral caching and resolution.
 * This class manages DFS referral cache and provides DFS path resolution functionality.
 */
public class Dfs {

    /**
     * Default constructor for Dfs.

 *
 * @author Louis Wasserman
 * @author Jon Noack
 */
@GwtIncompatible // not worth using in GWT for now
class CompactHashMap<K extends @Nullable Object, V extends @Nullable Object>
    extends AbstractMap<K, V> implements Serializable {
  /*
   * TODO: Make this a drop-in replacement for j.u. versions, actually drop them in, and test the
   * world. Figure out what sort of space-time tradeoff we're actually going to get here with the

	"github.com/minio/minio/internal/kms"
)

// Return pointer to testOneByteReadEOF{}
func newTestReaderEOF(data []byte) io.Reader {
	return &testOneByteReadEOF{false, data}
}

// OneByteReadEOF - implements io.Reader which returns 1 byte along with io.EOF error.
type testOneByteReadEOF struct {
	eof  bool
	data []byte
}

func (r *testOneByteReadEOF) Read(p []byte) (n int, err error) {
	if r.eof {
		return 0, io.EOF

 *
 * @author Jesse Wilson
 * @author Luke Sandberg
 * @since 1.0
 */
@GwtIncompatible
@J2ktIncompatible
public abstract class AbstractService implements Service {
  private static final ListenerCallQueue.Event<Listener> STARTING_EVENT =
      new ListenerCallQueue.Event<Listener>() {
        @Override
        public void call(Listener listener) {

        assertNotNull(secured);
        assertEquals("INTERFACE_METHOD_ROLE", secured.value()[0]);
    }

    // Test implementation of secured interface
    static class SecuredInterfaceImpl implements SecuredInterface {
        @Override
        public void securedMethod() {
        }
    }

    public void test_interfaceImplementation() {

  private static class TestedFuture<V> extends AbstractFuture<V> {
    private static <V> TestedFuture<V> create() {
      return new TestedFuture<V>();
    }
  }

  private static final class CountingRunnable implements Runnable {
    int count;

    @Override
    public void run() {
      count++;
    }

    void assertNotRun() {
      assertEquals(0, count);
    }

    void assertRun() {

 * @author Dimitris Andreou
 * @author Kurt Alfred Kluever
 */
@Immutable
@SuppressWarnings("IdentifierName") // the best we could do for adjacent digit blocks
final class Murmur3_32HashFunction extends AbstractHashFunction implements Serializable {
  static final HashFunction MURMUR3_32 =
      new Murmur3_32HashFunction(0, /* supplementaryPlaneFix= */ false);
  static final HashFunction MURMUR3_32_FIXED =

 * status code, content type, content length, and the response body.
 * It also provides methods for managing metadata, child URLs, and temporary files.
 */
public class ResponseData implements Closeable {

    private String url;

    private int httpStatusCode;

    private String charSet;

    private long contentLength;

    private String mimeType;

    private String method;