001/*
002 * Copyright (C) 2009 The Guava Authors
003 *
004 * Licensed under the Apache License, Version 2.0 (the "License");
005 * you may not use this file except in compliance with the License.
006 * You may obtain a copy of the License at
007 *
008 * http://www.apache.org/licenses/LICENSE-2.0
009 *
010 * Unless required by applicable law or agreed to in writing, software
011 * distributed under the License is distributed on an "AS IS" BASIS,
012 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
013 * See the License for the specific language governing permissions and
014 * limitations under the License.
015 */
016
017package com.google.common.collect.testing;
018
019import static java.util.Collections.emptySet;
020
021import com.google.common.annotations.GwtIncompatible;
022import com.google.common.collect.testing.features.CollectionFeature;
023import com.google.common.collect.testing.features.CollectionSize;
024import java.lang.reflect.Method;
025import java.util.ArrayDeque;
026import java.util.Collection;
027import java.util.Collections;
028import java.util.LinkedList;
029import java.util.PriorityQueue;
030import java.util.Queue;
031import java.util.concurrent.ArrayBlockingQueue;
032import java.util.concurrent.ConcurrentLinkedDeque;
033import java.util.concurrent.ConcurrentLinkedQueue;
034import java.util.concurrent.LinkedBlockingDeque;
035import java.util.concurrent.LinkedBlockingQueue;
036import java.util.concurrent.PriorityBlockingQueue;
037import junit.framework.Test;
038import junit.framework.TestSuite;
039
040/**
041 * Generates a test suite covering the {@link Queue} implementations in the {@link java.util}
042 * package. Can be subclassed to specify tests that should be suppressed.
043 *
044 * @author Jared Levy
045 */
046@GwtIncompatible
047public class TestsForQueuesInJavaUtil {
048  public static Test suite() {
049    return new TestsForQueuesInJavaUtil().allTests();
050  }
051
052  public Test allTests() {
053    TestSuite suite = new TestSuite();
054    suite.addTest(testsForArrayDeque());
055    suite.addTest(testsForLinkedList());
056    suite.addTest(testsForArrayBlockingQueue());
057    suite.addTest(testsForCheckedQueue());
058    suite.addTest(testsForConcurrentLinkedDeque());
059    suite.addTest(testsForConcurrentLinkedQueue());
060    suite.addTest(testsForLinkedBlockingDeque());
061    suite.addTest(testsForLinkedBlockingQueue());
062    suite.addTest(testsForPriorityBlockingQueue());
063    suite.addTest(testsForPriorityQueue());
064    return suite;
065  }
066
067  protected Collection<Method> suppressForCheckedQueue() {
068    return emptySet();
069  }
070
071  protected Collection<Method> suppressForArrayDeque() {
072    return emptySet();
073  }
074
075  protected Collection<Method> suppressForLinkedList() {
076    return emptySet();
077  }
078
079  protected Collection<Method> suppressForArrayBlockingQueue() {
080    return emptySet();
081  }
082
083  protected Collection<Method> suppressForConcurrentLinkedDeque() {
084    return emptySet();
085  }
086
087  protected Collection<Method> suppressForConcurrentLinkedQueue() {
088    return emptySet();
089  }
090
091  protected Collection<Method> suppressForLinkedBlockingDeque() {
092    return emptySet();
093  }
094
095  protected Collection<Method> suppressForLinkedBlockingQueue() {
096    return emptySet();
097  }
098
099  protected Collection<Method> suppressForPriorityBlockingQueue() {
100    return emptySet();
101  }
102
103  protected Collection<Method> suppressForPriorityQueue() {
104    return emptySet();
105  }
106
107  public Test testsForCheckedQueue() {
108    return QueueTestSuiteBuilder.using(
109            new TestStringQueueGenerator() {
110              @Override
111              public Queue<String> create(String[] elements) {
112                Queue<String> queue = new LinkedList<>(MinimalCollection.of(elements));
113                return Collections.checkedQueue(queue, String.class);
114              }
115            })
116        .named("checkedQueue/LinkedList")
117        .withFeatures(
118            CollectionFeature.GENERAL_PURPOSE,
119            CollectionFeature.ALLOWS_NULL_VALUES,
120            CollectionFeature.KNOWN_ORDER,
121            CollectionFeature.RESTRICTS_ELEMENTS,
122            CollectionSize.ANY)
123        // don't skip collection tests since checkedQueue() is not tested by TestsForListsInJavaUtil
124        .suppressing(suppressForCheckedQueue())
125        .createTestSuite();
126  }
127
128  public Test testsForArrayDeque() {
129    return QueueTestSuiteBuilder.using(
130            new TestStringQueueGenerator() {
131              @Override
132              public Queue<String> create(String[] elements) {
133                return new ArrayDeque<>(MinimalCollection.of(elements));
134              }
135            })
136        .named("ArrayDeque")
137        .withFeatures(
138            CollectionFeature.GENERAL_PURPOSE, CollectionFeature.KNOWN_ORDER, CollectionSize.ANY)
139        .suppressing(suppressForArrayDeque())
140        .createTestSuite();
141  }
142
143  public Test testsForLinkedList() {
144    return QueueTestSuiteBuilder.using(
145            new TestStringQueueGenerator() {
146              @Override
147              public Queue<String> create(String[] elements) {
148                return new LinkedList<>(MinimalCollection.of(elements));
149              }
150            })
151        .named("LinkedList")
152        .withFeatures(
153            CollectionFeature.GENERAL_PURPOSE,
154            CollectionFeature.ALLOWS_NULL_VALUES,
155            CollectionFeature.KNOWN_ORDER,
156            CollectionSize.ANY)
157        .skipCollectionTests() // already covered in TestsForListsInJavaUtil
158        .suppressing(suppressForLinkedList())
159        .createTestSuite();
160  }
161
162  public Test testsForArrayBlockingQueue() {
163    return QueueTestSuiteBuilder.using(
164            new TestStringQueueGenerator() {
165              @Override
166              public Queue<String> create(String[] elements) {
167                return new ArrayBlockingQueue<>(100, false, MinimalCollection.of(elements));
168              }
169            })
170        .named("ArrayBlockingQueue")
171        .withFeatures(
172            CollectionFeature.GENERAL_PURPOSE, CollectionFeature.KNOWN_ORDER, CollectionSize.ANY)
173        .suppressing(suppressForArrayBlockingQueue())
174        .createTestSuite();
175  }
176
177  public Test testsForConcurrentLinkedDeque() {
178    return QueueTestSuiteBuilder.using(
179            new TestStringQueueGenerator() {
180              @Override
181              public Queue<String> create(String[] elements) {
182                return new ConcurrentLinkedDeque<>(MinimalCollection.of(elements));
183              }
184            })
185        .named("ConcurrentLinkedDeque")
186        .withFeatures(
187            CollectionFeature.GENERAL_PURPOSE, CollectionFeature.KNOWN_ORDER, CollectionSize.ANY)
188        .suppressing(suppressForConcurrentLinkedDeque())
189        .createTestSuite();
190  }
191
192  public Test testsForConcurrentLinkedQueue() {
193    return QueueTestSuiteBuilder.using(
194            new TestStringQueueGenerator() {
195              @Override
196              public Queue<String> create(String[] elements) {
197                return new ConcurrentLinkedQueue<>(MinimalCollection.of(elements));
198              }
199            })
200        .named("ConcurrentLinkedQueue")
201        .withFeatures(
202            CollectionFeature.GENERAL_PURPOSE, CollectionFeature.KNOWN_ORDER, CollectionSize.ANY)
203        .suppressing(suppressForConcurrentLinkedQueue())
204        .createTestSuite();
205  }
206
207  public Test testsForLinkedBlockingDeque() {
208    return QueueTestSuiteBuilder.using(
209            new TestStringQueueGenerator() {
210              @Override
211              public Queue<String> create(String[] elements) {
212                return new LinkedBlockingDeque<>(MinimalCollection.of(elements));
213              }
214            })
215        .named("LinkedBlockingDeque")
216        .withFeatures(
217            CollectionFeature.GENERAL_PURPOSE, CollectionFeature.KNOWN_ORDER, CollectionSize.ANY)
218        .suppressing(suppressForLinkedBlockingDeque())
219        .createTestSuite();
220  }
221
222  public Test testsForLinkedBlockingQueue() {
223    return QueueTestSuiteBuilder.using(
224            new TestStringQueueGenerator() {
225              @Override
226              public Queue<String> create(String[] elements) {
227                return new LinkedBlockingQueue<>(MinimalCollection.of(elements));
228              }
229            })
230        .named("LinkedBlockingQueue")
231        .withFeatures(
232            CollectionFeature.GENERAL_PURPOSE, CollectionFeature.KNOWN_ORDER, CollectionSize.ANY)
233        .suppressing(suppressForLinkedBlockingQueue())
234        .createTestSuite();
235  }
236
237  // Not specifying KNOWN_ORDER for PriorityQueue and PriorityBlockingQueue
238  // even though they do have it, because our tests interpret KNOWN_ORDER to
239  // also mean that the iterator returns the head element first, which those
240  // don't.
241
242  public Test testsForPriorityBlockingQueue() {
243    return QueueTestSuiteBuilder.using(
244            new TestStringQueueGenerator() {
245              @Override
246              public Queue<String> create(String[] elements) {
247                return new PriorityBlockingQueue<>(MinimalCollection.of(elements));
248              }
249            })
250        .named("PriorityBlockingQueue")
251        .withFeatures(CollectionFeature.GENERAL_PURPOSE, CollectionSize.ANY)
252        .suppressing(suppressForPriorityBlockingQueue())
253        .createTestSuite();
254  }
255
256  public Test testsForPriorityQueue() {
257    return QueueTestSuiteBuilder.using(
258            new TestStringQueueGenerator() {
259              @Override
260              public Queue<String> create(String[] elements) {
261                return new PriorityQueue<>(MinimalCollection.of(elements));
262              }
263            })
264        .named("PriorityQueue")
265        .withFeatures(CollectionFeature.GENERAL_PURPOSE, CollectionSize.ANY)
266        .suppressing(suppressForPriorityQueue())
267        .createTestSuite();
268  }
269}