Java

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.testing.testers;
18

19
import static com.google.common.collect.testing.features.CollectionSize.ZERO;
20
import static com.google.common.collect.testing.features.MapFeature.ALLOWS_NULL_KEYS;
21
import static com.google.common.collect.testing.features.MapFeature.ALLOWS_NULL_VALUES;
22
import static com.google.common.collect.testing.features.MapFeature.FAILS_FAST_ON_CONCURRENT_MODIFICATION;
23
import static com.google.common.collect.testing.features.MapFeature.SUPPORTS_PUT;
24
import static java.util.Collections.singletonList;
25

26
import com.google.common.annotations.GwtCompatible;
27
import com.google.common.annotations.GwtIncompatible;
28
import com.google.common.annotations.J2ktIncompatible;
29
import com.google.common.collect.testing.AbstractMapTester;
30
import com.google.common.collect.testing.Helpers;
31
import com.google.common.collect.testing.MinimalCollection;
32
import com.google.common.collect.testing.features.CollectionSize;
33
import com.google.common.collect.testing.features.MapFeature;
34
import java.lang.reflect.Method;
35
import java.util.Collections;
36
import java.util.ConcurrentModificationException;
37
import java.util.Iterator;
38
import java.util.LinkedHashMap;
39
import java.util.List;
40
import java.util.Map;
41
import java.util.Map.Entry;
42
import org.checkerframework.checker.nullness.qual.Nullable;
43
import org.junit.Ignore;
44

45
/**
46
 * A generic JUnit test which tests {@code putAll} operations on a map. Can't be invoked directly;
47
 * please see {@link com.google.common.collect.testing.MapTestSuiteBuilder}.
48
 *
49
 * @author Chris Povirk
50
 * @author Kevin Bourrillion
51
 */
52
@GwtCompatible(emulated = true)
53
@Ignore // Affects only Android test runner, which respects JUnit 4 annotations on JUnit 3 tests.
54
@SuppressWarnings("JUnit4ClassUsedInJUnit3")
55
@ElementTypesAreNonnullByDefault
56
public class MapPutAllTester<K extends @Nullable Object, V extends @Nullable Object>
57
    extends AbstractMapTester<K, V> {
58
  private List<Entry<K, V>> containsNullKey;
59
  private List<Entry<K, V>> containsNullValue;
60

61
  @Override
62
  public void setUp() throws Exception {
63
    super.setUp();
64
    containsNullKey = singletonList(entry(null, v3()));
65
    containsNullValue = singletonList(entry(k3(), null));
66
  }
67

68
  @MapFeature.Require(SUPPORTS_PUT)
69
  public void testPutAll_supportedNothing() {
70
    getMap().putAll(emptyMap());
71
    expectUnchanged();
72
  }
73

74
  @MapFeature.Require(absent = SUPPORTS_PUT)
75
  public void testPutAll_unsupportedNothing() {
76
    try {
77
      getMap().putAll(emptyMap());
78
    } catch (UnsupportedOperationException tolerated) {
79
    }
80
    expectUnchanged();
81
  }
82

83
  @MapFeature.Require(SUPPORTS_PUT)
84
  public void testPutAll_supportedNonePresent() {
85
    putAll(createDisjointCollection());
86
    expectAdded(e3(), e4());
87
  }
88

89
  @MapFeature.Require(absent = SUPPORTS_PUT)
90
  public void testPutAll_unsupportedNonePresent() {
91
    try {
92
      putAll(createDisjointCollection());
93
      fail("putAll(nonePresent) should throw");
94
    } catch (UnsupportedOperationException expected) {
95
    }
96
    expectUnchanged();
97
    expectMissing(e3(), e4());
98
  }
99

100
  @MapFeature.Require(SUPPORTS_PUT)
101
  @CollectionSize.Require(absent = ZERO)
102
  public void testPutAll_supportedSomePresent() {
103
    putAll(MinimalCollection.of(e3(), e0()));
104
    expectAdded(e3());
105
  }
106

107
  @MapFeature.Require({FAILS_FAST_ON_CONCURRENT_MODIFICATION, SUPPORTS_PUT})
108
  @CollectionSize.Require(absent = ZERO)
109
  public void testPutAllSomePresentConcurrentWithEntrySetIteration() {
110
    try {
111
      Iterator<Entry<K, V>> iterator = getMap().entrySet().iterator();
112
      putAll(MinimalCollection.of(e3(), e0()));
113
      iterator.next();
114
      fail("Expected ConcurrentModificationException");
115
    } catch (ConcurrentModificationException expected) {
116
      // success
117
    }
118
  }
119

120
  @MapFeature.Require(absent = SUPPORTS_PUT)
121
  @CollectionSize.Require(absent = ZERO)
122
  public void testPutAll_unsupportedSomePresent() {
123
    try {
124
      putAll(MinimalCollection.of(e3(), e0()));
125
      fail("putAll(somePresent) should throw");
126
    } catch (UnsupportedOperationException expected) {
127
    }
128
    expectUnchanged();
129
  }
130

131
  @MapFeature.Require(absent = SUPPORTS_PUT)
132
  @CollectionSize.Require(absent = ZERO)
133
  public void testPutAll_unsupportedAllPresent() {
134
    try {
135
      putAll(MinimalCollection.of(e0()));
136
    } catch (UnsupportedOperationException tolerated) {
137
    }
138
    expectUnchanged();
139
  }
140

141
  @MapFeature.Require({SUPPORTS_PUT, ALLOWS_NULL_KEYS})
142
  public void testPutAll_nullKeySupported() {
143
    putAll(containsNullKey);
144
    expectAdded(containsNullKey.get(0));
145
  }
146

147
  @MapFeature.Require(value = SUPPORTS_PUT, absent = ALLOWS_NULL_KEYS)
148
  public void testPutAll_nullKeyUnsupported() {
149
    try {
150
      putAll(containsNullKey);
151
      fail("putAll(containsNullKey) should throw");
152
    } catch (NullPointerException expected) {
153
    }
154
    expectUnchanged();
155
    expectNullKeyMissingWhenNullKeysUnsupported(
156
        "Should not contain null key after unsupported putAll(containsNullKey)");
157
  }
158

159
  @MapFeature.Require({SUPPORTS_PUT, ALLOWS_NULL_VALUES})
160
  public void testPutAll_nullValueSupported() {
161
    putAll(containsNullValue);
162
    expectAdded(containsNullValue.get(0));
163
  }
164

165
  @MapFeature.Require(value = SUPPORTS_PUT, absent = ALLOWS_NULL_VALUES)
166
  public void testPutAll_nullValueUnsupported() {
167
    try {
168
      putAll(containsNullValue);
169
      fail("putAll(containsNullValue) should throw");
170
    } catch (NullPointerException expected) {
171
    }
172
    expectUnchanged();
173
    expectNullValueMissingWhenNullValuesUnsupported(
174
        "Should not contain null value after unsupported putAll(containsNullValue)");
175
  }
176

177
  @MapFeature.Require(SUPPORTS_PUT)
178
  public void testPutAll_nullCollectionReference() {
179
    try {
180
      getMap().putAll(null);
181
      fail("putAll(null) should throw NullPointerException");
182
    } catch (NullPointerException expected) {
183
    }
184
  }
185

186
  private Map<K, V> emptyMap() {
187
    return Collections.emptyMap();
188
  }
189

190
  private void putAll(Iterable<Entry<K, V>> entries) {
191
    Map<K, V> map = new LinkedHashMap<>();
192
    for (Entry<K, V> entry : entries) {
193
      map.put(entry.getKey(), entry.getValue());
194
    }
195
    getMap().putAll(map);
196
  }
197

198
  /**
199
   * Returns the {@link Method} instance for {@link #testPutAll_nullKeyUnsupported()} so that tests
200
   * can suppress it with {@code FeatureSpecificTestSuiteBuilder.suppressing()} until <a
201
   * href="http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=5045147">Sun bug 5045147</a> is fixed.
202
   */
203
  @J2ktIncompatible
204
  @GwtIncompatible // reflection
205
  public static Method getPutAllNullKeyUnsupportedMethod() {
206
    return Helpers.getMethod(MapPutAllTester.class, "testPutAll_nullKeyUnsupported");
207
  }
208
}
209