assertThat(Adapters.BIT_STRING.fromDer(bytes)).isEqualTo(bitString)
    assertThat(Adapters.BIT_STRING.toDer(bitString)).isEqualTo(bytes)
  }

  @Test fun `cannot decode empty bit string`() {
    val bytes = "0300".decodeHex()
    assertFailsWith<ProtocolException> {
      Adapters.BIT_STRING.fromDer(bytes)
    }.also { expected ->
      assertThat(expected).hasMessage("malformed bit string")
    }
  }

        doc.put("title", "Test");
        documentList1.add(doc);
        documentList2.add(doc);

        QueryResponseList qrList1 = new QueryResponseList(documentList1, 0, 10, 0);
        QueryResponseList qrList2 = new QueryResponseList(documentList2, 0, 10, 0);

        assertTrue(qrList1.equals(qrList2));
        assertEquals(qrList1.hashCode(), qrList2.hashCode());

        // Test with different content

        protwordsFile.insert(newItem);

        // Verify the item was added
        protwordsFile.reload(null);
        boolean found = false;
        PagingList<ProtwordsItem> list = protwordsFile.selectList(0, 100);
        for (ProtwordsItem item : list) {
            if ("newWord".equals(item.getInput())) {
                found = true;
                break;
            }
        }
        assertTrue(found);

        assertEquals(2000, intervalControlHelper.getDelay());

        intervalControlHelper.ruleList.clear();

        intervalControlHelper.addIntervalRule("12:15", "12:15", "*", 3000);
        assertEquals(3000, intervalControlHelper.getDelay());

        intervalControlHelper.ruleList.clear();

        intervalControlHelper.addIntervalRule("12:15", "12:15", "3,5", 4000);
        assertEquals(0, intervalControlHelper.getDelay());

    assertThat(max(LEAST)).isEqualTo(LEAST);
    assertThat(max(GREATEST)).isEqualTo(GREATEST);
    assertThat(max(8.0, 6.0, 7.0, 5.0, 3.0, 0.0, 9.0)).isEqualTo(9.0);

    assertThat(max(-0.0, 0.0)).isEqualTo(0.0);
    assertThat(max(0.0, -0.0)).isEqualTo(0.0);
    assertThat(max(NUMBERS)).isEqualTo(GREATEST);
    assertThat(Double.isNaN(max(VALUES))).isTrue();
  }

  @GwtIncompatible
  public void testMin_noArgs() {

              new byte[] {(byte) 0xcd, (byte) 0xab, (byte) 0x00, (byte) 0x00},
              0x0000abcd,
              null,
              "cdab0000"),
          new ExpectedHashCode(
              new byte[] {
                (byte) 0xef, (byte) 0xcd, (byte) 0xab, (byte) 0x00,
                (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00
              },
              0x00abcdef,
              0x0000000000abcdefL,

  private static final Inet4Address LOOPBACK4 = (Inet4Address) forString("127.0.0.1");
  private static final Inet4Address ANY4 = (Inet4Address) forString("0.0.0.0");

  private InetAddresses() {}

  /**
   * Returns an {@link Inet4Address}, given a byte array representation of the IPv4 address.
   *

    val bytes = binaryData(200)
    data.write("0264".decodeHex()).write(bytes, 0, 100)
    data.write("8064".decodeHex()).write(bytes, 100, 100)
    clientReader.processNextFrame()
    callback.assertBinaryMessage(bytes)
  }

  @Test fun twoFrameNotContinuation() {
    val bytes = binaryData(200)
    data.write("0264".decodeHex()).write(bytes, 0, 100)
    data.write("8264".decodeHex()).write(bytes, 100, 100)

                super.printByLtsv(valueMap);
            }

            @Override
            protected void printByEcs(final Map<String, String> valueMap) {
                valueMap.put("time", "2022-01-01T00:00:00.000Z");
                valueMap.remove("ip");
                super.printByEcs(valueMap);
            }

            @Override
            protected void printLog(final String message) {

        val delays = mutableListOf(50.µs, -1L)

        override fun runOnce(): Long {
          log += "run@${taskFaker.nanoTime}"
          redQueue.cancelAll()
          return delays.removeAt(0)
        }
      },
      100.µs,
    )

    taskFaker.advanceUntil(0.µs)
    assertThat(log).isEmpty()

    taskFaker.advanceUntil(100.µs)
    assertThat(log).containsExactly("run@100000")