}

    /**
     * Constructs an instance.
     *
     * @param reader
     *            The {@link Reader} to read strings from. Must not be {@literal null}.
     */
    public LineIterator(final Reader reader) {
        assertArgumentNotNull("reader", reader);
        this.reader = new BufferedReader(reader);
    }

    /**
     * Constructs an instance.
     *
     * @param reader

          "exemplar": true,
          "expr": "minio_cluster_replication_proxied_head_requests_total{job=\"$scrape_jobs\"}",
          "interval": "1m",
          "intervalFactor": 2,
          "legendFormat": "{{instance}}",
          "range": true,
          "refId": "A"
        }
      ],
      "title": "Total Proxied Head Requests",
      "type": "timeseries"
    },
    {
      "datasource": {

   * Returns a new {@code MutableClassToInstanceMap} instance backed by a {@link HashMap} using the
   * default initial capacity and load factor.
   */
  public static <B extends @Nullable Object> MutableClassToInstanceMap<B> create() {
    return new MutableClassToInstanceMap<>(new HashMap<Class<? extends @NonNull B>, B>());
  }

  /**
   * Returns a new {@code MutableClassToInstanceMap} instance backed by a given empty {@code

final class TransWaitNamedPipeResponseTest {

    /**
     * Verify that the default constructor creates an instance.
     */
    @Test
    void constructorInitialisesInstance() {
        // Arrange & Act
        TransWaitNamedPipeResponse resp = new TransWaitNamedPipeResponse();
        // Assert
        assertNotNull(resp, "Instance should not be null");
    }

    /**

   *     down the executor after the last event has been posted to this event bus.
   */
  public AsyncEventBus(String identifier, Executor executor) {
    super(identifier, executor, Dispatcher.legacyAsync(), LoggingHandler.INSTANCE);
  }

  /**
   * Creates a new AsyncEventBus that will use {@code executor} to dispatch events.
   *
   * @param executor Executor to use to dispatch events. It is the caller's responsibility to shut

 * This class handles the setup and organization of query facets for the search interface,
 * including automatic generation of file type facets and custom query mappings.
 */
public class FacetQueryView {
    /** Logger instance for this class */
    private static final Logger logger = LogManager.getLogger(FacetQueryView.class);

    /** Title for this facet query view */
    protected String title;

    /**
     * Map containing field names as keys and their corresponding configuration values as values.
     */
    private final Map<String, String> params;

    /**
     * Constructs a new FieldConfigs instance with the specified parameter map.
     *
     * @param params the map containing field names as keys and configuration values as values
     */
    public FieldConfigs(final Map<String, String> params) {

    @Test
    @DisplayName("getHandle returns the exact handle instance")
    void getHandle_returnsHandle() throws Exception {
        // Arrange
        SmbPipeOutputStream out = newStream();

        // Act
        SmbPipeHandleImpl got = out.getHandle();

        // Assert
        assertSame(handle, got, "getHandle should expose the same instance passed to constructor");
    }

    @Test

    try {
      assertFalse(getMap().entrySet().contains(mapEntry(IncomparableType.INSTANCE, v0())));
    } catch (ClassCastException acceptable) {
      // allowed by the spec
    }
  }

  public void testContainsEntryWithIncomparableValue() {
    try {
      assertFalse(getMap().entrySet().contains(mapEntry(k0(), IncomparableType.INSTANCE)));
    } catch (ClassCastException acceptable) {
      // allowed by the spec
    }

 * @since 2.0
 */
@GwtCompatible
@J2ktIncompatible
public final class EnumBiMap<K extends Enum<K>, V extends Enum<V>> extends AbstractBiMap<K, V> {
  /*
   * J2CL's EnumMap does not need the Class instance, so we can use Object.class instead. (Or we
   * could use null, but that messes with our nullness checking, including under J2KT. We could