public void test_encode() {
        assertNull(permissionHelper.encode(null));
        assertNull(permissionHelper.encode(""));
        assertNull(permissionHelper.encode(" "));
        assertNull(permissionHelper.encode("{user}"));
        assertNull(permissionHelper.encode("{role}"));
        assertNull(permissionHelper.encode("{group}"));
        assertNull(permissionHelper.encode("(allow)"));

        byte[] encoded = AvPairs.encode(pairs);

        assertNotNull(encoded, "Encoded data should not be null");
        assertEquals(4, encoded.length, "Should only have EOL (4 bytes)");
        assertEquals(AvPair.MsvAvEOL, SMBUtil.readInt2(encoded, 0), "Should be EOL");
        assertEquals(0, SMBUtil.readInt2(encoded, 2), "EOL length should be 0");
    }

    /**
     * Test round-trip encoding and decoding

 *
 *  * In queries, ' ' is encoded to '+' and '+' is encoded to "%2B".
 *
 *  * Characters in `encodeSet` are percent-encoded.
 *
 *  * Control characters and non-ASCII characters are percent-encoded.
 *
 *  * All other characters are copied without transformation.
 *
 * @param alreadyEncoded true to leave '%' as-is; false to convert it to '%25'.

  }

  private fun testToUrl(
    codePoint: Int,
    encoding: UrlComponentEncodingTester.Encoding,
    component: Component,
  ) {
    val encoded = encoding.encode(codePoint)
    val httpUrl = component.urlString(encoded).toHttpUrl()
    val javaNetUrl = httpUrl.toUrl()
    if (javaNetUrl.toString() != javaNetUrl.toString()) {
      fail("Encoding $component $codePoint using $encoding")
    }
  }

                }
            }
        }
        return hash;
    }

    /**
     * Encodes a similar document hash using GZIP compression and Base64 encoding.
     * This reduces storage space for hash values while maintaining uniqueness.
     *
     * @param hash the hash string to encode
     * @return the encoded hash string with prefix, or the original hash if encoding fails
     */

            byte[] buffer = new byte[8];
            int encoded = original.encode(buffer, 0);

            assertEquals(8, encoded);

            // Decode into new instance
            FileEndOfFileInformation decoded = new FileEndOfFileInformation();
            int decodedBytes = decoded.decode(buffer, 0, buffer.length);

            assertEquals(8, decodedBytes);

            // Verify values match

		MountPath: "/tmp/drive1",
		ID:        "uuid",
		Error:     "",
	}

	var buf bytes.Buffer
	gob.NewEncoder(&buf).Encode(v)
	encoded := buf.Bytes()
	b.Log("Size:", buf.Len(), "bytes")
	b.SetBytes(1)
	b.ReportAllocs()

	for b.Loop() {
		dec := gob.NewDecoder(bytes.NewBuffer(encoded))
		err := dec.Decode(&v)
		if err != nil {
			b.Fatal(err)
		}
	}
}

            byte[] buffer = new byte[EXPECTED_SIZE * 3];

            // When
            int offset1 = chunk1.encode(buffer, 0);
            int offset2 = chunk2.encode(buffer, offset1);
            int offset3 = chunk3.encode(buffer, offset1 + offset2);

            // Then
            assertEquals(EXPECTED_SIZE, offset1);
            assertEquals(EXPECTED_SIZE, offset2);

        decoded.decode(buf);
        assertEquals(val, decoded.value, "Decoded value should match encoded value for " + Long.toHexString(val));
    }

    /**
     * Ensure encode throws NPE when passed a null buffer.
     */
    @Test
    @DisplayName("Encode with null buffer throws NullPointerException")
    public void testEncodeNullBuffer() throws NdrException {
        NdrHyper hyper = new NdrHyper(5L);

            SrvCopychunkCopy copy = new SrvCopychunkCopy(sourceKey, mockChunk1, mockChunk2);
            byte[] buffer = new byte[200];

            // When
            copy.encode(buffer, 0);

            // Then
            verify(mockChunk1, times(1)).encode(eq(buffer), eq(HEADER_SIZE));