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

        .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()

        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));

    }

    @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");

		&Pet{Name: "pet-slice-append-3"},
	)

	AssertAssociationCount(t, users, "Pets", 10, "After Append")

	// Replace -> same as append
	DB.Model(&users).Association("Pets").Replace(
		[]*Pet{{Name: "pet-slice-replace-1-1"}, {Name: "pet-slice-replace-1-2"}},
		[]*Pet{{Name: "pet-slice-replace-2-1"}, {Name: "pet-slice-replace-2-2"}},
		&Pet{Name: "pet-slice-replace-3"},
	)

        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

     * @return preferred encryption cipher list in order of preference for SMB3 encryption
     * @since 2.2
     */
    String getPreferredCiphers();

    /**
     * Property {@code jcifs.smb.client.aes256Enabled} (boolean, default true)
     *
     * @return whether AES-256 encryption ciphers are enabled for SMB3.x
     * @since 2.2
     */
    boolean isAES256Enabled();

    /**