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.annotations.GwtIncompatible; 20 import com.google.common.collect.testing.features.CollectionFeature; 21 import com.google.common.collect.testing.features.CollectionSize; 22 import java.lang.reflect.Method; 23 import java.util.ArrayDeque; 24 import java.util.Collection; 25 import java.util.Collections; 26 import java.util.LinkedList; 27 import java.util.PriorityQueue; 28 import java.util.Queue; 29 import java.util.concurrent.ArrayBlockingQueue; 30 import java.util.concurrent.ConcurrentLinkedDeque; 31 import java.util.concurrent.ConcurrentLinkedQueue; 32 import java.util.concurrent.LinkedBlockingDeque; 33 import java.util.concurrent.LinkedBlockingQueue; 34 import java.util.concurrent.PriorityBlockingQueue; 35 import junit.framework.Test; 36 import junit.framework.TestSuite; 37 38 /** 39 * Generates a test suite covering the {@link Queue} implementations in the {@link java.util} 40 * package. Can be subclassed to specify tests that should be suppressed. 41 * 42 * @author Jared Levy 43 */ 44 @GwtIncompatible 45 public class TestsForQueuesInJavaUtil { suite()46 public static Test suite() { 47 return new TestsForQueuesInJavaUtil().allTests(); 48 } 49 allTests()50 public Test allTests() { 51 TestSuite suite = new TestSuite(); 52 suite.addTest(testsForArrayDeque()); 53 suite.addTest(testsForLinkedList()); 54 suite.addTest(testsForArrayBlockingQueue()); 55 suite.addTest(testsForCheckedQueue()); 56 suite.addTest(testsForConcurrentLinkedDeque()); 57 suite.addTest(testsForConcurrentLinkedQueue()); 58 suite.addTest(testsForLinkedBlockingDeque()); 59 suite.addTest(testsForLinkedBlockingQueue()); 60 suite.addTest(testsForPriorityBlockingQueue()); 61 suite.addTest(testsForPriorityQueue()); 62 return suite; 63 } 64 suppressForCheckedQueue()65 protected Collection<Method> suppressForCheckedQueue() { 66 return Collections.emptySet(); 67 } 68 suppressForArrayDeque()69 protected Collection<Method> suppressForArrayDeque() { 70 return Collections.emptySet(); 71 } 72 suppressForLinkedList()73 protected Collection<Method> suppressForLinkedList() { 74 return Collections.emptySet(); 75 } 76 suppressForArrayBlockingQueue()77 protected Collection<Method> suppressForArrayBlockingQueue() { 78 return Collections.emptySet(); 79 } 80 suppressForConcurrentLinkedDeque()81 protected Collection<Method> suppressForConcurrentLinkedDeque() { 82 return Collections.emptySet(); 83 } 84 suppressForConcurrentLinkedQueue()85 protected Collection<Method> suppressForConcurrentLinkedQueue() { 86 return Collections.emptySet(); 87 } 88 suppressForLinkedBlockingDeque()89 protected Collection<Method> suppressForLinkedBlockingDeque() { 90 return Collections.emptySet(); 91 } 92 suppressForLinkedBlockingQueue()93 protected Collection<Method> suppressForLinkedBlockingQueue() { 94 return Collections.emptySet(); 95 } 96 suppressForPriorityBlockingQueue()97 protected Collection<Method> suppressForPriorityBlockingQueue() { 98 return Collections.emptySet(); 99 } 100 suppressForPriorityQueue()101 protected Collection<Method> suppressForPriorityQueue() { 102 return Collections.emptySet(); 103 } 104 testsForCheckedQueue()105 public Test testsForCheckedQueue() { 106 return QueueTestSuiteBuilder.using( 107 new TestStringQueueGenerator() { 108 @Override 109 public Queue<String> create(String[] elements) { 110 Queue<String> queue = new LinkedList<>(MinimalCollection.of(elements)); 111 return Collections.checkedQueue(queue, String.class); 112 } 113 }) 114 .named("checkedQueue/LinkedList") 115 .withFeatures( 116 CollectionFeature.GENERAL_PURPOSE, 117 CollectionFeature.ALLOWS_NULL_VALUES, 118 CollectionFeature.KNOWN_ORDER, 119 CollectionFeature.RESTRICTS_ELEMENTS, 120 CollectionSize.ANY) 121 // don't skip collection tests since checkedQueue() is not tested by TestsForListsInJavaUtil 122 .suppressing(suppressForCheckedQueue()) 123 .createTestSuite(); 124 } 125 126 public Test testsForArrayDeque() { 127 return QueueTestSuiteBuilder.using( 128 new TestStringQueueGenerator() { 129 @Override 130 public Queue<String> create(String[] elements) { 131 return new ArrayDeque<>(MinimalCollection.of(elements)); 132 } 133 }) 134 .named("ArrayDeque") 135 .withFeatures( 136 CollectionFeature.GENERAL_PURPOSE, CollectionFeature.KNOWN_ORDER, CollectionSize.ANY) 137 .suppressing(suppressForArrayDeque()) 138 .createTestSuite(); 139 } 140 141 public Test testsForLinkedList() { 142 return QueueTestSuiteBuilder.using( 143 new TestStringQueueGenerator() { 144 @Override 145 public Queue<String> create(String[] elements) { 146 return new LinkedList<>(MinimalCollection.of(elements)); 147 } 148 }) 149 .named("LinkedList") 150 .withFeatures( 151 CollectionFeature.GENERAL_PURPOSE, 152 CollectionFeature.ALLOWS_NULL_VALUES, 153 CollectionFeature.KNOWN_ORDER, 154 CollectionSize.ANY) 155 .skipCollectionTests() // already covered in TestsForListsInJavaUtil 156 .suppressing(suppressForLinkedList()) 157 .createTestSuite(); 158 } 159 160 public Test testsForArrayBlockingQueue() { 161 return QueueTestSuiteBuilder.using( 162 new TestStringQueueGenerator() { 163 @Override 164 public Queue<String> create(String[] elements) { 165 return new ArrayBlockingQueue<>(100, false, MinimalCollection.of(elements)); 166 } 167 }) 168 .named("ArrayBlockingQueue") 169 .withFeatures( 170 CollectionFeature.GENERAL_PURPOSE, CollectionFeature.KNOWN_ORDER, CollectionSize.ANY) 171 .suppressing(suppressForArrayBlockingQueue()) 172 .createTestSuite(); 173 } 174 175 public Test testsForConcurrentLinkedDeque() { 176 return QueueTestSuiteBuilder.using( 177 new TestStringQueueGenerator() { 178 @Override 179 public Queue<String> create(String[] elements) { 180 return new ConcurrentLinkedDeque<>(MinimalCollection.of(elements)); 181 } 182 }) 183 .named("ConcurrentLinkedDeque") 184 .withFeatures( 185 CollectionFeature.GENERAL_PURPOSE, CollectionFeature.KNOWN_ORDER, CollectionSize.ANY) 186 .suppressing(suppressForConcurrentLinkedDeque()) 187 .createTestSuite(); 188 } 189 190 public Test testsForConcurrentLinkedQueue() { 191 return QueueTestSuiteBuilder.using( 192 new TestStringQueueGenerator() { 193 @Override 194 public Queue<String> create(String[] elements) { 195 return new ConcurrentLinkedQueue<>(MinimalCollection.of(elements)); 196 } 197 }) 198 .named("ConcurrentLinkedQueue") 199 .withFeatures( 200 CollectionFeature.GENERAL_PURPOSE, CollectionFeature.KNOWN_ORDER, CollectionSize.ANY) 201 .suppressing(suppressForConcurrentLinkedQueue()) 202 .createTestSuite(); 203 } 204 205 public Test testsForLinkedBlockingDeque() { 206 return QueueTestSuiteBuilder.using( 207 new TestStringQueueGenerator() { 208 @Override 209 public Queue<String> create(String[] elements) { 210 return new LinkedBlockingDeque<>(MinimalCollection.of(elements)); 211 } 212 }) 213 .named("LinkedBlockingDeque") 214 .withFeatures( 215 CollectionFeature.GENERAL_PURPOSE, CollectionFeature.KNOWN_ORDER, CollectionSize.ANY) 216 .suppressing(suppressForLinkedBlockingDeque()) 217 .createTestSuite(); 218 } 219 220 public Test testsForLinkedBlockingQueue() { 221 return QueueTestSuiteBuilder.using( 222 new TestStringQueueGenerator() { 223 @Override 224 public Queue<String> create(String[] elements) { 225 return new LinkedBlockingQueue<>(MinimalCollection.of(elements)); 226 } 227 }) 228 .named("LinkedBlockingQueue") 229 .withFeatures( 230 CollectionFeature.GENERAL_PURPOSE, CollectionFeature.KNOWN_ORDER, CollectionSize.ANY) 231 .suppressing(suppressForLinkedBlockingQueue()) 232 .createTestSuite(); 233 } 234 235 // Not specifying KNOWN_ORDER for PriorityQueue and PriorityBlockingQueue 236 // even though they do have it, because our tests interpret KNOWN_ORDER to 237 // also mean that the iterator returns the head element first, which those 238 // don't. 239 240 public Test testsForPriorityBlockingQueue() { 241 return QueueTestSuiteBuilder.using( 242 new TestStringQueueGenerator() { 243 @Override 244 public Queue<String> create(String[] elements) { 245 return new PriorityBlockingQueue<>(MinimalCollection.of(elements)); 246 } 247 }) 248 .named("PriorityBlockingQueue") 249 .withFeatures(CollectionFeature.GENERAL_PURPOSE, CollectionSize.ANY) 250 .suppressing(suppressForPriorityBlockingQueue()) 251 .createTestSuite(); 252 } 253 254 public Test testsForPriorityQueue() { 255 return QueueTestSuiteBuilder.using( 256 new TestStringQueueGenerator() { 257 @Override 258 public Queue<String> create(String[] elements) { 259 return new PriorityQueue<>(MinimalCollection.of(elements)); 260 } 261 }) 262 .named("PriorityQueue") 263 .withFeatures(CollectionFeature.GENERAL_PURPOSE, CollectionSize.ANY) 264 .suppressing(suppressForPriorityQueue()) 265 .createTestSuite(); 266 } 267 } 268