Merge branch '6.0.x'

# Conflicts:
#	spring-context/src/main/java/org/springframework/scheduling/concurrent/ExecutorConfigurationSupport.java

spring-beans/src/main/java/org/springframework/beans/factory/support/DefaultListableBeanFactory.java

@@ -979,7 +979,7 @@ public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFacto
 		for (String beanName : beanNames) {
 			Object singletonInstance = getSingleton(beanName);
 			if (singletonInstance instanceof SmartInitializingSingleton smartSingleton) {
-				StartupStep smartInitialize = this.getApplicationStartup().start("spring.beans.smart-initialize")
+				StartupStep smartInitialize = getApplicationStartup().start("spring.beans.smart-initialize")
 						.tag("beanName", beanName);
 				smartSingleton.afterSingletonsInstantiated();
 				smartInitialize.end();

spring-context/src/main/java/org/springframework/context/support/DefaultLifecycleProcessor.java

@@ -112,9 +112,10 @@ public class DefaultLifecycleProcessor implements LifecycleProcessor, BeanFactor
 
 
 	/**
-	 * Specify the maximum time allotted in milliseconds for the shutdown of
-	 * any phase (group of SmartLifecycle beans with the same 'phase' value).
-	 * <p>The default value is 30 seconds.
+	 * Specify the maximum time allotted in milliseconds for the shutdown of any
+	 * phase (group of {@link SmartLifecycle} beans with the same 'phase' value).
+	 * <p>The default value is 30000 milliseconds (30 seconds).
+	 * @see SmartLifecycle#getPhase()
 	 */
 	public void setTimeoutPerShutdownPhase(long timeoutPerShutdownPhase) {
 		this.timeoutPerShutdownPhase = timeoutPerShutdownPhase;

spring-jdbc/src/test/java/org/springframework/jdbc/datasource/DataSourceTransactionManagerTests.java

@@ -83,7 +83,7 @@ public class DataSourceTransactionManagerTests {
 
 	@AfterEach
 	public void verifyTransactionSynchronizationManagerState() {
-		assertThat(TransactionSynchronizationManager.getResourceMap().isEmpty()).isTrue();
+		assertThat(TransactionSynchronizationManager.getResourceMap()).isEmpty();
 		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
 		assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
 		assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
@@ -136,10 +136,8 @@ public class DataSourceTransactionManagerTests {
 		final DataSource dsToUse = (lazyConnection ? new LazyConnectionDataSourceProxy(ds) : ds);
 		tm = new DataSourceTransactionManager(dsToUse);
 		TransactionTemplate tt = new TransactionTemplate(tm);
-		boolean condition3 = !TransactionSynchronizationManager.hasResource(dsToUse);
-		assertThat(condition3).as("Hasn't thread connection").isTrue();
-		boolean condition2 = !TransactionSynchronizationManager.isSynchronizationActive();
-		assertThat(condition2).as("Synchronization not active").isTrue();
+		assertThat(TransactionSynchronizationManager.hasResource(dsToUse)).as("Hasn't thread connection").isFalse();
+		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isFalse();
 
 		tt.execute(new TransactionCallbackWithoutResult() {
 			@Override
@@ -165,10 +163,8 @@ public class DataSourceTransactionManagerTests {
 			}
 		});
 
-		boolean condition1 = !TransactionSynchronizationManager.hasResource(dsToUse);
-		assertThat(condition1).as("Hasn't thread connection").isTrue();
-		boolean condition = !TransactionSynchronizationManager.isSynchronizationActive();
-		assertThat(condition).as("Synchronization not active").isTrue();
+		assertThat(TransactionSynchronizationManager.hasResource(dsToUse)).as("Hasn't thread connection").isFalse();
+		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isFalse();
 
 		if (autoCommit && (!lazyConnection || createStatement)) {
 			InOrder ordered = inOrder(con);
@@ -229,10 +225,8 @@ public class DataSourceTransactionManagerTests {
 		final DataSource dsToUse = (lazyConnection ? new LazyConnectionDataSourceProxy(ds) : ds);
 		tm = new DataSourceTransactionManager(dsToUse);
 		TransactionTemplate tt = new TransactionTemplate(tm);
-		boolean condition3 = !TransactionSynchronizationManager.hasResource(dsToUse);
-		assertThat(condition3).as("Hasn't thread connection").isTrue();
-		boolean condition2 = !TransactionSynchronizationManager.isSynchronizationActive();
-		assertThat(condition2).as("Synchronization not active").isTrue();
+		assertThat(TransactionSynchronizationManager.hasResource(dsToUse)).as("Hasn't thread connection").isFalse();
+		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isFalse();
 
 		final RuntimeException ex = new RuntimeException("Application exception");
 		assertThatRuntimeException().isThrownBy(() ->
@@ -256,10 +250,8 @@ public class DataSourceTransactionManagerTests {
 				}))
 			.isEqualTo(ex);
 
-		boolean condition1 = !TransactionSynchronizationManager.hasResource(ds);
-		assertThat(condition1).as("Hasn't thread connection").isTrue();
-		boolean condition = !TransactionSynchronizationManager.isSynchronizationActive();
-		assertThat(condition).as("Synchronization not active").isTrue();
+		assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
+		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isFalse();
 
 		if (autoCommit && (!lazyConnection || createStatement)) {
 			InOrder ordered = inOrder(con);
@@ -279,10 +271,8 @@ public class DataSourceTransactionManagerTests {
 	public void testTransactionRollbackOnly() throws Exception {
 		tm.setTransactionSynchronization(DataSourceTransactionManager.SYNCHRONIZATION_NEVER);
 		TransactionTemplate tt = new TransactionTemplate(tm);
-		boolean condition2 = !TransactionSynchronizationManager.hasResource(ds);
-		assertThat(condition2).as("Hasn't thread connection").isTrue();
-		boolean condition1 = !TransactionSynchronizationManager.isSynchronizationActive();
-		assertThat(condition1).as("Synchronization not active").isTrue();
+		assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
+		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isFalse();
 
 		ConnectionHolder conHolder = new ConnectionHolder(con, true);
 		TransactionSynchronizationManager.bindResource(ds, conHolder);
@@ -292,10 +282,8 @@ public class DataSourceTransactionManagerTests {
 				@Override
 				protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException {
 					assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Has thread connection").isTrue();
-					boolean condition1 = !TransactionSynchronizationManager.isSynchronizationActive();
-					assertThat(condition1).as("Synchronization not active").isTrue();
-					boolean condition = !status.isNewTransaction();
-					assertThat(condition).as("Is existing transaction").isTrue();
+					assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isFalse();
+					assertThat(status.isNewTransaction()).as("Is existing transaction").isFalse();
 					throw ex;
 				}
 			});
@@ -303,16 +291,14 @@ public class DataSourceTransactionManagerTests {
 		}
 		catch (RuntimeException ex2) {
 			// expected
-			boolean condition = !TransactionSynchronizationManager.isSynchronizationActive();
-			assertThat(condition).as("Synchronization not active").isTrue();
+			assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isFalse();
 			assertThat(ex2).as("Correct exception thrown").isEqualTo(ex);
 		}
 		finally {
 			TransactionSynchronizationManager.unbindResource(ds);
 		}
 
-		boolean condition = !TransactionSynchronizationManager.hasResource(ds);
-		assertThat(condition).as("Hasn't thread connection").isTrue();
+		assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
 	}
 
 	@Test
@@ -330,10 +316,8 @@ public class DataSourceTransactionManagerTests {
 		if (failEarly) {
 			tm.setFailEarlyOnGlobalRollbackOnly(true);
 		}
-		boolean condition2 = !TransactionSynchronizationManager.hasResource(ds);
-		assertThat(condition2).as("Hasn't thread connection").isTrue();
-		boolean condition1 = !TransactionSynchronizationManager.isSynchronizationActive();
-		assertThat(condition1).as("Synchronization not active").isTrue();
+		assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
+		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isFalse();
 
 		TransactionStatus ts = tm.getTransaction(new DefaultTransactionDefinition());
 		TestTransactionSynchronization synch =
@@ -348,21 +332,18 @@ public class DataSourceTransactionManagerTests {
 			tt.execute(new TransactionCallbackWithoutResult() {
 				@Override
 				protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException {
-					boolean condition1 = !status.isNewTransaction();
-					assertThat(condition1).as("Is existing transaction").isTrue();
+					assertThat(status.isNewTransaction()).as("Is existing transaction").isFalse();
 					assertThat(status.isRollbackOnly()).as("Is not rollback-only").isFalse();
 					tt.execute(new TransactionCallbackWithoutResult() {
 						@Override
 						protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException {
 							assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Has thread connection").isTrue();
 							assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization active").isTrue();
-							boolean condition = !status.isNewTransaction();
-							assertThat(condition).as("Is existing transaction").isTrue();
+							assertThat(status.isNewTransaction()).as("Is existing transaction").isFalse();
 							status.setRollbackOnly();
 						}
 					});
-					boolean condition = !status.isNewTransaction();
-					assertThat(condition).as("Is existing transaction").isTrue();
+					assertThat(status.isNewTransaction()).as("Is existing transaction").isFalse();
 					assertThat(status.isRollbackOnly()).as("Is rollback-only").isTrue();
 				}
 			});
@@ -385,8 +366,7 @@ public class DataSourceTransactionManagerTests {
 			}
 		}
 
-		boolean condition = !TransactionSynchronizationManager.hasResource(ds);
-		assertThat(condition).as("Hasn't thread connection").isTrue();
+		assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
 		assertThat(synch.beforeCommitCalled).isFalse();
 		assertThat(synch.beforeCompletionCalled).isTrue();
 		assertThat(synch.afterCommitCalled).isFalse();
@@ -399,10 +379,8 @@ public class DataSourceTransactionManagerTests {
 	public void testParticipatingTransactionWithIncompatibleIsolationLevel() throws Exception {
 		tm.setValidateExistingTransaction(true);
 
-		boolean condition2 = !TransactionSynchronizationManager.hasResource(ds);
-		assertThat(condition2).as("Hasn't thread connection").isTrue();
-		boolean condition1 = !TransactionSynchronizationManager.isSynchronizationActive();
-		assertThat(condition1).as("Synchronization not active").isTrue();
+		assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
+		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isFalse();
 
 		assertThatExceptionOfType(IllegalTransactionStateException.class).isThrownBy(() -> {
 				final TransactionTemplate tt = new TransactionTemplate(tm);
@@ -424,8 +402,7 @@ public class DataSourceTransactionManagerTests {
 				});
 			});
 
-		boolean condition = !TransactionSynchronizationManager.hasResource(ds);
-		assertThat(condition).as("Hasn't thread connection").isTrue();
+		assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
 		verify(con).rollback();
 		verify(con).close();
 	}
@@ -435,10 +412,8 @@ public class DataSourceTransactionManagerTests {
 		willThrow(new SQLException("read-only not supported")).given(con).setReadOnly(true);
 		tm.setValidateExistingTransaction(true);
 
-		boolean condition2 = !TransactionSynchronizationManager.hasResource(ds);
-		assertThat(condition2).as("Hasn't thread connection").isTrue();
-		boolean condition1 = !TransactionSynchronizationManager.isSynchronizationActive();
-		assertThat(condition1).as("Synchronization not active").isTrue();
+		assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
+		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isFalse();
 
 		assertThatExceptionOfType(IllegalTransactionStateException.class).isThrownBy(() -> {
 			final TransactionTemplate tt = new TransactionTemplate(tm);
@@ -461,18 +436,15 @@ public class DataSourceTransactionManagerTests {
 			});
 		});
 
-		boolean condition = !TransactionSynchronizationManager.hasResource(ds);
-		assertThat(condition).as("Hasn't thread connection").isTrue();
+		assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
 		verify(con).rollback();
 		verify(con).close();
 	}
 
 	@Test
 	public void testParticipatingTransactionWithTransactionStartedFromSynch() throws Exception {
-		boolean condition2 = !TransactionSynchronizationManager.hasResource(ds);
-		assertThat(condition2).as("Hasn't thread connection").isTrue();
-		boolean condition1 = !TransactionSynchronizationManager.isSynchronizationActive();
-		assertThat(condition1).as("Synchronization not active").isTrue();
+		assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
+		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isFalse();
 
 		final TransactionTemplate tt = new TransactionTemplate(tm);
 		tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
@@ -498,14 +470,12 @@ public class DataSourceTransactionManagerTests {
 			}
 		});
 
-		boolean condition = !TransactionSynchronizationManager.hasResource(ds);
-		assertThat(condition).as("Hasn't thread connection").isTrue();
+		assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
 		assertThat(synch.beforeCommitCalled).isTrue();
 		assertThat(synch.beforeCompletionCalled).isTrue();
 		assertThat(synch.afterCommitCalled).isTrue();
 		assertThat(synch.afterCompletionCalled).isTrue();
-		boolean condition3 = synch.afterCompletionException instanceof IllegalStateException;
-		assertThat(condition3).isTrue();
+		assertThat(synch.afterCompletionException).isInstanceOf(IllegalStateException.class);
 		verify(con, times(2)).commit();
 		verify(con, times(2)).close();
 	}
@@ -516,10 +486,8 @@ public class DataSourceTransactionManagerTests {
 		final Connection con2 = mock();
 		given(ds2.getConnection()).willReturn(con2);
 
-		boolean condition2 = !TransactionSynchronizationManager.hasResource(ds);
-		assertThat(condition2).as("Hasn't thread connection").isTrue();
-		boolean condition1 = !TransactionSynchronizationManager.isSynchronizationActive();
-		assertThat(condition1).as("Synchronization not active").isTrue();
+		assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
+		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isFalse();
 
 		final TransactionTemplate tt = new TransactionTemplate(tm);
 
@@ -540,8 +508,7 @@ public class DataSourceTransactionManagerTests {
 			}
 		});
 
-		boolean condition = !TransactionSynchronizationManager.hasResource(ds);
-		assertThat(condition).as("Hasn't thread connection").isTrue();
+		assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
 		assertThat(synch.beforeCommitCalled).isTrue();
 		assertThat(synch.beforeCompletionCalled).isTrue();
 		assertThat(synch.afterCommitCalled).isTrue();
@@ -558,10 +525,8 @@ public class DataSourceTransactionManagerTests {
 		DataSourceTransactionManager tm2 = new DataSourceTransactionManager(ds);
 		// tm has no synch enabled (used at outer level), tm2 has synch enabled (inner level)
 
-		boolean condition2 = !TransactionSynchronizationManager.hasResource(ds);
-		assertThat(condition2).as("Hasn't thread connection").isTrue();
-		boolean condition1 = !TransactionSynchronizationManager.isSynchronizationActive();
-		assertThat(condition1).as("Synchronization not active").isTrue();
+		assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
+		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isFalse();
 
 		TransactionStatus ts = tm.getTransaction(new DefaultTransactionDefinition());
 		final TestTransactionSynchronization synch =
@@ -573,21 +538,18 @@ public class DataSourceTransactionManagerTests {
 			tt.execute(new TransactionCallbackWithoutResult() {
 				@Override
 				protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException {
-					boolean condition1 = !status.isNewTransaction();
-					assertThat(condition1).as("Is existing transaction").isTrue();
+					assertThat(status.isNewTransaction()).as("Is existing transaction").isFalse();
 					assertThat(status.isRollbackOnly()).as("Is not rollback-only").isFalse();
 					tt.execute(new TransactionCallbackWithoutResult() {
 						@Override
 						protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException {
 							assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Has thread connection").isTrue();
 							assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization active").isTrue();
-							boolean condition = !status.isNewTransaction();
-							assertThat(condition).as("Is existing transaction").isTrue();
+							assertThat(status.isNewTransaction()).as("Is existing transaction").isFalse();
 							status.setRollbackOnly();
 						}
 					});
-					boolean condition = !status.isNewTransaction();
-					assertThat(condition).as("Is existing transaction").isTrue();
+					assertThat(status.isNewTransaction()).as("Is existing transaction").isFalse();
 					assertThat(status.isRollbackOnly()).as("Is rollback-only").isTrue();
 					TransactionSynchronizationManager.registerSynchronization(synch);
 				}
@@ -596,8 +558,7 @@ public class DataSourceTransactionManagerTests {
 			tm.commit(ts);
 		});
 
-		boolean condition = !TransactionSynchronizationManager.hasResource(ds);
-		assertThat(condition).as("Hasn't thread connection").isTrue();
+		assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
 		assertThat(synch.beforeCommitCalled).isFalse();
 		assertThat(synch.beforeCompletionCalled).isTrue();
 		assertThat(synch.afterCommitCalled).isFalse();
@@ -610,10 +571,8 @@ public class DataSourceTransactionManagerTests {
 	public void testPropagationRequiresNewWithExistingTransaction() throws Exception {
 		final TransactionTemplate tt = new TransactionTemplate(tm);
 		tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
-		boolean condition2 = !TransactionSynchronizationManager.hasResource(ds);
-		assertThat(condition2).as("Hasn't thread connection").isTrue();
-		boolean condition1 = !TransactionSynchronizationManager.isSynchronizationActive();
-		assertThat(condition1).as("Synchronization not active").isTrue();
+		assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
+		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isFalse();
 
 		tt.execute(new TransactionCallbackWithoutResult() {
 			@Override
@@ -639,8 +598,7 @@ public class DataSourceTransactionManagerTests {
 			}
 		});
 
-		boolean condition = !TransactionSynchronizationManager.hasResource(ds);
-		assertThat(condition).as("Hasn't thread connection").isTrue();
+		assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
 		verify(con).rollback();
 		verify(con).commit();
 		verify(con, times(2)).close();
@@ -659,12 +617,9 @@ public class DataSourceTransactionManagerTests {
 		final TransactionTemplate tt2 = new TransactionTemplate(tm2);
 		tt2.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
 
-		boolean condition4 = !TransactionSynchronizationManager.hasResource(ds);
-		assertThat(condition4).as("Hasn't thread connection").isTrue();
-		boolean condition3 = !TransactionSynchronizationManager.hasResource(ds2);
-		assertThat(condition3).as("Hasn't thread connection").isTrue();
-		boolean condition2 = !TransactionSynchronizationManager.isSynchronizationActive();
-		assertThat(condition2).as("Synchronization not active").isTrue();
+		assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
+		assertThat(TransactionSynchronizationManager.hasResource(ds2)).as("Hasn't thread connection").isFalse();
+		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isFalse();
 
 		tt.execute(new TransactionCallbackWithoutResult() {
 			@Override
@@ -690,10 +645,8 @@ public class DataSourceTransactionManagerTests {
 			}
 		});
 
-		boolean condition1 = !TransactionSynchronizationManager.hasResource(ds);
-		assertThat(condition1).as("Hasn't thread connection").isTrue();
-		boolean condition = !TransactionSynchronizationManager.hasResource(ds2);
-		assertThat(condition).as("Hasn't thread connection").isTrue();
+		assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
+		assertThat(TransactionSynchronizationManager.hasResource(ds2)).as("Hasn't thread connection").isFalse();
 		verify(con).commit();
 		verify(con).close();
 		verify(con2).rollback();
@@ -714,12 +667,9 @@ public class DataSourceTransactionManagerTests {
 		final TransactionTemplate tt2 = new TransactionTemplate(tm2);
 		tt2.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
 
-		boolean condition4 = !TransactionSynchronizationManager.hasResource(ds);
-		assertThat(condition4).as("Hasn't thread connection").isTrue();
-		boolean condition3 = !TransactionSynchronizationManager.hasResource(ds2);
-		assertThat(condition3).as("Hasn't thread connection").isTrue();
-		boolean condition2 = !TransactionSynchronizationManager.isSynchronizationActive();
-		assertThat(condition2).as("Synchronization not active").isTrue();
+		assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
+		assertThat(TransactionSynchronizationManager.hasResource(ds2)).as("Hasn't thread connection").isFalse();
+		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isFalse();
 
 		assertThatExceptionOfType(CannotCreateTransactionException.class).isThrownBy(() ->
 			tt.execute(new TransactionCallbackWithoutResult() {
@@ -738,10 +688,8 @@ public class DataSourceTransactionManagerTests {
 				}
 			})).withCause(failure);
 
-		boolean condition1 = !TransactionSynchronizationManager.hasResource(ds);
-		assertThat(condition1).as("Hasn't thread connection").isTrue();
-		boolean condition = !TransactionSynchronizationManager.hasResource(ds2);
-		assertThat(condition).as("Hasn't thread connection").isTrue();
+		assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
+		assertThat(TransactionSynchronizationManager.hasResource(ds2)).as("Hasn't thread connection").isFalse();
 		verify(con).rollback();
 		verify(con).close();
 	}
@@ -750,10 +698,8 @@ public class DataSourceTransactionManagerTests {
 	public void testPropagationNotSupportedWithExistingTransaction() throws Exception {
 		final TransactionTemplate tt = new TransactionTemplate(tm);
 		tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
-		boolean condition2 = !TransactionSynchronizationManager.hasResource(ds);
-		assertThat(condition2).as("Hasn't thread connection").isTrue();
-		boolean condition1 = !TransactionSynchronizationManager.isSynchronizationActive();
-		assertThat(condition1).as("Synchronization not active").isTrue();
+		assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
+		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isFalse();
 
 		tt.execute(new TransactionCallbackWithoutResult() {
 			@Override
@@ -765,11 +711,9 @@ public class DataSourceTransactionManagerTests {
 				tt.execute(new TransactionCallbackWithoutResult() {
 					@Override
 					protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException {
-						boolean condition1 = !TransactionSynchronizationManager.hasResource(ds);
-						assertThat(condition1).as("Hasn't thread connection").isTrue();
+						assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
 						assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization active").isTrue();
-						boolean condition = !status.isNewTransaction();
-						assertThat(condition).as("Isn't new transaction").isTrue();
+						assertThat(status.isNewTransaction()).as("Isn't new transaction").isFalse();
 						assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
 						assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
 						status.setRollbackOnly();
@@ -781,8 +725,7 @@ public class DataSourceTransactionManagerTests {
 			}
 		});
 
-		boolean condition = !TransactionSynchronizationManager.hasResource(ds);
-		assertThat(condition).as("Hasn't thread connection").isTrue();
+		assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
 		verify(con).commit();
 		verify(con).close();
 	}
@@ -791,10 +734,8 @@ public class DataSourceTransactionManagerTests {
 	public void testPropagationNeverWithExistingTransaction() throws Exception {
 		final TransactionTemplate tt = new TransactionTemplate(tm);
 		tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
-		boolean condition2 = !TransactionSynchronizationManager.hasResource(ds);
-		assertThat(condition2).as("Hasn't thread connection").isTrue();
-		boolean condition1 = !TransactionSynchronizationManager.isSynchronizationActive();
-		assertThat(condition1).as("Synchronization not active").isTrue();
+		assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
+		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isFalse();
 
 		assertThatExceptionOfType(IllegalTransactionStateException.class).isThrownBy(() ->
 			tt.execute(new TransactionCallbackWithoutResult() {
@@ -812,8 +753,7 @@ public class DataSourceTransactionManagerTests {
 				}
 			}));
 
-		boolean condition = !TransactionSynchronizationManager.hasResource(ds);
-		assertThat(condition).as("Hasn't thread connection").isTrue();
+		assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
 		verify(con).rollback();
 		verify(con).close();
 	}
@@ -822,10 +762,8 @@ public class DataSourceTransactionManagerTests {
 	public void testPropagationSupportsAndRequiresNew() throws Exception {
 		TransactionTemplate tt = new TransactionTemplate(tm);
 		tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_SUPPORTS);
-		boolean condition2 = !TransactionSynchronizationManager.hasResource(ds);
-		assertThat(condition2).as("Hasn't thread connection").isTrue();
-		boolean condition1 = !TransactionSynchronizationManager.isSynchronizationActive();
-		assertThat(condition1).as("Synchronization not active").isTrue();
+		assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
+		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isFalse();
 
 		tt.execute(new TransactionCallbackWithoutResult() {
 			@Override
@@ -846,8 +784,7 @@ public class DataSourceTransactionManagerTests {
 			}
 		});
 
-		boolean condition = !TransactionSynchronizationManager.hasResource(ds);
-		assertThat(condition).as("Hasn't thread connection").isTrue();
+		assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
 		verify(con).commit();
 		verify(con).close();
 	}
@@ -861,10 +798,8 @@ public class DataSourceTransactionManagerTests {
 		final
 		TransactionTemplate tt = new TransactionTemplate(tm);
 		tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_SUPPORTS);
-		boolean condition2 = !TransactionSynchronizationManager.hasResource(ds);
-		assertThat(condition2).as("Hasn't thread connection").isTrue();
-		boolean condition1 = !TransactionSynchronizationManager.isSynchronizationActive();
-		assertThat(condition1).as("Synchronization not active").isTrue();
+		assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
+		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isFalse();
 
 		tt.execute(new TransactionCallbackWithoutResult() {
 			@Override
@@ -888,8 +823,7 @@ public class DataSourceTransactionManagerTests {
 			}
 		});
 
-		boolean condition = !TransactionSynchronizationManager.hasResource(ds);
-		assertThat(condition).as("Hasn't thread connection").isTrue();
+		assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
 		verify(con1).close();
 		verify(con2).commit();
 		verify(con2).close();
@@ -904,8 +838,7 @@ public class DataSourceTransactionManagerTests {
 		tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
 		tt.setIsolationLevel(TransactionDefinition.ISOLATION_SERIALIZABLE);
 		tt.setReadOnly(true);
-		boolean condition1 = !TransactionSynchronizationManager.hasResource(ds);
-		assertThat(condition1).as("Hasn't thread connection").isTrue();
+		assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
 		tt.execute(new TransactionCallbackWithoutResult() {
 			@Override
 			protected void doInTransactionWithoutResult(TransactionStatus status) {
@@ -915,8 +848,7 @@ public class DataSourceTransactionManagerTests {
 			}
 		});
 
-		boolean condition = !TransactionSynchronizationManager.hasResource(ds);
-		assertThat(condition).as("Hasn't thread connection").isTrue();
+		assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
 		InOrder ordered = inOrder(con);
 		ordered.verify(con).setReadOnly(true);
 		ordered.verify(con).setTransactionIsolation(Connection.TRANSACTION_SERIALIZABLE);
@@ -939,8 +871,7 @@ public class DataSourceTransactionManagerTests {
 		TransactionTemplate tt = new TransactionTemplate(tm);
 		tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
 		tt.setReadOnly(true);
-		boolean condition1 = !TransactionSynchronizationManager.hasResource(ds);
-		assertThat(condition1).as("Hasn't thread connection").isTrue();
+		assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
 		tt.execute(new TransactionCallbackWithoutResult() {
 			@Override
 			protected void doInTransactionWithoutResult(TransactionStatus status) {
@@ -950,8 +881,7 @@ public class DataSourceTransactionManagerTests {
 			}
 		});
 
-		boolean condition = !TransactionSynchronizationManager.hasResource(ds);
-		assertThat(condition).as("Hasn't thread connection").isTrue();
+		assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
 		InOrder ordered = inOrder(con, stmt);
 		ordered.verify(con).setReadOnly(true);
 		ordered.verify(con).setAutoCommit(false);
@@ -973,8 +903,7 @@ public class DataSourceTransactionManagerTests {
 
 		TransactionTemplate tt = new TransactionTemplate(tm);
 		tt.setTimeout(timeout);
-		boolean condition1 = !TransactionSynchronizationManager.hasResource(ds);
-		assertThat(condition1).as("Hasn't thread connection").isTrue();
+		assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
 
 		try {
 			tt.execute(new TransactionCallbackWithoutResult() {
@@ -1008,8 +937,7 @@ public class DataSourceTransactionManagerTests {
 			}
 		}
 
-		boolean condition = !TransactionSynchronizationManager.hasResource(ds);
-		assertThat(condition).as("Hasn't thread connection").isTrue();
+		assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
 		if (timeout > 1) {
 			verify(ps).setQueryTimeout(timeout - 1);
 			verify(con).commit();
@@ -1029,8 +957,7 @@ public class DataSourceTransactionManagerTests {
 		given(con.getWarnings()).willThrow(new SQLException());
 
 		TransactionTemplate tt = new TransactionTemplate(tm);
-		boolean condition1 = !TransactionSynchronizationManager.hasResource(ds);
-		assertThat(condition1).as("Hasn't thread connection").isTrue();
+		assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
 		tt.execute(new TransactionCallbackWithoutResult() {
 			@Override
 			protected void doInTransactionWithoutResult(TransactionStatus status) {
@@ -1051,8 +978,7 @@ public class DataSourceTransactionManagerTests {
 			}
 		});
 
-		boolean condition = !TransactionSynchronizationManager.hasResource(ds);
-		assertThat(condition).as("Hasn't thread connection").isTrue();
+		assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
 		InOrder ordered = inOrder(con);
 		ordered.verify(con).setAutoCommit(false);
 		ordered.verify(con).commit();
@@ -1066,8 +992,7 @@ public class DataSourceTransactionManagerTests {
 
 		final TransactionTemplate tt = new TransactionTemplate(tm);
 		tt.setPropagationBehavior(TransactionTemplate.PROPAGATION_REQUIRES_NEW);
-		boolean condition1 = !TransactionSynchronizationManager.hasResource(ds);
-		assertThat(condition1).as("Hasn't thread connection").isTrue();
+		assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
 
 		tt.execute(new TransactionCallbackWithoutResult() {
 			@Override
@@ -1111,8 +1036,7 @@ public class DataSourceTransactionManagerTests {
 			}
 		});
 
-		boolean condition = !TransactionSynchronizationManager.hasResource(ds);
-		assertThat(condition).as("Hasn't thread connection").isTrue();
+		assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
 		InOrder ordered = inOrder(con);
 		ordered.verify(con).setAutoCommit(false);
 		ordered.verify(con).commit();
@@ -1126,8 +1050,7 @@ public class DataSourceTransactionManagerTests {
 
 		final TransactionTemplate tt = new TransactionTemplate(tm);
 		tt.setPropagationBehavior(TransactionTemplate.PROPAGATION_REQUIRES_NEW);
-		boolean condition1 = !TransactionSynchronizationManager.hasResource(ds);
-		assertThat(condition1).as("Hasn't thread connection").isTrue();
+		assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
 
 		tt.execute(new TransactionCallbackWithoutResult() {
 			@Override
@@ -1172,8 +1095,7 @@ public class DataSourceTransactionManagerTests {
 			}
 		});
 
-		boolean condition = !TransactionSynchronizationManager.hasResource(ds);
-		assertThat(condition).as("Hasn't thread connection").isTrue();
+		assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
 		InOrder ordered = inOrder(con);
 		ordered.verify(con).setAutoCommit(false);
 		ordered.verify(con).commit();
@@ -1197,8 +1119,7 @@ public class DataSourceTransactionManagerTests {
 				}
 			}));
 
-		boolean condition = !TransactionSynchronizationManager.hasResource(ds);
-		assertThat(condition).as("Hasn't thread connection").isTrue();
+		assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
 		verify(con).close();
 	}
 
@@ -1215,8 +1136,7 @@ public class DataSourceTransactionManagerTests {
 				}
 			}));
 
-		boolean condition = !TransactionSynchronizationManager.hasResource(ds);
-		assertThat(condition).as("Hasn't thread connection").isTrue();
+		assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
 		verify(con).close();
 	}
 
@@ -1234,8 +1154,7 @@ public class DataSourceTransactionManagerTests {
 				}
 			}));
 
-		boolean condition = !TransactionSynchronizationManager.hasResource(ds);
-		assertThat(condition).as("Hasn't thread connection").isTrue();
+		assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
 		verify(con).rollback();
 		verify(con).close();
 	}
@@ -1254,8 +1173,7 @@ public class DataSourceTransactionManagerTests {
 				}
 			}));
 
-		boolean condition = !TransactionSynchronizationManager.hasResource(ds);
-		assertThat(condition).as("Hasn't thread connection").isTrue();
+		assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
 		InOrder ordered = inOrder(con);
 		ordered.verify(con).setAutoCommit(false);
 		ordered.verify(con).rollback();
@@ -1267,65 +1185,53 @@ public class DataSourceTransactionManagerTests {
 	public void testTransactionWithPropagationSupports() throws Exception {
 		TransactionTemplate tt = new TransactionTemplate(tm);
 		tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_SUPPORTS);
-		boolean condition1 = !TransactionSynchronizationManager.hasResource(ds);
-		assertThat(condition1).as("Hasn't thread connection").isTrue();
+		assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
 
 		tt.execute(new TransactionCallbackWithoutResult() {
 			@Override
 			protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException {
-				boolean condition1 = !TransactionSynchronizationManager.hasResource(ds);
-				assertThat(condition1).as("Hasn't thread connection").isTrue();
-				boolean condition = !status.isNewTransaction();
-				assertThat(condition).as("Is not new transaction").isTrue();
+				assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
+				assertThat(status.isNewTransaction()).as("Is not new transaction").isFalse();
 				assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
 				assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
 			}
 		});
 
-		boolean condition = !TransactionSynchronizationManager.hasResource(ds);
-		assertThat(condition).as("Hasn't thread connection").isTrue();
+		assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
 	}
 
 	@Test
 	public void testTransactionWithPropagationNotSupported() throws Exception {
 		TransactionTemplate tt = new TransactionTemplate(tm);
 		tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_NOT_SUPPORTED);
-		boolean condition1 = !TransactionSynchronizationManager.hasResource(ds);
-		assertThat(condition1).as("Hasn't thread connection").isTrue();
+		assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
 
 		tt.execute(new TransactionCallbackWithoutResult() {
 			@Override
 			protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException {
-				boolean condition1 = !TransactionSynchronizationManager.hasResource(ds);
-				assertThat(condition1).as("Hasn't thread connection").isTrue();
-				boolean condition = !status.isNewTransaction();
-				assertThat(condition).as("Is not new transaction").isTrue();
+				assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
+				assertThat(status.isNewTransaction()).as("Is not new transaction").isFalse();
 			}
 		});
 
-		boolean condition = !TransactionSynchronizationManager.hasResource(ds);
-		assertThat(condition).as("Hasn't thread connection").isTrue();
+		assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
 	}
 
 	@Test
 	public void testTransactionWithPropagationNever() throws Exception {
 		TransactionTemplate tt = new TransactionTemplate(tm);
 		tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_NEVER);
-		boolean condition1 = !TransactionSynchronizationManager.hasResource(ds);
-		assertThat(condition1).as("Hasn't thread connection").isTrue();
+		assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
 
 		tt.execute(new TransactionCallbackWithoutResult() {
 			@Override
 			protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException {
-				boolean condition1 = !TransactionSynchronizationManager.hasResource(ds);
-				assertThat(condition1).as("Hasn't thread connection").isTrue();
-				boolean condition = !status.isNewTransaction();
-				assertThat(condition).as("Is not new transaction").isTrue();
+				assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
+				assertThat(status.isNewTransaction()).as("Is not new transaction").isFalse();
 			}
 		});
 
-		boolean condition = !TransactionSynchronizationManager.hasResource(ds);
-		assertThat(condition).as("Hasn't thread connection").isTrue();
+		assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
 	}
 
 	@Test
@@ -1350,37 +1256,32 @@ public class DataSourceTransactionManagerTests {
 
 		final TransactionTemplate tt = new TransactionTemplate(tm);
 		tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_NESTED);
-		boolean condition2 = !TransactionSynchronizationManager.hasResource(ds);
-		assertThat(condition2).as("Hasn't thread connection").isTrue();
-		boolean condition1 = !TransactionSynchronizationManager.isSynchronizationActive();
-		assertThat(condition1).as("Synchronization not active").isTrue();
+		assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
+		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active")
+				.isFalse();
 
 		tt.execute(new TransactionCallbackWithoutResult() {
 			@Override
 			protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException {
 				assertThat(status.isNewTransaction()).as("Is new transaction").isTrue();
-				boolean condition1 = !status.hasSavepoint();
-				assertThat(condition1).as("Isn't nested transaction").isTrue();
+				assertThat(status.hasSavepoint()).as("Isn't nested transaction").isFalse();
 				for (int i = 0; i < count; i++) {
 					tt.execute(new TransactionCallbackWithoutResult() {
 						@Override
 						protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException {
 							assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Has thread connection").isTrue();
 							assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization active").isTrue();
-							boolean condition = !status.isNewTransaction();
-							assertThat(condition).as("Isn't new transaction").isTrue();
+							assertThat(status.isNewTransaction()).as("Isn't new transaction").isFalse();
 							assertThat(status.hasSavepoint()).as("Is nested transaction").isTrue();
 						}
 					});
 				}
 				assertThat(status.isNewTransaction()).as("Is new transaction").isTrue();
-				boolean condition = !status.hasSavepoint();
-				assertThat(condition).as("Isn't nested transaction").isTrue();
+				assertThat(status.hasSavepoint()).as("Isn't nested transaction").isFalse();
 			}
 		});
 
-		boolean condition = !TransactionSynchronizationManager.hasResource(ds);
-		assertThat(condition).as("Hasn't thread connection").isTrue();
+		assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
 		verify(con, times(count)).releaseSavepoint(sp);
 		verify(con).commit();
 		verify(con).close();
@@ -1397,36 +1298,31 @@ public class DataSourceTransactionManagerTests {
 
 		final TransactionTemplate tt = new TransactionTemplate(tm);
 		tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_NESTED);
-		boolean condition2 = !TransactionSynchronizationManager.hasResource(ds);
-		assertThat(condition2).as("Hasn't thread connection").isTrue();
-		boolean condition1 = !TransactionSynchronizationManager.isSynchronizationActive();
-		assertThat(condition1).as("Synchronization not active").isTrue();
+		assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
+		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active")
+				.isFalse();
 
 		tt.execute(new TransactionCallbackWithoutResult() {
 			@Override
 			protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException {
 				assertThat(status.isNewTransaction()).as("Is new transaction").isTrue();
-				boolean condition1 = !status.hasSavepoint();
-				assertThat(condition1).as("Isn't nested transaction").isTrue();
+				assertThat(status.hasSavepoint()).as("Isn't nested transaction").isFalse();
 				tt.execute(new TransactionCallbackWithoutResult() {
 					@Override
 					protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException {
 						assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Has thread connection").isTrue();
 						assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization active").isTrue();
-						boolean condition = !status.isNewTransaction();
-						assertThat(condition).as("Isn't new transaction").isTrue();
+						assertThat(status.isNewTransaction()).as("Isn't new transaction").isFalse();
 						assertThat(status.hasSavepoint()).as("Is nested transaction").isTrue();
 						status.setRollbackOnly();
 					}
 				});
 				assertThat(status.isNewTransaction()).as("Is new transaction").isTrue();
-				boolean condition = !status.hasSavepoint();
-				assertThat(condition).as("Isn't nested transaction").isTrue();
+				assertThat(status.hasSavepoint()).as("Isn't nested transaction").isFalse();
 			}
 		});
 
-		boolean condition = !TransactionSynchronizationManager.hasResource(ds);
-		assertThat(condition).as("Hasn't thread connection").isTrue();
+		assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
 		verify(con).rollback(sp);
 		verify(con).releaseSavepoint(sp);
 		verify(con).commit();
@@ -1444,25 +1340,22 @@ public class DataSourceTransactionManagerTests {
 
 		final TransactionTemplate tt = new TransactionTemplate(tm);
 		tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_NESTED);
-		boolean condition2 = !TransactionSynchronizationManager.hasResource(ds);
-		assertThat(condition2).as("Hasn't thread connection").isTrue();
-		boolean condition1 = !TransactionSynchronizationManager.isSynchronizationActive();
-		assertThat(condition1).as("Synchronization not active").isTrue();
+		assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
+		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active")
+				.isFalse();
 
 		tt.execute(new TransactionCallbackWithoutResult() {
 			@Override
 			protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException {
 				assertThat(status.isNewTransaction()).as("Is new transaction").isTrue();
-				boolean condition1 = !status.hasSavepoint();
-				assertThat(condition1).as("Isn't nested transaction").isTrue();
+				assertThat(status.hasSavepoint()).as("Isn't nested transaction").isFalse();
 				assertThatIllegalStateException().isThrownBy(() ->
 					tt.execute(new TransactionCallbackWithoutResult() {
 						@Override
 						protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException {
 							assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Has thread connection").isTrue();
 							assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization active").isTrue();
-							boolean condition = !status.isNewTransaction();
-							assertThat(condition).as("Isn't new transaction").isTrue();
+							assertThat(status.isNewTransaction()).as("Isn't new transaction").isFalse();
 							assertThat(status.hasSavepoint()).as("Is nested transaction").isTrue();
 							TransactionTemplate ntt = new TransactionTemplate(tm);
 							ntt.execute(new TransactionCallbackWithoutResult() {
@@ -1470,23 +1363,19 @@ public class DataSourceTransactionManagerTests {
 								protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException {
 									assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Has thread connection").isTrue();
 									assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization active").isTrue();
-									boolean condition1 = !status.isNewTransaction();
-									assertThat(condition1).as("Isn't new transaction").isTrue();
-									boolean condition = !status.hasSavepoint();
-									assertThat(condition).as("Is regular transaction").isTrue();
+									assertThat(status.isNewTransaction()).as("Isn't new transaction").isFalse();
+									assertThat(status.hasSavepoint()).as("Is regular transaction").isFalse();
 									throw new IllegalStateException();
 								}
 							});
 						}
 					}));
 				assertThat(status.isNewTransaction()).as("Is new transaction").isTrue();
-				boolean condition = !status.hasSavepoint();
-				assertThat(condition).as("Isn't nested transaction").isTrue();
+				assertThat(status.hasSavepoint()).as("Isn't nested transaction").isFalse();
 			}
 		});
 
-		boolean condition = !TransactionSynchronizationManager.hasResource(ds);
-		assertThat(condition).as("Hasn't thread connection").isTrue();
+		assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
 		verify(con).rollback(sp);
 		verify(con).releaseSavepoint(sp);
 		verify(con).commit();
@@ -1504,25 +1393,22 @@ public class DataSourceTransactionManagerTests {
 
 		final TransactionTemplate tt = new TransactionTemplate(tm);
 		tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_NESTED);
-		boolean condition2 = !TransactionSynchronizationManager.hasResource(ds);
-		assertThat(condition2).as("Hasn't thread connection").isTrue();
-		boolean condition1 = !TransactionSynchronizationManager.isSynchronizationActive();
-		assertThat(condition1).as("Synchronization not active").isTrue();
+		assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
+		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active")
+				.isFalse();
 
 		tt.execute(new TransactionCallbackWithoutResult() {
 			@Override
 			protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException {
 				assertThat(status.isNewTransaction()).as("Is new transaction").isTrue();
-				boolean condition1 = !status.hasSavepoint();
-				assertThat(condition1).as("Isn't nested transaction").isTrue();
+				assertThat(status.hasSavepoint()).as("Isn't nested transaction").isFalse();
 				assertThatExceptionOfType(UnexpectedRollbackException.class).isThrownBy(() ->
 					tt.execute(new TransactionCallbackWithoutResult() {
 						@Override
 						protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException {
 							assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Has thread connection").isTrue();
 							assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization active").isTrue();
-							boolean condition = !status.isNewTransaction();
-							assertThat(condition).as("Isn't new transaction").isTrue();
+							assertThat(status.isNewTransaction()).as("Isn't new transaction").isFalse();
 							assertThat(status.hasSavepoint()).as("Is nested transaction").isTrue();
 							TransactionTemplate ntt = new TransactionTemplate(tm);
 							ntt.execute(new TransactionCallbackWithoutResult() {
@@ -1530,23 +1416,19 @@ public class DataSourceTransactionManagerTests {
 								protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException {
 									assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Has thread connection").isTrue();
 									assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization active").isTrue();
-									boolean condition1 = !status.isNewTransaction();
-									assertThat(condition1).as("Isn't new transaction").isTrue();
-									boolean condition = !status.hasSavepoint();
-									assertThat(condition).as("Is regular transaction").isTrue();
+									assertThat(status.isNewTransaction()).as("Isn't new transaction").isFalse();
+									assertThat(status.hasSavepoint()).as("Is regular transaction").isFalse();
 									status.setRollbackOnly();
 								}
 							});
 						}
 					}));
 				assertThat(status.isNewTransaction()).as("Is new transaction").isTrue();
-				boolean condition = !status.hasSavepoint();
-				assertThat(condition).as("Isn't nested transaction").isTrue();
+				assertThat(status.hasSavepoint()).as("Isn't nested transaction").isFalse();
 			}
 		});
 
-		boolean condition = !TransactionSynchronizationManager.hasResource(ds);
-		assertThat(condition).as("Hasn't thread connection").isTrue();
+		assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
 		verify(con).rollback(sp);
 		verify(con).releaseSavepoint(sp);
 		verify(con).commit();
@@ -1564,10 +1446,9 @@ public class DataSourceTransactionManagerTests {
 
 		final TransactionTemplate tt = new TransactionTemplate(tm);
 		tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_NESTED);
-		boolean condition2 = !TransactionSynchronizationManager.hasResource(ds);
-		assertThat(condition2).as("Hasn't thread connection").isTrue();
-		boolean condition1 = !TransactionSynchronizationManager.isSynchronizationActive();
-		assertThat(condition1).as("Synchronization not active").isTrue();
+		assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
+		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active")
+				.isFalse();
 
 		tt.execute(new TransactionCallbackWithoutResult() {
 			@Override
@@ -1579,8 +1460,7 @@ public class DataSourceTransactionManagerTests {
 			}
 		});
 
-		boolean condition = !TransactionSynchronizationManager.hasResource(ds);
-		assertThat(condition).as("Hasn't thread connection").isTrue();
+		assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
 		verify(con).releaseSavepoint(sp);
 		verify(con).commit();
 		verify(con).close();
@@ -1598,10 +1478,8 @@ public class DataSourceTransactionManagerTests {
 
 		final TransactionTemplate tt = new TransactionTemplate(tm);
 		tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_NESTED);
-		boolean condition2 = !TransactionSynchronizationManager.hasResource(ds);
-		assertThat(condition2).as("Hasn't thread connection").isTrue();
-		boolean condition1 = !TransactionSynchronizationManager.isSynchronizationActive();
-		assertThat(condition1).as("Synchronization not active").isTrue();
+		assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
+		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isFalse();
 
 		tt.execute(new TransactionCallbackWithoutResult() {
 			@Override
@@ -1613,8 +1491,7 @@ public class DataSourceTransactionManagerTests {
 			}
 		});
 
-		boolean condition = !TransactionSynchronizationManager.hasResource(ds);
-		assertThat(condition).as("Hasn't thread connection").isTrue();
+		assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
 		verify(con).rollback(sp);
 		verify(con).commit();
 		verify(con).close();
@@ -1624,10 +1501,8 @@ public class DataSourceTransactionManagerTests {
 	public void testTransactionWithPropagationNested() throws Exception {
 		final TransactionTemplate tt = new TransactionTemplate(tm);
 		tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_NESTED);
-		boolean condition2 = !TransactionSynchronizationManager.hasResource(ds);
-		assertThat(condition2).as("Hasn't thread connection").isTrue();
-		boolean condition1 = !TransactionSynchronizationManager.isSynchronizationActive();
-		assertThat(condition1).as("Synchronization not active").isTrue();
+		assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
+		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isFalse();
 
 		tt.execute(new TransactionCallbackWithoutResult() {
 			@Override
@@ -1636,8 +1511,7 @@ public class DataSourceTransactionManagerTests {
 			}
 		});
 
-		boolean condition = !TransactionSynchronizationManager.hasResource(ds);
-		assertThat(condition).as("Hasn't thread connection").isTrue();
+		assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
 		verify(con).commit();
 		verify(con).close();
 	}
@@ -1646,10 +1520,8 @@ public class DataSourceTransactionManagerTests {
 	public void testTransactionWithPropagationNestedAndRollback() throws Exception {
 		final TransactionTemplate tt = new TransactionTemplate(tm);
 		tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_NESTED);
-		boolean condition2 = !TransactionSynchronizationManager.hasResource(ds);
-		assertThat(condition2).as("Hasn't thread connection").isTrue();
-		boolean condition1 = !TransactionSynchronizationManager.isSynchronizationActive();
-		assertThat(condition1).as("Synchronization not active").isTrue();
+		assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
+		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isFalse();
 
 		tt.execute(new TransactionCallbackWithoutResult() {
 			@Override
@@ -1659,8 +1531,7 @@ public class DataSourceTransactionManagerTests {
 			}
 		});
 
-		boolean condition = !TransactionSynchronizationManager.hasResource(ds);
-		assertThat(condition).as("Hasn't thread connection").isTrue();
+		assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
 		verify(con).rollback();
 		verify(con).close();
 	}

spring-jdbc/src/test/java/org/springframework/jdbc/support/JdbcTransactionManagerTests.java

@@ -143,8 +143,7 @@ public class JdbcTransactionManagerTests {
 		tm = new JdbcTransactionManager(dsToUse);
 		TransactionTemplate tt = new TransactionTemplate(tm);
 		assertThat(TransactionSynchronizationManager.hasResource(dsToUse)).as("Hasn't thread connection").isFalse();
-		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active")
-				.isFalse();
+		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isFalse();
 
 		tt.execute(new TransactionCallbackWithoutResult() {
 			@Override
@@ -171,8 +170,7 @@ public class JdbcTransactionManagerTests {
 		});
 
 		assertThat(TransactionSynchronizationManager.hasResource(dsToUse)).as("Hasn't thread connection").isFalse();
-		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active")
-				.isFalse();
+		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isFalse();
 
 		if (autoCommit && (!lazyConnection || createStatement)) {
 			InOrder ordered = inOrder(con);
@@ -234,8 +232,7 @@ public class JdbcTransactionManagerTests {
 		tm = new JdbcTransactionManager(dsToUse);
 		TransactionTemplate tt = new TransactionTemplate(tm);
 		assertThat(TransactionSynchronizationManager.hasResource(dsToUse)).as("Hasn't thread connection").isFalse();
-		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active")
-				.isFalse();
+		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isFalse();
 
 		final RuntimeException ex = new RuntimeException("Application exception");
 		assertThatRuntimeException().isThrownBy(() ->
@@ -260,8 +257,7 @@ public class JdbcTransactionManagerTests {
 			.isEqualTo(ex);
 
 		assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
-		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active")
-				.isFalse();
+		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isFalse();
 
 		if (autoCommit && (!lazyConnection || createStatement)) {
 			InOrder ordered = inOrder(con);
@@ -282,8 +278,7 @@ public class JdbcTransactionManagerTests {
 		tm.setTransactionSynchronization(JdbcTransactionManager.SYNCHRONIZATION_NEVER);
 		TransactionTemplate tt = new TransactionTemplate(tm);
 		assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
-		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active")
-				.isFalse();
+		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isFalse();
 
 		ConnectionHolder conHolder = new ConnectionHolder(con, true);
 		TransactionSynchronizationManager.bindResource(ds, conHolder);
@@ -293,8 +288,7 @@ public class JdbcTransactionManagerTests {
 				@Override
 				protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException {
 					assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Has thread connection").isTrue();
-					assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active")
-							.isFalse();
+					assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isFalse();
 					assertThat(status.isNewTransaction()).as("Is existing transaction").isFalse();
 					throw ex;
 				}
@@ -303,8 +297,7 @@ public class JdbcTransactionManagerTests {
 		}
 		catch (RuntimeException ex2) {
 			// expected
-			assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active")
-					.isFalse();
+			assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isFalse();
 			assertThat(ex2).as("Correct exception thrown").isEqualTo(ex);
 		}
 		finally {
@@ -330,8 +323,7 @@ public class JdbcTransactionManagerTests {
 			tm.setFailEarlyOnGlobalRollbackOnly(true);
 		}
 		assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
-		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active")
-				.isFalse();
+		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isFalse();
 
 		TransactionStatus ts = tm.getTransaction(new DefaultTransactionDefinition());
 		TestTransactionSynchronization synch =
@@ -394,8 +386,7 @@ public class JdbcTransactionManagerTests {
 		tm.setValidateExistingTransaction(true);
 
 		assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
-		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active")
-				.isFalse();
+		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isFalse();
 
 		assertThatExceptionOfType(IllegalTransactionStateException.class).isThrownBy(() -> {
 				final TransactionTemplate tt = new TransactionTemplate(tm);
@@ -428,8 +419,7 @@ public class JdbcTransactionManagerTests {
 		tm.setValidateExistingTransaction(true);
 
 		assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
-		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active")
-				.isFalse();
+		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isFalse();
 
 		assertThatExceptionOfType(IllegalTransactionStateException.class).isThrownBy(() -> {
 			final TransactionTemplate tt = new TransactionTemplate(tm);
@@ -460,8 +450,7 @@ public class JdbcTransactionManagerTests {
 	@Test
 	public void testParticipatingTransactionWithTransactionStartedFromSynch() throws Exception {
 		assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
-		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active")
-				.isFalse();
+		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isFalse();
 
 		final TransactionTemplate tt = new TransactionTemplate(tm);
 		tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
@@ -504,8 +493,7 @@ public class JdbcTransactionManagerTests {
 		given(ds2.getConnection()).willReturn(con2);
 
 		assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
-		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active")
-				.isFalse();
+		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isFalse();
 
 		final TransactionTemplate tt = new TransactionTemplate(tm);
 
@@ -544,8 +532,7 @@ public class JdbcTransactionManagerTests {
 		// tm has no synch enabled (used at outer level), tm2 has synch enabled (inner level)
 
 		assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
-		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active")
-				.isFalse();
+		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isFalse();
 
 		TransactionStatus ts = tm.getTransaction(new DefaultTransactionDefinition());
 		final TestTransactionSynchronization synch =
@@ -591,8 +578,7 @@ public class JdbcTransactionManagerTests {
 		final TransactionTemplate tt = new TransactionTemplate(tm);
 		tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
 		assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
-		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active")
-				.isFalse();
+		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isFalse();
 
 		tt.execute(new TransactionCallbackWithoutResult() {
 			@Override
@@ -639,8 +625,7 @@ public class JdbcTransactionManagerTests {
 
 		assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
 		assertThat(TransactionSynchronizationManager.hasResource(ds2)).as("Hasn't thread connection").isFalse();
-		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active")
-				.isFalse();
+		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isFalse();
 
 		tt.execute(new TransactionCallbackWithoutResult() {
 			@Override
@@ -690,8 +675,7 @@ public class JdbcTransactionManagerTests {
 
 		assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
 		assertThat(TransactionSynchronizationManager.hasResource(ds2)).as("Hasn't thread connection").isFalse();
-		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active")
-				.isFalse();
+		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isFalse();
 
 		assertThatExceptionOfType(CannotCreateTransactionException.class).isThrownBy(() ->
 			tt.execute(new TransactionCallbackWithoutResult() {
@@ -721,8 +705,7 @@ public class JdbcTransactionManagerTests {
 		final TransactionTemplate tt = new TransactionTemplate(tm);
 		tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
 		assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
-		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active")
-				.isFalse();
+		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isFalse();
 
 		tt.execute(new TransactionCallbackWithoutResult() {
 			@Override
@@ -734,8 +717,7 @@ public class JdbcTransactionManagerTests {
 				tt.execute(new TransactionCallbackWithoutResult() {
 					@Override
 					protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException {
-						assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection")
-								.isFalse();
+						assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
 						assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization active").isTrue();
 						assertThat(status.isNewTransaction()).as("Isn't new transaction").isFalse();
 						assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
@@ -759,8 +741,7 @@ public class JdbcTransactionManagerTests {
 		final TransactionTemplate tt = new TransactionTemplate(tm);
 		tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
 		assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
-		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active")
-				.isFalse();
+		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isFalse();
 
 		assertThatExceptionOfType(IllegalTransactionStateException.class).isThrownBy(() ->
 			tt.execute(new TransactionCallbackWithoutResult() {
@@ -788,8 +769,7 @@ public class JdbcTransactionManagerTests {
 		TransactionTemplate tt = new TransactionTemplate(tm);
 		tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_SUPPORTS);
 		assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
-		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active")
-				.isFalse();
+		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isFalse();
 
 		tt.execute(new TransactionCallbackWithoutResult() {
 			@Override
@@ -825,8 +805,7 @@ public class JdbcTransactionManagerTests {
 		TransactionTemplate tt = new TransactionTemplate(tm);
 		tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_SUPPORTS);
 		assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
-		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active")
-				.isFalse();
+		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isFalse();
 
 		tt.execute(new TransactionCallbackWithoutResult() {
 			@Override
@@ -1586,8 +1565,7 @@ public class JdbcTransactionManagerTests {
 		final TransactionTemplate tt = new TransactionTemplate(tm);
 		tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_NESTED);
 		assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
-		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active")
-				.isFalse();
+		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isFalse();
 
 		tt.execute(new TransactionCallbackWithoutResult() {
 			@Override
@@ -1610,8 +1588,7 @@ public class JdbcTransactionManagerTests {
 		final TransactionTemplate tt = new TransactionTemplate(tm);
 		tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_NESTED);
 		assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
-		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active")
-				.isFalse();
+		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isFalse();
 
 		tt.execute(new TransactionCallbackWithoutResult() {
 			@Override
@@ -1630,8 +1607,7 @@ public class JdbcTransactionManagerTests {
 		final TransactionTemplate tt = new TransactionTemplate(tm);
 		tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_NESTED);
 		assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
-		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active")
-				.isFalse();
+		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isFalse();
 
 		tt.execute(new TransactionCallbackWithoutResult() {
 			@Override

spring-jms/src/main/java/org/springframework/jms/listener/AbstractJmsListeningContainer.java

@@ -125,18 +125,19 @@ public abstract class AbstractJmsListeningContainer extends JmsDestinationAccess
 	}
 
 	/**
-	 * Specify the phase in which this container should be started and
-	 * stopped. The startup order proceeds from lowest to highest, and
-	 * the shutdown order is the reverse of that. By default this value
-	 * is Integer.MAX_VALUE meaning that this container starts as late
-	 * as possible and stops as soon as possible.
+	 * Specify the lifecycle phase in which this container should be started and stopped.
+	 * <p>The startup order proceeds from lowest to highest, and the shutdown order
+	 * is the reverse of that. The default is {@link #DEFAULT_PHASE} meaning that
+	 * this container starts as late as possible and stops as soon as possible.
+	 * @see SmartLifecycle#getPhase()
 	 */
 	public void setPhase(int phase) {
 		this.phase = phase;
 	}
 
 	/**
-	 * Return the phase in which this container will be started and stopped.
+	 * Return the lifecycle phase in which this container will be started and stopped.
+	 * @see #setPhase
 	 */
 	@Override
 	public int getPhase() {