assertThat(request.body).isNull()
    assertThat(request.tags).isEqualTo(EmptyTags)
  }

  @Test
  fun string() {
    val contentType = "text/plain; charset=utf-8".toMediaType()
    val body = "abc".toByteArray().toRequestBody(contentType)
    assertThat(body.contentType()).isEqualTo(contentType)
    assertThat(body.contentLength()).isEqualTo(3)
    assertThat(bodyToHex(body)).isEqualTo("616263")

        SMBUtil.writeInt4(1, buffer, notifyOffset + 4);
        SMBUtil.writeInt4(6, buffer, notifyOffset + 8); // 6 bytes filename
        System.arraycopy("abc".getBytes("UnicodeLittleUnmarked"), 0, buffer, notifyOffset + 12, 6);

        // Second notification starts at aligned offset
        notifyOffset = 108; // 80 + 28
        SMBUtil.writeInt4(0, buffer, notifyOffset);

    int FILE_WRITE_ATTRIBUTES = 0x00000100; // 9
    /** Delete access right */
    int DELETE = 0x00010000; // 16
    /** Read control access right */
    int READ_CONTROL = 0x00020000; // 17
    /** Write DAC access right */
    int WRITE_DAC = 0x00040000; // 18
    /** Write owner access right */
    int WRITE_OWNER = 0x00080000; // 19
    /** Synchronize access right */
    int SYNCHRONIZE = 0x00100000; // 20

          } else if (socketMode == Channel) {
            socketFactory(ChannelSocketFactory())
          }
        }.build()

    server.enqueue(MockResponse(body = "abc"))

    @Suppress("HttpUrlsUsage")
    val url =
      if (socketMode is TlsInstance) {
        "https://$hostname:${server.port}/get"
      } else {
        "http://$hostname:${server.port}/get"
      }

  public void testReadEmptyString() throws IOException {
    assertReadsCorrectly("");
  }

  public void testReadsStringsCorrectly() throws IOException {
    assertReadsCorrectly("abc");
    assertReadsCorrectly("abcde");
    assertReadsCorrectly("abcdefghijkl");
    assertReadsCorrectly(
        ""
            + "abcdefghijklmnopqrstuvwxyz\n"
            + "ABCDEFGHIJKLMNOPQRSTUVWXYZ\r"

    @DisplayName("readUTF(): decodes bytes after size prefix")
    void readUTF_decodes() throws Exception {
        SmbRandomAccessFile raf = spy(newInstance("r", false, false, false));
        // Size prefix 3, then bytes for "abc"
        doReturn(3).when(raf).readUnsignedShort();
        doAnswer(inv -> {
            byte[] b = inv.getArgument(0);
            int off = inv.getArgument(1);
            b[off] = 'a';

    val sink1 = stream1.sink.buffer()
    val sink2 = stream2.sink.buffer()
    sink1.writeUtf8("abc")
    assertFailsWith<IOException> {
      sink2.writeUtf8("abc")
      sink2.flush()
    }.also { expected ->
      assertThat(expected.message).isEqualTo("stream was reset: REFUSED_STREAM")
    }
    sink1.writeUtf8("def")
    sink1.close()

  }

  @SuppressWarnings("unchecked") // functor classes have no type parameters
  public void testGet_functors() {
    assertEquals(0, ArbitraryInstances.get(Comparator.class).compare("abc", 123));
    assertTrue(ArbitraryInstances.get(Predicate.class).apply("abc"));
    assertTrue(ArbitraryInstances.get(Equivalence.class).equivalent(1, 1));
    assertFalse(ArbitraryInstances.get(Equivalence.class).equivalent(1, 2));
  }

    // Test that only data and data-order is important, not the individual operations.
    new EqualsTester()
        .addEqualityGroup(
            hashFunction.hashUnencodedChars("abc"),
            hashFunction.newHasher().putUnencodedChars("abc").hash(),
            hashFunction.newHasher().putUnencodedChars("ab").putUnencodedChars("c").hash(),
            hashFunction.newHasher().putUnencodedChars("a").putUnencodedChars("bc").hash(),

    // Test that only data and data-order is important, not the individual operations.
    new EqualsTester()
        .addEqualityGroup(
            hashFunction.hashUnencodedChars("abc"),
            hashFunction.newHasher().putUnencodedChars("abc").hash(),
            hashFunction.newHasher().putUnencodedChars("ab").putUnencodedChars("c").hash(),
            hashFunction.newHasher().putUnencodedChars("a").putUnencodedChars("bc").hash(),