byte[] emptyData = new byte[8];

        PACDecodingException e = assertThrows(PACDecodingException.class, () -> new Pac(emptyData, keys));
        // Any PACDecodingException is acceptable for this test
        assertNotNull(e.getMessage());
    }

    @Test
    void testTooSmallPac() {
        // Test that PAC smaller than 8 bytes is rejected
        byte[] smallData = new byte[4];

	testCases := []struct {
		data           []byte
		expectedResult *FilterRule
		expectErr      bool
	}{
		{[]byte(`<FilterRule></FilterRule>`), nil, true},
		{[]byte(`<FilterRule><Name></Name></FilterRule>`), nil, true},
		{[]byte(`<FilterRule><Value></Value></FilterRule>`), nil, true},
		{[]byte(`<FilterRule><Name></Name><Value></Value></FilterRule>`), nil, true},

    /**
     * Size of the transform header in bytes
     */
    public static final int TRANSFORM_HEADER_SIZE = 52;

    private final byte[] signature = new byte[16];
    private final byte[] nonce = new byte[16];
    private int originalMessageSize;
    private int flags;
    private long sessionId;

    /**
     * Create a new SMB2 Transform Header
     */

        verifyNfold("password", 7,
                new byte[] { (byte) 0x78, (byte) 0xa0, (byte) 0x7b, (byte) 0x6c, (byte) 0xaf, (byte) 0x85, (byte) 0xfa });

        // 64-fold("Rough Consensus, and Running Code")
        verifyNfold("Rough Consensus, and Running Code", 8,
                new byte[] { (byte) 0xbb, (byte) 0x6e, (byte) 0xd3, (byte) 0x08, (byte) 0x70, (byte) 0xb7, (byte) 0xf0, (byte) 0xe0 });

        // 64-fold("kerberos")

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

    /**
     * {@inheritDoc}
     *
     * @see jcifs.internal.smb2.ServerMessageBlock2#readBytesWireFormat(byte[], int)
     */
    @Override

     * @param buffer
     *            the transaction buffer to use
     */
    public void setBuffer(final byte[] buffer) {
        this.txn_buf = buffer;
    }

    /**
     * Releases and returns the transaction buffer
     * @return the txn_buf
     */
    public byte[] releaseBuffer() {
        final byte[] buf = this.txn_buf;
        this.txn_buf = null;
        return buf;
    }

    /**

    /**
     * Channel type for RDMA version 1 with invalidate
     */
    public static int SMB2_CHANNEL_RDMA_V1_INVALIDATE = 0x2;

    private byte[] fileId;
    private final byte[] outputBuffer;
    private final int outputBufferOffset;
    private byte padding;
    private byte readFlags;
    private int readLength;
    private long offset;
    private int minimumCount;
    private int channel;
    private int remainingBytes;

            uuid.time_mid = (short) 0x9ABC;
            uuid.time_hi_and_version = (short) 0xDEF0;
            uuid.clock_seq_hi_and_reserved = (byte) 0x11;
            uuid.clock_seq_low = (byte) 0x22;
            uuid.node = new byte[] { (byte) 0xAA, (byte) 0xBB, (byte) 0xCC, (byte) 0xDD, (byte) 0xEE, (byte) 0xFF };

            // Mock the derive method to return a buffer for node encoding

      Byte[] suffix = {(byte) 86, (byte) 99};
      Byte[] all = concat(concat(prefix, elements), suffix);
      return asList(all).subList(2, elements.length + 2);
    }
  }

  private static Byte[] concat(Byte[] left, Byte[] right) {
    Byte[] result = new Byte[left.length + right.length];
    System.arraycopy(left, 0, result, 0, left.length);
    System.arraycopy(right, 0, result, left.length, right.length);

    }

    // KGS!@#$%
    static final byte[] S8 = { (byte) 0x4b, (byte) 0x47, (byte) 0x53, (byte) 0x21, (byte) 0x40, (byte) 0x23, (byte) 0x24, (byte) 0x25 };

    /*
     * Accepts key multiple of 7
     * Returns enc multiple of 8
     * Multiple is the same like: 21 byte key gives 24 byte result
     */
    static void E(final byte[] key, final byte[] data, final byte[] e) throws ShortBufferException {