// Prepare byte array
        byte[] encryptionKey = "12345678".getBytes();
        byte[] domainNameBytes = "DOMAIN".getBytes(ServerMessageBlock.OEM_ENCODING);
        ByteBuffer buffer = ByteBuffer.allocate(response.byteCount);
        buffer.put(encryptionKey);
        buffer.put(domainNameBytes);
        buffer.put((byte) 0x00); // Null terminator

        byte[] byteData = buffer.array();

        return true;
    }

    @Override
    protected int writeSetupWireFormat(final byte[] dst, final int dstIndex) {
        return 0;
    }

    @Override
    protected int writeParametersWireFormat(final byte[] dst, final int dstIndex) {
        return 0;
    }

    @Override
    protected int writeDataWireFormat(final byte[] dst, final int dstIndex) {
        return 0;
    }

    @Override

    DataInput in = new LittleEndianDataInputStream(new ByteArrayInputStream(data));
    byte[] b = new byte[data.length];
    in.readFully(b);
    assertEquals(Bytes.asList(data), Bytes.asList(b));
  }

  public void testReadUnsignedByte_eof() throws IOException {
    DataInput in = new LittleEndianDataInputStream(new ByteArrayInputStream(new byte[0]));
    assertThrows(EOFException.class, () -> in.readUnsignedByte());
  }

func NewBitrotVerifier(algorithm BitrotAlgorithm, checksum []byte) *BitrotVerifier {
	return &BitrotVerifier{algorithm, checksum}
}

// BitrotVerifier can be used to verify protected data.
type BitrotVerifier struct {
	algorithm BitrotAlgorithm
	sum       []byte
}

// BitrotAlgorithmFromString returns a bitrot algorithm from the given string representation.

        // Calculate hash
        Method calcMethod = findMethod(transport.getClass(), "calculatePreauthHash", byte[].class, int.class, int.class, byte[].class);
        calcMethod.setAccessible(true);

        byte[] input = "test data".getBytes();
        byte[] oldHash = new byte[64];

        byte[] newHash = (byte[]) calcMethod.invoke(transport, input, 0, input.length, oldHash);

        assertNotNull(newHash);

            andxCommand = (byte) 0xFF;
            andx = null;

            dst[start + ANDX_COMMAND_OFFSET] = (byte) 0xFF;
            dst[start + ANDX_RESERVED_OFFSET] = (byte) 0x00;
            //            dst[start + ANDX_OFFSET_OFFSET] = (byte)0x00;
            //            dst[start + ANDX_OFFSET_OFFSET + 1] = (byte)0x00;
            dst[start + ANDX_OFFSET_OFFSET] = (byte) 0xde;

        byte[] encodeBuffer = new byte[1024];
        NdrBuffer dst = new NdrBuffer(encodeBuffer, 0);
        enumEx.encode_in(dst);

        // Simulate decode_out with null info and totalentries
        netdfs.NetrDfsEnumEx decodedEnumEx = new netdfs.NetrDfsEnumEx(null, 0, 0, null, null);

        // Manually encode the expected output for decode_out
        byte[] encodeBufferOut2 = new byte[1024];

	testCases := []struct {
		name         Name
		expectedData []byte
		expectErr    bool
	}{
		{ObjectAccessedAll, []byte("<Name>s3:ObjectAccessed:*</Name>"), false},
		{ObjectRemovedDelete, []byte("<Name>s3:ObjectRemoved:Delete</Name>"), false},
		{ObjectRemovedNoOP, []byte("<Name>s3:ObjectRemoved:NoOP</Name>"), false},
		{blankName, []byte("<Name></Name>"), false},
	}

	for i, testCase := range testCases {

        maxParameterCount = 0;
        maxDataCount = 0xFFFF;
        maxSetupCount = (byte) 0x00;
        setupCount = 2;
        name = "\\PIPE\\";
    }

    @Override
    int writeSetupWireFormat(final byte[] dst, int dstIndex) {
        dst[dstIndex] = subCommand;
        dstIndex++;
        dst[dstIndex++] = (byte) 0x00;
        writeInt2(pipeFid, dst, dstIndex);
        dstIndex += 2;
        return 4;
    }

        // Prepare test data with offset
        int offset = 10;
        String expectedFilename = "offsetfile.txt";
        byte[] buffer = new byte[200 + offset];
        byte[] dataBuffer = createValidBuffer(expectedFilename, "OFFSET~1.TXT", true);
        System.arraycopy(dataBuffer, 0, buffer, offset, dataBuffer.length);

        // Decode from offset