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 
17 package com.google.common.collect.testing;
18 
19 import com.google.common.collect.testing.features.CollectionFeature;
20 import com.google.common.collect.testing.features.CollectionSize;
21 
22 import junit.framework.Test;
23 import junit.framework.TestSuite;
24 
25 import java.lang.reflect.Method;
26 import java.util.Collection;
27 import java.util.Collections;
28 import java.util.LinkedList;
29 import java.util.PriorityQueue;
30 import java.util.Queue;
31 import java.util.concurrent.ArrayBlockingQueue;
32 import java.util.concurrent.ConcurrentLinkedQueue;
33 import java.util.concurrent.LinkedBlockingQueue;
34 import 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  */
43 public class TestsForQueuesInJavaUtil {
suite()44   public static Test suite() {
45     return new TestsForQueuesInJavaUtil().allTests();
46   }
47 
allTests()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 
suppressForLinkedList()59   protected Collection<Method> suppressForLinkedList() {
60     return Collections.emptySet();
61   }
suppressForArrayBlockingQueue()62   protected Collection<Method> suppressForArrayBlockingQueue() {
63     return Collections.emptySet();
64   }
suppressForConcurrentLinkedQueue()65   protected Collection<Method> suppressForConcurrentLinkedQueue() {
66     return Collections.emptySet();
67   }
suppressForLinkedBlockingQueue()68   protected Collection<Method> suppressForLinkedBlockingQueue() {
69     return Collections.emptySet();
70   }
suppressForPriorityBlockingQueue()71   protected Collection<Method> suppressForPriorityBlockingQueue() {
72     return Collections.emptySet();
73   }
suppressForPriorityQueue()74   protected Collection<Method> suppressForPriorityQueue() {
75     return Collections.emptySet();
76   }
77 
testsForLinkedList()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