Use spring-javaformat to format and check code

Resolves: #1450

spring-session-hazelcast/src/integration-test/java/org/springframework/session/hazelcast/AbstractHazelcastRepositoryITests.java

@@ -40,7 +40,7 @@ import static org.assertj.core.api.Assertions.assertThat;
  * @author Tommy Ludwig
  * @author Vedran Pavic
  */
-public abstract class AbstractHazelcastRepositoryITests {
+abstract class AbstractHazelcastRepositoryITests {
 
 	private static final String SPRING_SECURITY_CONTEXT = "SPRING_SECURITY_CONTEXT";
 
@@ -51,7 +51,7 @@ public abstract class AbstractHazelcastRepositoryITests {
 	private HazelcastSessionRepository repository;
 
 	@Test
-	public void createAndDestroySession() {
+	void createAndDestroySession() {
 		HazelcastSession sessionToSave = this.repository.createSession();
 		String sessionId = sessionToSave.getId();
 
@@ -71,7 +71,7 @@ public abstract class AbstractHazelcastRepositoryITests {
 	}
 
 	@Test
-	public void changeSessionIdWhenOnlyChangeId() {
+	void changeSessionIdWhenOnlyChangeId() {
 		String attrName = "changeSessionId";
 		String attrValue = "changeSessionId-value";
 		HazelcastSession toSave = this.repository.createSession();
@@ -90,17 +90,15 @@ public abstract class AbstractHazelcastRepositoryITests {
 
 		assertThat(this.repository.findById(originalFindById)).isNull();
 
-		HazelcastSession findByChangeSessionId = this.repository
-				.findById(changeSessionId);
+		HazelcastSession findByChangeSessionId = this.repository.findById(changeSessionId);
 
-		assertThat(findByChangeSessionId.<String>getAttribute(attrName))
-				.isEqualTo(attrValue);
+		assertThat(findByChangeSessionId.<String>getAttribute(attrName)).isEqualTo(attrValue);
 
 		this.repository.deleteById(changeSessionId);
 	}
 
 	@Test
-	public void changeSessionIdWhenChangeTwice() {
+	void changeSessionIdWhenChangeTwice() {
 		HazelcastSession toSave = this.repository.createSession();
 
 		this.repository.save(toSave);
@@ -119,7 +117,7 @@ public abstract class AbstractHazelcastRepositoryITests {
 	}
 
 	@Test
-	public void changeSessionIdWhenSetAttributeOnChangedSession() {
+	void changeSessionIdWhenSetAttributeOnChangedSession() {
 		String attrName = "changeSessionId";
 		String attrValue = "changeSessionId-value";
 
@@ -138,17 +136,15 @@ public abstract class AbstractHazelcastRepositoryITests {
 
 		assertThat(this.repository.findById(originalFindById)).isNull();
 
-		HazelcastSession findByChangeSessionId = this.repository
-				.findById(changeSessionId);
+		HazelcastSession findByChangeSessionId = this.repository.findById(changeSessionId);
 
-		assertThat(findByChangeSessionId.<String>getAttribute(attrName))
-				.isEqualTo(attrValue);
+		assertThat(findByChangeSessionId.<String>getAttribute(attrName)).isEqualTo(attrValue);
 
 		this.repository.deleteById(changeSessionId);
 	}
 
 	@Test
-	public void changeSessionIdWhenHasNotSaved() {
+	void changeSessionIdWhenHasNotSaved() {
 		HazelcastSession toSave = this.repository.createSession();
 		String originalId = toSave.getId();
 		toSave.changeSessionId();
@@ -162,7 +158,7 @@ public abstract class AbstractHazelcastRepositoryITests {
 	}
 
 	@Test // gh-1076
-	public void attemptToUpdateSessionAfterDelete() {
+	void attemptToUpdateSessionAfterDelete() {
 		HazelcastSession session = this.repository.createSession();
 		String sessionId = session.getId();
 		this.repository.save(session);
@@ -175,7 +171,7 @@ public abstract class AbstractHazelcastRepositoryITests {
 	}
 
 	@Test
-	public void createAndUpdateSession() {
+	void createAndUpdateSession() {
 		HazelcastSession session = this.repository.createSession();
 		String sessionId = session.getId();
 
@@ -190,13 +186,12 @@ public abstract class AbstractHazelcastRepositoryITests {
 	}
 
 	@Test
-	public void createSessionWithSecurityContextAndFindById() {
+	void createSessionWithSecurityContextAndFindById() {
 		HazelcastSession session = this.repository.createSession();
 		String sessionId = session.getId();
 
-		Authentication authentication = new UsernamePasswordAuthenticationToken(
-				"saves-" + System.currentTimeMillis(), "password",
-				AuthorityUtils.createAuthorityList("ROLE_USER"));
+		Authentication authentication = new UsernamePasswordAuthenticationToken("saves-" + System.currentTimeMillis(),
+				"password", AuthorityUtils.createAuthorityList("ROLE_USER"));
 		SecurityContext securityContext = SecurityContextHolder.createEmptyContext();
 		securityContext.setAuthentication(authentication);
 		session.setAttribute(SPRING_SECURITY_CONTEXT, securityContext);
@@ -207,23 +202,23 @@ public abstract class AbstractHazelcastRepositoryITests {
 	}
 
 	@Test
-	public void createSessionWithSecurityContextAndFindByPrincipal() {
+	void createSessionWithSecurityContextAndFindByPrincipal() {
 		Assumptions.assumeTrue(this.hazelcastInstance instanceof HazelcastInstanceProxy,
 				"Hazelcast runs in embedded server topology");
 
 		HazelcastSession session = this.repository.createSession();
 
 		String username = "saves-" + System.currentTimeMillis();
-		Authentication authentication = new UsernamePasswordAuthenticationToken(username,
-				"password", AuthorityUtils.createAuthorityList("ROLE_USER"));
+		Authentication authentication = new UsernamePasswordAuthenticationToken(username, "password",
+				AuthorityUtils.createAuthorityList("ROLE_USER"));
 		SecurityContext securityContext = SecurityContextHolder.createEmptyContext();
 		securityContext.setAuthentication(authentication);
 		session.setAttribute(SPRING_SECURITY_CONTEXT, securityContext);
 
 		this.repository.save(session);
 
-		assertThat(this.repository.findByIndexNameAndIndexValue(
-				FindByIndexNameSessionRepository.PRINCIPAL_NAME_INDEX_NAME, username))
+		assertThat(this.repository
+				.findByIndexNameAndIndexValue(FindByIndexNameSessionRepository.PRINCIPAL_NAME_INDEX_NAME, username))
 						.hasSize(1);
 	}
 

spring-session-hazelcast/src/integration-test/java/org/springframework/session/hazelcast/HazelcastClientRepositoryITests.java

@@ -45,24 +45,20 @@ import org.springframework.test.context.web.WebAppConfiguration;
 @ExtendWith(SpringExtension.class)
 @ContextConfiguration
 @WebAppConfiguration
-public class HazelcastClientRepositoryITests extends AbstractHazelcastRepositoryITests {
+class HazelcastClientRepositoryITests extends AbstractHazelcastRepositoryITests {
 
-	private static GenericContainer container = new GenericContainer<>(
-			"hazelcast/hazelcast:3.12.1")
-					.withExposedPorts(5701)
-					.withEnv("JAVA_OPTS",
-							"-Dhazelcast.config=/opt/hazelcast/config_ext/hazelcast.xml")
-					.withClasspathResourceMapping("/hazelcast-server.xml",
-							"/opt/hazelcast/config_ext/hazelcast.xml",
-							BindMode.READ_ONLY);
+	private static GenericContainer container = new GenericContainer<>("hazelcast/hazelcast:3.12.1")
+			.withExposedPorts(5701).withEnv("JAVA_OPTS", "-Dhazelcast.config=/opt/hazelcast/config_ext/hazelcast.xml")
+			.withClasspathResourceMapping("/hazelcast-server.xml", "/opt/hazelcast/config_ext/hazelcast.xml",
+					BindMode.READ_ONLY);
 
 	@BeforeAll
-	public static void setUpClass() {
+	static void setUpClass() {
 		container.start();
 	}
 
 	@AfterAll
-	public static void tearDownClass() {
+	static void tearDownClass() {
 		container.stop();
 	}
 
@@ -73,11 +69,10 @@ public class HazelcastClientRepositoryITests extends AbstractHazelcastRepository
 		@Bean
 		public HazelcastInstance hazelcastInstance() {
 			ClientConfig clientConfig = new ClientConfig();
-			clientConfig.getNetworkConfig().addAddress(container.getContainerIpAddress()
-					+ ":" + container.getFirstMappedPort());
-			clientConfig.getUserCodeDeploymentConfig().setEnabled(true)
-					.addClass(Session.class).addClass(MapSession.class)
-					.addClass(SessionUpdateEntryProcessor.class);
+			clientConfig.getNetworkConfig()
+					.addAddress(container.getContainerIpAddress() + ":" + container.getFirstMappedPort());
+			clientConfig.getUserCodeDeploymentConfig().setEnabled(true).addClass(Session.class)
+					.addClass(MapSession.class).addClass(SessionUpdateEntryProcessor.class);
 			return HazelcastClient.newHazelcastClient(clientConfig);
 		}
 

spring-session-hazelcast/src/integration-test/java/org/springframework/session/hazelcast/HazelcastITestUtils.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2014-2018 the original author or authors.
+ * Copyright 2014-2019 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.
@@ -51,13 +51,10 @@ public final class HazelcastITestUtils {
 
 		networkConfig.setPort(port);
 
-		networkConfig.getJoin()
-				.getMulticastConfig().setEnabled(false);
+		networkConfig.getJoin().getMulticastConfig().setEnabled(false);
 
-		config.getMapConfig(HazelcastSessionRepository.DEFAULT_SESSION_MAP_NAME)
-				.addMapAttributeConfig(attributeConfig)
-				.addMapIndexConfig(new MapIndexConfig(
-						HazelcastSessionRepository.PRINCIPAL_NAME_ATTRIBUTE, false));
+		config.getMapConfig(HazelcastSessionRepository.DEFAULT_SESSION_MAP_NAME).addMapAttributeConfig(attributeConfig)
+				.addMapIndexConfig(new MapIndexConfig(HazelcastSessionRepository.PRINCIPAL_NAME_ATTRIBUTE, false));
 
 		return Hazelcast.newHazelcastInstance(config);
 	}

spring-session-hazelcast/src/integration-test/java/org/springframework/session/hazelcast/HazelcastServerRepositoryITests.java

@@ -36,7 +36,7 @@ import org.springframework.test.context.web.WebAppConfiguration;
 @ExtendWith(SpringExtension.class)
 @ContextConfiguration
 @WebAppConfiguration
-public class HazelcastServerRepositoryITests extends AbstractHazelcastRepositoryITests {
+class HazelcastServerRepositoryITests extends AbstractHazelcastRepositoryITests {
 
 	@EnableHazelcastHttpSession
 	@Configuration

spring-session-hazelcast/src/integration-test/java/org/springframework/session/hazelcast/SessionEventRegistry.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2014-2018 the original author or authors.
+ * Copyright 2014-2019 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,9 @@ import org.springframework.context.ApplicationListener;
 import org.springframework.session.events.AbstractSessionEvent;
 
 public class SessionEventRegistry implements ApplicationListener<AbstractSessionEvent> {
+
 	private Map<String, AbstractSessionEvent> events = new HashMap<>();
+
 	private ConcurrentMap<String, Object> locks = new ConcurrentHashMap<>();
 
 	@Override
@@ -48,14 +50,12 @@ public class SessionEventRegistry implements ApplicationListener<AbstractSession
 	}
 
 	@SuppressWarnings("unchecked")
-	public <E extends AbstractSessionEvent> E getEvent(String sessionId)
-			throws InterruptedException {
+	public <E extends AbstractSessionEvent> E getEvent(String sessionId) throws InterruptedException {
 		return (E) waitForEvent(sessionId);
 	}
 
 	@SuppressWarnings("unchecked")
-	private <E extends AbstractSessionEvent> E waitForEvent(String sessionId)
-			throws InterruptedException {
+	private <E extends AbstractSessionEvent> E waitForEvent(String sessionId) throws InterruptedException {
 		Object lock = getLock(sessionId);
 		synchronized (lock) {
 			if (!this.events.containsKey(sessionId)) {
@@ -68,4 +68,5 @@ public class SessionEventRegistry implements ApplicationListener<AbstractSession
 	private Object getLock(String sessionId) {
 		return this.locks.computeIfAbsent(sessionId, (k) -> new Object());
 	}
+
 }

spring-session-hazelcast/src/integration-test/java/org/springframework/session/hazelcast/config/annotation/web/http/EnableHazelcastHttpSessionEventsTests.java

@@ -57,7 +57,7 @@ import static org.assertj.core.api.Assertions.assertThat;
 @ExtendWith(SpringExtension.class)
 @ContextConfiguration
 @WebAppConfiguration
-public class EnableHazelcastHttpSessionEventsTests<S extends Session> {
+class EnableHazelcastHttpSessionEventsTests<S extends Session> {
 
 	private static final int MAX_INACTIVE_INTERVAL_IN_SECONDS = 1;
 
@@ -68,12 +68,12 @@ public class EnableHazelcastHttpSessionEventsTests<S extends Session> {
 	private SessionEventRegistry registry;
 
 	@BeforeEach
-	public void setup() {
+	void setup() {
 		this.registry.clear();
 	}
 
 	@Test
-	public void saveSessionTest() throws InterruptedException {
+	void saveSessionTest() throws InterruptedException {
 		String username = "saves-" + System.currentTimeMillis();
 
 		S sessionToSave = this.repository.createSession();
@@ -81,13 +81,12 @@ public class EnableHazelcastHttpSessionEventsTests<S extends Session> {
 		String expectedAttributeName = "a";
 		String expectedAttributeValue = "b";
 		sessionToSave.setAttribute(expectedAttributeName, expectedAttributeValue);
-		Authentication toSaveToken = new UsernamePasswordAuthenticationToken(username,
-				"password", AuthorityUtils.createAuthorityList("ROLE_USER"));
+		Authentication toSaveToken = new UsernamePasswordAuthenticationToken(username, "password",
+				AuthorityUtils.createAuthorityList("ROLE_USER"));
 		SecurityContext toSaveContext = SecurityContextHolder.createEmptyContext();
 		toSaveContext.setAuthentication(toSaveToken);
 		sessionToSave.setAttribute("SPRING_SECURITY_CONTEXT", toSaveContext);
-		sessionToSave.setAttribute(
-				FindByIndexNameSessionRepository.PRINCIPAL_NAME_INDEX_NAME, username);
+		sessionToSave.setAttribute(FindByIndexNameSessionRepository.PRINCIPAL_NAME_INDEX_NAME, username);
 
 		this.repository.save(sessionToSave);
 
@@ -98,14 +97,13 @@ public class EnableHazelcastHttpSessionEventsTests<S extends Session> {
 		Session session = this.repository.findById(sessionToSave.getId());
 
 		assertThat(session.getId()).isEqualTo(sessionToSave.getId());
-		assertThat(session.getAttributeNames())
-				.isEqualTo(sessionToSave.getAttributeNames());
+		assertThat(session.getAttributeNames()).isEqualTo(sessionToSave.getAttributeNames());
 		assertThat(session.<String>getAttribute(expectedAttributeName))
 				.isEqualTo(sessionToSave.getAttribute(expectedAttributeName));
 	}
 
 	@Test
-	public void expiredSessionTest() throws InterruptedException {
+	void expiredSessionTest() throws InterruptedException {
 		S sessionToSave = this.repository.createSession();
 
 		this.repository.save(sessionToSave);
@@ -126,7 +124,7 @@ public class EnableHazelcastHttpSessionEventsTests<S extends Session> {
 	}
 
 	@Test
-	public void deletedSessionTest() throws InterruptedException {
+	void deletedSessionTest() throws InterruptedException {
 		S sessionToSave = this.repository.createSession();
 
 		this.repository.save(sessionToSave);
@@ -146,7 +144,7 @@ public class EnableHazelcastHttpSessionEventsTests<S extends Session> {
 	}
 
 	@Test
-	public void saveUpdatesTimeToLiveTest() throws InterruptedException {
+	void saveUpdatesTimeToLiveTest() throws InterruptedException {
 		S sessionToSave = this.repository.createSession();
 		sessionToSave.setMaxInactiveInterval(Duration.ofSeconds(3));
 		this.repository.save(sessionToSave);
@@ -164,7 +162,7 @@ public class EnableHazelcastHttpSessionEventsTests<S extends Session> {
 	}
 
 	@Test // gh-1077
-	public void changeSessionIdNoEventTest() throws InterruptedException {
+	void changeSessionIdNoEventTest() throws InterruptedException {
 		S sessionToSave = this.repository.createSession();
 		sessionToSave.setMaxInactiveInterval(Duration.ofMinutes(30));
 
@@ -182,7 +180,7 @@ public class EnableHazelcastHttpSessionEventsTests<S extends Session> {
 	}
 
 	@Test // gh-1300
-	public void updateMaxInactiveIntervalTest() throws InterruptedException {
+	void updateMaxInactiveIntervalTest() throws InterruptedException {
 		S sessionToSave = this.repository.createSession();
 		sessionToSave.setMaxInactiveInterval(Duration.ofMinutes(30));
 		this.repository.save(sessionToSave);

spring-session-hazelcast/src/integration-test/java/org/springframework/session/hazelcast/config/annotation/web/http/HazelcastHttpSessionConfigurationXmlTests.java

@@ -49,13 +49,13 @@ public class HazelcastHttpSessionConfigurationXmlTests<S extends Session> {
 	@ExtendWith(SpringExtension.class)
 	@ContextConfiguration
 	@WebAppConfiguration
-	public static class CustomXmlMapNameTest<S extends Session> {
+	static class CustomXmlMapNameTest<S extends Session> {
 
 		@Autowired
 		private SessionRepository<S> repository;
 
 		@Test
-		public void saveSessionTest() throws InterruptedException {
+		void saveSessionTest() throws InterruptedException {
 
 			S sessionToSave = this.repository.createSession();
 
@@ -64,8 +64,7 @@ public class HazelcastHttpSessionConfigurationXmlTests<S extends Session> {
 			S session = this.repository.findById(sessionToSave.getId());
 
 			assertThat(session.getId()).isEqualTo(sessionToSave.getId());
-			assertThat(session.getMaxInactiveInterval())
-					.isEqualTo(Duration.ofMinutes(30));
+			assertThat(session.getMaxInactiveInterval()).isEqualTo(Duration.ofMinutes(30));
 		}
 
 		@Configuration
@@ -81,19 +80,21 @@ public class HazelcastHttpSessionConfigurationXmlTests<S extends Session> {
 				hazelcastConfig.setNetworkConfig(netConfig);
 				return Hazelcast.newHazelcastInstance(hazelcastConfig);
 			}
+
 		}
+
 	}
 
 	@ExtendWith(SpringExtension.class)
 	@ContextConfiguration
 	@WebAppConfiguration
-	public static class CustomXmlMapNameAndIdleTest<S extends Session> {
+	static class CustomXmlMapNameAndIdleTest<S extends Session> {
 
 		@Autowired
 		private SessionRepository<S> repository;
 
 		@Test
-		public void saveSessionTest() throws InterruptedException {
+		void saveSessionTest() throws InterruptedException {
 
 			S sessionToSave = this.repository.createSession();
 
@@ -102,8 +103,7 @@ public class HazelcastHttpSessionConfigurationXmlTests<S extends Session> {
 			S session = this.repository.findById(sessionToSave.getId());
 
 			assertThat(session.getId()).isEqualTo(sessionToSave.getId());
-			assertThat(session.getMaxInactiveInterval())
-					.isEqualTo(Duration.ofMinutes(20));
+			assertThat(session.getMaxInactiveInterval()).isEqualTo(Duration.ofMinutes(20));
 		}
 
 		@Configuration
@@ -119,7 +119,9 @@ public class HazelcastHttpSessionConfigurationXmlTests<S extends Session> {
 				hazelcastConfig.setNetworkConfig(netConfig);
 				return Hazelcast.newHazelcastInstance(hazelcastConfig);
 			}
+
 		}
+
 	}
 
 }

spring-session-hazelcast/src/main/java/org/springframework/session/hazelcast/HazelcastSessionRepository.java

@@ -108,8 +108,8 @@ import org.springframework.util.ClassUtils;
  * @author Aleksandar Stojsavljevic
  * @since 1.3.0
  */
-public class HazelcastSessionRepository implements
-		FindByIndexNameSessionRepository<HazelcastSessionRepository.HazelcastSession>,
+public class HazelcastSessionRepository
+		implements FindByIndexNameSessionRepository<HazelcastSessionRepository.HazelcastSession>,
 		EntryAddedListener<String, MapSession>, EntryEvictedListener<String, MapSession>,
 		EntryRemovedListener<String, MapSession> {
 
@@ -125,8 +125,7 @@ public class HazelcastSessionRepository implements
 
 	private static final String SPRING_SECURITY_CONTEXT = "SPRING_SECURITY_CONTEXT";
 
-	private static final boolean SUPPORTS_SET_TTL = ClassUtils
-			.hasAtLeastOneMethodWithName(IMap.class, "setTtl");
+	private static final boolean SUPPORTS_SET_TTL = ClassUtils.hasAtLeastOneMethodWithName(IMap.class, "setTtl");
 
 	private static final Log logger = LogFactory.getLog(HazelcastSessionRepository.class);
 
@@ -180,14 +179,11 @@ public class HazelcastSessionRepository implements
 	 * Sets the {@link ApplicationEventPublisher} that is used to publish
 	 * {@link AbstractSessionEvent session events}. The default is to not publish session
 	 * events.
-	 *
 	 * @param applicationEventPublisher the {@link ApplicationEventPublisher} that is used
 	 * to publish session events. Cannot be null.
 	 */
-	public void setApplicationEventPublisher(
-			ApplicationEventPublisher applicationEventPublisher) {
-		Assert.notNull(applicationEventPublisher,
-				"ApplicationEventPublisher cannot be null");
+	public void setApplicationEventPublisher(ApplicationEventPublisher applicationEventPublisher) {
+		Assert.notNull(applicationEventPublisher, "ApplicationEventPublisher cannot be null");
 		this.eventPublisher = applicationEventPublisher;
 	}
 
@@ -224,8 +220,7 @@ public class HazelcastSessionRepository implements
 	public HazelcastSession createSession() {
 		HazelcastSession result = new HazelcastSession();
 		if (this.defaultMaxInactiveInterval != null) {
-			result.setMaxInactiveInterval(
-					Duration.ofSeconds(this.defaultMaxInactiveInterval));
+			result.setMaxInactiveInterval(Duration.ofSeconds(this.defaultMaxInactiveInterval));
 		}
 		return result;
 	}
@@ -233,14 +228,14 @@ public class HazelcastSessionRepository implements
 	@Override
 	public void save(HazelcastSession session) {
 		if (session.isNew) {
-			this.sessions.set(session.getId(), session.getDelegate(),
-					session.getMaxInactiveInterval().getSeconds(), TimeUnit.SECONDS);
+			this.sessions.set(session.getId(), session.getDelegate(), session.getMaxInactiveInterval().getSeconds(),
+					TimeUnit.SECONDS);
 		}
 		else if (session.sessionIdChanged) {
 			this.sessions.delete(session.originalId);
 			session.originalId = session.getId();
-			this.sessions.set(session.getId(), session.getDelegate(),
-					session.getMaxInactiveInterval().getSeconds(), TimeUnit.SECONDS);
+			this.sessions.set(session.getId(), session.getDelegate(), session.getMaxInactiveInterval().getSeconds(),
+					TimeUnit.SECONDS);
 		}
 		else if (session.hasChanges()) {
 			SessionUpdateEntryProcessor entryProcessor = new SessionUpdateEntryProcessor();
@@ -262,8 +257,7 @@ public class HazelcastSessionRepository implements
 	}
 
 	private void updateTtl(HazelcastSession session) {
-		this.sessions.setTtl(session.getId(),
-				session.getMaxInactiveInterval().getSeconds(), TimeUnit.SECONDS);
+		this.sessions.setTtl(session.getId(), session.getMaxInactiveInterval().getSeconds(), TimeUnit.SECONDS);
 	}
 
 	@Override
@@ -285,13 +279,11 @@ public class HazelcastSessionRepository implements
 	}
 
 	@Override
-	public Map<String, HazelcastSession> findByIndexNameAndIndexValue(String indexName,
-			String indexValue) {
+	public Map<String, HazelcastSession> findByIndexNameAndIndexValue(String indexName, String indexValue) {
 		if (!PRINCIPAL_NAME_INDEX_NAME.equals(indexName)) {
 			return Collections.emptyMap();
 		}
-		Collection<MapSession> sessions = this.sessions
-				.values(Predicates.equal(PRINCIPAL_NAME_ATTRIBUTE, indexValue));
+		Collection<MapSession> sessions = this.sessions.values(Predicates.equal(PRINCIPAL_NAME_ATTRIBUTE, indexValue));
 		Map<String, HazelcastSession> sessionMap = new HashMap<>(sessions.size());
 		for (MapSession session : sessions) {
 			sessionMap.put(session.getId(), new HazelcastSession(session));
@@ -315,8 +307,7 @@ public class HazelcastSessionRepository implements
 		if (logger.isDebugEnabled()) {
 			logger.debug("Session expired with id: " + event.getOldValue().getId());
 		}
-		this.eventPublisher
-				.publishEvent(new SessionExpiredEvent(this, event.getOldValue()));
+		this.eventPublisher.publishEvent(new SessionExpiredEvent(this, event.getOldValue()));
 	}
 
 	@Override
@@ -434,9 +425,7 @@ public class HazelcastSessionRepository implements
 			this.delegate.setAttribute(attributeName, attributeValue);
 			this.delta.put(attributeName, attributeValue);
 			if (SPRING_SECURITY_CONTEXT.equals(attributeName)) {
-				String principal = (attributeValue != null)
-						? principalNameResolver.resolvePrincipal(this)
-						: null;
+				String principal = (attributeValue != null) ? principalNameResolver.resolvePrincipal(this) : null;
 				this.delegate.setAttribute(PRINCIPAL_NAME_INDEX_NAME, principal);
 			}
 			flushImmediateIfNecessary();
@@ -452,8 +441,7 @@ public class HazelcastSessionRepository implements
 		}
 
 		boolean hasChanges() {
-			return (this.lastAccessedTimeChanged || this.maxInactiveIntervalChanged
-					|| !this.delta.isEmpty());
+			return (this.lastAccessedTimeChanged || this.maxInactiveIntervalChanged || !this.delta.isEmpty());
 		}
 
 		void clearChangeFlags() {
@@ -486,8 +474,7 @@ public class HazelcastSessionRepository implements
 			}
 			Object authentication = session.getAttribute(SPRING_SECURITY_CONTEXT);
 			if (authentication != null) {
-				Expression expression = this.parser
-						.parseExpression("authentication?.name");
+				Expression expression = this.parser.parseExpression("authentication?.name");
 				return expression.getValue(authentication, String.class);
 			}
 			return null;

spring-session-hazelcast/src/main/java/org/springframework/session/hazelcast/PrincipalNameExtractor.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2014-2017 the original author or authors.
+ * Copyright 2014-2019 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.
@@ -34,8 +34,7 @@ public class PrincipalNameExtractor extends ValueExtractor<MapSession, String> {
 	@Override
 	@SuppressWarnings("unchecked")
 	public void extract(MapSession target, String argument, ValueCollector collector) {
-		String principalName = target
-				.getAttribute(FindByIndexNameSessionRepository.PRINCIPAL_NAME_INDEX_NAME);
+		String principalName = target.getAttribute(FindByIndexNameSessionRepository.PRINCIPAL_NAME_INDEX_NAME);
 		if (principalName != null) {
 			collector.addObject(principalName);
 		}

spring-session-hazelcast/src/main/java/org/springframework/session/hazelcast/SessionUpdateEntryProcessor.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2014-2018 the original author or authors.
+ * Copyright 2014-2019 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.
@@ -33,8 +33,7 @@ import org.springframework.session.MapSession;
  * @since 1.3.4
  * @see HazelcastSessionRepository#save(HazelcastSessionRepository.HazelcastSession)
  */
-public class SessionUpdateEntryProcessor
-		extends AbstractEntryProcessor<String, MapSession> implements Offloadable {
+public class SessionUpdateEntryProcessor extends AbstractEntryProcessor<String, MapSession> implements Offloadable {
 
 	private Instant lastAccessedTime;
 

spring-session-hazelcast/src/main/java/org/springframework/session/hazelcast/config/annotation/SpringSessionHazelcastInstance.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2014-2017 the original author or authors.
+ * Copyright 2014-2019 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.
@@ -34,8 +34,7 @@ import org.springframework.session.hazelcast.HazelcastSessionRepository;
  * @author Vedran Pavic
  * @since 2.0.0
  */
-@Target({ ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER, ElementType.TYPE,
-		ElementType.ANNOTATION_TYPE })
+@Target({ ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER, ElementType.TYPE, ElementType.ANNOTATION_TYPE })
 @Retention(RetentionPolicy.RUNTIME)
 @Documented
 @Qualifier

spring-session-hazelcast/src/main/java/org/springframework/session/hazelcast/config/annotation/web/http/EnableHazelcastHttpSession.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2014-2017 the original author or authors.
+ * Copyright 2014-2019 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.
@@ -79,8 +79,7 @@ public @interface EnableHazelcastHttpSession {
 
 	/**
 	 * This is the name of the Map that will be used in Hazelcast to store the session
-	 * data. Default is
-	 * {@link HazelcastSessionRepository#DEFAULT_SESSION_MAP_NAME}.
+	 * data. Default is {@link HazelcastSessionRepository#DEFAULT_SESSION_MAP_NAME}.
 	 * @return the name of the Map to store the sessions in Hazelcast
 	 */
 	String sessionMapName() default HazelcastSessionRepository.DEFAULT_SESSION_MAP_NAME;

spring-session-hazelcast/src/main/java/org/springframework/session/hazelcast/config/annotation/web/http/HazelcastHttpSessionConfiguration.java

@@ -47,8 +47,7 @@ import org.springframework.util.StringUtils;
  * @see EnableHazelcastHttpSession
  */
 @Configuration(proxyBeanMethods = false)
-public class HazelcastHttpSessionConfiguration extends SpringHttpSessionConfiguration
-		implements ImportAware {
+public class HazelcastHttpSessionConfiguration extends SpringHttpSessionConfiguration implements ImportAware {
 
 	private Integer maxInactiveIntervalInSeconds = MapSession.DEFAULT_MAX_INACTIVE_INTERVAL_SECONDS;
 
@@ -62,14 +61,12 @@ public class HazelcastHttpSessionConfiguration extends SpringHttpSessionConfigur
 
 	@Bean
 	public HazelcastSessionRepository sessionRepository() {
-		HazelcastSessionRepository sessionRepository = new HazelcastSessionRepository(
-				this.hazelcastInstance);
+		HazelcastSessionRepository sessionRepository = new HazelcastSessionRepository(this.hazelcastInstance);
 		sessionRepository.setApplicationEventPublisher(this.applicationEventPublisher);
 		if (StringUtils.hasText(this.sessionMapName)) {
 			sessionRepository.setSessionMapName(this.sessionMapName);
 		}
-		sessionRepository
-				.setDefaultMaxInactiveInterval(this.maxInactiveIntervalInSeconds);
+		sessionRepository.setDefaultMaxInactiveInterval(this.maxInactiveIntervalInSeconds);
 		sessionRepository.setHazelcastFlushMode(this.hazelcastFlushMode);
 		return sessionRepository;
 	}
@@ -90,8 +87,7 @@ public class HazelcastHttpSessionConfiguration extends SpringHttpSessionConfigur
 	public void setHazelcastInstance(
 			@SpringSessionHazelcastInstance ObjectProvider<HazelcastInstance> springSessionHazelcastInstance,
 			ObjectProvider<HazelcastInstance> hazelcastInstance) {
-		HazelcastInstance hazelcastInstanceToUse = springSessionHazelcastInstance
-				.getIfAvailable();
+		HazelcastInstance hazelcastInstanceToUse = springSessionHazelcastInstance.getIfAvailable();
 		if (hazelcastInstanceToUse == null) {
 			hazelcastInstanceToUse = hazelcastInstance.getObject();
 		}
@@ -99,8 +95,7 @@ public class HazelcastHttpSessionConfiguration extends SpringHttpSessionConfigur
 	}
 
 	@Autowired
-	public void setApplicationEventPublisher(
-			ApplicationEventPublisher applicationEventPublisher) {
+	public void setApplicationEventPublisher(ApplicationEventPublisher applicationEventPublisher) {
 		this.applicationEventPublisher = applicationEventPublisher;
 	}
 
@@ -109,8 +104,7 @@ public class HazelcastHttpSessionConfiguration extends SpringHttpSessionConfigur
 		Map<String, Object> attributeMap = importMetadata
 				.getAnnotationAttributes(EnableHazelcastHttpSession.class.getName());
 		AnnotationAttributes attributes = AnnotationAttributes.fromMap(attributeMap);
-		this.maxInactiveIntervalInSeconds =
-				attributes.getNumber("maxInactiveIntervalInSeconds");
+		this.maxInactiveIntervalInSeconds = attributes.getNumber("maxInactiveIntervalInSeconds");
 		String sessionMapNameValue = attributes.getString("sessionMapName");
 		if (StringUtils.hasText(sessionMapNameValue)) {
 			this.sessionMapName = sessionMapNameValue;

spring-session-hazelcast/src/test/java/org/springframework/session/hazelcast/HazelcastSessionRepositoryTests.java

@@ -58,7 +58,7 @@ import static org.mockito.Mockito.verifyZeroInteractions;
  * @author Vedran Pavic
  * @author Aleksandar Stojsavljevic
  */
-public class HazelcastSessionRepositoryTests {
+class HazelcastSessionRepositoryTests {
 
 	private static final String SPRING_SECURITY_CONTEXT = "SPRING_SECURITY_CONTEXT";
 
@@ -70,241 +70,218 @@ public class HazelcastSessionRepositoryTests {
 	private HazelcastSessionRepository repository;
 
 	@BeforeEach
-	public void setUp() {
-		given(this.hazelcastInstance.<String, MapSession>getMap(anyString()))
-				.willReturn(this.sessions);
+	void setUp() {
+		given(this.hazelcastInstance.<String, MapSession>getMap(anyString())).willReturn(this.sessions);
 		this.repository = new HazelcastSessionRepository(this.hazelcastInstance);
 		this.repository.init();
 	}
 
 	@Test
-	public void constructorNullHazelcastInstance() {
-		assertThatIllegalArgumentException()
-				.isThrownBy(() -> new HazelcastSessionRepository(null))
+	void constructorNullHazelcastInstance() {
+		assertThatIllegalArgumentException().isThrownBy(() -> new HazelcastSessionRepository(null))
 				.withMessage("HazelcastInstance must not be null");
 	}
 
 	@Test
-	public void createSessionDefaultMaxInactiveInterval() {
-		verify(this.sessions, times(1)).addEntryListener(any(MapListener.class),
-				anyBoolean());
+	void createSessionDefaultMaxInactiveInterval() {
+		verify(this.sessions, times(1)).addEntryListener(any(MapListener.class), anyBoolean());
 
 		HazelcastSession session = this.repository.createSession();
 
-		assertThat(session.getMaxInactiveInterval())
-				.isEqualTo(new MapSession().getMaxInactiveInterval());
+		assertThat(session.getMaxInactiveInterval()).isEqualTo(new MapSession().getMaxInactiveInterval());
 		verifyZeroInteractions(this.sessions);
 	}
 
 	@Test
-	public void createSessionCustomMaxInactiveInterval() {
-		verify(this.sessions, times(1)).addEntryListener(any(MapListener.class),
-				anyBoolean());
+	void createSessionCustomMaxInactiveInterval() {
+		verify(this.sessions, times(1)).addEntryListener(any(MapListener.class), anyBoolean());
 
 		int interval = 1;
 		this.repository.setDefaultMaxInactiveInterval(interval);
 
 		HazelcastSession session = this.repository.createSession();
 
-		assertThat(session.getMaxInactiveInterval())
-				.isEqualTo(Duration.ofSeconds(interval));
+		assertThat(session.getMaxInactiveInterval()).isEqualTo(Duration.ofSeconds(interval));
 		verifyZeroInteractions(this.sessions);
 	}
 
 	@Test
-	public void saveNewFlushModeOnSave() {
-		verify(this.sessions, times(1)).addEntryListener(any(MapListener.class),
-				anyBoolean());
+	void saveNewFlushModeOnSave() {
+		verify(this.sessions, times(1)).addEntryListener(any(MapListener.class), anyBoolean());
 
 		HazelcastSession session = this.repository.createSession();
 		verifyZeroInteractions(this.sessions);
 
 		this.repository.save(session);
-		verify(this.sessions, times(1)).set(eq(session.getId()),
-				eq(session.getDelegate()), isA(Long.class), eq(TimeUnit.SECONDS));
+		verify(this.sessions, times(1)).set(eq(session.getId()), eq(session.getDelegate()), isA(Long.class),
+				eq(TimeUnit.SECONDS));
 		verifyZeroInteractions(this.sessions);
 	}
 
 	@Test
-	public void saveNewFlushModeImmediate() {
-		verify(this.sessions, times(1)).addEntryListener(any(MapListener.class),
-				anyBoolean());
+	void saveNewFlushModeImmediate() {
+		verify(this.sessions, times(1)).addEntryListener(any(MapListener.class), anyBoolean());
 
 		this.repository.setHazelcastFlushMode(HazelcastFlushMode.IMMEDIATE);
 
 		HazelcastSession session = this.repository.createSession();
-		verify(this.sessions, times(1)).set(eq(session.getId()),
-				eq(session.getDelegate()), isA(Long.class), eq(TimeUnit.SECONDS));
+		verify(this.sessions, times(1)).set(eq(session.getId()), eq(session.getDelegate()), isA(Long.class),
+				eq(TimeUnit.SECONDS));
 		verifyZeroInteractions(this.sessions);
 	}
 
 	@Test
-	public void saveUpdatedAttributeFlushModeOnSave() {
-		verify(this.sessions, times(1)).addEntryListener(any(MapListener.class),
-				anyBoolean());
+	void saveUpdatedAttributeFlushModeOnSave() {
+		verify(this.sessions, times(1)).addEntryListener(any(MapListener.class), anyBoolean());
 
 		HazelcastSession session = this.repository.createSession();
 		session.setAttribute("testName", "testValue");
 		verifyZeroInteractions(this.sessions);
 
 		this.repository.save(session);
-		verify(this.sessions, times(1)).set(eq(session.getId()),
-				eq(session.getDelegate()), isA(Long.class), eq(TimeUnit.SECONDS));
+		verify(this.sessions, times(1)).set(eq(session.getId()), eq(session.getDelegate()), isA(Long.class),
+				eq(TimeUnit.SECONDS));
 		verifyZeroInteractions(this.sessions);
 	}
 
 	@Test
-	public void saveUpdatedAttributeFlushModeImmediate() {
-		verify(this.sessions, times(1)).addEntryListener(any(MapListener.class),
-				anyBoolean());
+	void saveUpdatedAttributeFlushModeImmediate() {
+		verify(this.sessions, times(1)).addEntryListener(any(MapListener.class), anyBoolean());
 
 		this.repository.setHazelcastFlushMode(HazelcastFlushMode.IMMEDIATE);
 
 		HazelcastSession session = this.repository.createSession();
 		session.setAttribute("testName", "testValue");
-		verify(this.sessions, times(1)).set(eq(session.getId()),
-				eq(session.getDelegate()), isA(Long.class), eq(TimeUnit.SECONDS));
-		verify(this.sessions, times(1)).executeOnKey(eq(session.getId()),
-				any(EntryProcessor.class));
+		verify(this.sessions, times(1)).set(eq(session.getId()), eq(session.getDelegate()), isA(Long.class),
+				eq(TimeUnit.SECONDS));
+		verify(this.sessions, times(1)).executeOnKey(eq(session.getId()), any(EntryProcessor.class));
 
 		this.repository.save(session);
 		verifyZeroInteractions(this.sessions);
 	}
 
 	@Test
-	public void removeAttributeFlushModeOnSave() {
-		verify(this.sessions, times(1)).addEntryListener(any(MapListener.class),
-				anyBoolean());
+	void removeAttributeFlushModeOnSave() {
+		verify(this.sessions, times(1)).addEntryListener(any(MapListener.class), anyBoolean());
 
 		HazelcastSession session = this.repository.createSession();
 		session.removeAttribute("testName");
 		verifyZeroInteractions(this.sessions);
 
 		this.repository.save(session);
-		verify(this.sessions, times(1)).set(eq(session.getId()),
-				eq(session.getDelegate()), isA(Long.class), eq(TimeUnit.SECONDS));
+		verify(this.sessions, times(1)).set(eq(session.getId()), eq(session.getDelegate()), isA(Long.class),
+				eq(TimeUnit.SECONDS));
 		verifyZeroInteractions(this.sessions);
 	}
 
 	@Test
-	public void removeAttributeFlushModeImmediate() {
-		verify(this.sessions, times(1)).addEntryListener(any(MapListener.class),
-				anyBoolean());
+	void removeAttributeFlushModeImmediate() {
+		verify(this.sessions, times(1)).addEntryListener(any(MapListener.class), anyBoolean());
 
 		this.repository.setHazelcastFlushMode(HazelcastFlushMode.IMMEDIATE);
 
 		HazelcastSession session = this.repository.createSession();
 		session.removeAttribute("testName");
-		verify(this.sessions, times(1)).set(eq(session.getId()),
-				eq(session.getDelegate()), isA(Long.class), eq(TimeUnit.SECONDS));
-		verify(this.sessions, times(1)).executeOnKey(eq(session.getId()),
-				any(EntryProcessor.class));
+		verify(this.sessions, times(1)).set(eq(session.getId()), eq(session.getDelegate()), isA(Long.class),
+				eq(TimeUnit.SECONDS));
+		verify(this.sessions, times(1)).executeOnKey(eq(session.getId()), any(EntryProcessor.class));
 
 		this.repository.save(session);
 		verifyZeroInteractions(this.sessions);
 	}
 
 	@Test
-	public void saveUpdatedLastAccessedTimeFlushModeOnSave() {
-		verify(this.sessions, times(1)).addEntryListener(any(MapListener.class),
-				anyBoolean());
+	void saveUpdatedLastAccessedTimeFlushModeOnSave() {
+		verify(this.sessions, times(1)).addEntryListener(any(MapListener.class), anyBoolean());
 
 		HazelcastSession session = this.repository.createSession();
 		session.setLastAccessedTime(Instant.now());
 		verifyZeroInteractions(this.sessions);
 
 		this.repository.save(session);
-		verify(this.sessions, times(1)).set(eq(session.getId()),
-				eq(session.getDelegate()), isA(Long.class), eq(TimeUnit.SECONDS));
+		verify(this.sessions, times(1)).set(eq(session.getId()), eq(session.getDelegate()), isA(Long.class),
+				eq(TimeUnit.SECONDS));
 		verifyZeroInteractions(this.sessions);
 	}
 
 	@Test
-	public void saveUpdatedLastAccessedTimeFlushModeImmediate() {
-		verify(this.sessions, times(1)).addEntryListener(any(MapListener.class),
-				anyBoolean());
+	void saveUpdatedLastAccessedTimeFlushModeImmediate() {
+		verify(this.sessions, times(1)).addEntryListener(any(MapListener.class), anyBoolean());
 
 		this.repository.setHazelcastFlushMode(HazelcastFlushMode.IMMEDIATE);
 
 		HazelcastSession session = this.repository.createSession();
 		session.setLastAccessedTime(Instant.now());
-		verify(this.sessions, times(1)).set(eq(session.getId()),
-				eq(session.getDelegate()), isA(Long.class), eq(TimeUnit.SECONDS));
-		verify(this.sessions, times(1)).executeOnKey(eq(session.getId()),
-				any(EntryProcessor.class));
+		verify(this.sessions, times(1)).set(eq(session.getId()), eq(session.getDelegate()), isA(Long.class),
+				eq(TimeUnit.SECONDS));
+		verify(this.sessions, times(1)).executeOnKey(eq(session.getId()), any(EntryProcessor.class));
 
 		this.repository.save(session);
 		verifyZeroInteractions(this.sessions);
 	}
 
 	@Test
-	public void saveUpdatedMaxInactiveIntervalInSecondsFlushModeOnSave() {
-		verify(this.sessions, times(1)).addEntryListener(any(MapListener.class),
-				anyBoolean());
+	void saveUpdatedMaxInactiveIntervalInSecondsFlushModeOnSave() {
+		verify(this.sessions, times(1)).addEntryListener(any(MapListener.class), anyBoolean());
 
 		HazelcastSession session = this.repository.createSession();
 		session.setMaxInactiveInterval(Duration.ofSeconds(1));
 		verifyZeroInteractions(this.sessions);
 
 		this.repository.save(session);
-		verify(this.sessions, times(1)).set(eq(session.getId()),
-				eq(session.getDelegate()), isA(Long.class), eq(TimeUnit.SECONDS));
+		verify(this.sessions, times(1)).set(eq(session.getId()), eq(session.getDelegate()), isA(Long.class),
+				eq(TimeUnit.SECONDS));
 		verifyZeroInteractions(this.sessions);
 	}
 
 	@Test
-	public void saveUpdatedMaxInactiveIntervalInSecondsFlushModeImmediate() {
-		verify(this.sessions, times(1)).addEntryListener(any(MapListener.class),
-				anyBoolean());
+	void saveUpdatedMaxInactiveIntervalInSecondsFlushModeImmediate() {
+		verify(this.sessions, times(1)).addEntryListener(any(MapListener.class), anyBoolean());
 
 		this.repository.setHazelcastFlushMode(HazelcastFlushMode.IMMEDIATE);
 
 		HazelcastSession session = this.repository.createSession();
 		String sessionId = session.getId();
 		session.setMaxInactiveInterval(Duration.ofSeconds(1));
-		verify(this.sessions, times(1)).set(eq(sessionId), eq(session.getDelegate()),
-				isA(Long.class), eq(TimeUnit.SECONDS));
+		verify(this.sessions, times(1)).set(eq(sessionId), eq(session.getDelegate()), isA(Long.class),
+				eq(TimeUnit.SECONDS));
 		verify(this.sessions).setTtl(eq(sessionId), anyLong(), any());
-		verify(this.sessions, times(1)).executeOnKey(eq(sessionId),
-				any(EntryProcessor.class));
+		verify(this.sessions, times(1)).executeOnKey(eq(sessionId), any(EntryProcessor.class));
 
 		this.repository.save(session);
 		verifyZeroInteractions(this.sessions);
 	}
 
 	@Test
-	public void saveUnchangedFlushModeOnSave() {
-		verify(this.sessions, times(1)).addEntryListener(any(MapListener.class),
-				anyBoolean());
+	void saveUnchangedFlushModeOnSave() {
+		verify(this.sessions, times(1)).addEntryListener(any(MapListener.class), anyBoolean());
 
 		HazelcastSession session = this.repository.createSession();
 		this.repository.save(session);
-		verify(this.sessions, times(1)).set(eq(session.getId()),
-				eq(session.getDelegate()), isA(Long.class), eq(TimeUnit.SECONDS));
+		verify(this.sessions, times(1)).set(eq(session.getId()), eq(session.getDelegate()), isA(Long.class),
+				eq(TimeUnit.SECONDS));
 
 		this.repository.save(session);
 		verifyZeroInteractions(this.sessions);
 	}
 
 	@Test
-	public void saveUnchangedFlushModeImmediate() {
-		verify(this.sessions, times(1)).addEntryListener(any(MapListener.class),
-				anyBoolean());
+	void saveUnchangedFlushModeImmediate() {
+		verify(this.sessions, times(1)).addEntryListener(any(MapListener.class), anyBoolean());
 
 		this.repository.setHazelcastFlushMode(HazelcastFlushMode.IMMEDIATE);
 
 		HazelcastSession session = this.repository.createSession();
-		verify(this.sessions, times(1)).set(eq(session.getId()),
-				eq(session.getDelegate()), isA(Long.class), eq(TimeUnit.SECONDS));
+		verify(this.sessions, times(1)).set(eq(session.getId()), eq(session.getDelegate()), isA(Long.class),
+				eq(TimeUnit.SECONDS));
 
 		this.repository.save(session);
 		verifyZeroInteractions(this.sessions);
 	}
 
 	@Test
-	public void getSessionNotFound() {
-		verify(this.sessions, times(1)).addEntryListener(any(MapListener.class),
-				anyBoolean());
+	void getSessionNotFound() {
+		verify(this.sessions, times(1)).addEntryListener(any(MapListener.class), anyBoolean());
 
 		String sessionId = "testSessionId";
 
@@ -316,13 +293,11 @@ public class HazelcastSessionRepositoryTests {
 	}
 
 	@Test
-	public void getSessionExpired() {
-		verify(this.sessions, times(1)).addEntryListener(any(MapListener.class),
-				anyBoolean());
+	void getSessionExpired() {
+		verify(this.sessions, times(1)).addEntryListener(any(MapListener.class), anyBoolean());
 
 		MapSession expired = new MapSession();
-		expired.setLastAccessedTime(Instant.now()
-				.minusSeconds(MapSession.DEFAULT_MAX_INACTIVE_INTERVAL_SECONDS + 1));
+		expired.setLastAccessedTime(Instant.now().minusSeconds(MapSession.DEFAULT_MAX_INACTIVE_INTERVAL_SECONDS + 1));
 		given(this.sessions.get(eq(expired.getId()))).willReturn(expired);
 
 		HazelcastSession session = this.repository.findById(expired.getId());
@@ -334,9 +309,8 @@ public class HazelcastSessionRepositoryTests {
 	}
 
 	@Test
-	public void getSessionFound() {
-		verify(this.sessions, times(1)).addEntryListener(any(MapListener.class),
-				anyBoolean());
+	void getSessionFound() {
+		verify(this.sessions, times(1)).addEntryListener(any(MapListener.class), anyBoolean());
 
 		MapSession saved = new MapSession();
 		saved.setAttribute("savedName", "savedValue");
@@ -351,9 +325,8 @@ public class HazelcastSessionRepositoryTests {
 	}
 
 	@Test
-	public void delete() {
-		verify(this.sessions, times(1)).addEntryListener(any(MapListener.class),
-				anyBoolean());
+	void delete() {
+		verify(this.sessions, times(1)).addEntryListener(any(MapListener.class), anyBoolean());
 
 		String sessionId = "testSessionId";
 
@@ -364,30 +337,26 @@ public class HazelcastSessionRepositoryTests {
 	}
 
 	@Test
-	public void findByIndexNameAndIndexValueUnknownIndexName() {
-		verify(this.sessions, times(1)).addEntryListener(any(MapListener.class),
-				anyBoolean());
+	void findByIndexNameAndIndexValueUnknownIndexName() {
+		verify(this.sessions, times(1)).addEntryListener(any(MapListener.class), anyBoolean());
 
 		String indexValue = "testIndexValue";
 
-		Map<String, HazelcastSession> sessions = this.repository
-				.findByIndexNameAndIndexValue("testIndexName", indexValue);
+		Map<String, HazelcastSession> sessions = this.repository.findByIndexNameAndIndexValue("testIndexName",
+				indexValue);
 
 		assertThat(sessions).isEmpty();
 		verifyZeroInteractions(this.sessions);
 	}
 
 	@Test
-	public void findByIndexNameAndIndexValuePrincipalIndexNameNotFound() {
-		verify(this.sessions, times(1)).addEntryListener(any(MapListener.class),
-				anyBoolean());
+	void findByIndexNameAndIndexValuePrincipalIndexNameNotFound() {
+		verify(this.sessions, times(1)).addEntryListener(any(MapListener.class), anyBoolean());
 
 		String principal = "username";
 
 		Map<String, HazelcastSession> sessions = this.repository
-				.findByIndexNameAndIndexValue(
-						FindByIndexNameSessionRepository.PRINCIPAL_NAME_INDEX_NAME,
-						principal);
+				.findByIndexNameAndIndexValue(FindByIndexNameSessionRepository.PRINCIPAL_NAME_INDEX_NAME, principal);
 
 		assertThat(sessions).isEmpty();
 		verify(this.sessions, times(1)).values(isA(EqualPredicate.class));
@@ -395,13 +364,12 @@ public class HazelcastSessionRepositoryTests {
 	}
 
 	@Test
-	public void findByIndexNameAndIndexValuePrincipalIndexNameFound() {
-		verify(this.sessions, times(1)).addEntryListener(any(MapListener.class),
-				anyBoolean());
+	void findByIndexNameAndIndexValuePrincipalIndexNameFound() {
+		verify(this.sessions, times(1)).addEntryListener(any(MapListener.class), anyBoolean());
 
 		String principal = "username";
-		Authentication authentication = new UsernamePasswordAuthenticationToken(principal,
-				"notused", AuthorityUtils.createAuthorityList("ROLE_USER"));
+		Authentication authentication = new UsernamePasswordAuthenticationToken(principal, "notused",
+				AuthorityUtils.createAuthorityList("ROLE_USER"));
 		List<MapSession> saved = new ArrayList<>(2);
 		MapSession saved1 = new MapSession();
 		saved1.setAttribute(SPRING_SECURITY_CONTEXT, authentication);
@@ -412,9 +380,7 @@ public class HazelcastSessionRepositoryTests {
 		given(this.sessions.values(isA(EqualPredicate.class))).willReturn(saved);
 
 		Map<String, HazelcastSession> sessions = this.repository
-				.findByIndexNameAndIndexValue(
-						FindByIndexNameSessionRepository.PRINCIPAL_NAME_INDEX_NAME,
-						principal);
+				.findByIndexNameAndIndexValue(FindByIndexNameSessionRepository.PRINCIPAL_NAME_INDEX_NAME, principal);
 
 		assertThat(sessions).hasSize(2);
 		verify(this.sessions, times(1)).values(isA(EqualPredicate.class));
@@ -422,7 +388,7 @@ public class HazelcastSessionRepositoryTests {
 	}
 
 	@Test // gh-1120
-	public void getAttributeNamesAndRemove() {
+	void getAttributeNamesAndRemove() {
 		HazelcastSession session = this.repository.createSession();
 		session.setAttribute("attribute1", "value1");
 		session.setAttribute("attribute2", "value2");

spring-session-hazelcast/src/test/java/org/springframework/session/hazelcast/config/annotation/web/http/HazelcastHttpSessionConfigurationTests.java

@@ -43,7 +43,7 @@ import static org.mockito.Mockito.mock;
  * @author Vedran Pavic
  * @author Aleksandar Stojsavljevic
  */
-public class HazelcastHttpSessionConfigurationTests {
+class HazelcastHttpSessionConfigurationTests {
 
 	private static final String MAP_NAME = "spring:test:sessions";
 
@@ -54,150 +54,130 @@ public class HazelcastHttpSessionConfigurationTests {
 	private AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
 
 	@AfterEach
-	public void closeContext() {
+	void closeContext() {
 		if (this.context != null) {
 			this.context.close();
 		}
 	}
 
 	@Test
-	public void noHazelcastInstanceConfiguration() {
+	void noHazelcastInstanceConfiguration() {
 		assertThatExceptionOfType(BeanCreationException.class)
-				.isThrownBy(
-						() -> registerAndRefresh(NoHazelcastInstanceConfiguration.class))
+				.isThrownBy(() -> registerAndRefresh(NoHazelcastInstanceConfiguration.class))
 				.withMessageContaining("HazelcastInstance");
 	}
 
 	@Test
-	public void defaultConfiguration() {
+	void defaultConfiguration() {
 		registerAndRefresh(DefaultConfiguration.class);
 
 		assertThat(this.context.getBean(HazelcastSessionRepository.class)).isNotNull();
 	}
 
 	@Test
-	public void customTableName() {
+	void customTableName() {
 		registerAndRefresh(CustomSessionMapNameConfiguration.class);
 
-		HazelcastSessionRepository repository = this.context
-				.getBean(HazelcastSessionRepository.class);
-		HazelcastHttpSessionConfiguration configuration = this.context
-				.getBean(HazelcastHttpSessionConfiguration.class);
+		HazelcastSessionRepository repository = this.context.getBean(HazelcastSessionRepository.class);
+		HazelcastHttpSessionConfiguration configuration = this.context.getBean(HazelcastHttpSessionConfiguration.class);
 		assertThat(repository).isNotNull();
-		assertThat(ReflectionTestUtils.getField(configuration, "sessionMapName"))
-				.isEqualTo(MAP_NAME);
+		assertThat(ReflectionTestUtils.getField(configuration, "sessionMapName")).isEqualTo(MAP_NAME);
 	}
 
 	@Test
-	public void setCustomSessionMapName() {
-		registerAndRefresh(BaseConfiguration.class,
-				CustomSessionMapNameSetConfiguration.class);
+	void setCustomSessionMapName() {
+		registerAndRefresh(BaseConfiguration.class, CustomSessionMapNameSetConfiguration.class);
 
-		HazelcastSessionRepository repository = this.context
-				.getBean(HazelcastSessionRepository.class);
-		HazelcastHttpSessionConfiguration configuration = this.context
-				.getBean(HazelcastHttpSessionConfiguration.class);
+		HazelcastSessionRepository repository = this.context.getBean(HazelcastSessionRepository.class);
+		HazelcastHttpSessionConfiguration configuration = this.context.getBean(HazelcastHttpSessionConfiguration.class);
 		assertThat(repository).isNotNull();
-		assertThat(ReflectionTestUtils.getField(configuration, "sessionMapName"))
-				.isEqualTo(MAP_NAME);
+		assertThat(ReflectionTestUtils.getField(configuration, "sessionMapName")).isEqualTo(MAP_NAME);
 	}
 
 	@Test
-	public void setCustomMaxInactiveIntervalInSeconds() {
-		registerAndRefresh(BaseConfiguration.class,
-				CustomMaxInactiveIntervalInSecondsSetConfiguration.class);
+	void setCustomMaxInactiveIntervalInSeconds() {
+		registerAndRefresh(BaseConfiguration.class, CustomMaxInactiveIntervalInSecondsSetConfiguration.class);
 
-		HazelcastSessionRepository repository = this.context
-				.getBean(HazelcastSessionRepository.class);
+		HazelcastSessionRepository repository = this.context.getBean(HazelcastSessionRepository.class);
 		assertThat(repository).isNotNull();
 		assertThat(ReflectionTestUtils.getField(repository, "defaultMaxInactiveInterval"))
 				.isEqualTo(MAX_INACTIVE_INTERVAL_IN_SECONDS);
 	}
 
 	@Test
-	public void customMaxInactiveIntervalInSeconds() {
+	void customMaxInactiveIntervalInSeconds() {
 		registerAndRefresh(CustomMaxInactiveIntervalInSecondsConfiguration.class);
 
-		HazelcastSessionRepository repository = this.context
-				.getBean(HazelcastSessionRepository.class);
+		HazelcastSessionRepository repository = this.context.getBean(HazelcastSessionRepository.class);
 		assertThat(repository).isNotNull();
 		assertThat(ReflectionTestUtils.getField(repository, "defaultMaxInactiveInterval"))
 				.isEqualTo(MAX_INACTIVE_INTERVAL_IN_SECONDS);
 	}
 
 	@Test
-	public void customFlushImmediately() {
+	void customFlushImmediately() {
 		registerAndRefresh(CustomFlushImmediatelyConfiguration.class);
 
-		HazelcastSessionRepository repository = this.context
-				.getBean(HazelcastSessionRepository.class);
+		HazelcastSessionRepository repository = this.context.getBean(HazelcastSessionRepository.class);
 		assertThat(repository).isNotNull();
 		assertThat(ReflectionTestUtils.getField(repository, "hazelcastFlushMode"))
 				.isEqualTo(HazelcastFlushMode.IMMEDIATE);
 	}
 
 	@Test
-	public void setCustomFlushImmediately() {
-		registerAndRefresh(BaseConfiguration.class,
-				CustomFlushImmediatelySetConfiguration.class);
+	void setCustomFlushImmediately() {
+		registerAndRefresh(BaseConfiguration.class, CustomFlushImmediatelySetConfiguration.class);
 
-		HazelcastSessionRepository repository = this.context
-				.getBean(HazelcastSessionRepository.class);
+		HazelcastSessionRepository repository = this.context.getBean(HazelcastSessionRepository.class);
 		assertThat(repository).isNotNull();
 		assertThat(ReflectionTestUtils.getField(repository, "hazelcastFlushMode"))
 				.isEqualTo(HazelcastFlushMode.IMMEDIATE);
 	}
 
 	@Test
-	public void qualifiedHazelcastInstanceConfiguration() {
+	void qualifiedHazelcastInstanceConfiguration() {
 		registerAndRefresh(QualifiedHazelcastInstanceConfiguration.class);
 
-		HazelcastSessionRepository repository = this.context
-				.getBean(HazelcastSessionRepository.class);
-		HazelcastInstance hazelcastInstance = this.context
-				.getBean("qualifiedHazelcastInstance", HazelcastInstance.class);
+		HazelcastSessionRepository repository = this.context.getBean(HazelcastSessionRepository.class);
+		HazelcastInstance hazelcastInstance = this.context.getBean("qualifiedHazelcastInstance",
+				HazelcastInstance.class);
 		assertThat(repository).isNotNull();
 		assertThat(hazelcastInstance).isNotNull();
-		assertThat(ReflectionTestUtils.getField(repository, "sessions")).isEqualTo(
-				QualifiedHazelcastInstanceConfiguration.qualifiedHazelcastInstanceSessions);
+		assertThat(ReflectionTestUtils.getField(repository, "sessions"))
+				.isEqualTo(QualifiedHazelcastInstanceConfiguration.qualifiedHazelcastInstanceSessions);
 	}
 
 	@Test
-	public void primaryHazelcastInstanceConfiguration() {
+	void primaryHazelcastInstanceConfiguration() {
 		registerAndRefresh(PrimaryHazelcastInstanceConfiguration.class);
 
-		HazelcastSessionRepository repository = this.context
-				.getBean(HazelcastSessionRepository.class);
-		HazelcastInstance hazelcastInstance = this.context
-				.getBean("primaryHazelcastInstance", HazelcastInstance.class);
+		HazelcastSessionRepository repository = this.context.getBean(HazelcastSessionRepository.class);
+		HazelcastInstance hazelcastInstance = this.context.getBean("primaryHazelcastInstance", HazelcastInstance.class);
 		assertThat(repository).isNotNull();
 		assertThat(hazelcastInstance).isNotNull();
-		assertThat(ReflectionTestUtils.getField(repository, "sessions")).isEqualTo(
-				PrimaryHazelcastInstanceConfiguration.primaryHazelcastInstanceSessions);
+		assertThat(ReflectionTestUtils.getField(repository, "sessions"))
+				.isEqualTo(PrimaryHazelcastInstanceConfiguration.primaryHazelcastInstanceSessions);
 	}
 
 	@Test
-	public void qualifiedAndPrimaryHazelcastInstanceConfiguration() {
+	void qualifiedAndPrimaryHazelcastInstanceConfiguration() {
 		registerAndRefresh(QualifiedAndPrimaryHazelcastInstanceConfiguration.class);
 
-		HazelcastSessionRepository repository = this.context
-				.getBean(HazelcastSessionRepository.class);
-		HazelcastInstance hazelcastInstance = this.context
-				.getBean("qualifiedHazelcastInstance", HazelcastInstance.class);
+		HazelcastSessionRepository repository = this.context.getBean(HazelcastSessionRepository.class);
+		HazelcastInstance hazelcastInstance = this.context.getBean("qualifiedHazelcastInstance",
+				HazelcastInstance.class);
 		assertThat(repository).isNotNull();
 		assertThat(hazelcastInstance).isNotNull();
-		assertThat(ReflectionTestUtils.getField(repository, "sessions")).isEqualTo(
-				QualifiedAndPrimaryHazelcastInstanceConfiguration.qualifiedHazelcastInstanceSessions);
+		assertThat(ReflectionTestUtils.getField(repository, "sessions"))
+				.isEqualTo(QualifiedAndPrimaryHazelcastInstanceConfiguration.qualifiedHazelcastInstanceSessions);
 	}
 
 	@Test
-	public void namedHazelcastInstanceConfiguration() {
+	void namedHazelcastInstanceConfiguration() {
 		registerAndRefresh(NamedHazelcastInstanceConfiguration.class);
 
-		HazelcastSessionRepository repository = this.context
-				.getBean(HazelcastSessionRepository.class);
-		HazelcastInstance hazelcastInstance = this.context.getBean("hazelcastInstance",
-				HazelcastInstance.class);
+		HazelcastSessionRepository repository = this.context.getBean(HazelcastSessionRepository.class);
+		HazelcastInstance hazelcastInstance = this.context.getBean("hazelcastInstance", HazelcastInstance.class);
 		assertThat(repository).isNotNull();
 		assertThat(hazelcastInstance).isNotNull();
 		assertThat(ReflectionTestUtils.getField(repository, "sessions"))
@@ -205,9 +185,9 @@ public class HazelcastHttpSessionConfigurationTests {
 	}
 
 	@Test
-	public void multipleHazelcastInstanceConfiguration() {
-		assertThatExceptionOfType(BeanCreationException.class).isThrownBy(
-				() -> registerAndRefresh(MultipleHazelcastInstanceConfiguration.class))
+	void multipleHazelcastInstanceConfiguration() {
+		assertThatExceptionOfType(BeanCreationException.class)
+				.isThrownBy(() -> registerAndRefresh(MultipleHazelcastInstanceConfiguration.class))
 				.withMessageContaining("expected single matching bean but found 2");
 	}
 
@@ -219,6 +199,7 @@ public class HazelcastHttpSessionConfigurationTests {
 	@Configuration
 	@EnableHazelcastHttpSession
 	static class NoHazelcastInstanceConfiguration {
+
 	}
 
 	static class BaseConfiguration {
@@ -229,8 +210,7 @@ public class HazelcastHttpSessionConfigurationTests {
 		@Bean
 		public HazelcastInstance defaultHazelcastInstance() {
 			HazelcastInstance hazelcastInstance = mock(HazelcastInstance.class);
-			given(hazelcastInstance.getMap(anyString()))
-					.willReturn(defaultHazelcastInstanceSessions);
+			given(hazelcastInstance.getMap(anyString())).willReturn(defaultHazelcastInstanceSessions);
 			return hazelcastInstance;
 		}
 
@@ -239,16 +219,17 @@ public class HazelcastHttpSessionConfigurationTests {
 	@Configuration
 	@EnableHazelcastHttpSession
 	static class DefaultConfiguration extends BaseConfiguration {
+
 	}
 
 	@Configuration
 	@EnableHazelcastHttpSession(sessionMapName = MAP_NAME)
 	static class CustomSessionMapNameConfiguration extends BaseConfiguration {
+
 	}
 
 	@Configuration
-	static class CustomSessionMapNameSetConfiguration
-			extends HazelcastHttpSessionConfiguration {
+	static class CustomSessionMapNameSetConfiguration extends HazelcastHttpSessionConfiguration {
 
 		CustomSessionMapNameSetConfiguration() {
 			setSessionMapName(MAP_NAME);
@@ -257,8 +238,7 @@ public class HazelcastHttpSessionConfigurationTests {
 	}
 
 	@Configuration
-	static class CustomMaxInactiveIntervalInSecondsSetConfiguration
-			extends HazelcastHttpSessionConfiguration {
+	static class CustomMaxInactiveIntervalInSecondsSetConfiguration extends HazelcastHttpSessionConfiguration {
 
 		CustomMaxInactiveIntervalInSecondsSetConfiguration() {
 			setMaxInactiveIntervalInSeconds(MAX_INACTIVE_INTERVAL_IN_SECONDS);
@@ -268,13 +248,12 @@ public class HazelcastHttpSessionConfigurationTests {
 
 	@Configuration
 	@EnableHazelcastHttpSession(maxInactiveIntervalInSeconds = MAX_INACTIVE_INTERVAL_IN_SECONDS)
-	static class CustomMaxInactiveIntervalInSecondsConfiguration
-			extends BaseConfiguration {
+	static class CustomMaxInactiveIntervalInSecondsConfiguration extends BaseConfiguration {
+
 	}
 
 	@Configuration
-	static class CustomFlushImmediatelySetConfiguration
-			extends HazelcastHttpSessionConfiguration {
+	static class CustomFlushImmediatelySetConfiguration extends HazelcastHttpSessionConfiguration {
 
 		CustomFlushImmediatelySetConfiguration() {
 			setHazelcastFlushMode(HAZELCAST_FLUSH_MODE);
@@ -285,6 +264,7 @@ public class HazelcastHttpSessionConfigurationTests {
 	@Configuration
 	@EnableHazelcastHttpSession(hazelcastFlushMode = HazelcastFlushMode.IMMEDIATE)
 	static class CustomFlushImmediatelyConfiguration extends BaseConfiguration {
+
 	}
 
 	@Configuration
@@ -298,8 +278,7 @@ public class HazelcastHttpSessionConfigurationTests {
 		@SpringSessionHazelcastInstance
 		public HazelcastInstance qualifiedHazelcastInstance() {
 			HazelcastInstance hazelcastInstance = mock(HazelcastInstance.class);
-			given(hazelcastInstance.getMap(anyString()))
-					.willReturn(qualifiedHazelcastInstanceSessions);
+			given(hazelcastInstance.getMap(anyString())).willReturn(qualifiedHazelcastInstanceSessions);
 			return hazelcastInstance;
 		}
 
@@ -316,8 +295,7 @@ public class HazelcastHttpSessionConfigurationTests {
 		@Primary
 		public HazelcastInstance primaryHazelcastInstance() {
 			HazelcastInstance hazelcastInstance = mock(HazelcastInstance.class);
-			given(hazelcastInstance.getMap(anyString()))
-					.willReturn(primaryHazelcastInstanceSessions);
+			given(hazelcastInstance.getMap(anyString())).willReturn(primaryHazelcastInstanceSessions);
 			return hazelcastInstance;
 		}
 
@@ -325,8 +303,7 @@ public class HazelcastHttpSessionConfigurationTests {
 
 	@Configuration
 	@EnableHazelcastHttpSession
-	static class QualifiedAndPrimaryHazelcastInstanceConfiguration
-			extends BaseConfiguration {
+	static class QualifiedAndPrimaryHazelcastInstanceConfiguration extends BaseConfiguration {
 
 		@SuppressWarnings("unchecked")
 		static IMap<Object, Object> qualifiedHazelcastInstanceSessions = mock(IMap.class);
@@ -338,8 +315,7 @@ public class HazelcastHttpSessionConfigurationTests {
 		@SpringSessionHazelcastInstance
 		public HazelcastInstance qualifiedHazelcastInstance() {
 			HazelcastInstance hazelcastInstance = mock(HazelcastInstance.class);
-			given(hazelcastInstance.getMap(anyString()))
-					.willReturn(qualifiedHazelcastInstanceSessions);
+			given(hazelcastInstance.getMap(anyString())).willReturn(qualifiedHazelcastInstanceSessions);
 			return hazelcastInstance;
 		}
 
@@ -347,8 +323,7 @@ public class HazelcastHttpSessionConfigurationTests {
 		@Primary
 		public HazelcastInstance primaryHazelcastInstance() {
 			HazelcastInstance hazelcastInstance = mock(HazelcastInstance.class);
-			given(hazelcastInstance.getMap(anyString()))
-					.willReturn(primaryHazelcastInstanceSessions);
+			given(hazelcastInstance.getMap(anyString())).willReturn(primaryHazelcastInstanceSessions);
 			return hazelcastInstance;
 		}
 
@@ -364,8 +339,7 @@ public class HazelcastHttpSessionConfigurationTests {
 		@Bean
 		public HazelcastInstance hazelcastInstance() {
 			HazelcastInstance hazelcastInstance = mock(HazelcastInstance.class);
-			given(hazelcastInstance.getMap(anyString()))
-					.willReturn(hazelcastInstanceSessions);
+			given(hazelcastInstance.getMap(anyString())).willReturn(hazelcastInstanceSessions);
 			return hazelcastInstance;
 		}
 
@@ -381,8 +355,7 @@ public class HazelcastHttpSessionConfigurationTests {
 		@Bean
 		public HazelcastInstance secondaryHazelcastInstance() {
 			HazelcastInstance hazelcastInstance = mock(HazelcastInstance.class);
-			given(hazelcastInstance.getMap(anyString()))
-					.willReturn(secondaryHazelcastInstanceSessions);
+			given(hazelcastInstance.getMap(anyString())).willReturn(secondaryHazelcastInstanceSessions);
 			return hazelcastInstance;
 		}