val actualElapsedNs = result.timestampNs - (lastTimestampNs ?: result.timestampNs)
    lastTimestampNs = result.timestampNs

    if (eventClass != null) {
      assertThat(result).isInstanceOf(eventClass)
    }

    if (elapsedMs != -1L) {
      assertThat(
        TimeUnit.NANOSECONDS.toMillis(actualElapsedNs)
          .toDouble(),
      )
        .isCloseTo(elapsedMs.toDouble(), 100.0)
    }

    return result

        System.out.println(value);
        assertThat(value, is(notNullValue()));
    }

    /**
     * @throws Exception
     */
    @Test
    public void testGetBundle() throws Exception {
        final ResourceBundle bundle = ResourceBundleUtil.getBundle("CLMessages", null, this.getClass().getClassLoader());
        assertThat(bundle, is(notNullValue()));
    }

    /**
     * @throws Exception

    }.also { expected ->
      assertThat(expected.message).isEqualTo("Code must be in range [1000,5000): 98724976")
    }
  }

  @Test fun closeReservedThrows() {
    assertFailsWith<IllegalArgumentException> {
      clientWriter.writeClose(1005, "Hello".encodeUtf8())
    }.also { expected ->
      assertThat(expected.message).isEqualTo("Code 1005 is reserved and may not be used.")
    }

    assertThat(url.resolve("#s")).isEqualTo(parse("http://a/b/c/d;p?q#s"))
    assertThat(url.resolve("g#s")).isEqualTo(parse("http://a/b/c/g#s"))
    assertThat(url.resolve("g?y#s")).isEqualTo(parse("http://a/b/c/g?y#s"))
    assertThat(url.resolve(";x")).isEqualTo(parse("http://a/b/c/;x"))
    assertThat(url.resolve("g;x")).isEqualTo(parse("http://a/b/c/g;x"))
    assertThat(url.resolve("g;x?y#s")).isEqualTo(parse("http://a/b/c/g;x?y#s"))

      assertThat(MoreFiles.equal(fooPath, barPath)).isFalse();
      assertThat(MoreFiles.equal(fooPath, fooPath)).isTrue();
      assertThat(MoreFiles.asByteSource(fooPath).contentEquals(MoreFiles.asByteSource(fooPath)))
          .isTrue();

      Path fooCopy = Files.copy(fooPath, fs.getPath("fooCopy"));
      assertThat(Files.isSameFile(fooPath, fooCopy)).isFalse();

          .build(),
      )
    assertThat(cacheControl.noCache).isTrue()
    assertThat(cacheControl.noStore).isTrue()
    assertThat(cacheControl.maxAgeSeconds).isEqualTo(1)
    assertThat(cacheControl.sMaxAgeSeconds).isEqualTo(2)
    assertThat(cacheControl.isPrivate).isTrue()
    assertThat(cacheControl.isPublic).isTrue()
    assertThat(cacheControl.mustRevalidate).isTrue()
    assertThat(cacheControl.maxStaleSeconds).isEqualTo(3)

        .url("https://square.com")
        .build()
    assertThat(request.tag()).isNull()
    assertThat(request.tag(Any::class.java)).isNull()
    assertThat(request.tag(UUID::class.java)).isNull()
    assertThat(request.tag(String::class.java)).isNull()

    // Alternate access APIs also work.
    assertThat(request.tag<String>()).isNull()
    assertThat(request.tag(String::class)).isNull()
  }

  @Test

    derReader.read("test") { header ->
      assertThat(header.tag).isEqualTo(2L)
      assertThat(header.tagClass).isEqualTo(DerHeader.TAG_CLASS_CONTEXT_SPECIFIC)
      assertThat(header.length).isEqualTo(7L)

      derReader.read("test") { header ->
        assertThat(header.tag).isEqualTo(3L)
        assertThat(header.tagClass).isEqualTo(DerHeader.TAG_CLASS_APPLICATION)
        assertThat(header.length).isEqualTo(5L)

  public void testCount() {
    assertThat(EMPTY_STATS_VARARGS.count()).isEqualTo(0);
    assertThat(EMPTY_STATS_ITERABLE.count()).isEqualTo(0);
    assertThat(ONE_VALUE_STATS.count()).isEqualTo(1);
    assertThat(TWO_VALUES_STATS.count()).isEqualTo(2);
    assertThat(MANY_VALUES_STATS_VARARGS.count()).isEqualTo(MANY_VALUES_COUNT);
    assertThat(MANY_VALUES_STATS_ITERABLE.count()).isEqualTo(MANY_VALUES_COUNT);

        assertThat(newArray.length, is(2));
        assertThat(newArray[0], is("111"));
        assertThat(newArray[1], is("222"));

        final String[] emptyArray = new String[0];
        assertThat(ArrayUtil.addAll((Object[]) null, (Object[]) null), is(nullValue()));
        assertThat(ArrayUtil.addAll(null, emptyArray).length, is(0));