1 /* 2 * Copyright (C) 2007 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; 18 19 import java.util.ArrayDeque; 20 import java.util.Collection; 21 import java.util.Iterator; 22 import java.util.Queue; 23 import junit.framework.TestCase; 24 25 /** 26 * Tests for {@link Synchronized#queue} and {@link Queues#synchronizedQueue}. 27 * 28 * @author Kurt Alfred Kluever 29 */ 30 public class SynchronizedQueueTest extends TestCase { 31 create()32 protected Queue<String> create() { 33 TestQueue<String> inner = new TestQueue<>(); 34 Queue<String> outer = Synchronized.queue(inner, null); 35 inner.mutex = outer; 36 outer.add("foo"); // necessary because we try to remove elements later on 37 return outer; 38 } 39 40 private static final class TestQueue<E> implements Queue<E> { 41 private final Queue<E> delegate = Lists.newLinkedList(); 42 public Object mutex; 43 44 @Override offer(E o)45 public boolean offer(E o) { 46 assertTrue(Thread.holdsLock(mutex)); 47 return delegate.offer(o); 48 } 49 50 @Override poll()51 public E poll() { 52 assertTrue(Thread.holdsLock(mutex)); 53 return delegate.poll(); 54 } 55 56 @Override remove()57 public E remove() { 58 assertTrue(Thread.holdsLock(mutex)); 59 return delegate.remove(); 60 } 61 62 @Override remove(Object object)63 public boolean remove(Object object) { 64 assertTrue(Thread.holdsLock(mutex)); 65 return delegate.remove(object); 66 } 67 68 @Override peek()69 public E peek() { 70 assertTrue(Thread.holdsLock(mutex)); 71 return delegate.peek(); 72 } 73 74 @Override element()75 public E element() { 76 assertTrue(Thread.holdsLock(mutex)); 77 return delegate.element(); 78 } 79 80 @Override iterator()81 public Iterator<E> iterator() { 82 // We explicitly don't lock for iterator() 83 assertFalse(Thread.holdsLock(mutex)); 84 return delegate.iterator(); 85 } 86 87 @Override size()88 public int size() { 89 assertTrue(Thread.holdsLock(mutex)); 90 return delegate.size(); 91 } 92 93 @Override removeAll(Collection<?> collection)94 public boolean removeAll(Collection<?> collection) { 95 assertTrue(Thread.holdsLock(mutex)); 96 return delegate.removeAll(collection); 97 } 98 99 @Override isEmpty()100 public boolean isEmpty() { 101 assertTrue(Thread.holdsLock(mutex)); 102 return delegate.isEmpty(); 103 } 104 105 @Override contains(Object object)106 public boolean contains(Object object) { 107 assertTrue(Thread.holdsLock(mutex)); 108 return delegate.contains(object); 109 } 110 111 @Override add(E element)112 public boolean add(E element) { 113 assertTrue(Thread.holdsLock(mutex)); 114 return delegate.add(element); 115 } 116 117 @Override containsAll(Collection<?> collection)118 public boolean containsAll(Collection<?> collection) { 119 assertTrue(Thread.holdsLock(mutex)); 120 return delegate.containsAll(collection); 121 } 122 123 @Override addAll(Collection<? extends E> collection)124 public boolean addAll(Collection<? extends E> collection) { 125 assertTrue(Thread.holdsLock(mutex)); 126 return delegate.addAll(collection); 127 } 128 129 @Override retainAll(Collection<?> collection)130 public boolean retainAll(Collection<?> collection) { 131 assertTrue(Thread.holdsLock(mutex)); 132 return delegate.retainAll(collection); 133 } 134 135 @Override clear()136 public void clear() { 137 assertTrue(Thread.holdsLock(mutex)); 138 delegate.clear(); 139 } 140 141 @Override toArray()142 public Object[] toArray() { 143 assertTrue(Thread.holdsLock(mutex)); 144 return delegate.toArray(); 145 } 146 147 @Override toArray(T[] array)148 public <T> T[] toArray(T[] array) { 149 assertTrue(Thread.holdsLock(mutex)); 150 return delegate.toArray(array); 151 } 152 153 private static final long serialVersionUID = 0; 154 } 155 156 @SuppressWarnings("CheckReturnValue") testHoldsLockOnAllOperations()157 public void testHoldsLockOnAllOperations() { 158 create().element(); 159 create().offer("foo"); 160 create().peek(); 161 create().poll(); 162 create().remove(); 163 create().add("foo"); 164 create().addAll(ImmutableList.of("foo")); 165 create().clear(); 166 create().contains("foo"); 167 create().containsAll(ImmutableList.of("foo")); 168 create().equals(new ArrayDeque<>(ImmutableList.of("foo"))); 169 create().hashCode(); 170 create().isEmpty(); 171 create().iterator(); 172 create().remove("foo"); 173 create().removeAll(ImmutableList.of("foo")); 174 create().retainAll(ImmutableList.of("foo")); 175 create().size(); 176 create().toArray(); 177 create().toArray(new String[] {"foo"}); 178 } 179 } 180