Improve allowNullValue handling when a null value is provided

This commit improves `AbstractValueAdaptingCache` to throw a dedicated
exception if `allowNullValues` is `false` and a `null` value is provided
anyway. This avoid a lower-level exception from the cache library that
will miss some context.

Issue: SPR-15173

spring-context/src/test/java/org/springframework/cache/AbstractCacheTests.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2015 the original author or authors.
+ * Copyright 2002-2017 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -26,6 +26,8 @@ import org.junit.Rule;
 import org.junit.Test;
 import org.junit.rules.ExpectedException;
 
+import org.springframework.cache.support.AbstractValueAdaptingCache;
+
 import static org.hamcrest.core.Is.*;
 import static org.junit.Assert.*;
 

spring-context/src/test/java/org/springframework/cache/AbstractValueAdaptingCacheTests.java

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2002-2017 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.cache;
+
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.ExpectedException;
+
+import org.springframework.cache.support.AbstractValueAdaptingCache;
+
+/**
+ *
+ * @author Stephane Nicoll
+ */
+public abstract class AbstractValueAdaptingCacheTests<T extends AbstractValueAdaptingCache>
+		extends AbstractCacheTests<T>  {
+
+	@Rule
+	public ExpectedException thrown = ExpectedException.none();
+
+	protected final static String CACHE_NAME_NO_NULL = "testCacheNoNull";
+
+	protected abstract T getCache(boolean allowNull);
+
+	@Test
+	public void testCachePutNullValueAllowNullFalse() {
+		T cache = getCache(false);
+		String key = createRandomKey();
+
+		this.thrown.expect(IllegalArgumentException.class);
+		this.thrown.expectMessage(CACHE_NAME_NO_NULL);
+		this.thrown.expectMessage(
+				"is configured to not allow null values but null was provided");
+		cache.put(key, null);
+	}
+
+}

spring-context/src/test/java/org/springframework/cache/concurrent/ConcurrentMapCacheManagerTests.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2015 the original author or authors.
+ * Copyright 2002-2017 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -104,14 +104,7 @@ public class ConcurrentMapCacheManagerTests {
 		assertEquals("value1", cache1x.get("key1").get());
 		cache1x.put("key2", 2);
 		assertEquals(2, cache1x.get("key2").get());
-		try {
-			cache1x.put("key3", null);
-			fail("Should have thrown NullPointerException");
-		}
-		catch (NullPointerException ex) {
-			// expected
-		}
-
+		
 		cm.setAllowNullValues(true);
 		Cache cache1y = cm.getCache("c1");
 

spring-context/src/test/java/org/springframework/cache/concurrent/ConcurrentMapCacheTests.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2016 the original author or authors.
+ * Copyright 2002-2017 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -25,7 +25,7 @@ import java.util.concurrent.ConcurrentMap;
 import org.junit.Before;
 import org.junit.Test;
 
-import org.springframework.cache.AbstractCacheTests;
+import org.springframework.cache.AbstractValueAdaptingCacheTests;
 import org.springframework.core.serializer.support.SerializationDelegate;
 
 import static org.junit.Assert.*;
@@ -35,23 +35,35 @@ import static org.junit.Assert.*;
  * @author Juergen Hoeller
  * @author Stephane Nicoll
  */
-public class ConcurrentMapCacheTests extends AbstractCacheTests<ConcurrentMapCache> {
+public class ConcurrentMapCacheTests
+		extends AbstractValueAdaptingCacheTests<ConcurrentMapCache> {
 
 	protected ConcurrentMap<Object, Object> nativeCache;
 
 	protected ConcurrentMapCache cache;
 
+	protected ConcurrentMap<Object, Object> nativeCacheNoNull;
+
+	protected ConcurrentMapCache cacheNoNull;
+
 
 	@Before
 	public void setUp() throws Exception {
 		this.nativeCache = new ConcurrentHashMap<>();
 		this.cache = new ConcurrentMapCache(CACHE_NAME, this.nativeCache, true);
+		this.nativeCacheNoNull = new ConcurrentHashMap<>();
+		this.cacheNoNull = new ConcurrentMapCache(CACHE_NAME_NO_NULL,
+				this.nativeCacheNoNull, false);
 		this.cache.clear();
 	}
 
 	@Override
 	protected ConcurrentMapCache getCache() {
-		return this.cache;
+		return getCache(true);
+	}
+
+	@Override protected ConcurrentMapCache getCache(boolean allowNull) {
+		return allowNull ? this.cache : this.cacheNoNull;
 	}
 
 	@Override