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              // We are testing LinkedList / testing our tests on LinkedList.
148              @SuppressWarnings("JdkObsolete")
149              public Queue<String> create(String[] elements) {
150                return new LinkedList<>(MinimalCollection.of(elements));
151              }
152            })
153        .named("LinkedList")
154        .withFeatures(
155            CollectionFeature.GENERAL_PURPOSE,
156            CollectionFeature.ALLOWS_NULL_VALUES,
157            CollectionFeature.KNOWN_ORDER,
158            CollectionSize.ANY)
159        .skipCollectionTests() // already covered in TestsForListsInJavaUtil
160        .suppressing(suppressForLinkedList())
161        .createTestSuite();
162  }
163
164  public Test testsForArrayBlockingQueue() {
165    return QueueTestSuiteBuilder.using(
166            new TestStringQueueGenerator() {
167              @Override
168              public Queue<String> create(String[] elements) {
169                return new ArrayBlockingQueue<>(100, false, MinimalCollection.of(elements));
170              }
171            })
172        .named("ArrayBlockingQueue")
173        .withFeatures(
174            CollectionFeature.GENERAL_PURPOSE, CollectionFeature.KNOWN_ORDER, CollectionSize.ANY)
175        .suppressing(suppressForArrayBlockingQueue())
176        .createTestSuite();
177  }
178
179  public Test testsForConcurrentLinkedDeque() {
180    return QueueTestSuiteBuilder.using(
181            new TestStringQueueGenerator() {
182              @Override
183              public Queue<String> create(String[] elements) {
184                return new ConcurrentLinkedDeque<>(MinimalCollection.of(elements));
185              }
186            })
187        .named("ConcurrentLinkedDeque")
188        .withFeatures(
189            CollectionFeature.GENERAL_PURPOSE, CollectionFeature.KNOWN_ORDER, CollectionSize.ANY)
190        .suppressing(suppressForConcurrentLinkedDeque())
191        .createTestSuite();
192  }
193
194  public Test testsForConcurrentLinkedQueue() {
195    return QueueTestSuiteBuilder.using(
196            new TestStringQueueGenerator() {
197              @Override
198              public Queue<String> create(String[] elements) {
199                return new ConcurrentLinkedQueue<>(MinimalCollection.of(elements));
200              }
201            })
202        .named("ConcurrentLinkedQueue")
203        .withFeatures(
204            CollectionFeature.GENERAL_PURPOSE, CollectionFeature.KNOWN_ORDER, CollectionSize.ANY)
205        .suppressing(suppressForConcurrentLinkedQueue())
206        .createTestSuite();
207  }
208
209  public Test testsForLinkedBlockingDeque() {
210    return QueueTestSuiteBuilder.using(
211            new TestStringQueueGenerator() {
212              @Override
213              public Queue<String> create(String[] elements) {
214                return new LinkedBlockingDeque<>(MinimalCollection.of(elements));
215              }
216            })
217        .named("LinkedBlockingDeque")
218        .withFeatures(
219            CollectionFeature.GENERAL_PURPOSE, CollectionFeature.KNOWN_ORDER, CollectionSize.ANY)
220        .suppressing(suppressForLinkedBlockingDeque())
221        .createTestSuite();
222  }
223
224  public Test testsForLinkedBlockingQueue() {
225    return QueueTestSuiteBuilder.using(
226            new TestStringQueueGenerator() {
227              @Override
228              public Queue<String> create(String[] elements) {
229                return new LinkedBlockingQueue<>(MinimalCollection.of(elements));
230              }
231            })
232        .named("LinkedBlockingQueue")
233        .withFeatures(
234            CollectionFeature.GENERAL_PURPOSE, CollectionFeature.KNOWN_ORDER, CollectionSize.ANY)
235        .suppressing(suppressForLinkedBlockingQueue())
236        .createTestSuite();
237  }
238
239  // Not specifying KNOWN_ORDER for PriorityQueue and PriorityBlockingQueue
240  // even though they do have it, because our tests interpret KNOWN_ORDER to
241  // also mean that the iterator returns the head element first, which those
242  // don't.
243
244  public Test testsForPriorityBlockingQueue() {
245    return QueueTestSuiteBuilder.using(
246            new TestStringQueueGenerator() {
247              @Override
248              public Queue<String> create(String[] elements) {
249                return new PriorityBlockingQueue<>(MinimalCollection.of(elements));
250              }
251            })
252        .named("PriorityBlockingQueue")
253        .withFeatures(CollectionFeature.GENERAL_PURPOSE, CollectionSize.ANY)
254        .suppressing(suppressForPriorityBlockingQueue())
255        .createTestSuite();
256  }
257
258  public Test testsForPriorityQueue() {
259    return QueueTestSuiteBuilder.using(
260            new TestStringQueueGenerator() {
261              @Override
262              public Queue<String> create(String[] elements) {
263                return new PriorityQueue<>(MinimalCollection.of(elements));
264              }
265            })
266        .named("PriorityQueue")
267        .withFeatures(CollectionFeature.GENERAL_PURPOSE, CollectionSize.ANY)
268        .suppressing(suppressForPriorityQueue())
269        .createTestSuite();
270  }
271}