*
     * @param key the key whose presence in this map is to be tested
     * @return true if this map contains a mapping for the specified key
     */
    @Override
    public boolean containsKey(final Object key) {
        return parent.containsKey(key);
    }

    /**
     * Returns true if this map maps one or more keys to the specified value.
     *

    /*
     * 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 {
        final byte[] key7 = new byte[7];
        final byte[] e8 = new byte[8];

        for (int i = 0; i < key.length / 7; i++) {

                for (KerberosKey key : keys) {
                    keysByAlgo.put(key.getKeyType(), key);
                }

                KerberosKey serverKey = keysByAlgo.get(encType.getValue().intValue());
                if (keysByAlgo.isEmpty() || serverKey == null) {
                    throw new PACDecodingException("Kerberos key not found for eType " + encType.getValue());
                }

        keys.put(PacSignature.ETYPE_ARCFOUR_HMAC, hmacKey);
        keys.put(PacSignature.ETYPE_AES128_CTS_HMAC_SHA1_96, aes128Key);
        keys.put(PacSignature.ETYPE_AES256_CTS_HMAC_SHA1_96, aes256Key);

        // Test HMAC-MD5
        byte[] mac1 = PacMac.calculateMac(PacSignature.KERB_CHECKSUM_HMAC_MD5, keys, TEST_DATA);
        assertNotNull(mac1);

        # String columns may not be needed
        # to be set these condition-keys basically.
        #; GreaterThan = map:{}
        #; LessThan = map:{}
        #; GreaterEqual = map:{}
        #; LessEqual = map:{}

        # [Exclude]
        # Common columns of String type may not be needed
        # to be set these condition-keys basically.
        #; !NotEqual = map:{ $$ALL$$ = list:{ $$CommonColumn$$ } }

    /** Storage endpoint configuration key. */
    public static final String STORAGE_ENDPOINT = "storage.endpoint";

    /** Storage access key configuration key. */
    public static final String STORAGE_ACCESS_KEY = "storage.accesskey";

    /** Storage secret key configuration key. */
    public static final String STORAGE_SECRET_KEY = "storage.secretkey";

    }

    /**
     * Retrieves an extractor for the specified key.
     * If multiple extractors are associated with the key, returns a composite extractor
     * that tries each extractor in order until one succeeds.
     *
     * @param key the key to look up
     * @return the extractor for the key, or null if not found
     */
    public Extractor getExtractor(final String key) {

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

        for (int i = 0; i < key.length / 7; i++) {

     */
    public BeanMap() {
    }

    @Override
    public Object get(final Object key) {
        if (!containsKey(key)) {
            throw new IllegalKeyOfBeanMapException(key, this);
        }
        return super.get(key);
    }

     *
     * @param token the PAC token bytes
     * @param keys map of Kerberos keys indexed by key type
     * @throws PACDecodingException if PAC decoding fails
     */
    public KerberosPacAuthData(byte[] token, Map<Integer, KerberosKey> keys) throws PACDecodingException {
        this.pac = new Pac(token, keys);
    }

    /**
     * Returns the PAC object.
     *