public void testDecorateFactory() {

        final Queue queue = makeFullCollection();

        assertSame(queue, UnmodifiableQueue.unmodifiableQueue(queue));

        try {

            UnmodifiableQueue.unmodifiableQueue(null);

            fail();

        } catch (final IllegalArgumentException ex) {}

    }

        protected UnmodifiableEntrySetIterator(final Iterator> iterator) {

            super(iterator);

        }

            return new UnmodifiableEntry(getIterator().next());

            super();

            this.key = key;

            this.value = value;

            leftNode = new Node[2];

            rightNode = new Node[2];

            parentNode = new Node[2];

            blackColor = new boolean[] { true, true };

            calculatedHashCode = false;

        }

            switch (dataElement) {

                return getKey();

                return getValue();

            leftNode[dataElement.ordinal()] = node;

        }

            return leftNode[dataElement.ordinal()];

            rightNode[dataElement.ordinal()] = node;

        }

            return rightNode[dataElement.ordinal()];

            parentNode[dataElement.ordinal()] = node;

        }

            return parentNode[dataElement.ordinal()];

            return !blackColor[dataElement.ordinal()];

            blackColor[dataElement.ordinal()] = true;

        }

            blackColor[dataElement.ordinal()] = false;

        }

            return parentNode[dataElement.ordinal()] != null

            return parentNode[dataElement.ordinal()] != null

            return key;

            return value;

        if (coll instanceof Unmodifiable) {

            final Collection tmpColl = (Collection) coll;

            return tmpColl;

        return new UnmodifiableCollection(coll);

        super((Collection) coll);

    }

    private transient int nodeCount = 0;

    private transient int modifications = 0;

    private transient Inverse inverse = null;

        super();

        rootNode = new Node[2];

    }

        return nodeCount;

        checkKey(key);

        final Node node = lookupKey(key);

        return node == null ? null : node.getValue();

        final V result = get(key);

        doPut(key, value);

        return result;

        checkKeyAndValue(key, value);

        doRemoveKey(key);

        doRemoveValue(value);

        Node node = rootNode[KEY.ordinal()];

        if (node == null) {

            final Node root = new Node(key, value);

            rootNode[KEY.ordinal()] = root;

            rootNode[VALUE.ordinal()] = root;

            grow();

        } else {

                final int cmp = compare(key, node.getKey());

                if (cmp == 0) {

                } else if (cmp < 0) {

                    if (node.getLeft(KEY) != null) {

                        node = node.getLeft(KEY);

                        final Node newNode = new Node(key, value);

                        insertValue(newNode);

                        node.setLeft(newNode, KEY);

                        newNode.setParent(node, KEY);

                        doRedBlackInsert(newNode, KEY);

                        grow();

                        break;

                    if (node.getRight(KEY) != null) {

                        node = node.getRight(KEY);

                        final Node newNode = new Node(key, value);

                        insertValue(newNode);

                        node.setRight(newNode, KEY);

                        newNode.setParent(node, KEY);

                        doRedBlackInsert(newNode, KEY);

                        grow();

                        break;

            }

    }

        final Node node = lookupKey(key);

        if (node == null) {

            return null;

        final Node node = lookupValue(value);

        if (node == null) {

            return null;

        Node rval = null;

        Node node = rootNode[dataElement.ordinal()];

        while (node != null) {

            final int cmp = compare((T) data, (T) node.getData(dataElement));

            if (cmp == 0) {

                node = cmp < 0 ? node.getLeft(dataElement) : node.getRight(dataElement);

        }

        return rval;

        return this.lookup(key, KEY);

        return this.lookup(value, VALUE);

        return o1.compareTo(o2);

        return node != null && node.isRed(dataElement);

        if (node != null) {

            node.setRed(dataElement);

    }

        if (node != null) {

            node.setBlack(dataElement);

    }

        return getParent(getParent(node, dataElement), dataElement);

        return node == null ? null : node.getParent(dataElement);

        return node == null ? null : node.getRight(dataElement);

        return node == null ? null : node.getLeft(dataElement);

        final Node rightChild = node.getRight(dataElement);

        node.setRight(rightChild.getLeft(dataElement), dataElement);

        if (rightChild.getLeft(dataElement) != null) {

        rightChild.setParent(node.getParent(dataElement), dataElement);

        if (node.getParent(dataElement) == null) {

            rootNode[dataElement.ordinal()] = rightChild;

        } else if (node.getParent(dataElement).getLeft(dataElement) == node) {

            node.getParent(dataElement).setLeft(rightChild, dataElement);

            node.getParent(dataElement).setRight(rightChild, dataElement);

        rightChild.setLeft(node, dataElement);

        node.setParent(rightChild, dataElement);

    }

        final Node leftChild = node.getLeft(dataElement);

        node.setLeft(leftChild.getRight(dataElement), dataElement);

        if (leftChild.getRight(dataElement) != null) {

        leftChild.setParent(node.getParent(dataElement), dataElement);

        if (node.getParent(dataElement) == null) {

        } else if (node.getParent(dataElement).getRight(dataElement) == node) {

            node.getParent(dataElement).setRight(leftChild, dataElement);

        leftChild.setRight(node, dataElement);

        node.setParent(leftChild, dataElement);

    }

        Node currentNode = insertedNode;

        makeRed(currentNode, dataElement);

        while (currentNode != null

            if (currentNode.isLeftChild(dataElement)) {

                final Node y = getRightChild(getGrandParent(currentNode, dataElement), dataElement);

                if (isRed(y, dataElement)) {

                    makeBlack(getParent(currentNode, dataElement), dataElement);

                    makeBlack(y, dataElement);

                    makeRed(getGrandParent(currentNode, dataElement), dataElement);

                    currentNode = getGrandParent(currentNode, dataElement);

                    if (currentNode.isRightChild(dataElement)) {

                    makeBlack(getParent(currentNode, dataElement), dataElement);

                    makeRed(getGrandParent(currentNode, dataElement), dataElement);

                    if (getGrandParent(currentNode, dataElement) != null) {

                        rotateRight(getGrandParent(currentNode, dataElement), dataElement);

            } else {

                final Node y = getLeftChild(getGrandParent(currentNode, dataElement), dataElement);

                if (isRed(y, dataElement)) {

                    makeBlack(getParent(currentNode, dataElement), dataElement);

                    makeBlack(y, dataElement);

                    makeRed(getGrandParent(currentNode, dataElement), dataElement);

                    currentNode = getGrandParent(currentNode, dataElement);

                    if (currentNode.isLeftChild(dataElement)) {

                    makeBlack(getParent(currentNode, dataElement), dataElement);

                    makeRed(getGrandParent(currentNode, dataElement), dataElement);

                    if (getGrandParent(currentNode, dataElement) != null) {

                        rotateLeft(getGrandParent(currentNode, dataElement), dataElement);

            }

        makeBlack(rootNode[dataElement.ordinal()], dataElement);

    }

        if (o == null) {

        if (!(o instanceof Comparable)) {

    }

        checkNonNullComparable(key, KEY);

    }

        checkNonNullComparable(value, VALUE);

    }

        checkKey(key);

        checkValue(value);

    }

        modifications++;

    }

        modify();

        nodeCount++;

    }

        Node node = rootNode[VALUE.ordinal()];

            final int cmp = compare(newNode.getValue(), node.getValue());

            if (cmp == 0) {

            } else if (cmp < 0) {

                if (node.getLeft(VALUE) != null) {

                    node = node.getLeft(VALUE);

                    node.setLeft(newNode, VALUE);

                    newNode.setParent(node, VALUE);

                    doRedBlackInsert(newNode, VALUE);

                    break;

                if (node.getRight(VALUE) != null) {

                    node = node.getRight(VALUE);

                    node.setRight(newNode, VALUE);

                    newNode.setParent(node, VALUE);

                    doRedBlackInsert(newNode, VALUE);

                    break;

        }

    }

    protected AbstractMapDecorator(final Map map) {

        if (map == null) {

            throw new IllegalArgumentException("Map must not be null");

        this.map = map;

    }

        return map;

        return decorated().entrySet();

        if (map instanceof Unmodifiable) {

            final BidiMap tmpMap = (BidiMap) map;

            return tmpMap;

        return new UnmodifiableBidiMap(map);

        super((BidiMap) map);

    }

        if (map instanceof Unmodifiable) {

            final SortedBidiMap tmpMap = (SortedBidiMap) map;

            return tmpMap;

        return new UnmodifiableSortedBidiMap(map);

        super((SortedBidiMap) map);

    }

        final Set> set = super.entrySet();

        return UnmodifiableEntrySet.unmodifiableEntrySet(set);

        super(new HashMap(), new HashMap());

    }

        super(list);

    }

    static enum DataElement {

        KEY("key"), VALUE("value");

        private DataElement(final String description) {

            this.description = description;

        }

        super(list);

    }

        super(queue);

    }

        protected Map.Entry last = null;

        protected boolean canRemove = false;

            super(iterator);

            this.parent = parent;

        }

            last = new MapEntry(super.next(), parent);

            canRemove = true;

            return last;

        super(iterator);

    }

        return getIterator().next();

            super(entry);

            this.parent = parent;

        }

        super(map);

    }

        return (BidiMap) super.decorated();

    transient BidiMap inverseBidiMap = null;

    transient Set keySet = null;

    transient Set values = null;

    transient Set> entrySet = null;

        super();

        this.normalMap = normalMap;

        this.reverseMap = reverseMap;

    }

        return normalMap.size();

        if (normalMap.containsKey(key)) {

        if (reverseMap.containsKey(value)) {

        final V obj = normalMap.put(key, value);

        reverseMap.put(value, key);

        return obj;

        if (entrySet == null) {

            entrySet = new EntrySet(this);

        return entrySet;

        return new EntrySetIterator(iterator, this);

            super(parent.normalMap.entrySet(), parent);

        }

            return parent.createEntrySetIterator(super.iterator());

        super(map);

    }

        return (OrderedBidiMap) super.decorated();

            super(coll);

            this.parent = parent;

        }

        super();

        if (iterator == null) {

        this.iterator = iterator;

    }

        return iterator;

        return iterator.hasNext();

        switch (dataElement) {

        if (set instanceof Unmodifiable) {

        return new UnmodifiableEntrySet(set);

        super(set);

    }

        return new UnmodifiableEntrySetIterator(decorated().iterator());

        super(map);

    }

        return (SortedBidiMap) super.decorated();

    protected AbstractCollectionDecorator(final Collection coll) {

        if (coll == null) {

            throw new IllegalArgumentException("Collection must not be null");

        this.collection = coll;

    }

        return collection;

        return decorated().iterator();

        super(new TreeMap(), new TreeMap());

        this.comparator = null;

        this.valueComparator = null;

    }

        if (queue instanceof Unmodifiable) {

            final Queue tmpQueue = (Queue) queue;

            return tmpQueue;

        return new UnmodifiableQueue(queue);

        super((Queue) queue);

    }

        if (map instanceof Unmodifiable) {

            final OrderedBidiMap tmpMap = (OrderedBidiMap) map;

            return tmpMap;

        return new UnmodifiableOrderedBidiMap(map);

        super((OrderedBidiMap) map);

    }

public abstract class AbstractIterableMap implements IterableMap {

        if (list instanceof Unmodifiable) {

            final List tmpList = (List) list;

            return tmpList;

        super((List) list);

    }

    public AbstractMapEntryDecorator(final Map.Entry entry) {

        if (entry == null) {

        this.entry = entry;

    }

        return entry.getKey();

        return entry.getValue();

        super(set);

    }

        return (Set) super.decorated();

        protected UnmodifiableEntry(final Map.Entry entry) {

            super(entry);

        }