MOVL (AX)(X0*1), AX             // ERROR "invalid instruction"
	MOVL (AX)(Y0*1), AX             // ERROR "invalid instruction"
	// VSIB/VM is invalid without vector index.
	// TODO(quasilyte): improve error message (#21860).
	// "invalid VSIB address (missing vector index)"
	VPGATHERQQ Y2, (BP), Y1         // ERROR "invalid instruction"
	// AVX2GATHER mask/index/dest #UD cases.

        // Mock data for SmbQueryFSSizeInfo
        writeInt8(2000, buffer, 0); // total allocation units
        writeInt8(1000, buffer, 8); // free allocation units
        writeInt4(8, buffer, 16); // sectors per allocation unit
        writeInt4(4096, buffer, 20); // bytes per sector

        int bytesRead = response.readDataWireFormat(buffer, 0, buffer.length);

        assertEquals(24, bytesRead, "Should read 24 bytes");

 * This structure provides complete allocation details including total allocation units, caller-available free units,
 * actual free allocation units, sectors per allocation unit, and bytes per sector.
 */
public class FileFsFullSizeInformation implements AllocInfo, FileSystemInformation, Decodable {

    private long alloc; // Also handles SmbQueryFSSizeInfo
    private long free;

Using `gotestjsonbuildtext=1` restores the 1.23 behavior.
This setting will be removed in a future release, Go 1.28 at the earliest.

Go 1.24 changed [`crypto/rsa`](/pkg/crypto/rsa) to require RSA keys to be at
least 1024 bits. This behavior can be controlled with the `rsa1024min` setting.
Using `rsa1024min=0` restores the Go 1.23 behavior.

        byte[] data = { 1, 2, 3 };
        int outlen = 5;
        byte[] expanded = PacMac.expandNFold(data, outlen);
        assertNotNull(expanded);
        assertEquals(outlen, expanded.length);

        // Test vectors from RFC 3961 Appendix A.1
        // 64-fold("012345")
        verifyNfold("012345", 8,
                new byte[] { (byte) 0xbe, (byte) 0x07, (byte) 0x26, (byte) 0x31, (byte) 0x27, (byte) 0x6b, (byte) 0x19, (byte) 0x55 });

        }
        return out;
    }

    @Test
    @DisplayName("getNTHash: known vector for 'password'")
    void testGetNTHash_knownVector() {
        // Arrange
        String password = "password";
        // Known NT hash for "password" (UTF-16LE MD4)
        // This is a well-known test vector: password -> 8846F7EAEE8FB117AD06BDD830B7586C
        byte[] expected = hex("8846F7EAEE8FB117AD06BDD830B7586C");

    EXPECT_TRUE(found);
    TF_DeleteBuffer(op_list_buffer);
  }
}

void TestEncodeDecode(int line, const std::vector<string>& data) {
  const int64_t n = data.size();
  absl::Status status;
  for (const std::vector<int64_t>& dims :
       std::vector<std::vector<int64_t>>{{n}, {1, n}, {n, 1}, {n / 2, 2}}) {
    // Create C++ Tensor
    Tensor src(tensorflow::DT_STRING, TensorShape(dims));

/**
 * Represents the FILE_FS_SIZE_INFORMATION structure used to query file system size information.
 * This structure provides details about the total allocation units, free allocation units,
 * sectors per allocation unit, and bytes per sector for a file system volume.
 */
public class FileFsSizeInformation implements AllocInfo {

    private long alloc; // Also handles SmbQueryFSSizeInfo
    private long free;

/**
 * Represents the SMB_INFO_ALLOCATION information level used in SMB transaction requests.
 * This structure provides allocation information for a file system including total units,
 * free units, sectors per allocation unit, and bytes per sector.
 */
public class SmbInfoAllocation implements AllocInfo {

    /**
     * Default constructor for SMB allocation information.
     */
    public SmbInfoAllocation() {

        assertArrayEquals(result1, result2);
    }

    @Test
    void testHMACT64WithKnownTestVector() throws NoSuchAlgorithmException {
        // Test with known test vector
        // Using test vector from RFC 2104 adapted for HMACT64
        byte[] key = new byte[16];
        Arrays.fill(key, (byte) 0x0b);
        byte[] data = "Hi There".getBytes();