.host("host")
        .username("=[]:;\"~|?#@^/$%*")
        .build()
    assertThat(url.toString())
      .isEqualTo("http://%3D%5B%5D%3A%3B%22~%7C%3F%23%40%5E%2F$%25*@host/")
    assertThat(url.toUri().toString())
      .isEqualTo("http://%3D%5B%5D%3A%3B%22~%7C%3F%23%40%5E%2F$%25*@host/")
  }

  @Test
  fun toUriPasswordSpecialCharacters() {
    val url =
      HttpUrl
        .Builder()

        fileStandardInfo.decode(buffer, 0, buffer.length);
        assertEquals(expectedEndOfFile, fileStandardInfo.getSize());
    }

    @Test
    @DisplayName("Test size method returns 22")
    void testSize() {
        assertEquals(22, fileStandardInfo.size());
    }

    @Test
    @DisplayName("Test decode with valid data")
    void testDecodeWithValidData() throws SMBProtocolDecodingException {
        // Prepare test data

        bb.putShort((short) 300); // ttl
        bb.putShort((short) 22); // pathOffset (relative to start of referral)
        bb.putShort((short) 54); // altPathOffset
        bb.putShort((short) 76); // nodeOffset

        // Path string at offset 22 (relative to start of referral at position 0)
        bb.position(22);
        String path = "\\\\server\\share";
        bb.put(path.getBytes(StandardCharsets.UTF_16LE));

        byte[] dst = new byte[1024];
        int result = setupAndX.writeParameterWordsWireFormat(dst, 0);

        // Verify that data was written (should write 22 bytes based on implementation)
        assertEquals(22, result, "writeParameterWordsWireFormat should write 22 bytes");
    }

    @Test
    void testWriteBytesWireFormat() {
        byte[] dst = new byte[1024];
        int result = setupAndX.writeBytesWireFormat(dst, 0);

    }

    @Test
    @DisplayName("Test decode with typical values")
    void testDecodeWithTypicalValues() throws SMBProtocolDecodingException {
        // Prepare test data
        byte[] buffer = new byte[22];
        int idFileSystem = 0x12345678;
        int sectPerAlloc = 8;
        long alloc = 1000000L;
        long free = 500000L;
        int bytesPerSect = 512;

        // Encode test data
        int offset = 0;

        assertEquals(DEFAULT_SECURITY_MODE, SMBUtil.readInt2(buffer, 20));

        // Verify dialect count (2 bytes)
        assertEquals(defaultDialects.length, SMBUtil.readInt2(buffer, 22));

        // Verify dialects
        int dialectOffset = 24;
        for (int i = 0; i < defaultDialects.length; i++) {
            assertEquals(defaultDialects[i], SMBUtil.readInt2(buffer, dialectOffset + i * 2));

            ImmutableMap.builder().put(1, 1).put(2, 2).buildOrThrow(),
            ImmutableMap.ofEntries(entry(1, 1), entry(2, 2)),
            map(1, 1, 2, 2))
        .addEqualityGroup(
            ImmutableMap.of(1, 1, 2, 2, 3, 3),
            ImmutableMap.builder().put(1, 1).put(2, 2).put(3, 3).buildOrThrow(),
            ImmutableMap.ofEntries(entry(1, 1), entry(2, 2), entry(3, 3)),
            map(1, 1, 2, 2, 3, 3))

        SMBUtil.writeInt2(testSecurityMode, buffer, bufferIndex + 20);

        // Set dialect (2 bytes)
        int testDialect = 0x0311;
        SMBUtil.writeInt2(testDialect, buffer, bufferIndex + 22);

        // Execute decode
        int bytesDecoded = response.decode(buffer, bufferIndex, 24);

        // Verify results
        assertEquals(24, bytesDecoded, "Should decode exactly 24 bytes");

        // v1-->v3
        graph.addEdge(v1, v3, new MetadataGraphEdge("1.1", true, null, null, 2, 1));
        graph.addEdge(v1, v3, new MetadataGraphEdge("1.2", true, null, null, 4, 2));

        // v3-->v4
        graph.addEdge(v3, v4, new MetadataGraphEdge("1.1", true, ArtifactScopeEnum.runtime, null, 2, 2));

        smb.useUnicode = true;
        String testString = "Hello Unicode World";
        byte[] buffer = new byte[testString.length() * 2 + 2];
        int len = smb.writeString(testString, buffer, 0);
        assertEquals(testString.length() * 2 + 2, len);
        String readString = smb.readString(buffer, 0);
        assertEquals(testString, readString);
    }

    @Test