blob: 4df3e5ffa6565665efcb55dc2f7c66d0c4fe28a4 [file] [log] [blame]
Bjorn Bringert1d580d02012-05-07 16:50:46 +01001/*
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
17package com.google.common.collect;
18
19import static com.google.common.base.Preconditions.checkNotNull;
20
21import com.google.common.collect.Synchronized.SynchronizedCollection;
22import com.google.common.collect.Synchronized.SynchronizedSet;
23import com.google.common.testing.SerializableTester;
24
25import junit.framework.TestCase;
26
27import java.io.Serializable;
28import java.util.Collection;
29import java.util.HashMap;
30import java.util.Map;
31import java.util.Set;
32
33/**
34 * Tests for {@code Synchronized#map}.
35 *
36 * @author Mike Bostock
37 */
38public class SynchronizedMapTest extends TestCase {
39 public final Object mutex = new Integer(1); // something Serializable
40
41 protected <K, V> Map<K, V> create() {
42 TestMap<K, V> inner = new TestMap<K, V>(new HashMap<K, V>(), mutex);
43 Map<K, V> outer = Synchronized.map(inner, mutex);
44 return outer;
45 }
46
47 static class TestMap<K, V> extends ForwardingMap<K, V>
48 implements Serializable {
49 public final Object mutex;
50 private Map<K, V> delegate;
51 public TestMap(Map<K, V> delegate, Object mutex) {
52 checkNotNull(mutex);
53 this.delegate = delegate;
54 this.mutex = mutex;
55 }
56
57 @Override protected Map<K, V> delegate() {
58 return delegate;
59 }
60
61 @Override public int size() {
62 assertTrue(Thread.holdsLock(mutex));
63 return super.size();
64 }
65
66 @Override public boolean isEmpty() {
67 assertTrue(Thread.holdsLock(mutex));
68 return super.isEmpty();
69 }
70
71 @Override public V remove(Object object) {
72 assertTrue(Thread.holdsLock(mutex));
73 return super.remove(object);
74 }
75
76 @Override public void clear() {
77 assertTrue(Thread.holdsLock(mutex));
78 super.clear();
79 }
80
81 @Override public boolean containsKey(Object key) {
82 assertTrue(Thread.holdsLock(mutex));
83 return super.containsKey(key);
84 }
85
86 @Override public boolean containsValue(Object value) {
87 assertTrue(Thread.holdsLock(mutex));
88 return super.containsValue(value);
89 }
90
91 @Override public V get(Object key) {
92 assertTrue(Thread.holdsLock(mutex));
93 return super.get(key);
94 }
95
96 @Override public V put(K key, V value) {
97 assertTrue(Thread.holdsLock(mutex));
98 return super.put(key, value);
99 }
100
101 @Override public void putAll(Map<? extends K, ? extends V> map) {
102 assertTrue(Thread.holdsLock(mutex));
103 super.putAll(map);
104 }
105
106 @Override public Set<K> keySet() {
107 assertTrue(Thread.holdsLock(mutex));
108 return super.keySet();
109 }
110
111 @Override public Collection<V> values() {
112 assertTrue(Thread.holdsLock(mutex));
113 return super.values();
114 }
115
116 @Override public Set<Entry<K, V>> entrySet() {
117 assertTrue(Thread.holdsLock(mutex));
118 return super.entrySet();
119 }
120
121 @Override public boolean equals(Object obj) {
122 assertTrue(Thread.holdsLock(mutex));
123 return super.equals(obj);
124 }
125
126 @Override public int hashCode() {
127 assertTrue(Thread.holdsLock(mutex));
128 return super.hashCode();
129 }
130
131 @Override public String toString() {
132 assertTrue(Thread.holdsLock(mutex));
133 return super.toString();
134 }
135
136 private static final long serialVersionUID = 0;
137 }
138
139 /*
140 * This is somewhat of a weak test; we verify that all of the methods are
141 * correct, but not that they're actually forwarding correctly. We also rely
142 * on the other tests (e.g., SynchronizedSetTest) to verify that the
143 * collection views are synchronized correctly.
144 */
145
146 public void testSize() {
147 create().size();
148 }
149
150 public void testIsEmpty() {
151 create().isEmpty();
152 }
153
154 public void testRemove() {
155 create().remove(null);
156 }
157
158 public void testClear() {
159 create().clear();
160 }
161
162 public void testContainsKey() {
163 create().containsKey(null);
164 }
165
166 public void testContainsValue() {
167 create().containsValue(null);
168 }
169
170 public void testGet() {
171 create().get(null);
172 }
173
174 public void testPut() {
175 create().put(null, null);
176 }
177
178 public void testPutAll() {
179 create().putAll(new HashMap<String, Integer>());
180 }
181
182 public void testKeySet() {
183 Map<String, Integer> map = create();
184 Set<String> keySet = map.keySet();
185 assertTrue(keySet instanceof SynchronizedSet);
186 assertSame(mutex, ((SynchronizedSet<?>) keySet).mutex);
187 }
188
189 public void testValues() {
190 Map<String, Integer> map = create();
191 Collection<Integer> values = map.values();
192 assertTrue(values instanceof SynchronizedCollection);
193 assertSame(mutex, ((SynchronizedCollection<?>) values).mutex);
194 }
195
196 public void testEntrySet() {
197 Map<String, Integer> map = create();
198 Set<Map.Entry<String, Integer>> entrySet = map.entrySet();
199 assertTrue(entrySet instanceof SynchronizedSet);
200 assertSame(mutex, ((SynchronizedSet<?>) entrySet).mutex);
201 }
202
203 public void testEquals() {
204 create().equals(new HashMap<String, Integer>());
205 }
206
207 public void testHashCode() {
208 create().hashCode();
209 }
210
211 public void testToString() {
212 create().toString();
213 }
214
215 public void testSerialization() {
216 SerializableTester.reserializeAndAssert(create());
217 }
218}