diff --git a/spring-context/src/test/java/org/springframework/cache/CacheReproTests.java b/spring-context/src/test/java/org/springframework/cache/CacheReproTests.java index 729bb61dfd..b33b8be756 100644 --- a/spring-context/src/test/java/org/springframework/cache/CacheReproTests.java +++ b/spring-context/src/test/java/org/springframework/cache/CacheReproTests.java @@ -16,7 +16,6 @@ package org.springframework.cache; -import java.util.Arrays; import java.util.Collection; import java.util.Collections; import java.util.List; @@ -128,8 +127,8 @@ public class CacheReproTests { AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(Spr13081Config.class); Spr13081Service bean = context.getBean(Spr13081Service.class); - thrown.expect(IllegalStateException.class); - thrown.expectMessage(MyCacheResolver.class.getName()); + this.thrown.expect(IllegalStateException.class); + this.thrown.expectMessage(MyCacheResolver.class.getName()); bean.getSimple(null); } @@ -235,7 +234,7 @@ public class CacheReproTests { @Bean public CacheManager cacheManager() { SimpleCacheManager cacheManager = new SimpleCacheManager(); - cacheManager.setCaches(Arrays.asList(cache())); + cacheManager.setCaches(Collections.singletonList(cache())); return cacheManager; } diff --git a/spring-context/src/test/java/org/springframework/cache/annotation/AnnotationCacheOperationSourceTests.java b/spring-context/src/test/java/org/springframework/cache/annotation/AnnotationCacheOperationSourceTests.java index 409d969213..19e800ee97 100644 --- a/spring-context/src/test/java/org/springframework/cache/annotation/AnnotationCacheOperationSourceTests.java +++ b/spring-context/src/test/java/org/springframework/cache/annotation/AnnotationCacheOperationSourceTests.java @@ -75,7 +75,7 @@ public class AnnotationCacheOperationSourceTests { @Test public void emptyCaching() throws Exception { - Collection ops = getOps(AnnotatedClass.class, "emptyCaching", 0); + getOps(AnnotatedClass.class, "emptyCaching", 0); } @Test @@ -155,7 +155,7 @@ public class AnnotationCacheOperationSourceTests { @Test public void keyAndKeyGeneratorCannotBeSetTogether() { - exception.expect(IllegalStateException.class); + this.exception.expect(IllegalStateException.class); getOps(AnnotatedClass.class, "invalidKeyAndKeyGeneratorSet"); } @@ -189,7 +189,7 @@ public class AnnotationCacheOperationSourceTests { @Test public void cacheResolverAndCacheManagerCannotBeSetTogether() { - exception.expect(IllegalStateException.class); + this.exception.expect(IllegalStateException.class); getOps(AnnotatedClass.class, "invalidCacheResolverAndCacheManagerSet"); } @@ -275,7 +275,7 @@ public class AnnotationCacheOperationSourceTests { private Collection getOps(Class target, String name) { try { Method method = target.getMethod(name); - return source.getCacheOperations(method, target); + return this.source.getCacheOperations(method, target); } catch (NoSuchMethodException ex) { throw new IllegalStateException(ex); diff --git a/spring-context/src/test/java/org/springframework/cache/config/AbstractCacheAnnotationTests.java b/spring-context/src/test/java/org/springframework/cache/config/AbstractCacheAnnotationTests.java index 8a00e7358a..ef5f0aa2ea 100644 --- a/spring-context/src/test/java/org/springframework/cache/config/AbstractCacheAnnotationTests.java +++ b/spring-context/src/test/java/org/springframework/cache/config/AbstractCacheAnnotationTests.java @@ -1,5 +1,5 @@ /* - * Copyright 2002-2015 the original author or authors. + * Copyright 2002-2016 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. @@ -60,12 +60,12 @@ public abstract class AbstractCacheAnnotationTests { @Before public void setup() { - ctx = getApplicationContext(); - cs = ctx.getBean("service", CacheableService.class); - ccs = ctx.getBean("classService", CacheableService.class); - cm = ctx.getBean("cacheManager", CacheManager.class); + this.ctx = getApplicationContext(); + this.cs = ctx.getBean("service", CacheableService.class); + this.ccs = ctx.getBean("classService", CacheableService.class); + this.cm = ctx.getBean("cacheManager", CacheManager.class); - Collection cn = cm.getCacheNames(); + Collection cn = this.cm.getCacheNames(); assertTrue(cn.contains("testCache")); assertTrue(cn.contains("secondary")); assertTrue(cn.contains("primary")); @@ -73,8 +73,8 @@ public abstract class AbstractCacheAnnotationTests { @After public void close() { - if (ctx != null) { - ctx.close(); + if (this.ctx != null) { + this.ctx.close(); } } @@ -92,7 +92,7 @@ public abstract class AbstractCacheAnnotationTests { public void testCacheableNull(CacheableService service) throws Exception { Object o1 = new Object(); - assertNull(cm.getCache("testCache").get(o1)); + assertNull(this.cm.getCache("testCache").get(o1)); Object r1 = service.cacheNull(o1); Object r2 = service.cacheNull(o1); @@ -101,7 +101,7 @@ public abstract class AbstractCacheAnnotationTests { assertSame(r1, r2); assertSame(r1, r3); - assertEquals(r3, cm.getCache("testCache").get(o1).get()); + assertEquals(r3, this.cm.getCache("testCache").get(o1).get()); assertNull("Cached value should be null", r3); } @@ -118,7 +118,7 @@ public abstract class AbstractCacheAnnotationTests { public void testCacheableSyncNull(CacheableService service) throws Exception { Object o1 = new Object(); - assertNull(cm.getCache("testCache").get(o1)); + assertNull(this.cm.getCache("testCache").get(o1)); Object r1 = service.cacheSyncNull(o1); Object r2 = service.cacheSyncNull(o1); @@ -127,7 +127,7 @@ public abstract class AbstractCacheAnnotationTests { assertSame(r1, r2); assertSame(r1, r3); - assertEquals(r3, cm.getCache("testCache").get(o1).get()); + assertEquals(r3, this.cm.getCache("testCache").get(o1).get()); assertNull("Cached value should be null", r3); } @@ -229,7 +229,7 @@ public abstract class AbstractCacheAnnotationTests { assertSame(r1, r2); assertNotSame(r1, r10); service.evictAll(new Object()); - Cache cache = cm.getCache("testCache"); + Cache cache = this.cm.getCache("testCache"); assertNull(cache.get(o1)); assertNull(cache.get(o2)); @@ -264,11 +264,11 @@ public abstract class AbstractCacheAnnotationTests { } public void testUnlessExpression(CacheableService service) throws Exception { - Cache cache = cm.getCache("testCache"); + Cache cache = this.cm.getCache("testCache"); cache.clear(); service.unless(10); service.unless(11); - assertThat(cache.get(10).get(), equalTo((Object) 10L)); + assertThat(cache.get(10).get(), equalTo(10L)); assertThat(cache.get(11), nullValue()); } @@ -311,7 +311,7 @@ public abstract class AbstractCacheAnnotationTests { Object key = new Object(); Object r1 = service.name(key); assertSame(r1, service.name(key)); - Cache cache = cm.getCache("testCache"); + Cache cache = this.cm.getCache("testCache"); // assert the method name is used assertNotNull(cache.get(keyName)); } @@ -320,7 +320,7 @@ public abstract class AbstractCacheAnnotationTests { Object key = new Object(); Object r1 = service.rootVars(key); assertSame(r1, service.rootVars(key)); - Cache cache = cm.getCache("testCache"); + Cache cache = this.cm.getCache("testCache"); // assert the method name is used String expectedKey = "rootVarsrootVars" + AopProxyUtils.ultimateTargetClass(service) + service; assertNotNull(cache.get(expectedKey)); @@ -340,7 +340,7 @@ public abstract class AbstractCacheAnnotationTests { public void testUncheckedThrowable(CacheableService service) throws Exception { try { - service.throwUnchecked(Long.valueOf(1)); + service.throwUnchecked(1L); fail("Excepted exception"); } catch (RuntimeException ex) { @@ -364,7 +364,7 @@ public abstract class AbstractCacheAnnotationTests { public void testUncheckedThrowableSync(CacheableService service) throws Exception { try { - service.throwUncheckedSync(Long.valueOf(1)); + service.throwUncheckedSync(1L); fail("Excepted exception"); } catch (RuntimeException ex) { @@ -380,7 +380,7 @@ public abstract class AbstractCacheAnnotationTests { public void testCacheUpdate(CacheableService service) { Object o = new Object(); - Cache cache = cm.getCache("testCache"); + Cache cache = this.cm.getCache("testCache"); assertNull(cache.get(o)); Object r1 = service.update(o); assertSame(r1, cache.get(o).get()); @@ -392,10 +392,10 @@ public abstract class AbstractCacheAnnotationTests { } public void testConditionalCacheUpdate(CacheableService service) { - Integer one = Integer.valueOf(1); - Integer three = Integer.valueOf(3); + Integer one = 1; + Integer three = 3; - Cache cache = cm.getCache("testCache"); + Cache cache = this.cm.getCache("testCache"); assertEquals(one, Integer.valueOf(service.conditionalUpdate(one).toString())); assertNull(cache.get(one)); @@ -407,8 +407,8 @@ public abstract class AbstractCacheAnnotationTests { Object o1 = new Object(); Object o2 = new Object(); - Cache primary = cm.getCache("primary"); - Cache secondary = cm.getCache("secondary"); + Cache primary = this.cm.getCache("primary"); + Cache secondary = this.cm.getCache("secondary"); assertNull(primary.get(o1)); assertNull(secondary.get(o1)); @@ -437,8 +437,8 @@ public abstract class AbstractCacheAnnotationTests { Object r1 = service.multiCache(o1); Object r2 = service.multiCache(o1); - Cache primary = cm.getCache("primary"); - Cache secondary = cm.getCache("secondary"); + Cache primary = this.cm.getCache("primary"); + Cache secondary = this.cm.getCache("secondary"); primary.put(o2, o2); assertSame(r1, r2); @@ -460,10 +460,10 @@ public abstract class AbstractCacheAnnotationTests { } public void testMultiPut(CacheableService service) { - Object o = Integer.valueOf(1); + Object o = 1; - Cache primary = cm.getCache("primary"); - Cache secondary = cm.getCache("secondary"); + Cache primary = this.cm.getCache("primary"); + Cache secondary = this.cm.getCache("secondary"); assertNull(primary.get(o)); assertNull(secondary.get(o)); @@ -471,7 +471,7 @@ public abstract class AbstractCacheAnnotationTests { assertSame(r1, primary.get(o).get()); assertSame(r1, secondary.get(o).get()); - o = Integer.valueOf(2); + o = 2; assertNull(primary.get(o)); assertNull(secondary.get(o)); Object r2 = service.multiUpdate(o); @@ -482,7 +482,7 @@ public abstract class AbstractCacheAnnotationTests { public void testPutRefersToResult(CacheableService service) throws Exception { Long id = Long.MIN_VALUE; TestEntity entity = new TestEntity(); - Cache primary = cm.getCache("primary"); + Cache primary = this.cm.getCache("primary"); assertNull(primary.get(id)); assertNull(entity.getId()); service.putRefersToResult(entity); @@ -492,9 +492,9 @@ public abstract class AbstractCacheAnnotationTests { public void testMultiCacheAndEvict(CacheableService service) { String methodName = "multiCacheAndEvict"; - Cache primary = cm.getCache("primary"); - Cache secondary = cm.getCache("secondary"); - Object key = Integer.valueOf(1); + Cache primary = this.cm.getCache("primary"); + Cache secondary = this.cm.getCache("secondary"); + Object key = 1; secondary.put(key, key); @@ -511,9 +511,9 @@ public abstract class AbstractCacheAnnotationTests { } public void testMultiConditionalCacheAndEvict(CacheableService service) { - Cache primary = cm.getCache("primary"); - Cache secondary = cm.getCache("secondary"); - Object key = Integer.valueOf(1); + Cache primary = this.cm.getCache("primary"); + Cache secondary = this.cm.getCache("secondary"); + Object key = 1; secondary.put(key, key); @@ -526,7 +526,7 @@ public abstract class AbstractCacheAnnotationTests { assertTrue(!r1.equals(r3)); assertNull(primary.get(key)); - Object key2 = Integer.valueOf(3); + Object key2 = 3; Object r2 = service.multiConditionalCacheAndEvict(key2); assertSame(r2, service.multiConditionalCacheAndEvict(key2)); @@ -537,163 +537,163 @@ public abstract class AbstractCacheAnnotationTests { @Test public void testCacheable() throws Exception { - testCacheable(cs); + testCacheable(this.cs); } @Test public void testCacheableNull() throws Exception { - testCacheableNull(cs); + testCacheableNull(this.cs); } @Test public void testCacheableSync() throws Exception { - testCacheableSync(cs); + testCacheableSync(this.cs); } @Test public void testCacheableSyncNull() throws Exception { - testCacheableSyncNull(cs); + testCacheableSyncNull(this.cs); } @Test public void testInvalidate() throws Exception { - testEvict(cs); + testEvict(this.cs); } @Test public void testEarlyInvalidate() throws Exception { - testEvictEarly(cs); + testEvictEarly(this.cs); } @Test public void testEvictWithException() throws Exception { - testEvictException(cs); + testEvictException(this.cs); } @Test public void testEvictAll() throws Exception { - testEvictAll(cs); + testEvictAll(this.cs); } @Test public void testInvalidateWithKey() throws Exception { - testEvictWKey(cs); + testEvictWKey(this.cs); } @Test public void testEarlyInvalidateWithKey() throws Exception { - testEvictWKeyEarly(cs); + testEvictWKeyEarly(this.cs); } @Test public void testConditionalExpression() throws Exception { - testConditionalExpression(cs); + testConditionalExpression(this.cs); } @Test public void testConditionalExpressionSync() throws Exception { - testConditionalExpressionSync(cs); + testConditionalExpressionSync(this.cs); } @Test public void testUnlessExpression() throws Exception { - testUnlessExpression(cs); + testUnlessExpression(this.cs); } @Test public void testClassCacheUnlessExpression() throws Exception { - testUnlessExpression(cs); + testUnlessExpression(this.cs); } @Test public void testKeyExpression() throws Exception { - testKeyExpression(cs); + testKeyExpression(this.cs); } @Test public void testVarArgsKey() throws Exception { - testVarArgsKey(cs); + testVarArgsKey(this.cs); } @Test public void testClassCacheCacheable() throws Exception { - testCacheable(ccs); + testCacheable(this.ccs); } @Test public void testClassCacheInvalidate() throws Exception { - testEvict(ccs); + testEvict(this.ccs); } @Test public void testClassEarlyInvalidate() throws Exception { - testEvictEarly(ccs); + testEvictEarly(this.ccs); } @Test public void testClassEvictAll() throws Exception { - testEvictAll(ccs); + testEvictAll(this.ccs); } @Test public void testClassEvictWithException() throws Exception { - testEvictException(ccs); + testEvictException(this.ccs); } @Test public void testClassCacheInvalidateWKey() throws Exception { - testEvictWKey(ccs); + testEvictWKey(this.ccs); } @Test public void testClassEarlyInvalidateWithKey() throws Exception { - testEvictWKeyEarly(ccs); + testEvictWKeyEarly(this.ccs); } @Test public void testNullValue() throws Exception { - testNullValue(cs); + testNullValue(this.cs); } @Test public void testClassNullValue() throws Exception { Object key = new Object(); - assertNull(ccs.nullValue(key)); - int nr = ccs.nullInvocations().intValue(); - assertNull(ccs.nullValue(key)); - assertEquals(nr, ccs.nullInvocations().intValue()); - assertNull(ccs.nullValue(new Object())); + assertNull(this.ccs.nullValue(key)); + int nr = this.ccs.nullInvocations().intValue(); + assertNull(this.ccs.nullValue(key)); + assertEquals(nr, this.ccs.nullInvocations().intValue()); + assertNull(this.ccs.nullValue(new Object())); // the check method is also cached - assertEquals(nr, ccs.nullInvocations().intValue()); + assertEquals(nr, this.ccs.nullInvocations().intValue()); assertEquals(nr + 1, AnnotatedClassCacheableService.nullInvocations.intValue()); } @Test public void testMethodName() throws Exception { - testMethodName(cs, "name"); + testMethodName(this.cs, "name"); } @Test public void testClassMethodName() throws Exception { - testMethodName(ccs, "nametestCache"); + testMethodName(this.ccs, "nametestCache"); } @Test public void testRootVars() throws Exception { - testRootVars(cs); + testRootVars(this.cs); } @Test public void testClassRootVars() throws Exception { - testRootVars(ccs); + testRootVars(this.ccs); } @Test public void testCustomKeyGenerator() { Object param = new Object(); - Object r1 = cs.customKeyGenerator(param); - assertSame(r1, cs.customKeyGenerator(param)); - Cache cache = cm.getCache("testCache"); + Object r1 = this.cs.customKeyGenerator(param); + assertSame(r1, this.cs.customKeyGenerator(param)); + Cache cache = this.cm.getCache("testCache"); // Checks that the custom keyGenerator was used Object expectedKey = SomeCustomKeyGenerator.generateKey("customKeyGenerator", param); assertNotNull(cache.get(expectedKey)); @@ -703,7 +703,7 @@ public abstract class AbstractCacheAnnotationTests { public void testUnknownCustomKeyGenerator() { try { Object param = new Object(); - cs.unknownCustomKeyGenerator(param); + this.cs.unknownCustomKeyGenerator(param); fail("should have failed with NoSuchBeanDefinitionException"); } catch (NoSuchBeanDefinitionException ex) { @@ -713,10 +713,10 @@ public abstract class AbstractCacheAnnotationTests { @Test public void testCustomCacheManager() { - CacheManager customCm = ctx.getBean("customCacheManager", CacheManager.class); + CacheManager customCm = this.ctx.getBean("customCacheManager", CacheManager.class); Object key = new Object(); - Object r1 = cs.customCacheManager(key); - assertSame(r1, cs.customCacheManager(key)); + Object r1 = this.cs.customCacheManager(key); + assertSame(r1, this.cs.customCacheManager(key)); Cache cache = customCm.getCache("testCache"); assertNotNull(cache.get(key)); @@ -726,7 +726,7 @@ public abstract class AbstractCacheAnnotationTests { public void testUnknownCustomCacheManager() { try { Object param = new Object(); - cs.unknownCustomCacheManager(param); + this.cs.unknownCustomCacheManager(param); fail("should have failed with NoSuchBeanDefinitionException"); } catch (NoSuchBeanDefinitionException ex) { @@ -736,132 +736,132 @@ public abstract class AbstractCacheAnnotationTests { @Test public void testNullArg() throws Exception { - testNullArg(cs); + testNullArg(this.cs); } @Test public void testClassNullArg() throws Exception { - testNullArg(ccs); + testNullArg(this.ccs); } @Test public void testCheckedException() throws Exception { - testCheckedThrowable(cs); + testCheckedThrowable(this.cs); } @Test public void testClassCheckedException() throws Exception { - testCheckedThrowable(ccs); + testCheckedThrowable(this.ccs); } @Test public void testCheckedExceptionSync() throws Exception { - testCheckedThrowableSync(cs); + testCheckedThrowableSync(this.cs); } @Test public void testClassCheckedExceptionSync() throws Exception { - testCheckedThrowableSync(ccs); + testCheckedThrowableSync(this.ccs); } @Test public void testUncheckedException() throws Exception { - testUncheckedThrowable(cs); + testUncheckedThrowable(this.cs); } @Test public void testClassUncheckedException() throws Exception { - testUncheckedThrowable(ccs); + testUncheckedThrowable(this.ccs); } @Test public void testUncheckedExceptionSync() throws Exception { - testUncheckedThrowableSync(cs); + testUncheckedThrowableSync(this.cs); } @Test public void testClassUncheckedExceptionSync() throws Exception { - testUncheckedThrowableSync(ccs); + testUncheckedThrowableSync(this.ccs); } @Test public void testUpdate() { - testCacheUpdate(cs); + testCacheUpdate(this.cs); } @Test public void testClassUpdate() { - testCacheUpdate(ccs); + testCacheUpdate(this.ccs); } @Test public void testConditionalUpdate() { - testConditionalCacheUpdate(cs); + testConditionalCacheUpdate(this.cs); } @Test public void testClassConditionalUpdate() { - testConditionalCacheUpdate(ccs); + testConditionalCacheUpdate(this.ccs); } @Test public void testMultiCache() { - testMultiCache(cs); + testMultiCache(this.cs); } @Test public void testClassMultiCache() { - testMultiCache(ccs); + testMultiCache(this.ccs); } @Test public void testMultiEvict() { - testMultiEvict(cs); + testMultiEvict(this.cs); } @Test public void testClassMultiEvict() { - testMultiEvict(ccs); + testMultiEvict(this.ccs); } @Test public void testMultiPut() { - testMultiPut(cs); + testMultiPut(this.cs); } @Test public void testClassMultiPut() { - testMultiPut(ccs); + testMultiPut(this.ccs); } @Test public void testPutRefersToResult() throws Exception { - testPutRefersToResult(cs); + testPutRefersToResult(this.cs); } @Test public void testClassPutRefersToResult() throws Exception { - testPutRefersToResult(ccs); + testPutRefersToResult(this.ccs); } @Test public void testMultiCacheAndEvict() { - testMultiCacheAndEvict(cs); + testMultiCacheAndEvict(this.cs); } @Test public void testClassMultiCacheAndEvict() { - testMultiCacheAndEvict(ccs); + testMultiCacheAndEvict(this.ccs); } @Test public void testMultiConditionalCacheAndEvict() { - testMultiConditionalCacheAndEvict(cs); + testMultiConditionalCacheAndEvict(this.cs); } @Test public void testClassMultiConditionalCacheAndEvict() { - testMultiConditionalCacheAndEvict(ccs); + testMultiConditionalCacheAndEvict(this.ccs); } } diff --git a/spring-context/src/test/java/org/springframework/cache/config/AnnotatedClassCacheableService.java b/spring-context/src/test/java/org/springframework/cache/config/AnnotatedClassCacheableService.java index 88886b6a8a..82dfcb439a 100644 --- a/spring-context/src/test/java/org/springframework/cache/config/AnnotatedClassCacheableService.java +++ b/spring-context/src/test/java/org/springframework/cache/config/AnnotatedClassCacheableService.java @@ -1,5 +1,5 @@ /* - * Copyright 2002-2015 the original author or authors. + * Copyright 2002-2016 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. @@ -38,7 +38,7 @@ public class AnnotatedClassCacheableService implements CacheableService @Override public Object cache(Object arg1) { - return counter.getAndIncrement(); + return this.counter.getAndIncrement(); } @Override @@ -49,7 +49,7 @@ public class AnnotatedClassCacheableService implements CacheableService @Override @Cacheable(cacheNames = "testCache", sync = true) public Object cacheSync(Object arg1) { - return counter.getAndIncrement(); + return this.counter.getAndIncrement(); } @Override @@ -110,55 +110,55 @@ public class AnnotatedClassCacheableService implements CacheableService @Override @Cacheable(cacheNames = "testCache", key = "#p0") public Object key(Object arg1, Object arg2) { - return counter.getAndIncrement(); + return this.counter.getAndIncrement(); } @Override @Cacheable("testCache") public Object varArgsKey(Object... args) { - return counter.getAndIncrement(); + return this.counter.getAndIncrement(); } @Override @Cacheable(cacheNames = "testCache", key = "#root.methodName + #root.caches[0].name") public Object name(Object arg1) { - return counter.getAndIncrement(); + return this.counter.getAndIncrement(); } @Override @Cacheable(cacheNames = "testCache", key = "#root.methodName + #root.method.name + #root.targetClass + #root.target") public Object rootVars(Object arg1) { - return counter.getAndIncrement(); + return this.counter.getAndIncrement(); } @Override @Cacheable(cacheNames = "testCache", keyGenerator = "customKyeGenerator") public Object customKeyGenerator(Object arg1) { - return counter.getAndIncrement(); + return this.counter.getAndIncrement(); } @Override @Cacheable(cacheNames = "testCache", keyGenerator = "unknownBeanName") public Object unknownCustomKeyGenerator(Object arg1) { - return counter.getAndIncrement(); + return this.counter.getAndIncrement(); } @Override @Cacheable(cacheNames = "testCache", cacheManager = "customCacheManager") public Object customCacheManager(Object arg1) { - return counter.getAndIncrement(); + return this.counter.getAndIncrement(); } @Override @Cacheable(cacheNames = "testCache", cacheManager = "unknownBeanName") public Object unknownCustomCacheManager(Object arg1) { - return counter.getAndIncrement(); + return this.counter.getAndIncrement(); } @Override @CachePut("testCache") public Object update(Object arg1) { - return counter.getAndIncrement(); + return this.counter.getAndIncrement(); } @Override @@ -205,25 +205,25 @@ public class AnnotatedClassCacheableService implements CacheableService @Override @Caching(cacheable = { @Cacheable("primary"), @Cacheable("secondary") }) public Object multiCache(Object arg1) { - return counter.getAndIncrement(); + return this.counter.getAndIncrement(); } @Override @Caching(evict = { @CacheEvict("primary"), @CacheEvict(cacheNames = "secondary", key = "#a0"), @CacheEvict(cacheNames = "primary", key = "#p0 + 'A'") }) public Object multiEvict(Object arg1) { - return counter.getAndIncrement(); + return this.counter.getAndIncrement(); } @Override @Caching(cacheable = { @Cacheable(cacheNames = "primary", key = "#root.methodName") }, evict = { @CacheEvict("secondary") }) public Object multiCacheAndEvict(Object arg1) { - return counter.getAndIncrement(); + return this.counter.getAndIncrement(); } @Override @Caching(cacheable = { @Cacheable(cacheNames = "primary", condition = "#a0 == 3") }, evict = { @CacheEvict("secondary") }) public Object multiConditionalCacheAndEvict(Object arg1) { - return counter.getAndIncrement(); + return this.counter.getAndIncrement(); } @Override diff --git a/spring-context/src/test/java/org/springframework/cache/config/AnnotationNamespaceDrivenTests.java b/spring-context/src/test/java/org/springframework/cache/config/AnnotationNamespaceDrivenTests.java index ee78edcfb3..22ad15af19 100644 --- a/spring-context/src/test/java/org/springframework/cache/config/AnnotationNamespaceDrivenTests.java +++ b/spring-context/src/test/java/org/springframework/cache/config/AnnotationNamespaceDrivenTests.java @@ -1,5 +1,5 @@ /* - * Copyright 2002-2015 the original author or authors. + * Copyright 2002-2016 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. @@ -40,9 +40,9 @@ public class AnnotationNamespaceDrivenTests extends AbstractCacheAnnotationTests @Test public void testKeyStrategy() { - CacheInterceptor ci = ctx.getBean( + CacheInterceptor ci = this.ctx.getBean( "org.springframework.cache.interceptor.CacheInterceptor#0", CacheInterceptor.class); - assertSame(ctx.getBean("keyGenerator"), ci.getKeyGenerator()); + assertSame(this.ctx.getBean("keyGenerator"), ci.getKeyGenerator()); } @Test @@ -67,9 +67,9 @@ public class AnnotationNamespaceDrivenTests extends AbstractCacheAnnotationTests @Test public void testCacheErrorHandler() { - CacheInterceptor ci = ctx.getBean( + CacheInterceptor ci = this.ctx.getBean( "org.springframework.cache.interceptor.CacheInterceptor#0", CacheInterceptor.class); - assertSame(ctx.getBean("errorHandler", CacheErrorHandler.class), ci.getErrorHandler()); + assertSame(this.ctx.getBean("errorHandler", CacheErrorHandler.class), ci.getErrorHandler()); } } diff --git a/spring-context/src/test/java/org/springframework/cache/config/CacheAdviceNamespaceTests.java b/spring-context/src/test/java/org/springframework/cache/config/CacheAdviceNamespaceTests.java index 183db521f2..d0323c0991 100644 --- a/spring-context/src/test/java/org/springframework/cache/config/CacheAdviceNamespaceTests.java +++ b/spring-context/src/test/java/org/springframework/cache/config/CacheAdviceNamespaceTests.java @@ -1,5 +1,5 @@ /* - * Copyright 2002-2015 the original author or authors. + * Copyright 2002-2016 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. @@ -37,8 +37,8 @@ public class CacheAdviceNamespaceTests extends AbstractCacheAnnotationTests { @Test public void testKeyStrategy() throws Exception { - CacheInterceptor bean = ctx.getBean("cacheAdviceClass", CacheInterceptor.class); - Assert.assertSame(ctx.getBean("keyGenerator"), bean.getKeyGenerator()); + CacheInterceptor bean = this.ctx.getBean("cacheAdviceClass", CacheInterceptor.class); + Assert.assertSame(this.ctx.getBean("keyGenerator"), bean.getKeyGenerator()); } } diff --git a/spring-context/src/test/java/org/springframework/cache/config/CustomInterceptorTests.java b/spring-context/src/test/java/org/springframework/cache/config/CustomInterceptorTests.java index 2aa49ba77b..e9e20f5e75 100644 --- a/spring-context/src/test/java/org/springframework/cache/config/CustomInterceptorTests.java +++ b/spring-context/src/test/java/org/springframework/cache/config/CustomInterceptorTests.java @@ -1,5 +1,5 @@ /* - * Copyright 2002-2014 the original author or authors. + * Copyright 2002-2016 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. @@ -37,7 +37,6 @@ import org.springframework.context.annotation.Configuration; import static org.junit.Assert.*; /** - * * @author Stephane Nicoll */ public class CustomInterceptorTests { @@ -48,18 +47,18 @@ public class CustomInterceptorTests { @Before public void setup() { - ctx = new AnnotationConfigApplicationContext(EnableCachingConfig.class); - cs = ctx.getBean("service", CacheableService.class); + this.ctx = new AnnotationConfigApplicationContext(EnableCachingConfig.class); + this.cs = ctx.getBean("service", CacheableService.class); } @After public void tearDown() { - ctx.close(); + this.ctx.close(); } @Test public void onlyOneInterceptorIsAvailable() { - Map interceptors = ctx.getBeansOfType(CacheInterceptor.class); + Map interceptors = this.ctx.getBeansOfType(CacheInterceptor.class); assertEquals("Only one interceptor should be defined", 1, interceptors.size()); CacheInterceptor interceptor = interceptors.values().iterator().next(); assertEquals("Custom interceptor not defined", TestCacheInterceptor.class, interceptor.getClass()); @@ -67,14 +66,14 @@ public class CustomInterceptorTests { @Test public void customInterceptorAppliesWithRuntimeException() { - Object o = cs.throwUnchecked(0L); + Object o = this.cs.throwUnchecked(0L); assertEquals(55L, o); // See TestCacheInterceptor } @Test public void customInterceptorAppliesWithCheckedException() { try { - cs.throwChecked(0L); + this.cs.throwChecked(0L); fail("Should have failed"); } catch (RuntimeException e) { diff --git a/spring-context/src/test/java/org/springframework/cache/config/DefaultCacheableService.java b/spring-context/src/test/java/org/springframework/cache/config/DefaultCacheableService.java index 93b7a239cf..3be247806f 100644 --- a/spring-context/src/test/java/org/springframework/cache/config/DefaultCacheableService.java +++ b/spring-context/src/test/java/org/springframework/cache/config/DefaultCacheableService.java @@ -1,5 +1,5 @@ /* - * Copyright 2002-2015 the original author or authors. + * Copyright 2002-2016 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. @@ -39,7 +39,7 @@ public class DefaultCacheableService implements CacheableService { @Override @Cacheable("testCache") public Long cache(Object arg1) { - return counter.getAndIncrement(); + return this.counter.getAndIncrement(); } @Override @@ -51,7 +51,7 @@ public class DefaultCacheableService implements CacheableService { @Override @Cacheable(cacheNames = "testCache", sync = true) public Long cacheSync(Object arg1) { - return counter.getAndIncrement(); + return this.counter.getAndIncrement(); } @Override @@ -96,13 +96,13 @@ public class DefaultCacheableService implements CacheableService { @Override @Cacheable(cacheNames = "testCache", condition = "#p0 == 3") public Long conditional(int classField) { - return counter.getAndIncrement(); + return this.counter.getAndIncrement(); } @Override @Cacheable(cacheNames = "testCache", sync = true, condition = "#p0 == 3") public Long conditionalSync(int classField) { - return counter.getAndIncrement(); + return this.counter.getAndIncrement(); } @Override @@ -114,55 +114,55 @@ public class DefaultCacheableService implements CacheableService { @Override @Cacheable(cacheNames = "testCache", key = "#p0") public Long key(Object arg1, Object arg2) { - return counter.getAndIncrement(); + return this.counter.getAndIncrement(); } @Override @Cacheable(cacheNames = "testCache") public Long varArgsKey(Object... args) { - return counter.getAndIncrement(); + return this.counter.getAndIncrement(); } @Override @Cacheable(cacheNames = "testCache", key = "#root.methodName") public Long name(Object arg1) { - return counter.getAndIncrement(); + return this.counter.getAndIncrement(); } @Override @Cacheable(cacheNames = "testCache", key = "#root.methodName + #root.method.name + #root.targetClass + #root.target") public Long rootVars(Object arg1) { - return counter.getAndIncrement(); + return this.counter.getAndIncrement(); } @Override @Cacheable(cacheNames = "testCache", keyGenerator = "customKeyGenerator") public Long customKeyGenerator(Object arg1) { - return counter.getAndIncrement(); + return this.counter.getAndIncrement(); } @Override @Cacheable(cacheNames = "testCache", keyGenerator = "unknownBeanName") public Long unknownCustomKeyGenerator(Object arg1) { - return counter.getAndIncrement(); + return this.counter.getAndIncrement(); } @Override @Cacheable(cacheNames = "testCache", cacheManager = "customCacheManager") public Long customCacheManager(Object arg1) { - return counter.getAndIncrement(); + return this.counter.getAndIncrement(); } @Override @Cacheable(cacheNames = "testCache", cacheManager = "unknownBeanName") public Long unknownCustomCacheManager(Object arg1) { - return counter.getAndIncrement(); + return this.counter.getAndIncrement(); } @Override @CachePut("testCache") public Long update(Object arg1) { - return counter.getAndIncrement(); + return this.counter.getAndIncrement(); } @Override @@ -174,13 +174,13 @@ public class DefaultCacheableService implements CacheableService { @Override @Cacheable("testCache") public Long nullValue(Object arg1) { - nullInvocations.incrementAndGet(); + this.nullInvocations.incrementAndGet(); return null; } @Override public Number nullInvocations() { - return nullInvocations.get(); + return this.nullInvocations.get(); } @Override @@ -212,25 +212,25 @@ public class DefaultCacheableService implements CacheableService { @Override @Caching(cacheable = { @Cacheable("primary"), @Cacheable("secondary") }) public Long multiCache(Object arg1) { - return counter.getAndIncrement(); + return this.counter.getAndIncrement(); } @Override @Caching(evict = { @CacheEvict("primary"), @CacheEvict(cacheNames = "secondary", key = "#p0"), @CacheEvict(cacheNames = "primary", key = "#p0 + 'A'") }) public Long multiEvict(Object arg1) { - return counter.getAndIncrement(); + return this.counter.getAndIncrement(); } @Override @Caching(cacheable = { @Cacheable(cacheNames = "primary", key = "#root.methodName") }, evict = { @CacheEvict("secondary") }) public Long multiCacheAndEvict(Object arg1) { - return counter.getAndIncrement(); + return this.counter.getAndIncrement(); } @Override @Caching(cacheable = { @Cacheable(cacheNames = "primary", condition = "#p0 == 3") }, evict = { @CacheEvict("secondary") }) public Long multiConditionalCacheAndEvict(Object arg1) { - return counter.getAndIncrement(); + return this.counter.getAndIncrement(); } @Override diff --git a/spring-context/src/test/java/org/springframework/cache/config/EnableCachingIntegrationTests.java b/spring-context/src/test/java/org/springframework/cache/config/EnableCachingIntegrationTests.java index 4ab2d70657..d95c70d100 100644 --- a/spring-context/src/test/java/org/springframework/cache/config/EnableCachingIntegrationTests.java +++ b/spring-context/src/test/java/org/springframework/cache/config/EnableCachingIntegrationTests.java @@ -80,7 +80,7 @@ public class EnableCachingIntegrationTests { public void beanCondition() { this.context = new AnnotationConfigApplicationContext(BeanConditionConfig.class); Cache cache = getCache(); - FooService service = context.getBean(FooService.class); + FooService service = this.context.getBean(FooService.class); Object key = new Object(); service.getWithCondition(key); @@ -133,13 +133,13 @@ public class EnableCachingIntegrationTests { @Override @Cacheable public Object getSimple(Object key) { - return counter.getAndIncrement(); + return this.counter.getAndIncrement(); } @Override @Cacheable(condition = "@bar.enabled") public Object getWithCondition(Object key) { - return counter.getAndIncrement(); + return this.counter.getAndIncrement(); } } @@ -161,7 +161,7 @@ public class EnableCachingIntegrationTests { } public boolean isEnabled() { - return enabled; + return this.enabled; } } } diff --git a/spring-context/src/test/java/org/springframework/cache/config/EnableCachingTests.java b/spring-context/src/test/java/org/springframework/cache/config/EnableCachingTests.java index 4fcd044444..8f73c6ab9d 100644 --- a/spring-context/src/test/java/org/springframework/cache/config/EnableCachingTests.java +++ b/spring-context/src/test/java/org/springframework/cache/config/EnableCachingTests.java @@ -1,5 +1,5 @@ /* - * Copyright 2002-2014 the original author or authors. + * Copyright 2002-2016 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. @@ -39,7 +39,8 @@ import org.springframework.context.annotation.Configuration; import static org.junit.Assert.*; /** - * Integration tests for @EnableCaching and its related @Configuration classes. + * Integration tests for {@code @EnableCaching} and its related + * {@code @Configuration} classes. * * @author Chris Beams * @author Stephane Nicoll @@ -54,14 +55,14 @@ public class EnableCachingTests extends AbstractCacheAnnotationTests { @Test public void testKeyStrategy() { - CacheInterceptor ci = ctx.getBean(CacheInterceptor.class); - assertSame(ctx.getBean("keyGenerator", KeyGenerator.class), ci.getKeyGenerator()); + CacheInterceptor ci = this.ctx.getBean(CacheInterceptor.class); + assertSame(this.ctx.getBean("keyGenerator", KeyGenerator.class), ci.getKeyGenerator()); } @Test public void testCacheErrorHandler() { - CacheInterceptor ci = ctx.getBean(CacheInterceptor.class); - assertSame(ctx.getBean("errorHandler", CacheErrorHandler.class), ci.getErrorHandler()); + CacheInterceptor ci = this.ctx.getBean(CacheInterceptor.class); + assertSame(this.ctx.getBean("errorHandler", CacheErrorHandler.class), ci.getErrorHandler()); } // --- local tests ------- diff --git a/spring-context/src/test/java/org/springframework/cache/config/ExpressionCachingIntegrationTests.java b/spring-context/src/test/java/org/springframework/cache/config/ExpressionCachingIntegrationTests.java index f00ddde35d..2986c8cfc3 100644 --- a/spring-context/src/test/java/org/springframework/cache/config/ExpressionCachingIntegrationTests.java +++ b/spring-context/src/test/java/org/springframework/cache/config/ExpressionCachingIntegrationTests.java @@ -1,5 +1,5 @@ /* - * Copyright 2002-2014 the original author or authors. + * Copyright 2002-2016 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. @@ -29,7 +29,6 @@ import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; /** - * * @author Stephane Nicoll */ public class ExpressionCachingIntegrationTests { @@ -65,7 +64,7 @@ public class ExpressionCachingIntegrationTests { } - private static interface BaseDao { + private interface BaseDao { T persist(T t); } @@ -94,7 +93,7 @@ public class ExpressionCachingIntegrationTests { @SuppressWarnings("unused") public String getId() { - return id; + return this.id; } } @@ -107,7 +106,7 @@ public class ExpressionCachingIntegrationTests { @SuppressWarnings("unused") public String getId() { - return id; + return this.id; } } diff --git a/spring-context/src/test/java/org/springframework/cache/interceptor/CacheErrorHandlerTests.java b/spring-context/src/test/java/org/springframework/cache/interceptor/CacheErrorHandlerTests.java index 4404d78933..6079666751 100644 --- a/spring-context/src/test/java/org/springframework/cache/interceptor/CacheErrorHandlerTests.java +++ b/spring-context/src/test/java/org/springframework/cache/interceptor/CacheErrorHandlerTests.java @@ -1,5 +1,5 @@ /* - * Copyright 2002-2014 the original author or authors. + * Copyright 2002-2016 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. @@ -16,7 +16,7 @@ package org.springframework.cache.interceptor; -import java.util.Arrays; +import java.util.Collections; import java.util.concurrent.atomic.AtomicLong; import org.junit.Before; @@ -43,7 +43,6 @@ import static org.junit.Assert.*; import static org.mockito.BDDMockito.*; /** - * * @author Stephane Nicoll */ public class CacheErrorHandlerTests { @@ -71,23 +70,23 @@ public class CacheErrorHandlerTests { @Test public void getFail() { UnsupportedOperationException exception = new UnsupportedOperationException("Test exception on get"); - willThrow(exception).given(cache).get(0L); + willThrow(exception).given(this.cache).get(0L); Object result = this.simpleService.get(0L); - verify(errorHandler).handleCacheGetError(exception, cache, 0L); - verify(cache).get(0L); - verify(cache).put(0L, result); // result of the invocation + verify(this.errorHandler).handleCacheGetError(exception, cache, 0L); + verify(this.cache).get(0L); + verify(this.cache).put(0L, result); // result of the invocation } @Test public void getAndPutFail() { UnsupportedOperationException exception = new UnsupportedOperationException("Test exception on get"); - willThrow(exception).given(cache).get(0L); - willThrow(exception).given(cache).put(0L, 0L); // Update of the cache will fail as well + willThrow(exception).given(this.cache).get(0L); + willThrow(exception).given(this.cache).put(0L, 0L); // Update of the cache will fail as well Object counter = this.simpleService.get(0L); - willReturn(new SimpleValueWrapper(2L)).given(cache).get(0L); + willReturn(new SimpleValueWrapper(2L)).given(this.cache).get(0L); Object counter2 = this.simpleService.get(0L); Object counter3 = this.simpleService.get(0L); assertNotSame(counter, counter2); @@ -97,71 +96,71 @@ public class CacheErrorHandlerTests { @Test public void getFailProperException() { UnsupportedOperationException exception = new UnsupportedOperationException("Test exception on get"); - willThrow(exception).given(cache).get(0L); + willThrow(exception).given(this.cache).get(0L); - cacheInterceptor.setErrorHandler(new SimpleCacheErrorHandler()); + this.cacheInterceptor.setErrorHandler(new SimpleCacheErrorHandler()); - thrown.expect(is(exception)); + this.thrown.expect(is(exception)); this.simpleService.get(0L); } @Test public void putFail() { UnsupportedOperationException exception = new UnsupportedOperationException("Test exception on put"); - willThrow(exception).given(cache).put(0L, 0L); + willThrow(exception).given(this.cache).put(0L, 0L); this.simpleService.put(0L); - verify(errorHandler).handleCachePutError(exception, cache, 0L, 0L); + verify(this.errorHandler).handleCachePutError(exception, cache, 0L, 0L); } @Test public void putFailProperException() { UnsupportedOperationException exception = new UnsupportedOperationException("Test exception on put"); - willThrow(exception).given(cache).put(0L, 0L); + willThrow(exception).given(this.cache).put(0L, 0L); - cacheInterceptor.setErrorHandler(new SimpleCacheErrorHandler()); + this.cacheInterceptor.setErrorHandler(new SimpleCacheErrorHandler()); - thrown.expect(is(exception)); + this.thrown.expect(is(exception)); this.simpleService.put(0L); } @Test public void evictFail() { UnsupportedOperationException exception = new UnsupportedOperationException("Test exception on evict"); - willThrow(exception).given(cache).evict(0L); + willThrow(exception).given(this.cache).evict(0L); this.simpleService.evict(0L); - verify(errorHandler).handleCacheEvictError(exception, cache, 0L); + verify(this.errorHandler).handleCacheEvictError(exception, cache, 0L); } @Test public void evictFailProperException() { UnsupportedOperationException exception = new UnsupportedOperationException("Test exception on evict"); - willThrow(exception).given(cache).evict(0L); + willThrow(exception).given(this.cache).evict(0L); - cacheInterceptor.setErrorHandler(new SimpleCacheErrorHandler()); + this.cacheInterceptor.setErrorHandler(new SimpleCacheErrorHandler()); - thrown.expect(is(exception)); + this.thrown.expect(is(exception)); this.simpleService.evict(0L); } @Test public void clearFail() { UnsupportedOperationException exception = new UnsupportedOperationException("Test exception on evict"); - willThrow(exception).given(cache).clear(); + willThrow(exception).given(this.cache).clear(); this.simpleService.clear(); - verify(errorHandler).handleCacheClearError(exception, cache); + verify(this.errorHandler).handleCacheClearError(exception, cache); } @Test public void clearFailProperException() { UnsupportedOperationException exception = new UnsupportedOperationException("Test exception on evict"); - willThrow(exception).given(cache).clear(); + willThrow(exception).given(this.cache).clear(); - cacheInterceptor.setErrorHandler(new SimpleCacheErrorHandler()); + this.cacheInterceptor.setErrorHandler(new SimpleCacheErrorHandler()); - thrown.expect(is(exception)); + this.thrown.expect(is(exception)); this.simpleService.clear(); } @@ -184,7 +183,7 @@ public class CacheErrorHandlerTests { @Bean public CacheManager cacheManager() { SimpleCacheManager cacheManager = new SimpleCacheManager(); - cacheManager.setCaches(Arrays.asList(mockCache())); + cacheManager.setCaches(Collections.singletonList(mockCache())); return cacheManager; } @@ -203,12 +202,12 @@ public class CacheErrorHandlerTests { @Cacheable public Object get(long id) { - return counter.getAndIncrement(); + return this.counter.getAndIncrement(); } @CachePut public Object put(long id) { - return counter.getAndIncrement(); + return this.counter.getAndIncrement(); } @CacheEvict diff --git a/spring-context/src/test/java/org/springframework/cache/interceptor/CachePutEvaluationTests.java b/spring-context/src/test/java/org/springframework/cache/interceptor/CachePutEvaluationTests.java index d9236e337a..9d2279f378 100644 --- a/spring-context/src/test/java/org/springframework/cache/interceptor/CachePutEvaluationTests.java +++ b/spring-context/src/test/java/org/springframework/cache/interceptor/CachePutEvaluationTests.java @@ -1,5 +1,5 @@ /* - * Copyright 2002-2014 the original author or authors. + * Copyright 2002-2016 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. @@ -54,8 +54,8 @@ public class CachePutEvaluationTests { @Before public void setup() { this.context = new AnnotationConfigApplicationContext(Config.class); - this.cache = context.getBean(CacheManager.class).getCache("test"); - this.service = context.getBean(SimpleService.class); + this.cache = this.context.getBean(CacheManager.class).getCache("test"); + this.service = this.context.getBean(SimpleService.class); } @After @@ -69,38 +69,38 @@ public class CachePutEvaluationTests { public void mutualGetPutExclusion() { String key = "1"; - Long first = service.getOrPut(key, true); - Long second = service.getOrPut(key, true); + Long first = this.service.getOrPut(key, true); + Long second = this.service.getOrPut(key, true); assertSame(first, second); // This forces the method to be executed again Long expected = first + 1; - Long third = service.getOrPut(key, false); + Long third = this.service.getOrPut(key, false); assertEquals(expected, third); - Long fourth = service.getOrPut(key, true); + Long fourth = this.service.getOrPut(key, true); assertSame(third, fourth); } @Test public void getAndPut() { - cache.clear(); + this.cache.clear(); long key = 1; - Long value = service.getAndPut(key); + Long value = this.service.getAndPut(key); - assertEquals("Wrong value for @Cacheable key", value, cache.get(key).get()); - assertEquals("Wrong value for @CachePut key", value, cache.get(value + 100).get()); // See @CachePut + assertEquals("Wrong value for @Cacheable key", value, this.cache.get(key).get()); + assertEquals("Wrong value for @CachePut key", value, this.cache.get(value + 100).get()); // See @CachePut // CachePut forced a method call - Long anotherValue = service.getAndPut(key); + Long anotherValue = this.service.getAndPut(key); assertNotSame(value, anotherValue); // NOTE: while you might expect the main key to have been updated, it hasn't. @Cacheable operations // are only processed in case of a cache miss. This is why combining @Cacheable with @CachePut // is a very bad idea. We could refine the condition now that we can figure out if we are going // to invoke the method anyway but that brings a whole new set of potential regressions. //assertEquals("Wrong value for @Cacheable key", anotherValue, cache.get(key).get()); - assertEquals("Wrong value for @CachePut key", anotherValue, cache.get(anotherValue + 100).get()); + assertEquals("Wrong value for @CachePut key", anotherValue, this.cache.get(anotherValue + 100).get()); } @Configuration @@ -130,7 +130,7 @@ public class CachePutEvaluationTests { @Cacheable(condition = "#p1", key = "#p0") @CachePut(condition = "!#p1", key = "#p0") public Long getOrPut(Object id, boolean flag) { - return counter.getAndIncrement(); + return this.counter.getAndIncrement(); } /** @@ -140,7 +140,7 @@ public class CachePutEvaluationTests { @Cacheable @CachePut(key = "#result + 100", condition = "#result != null") public Long getAndPut(long id) { - return counter.getAndIncrement(); + return this.counter.getAndIncrement(); } } } diff --git a/spring-context/src/test/java/org/springframework/cache/interceptor/CacheResolverCustomizationTests.java b/spring-context/src/test/java/org/springframework/cache/interceptor/CacheResolverCustomizationTests.java index 3c81052b92..23b391dfbc 100644 --- a/spring-context/src/test/java/org/springframework/cache/interceptor/CacheResolverCustomizationTests.java +++ b/spring-context/src/test/java/org/springframework/cache/interceptor/CacheResolverCustomizationTests.java @@ -1,5 +1,5 @@ /* - * Copyright 2002-2014 the original author or authors. + * Copyright 2002-2016 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. @@ -67,63 +67,63 @@ public class CacheResolverCustomizationTests { @Test public void noCustomization() { - Cache cache = cacheManager.getCache("default"); + Cache cache = this.cacheManager.getCache("default"); Object key = new Object(); assertCacheMiss(key, cache); - Object value = simpleService.getSimple(key); + Object value = this.simpleService.getSimple(key); assertCacheHit(key, value, cache); } @Test public void customCacheResolver() { - Cache cache = cacheManager.getCache("primary"); + Cache cache = this.cacheManager.getCache("primary"); Object key = new Object(); assertCacheMiss(key, cache); - Object value = simpleService.getWithCustomCacheResolver(key); + Object value = this.simpleService.getWithCustomCacheResolver(key); assertCacheHit(key, value, cache); } @Test public void customCacheManager() { - Cache cache = anotherCacheManager.getCache("default"); + Cache cache = this.anotherCacheManager.getCache("default"); Object key = new Object(); assertCacheMiss(key, cache); - Object value = simpleService.getWithCustomCacheManager(key); + Object value = this.simpleService.getWithCustomCacheManager(key); assertCacheHit(key, value, cache); } @Test public void runtimeResolution() { - Cache defaultCache = cacheManager.getCache("default"); - Cache primaryCache = cacheManager.getCache("primary"); + Cache defaultCache = this.cacheManager.getCache("default"); + Cache primaryCache = this.cacheManager.getCache("primary"); Object key = new Object(); assertCacheMiss(key, defaultCache, primaryCache); - Object value = simpleService.getWithRuntimeCacheResolution(key, "default"); + Object value = this.simpleService.getWithRuntimeCacheResolution(key, "default"); assertCacheHit(key, value, defaultCache); assertCacheMiss(key, primaryCache); Object key2 = new Object(); assertCacheMiss(key2, defaultCache, primaryCache); - Object value2 = simpleService.getWithRuntimeCacheResolution(key2, "primary"); + Object value2 = this.simpleService.getWithRuntimeCacheResolution(key2, "primary"); assertCacheHit(key2, value2, primaryCache); assertCacheMiss(key2, defaultCache); } @Test public void namedResolution() { - Cache cache = cacheManager.getCache("secondary"); + Cache cache = this.cacheManager.getCache("secondary"); Object key = new Object(); assertCacheMiss(key, cache); - Object value = simpleService.getWithNamedCacheResolution(key); + Object value = this.simpleService.getWithNamedCacheResolution(key); assertCacheHit(key, value, cache); } @@ -131,7 +131,7 @@ public class CacheResolverCustomizationTests { public void noCacheResolved() { Method method = ReflectionUtils.findMethod(SimpleService.class, "noCacheResolved", Object.class); try { - simpleService.noCacheResolved(new Object()); + this.simpleService.noCacheResolved(new Object()); fail("Should have failed, no cache resolved"); } catch (IllegalStateException ex) { @@ -142,7 +142,7 @@ public class CacheResolverCustomizationTests { @Test public void unknownCacheResolver() { try { - simpleService.unknownCacheResolver(new Object()); + this.simpleService.unknownCacheResolver(new Object()); fail("Should have failed, no cache resolver with that name"); } catch (NoSuchBeanDefinitionException ex) { @@ -214,37 +214,37 @@ public class CacheResolverCustomizationTests { @Cacheable public Object getSimple(Object key) { - return counter.getAndIncrement(); + return this.counter.getAndIncrement(); } @Cacheable(cacheResolver = "primaryCacheResolver") public Object getWithCustomCacheResolver(Object key) { - return counter.getAndIncrement(); + return this.counter.getAndIncrement(); } @Cacheable(cacheManager = "anotherCacheManager") public Object getWithCustomCacheManager(Object key) { - return counter.getAndIncrement(); + return this.counter.getAndIncrement(); } @Cacheable(cacheResolver = "runtimeCacheResolver", key = "#p0") public Object getWithRuntimeCacheResolution(Object key, String cacheName) { - return counter.getAndIncrement(); + return this.counter.getAndIncrement(); } @Cacheable(cacheResolver = "namedCacheResolver") public Object getWithNamedCacheResolution(Object key) { - return counter.getAndIncrement(); + return this.counter.getAndIncrement(); } @Cacheable(cacheResolver = "nullCacheResolver") // No cache resolved for the operation public Object noCacheResolved(Object key) { - return counter.getAndIncrement(); + return this.counter.getAndIncrement(); } @Cacheable(cacheResolver = "unknownCacheResolver") // No such bean defined public Object unknownCacheResolver(Object key) { - return counter.getAndIncrement(); + return this.counter.getAndIncrement(); } } diff --git a/spring-context/src/test/java/org/springframework/cache/interceptor/CacheSyncFailureTests.java b/spring-context/src/test/java/org/springframework/cache/interceptor/CacheSyncFailureTests.java index 531bc01ad5..e78d18fd86 100644 --- a/spring-context/src/test/java/org/springframework/cache/interceptor/CacheSyncFailureTests.java +++ b/spring-context/src/test/java/org/springframework/cache/interceptor/CacheSyncFailureTests.java @@ -54,7 +54,7 @@ public class CacheSyncFailureTests { @Before public void setUp() { this.context = new AnnotationConfigApplicationContext(Config.class); - this.simpleService = context.getBean(SimpleService.class); + this.simpleService = this.context.getBean(SimpleService.class); } @After @@ -66,36 +66,36 @@ public class CacheSyncFailureTests { @Test public void unlessSync() { - thrown.expect(IllegalStateException.class); - thrown.expectMessage("@Cacheable(sync=true) does not support unless attribute"); + this.thrown.expect(IllegalStateException.class); + this.thrown.expectMessage("@Cacheable(sync=true) does not support unless attribute"); this.simpleService.unlessSync("key"); } @Test public void severalCachesSync() { - thrown.expect(IllegalStateException.class); - thrown.expectMessage("@Cacheable(sync=true) only allows a single cache"); + this.thrown.expect(IllegalStateException.class); + this.thrown.expectMessage("@Cacheable(sync=true) only allows a single cache"); this.simpleService.severalCachesSync("key"); } @Test public void severalCachesWithResolvedSync() { - thrown.expect(IllegalStateException.class); - thrown.expectMessage("@Cacheable(sync=true) only allows a single cache"); + this.thrown.expect(IllegalStateException.class); + this.thrown.expectMessage("@Cacheable(sync=true) only allows a single cache"); this.simpleService.severalCachesWithResolvedSync("key"); } @Test public void syncWithAnotherOperation() { - thrown.expect(IllegalStateException.class); - thrown.expectMessage("@Cacheable(sync=true) cannot be combined with other cache operations"); + this.thrown.expect(IllegalStateException.class); + this.thrown.expectMessage("@Cacheable(sync=true) cannot be combined with other cache operations"); this.simpleService.syncWithAnotherOperation("key"); } @Test public void syncWithTwoGetOperations() { - thrown.expect(IllegalStateException.class); - thrown.expectMessage("Only one @Cacheable(sync=true) entry is allowed"); + this.thrown.expect(IllegalStateException.class); + this.thrown.expectMessage("Only one @Cacheable(sync=true) entry is allowed"); this.simpleService.syncWithTwoGetOperations("key"); } diff --git a/spring-context/src/test/java/org/springframework/cache/interceptor/ExpressionEvaluatorTests.java b/spring-context/src/test/java/org/springframework/cache/interceptor/ExpressionEvaluatorTests.java index 6e3b563351..a49f6f09b0 100644 --- a/spring-context/src/test/java/org/springframework/cache/interceptor/ExpressionEvaluatorTests.java +++ b/spring-context/src/test/java/org/springframework/cache/interceptor/ExpressionEvaluatorTests.java @@ -81,7 +81,7 @@ public class ExpressionEvaluatorTests { Object[] args = new Object[] { new Object(), new Object() }; Collection caches = Collections.singleton(new ConcurrentMapCache("test")); - EvaluationContext evalCtx = eval.createEvaluationContext(caches, method, args, + EvaluationContext evalCtx = this.eval.createEvaluationContext(caches, method, args, target, target.getClass(), null); Collection ops = getOps("multipleCaching"); @@ -89,8 +89,8 @@ public class ExpressionEvaluatorTests { AnnotatedElementKey key = new AnnotatedElementKey(method, AnnotatedClass.class); - Object keyA = eval.key(it.next().getKey(), key, evalCtx); - Object keyB = eval.key(it.next().getKey(), key, evalCtx); + Object keyA = this.eval.key(it.next().getKey(), key, evalCtx); + Object keyB = this.eval.key(it.next().getKey(), key, evalCtx); assertEquals(args[0], keyA); assertEquals(args[1], keyB); @@ -100,7 +100,7 @@ public class ExpressionEvaluatorTests { public void withReturnValue() throws Exception { EvaluationContext context = createEvaluationContext("theResult"); Object value = new SpelExpressionParser().parseExpression("#result").getValue(context); - assertThat(value, equalTo((Object) "theResult")); + assertThat(value, equalTo("theResult")); } @Test @@ -151,7 +151,7 @@ public class ExpressionEvaluatorTests { Object.class); Object[] args = new Object[] { new Object(), new Object() }; Collection caches = Collections.singleton(new ConcurrentMapCache("test")); - return eval.createEvaluationContext(caches, method, args, target, target.getClass(), result, beanFactory); + return this.eval.createEvaluationContext(caches, method, args, target, target.getClass(), result, beanFactory); } diff --git a/spring-context/src/test/java/org/springframework/cache/interceptor/SimpleKeyGeneratorTests.java b/spring-context/src/test/java/org/springframework/cache/interceptor/SimpleKeyGeneratorTests.java index 98cb0d780d..6f1e4341f6 100644 --- a/spring-context/src/test/java/org/springframework/cache/interceptor/SimpleKeyGeneratorTests.java +++ b/spring-context/src/test/java/org/springframework/cache/interceptor/SimpleKeyGeneratorTests.java @@ -1,5 +1,5 @@ /* - * Copyright 2002-2014 the original author or authors. + * Copyright 2002-2016 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. @@ -52,7 +52,7 @@ public class SimpleKeyGeneratorTests { assertThat(k1.hashCode(), not(equalTo(k3.hashCode()))); assertThat(k1, equalTo(k2)); assertThat(k1, not(equalTo(k3))); - assertThat(k1, equalTo((Object) "a")); + assertThat(k1, equalTo("a")); } @Test