From 8e8c3f5a7c86796e65282776012c6bbb9706d76c Mon Sep 17 00:00:00 2001 From: Juergen Hoeller Date: Fri, 7 Jul 2023 13:14:40 +0200 Subject: [PATCH 1/2] Polishing --- .../support/DefaultListableBeanFactory.java | 2 +- .../context/support/DefaultLifecycleProcessor.java | 2 +- .../concurrent/ExecutorConfigurationSupport.java | 12 ++++++++---- .../scheduling/annotation/EnableAsyncTests.java | 14 ++++++-------- .../annotation/EnableSchedulingTests.java | 4 ++-- .../listener/AbstractJmsListeningContainer.java | 13 +++++++------ 6 files changed, 25 insertions(+), 22 deletions(-) diff --git a/spring-beans/src/main/java/org/springframework/beans/factory/support/DefaultListableBeanFactory.java b/spring-beans/src/main/java/org/springframework/beans/factory/support/DefaultListableBeanFactory.java index baa50d95661..6df2757ab9c 100644 --- a/spring-beans/src/main/java/org/springframework/beans/factory/support/DefaultListableBeanFactory.java +++ b/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(); diff --git a/spring-context/src/main/java/org/springframework/context/support/DefaultLifecycleProcessor.java b/spring-context/src/main/java/org/springframework/context/support/DefaultLifecycleProcessor.java index 5c57b1c8651..3198e103c75 100644 --- a/spring-context/src/main/java/org/springframework/context/support/DefaultLifecycleProcessor.java +++ b/spring-context/src/main/java/org/springframework/context/support/DefaultLifecycleProcessor.java @@ -66,7 +66,7 @@ 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). - *

The default value is 30 seconds. + *

The default value is 30000 milliseconds (30 seconds). */ public void setTimeoutPerShutdownPhase(long timeoutPerShutdownPhase) { this.timeoutPerShutdownPhase = timeoutPerShutdownPhase; diff --git a/spring-context/src/main/java/org/springframework/scheduling/concurrent/ExecutorConfigurationSupport.java b/spring-context/src/main/java/org/springframework/scheduling/concurrent/ExecutorConfigurationSupport.java index 55ca08ed9bf..ae4d3a1e34a 100644 --- a/spring-context/src/main/java/org/springframework/scheduling/concurrent/ExecutorConfigurationSupport.java +++ b/spring-context/src/main/java/org/springframework/scheduling/concurrent/ExecutorConfigurationSupport.java @@ -108,9 +108,9 @@ public abstract class ExecutorConfigurationSupport extends CustomizableThreadFac /** * Set whether to wait for scheduled tasks to complete on shutdown, * not interrupting running tasks and executing all tasks in the queue. - *

Default is "false", shutting down immediately through interrupting - * ongoing tasks and clearing the queue. Switch this flag to "true" if you - * prefer fully completed tasks at the expense of a longer shutdown phase. + *

Default is {@code false}, shutting down immediately through interrupting + * ongoing tasks and clearing the queue. Switch this flag to {@code true} if + * you prefer fully completed tasks at the expense of a longer shutdown phase. *

Note that Spring's container shutdown continues while ongoing tasks * are being completed. If you want this executor to block and wait for the * termination of tasks before the rest of the container continues to shut @@ -211,9 +211,13 @@ public abstract class ExecutorConfigurationSupport extends CustomizableThreadFac } /** - * Perform a shutdown on the underlying ExecutorService. + * Perform a full shutdown on the underlying ExecutorService, + * according to the corresponding configuration settings. + * @see #setWaitForTasksToCompleteOnShutdown + * @see #setAwaitTerminationMillis * @see java.util.concurrent.ExecutorService#shutdown() * @see java.util.concurrent.ExecutorService#shutdownNow() + * @see java.util.concurrent.ExecutorService#awaitTermination */ public void shutdown() { if (logger.isDebugEnabled()) { diff --git a/spring-context/src/test/java/org/springframework/scheduling/annotation/EnableAsyncTests.java b/spring-context/src/test/java/org/springframework/scheduling/annotation/EnableAsyncTests.java index 3514da33467..40d79675b25 100644 --- a/spring-context/src/test/java/org/springframework/scheduling/annotation/EnableAsyncTests.java +++ b/spring-context/src/test/java/org/springframework/scheduling/annotation/EnableAsyncTests.java @@ -96,9 +96,8 @@ public class EnableAsyncTests { public void properExceptionForExistingProxyDependencyMismatch() { AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(); ctx.register(AsyncConfig.class, AsyncBeanWithInterface.class, AsyncBeanUser.class); - assertThatExceptionOfType(UnsatisfiedDependencyException.class).isThrownBy( - ctx::refresh) - .withCauseInstanceOf(BeanNotOfRequiredTypeException.class); + assertThatExceptionOfType(UnsatisfiedDependencyException.class).isThrownBy(ctx::refresh) + .withCauseInstanceOf(BeanNotOfRequiredTypeException.class); ctx.close(); } @@ -106,9 +105,8 @@ public class EnableAsyncTests { public void properExceptionForResolvedProxyDependencyMismatch() { AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(); ctx.register(AsyncConfig.class, AsyncBeanUser.class, AsyncBeanWithInterface.class); - assertThatExceptionOfType(UnsatisfiedDependencyException.class).isThrownBy( - ctx::refresh) - .withCauseInstanceOf(BeanNotOfRequiredTypeException.class); + assertThatExceptionOfType(UnsatisfiedDependencyException.class).isThrownBy(ctx::refresh) + .withCauseInstanceOf(BeanNotOfRequiredTypeException.class); ctx.close(); } @@ -208,8 +206,7 @@ public class EnableAsyncTests { @SuppressWarnings("resource") AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(); ctx.register(AspectJAsyncAnnotationConfig.class); - assertThatExceptionOfType(BeanDefinitionStoreException.class).isThrownBy( - ctx::refresh); + assertThatExceptionOfType(BeanDefinitionStoreException.class).isThrownBy(ctx::refresh); } @Test @@ -521,6 +518,7 @@ public class EnableAsyncTests { } } + @Configuration @EnableAsync static class AsyncWithExecutorQualifiedByExpressionConfig { diff --git a/spring-context/src/test/java/org/springframework/scheduling/annotation/EnableSchedulingTests.java b/spring-context/src/test/java/org/springframework/scheduling/annotation/EnableSchedulingTests.java index b87abbe704c..08a44180af2 100644 --- a/spring-context/src/test/java/org/springframework/scheduling/annotation/EnableSchedulingTests.java +++ b/spring-context/src/test/java/org/springframework/scheduling/annotation/EnableSchedulingTests.java @@ -1,5 +1,5 @@ /* - * Copyright 2002-2022 the original author or authors. + * Copyright 2002-2023 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. @@ -89,7 +89,7 @@ public class EnableSchedulingTests { assertThat(ctx.getBean(AtomicInteger.class).get()).isGreaterThanOrEqualTo(10); assertThat(ctx.getBean(ExplicitSchedulerConfig.class).threadName).startsWith("explicitScheduler-"); assertThat(Arrays.asList(ctx.getDefaultListableBeanFactory().getDependentBeans("myTaskScheduler")).contains( - TaskManagementConfigUtils.SCHEDULED_ANNOTATION_PROCESSOR_BEAN_NAME)).isTrue(); + TaskManagementConfigUtils.SCHEDULED_ANNOTATION_PROCESSOR_BEAN_NAME)).isTrue(); } @Test diff --git a/spring-jms/src/main/java/org/springframework/jms/listener/AbstractJmsListeningContainer.java b/spring-jms/src/main/java/org/springframework/jms/listener/AbstractJmsListeningContainer.java index 3e30e597884..104f98e79d0 100644 --- a/spring-jms/src/main/java/org/springframework/jms/listener/AbstractJmsListeningContainer.java +++ b/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. + *

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() { From 35c7e3960e693ea87658e9bbc215794cf2969282 Mon Sep 17 00:00:00 2001 From: Juergen Hoeller Date: Fri, 7 Jul 2023 13:46:57 +0200 Subject: [PATCH 2/2] Polishing --- .../support/DefaultLifecycleProcessor.java | 7 +- .../DataSourceTransactionManagerTests.java | 409 ++++++------------ .../support/JdbcTransactionManagerTests.java | 72 +-- 3 files changed, 168 insertions(+), 320 deletions(-) diff --git a/spring-context/src/main/java/org/springframework/context/support/DefaultLifecycleProcessor.java b/spring-context/src/main/java/org/springframework/context/support/DefaultLifecycleProcessor.java index 3198e103c75..44dca4ad5ed 100644 --- a/spring-context/src/main/java/org/springframework/context/support/DefaultLifecycleProcessor.java +++ b/spring-context/src/main/java/org/springframework/context/support/DefaultLifecycleProcessor.java @@ -1,5 +1,5 @@ /* - * Copyright 2002-2022 the original author or authors. + * Copyright 2002-2023 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. @@ -64,9 +64,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). + * Specify the maximum time allotted in milliseconds for the shutdown of any + * phase (group of {@link SmartLifecycle} beans with the same 'phase' value). *

The default value is 30000 milliseconds (30 seconds). + * @see SmartLifecycle#getPhase() */ public void setTimeoutPerShutdownPhase(long timeoutPerShutdownPhase) { this.timeoutPerShutdownPhase = timeoutPerShutdownPhase; diff --git a/spring-jdbc/src/test/java/org/springframework/jdbc/datasource/DataSourceTransactionManagerTests.java b/spring-jdbc/src/test/java/org/springframework/jdbc/datasource/DataSourceTransactionManagerTests.java index f6cb99fbfca..dea00432629 100644 --- a/spring-jdbc/src/test/java/org/springframework/jdbc/datasource/DataSourceTransactionManagerTests.java +++ b/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(); } diff --git a/spring-jdbc/src/test/java/org/springframework/jdbc/support/JdbcTransactionManagerTests.java b/spring-jdbc/src/test/java/org/springframework/jdbc/support/JdbcTransactionManagerTests.java index 23bf666db42..7ceb54b2883 100644 --- a/spring-jdbc/src/test/java/org/springframework/jdbc/support/JdbcTransactionManagerTests.java +++ b/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