001/* 002 * Copyright (C) 2015 The Guava Authors 003 * 004 * Licensed under the Apache License, Version 2.0 (the "License"); 005 * you may not use this file except in compliance with the License. 006 * You may obtain a copy of the License at 007 * 008 * http://www.apache.org/licenses/LICENSE-2.0 009 * 010 * Unless required by applicable law or agreed to in writing, software 011 * distributed under the License is distributed on an "AS IS" BASIS, 012 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 013 * See the License for the specific language governing permissions and 014 * limitations under the License. 015 */ 016 017package com.google.common.collect.testing.testers; 018 019import static com.google.common.collect.testing.features.CollectionSize.ZERO; 020import static com.google.common.collect.testing.features.MapFeature.ALLOWS_NULL_KEYS; 021import static com.google.common.collect.testing.features.MapFeature.ALLOWS_NULL_VALUES; 022import static com.google.common.collect.testing.features.MapFeature.SUPPORTS_PUT; 023 024import com.google.common.annotations.GwtCompatible; 025import com.google.common.collect.testing.AbstractMapTester; 026import com.google.common.collect.testing.features.CollectionSize; 027import com.google.common.collect.testing.features.MapFeature; 028import com.google.errorprone.annotations.CanIgnoreReturnValue; 029import java.util.Map.Entry; 030import java.util.concurrent.ConcurrentMap; 031import org.junit.Ignore; 032 033/** 034 * A generic JUnit test which tests {@code putIfAbsent} operations on a concurrent map. Can't be 035 * invoked directly; please see {@link 036 * com.google.common.collect.testing.ConcurrentMapTestSuiteBuilder}. 037 * 038 * @author Louis Wasserman 039 */ 040@GwtCompatible 041@Ignore // Affects only Android test runner, which respects JUnit 4 annotations on JUnit 3 tests. 042@ElementTypesAreNonnullByDefault 043public class ConcurrentMapPutIfAbsentTester<K, V> extends AbstractMapTester<K, V> { 044 @Override 045 protected ConcurrentMap<K, V> getMap() { 046 return (ConcurrentMap<K, V>) super.getMap(); 047 } 048 049 @MapFeature.Require(SUPPORTS_PUT) 050 public void testPutIfAbsent_supportedAbsent() { 051 assertNull("putIfAbsent(notPresent, value) should return null", putIfAbsent(e3())); 052 expectAdded(e3()); 053 } 054 055 @MapFeature.Require(SUPPORTS_PUT) 056 @CollectionSize.Require(absent = ZERO) 057 public void testPutIfAbsent_supportedPresent() { 058 assertEquals( 059 "putIfAbsent(present, value) should return existing value", 060 v0(), 061 getMap().putIfAbsent(k0(), v3())); 062 expectUnchanged(); 063 } 064 065 @MapFeature.Require(absent = SUPPORTS_PUT) 066 public void testPutIfAbsent_unsupportedAbsent() { 067 try { 068 putIfAbsent(e3()); 069 fail("putIfAbsent(notPresent, value) should throw"); 070 } catch (UnsupportedOperationException expected) { 071 } 072 expectUnchanged(); 073 expectMissing(e3()); 074 } 075 076 @MapFeature.Require(absent = SUPPORTS_PUT) 077 @CollectionSize.Require(absent = ZERO) 078 public void testPutIfAbsent_unsupportedPresentExistingValue() { 079 try { 080 assertEquals( 081 "putIfAbsent(present, existingValue) should return present or throw", 082 v0(), 083 putIfAbsent(e0())); 084 } catch (UnsupportedOperationException tolerated) { 085 } 086 expectUnchanged(); 087 } 088 089 @MapFeature.Require(absent = SUPPORTS_PUT) 090 @CollectionSize.Require(absent = ZERO) 091 public void testPutIfAbsent_unsupportedPresentDifferentValue() { 092 try { 093 getMap().putIfAbsent(k0(), v3()); 094 } catch (UnsupportedOperationException tolerated) { 095 } 096 expectUnchanged(); 097 } 098 099 @MapFeature.Require(value = SUPPORTS_PUT, absent = ALLOWS_NULL_KEYS) 100 public void testPutIfAbsent_nullKeyUnsupported() { 101 try { 102 getMap().putIfAbsent(null, v3()); 103 fail("putIfAbsent(null, value) should throw"); 104 } catch (NullPointerException expected) { 105 } 106 expectUnchanged(); 107 expectNullKeyMissingWhenNullKeysUnsupported( 108 "Should not contain null key after unsupported putIfAbsent(null, value)"); 109 } 110 111 @MapFeature.Require(value = SUPPORTS_PUT, absent = ALLOWS_NULL_VALUES) 112 public void testPutIfAbsent_nullValueUnsupported() { 113 try { 114 getMap().putIfAbsent(k3(), null); 115 fail("putIfAbsent(key, null) should throw"); 116 } catch (NullPointerException expected) { 117 } 118 expectUnchanged(); 119 expectNullValueMissingWhenNullValuesUnsupported( 120 "Should not contain null value after unsupported put(key, null)"); 121 } 122 123 @MapFeature.Require(value = SUPPORTS_PUT, absent = ALLOWS_NULL_VALUES) 124 @CollectionSize.Require(absent = ZERO) 125 public void testPutIfAbsent_putWithNullValueUnsupported() { 126 try { 127 getMap().putIfAbsent(k0(), null); 128 } catch (NullPointerException tolerated) { 129 } 130 expectUnchanged(); 131 expectNullValueMissingWhenNullValuesUnsupported( 132 "Should not contain null after unsupported putIfAbsent(present, null)"); 133 } 134 135 @CanIgnoreReturnValue 136 private V putIfAbsent(Entry<K, V> entry) { 137 return getMap().putIfAbsent(entry.getKey(), entry.getValue()); 138 } 139}