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}