// Decode
        smbInfoAllocation.decode(buffer, 0, buffer.length);

        // Verify - with sectPerAlloc = 1, capacity = alloc * bytesPerSect
        assertEquals(alloc * bytesPerSect, smbInfoAllocation.getCapacity());
        assertEquals(free * bytesPerSect, smbInfoAllocation.getFree());
    }

    @Test
    @DisplayName("Test decode with large bytes per sector")

            // When: Decoding the value
            ndrShort.decode(mockBuffer);

            // Then: Should set the negative value directly (no masking on decode)
            verify(mockBuffer).dec_ndr_short();
            assertEquals(negativeValue, ndrShort.value);
        }

        @Test
        @DisplayName("Should decode large value correctly")
        void testDecodeLargeValue() throws NdrException {

            assertEquals(FileSystemInformation.FS_SIZE_INFO, fileFsSizeInfo.getFileSystemInformationClass());
        }
    }

    @Nested
    @DisplayName("Decode Method Tests")
    class DecodeMethodTests {

        @Test
        @DisplayName("Should decode buffer with typical values correctly")
        void shouldDecodeBufferWithTypicalValues() throws SMBProtocolDecodingException {

	// server admin credentials change. This is done to ensure
	// that clients cannot decode the token using the temp
	// secret keys and generate an entirely new claim by essentially
	// hijacking the policies. We need to make sure that this is
	// based on admin credential such that token cannot be decoded
	// on the client side and is treated like an opaque value.
	claims, err := auth.ExtractClaims(token, secret)

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

        // Configure the mock NdrBuffer to return a specific value when dec_ndr_hyper is called
        when(mockNdrBuffer.dec_ndr_hyper()).thenReturn(decodedValue);

        // Call the decode method with the mocked NdrBuffer

    assertNull(Punycode.decode("xn--a-9b.net"))
    assertEquals("a՚.net", Punycode.decode("xn--a-99b.net"))
    assertEquals("a溠.net", Punycode.decode("xn--a-999b.net"))
    assertEquals("a\uD8E2\uDF5C.net", Punycode.decode("xn--a-9999b.net"))
    assertNull(Punycode.decode("xn--a-99999b.net"))
  }

  @Test fun dashInPrefix() {
    testEncodeDecode(
      unicode = "klmnöpqrst-uvwxy",

            assertEquals(FileSystemInformation.FS_FULL_SIZE_INFO, fileFsFullSizeInfo.getFileSystemInformationClass());
        }
    }

    @Nested
    @DisplayName("Decode Method Tests")
    class DecodeMethodTests {

        @Test
        @DisplayName("Should decode buffer with typical values correctly")
        void shouldDecodeBufferWithTypicalValues() throws SMBProtocolDecodingException {

                    this.info = new DfsEnumStruct();
                }
                this.info.decode(_src);

            }
            final int _totalentriesp = _src.dec_ndr_long();
            if (_totalentriesp != 0) {
                this.totalentries.decode(_src);

            }
            this.retval = _src.dec_ndr_long();
        }
    }

            // Setup for SamrSamEntry decode chain
            mockDeferredBuffer.deferred = mockDeferredBuffer;
            when(mockDeferredBuffer.dec_ndr_short()).thenReturn(0, 0, 0);

            // When: Decoding output
            message.decode_out(mockNdrBuffer);

            // Then: Should decode all output parameters
            verify(samArray).decode(mockNdrBuffer);

            assertEquals(0, buffer.getNumReferrals());
            assertEquals(0, buffer.getTflags());
        }
    }

    @Nested
    @DisplayName("Decode Tests")
    class DecodeTests {

        @Test
        @DisplayName("Should decode buffer with no referrals")
        void testDecodeNoReferrals() {
            // Prepare test data: pathConsumed=0, numReferrals=0, tflags=0