}

  public void testBase32LenientPadding() {
    testDecodes(base32(), "MZXW6", "foo");
    testDecodes(base32(), "MZXW6=", "foo");
    testDecodes(base32(), "MZXW6==", "foo");
    testDecodes(base32(), "MZXW6===", "foo"); // proper padding length
    testDecodes(base32(), "MZXW6====", "foo");
    testDecodes(base32(), "MZXW6=====", "foo");
  }

  public void testBase32AlternatePadding() {

	process.exit(1);
}

globalThis.require = require;
globalThis.fs = require("fs");
globalThis.path = require("path");
globalThis.TextEncoder = require("util").TextEncoder;
globalThis.TextDecoder = require("util").TextDecoder;

globalThis.performance ??= require("performance");

globalThis.crypto ??= require("crypto");

require("./wasm_exec");

const go = new Go();
go.argv = process.argv.slice(2);

     */
    public void testEncode() throws Exception {
        assertEquals("Program+Files", URLUtil.encode("Program Files", "UTF-8"));
    }

    /**
     * @throws Exception
     */
    public void testDecode() throws Exception {
        assertEquals("Program Files", URLUtil.decode("Program+Files", "UTF-8"));
    }

    /**
     * @throws Exception
     */
    public void testToCanonicalProtocol() throws Exception {

	if (!globalThis.TextEncoder) {
		throw new Error("globalThis.TextEncoder is not available, polyfill required");
	}

	if (!globalThis.TextDecoder) {
		throw new Error("globalThis.TextDecoder is not available, polyfill required");
	}

	const encoder = new TextEncoder("utf-8");
	const decoder = new TextDecoder("utf-8");

	globalThis.Go = class {
		constructor() {
			this.argv = ["js"];
			this.env = {};

        verify(mockNdrBuffer, times(1)).enc_ndr_hyper(testValue);
        verifyNoMoreInteractions(mockNdrBuffer);
    }

    @Test
    void testDecode() throws NdrException {
        // Test the decode method
        long decodedValue = 112233445566778L;
        NdrHyper ndrHyper = new NdrHyper(0); // Initialize with a dummy value

            verify(mockNdrBuffer).enc_ndr_referent(null, 1);
        }

        @Test
        @DisplayName("Should decode entry correctly")
        void testDecode() throws NdrException {
            // Given: Mocked buffer data
            samr.SamrSamEntry entry = new samr.SamrSamEntry();
            when(mockNdrBuffer.dec_ndr_long()).thenReturn(1, 100); // idx, _name_bufferp

            verify(mockNdrBuffer).enc_ndr_referent(null, 1);
        }

        @Test
        @DisplayName("Should decode entry correctly")
        void testDecode() throws NdrException {
            // Given: Mocked buffer data
            samr.SamrSamEntry entry = new samr.SamrSamEntry();
            when(mockNdrBuffer.dec_ndr_long()).thenReturn(1, 100); // idx, _name_bufferp

     * Verifies that the decode method of a concrete implementation is called
     * and interacts with the NdrBuffer as expected.
     * @throws NdrException if decoding fails.
     */
    @Test
    void testDecode() throws NdrException {
        // When
        ndrObject.decode(mockBuffer);

        // Then
        // Verify that our mock buffer had the expected method called.
        verify(mockBuffer).dec_ndr_long();
    }

        // Verify that enc_ndr_small was called with the correct value
        verify(mockNdrBuffer, times(1)).enc_ndr_small(100);
        verifyNoMoreInteractions(mockNdrBuffer);
    }

    @Test
    void testDecode() throws NdrException {
        // Define the value that dec_ndr_small should return
        int decodedValue = 200;
        when(mockNdrBuffer.dec_ndr_small()).thenReturn(decodedValue);

                Arguments.of("////", new byte[] { (byte) 0xff, (byte) 0xff, (byte) 0xff })); // all 0xFF bytes
    }

    @ParameterizedTest(name = "decode({1}) -> {2}")
    @MethodSource("decodeProvider")
    void testDecode(String encoded, byte[] expected) {
        // Act
        byte[] actual = Base64.decode(encoded);
        // Assert
        assertArrayEquals(expected, actual, "Base64.decode should return original bytes");
    }