// Verify results is now set (even if empty)
        assertNotNull(response.getResults());
    }

    @ParameterizedTest
    @CsvSource({ "0x01, FILE_DIRECTORY_INFO", "0x02, FILE_FULL_DIRECTORY_INFO", "0x03, FILE_BOTH_DIRECTORY_INFO" })
    @DisplayName("Test constructor with different info class constants")
    void testConstructorWithDifferentInfoClasses(byte infoClass, String description) {

			[out] policy_handle *handle);

	[op(0x07)]
	int SamrOpenDomain([in] policy_handle *handle,
			[in] uint32_t access_mask,
			[in] sid_t *sid,
			[out] policy_handle *domain_handle);

	typedef struct {
		uint32_t idx;
		unicode_string name;
	} SamrSamEntry;

	typedef struct {
		uint32_t count;
		[size_is(count)] SamrSamEntry *entries;
	} SamrSamArray;

	[op(0x0f)]

    }

    @Test
    void testConstructorWithMalformedToken() {
        // Test that PACDecodingException is thrown for a malformed token
        byte[] malformedToken = new byte[] { 0x01, 0x02, 0x03 };
        PACDecodingException e = assertThrows(PACDecodingException.class, () -> new KerberosTicket(malformedToken, (byte) 0, keys));
        assertTrue(e.getMessage().startsWith("Malformed kerberos ticket"));
    }

        // Verify content
        assertEquals(SmbComTransaction.TRANS2_QUERY_FS_INFORMATION, buffer[0]);
        assertEquals(0x00, buffer[1]);
        assertEquals(0x03, buffer[2]); // Low byte of 0x0103
        assertEquals(0x01, buffer[3]); // High byte of 0x0103
    }

    @DisplayName("Test toString with different information levels")
    @ParameterizedTest

            request.setOffset(1000L);
            request.setRemainingBytes(500);
            request.setWriteFlags(0x01);

            // Update parameters
            request.setData(new byte[200], 0, 200);
            request.setOffset(2000L);
            request.setRemainingBytes(1000);
            request.setWriteFlags(0x02);

            // Update file ID
            byte[] newFileId = new byte[16];

            buffer[i] = (byte) (i * 2);
        }

        // Mock number of links (4 bytes)
        buffer[16] = 0x01;
        buffer[17] = 0x00;
        buffer[18] = 0x00;
        buffer[19] = 0x00;

        // Mock delete pending and directory flags
        buffer[20] = 0x00;
        buffer[21] = 0x00;

        return buffer;
    }

    private byte[] createMockFileInternalInfoBuffer() {

        byte[] src = new byte[200];
        // Setup minimal valid header
        src[0] = 0x00;
        src[1] = 0x01; // Transaction ID
        src[2] = 0x00; // Flags
        src[3] = 0x00; // Flags
        src[4] = 0x00;
        src[5] = 0x01; // Question count

        // Act
        int result = nodeStatusRequest.readWireFormat(src, 0);

        // Assert

     * .
     */
    @Test
    public void testToBinary() {
        assertThat(BinaryConversionUtil.toBinary(null), nullValue());
        final byte[] b = { 0x00, 0x01 };
        assertThat(BinaryConversionUtil.toBinary(b), is(b));
        assertThat(BinaryConversionUtil.toBinary("hoge"), is("hoge".getBytes()));
    }

    /**
     * Test method for

	},
	{
		// Zstd skippable frame header.
		header: []byte{0x2a, 0x4d, 0x18},
		f:      formatZstd,
	},
	{
		// LZ4
		header: []byte{0x4, 0x22, 0x4d, 0x18},
		f:      formatLZ4,
	},
	{
		// Snappy/S2 stream
		header: []byte{0xff, 0x06, 0x00, 0x00},
		f:      formatS2,
	},
	{
		header: []byte{0x42, 0x5a, 'h'},
		f:      formatBZ2,
	},
}

type untarOptions struct {
	ignoreDirs bool

      return false;
    }

    byte[] bytes = ip.getAddress();

    if ((bytes[8] | (byte) 0x03) != (byte) 0x03) {

      // Verify that high byte of the 64 bit identifier is zero, modulo
      // the U/L and G bits, with which we are not concerned.
      return false;
    }

    return (bytes[9] == (byte) 0x00) && (bytes[10] == (byte) 0x5e) && (bytes[11] == (byte) 0xfe);
  }

  /**