public void testTransformedQueue() {

        Queue

        assertTrue("Returned object should be an TransformedQueue.", queue instanceof TransformedQueue);

        try {

            QueueUtils.transformingQueue(null, nopTransformer);

            fail("Expecting IllegalArgumentException for null queue.");

        } catch (final IllegalArgumentException ex) {

            // expected

        }

        try {

            QueueUtils.transformingQueue(new LinkedList

            fail("Expecting IllegalArgumentException for null transformer.");

        } catch (final IllegalArgumentException ex) {

            // expected

        }

    }

    protected AbstractCollectionDecorator(final Collection coll) {

        if (coll == null) {

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

        this.collection = coll;

    }

        return new TransformedQueue(queue, transformer);

        super(queue, transformer);

    }

        super(coll);

        if (predicate == null) {

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

        this.predicate = predicate;

        for (final E item : coll) {

    }

        super(coll);

        if (transformer == null) {

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

        this.transformer = transformer;

    }

    public static final Transformer INSTANCE = new NOPTransformer

        return (Transformer) INSTANCE;

        super();

    }

        return NOPTransformer.nopTransformer();

        if (queue instanceof Unmodifiable) {

        return new UnmodifiableQueue(queue);

        super((Queue) queue);

    }

    public static final Queue

        return UnmodifiableQueue.unmodifiableQueue(queue);

        return PredicatedQueue.predicatedQueue(queue, predicate);

        return TransformedQueue.transformingQueue(queue, transformer);

        super(queue);

    }

    public static final Predicate INSTANCE = new TruePredicate

        return (Predicate) INSTANCE;

        super();

    }

        return new PredicatedQueue(Queue, predicate);

        super(queue, predicate);

    }