public void testMultiKeyPutWithNullKey() {

        final MultiKeyMap map = new MultiKeyMap();

        map.put("a", null, "value1");

        map.put("b", null, "value2");

        map.put("c", null, "value3");

        map.put("a", "z",  "value4");

        map.put("a", null, "value5");

        map.put(null, "a", "value6");

        map.put(null, null, "value7");

        assertEquals(6, map.size());

        assertEquals("value5", map.get("a", null));

        assertEquals("value4", map.get("a", "z"));

        assertEquals("value6", map.get(null, "a"));

    }

public abstract class AbstractIterableMap implements IterableMap {

    protected AbstractMapDecorator(final Map map) {

        if (map == null) {

        this.map = map;

    }

        return map;

        return decorated().size();

    protected static final Object NULL = new Object();

        super();

        this.loadFactor = loadFactor;

        this.data = new HashEntry[initialCapacity];

        this.threshold = threshold;

        init();

    }

    }

        return size;

        return key == null ? NULL : key;

        return hashCode & dataSize - 1;

        entry.setValue(newValue);

    }

        modCount++;

        final HashEntry entry = createEntry(data[hashIndex], hashCode, key, value);

        addEntry(entry, hashIndex);

        size++;

        checkCapacity();

    }

        return new HashEntry(next, hashCode, convertKey(key), value);

        data[hashIndex] = entry;

    }

        if (size >= threshold) {

    }

        this(new HashedMap, V>());

    }

        super(map);

        this.map = map;

    }

        final int hashCode = hash(key1, key2);

        AbstractHashedMap.HashEntry, V> entry =

        while (entry != null) {

            if (entry.hashCode == hashCode && isEqualKey(entry, key1, key2)) {

                return entry.getValue();

            entry = entry.next;

        final int hashCode = hash(key1, key2);

        final int index = decorated().hashIndex(hashCode, decorated().data.length);

        AbstractHashedMap.HashEntry, V> entry = decorated().data[index];

        while (entry != null) {

            if (entry.hashCode == hashCode && isEqualKey(entry, key1, key2)) {

                final V oldValue = entry.getValue();

                decorated().updateEntry(entry, value);

                return oldValue;

            entry = entry.next;

        decorated().addMapping(index, hashCode, new MultiKey(key1, key2), value);

        return null;

        int h = 0;

        if (key1 != null) {

            h ^= key1.hashCode();

        if (key2 != null) {

            h ^= key2.hashCode();

        h += ~(h << 9);

        h ^=  h >>> 14;

        h +=  h << 4;

        h ^=  h >>> 10;

        return h;

        final MultiKey multi = entry.getKey();

        return

        return (AbstractHashedMap, V>) super.decorated();

            super();

            this.next = next;

            this.hashCode = hashCode;

            this.key = key;

            this.value = value;

        }

            if (key == NULL) {

            return (K) key;

            return (V) value;

            final Object old = this.value;

            this.value = value;

            return (V) old;

        this((K[]) new Object[] { key1, key2 }, false);

    }

        super();

        if (keys == null) {

        if (makeClone) {

            this.keys = keys;

        calculateHashCode(keys);

    }

        return keys[index];

        return keys.length;

        int total = 0;

        for (final Object key : keys) {

            if (key != null) {

                total ^= key.hashCode();

        hashCode = total;

    }

        super(DEFAULT_CAPACITY, DEFAULT_LOAD_FACTOR, DEFAULT_THRESHOLD);

    }