public fun shutdownServer(shutdownServer: Boolean): Builder =
      apply {
        this.shutdownServer = shutdownServer
      }

    /**
     * Throttles the request reader and response writer to sleep for the given period after each
     * series of [bytesPerPeriod] bytes are transferred. Use this to simulate network behavior.
     */
    public fun throttleBody(
      bytesPerPeriod: Long,
      period: Long,

    filtered.put("chicken", 7);
    assertEquals(ImmutableMap.of("cat", 3, "horse", 5, "chicken", 7), filtered);

    assertThrows(
        IllegalArgumentException.class,
        () -> filtered.putAll(ImmutableMap.of("sheep", 5, "cow", 7)));
    assertEquals(ImmutableMap.of("cat", 3, "horse", 5, "chicken", 7), filtered);
  }

  public void testFilteredEntriesObjectPredicate() {
    Map<String, Integer> unfiltered = createUnfiltered();

        NullPointerException.class, () -> multimap().putAll(k3(), newArrayList(null, v3())));

    /*
     * In principle, a Multimap implementation could add e3 first before failing on the null. But
     * that seems unlikely enough to be worth complicating the test over, especially if there's any
     * chance that a permissive test could mask a bug.
     */
    expectUnchanged();

With fast fallback, OkHttp attempts to connect to multiple web servers concurrently. It keeps whichever route connects first and cancels all of the others. Its rules are:

 * Prefer to alternate IP addresses from different address families, (IPv6 / IPv4), starting with IPv6.

        // First read
        NbtAddress result = lmhosts.getByName("TESTHOST", mockContext);
        assertNotNull(result);

        // Modify file with a delay to ensure different lastModified time
        Thread.sleep(100);
        try (FileWriter writer = new FileWriter(lmhostsFile)) {
            writer.write("192.168.1.200 NEWHOST\n");
        }

        // Should reload file and find new host

                        numberOfSuggestDocs += res.getNumberOfSuggestDocs();
                        numberOfInputDocs += res.getNumberOfInputDocs();
                        queryLogs.clear();

                        Thread.sleep(requestInterval);
                    }
                }
                deferred.resolve(
                        new SuggestIndexResponse(numberOfSuggestDocs, numberOfInputDocs, errors, System.currentTimeMillis() - start));

    attributes:
      value: >
        #### Ubiquity: provide concrete use cases


        Did you *actually* encounter the need for this feature in a real-world scenario, or is it
        just a feature that seems like a sensible addition to Guava?


        Before new features get added to Guava, we really want to be sure that it's for a use case

 * UrlFilter, RuleManager, CrawlerContainer, IntervalController, and CrawlerClientFactory,
 * to perform its tasks.
 *
 * <p>The crawling process involves the following steps:
 * <ol>
 *   <li>Initialization: Sets up the crawler context and initializes the URL filter.</li>
 *   <li>Thread Creation: Creates a group of crawler threads to perform the actual crawling.</li>

                });
            }

            // Submit task to wipe key
            executor.submit(() -> {
                try {
                    startLatch.await();
                    Thread.sleep(10);
                    digest.secureWipeKey();
                } catch (Exception e) {
                    // Ignore
                }
            });

            // Submit more tasks that try to verify data

for HTTPS:

```java
HeldCertificate localhostCertificate = new HeldCertificate.Builder()
    .addSubjectAlternativeName("localhost")
    .build();
```

[`HandshakeCertificates`][handshake_certificates] keeps the certificates for a TLS handshake.
Use its [builder][handshake_certificates_builder] to define which certificates the HTTPS server
returns to its clients. The returned instance can create an `SSLSocketFactory` that implements this