1/*
2 * Copyright (C) 2009 The Guava Authors
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17package com.google.common.collect.testing;
18
19import com.google.common.collect.testing.features.CollectionFeature;
20import com.google.common.collect.testing.features.CollectionSize;
21
22import junit.framework.Test;
23import junit.framework.TestSuite;
24
25import java.lang.reflect.Method;
26import java.util.Collection;
27import java.util.Collections;
28import java.util.LinkedList;
29import java.util.PriorityQueue;
30import java.util.Queue;
31import java.util.concurrent.ArrayBlockingQueue;
32import java.util.concurrent.ConcurrentLinkedQueue;
33import java.util.concurrent.LinkedBlockingQueue;
34import java.util.concurrent.PriorityBlockingQueue;
35
36/**
37 * Generates a test suite covering the {@link Queue} implementations in the
38 * {@link java.util} package. Can be subclassed to specify tests that should
39 * be suppressed.
40 *
41 * @author Jared Levy
42 */
43public class TestsForQueuesInJavaUtil {
44  public static Test suite() {
45    return new TestsForQueuesInJavaUtil().allTests();
46  }
47
48  public Test allTests() {
49    TestSuite suite = new TestSuite();
50    suite.addTest(testsForLinkedList());
51    suite.addTest(testsForArrayBlockingQueue());
52    suite.addTest(testsForConcurrentLinkedQueue());
53    suite.addTest(testsForLinkedBlockingQueue());
54    suite.addTest(testsForPriorityBlockingQueue());
55    suite.addTest(testsForPriorityQueue());
56    return suite;
57  }
58
59  protected Collection<Method> suppressForLinkedList() {
60    return Collections.emptySet();
61  }
62  protected Collection<Method> suppressForArrayBlockingQueue() {
63    return Collections.emptySet();
64  }
65  protected Collection<Method> suppressForConcurrentLinkedQueue() {
66    return Collections.emptySet();
67  }
68  protected Collection<Method> suppressForLinkedBlockingQueue() {
69    return Collections.emptySet();
70  }
71  protected Collection<Method> suppressForPriorityBlockingQueue() {
72    return Collections.emptySet();
73  }
74  protected Collection<Method> suppressForPriorityQueue() {
75    return Collections.emptySet();
76  }
77
78  public Test testsForLinkedList() {
79    return QueueTestSuiteBuilder
80        .using(new TestStringQueueGenerator() {
81            @Override public Queue<String> create(String[] elements) {
82              return new LinkedList<String>(MinimalCollection.of(elements));
83            }
84          })
85        .named("LinkedList")
86        .withFeatures(
87            CollectionFeature.GENERAL_PURPOSE,
88            CollectionFeature.ALLOWS_NULL_VALUES,
89            CollectionFeature.KNOWN_ORDER,
90            CollectionSize.ANY)
91        .skipCollectionTests() // already covered in TestsForListsInJavaUtil
92        .suppressing(suppressForLinkedList())
93        .createTestSuite();
94  }
95
96  public Test testsForArrayBlockingQueue() {
97    return QueueTestSuiteBuilder
98        .using(new TestStringQueueGenerator() {
99            @Override public Queue<String> create(String[] elements) {
100              return new ArrayBlockingQueue<String>(
101                  100, false, MinimalCollection.of(elements));
102            }
103          })
104        .named("ArrayBlockingQueue")
105        .withFeatures(
106            CollectionFeature.GENERAL_PURPOSE,
107            CollectionFeature.KNOWN_ORDER,
108            CollectionSize.ANY)
109        .suppressing(suppressForArrayBlockingQueue())
110        .createTestSuite();
111  }
112
113  public Test testsForConcurrentLinkedQueue() {
114    return QueueTestSuiteBuilder
115        .using(new TestStringQueueGenerator() {
116            @Override public Queue<String> create(String[] elements) {
117              return new ConcurrentLinkedQueue<String>(
118                  MinimalCollection.of(elements));
119            }
120          })
121        .named("ConcurrentLinkedQueue")
122        .withFeatures(
123            CollectionFeature.GENERAL_PURPOSE,
124            CollectionFeature.KNOWN_ORDER,
125            CollectionSize.ANY)
126        .suppressing(suppressForConcurrentLinkedQueue())
127        .createTestSuite();
128  }
129
130  public Test testsForLinkedBlockingQueue() {
131    return QueueTestSuiteBuilder
132        .using(new TestStringQueueGenerator() {
133            @Override public Queue<String> create(String[] elements) {
134              return new LinkedBlockingQueue<String>(
135                  MinimalCollection.of(elements));
136            }
137          })
138        .named("LinkedBlockingQueue")
139        .withFeatures(
140            CollectionFeature.GENERAL_PURPOSE,
141            CollectionFeature.KNOWN_ORDER,
142            CollectionSize.ANY)
143        .suppressing(suppressForLinkedBlockingQueue())
144        .createTestSuite();
145  }
146
147  // Not specifying KNOWN_ORDER for PriorityQueue and PriorityBlockingQueue
148  // even though they do have it, because our tests interpret KNOWN_ORDER to
149  // also mean that the iterator returns the head element first, which those
150  // don't.
151
152  public Test testsForPriorityBlockingQueue() {
153    return QueueTestSuiteBuilder
154        .using(new TestStringQueueGenerator() {
155            @Override public Queue<String> create(String[] elements) {
156              return new PriorityBlockingQueue<String>(
157                  MinimalCollection.of(elements));
158            }
159          })
160        .named("PriorityBlockingQueue")
161        .withFeatures(
162            CollectionFeature.GENERAL_PURPOSE,
163            CollectionSize.ANY)
164        .suppressing(suppressForPriorityBlockingQueue())
165        .createTestSuite();
166  }
167
168  public Test testsForPriorityQueue() {
169    return QueueTestSuiteBuilder
170        .using(new TestStringQueueGenerator() {
171            @Override public Queue<String> create(String[] elements) {
172              return new PriorityQueue<String>(MinimalCollection.of(elements));
173            }
174          })
175        .named("PriorityQueue")
176        .withFeatures(
177            CollectionFeature.GENERAL_PURPOSE,
178            CollectionSize.ANY)
179        .suppressing(suppressForPriorityQueue())
180        .createTestSuite();
181  }
182}
183