RateLimiter limiter = RateLimiter.create(5.0, stopwatch);
    assertThat(limiter.acquire()).isWithin(EPSILON).of(0.0);
    stopwatch.sleepMillis(400);
    assertThat(limiter.acquire()).isWithin(EPSILON).of(0.0);
    assertThat(limiter.acquire()).isWithin(EPSILON).of(0.0);
    assertThat(limiter.acquire()).isWithin(EPSILON).of(0.2);
  }

  public void testOneSecondBurst() {

    }

    assertThat(pairs).containsExactly("a" to "b", "c" to "d")
  }

  @Test fun builderGetOperator() {
    val builder = Headers.Builder()
    builder.add("a", "b")
    builder.add("c", "d")
    assertThat(builder["a"]).isEqualTo("b")
    assertThat(builder["c"]).isEqualTo("d")
    assertThat(builder["e"]).isNull()
  }

  @Test fun builderSetOperator() {
    val builder = Headers.Builder()

    client.webSocket!!.close(1000, "Hello!")
    assertThat(client.webSocket!!.close(1000, "Hello!")).isFalse()
    assertThat(client.webSocket!!.send("Hello!")).isFalse()
  }

  @Test
  fun clientCloseWith0Fails() {
    assertFailsWith<IllegalArgumentException> {
      client.webSocket!!.close(0, null)
    }.also { expected ->
      assertThat("Code must be in range [1000,5000): 0")

        assertThat(ObjectUtil.equals("", null), is(false));
        assertThat(ObjectUtil.equals("", ""), is(true));
        assertThat(ObjectUtil.equals(Boolean.TRUE, null), is(false));
        assertThat(ObjectUtil.equals(Boolean.TRUE, "true"), is(false));
        assertThat(ObjectUtil.equals(Boolean.TRUE, Boolean.TRUE), is(true));
        assertThat(ObjectUtil.equals(Boolean.TRUE, Boolean.FALSE), is(false));
    }

    assertThat(dispatcher.queuedCalls()).isEmpty()
    assertThat(a1.isExecuted()).isTrue()
    assertThat(a1.isCanceled()).isFalse()
    assertThat(a2.isExecuted()).isTrue()
    assertThat(a2.isCanceled()).isTrue()
    assertThat(a3.isExecuted()).isFalse()
    assertThat(a3.isCanceled()).isTrue()
    assertThat(a4.isExecuted()).isFalse()
    assertThat(a4.isCanceled()).isFalse()
  }

  @Test

    public void testContainsKey() throws Exception {
        assertThat(map.containsKey("ONE"), is(true));
        assertThat(map.containsKey("one"), is(true));
        assertThat(map.containsKey("onex"), is(not(true)));
    }

    /**
     * @throws Exception
     */
    @Test
    public void testGet() throws Exception {
        assertThat(map.get("ONE"), is("1"));
        assertThat(map.get("One"), is("1"));

        ).setHeader("content-type", "text/event-stream")
        .build(),
    )
    val source = newEventSource()
    assertThat(source.request().url.encodedPath).isEqualTo("/")
    listener.assertOpen()
    listener.assertEvent(null, null, "hey")
    listener.assertClose()
    assertThat(eventListener.recordedEventTypes()).containsExactly(
      "CallStart",
      "ProxySelectStart",
      "ProxySelectEnd",

    }
  }

  public void testEnsureNonNegative() {
    assertThat(DoubleUtils.ensureNonNegative(0.0)).isEqualTo(0.0);
    for (double positiveValue : POSITIVE_FINITE_DOUBLE_CANDIDATES) {
      assertThat(DoubleUtils.ensureNonNegative(positiveValue)).isEqualTo(positiveValue);
      assertThat(DoubleUtils.ensureNonNegative(-positiveValue)).isEqualTo(0.0);
    }
    assertThat(DoubleUtils.ensureNonNegative(Double.POSITIVE_INFINITY)).isPositiveInfinity();

          }
        };

    Class<?> finalizerCopy = decoupledLoader.loadFinalizer();

    assertThat(finalizerCopy).isNotNull();
    assertThat(finalizerCopy).isNotSameInstanceAs(Finalizer.class);

    assertThat(FinalizableReferenceQueue.getStartFinalizer(finalizerCopy)).isNotNull();
  }

  static class DecoupledClassLoader extends URLClassLoader {

          }
        };

    Class<?> finalizerCopy = decoupledLoader.loadFinalizer();

    assertThat(finalizerCopy).isNotNull();
    assertThat(finalizerCopy).isNotSameInstanceAs(Finalizer.class);

    assertThat(FinalizableReferenceQueue.getStartFinalizer(finalizerCopy)).isNotNull();
  }

  static class DecoupledClassLoader extends URLClassLoader {