public void testPut_nullKeyUnsupported() {
    assertThrows(NullPointerException.class, () -> put(nullKeyEntry));
    expectUnchanged();
    expectNullKeyMissingWhenNullKeysUnsupported(
        "Should not contain null key after unsupported put(null, value)");
  }

  @MapFeature.Require({SUPPORTS_PUT, ALLOWS_NULL_VALUES})
  public void testPut_nullValueSupported() {

        assertTrue(ex1.getMessage().contains("Already closed"));
        CIFSException ex2 = assertThrows(CIFSException.class, handle::getOutput, "getOutput after close must throw");
        assertTrue(ex2.getMessage().contains("Already closed"));
    }

    @Test
    @DisplayName("ensureOpen opens SMB2 via UNC path and marks open")

import java.security.cert.CertificateFactory
import java.security.cert.X509Certificate
import okio.Buffer
import okio.ByteString
import okio.ByteString.Companion.toByteString

/**
 * Decodes a multiline string that contains a [certificate][certificatePem] which is
 * [PEM-encoded][rfc_7468]. A typical input string looks like this:
 *
 * ```
 * -----BEGIN CERTIFICATE-----
 * MIIBYTCCAQegAwIBAgIBKjAKBggqhkjOPQQDAjApMRQwEgYDVQQLEwtlbmdpbmVl

        String newUnc = l.handleDFSReferral(dr, "\\req\\");
        // dunc is "\\" + path + remaining  - note: path may not have leading backslashes
        assertTrue(newUnc.contains("dfs/path") || newUnc.contains("dfs\\path"));
        assertEquals(dr, l.getDfsReferral());
        assertEquals("dfs-server", l.getServerWithDfs());

**Builder**: `RequestDataBuilder`, `ExtractorBuilder` - fluent construction
**Template Method**: `AbstractCrawlerClient`, `AbstractExtractor` - common logic with overrides
**DI**: LastaFlute container with `@Resource` and XML config

### Core Principles

**Thread Safety**:
- `AtomicLong` for counters (`CrawlerContext.accessCount`)
- `volatile` for status flags
- Synchronized blocks for critical sections

        try {
            new ContentCache((byte[]) null);
            fail("Expected IllegalArgumentException");
        } catch (IllegalArgumentException e) {
            assertTrue(e.getMessage().contains("data must not be null"));
        }
    }

    @Test
    public void testMemoryBasedCacheDefensiveCopy() throws IOException {
        byte[] data = "Hello, World!".getBytes();

  }

  // Name

  private @Nullable String name;

  /** Configures this builder produce a TestSuite with the given name. */
  @CanIgnoreReturnValue
  public B named(String name) {
    if (name.contains("(")) {
      throw new IllegalArgumentException(
          "Eclipse hides all characters after "
              + "'('; please use '[]' or other characters instead of parentheses");
    }
    this.name = name;

import java.util.LinkedList;
import java.util.List;
import java.util.Map;

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.codelibs.fess.crawler.container.CrawlerContainer;

import jakarta.annotation.Resource;

/**
 * Creates and manages crawler clients for web crawling operations.

  fun launchWireShark(): Process? {
    when (launch) {
      null -> {
        if (tlsVersions.contains(TLS_1_2)) {
          println("TLSv1.2 traffic will be logged automatically and available via wireshark")
        }

        if (tlsVersions.contains(TLS_1_3)) {
          println("TLSv1.3 requires an external command run before first traffic is sent")

            return "theDelegate";
          }
        };
    Executor sequential1 = newSequentialExecutor(delegate);
    Executor sequential2 = newSequentialExecutor(delegate);
    assertThat(sequential1.toString()).contains("theDelegate");
    assertThat(sequential1.toString()).isNotEqualTo(sequential2.toString());
    String[] whileRunningToString = new String[1];
    sequential1.execute(
        new Runnable() {
          @Override