* that satisfy the filter will be removed from the underlying set.
   *
   * <p>The returned set isn't threadsafe or serializable, even if {@code unfiltered} is.
   *
   * <p>Many of the filtered set's methods, such as {@code size()}, iterate across every element in
   * the underlying set and determine which elements satisfy the filter. When a live view is

 * options and then retried without them should the attempt fail.
 *
 * ## Connection Reuse
 *
 * Each connection can carry a varying number of streams, depending on the underlying protocol being
 * used. HTTP/1.x connections can carry either zero or one streams. HTTP/2 connections can carry any
 * number of streams, dynamically configured with `SETTINGS_MAX_CONCURRENT_STREAMS`. A connection

     * @return A new object created by invoking the default constructor
     * @throws InstantiationRuntimeException
     *             If the underlying constructor represents an abstract class
     * @throws IllegalAccessRuntimeException
     *             If the number of actual and formal parameters differ, if unwrapping of primitive arguments fails,

 * Fix: Support Shoutcast HTTP responses like `ICY 200 OK`.
 * Fix: Don't unzip if there isn't a response body.
 * Fix: Don't leak gzip streams on redirects.
 * Fix: Don't do DNS lookups on invalid hosts.
 * Fix: Exhaust the underlying stream when reading gzip streams.
 * Fix: Support the `PATCH` method.
 * Fix: Support request bodies on `DELETE` method.
 * Fix: Drop the `okhttp-protocols` module.

 * The size and frequency of the HTTP calls your application makes. If you’re making too many calls, or your calls are too large, you should know about it!
 * The performance of these calls on the underlying network. If the network’s performance isn’t sufficient, you need to either improve the network or use less of it.

### EventListener

      return proxy;
    }
  }

  /**
   * Intercepts calls to a {@code Map} to check that {@code setUpRan} is true when they happen. Then
   * forwards the calls to the underlying {@code Map}.
   */
  private static class CheckSetUpInvocationHandler implements InvocationHandler, Serializable {
    private final Map<String, String> map;
    private final AtomicBoolean setUpRan;

    IDLE,
    /** Runnable is not running, but is being queued for execution */
    QUEUING,
    /** runnable has been submitted but has not yet begun execution */
    QUEUED,
    RUNNING,
  }

  /** Underlying executor that all submitted Runnable objects are run on. */
  private final Executor executor;

  @GuardedBy("queue")
  private final Deque<Runnable> queue = new ArrayDeque<>();

  /** see {@link WorkerRunningState} */

            assertTrue(w.isReady(), "WriterThread should be ready to accept work");

            // Act: submit a write
            w.write(payload, 3, out);
        }

        // Assert: verify the underlying stream was called
        verify(out, timeout(1000)).write(payload, 0, 3);

        // Stop the thread by sending n = -1
        synchronized (w) {
            w.write(new byte[0], -1, out);
        }

            LogStream.setInstance(null);
        });
    }

    @Test
    void testPrintStreamDelegation() {
        // Test that LogStream properly delegates to underlying PrintStream
        // Use a real PrintStream with ByteArrayOutputStream to test delegation
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        PrintStream realStream = new PrintStream(baos);

 *
 */
public class DocMap implements Map<String, Object> {

    /** The key used for language field identification */
    private static final String LANG_KEY = "lang";

    /** The underlying map that this DocMap wraps */
    private final Map<String, Object> parent;

    /**
     * Constructor that creates a DocMap wrapping the given parent map.
     *