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

1 /*
2  * Copyright (C) 2016 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 java.util.Map.Entry;
30 import junit.framework.AssertionFailedError;
31 import org.junit.Ignore;
32 
33 /**
34  * A generic JUnit test which tests {@link Map#computeIfPresent}. Can't be invoked directly; please
35  * see {@link com.google.common.collect.testing.MapTestSuiteBuilder}.
36  *
37  * @author Louis Wasserman
38  */
39 @GwtCompatible
40 @Ignore // Affects only Android test runner, which respects JUnit 4 annotations on JUnit 3 tests.
41 public class MapComputeIfPresentTester<K, V> extends AbstractMapTester<K, V> {
42 
43   @MapFeature.Require(SUPPORTS_PUT)
44   public void testComputeIfPresent_supportedAbsent() {
45     assertNull(
46         "computeIfPresent(notPresent, function) should return null",
47         getMap()
48             .computeIfPresent(
49                 k3(),
50                 (k, v) -> {
51                   throw new AssertionFailedError();
52                 }));
53     expectUnchanged();
54   }
55 
56   @MapFeature.Require(SUPPORTS_PUT)
57   @CollectionSize.Require(absent = ZERO)
58   public void testComputeIfPresent_supportedPresent() {
59     assertEquals(
60         "computeIfPresent(present, function) should return new value",
61         v3(),
62         getMap()
63             .computeIfPresent(
64                 k0(),
65                 (k, v) -> {
66                   assertEquals(k0(), k);
67                   assertEquals(v0(), v);
68                   return v3();
69                 }));
70     expectReplacement(entry(k0(), v3()));
71   }
72 
73   @MapFeature.Require(SUPPORTS_PUT)
74   @CollectionSize.Require(absent = ZERO)
75   public void testComputeIfPresent_functionReturnsNull() {
76     assertNull(
77         "computeIfPresent(present, returnsNull) should return null",
78         getMap()
79             .computeIfPresent(
80                 k0(),
81                 (k, v) -> {
82                   assertEquals(k0(), k);
83                   assertEquals(v0(), v);
84                   return null;
85                 }));
86     expectMissing(e0());
87   }
88 
89   @MapFeature.Require({SUPPORTS_PUT, ALLOWS_NULL_VALUES})
90   @CollectionSize.Require(absent = ZERO)
91   public void testComputeIfPresent_nullTreatedAsAbsent() {
92     initMapWithNullValue();
93     assertNull(
94         "computeIfPresent(presentAssignedToNull, function) should return null",
95         getMap()
96             .computeIfPresent(
97                 getKeyForNullValue(),
98                 (k, v) -> {
99                   throw new AssertionFailedError();
100                 }));
101     expectReplacement(entry(getKeyForNullValue(), null));
102   }
103 
104   static class ExpectedException extends RuntimeException {}
105 
106   @MapFeature.Require(SUPPORTS_PUT)
107   @CollectionSize.Require(absent = ZERO)
108   public void testComputeIfPresent_functionThrows() {
109     try {
110       getMap()
111           .computeIfPresent(
112               k0(),
113               (k, v) -> {
114                 assertEquals(k0(), k);
115                 assertEquals(v0(), v);
116                 throw new ExpectedException();
117               });
118       fail("Expected ExpectedException");
119     } catch (ExpectedException expected) {
120     }
121     expectUnchanged();
122   }
123 
124   @MapFeature.Require({SUPPORTS_PUT, ALLOWS_NULL_KEYS})
125   @CollectionSize.Require(absent = ZERO)
126   public void testComputeIfPresent_nullKeySupportedPresent() {
127     initMapWithNullKey();
128     assertEquals(
129         "computeIfPresent(null, function) should return new value",
130         v3(),
131         getMap()
132             .computeIfPresent(
133                 null,
134                 (k, v) -> {
135                   assertNull(k);
136                   assertEquals(getValueForNullKey(), v);
137                   return v3();
138                 }));
139 
140     Entry<K, V>[] expected = createArrayWithNullKey();
141     expected[getNullLocation()] = entry(null, v3());
142     expectContents(expected);
143   }
144 
145   @MapFeature.Require({SUPPORTS_PUT, ALLOWS_NULL_KEYS})
146   public void testComputeIfPresent_nullKeySupportedAbsent() {
147     assertNull(
148         "computeIfPresent(null, function) should return null",
149         getMap()
150             .computeIfPresent(
151                 null,
152                 (k, v) -> {
153                   throw new AssertionFailedError();
154                 }));
155     expectUnchanged();
156   }
157 
158   @MapFeature.Require(absent = SUPPORTS_PUT)
159   public void testComputeIfPresent_unsupportedAbsent() {
160     try {
161       getMap()
162           .computeIfPresent(
163               k3(),
164               (k, v) -> {
165                 throw new AssertionFailedError();
166               });
167     } catch (UnsupportedOperationException tolerated) {
168     }
169     expectUnchanged();
170   }
171 
172   @MapFeature.Require(absent = SUPPORTS_PUT)
173   @CollectionSize.Require(absent = ZERO)
174   public void testComputeIfPresent_unsupportedPresent() {
175     try {
176       getMap().computeIfPresent(k0(), (k, v) -> v3());
177       fail("Expected UnsupportedOperationException");
178     } catch (UnsupportedOperationException expected) {
179     }
180     expectUnchanged();
181   }
182 }