Coverage Summary for Class: MapComputeIfAbsentTester (com.google.common.collect.testing.testers)

1 /*
2  * Copyright (C) 2015 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.SUPPORTS_PUT;
23 
24 import com.google.common.annotations.GwtCompatible;
25 import com.google.common.collect.testing.AbstractMapTester;
26 import com.google.common.collect.testing.features.CollectionSize;
27 import com.google.common.collect.testing.features.MapFeature;
28 import java.util.Map;
29 import junit.framework.AssertionFailedError;
30 import org.junit.Ignore;
31 
32 /**
33  * A generic JUnit test which tests {@link Map#computeIfAbsent}. Can't be invoked directly; please
34  * see {@link com.google.common.collect.testing.MapTestSuiteBuilder}.
35  *
36  * @author Louis Wasserman
37  */
38 @GwtCompatible
39 @Ignore // Affects only Android test runner, which respects JUnit 4 annotations on JUnit 3 tests.
40 public class MapComputeIfAbsentTester<K, V> extends AbstractMapTester<K, V> {
41 
42   @MapFeature.Require(SUPPORTS_PUT)
43   public void testComputeIfAbsent_supportedAbsent() {
44     assertEquals(
45         "computeIfAbsent(notPresent, function) should return new value",
46         v3(),
47         getMap()
48             .computeIfAbsent(
49                 k3(),
50                 k -> {
51                   assertEquals(k3(), k);
52                   return v3();
53                 }));
54     expectAdded(e3());
55   }
56 
57   @MapFeature.Require(SUPPORTS_PUT)
58   @CollectionSize.Require(absent = ZERO)
59   public void testComputeIfAbsent_supportedPresent() {
60     assertEquals(
61         "computeIfAbsent(present, function) should return existing value",
62         v0(),
63         getMap()
64             .computeIfAbsent(
65                 k0(),
66                 k -> {
67                   throw new AssertionFailedError();
68                 }));
69     expectUnchanged();
70   }
71 
72   @MapFeature.Require(SUPPORTS_PUT)
73   public void testComputeIfAbsent_functionReturnsNullNotInserted() {
74     assertNull(
75         "computeIfAbsent(absent, returnsNull) should return null",
76         getMap()
77             .computeIfAbsent(
78                 k3(),
79                 k -> {
80                   assertEquals(k3(), k);
81                   return null;
82                 }));
83     expectUnchanged();
84   }
85 
86   @MapFeature.Require({SUPPORTS_PUT, ALLOWS_NULL_VALUES})
87   @CollectionSize.Require(absent = ZERO)
88   public void testComputeIfAbsent_nullTreatedAsAbsent() {
89     initMapWithNullValue();
90     assertEquals(
91         "computeIfAbsent(presentAssignedToNull, function) should return newValue",
92         getValueForNullKey(),
93         getMap()
94             .computeIfAbsent(
95                 getKeyForNullValue(),
96                 k -> {
97                   assertEquals(getKeyForNullValue(), k);
98                   return getValueForNullKey();
99                 }));
100     expectReplacement(entry(getKeyForNullValue(), getValueForNullKey()));
101   }
102 
103   @MapFeature.Require({SUPPORTS_PUT, ALLOWS_NULL_KEYS})
104   public void testComputeIfAbsent_nullKeySupported() {
105     getMap()
106         .computeIfAbsent(
107             null,
108             k -> {
109               assertNull(k);
110               return v3();
111             });
112     expectAdded(entry(null, v3()));
113   }
114 
115   static class ExpectedException extends RuntimeException {}
116 
117   @MapFeature.Require(SUPPORTS_PUT)
118   public void testComputeIfAbsent_functionThrows() {
119     try {
120       getMap()
121           .computeIfAbsent(
122               k3(),
123               k -> {
124                 assertEquals(k3(), k);
125                 throw new ExpectedException();
126               });
127       fail("Expected ExpectedException");
128     } catch (ExpectedException expected) {
129     }
130     expectUnchanged();
131   }
132 
133   @MapFeature.Require(absent = SUPPORTS_PUT)
134   public void testComputeIfAbsent_unsupportedAbsent() {
135     try {
136       getMap()
137           .computeIfAbsent(
138               k3(),
139               k -> {
140                 // allowed to be called
141                 assertEquals(k3(), k);
142                 return v3();
143               });
144       fail("computeIfAbsent(notPresent, function) should throw");
145     } catch (UnsupportedOperationException expected) {
146     }
147     expectUnchanged();
148   }
149 
150   @MapFeature.Require(absent = SUPPORTS_PUT)
151   @CollectionSize.Require(absent = ZERO)
152   public void testComputeIfAbsent_unsupportedPresentExistingValue() {
153     try {
154       assertEquals(
155           "computeIfAbsent(present, returnsCurrentValue) should return present or throw",
156           v0(),
157           getMap()
158               .computeIfAbsent(
159                   k0(),
160                   k -> {
161                     assertEquals(k0(), k);
162                     return v0();
163                   }));
164     } catch (UnsupportedOperationException tolerated) {
165     }
166     expectUnchanged();
167   }
168 
169   @MapFeature.Require(absent = SUPPORTS_PUT)
170   @CollectionSize.Require(absent = ZERO)
171   public void testComputeIfAbsent_unsupportedPresentDifferentValue() {
172     try {
173       assertEquals(
174           "computeIfAbsent(present, returnsDifferentValue) should return present or throw",
175           v0(),
176           getMap()
177               .computeIfAbsent(
178                   k0(),
179                   k -> {
180                     assertEquals(k0(), k);
181                     return v3();
182                   }));
183     } catch (UnsupportedOperationException tolerated) {
184     }
185     expectUnchanged();
186   }
187 
188   @MapFeature.Require(value = SUPPORTS_PUT, absent = ALLOWS_NULL_KEYS)
189   public void testComputeIfAbsent_nullKeyUnsupported() {
190     try {
191       getMap()
192           .computeIfAbsent(
193               null,
194               k -> {
195                 assertNull(k);
196                 return v3();
197               });
198       fail("computeIfAbsent(null, function) should throw");
199     } catch (NullPointerException expected) {
200     }
201     expectUnchanged();
202     expectNullKeyMissingWhenNullKeysUnsupported(
203         "Should not contain null key after unsupported computeIfAbsent(null, function)");
204   }
205 }