wip

107/src/test/java/org/ehcache/ParsesConfigurationExtensionTest.java

@@ -65,7 +65,7 @@ public void testConfigParse() throws ClassNotFoundException, SAXException, Insta
 
  @SuppressWarnings("rawtypes")
  @Test
- public void testXmlExample() throws ClassNotFoundException, SAXException, InstantiationException, IOException, IllegalAccessException {
+ public void testXmlExample() throws ReflectiveOperationException {
  XmlConfiguration config = new XmlConfiguration(ParsesConfigurationExtensionTest.class.getResource("/ehcache-example.xml"));
  final DefaultJsr107Service jsr107Service = new DefaultJsr107Service(ServiceUtils.findSingletonAmongst(Jsr107Configuration.class, config.getServiceCreationConfigurations()));
 

107/src/test/java/org/ehcache/jsr107/LoadAtomicsWith107Test.java

@@ -20,13 +20,13 @@
 import org.junit.After;
 import org.junit.Before;
 import org.junit.Test;
+import org.junit.runner.RunWith;
 import org.mockito.Mock;
-import org.mockito.MockitoAnnotations;
+import org.mockito.junit.MockitoJUnitRunner;
 
 import javax.cache.Cache;
 import javax.cache.CacheManager;
 import javax.cache.Caching;
-import javax.cache.configuration.Factory;
 import javax.cache.configuration.MutableConfiguration;
 import javax.cache.integration.CacheLoader;
 import javax.cache.integration.CacheWriter;
@@ -35,13 +35,13 @@
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.Matchers.is;
 import static org.mockito.ArgumentMatchers.eq;
-import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
 
 /**
  * LoadAtomicsWith107Test
  */
+@RunWith(MockitoJUnitRunner.class)
 public class LoadAtomicsWith107Test {
  @Mock
  private CacheLoader<Number, CharSequence> cacheLoader;
@@ -52,8 +52,6 @@ public class LoadAtomicsWith107Test {
 
  @Before
  public void setUp() throws Exception {
- MockitoAnnotations.initMocks(this);
-
  CachingProvider provider = Caching.getCachingProvider();
  cacheManager = provider.getCacheManager(this.getClass().getResource("/ehcache-loader-writer-107-load-atomics.xml").toURI(), getClass().getClassLoader());
 

107/src/test/java/org/ehcache/jsr107/LoaderWriterConfigTest.java

@@ -19,29 +19,29 @@
 import org.junit.After;
 import org.junit.Before;
 import org.junit.Test;
+import org.junit.runner.RunWith;
 import org.mockito.Mock;
-import org.mockito.MockitoAnnotations;
+import org.mockito.junit.MockitoJUnitRunner;
 
 import java.util.Set;
 
 import javax.cache.Cache;
 import javax.cache.Caching;
-import javax.cache.configuration.Factory;
 import javax.cache.configuration.MutableConfiguration;
 import javax.cache.integration.CacheLoader;
 import javax.cache.integration.CacheWriter;
 import javax.cache.spi.CachingProvider;
 
 import static java.util.Collections.singleton;
 import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoInteractions;
 import static org.mockito.Mockito.verifyNoMoreInteractions;
-import static org.mockito.Mockito.verifyZeroInteractions;
 
 /**
  * LoaderWriterConfigTest
  */
+@RunWith(MockitoJUnitRunner.class)
 public class LoaderWriterConfigTest {
 
  @Mock
@@ -52,7 +52,6 @@ public class LoaderWriterConfigTest {
 
  @Before
  public void setUp() {
- MockitoAnnotations.initMocks(this);
  cachingProvider = Caching.getCachingProvider();
  }
 
@@ -87,7 +86,7 @@ public void enablingReadThroughDoesNotForceWriteThrough() throws Exception {
 
  cache.get(100L);
 
- verifyZeroInteractions(cacheWriter);
+ verifyNoInteractions(cacheWriter);
  verify(cacheLoader).load(100L);
  }
 

107/src/test/java/org/ehcache/jsr107/LoaderWriterTest.java

@@ -20,16 +20,14 @@
 import org.junit.After;
 import org.junit.Before;
 import org.junit.Test;
+import org.junit.runner.RunWith;
 import org.mockito.Mock;
 import org.mockito.Mockito;
-import org.mockito.MockitoAnnotations;
-import org.mockito.invocation.InvocationOnMock;
-import org.mockito.stubbing.Answer;
+import org.mockito.junit.MockitoJUnitRunner;
 
 import javax.cache.Cache;
 import javax.cache.CacheManager;
 import javax.cache.Caching;
-import javax.cache.configuration.Factory;
 import javax.cache.configuration.MutableConfiguration;
 import javax.cache.integration.CacheLoader;
 import javax.cache.integration.CacheWriter;
@@ -40,12 +38,13 @@
 import static org.mockito.ArgumentMatchers.eq;
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.verifyZeroInteractions;
+import static org.mockito.Mockito.verifyNoInteractions;
 import static org.mockito.Mockito.when;
 
 /**
  * @author Ludovic Orban
  */
+@RunWith(MockitoJUnitRunner.class)
 public class LoaderWriterTest {
 
  @Mock
@@ -57,8 +56,6 @@ public class LoaderWriterTest {
 
  @Before
  public void setUp() throws Exception {
- MockitoAnnotations.initMocks(this);
-
  CachingProvider provider = Caching.getCachingProvider();
  cacheManager = provider.getCacheManager(this.getClass().getResource("/ehcache-loader-writer-107.xml").toURI(), getClass().getClassLoader());
 
@@ -81,7 +78,7 @@ public void testSimplePutIfAbsentWithLoaderAndWriter_absent() throws Exception {
  assertThat(testCache.putIfAbsent(1, "one"), is(true));
  assertThat(testCache.get(1), Matchers.<CharSequence>equalTo("one"));
 
- verifyZeroInteractions(cacheLoader);
+ verifyNoInteractions(cacheLoader);
  verify(cacheWriter, times(1)).write(eq(new Eh107CacheLoaderWriter.Entry<Number, CharSequence>(1, "one")));
  }
 
@@ -91,7 +88,7 @@ public void testSimplePutIfAbsentWithLoaderAndWriter_existsInSor() throws Except
  assertThat(testCache.putIfAbsent(1, "one"), is(true));
  assertThat(testCache.get(1), Matchers.<CharSequence>equalTo("one"));
 
- verifyZeroInteractions(cacheLoader);
+ verifyNoInteractions(cacheLoader);
  verify(cacheWriter, times(1)).write(eq(new Eh107CacheLoaderWriter.Entry<Number, CharSequence>(1, "one")));
  }
 
@@ -103,33 +100,29 @@ public void testSimplePutIfAbsentWithLoaderAndWriter_existsInStore() throws Exce
  assertThat(testCache.putIfAbsent(1, "one"), is(false));
  assertThat(testCache.get(1), Matchers.<CharSequence>equalTo("un"));
 
- verifyZeroInteractions(cacheLoader);
- verifyZeroInteractions(cacheWriter);
+ verifyNoInteractions(cacheLoader);
+ verifyNoInteractions(cacheWriter);
  }
 
 
  @Test
  public void testSimpleReplace2ArgsWithLoaderAndWriter_absent() throws Exception {
- when(cacheLoader.load(eq(1))).thenAnswer(invocation -> null);
-
  assertThat(testCache.containsKey(1), is(false));
  assertThat(testCache.replace(1, "one"), is(false));
  assertThat(testCache.containsKey(1), is(false));
 
- verifyZeroInteractions(cacheLoader);
- verifyZeroInteractions(cacheWriter);
+ verifyNoInteractions(cacheLoader);
+ verifyNoInteractions(cacheWriter);
  }
 
  @Test
  public void testSimpleReplace2ArgsWithLoaderAndWriter_existsInSor() throws Exception {
- when(cacheLoader.load(eq(1))).thenAnswer(invocation -> "un");
-
  assertThat(testCache.containsKey(1), is(false));
  assertThat(testCache.replace(1, "one"), is(false));
  assertThat(testCache.containsKey(1), is(false));
 
- verifyZeroInteractions(cacheLoader);
- verifyZeroInteractions(cacheWriter);
+ verifyNoInteractions(cacheLoader);
+ verifyNoInteractions(cacheWriter);
  }
 
  @Test
@@ -140,31 +133,27 @@ public void testSimpleReplace2ArgsWithLoaderAndWriter_existsInStore() throws Exc
  assertThat(testCache.replace(1, "one"), is(true));
  assertThat(testCache.get(1), Matchers.<CharSequence>equalTo("one"));
 
- verifyZeroInteractions(cacheLoader);
+ verifyNoInteractions(cacheLoader);
  verify(cacheWriter, times(1)).write(new Eh107CacheLoaderWriter.Entry<Number, CharSequence>(1, "one"));
  }
 
  @Test
  public void testSimpleReplace3ArgsWithLoaderAndWriter_absent() throws Exception {
- when(cacheLoader.load(eq(1))).thenAnswer(invocation -> null);
-
  assertThat(testCache.containsKey(1), is(false));
  assertThat(testCache.replace(1, "un", "one"), is(false));
 
- verifyZeroInteractions(cacheLoader);
- verifyZeroInteractions(cacheWriter);
+ verifyNoInteractions(cacheLoader);
+ verifyNoInteractions(cacheWriter);
  }
 
  @Test
  public void testSimpleReplace3ArgsWithLoaderAndWriter_existsInSor() throws Exception {
- when(cacheLoader.load(eq(1))).thenAnswer(invocation -> "un");
-
  assertThat(testCache.containsKey(1), is(false));
  assertThat(testCache.replace(1, "un", "one"), is(false));
  assertThat(testCache.containsKey(1), is(false));
 
- verifyZeroInteractions(cacheLoader);
- verifyZeroInteractions(cacheWriter);
+ verifyNoInteractions(cacheLoader);
+ verifyNoInteractions(cacheWriter);
  }
 
  @Test
@@ -175,7 +164,7 @@ public void testSimpleReplace3ArgsWithLoaderAndWriter_existsInStore() throws Exc
  assertThat(testCache.replace(1, "un", "one"), is(true));
  assertThat(testCache.get(1), Matchers.<CharSequence>equalTo("one"));
 
- verifyZeroInteractions(cacheLoader);
+ verifyNoInteractions(cacheLoader);
  verify(cacheWriter, times(1)).write(new Eh107CacheLoaderWriter.Entry<Number, CharSequence>(1, "one"));
  }
 
@@ -187,30 +176,26 @@ public void testSimpleReplace3ArgsWithLoaderAndWriter_existsInStore_notEquals()
  assertThat(testCache.replace(1, "uno", "one"), is(false));
  assertThat(testCache.get(1), Matchers.<CharSequence>equalTo("un"));
 
- verifyZeroInteractions(cacheLoader);
- verifyZeroInteractions(cacheWriter);
+ verifyNoInteractions(cacheLoader);
+ verifyNoInteractions(cacheWriter);
  }
 
  @Test
  public void testSimpleRemove2ArgsWithLoaderAndWriter_absent() throws Exception {
- when(cacheLoader.load(eq(1))).thenAnswer(invocation -> null);
-
  assertThat(testCache.containsKey(1), is(false));
  assertThat(testCache.remove(1, "one"), is(false));
 
- verifyZeroInteractions(cacheLoader);
- verifyZeroInteractions(cacheWriter);
+ verifyNoInteractions(cacheLoader);
+ verifyNoInteractions(cacheWriter);
  }
 
  @Test
  public void testSimpleRemove2ArgsWithLoaderAndWriter_existsInSor() throws Exception {
- when(cacheLoader.load(eq(1))).thenAnswer(invocation -> "un");
-
  assertThat(testCache.containsKey(1), is(false));
  assertThat(testCache.remove(1, "un"), is(false));
 
- verifyZeroInteractions(cacheLoader);
- verifyZeroInteractions(cacheWriter);
+ verifyNoInteractions(cacheLoader);
+ verifyNoInteractions(cacheWriter);
  }
 
  @Test
@@ -220,7 +205,7 @@ public void testSimpleRemove2ArgsWithLoaderAndWriter_existsInStore() throws Exce
 
  assertThat(testCache.remove(1, "un"), is(true));
 
- verifyZeroInteractions(cacheLoader);
+ verifyNoInteractions(cacheLoader);
  verify(cacheWriter, times(1)).delete(eq(1));
  }
 
@@ -231,8 +216,8 @@ public void testSimpleRemove2ArgsWithLoaderAndWriter_existsInStore_notEquals() t
 
  assertThat(testCache.remove(1, "one"), is(false));
 
- verifyZeroInteractions(cacheLoader);
- verifyZeroInteractions(cacheWriter);
+ verifyNoInteractions(cacheLoader);
+ verifyNoInteractions(cacheWriter);
  }
 
  private void reset(Object mock) {

azure-pipelines-static-analysis.yml

@@ -20,10 +20,11 @@
 resources:
  repositories:
  - repository: templates
- type: git 
+ type: git
  name: terracotta/terracotta
 
 jobs:
 - template: build-templates/gradle-common.yml@templates
  parameters:
+ jdkVersion: '1.11'
  gradleTasks: 'check'

azure-pipelines.yml

@@ -26,24 +26,13 @@ resources:
 jobs:
 - template: build-templates/gradle-common.yml@templates
  parameters:
- jdkVersion: '1.8'
- jobName: 'LinuxJava8'
-
-- template: build-templates/gradle-common.yml@templates
- parameters:
- jdkVersion: '1.8'
+ jdkVersion: '1.11'
  options: '-PtestVM=java11Home'
  jobName: 'LinuxJava11'
 
 - template: build-templates/gradle-common.yml@templates
  parameters:
  vmImage: 'windows-latest'
- jdkVersion: '1.8'
- jobName: 'WindowsJava8'
-
-- template: build-templates/gradle-common.yml@templates
- parameters:
- vmImage: 'windows-latest'
- jdkVersion: '1.8'
+ jdkVersion: '1.11'
  options: '-PtestVM=java11Home'
  jobName: 'WindowsJava11'

build.gradle

@@ -71,7 +71,7 @@ ext {
 }
 
 
-assert (JavaVersion.current().isJava8Compatible()) : 'The Ehcache 3 build requires Java 8+ to run'
+assert (JavaVersion.current().isJava11Compatible()) : 'The Ehcache 3 build requires Java 11+ to run'
 ext {
  testJava = Jvm.current()
 }
@@ -106,8 +106,8 @@ subprojects {
 
  archivesBaseName = "ehcache-${project.name}"
 
- sourceCompatibility = 1.8
- targetCompatibility = 1.8
+ sourceCompatibility = 1.11
+ targetCompatibility = 1.11
 
  repositories {
  if (project.hasProperty('mvnlocal')) {

clustered/client/src/main/java/org/ehcache/clustered/client/internal/store/CommonServerStoreProxy.java

@@ -231,7 +231,7 @@ public Map.Entry<Long, Chain> next() {
  }
  }
 
- @Override
+ @Override @SuppressWarnings("deprecation")
  protected void finalize() throws Throwable {
  if (!lastBatch) {
  entity.invokeAndWaitForReceive(new ServerStoreOpMessage.IteratorCloseMessage(iteratorId), false);