Remove test prefixes and avoid warnings in JDBC and TX tests

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

@@ -90,15 +90,16 @@ class DataSourceJtaTransactionTests {
 
 
 	@Test
-	void testJtaTransactionCommit() throws Exception {
+	void jtaTransactionCommit() throws Exception {
 		doTestJtaTransaction(false);
 	}
 
 	@Test
-	void testJtaTransactionRollback() throws Exception {
+	void jtaTransactionRollback() throws Exception {
 		doTestJtaTransaction(true);
 	}
 
+	@SuppressWarnings("deprecation")
 	private void doTestJtaTransaction(final boolean rollback) throws Exception {
 		if (rollback) {
 			given(userTransaction.getStatus()).willReturn(
@@ -145,55 +146,56 @@ class DataSourceJtaTransactionTests {
 	}
 
 	@Test
-	void testJtaTransactionCommitWithPropagationRequiresNew() throws Exception {
+	void jtaTransactionCommitWithPropagationRequiresNew() throws Exception {
 		doTestJtaTransactionWithPropagationRequiresNew(false, false, false, false);
 	}
 
 	@Test
-	void testJtaTransactionCommitWithPropagationRequiresNewWithAccessAfterResume() throws Exception {
+	void jtaTransactionCommitWithPropagationRequiresNewWithAccessAfterResume() throws Exception {
 		doTestJtaTransactionWithPropagationRequiresNew(false, false, true, false);
 	}
 
 	@Test
-	void testJtaTransactionCommitWithPropagationRequiresNewWithOpenOuterConnection() throws Exception {
+	void jtaTransactionCommitWithPropagationRequiresNewWithOpenOuterConnection() throws Exception {
 		doTestJtaTransactionWithPropagationRequiresNew(false, true, false, false);
 	}
 
 	@Test
-	void testJtaTransactionCommitWithPropagationRequiresNewWithOpenOuterConnectionAccessed() throws Exception {
+	void jtaTransactionCommitWithPropagationRequiresNewWithOpenOuterConnectionAccessed() throws Exception {
 		doTestJtaTransactionWithPropagationRequiresNew(false, true, true, false);
 	}
 
 	@Test
-	void testJtaTransactionCommitWithPropagationRequiresNewWithTransactionAwareDataSource() throws Exception {
+	void jtaTransactionCommitWithPropagationRequiresNewWithTransactionAwareDataSource() throws Exception {
 		doTestJtaTransactionWithPropagationRequiresNew(false, false, true, true);
 	}
 
 	@Test
-	void testJtaTransactionRollbackWithPropagationRequiresNew() throws Exception {
+	void jtaTransactionRollbackWithPropagationRequiresNew() throws Exception {
 		doTestJtaTransactionWithPropagationRequiresNew(true, false, false, false);
 	}
 
 	@Test
-	void testJtaTransactionRollbackWithPropagationRequiresNewWithAccessAfterResume() throws Exception {
+	void jtaTransactionRollbackWithPropagationRequiresNewWithAccessAfterResume() throws Exception {
 		doTestJtaTransactionWithPropagationRequiresNew(true, false, true, false);
 	}
 
 	@Test
-	void testJtaTransactionRollbackWithPropagationRequiresNewWithOpenOuterConnection() throws Exception {
+	void jtaTransactionRollbackWithPropagationRequiresNewWithOpenOuterConnection() throws Exception {
 		doTestJtaTransactionWithPropagationRequiresNew(true, true, false, false);
 	}
 
 	@Test
-	void testJtaTransactionRollbackWithPropagationRequiresNewWithOpenOuterConnectionAccessed() throws Exception {
+	void jtaTransactionRollbackWithPropagationRequiresNewWithOpenOuterConnectionAccessed() throws Exception {
 		doTestJtaTransactionWithPropagationRequiresNew(true, true, true, false);
 	}
 
 	@Test
-	void testJtaTransactionRollbackWithPropagationRequiresNewWithTransactionAwareDataSource() throws Exception {
+	void jtaTransactionRollbackWithPropagationRequiresNewWithTransactionAwareDataSource() throws Exception {
 		doTestJtaTransactionWithPropagationRequiresNew(true, false, true, true);
 	}
 
+	@SuppressWarnings("deprecation")
 	private void doTestJtaTransactionWithPropagationRequiresNew(
 			final boolean rollback, final boolean openOuterConnection, final boolean accessAfterResume,
 			final boolean useTransactionAwareDataSource) throws Exception {
@@ -316,25 +318,26 @@ class DataSourceJtaTransactionTests {
 	}
 
 	@Test
-	void testJtaTransactionCommitWithPropagationRequiredWithinSupports() throws Exception {
+	void jtaTransactionCommitWithPropagationRequiredWithinSupports() throws Exception {
 		doTestJtaTransactionCommitWithNewTransactionWithinEmptyTransaction(false, false);
 	}
 
 	@Test
-	void testJtaTransactionCommitWithPropagationRequiredWithinNotSupported() throws Exception {
+	void jtaTransactionCommitWithPropagationRequiredWithinNotSupported() throws Exception {
 		doTestJtaTransactionCommitWithNewTransactionWithinEmptyTransaction(false, true);
 	}
 
 	@Test
-	void testJtaTransactionCommitWithPropagationRequiresNewWithinSupports() throws Exception {
+	void jtaTransactionCommitWithPropagationRequiresNewWithinSupports() throws Exception {
 		doTestJtaTransactionCommitWithNewTransactionWithinEmptyTransaction(true, false);
 	}
 
 	@Test
-	void testJtaTransactionCommitWithPropagationRequiresNewWithinNotSupported() throws Exception {
+	void jtaTransactionCommitWithPropagationRequiresNewWithinNotSupported() throws Exception {
 		doTestJtaTransactionCommitWithNewTransactionWithinEmptyTransaction(true, true);
 	}
 
+	@SuppressWarnings("deprecation")
 	private void doTestJtaTransactionCommitWithNewTransactionWithinEmptyTransaction(
 			final boolean requiresNew, boolean notSupported) throws Exception {
 
@@ -405,45 +408,46 @@ class DataSourceJtaTransactionTests {
 	}
 
 	@Test
-	void testJtaTransactionCommitWithPropagationRequiresNewAndSuspendException() throws Exception {
+	void jtaTransactionCommitWithPropagationRequiresNewAndSuspendException() throws Exception {
 		doTestJtaTransactionWithPropagationRequiresNewAndBeginException(true, false, false);
 	}
 
 	@Test
-	void testJtaTransactionCommitWithPropagationRequiresNewWithOpenOuterConnectionAndSuspendException() throws Exception {
+	void jtaTransactionCommitWithPropagationRequiresNewWithOpenOuterConnectionAndSuspendException() throws Exception {
 		doTestJtaTransactionWithPropagationRequiresNewAndBeginException(true, true, false);
 	}
 
 	@Test
-	void testJtaTransactionCommitWithPropagationRequiresNewWithTransactionAwareDataSourceAndSuspendException() throws Exception {
+	void jtaTransactionCommitWithPropagationRequiresNewWithTransactionAwareDataSourceAndSuspendException() throws Exception {
 		doTestJtaTransactionWithPropagationRequiresNewAndBeginException(true, false, true);
 	}
 
 	@Test
-	void testJtaTransactionCommitWithPropagationRequiresNewWithOpenOuterConnectionAndTransactionAwareDataSourceAndSuspendException() throws Exception {
+	void jtaTransactionCommitWithPropagationRequiresNewWithOpenOuterConnectionAndTransactionAwareDataSourceAndSuspendException() throws Exception {
 		doTestJtaTransactionWithPropagationRequiresNewAndBeginException(true, true, true);
 	}
 
 	@Test
-	void testJtaTransactionCommitWithPropagationRequiresNewAndBeginException() throws Exception {
+	void jtaTransactionCommitWithPropagationRequiresNewAndBeginException() throws Exception {
 		doTestJtaTransactionWithPropagationRequiresNewAndBeginException(false, false, false);
 	}
 
 	@Test
-	void testJtaTransactionCommitWithPropagationRequiresNewWithOpenOuterConnectionAndBeginException() throws Exception {
+	void jtaTransactionCommitWithPropagationRequiresNewWithOpenOuterConnectionAndBeginException() throws Exception {
 		doTestJtaTransactionWithPropagationRequiresNewAndBeginException(false, true, false);
 	}
 
 	@Test
-	void testJtaTransactionCommitWithPropagationRequiresNewWithOpenOuterConnectionAndTransactionAwareDataSourceAndBeginException() throws Exception {
+	void jtaTransactionCommitWithPropagationRequiresNewWithOpenOuterConnectionAndTransactionAwareDataSourceAndBeginException() throws Exception {
 		doTestJtaTransactionWithPropagationRequiresNewAndBeginException(false, true, true);
 	}
 
 	@Test
-	void testJtaTransactionCommitWithPropagationRequiresNewWithTransactionAwareDataSourceAndBeginException() throws Exception {
+	void jtaTransactionCommitWithPropagationRequiresNewWithTransactionAwareDataSourceAndBeginException() throws Exception {
 		doTestJtaTransactionWithPropagationRequiresNewAndBeginException(false, false, true);
 	}
 
+	@SuppressWarnings("deprecation")
 	private void doTestJtaTransactionWithPropagationRequiresNewAndBeginException(boolean suspendException,
 			final boolean openOuterConnection, final boolean useTransactionAwareDataSource) throws Exception {
 
@@ -544,8 +548,9 @@ class DataSourceJtaTransactionTests {
 		}
 	}
 
+	@SuppressWarnings("deprecation")
 	@Test
-	void testJtaTransactionWithConnectionHolderStillBound() throws Exception {
+	void jtaTransactionWithConnectionHolderStillBound() throws Exception {
 		@SuppressWarnings("serial")
 		JtaTransactionManager ptm = new JtaTransactionManager(userTransaction) {
 
@@ -601,8 +606,9 @@ class DataSourceJtaTransactionTests {
 		verify(connection, times(3)).close();
 	}
 
+	@SuppressWarnings("deprecation")
 	@Test
-	void testJtaTransactionWithIsolationLevelDataSourceAdapter() throws Exception {
+	void jtaTransactionWithIsolationLevelDataSourceAdapter() throws Exception {
 		given(userTransaction.getStatus()).willReturn(
 				Status.STATUS_NO_TRANSACTION,
 				Status.STATUS_ACTIVE,
@@ -649,15 +655,16 @@ class DataSourceJtaTransactionTests {
 	}
 
 	@Test
-	void testJtaTransactionWithIsolationLevelDataSourceRouter() throws Exception {
+	void jtaTransactionWithIsolationLevelDataSourceRouter() throws Exception {
 		doTestJtaTransactionWithIsolationLevelDataSourceRouter(false);
 	}
 
 	@Test
-	void testJtaTransactionWithIsolationLevelDataSourceRouterWithDataSourceLookup() throws Exception {
+	void jtaTransactionWithIsolationLevelDataSourceRouterWithDataSourceLookup() throws Exception {
 		doTestJtaTransactionWithIsolationLevelDataSourceRouter(true);
 	}
 
+	@SuppressWarnings("deprecation")
 	private void doTestJtaTransactionWithIsolationLevelDataSourceRouter(boolean dataSourceLookup) throws Exception {
 		given(userTransaction.getStatus())
 			.willReturn(Status.STATUS_NO_TRANSACTION, Status.STATUS_ACTIVE, Status.STATUS_ACTIVE, Status.STATUS_NO_TRANSACTION, Status.STATUS_ACTIVE, Status.STATUS_ACTIVE);
@@ -717,4 +724,5 @@ class DataSourceJtaTransactionTests {
 		verify(connection1).close();
 		verify(connection2).close();
 	}
+
 }

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

@@ -25,9 +25,7 @@ import org.mockito.InOrder;
 
 import org.springframework.dao.ConcurrencyFailureException;
 import org.springframework.jdbc.datasource.DataSourceTransactionManagerTests;
-import org.springframework.transaction.TransactionStatus;
 import org.springframework.transaction.TransactionSystemException;
-import org.springframework.transaction.support.TransactionCallbackWithoutResult;
 import org.springframework.transaction.support.TransactionSynchronizationManager;
 import org.springframework.transaction.support.TransactionTemplate;
 
@@ -53,36 +51,14 @@ class JdbcTransactionManagerTests extends DataSourceTransactionManagerTests {
 
 	@Override
 	@Test
-	protected void testTransactionWithExceptionOnCommit() throws Exception {
+	protected void transactionWithExceptionOnCommit() throws Exception {
 		willThrow(new SQLException("Cannot commit")).given(con).commit();
 		TransactionTemplate tt = new TransactionTemplate(tm);
 
 		// plain TransactionSystemException
 		assertThatExceptionOfType(TransactionSystemException.class).isThrownBy(() ->
-				tt.execute(new TransactionCallbackWithoutResult() {
+				tt.executeWithoutResult(status -> {
-				@Override
-				protected void doInTransactionWithoutResult(TransactionStatus status) {
 					// something transactional
-				}
-			}));
-
-		assertThat(TransactionSynchronizationManager.hasResource(ds)).isFalse();
-		verify(con).close();
-	}
-
-	@Test
-	void testTransactionWithDataAccessExceptionOnCommit() throws Exception {
-		willThrow(new SQLException("Cannot commit")).given(con).commit();
-		((JdbcTransactionManager) tm).setExceptionTranslator((task, sql, ex) -> new ConcurrencyFailureException(task));
-		TransactionTemplate tt = new TransactionTemplate(tm);
-
-		// specific ConcurrencyFailureException
-		assertThatExceptionOfType(ConcurrencyFailureException.class).isThrownBy(() ->
-				tt.execute(new TransactionCallbackWithoutResult() {
-					@Override
-					protected void doInTransactionWithoutResult(TransactionStatus status) {
-						// something transactional
-					}
 				}));
 
 		assertThat(TransactionSynchronizationManager.hasResource(ds)).isFalse();
@@ -90,17 +66,30 @@ class JdbcTransactionManagerTests extends DataSourceTransactionManagerTests {
 	}
 
 	@Test
-	void testTransactionWithDataAccessExceptionOnCommitFromLazyExceptionTranslator() throws Exception {
+	void transactionWithDataAccessExceptionOnCommit() throws Exception {
+		willThrow(new SQLException("Cannot commit")).given(con).commit();
+		((JdbcTransactionManager) tm).setExceptionTranslator((task, sql, ex) -> new ConcurrencyFailureException(task));
+		TransactionTemplate tt = new TransactionTemplate(tm);
+
+		// specific ConcurrencyFailureException
+		assertThatExceptionOfType(ConcurrencyFailureException.class).isThrownBy(() ->
+				tt.executeWithoutResult(status -> {
+					// something transactional
+				}));
+
+		assertThat(TransactionSynchronizationManager.hasResource(ds)).isFalse();
+		verify(con).close();
+	}
+
+	@Test
+	void transactionWithDataAccessExceptionOnCommitFromLazyExceptionTranslator() throws Exception {
 		willThrow(new SQLException("Cannot commit", "40")).given(con).commit();
 		TransactionTemplate tt = new TransactionTemplate(tm);
 
 		// specific ConcurrencyFailureException
 		assertThatExceptionOfType(ConcurrencyFailureException.class).isThrownBy(() ->
-				tt.execute(new TransactionCallbackWithoutResult() {
+				tt.executeWithoutResult(status -> {
-					@Override
+					// something transactional
-					protected void doInTransactionWithoutResult(TransactionStatus status) {
-						// something transactional
-					}
 				}));
 
 		assertThat(TransactionSynchronizationManager.hasResource(ds)).isFalse();
@@ -109,7 +98,7 @@ class JdbcTransactionManagerTests extends DataSourceTransactionManagerTests {
 
 	@Override
 	@Test
-	protected void testTransactionWithExceptionOnCommitAndRollbackOnCommitFailure() throws Exception {
+	protected void transactionWithExceptionOnCommitAndRollbackOnCommitFailure() throws Exception {
 		willThrow(new SQLException("Cannot commit")).given(con).commit();
 
 		tm.setRollbackOnCommitFailure(true);
@@ -117,12 +106,9 @@ class JdbcTransactionManagerTests extends DataSourceTransactionManagerTests {
 
 		// plain TransactionSystemException
 		assertThatExceptionOfType(TransactionSystemException.class).isThrownBy(() ->
-				tt.execute(new TransactionCallbackWithoutResult() {
+				tt.executeWithoutResult(status -> {
-				@Override
-				protected void doInTransactionWithoutResult(TransactionStatus status) {
 					// something transactional
-				}
+				}));
-			}));
 
 		assertThat(TransactionSynchronizationManager.hasResource(ds)).isFalse();
 		verify(con).rollback();
@@ -131,16 +117,14 @@ class JdbcTransactionManagerTests extends DataSourceTransactionManagerTests {
 
 	@Override
 	@Test
-	protected void testTransactionWithExceptionOnRollback() throws Exception {
+	protected void transactionWithExceptionOnRollback() throws Exception {
 		given(con.getAutoCommit()).willReturn(true);
 		willThrow(new SQLException("Cannot rollback")).given(con).rollback();
 		TransactionTemplate tt = new TransactionTemplate(tm);
 
 		// plain TransactionSystemException
 		assertThatExceptionOfType(TransactionSystemException.class).isThrownBy(() ->
-				tt.execute(new TransactionCallbackWithoutResult() {
+				tt.executeWithoutResult(status -> {
-				@Override
-				protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException {
 					assertThat(status.getTransactionName()).isEmpty();
 					assertThat(status.hasTransaction()).isTrue();
 					assertThat(status.isNewTransaction()).isTrue();
@@ -151,31 +135,6 @@ class JdbcTransactionManagerTests extends DataSourceTransactionManagerTests {
 					status.setRollbackOnly();
 					assertThat(status.isRollbackOnly()).isTrue();
 					assertThat(status.isCompleted()).isFalse();
-				}
-			}));
-
-		assertThat(TransactionSynchronizationManager.hasResource(ds)).isFalse();
-		InOrder ordered = inOrder(con);
-		ordered.verify(con).setAutoCommit(false);
-		ordered.verify(con).rollback();
-		ordered.verify(con).setAutoCommit(true);
-		verify(con).close();
-	}
-
-	@Test
-	void testTransactionWithDataAccessExceptionOnRollback() throws Exception {
-		given(con.getAutoCommit()).willReturn(true);
-		willThrow(new SQLException("Cannot rollback")).given(con).rollback();
-		((JdbcTransactionManager) tm).setExceptionTranslator((task, sql, ex) -> new ConcurrencyFailureException(task));
-		TransactionTemplate tt = new TransactionTemplate(tm);
-
-		// specific ConcurrencyFailureException
-		assertThatExceptionOfType(ConcurrencyFailureException.class).isThrownBy(() ->
-				tt.execute(new TransactionCallbackWithoutResult() {
-					@Override
-					protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException {
-						status.setRollbackOnly();
-					}
 				}));
 
 		assertThat(TransactionSynchronizationManager.hasResource(ds)).isFalse();
@@ -187,27 +146,43 @@ class JdbcTransactionManagerTests extends DataSourceTransactionManagerTests {
 	}
 
 	@Test
-	void testTransactionWithDataAccessExceptionOnRollbackFromLazyExceptionTranslator() throws Exception {
+	void transactionWithDataAccessExceptionOnRollback() throws Exception {
+		given(con.getAutoCommit()).willReturn(true);
+		willThrow(new SQLException("Cannot rollback")).given(con).rollback();
+		((JdbcTransactionManager) tm).setExceptionTranslator((task, sql, ex) -> new ConcurrencyFailureException(task));
+		TransactionTemplate tt = new TransactionTemplate(tm);
+
+		// specific ConcurrencyFailureException
+		assertThatExceptionOfType(ConcurrencyFailureException.class).isThrownBy(() ->
+				tt.executeWithoutResult(status -> status.setRollbackOnly()));
+
+		assertThat(TransactionSynchronizationManager.hasResource(ds)).isFalse();
+		InOrder ordered = inOrder(con);
+		ordered.verify(con).setAutoCommit(false);
+		ordered.verify(con).rollback();
+		ordered.verify(con).setAutoCommit(true);
+		verify(con).close();
+	}
+
+	@Test
+	void transactionWithDataAccessExceptionOnRollbackFromLazyExceptionTranslator() throws Exception {
 		given(con.getAutoCommit()).willReturn(true);
 		willThrow(new SQLException("Cannot rollback", "40")).given(con).rollback();
 		TransactionTemplate tt = new TransactionTemplate(tm);
 
 		// specific ConcurrencyFailureException
 		assertThatExceptionOfType(ConcurrencyFailureException.class).isThrownBy(() ->
-				tt.execute(new TransactionCallbackWithoutResult() {
+				tt.executeWithoutResult(status -> {
-					@Override
+					assertThat(status.getTransactionName()).isEmpty();
-					protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException {
+					assertThat(status.hasTransaction()).isTrue();
-						assertThat(status.getTransactionName()).isEmpty();
+					assertThat(status.isNewTransaction()).isTrue();
-						assertThat(status.hasTransaction()).isTrue();
+					assertThat(status.isNested()).isFalse();
-						assertThat(status.isNewTransaction()).isTrue();
+					assertThat(status.hasSavepoint()).isFalse();
-						assertThat(status.isNested()).isFalse();
+					assertThat(status.isReadOnly()).isFalse();
-						assertThat(status.hasSavepoint()).isFalse();
+					assertThat(status.isRollbackOnly()).isFalse();
-						assertThat(status.isReadOnly()).isFalse();
+					status.setRollbackOnly();
-						assertThat(status.isRollbackOnly()).isFalse();
+					assertThat(status.isRollbackOnly()).isTrue();
-						status.setRollbackOnly();
+					assertThat(status.isCompleted()).isFalse();
-						assertThat(status.isRollbackOnly()).isTrue();
-						assertThat(status.isCompleted()).isFalse();
-					}
 				}));
 
 		assertThat(TransactionSynchronizationManager.hasResource(ds)).isFalse();

spring-tx/src/test/java/org/springframework/transaction/JndiJtaTransactionManagerTests.java

@@ -25,7 +25,6 @@ import org.junit.jupiter.api.Test;
 import org.springframework.context.testfixture.jndi.ExpectedLookupTemplate;
 import org.springframework.transaction.jta.JtaTransactionManager;
 import org.springframework.transaction.jta.UserTransactionAdapter;
-import org.springframework.transaction.support.TransactionCallbackWithoutResult;
 import org.springframework.transaction.support.TransactionSynchronizationManager;
 import org.springframework.transaction.support.TransactionTemplate;
 
@@ -102,13 +101,10 @@ class JndiJtaTransactionManagerTests {
 		boolean condition1 = !TransactionSynchronizationManager.isSynchronizationActive();
 		assertThat(condition1).isTrue();
 		assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
-		tt.execute(new TransactionCallbackWithoutResult() {
+		tt.executeWithoutResult(status -> {
-			@Override
+			// something transactional
-			protected void doInTransactionWithoutResult(TransactionStatus status) {
+			assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
-				// something transactional
+			assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
-				assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
-				assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
-			}
 		});
 		boolean condition = !TransactionSynchronizationManager.isSynchronizationActive();
 		assertThat(condition).isTrue();
@@ -149,13 +145,10 @@ class JndiJtaTransactionManagerTests {
 		boolean condition1 = !TransactionSynchronizationManager.isSynchronizationActive();
 		assertThat(condition1).isTrue();
 		assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
-		tt.execute(new TransactionCallbackWithoutResult() {
+		tt.executeWithoutResult(status -> {
-			@Override
+			// something transactional
-			protected void doInTransactionWithoutResult(TransactionStatus status) {
+			assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
-				// something transactional
+			assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
-				assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
-				assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
-			}
 		});
 		boolean condition = !TransactionSynchronizationManager.isSynchronizationActive();
 		assertThat(condition).isTrue();
@@ -185,26 +178,19 @@ class JndiJtaTransactionManagerTests {
 		boolean condition1 = !TransactionSynchronizationManager.isSynchronizationActive();
 		assertThat(condition1).isTrue();
 		assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
-		tt.execute(new TransactionCallbackWithoutResult() {
+		tt.executeWithoutResult(status -> {
-			@Override
+			// something transactional
-			protected void doInTransactionWithoutResult(TransactionStatus status) {
+			assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
-				// something transactional
+			assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
-				assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
-				assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
-			}
 		});
 
 		ptm.setJndiTemplate(new ExpectedLookupTemplate("java:comp/UserTransaction", ut2));
-		tt.execute(new TransactionCallbackWithoutResult() {
+		tt.executeWithoutResult(status -> {
-			@Override
+			// something transactional
-			protected void doInTransactionWithoutResult(TransactionStatus status) {
+			assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
-				// something transactional
+			assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
-				assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
-				assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
-			}
 		});
-		boolean condition = !TransactionSynchronizationManager.isSynchronizationActive();
+		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
-		assertThat(condition).isTrue();
 		assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
 
 		verify(ut).begin();

spring-tx/src/test/java/org/springframework/transaction/JtaTransactionManagerTests.java

@@ -31,7 +31,6 @@ import org.junit.jupiter.api.Test;
 import org.springframework.dao.OptimisticLockingFailureException;
 import org.springframework.transaction.jta.JtaTransactionManager;
 import org.springframework.transaction.support.DefaultTransactionDefinition;
-import org.springframework.transaction.support.TransactionCallbackWithoutResult;
 import org.springframework.transaction.support.TransactionSynchronization;
 import org.springframework.transaction.support.TransactionSynchronizationManager;
 import org.springframework.transaction.support.TransactionTemplate;
@@ -69,22 +68,19 @@ class JtaTransactionManagerTests {
 		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
 		assertThat(TransactionSynchronizationManager.getCurrentTransactionName()).isNull();
 		assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
-		tt.execute(new TransactionCallbackWithoutResult() {
+		tt.executeWithoutResult(status -> {
-			@Override
+			// something transactional
-			protected void doInTransactionWithoutResult(TransactionStatus status) {
+			assertThat(status.getTransactionName()).isEqualTo("txName");
-				// something transactional
+			assertThat(status.hasTransaction()).isTrue();
-				assertThat(status.getTransactionName()).isEqualTo("txName");
+			assertThat(status.isNewTransaction()).isTrue();
-				assertThat(status.hasTransaction()).isTrue();
+			assertThat(status.isNested()).isFalse();
-				assertThat(status.isNewTransaction()).isTrue();
+			assertThat(status.isReadOnly()).isFalse();
-				assertThat(status.isNested()).isFalse();
+			assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
-				assertThat(status.isReadOnly()).isFalse();
+			TransactionSynchronizationManager.registerSynchronization(synch);
-				assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
+			assertThat(TransactionSynchronizationManager.getCurrentTransactionName()).isEqualTo("txName");
-				TransactionSynchronizationManager.registerSynchronization(synch);
+			assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
-				assertThat(TransactionSynchronizationManager.getCurrentTransactionName()).isEqualTo("txName");
+			assertThat(status.isRollbackOnly()).isFalse();
-				assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
+			assertThat(status.isCompleted()).isFalse();
-				assertThat(status.isRollbackOnly()).isFalse();
-				assertThat(status.isCompleted()).isFalse();
-			}
 		});
 		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
 		assertThat(TransactionSynchronizationManager.getCurrentTransactionName()).isNull();
@@ -109,20 +105,17 @@ class JtaTransactionManagerTests {
 		TransactionTemplate tt = new TransactionTemplate(ptm);
 		ptm.setTransactionSynchronization(JtaTransactionManager.SYNCHRONIZATION_ON_ACTUAL_TRANSACTION);
 		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
-		tt.execute(new TransactionCallbackWithoutResult() {
+		tt.executeWithoutResult(status -> {
-			@Override
+			// something transactional
-			protected void doInTransactionWithoutResult(TransactionStatus status) {
+			assertThat(status.getTransactionName()).isEmpty();
-				// something transactional
+			assertThat(status.hasTransaction()).isTrue();
-				assertThat(status.getTransactionName()).isEmpty();
+			assertThat(status.isNewTransaction()).isTrue();
-				assertThat(status.hasTransaction()).isTrue();
+			assertThat(status.isNested()).isFalse();
-				assertThat(status.isNewTransaction()).isTrue();
+			assertThat(status.isReadOnly()).isFalse();
-				assertThat(status.isNested()).isFalse();
+			assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
-				assertThat(status.isReadOnly()).isFalse();
+			TransactionSynchronizationManager.registerSynchronization(synch);
-				assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
+			assertThat(status.isRollbackOnly()).isFalse();
-				TransactionSynchronizationManager.registerSynchronization(synch);
+			assertThat(status.isCompleted()).isFalse();
-				assertThat(status.isRollbackOnly()).isFalse();
-				assertThat(status.isCompleted()).isFalse();
-			}
 		});
 		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
 
@@ -146,18 +139,15 @@ class JtaTransactionManagerTests {
 		ptm.afterPropertiesSet();
 
 		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
-		tt.execute(new TransactionCallbackWithoutResult() {
+		tt.executeWithoutResult(status -> {
-			@Override
+			assertThat(status.getTransactionName()).isEmpty();
-			protected void doInTransactionWithoutResult(TransactionStatus status) {
+			assertThat(status.hasTransaction()).isTrue();
-				assertThat(status.getTransactionName()).isEmpty();
+			assertThat(status.isNewTransaction()).isTrue();
-				assertThat(status.hasTransaction()).isTrue();
+			assertThat(status.isNested()).isFalse();
-				assertThat(status.isNewTransaction()).isTrue();
+			assertThat(status.isReadOnly()).isFalse();
-				assertThat(status.isNested()).isFalse();
+			assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
-				assertThat(status.isReadOnly()).isFalse();
+			assertThat(status.isRollbackOnly()).isFalse();
-				assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
+			assertThat(status.isCompleted()).isFalse();
-				assertThat(status.isRollbackOnly()).isFalse();
-				assertThat(status.isCompleted()).isFalse();
-			}
 		});
 		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
 
@@ -179,22 +169,19 @@ class JtaTransactionManagerTests {
 		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
 		assertThat(TransactionSynchronizationManager.getCurrentTransactionName()).isNull();
 		assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
-		tt.execute(new TransactionCallbackWithoutResult() {
+		tt.executeWithoutResult(status -> {
-			@Override
+			assertThat(status.getTransactionName()).isEqualTo("txName");
-			protected void doInTransactionWithoutResult(TransactionStatus status) {
+			assertThat(status.hasTransaction()).isTrue();
-				assertThat(status.getTransactionName()).isEqualTo("txName");
+			assertThat(status.isNewTransaction()).isTrue();
-				assertThat(status.hasTransaction()).isTrue();
+			assertThat(status.isNested()).isFalse();
-				assertThat(status.isNewTransaction()).isTrue();
+			assertThat(status.isReadOnly()).isFalse();
-				assertThat(status.isNested()).isFalse();
+			assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
-				assertThat(status.isReadOnly()).isFalse();
+			TransactionSynchronizationManager.registerSynchronization(synch);
-				assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
+			assertThat(TransactionSynchronizationManager.getCurrentTransactionName()).isEqualTo("txName");
-				TransactionSynchronizationManager.registerSynchronization(synch);
+			assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
-				assertThat(TransactionSynchronizationManager.getCurrentTransactionName()).isEqualTo("txName");
+			status.setRollbackOnly();
-				assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
+			assertThat(status.isRollbackOnly()).isTrue();
-				status.setRollbackOnly();
+			assertThat(status.isCompleted()).isFalse();
-				assertThat(status.isRollbackOnly()).isTrue();
-				assertThat(status.isCompleted()).isFalse();
-			}
 		});
 		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
 		assertThat(TransactionSynchronizationManager.getCurrentTransactionName()).isNull();
@@ -218,20 +205,17 @@ class JtaTransactionManagerTests {
 		ptm.setTransactionSynchronization(JtaTransactionManager.SYNCHRONIZATION_ON_ACTUAL_TRANSACTION);
 		tt.setTimeout(10);
 		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
-		tt.execute(new TransactionCallbackWithoutResult() {
+		tt.executeWithoutResult(status -> {
-			@Override
+			assertThat(status.getTransactionName()).isEmpty();
-			protected void doInTransactionWithoutResult(TransactionStatus status) {
+			assertThat(status.hasTransaction()).isTrue();
-				assertThat(status.getTransactionName()).isEmpty();
+			assertThat(status.isNewTransaction()).isTrue();
-				assertThat(status.hasTransaction()).isTrue();
+			assertThat(status.isNested()).isFalse();
-				assertThat(status.isNewTransaction()).isTrue();
+			assertThat(status.isReadOnly()).isFalse();
-				assertThat(status.isNested()).isFalse();
+			assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
-				assertThat(status.isReadOnly()).isFalse();
+			TransactionSynchronizationManager.registerSynchronization(synch);
-				assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
+			status.setRollbackOnly();
-				TransactionSynchronizationManager.registerSynchronization(synch);
+			assertThat(status.isRollbackOnly()).isTrue();
-				status.setRollbackOnly();
+			assertThat(status.isCompleted()).isFalse();
-				assertThat(status.isRollbackOnly()).isTrue();
-				assertThat(status.isCompleted()).isFalse();
-			}
 		});
 		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
 
@@ -254,20 +238,17 @@ class JtaTransactionManagerTests {
 		ptm.afterPropertiesSet();
 
 		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
-		tt.execute(new TransactionCallbackWithoutResult() {
+		tt.executeWithoutResult(status -> {
-			@Override
+			assertThat(status.getTransactionName()).isEmpty();
-			protected void doInTransactionWithoutResult(TransactionStatus status) {
+			assertThat(status.hasTransaction()).isTrue();
-				assertThat(status.getTransactionName()).isEmpty();
+			assertThat(status.isNewTransaction()).isTrue();
-				assertThat(status.hasTransaction()).isTrue();
+			assertThat(status.isNested()).isFalse();
-				assertThat(status.isNewTransaction()).isTrue();
+			assertThat(status.isReadOnly()).isFalse();
-				assertThat(status.isNested()).isFalse();
+			assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
-				assertThat(status.isReadOnly()).isFalse();
+			assertThat(status.isRollbackOnly()).isFalse();
-				assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
+			status.setRollbackOnly();
-				assertThat(status.isRollbackOnly()).isFalse();
+			assertThat(status.isRollbackOnly()).isTrue();
-				status.setRollbackOnly();
+			assertThat(status.isCompleted()).isFalse();
-				assertThat(status.isRollbackOnly()).isTrue();
-				assertThat(status.isCompleted()).isFalse();
-			}
 		});
 		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
 
@@ -287,13 +268,10 @@ class JtaTransactionManagerTests {
 		JtaTransactionManager ptm = newJtaTransactionManager(ut);
 		TransactionTemplate tt = new TransactionTemplate(ptm);
 		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
-		tt.execute(new TransactionCallbackWithoutResult() {
+		tt.executeWithoutResult(status -> {
-			@Override
+			assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
-			protected void doInTransactionWithoutResult(TransactionStatus status) {
+			TransactionSynchronizationManager.registerSynchronization(synch);
-				assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
+			status.setRollbackOnly();
-				TransactionSynchronizationManager.registerSynchronization(synch);
-				status.setRollbackOnly();
-			}
 		});
 		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
 
@@ -313,13 +291,10 @@ class JtaTransactionManagerTests {
 		TransactionTemplate tt = new TransactionTemplate(ptm);
 		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
 		assertThatIllegalStateException().isThrownBy(() ->
-			tt.execute(new TransactionCallbackWithoutResult() {
+			tt.executeWithoutResult(status -> {
-				@Override
+				assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
-				protected void doInTransactionWithoutResult(TransactionStatus status) {
+				TransactionSynchronizationManager.registerSynchronization(synch);
-					assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
+				throw new IllegalStateException("I want a rollback");
-					TransactionSynchronizationManager.registerSynchronization(synch);
-					throw new IllegalStateException("I want a rollback");
-				}
 			}));
 		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
 
@@ -340,12 +315,9 @@ class JtaTransactionManagerTests {
 		TransactionTemplate tt = new TransactionTemplate(ptm);
 		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
 		assertThatExceptionOfType(OptimisticLockingFailureException.class).isThrownBy(() ->
-			tt.execute(new TransactionCallbackWithoutResult() {
+			tt.executeWithoutResult(status -> {
-				@Override
+				assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
-				protected void doInTransactionWithoutResult(TransactionStatus status) {
+				TransactionSynchronizationManager.registerSynchronization(synch);
-					assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
-					TransactionSynchronizationManager.registerSynchronization(synch);
-				}
 			}));
 		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
 
@@ -365,13 +337,10 @@ class JtaTransactionManagerTests {
 		ptm.setGlobalRollbackOnParticipationFailure(false);
 		TransactionTemplate tt = new TransactionTemplate(ptm);
 		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
-		tt.execute(new TransactionCallbackWithoutResult() {
+		tt.executeWithoutResult(status -> {
-			@Override
+			assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
-			protected void doInTransactionWithoutResult(TransactionStatus status) {
+			TransactionSynchronizationManager.registerSynchronization(synch);
-				assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
+			status.setRollbackOnly();
-				TransactionSynchronizationManager.registerSynchronization(synch);
-				status.setRollbackOnly();
-			}
 		});
 		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
 
@@ -391,13 +360,10 @@ class JtaTransactionManagerTests {
 		TransactionTemplate tt = new TransactionTemplate(ptm);
 		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
 		assertThatIllegalStateException().isThrownBy(() ->
-			tt.execute(new TransactionCallbackWithoutResult() {
+			tt.executeWithoutResult(status -> {
-				@Override
+				assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
-				protected void doInTransactionWithoutResult(TransactionStatus status) {
+				TransactionSynchronizationManager.registerSynchronization(synch);
-					assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
+				throw new IllegalStateException("I want a rollback");
-					TransactionSynchronizationManager.registerSynchronization(synch);
-					throw new IllegalStateException("I want a rollback");
-				}
 			}));
 		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
 
@@ -419,13 +385,10 @@ class JtaTransactionManagerTests {
 		JtaTransactionManager ptm = newJtaTransactionManager(ut, tm);
 		TransactionTemplate tt = new TransactionTemplate(ptm);
 		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
-		tt.execute(new TransactionCallbackWithoutResult() {
+		tt.executeWithoutResult(status -> {
-			@Override
+			assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
-			protected void doInTransactionWithoutResult(TransactionStatus status) {
+			TransactionSynchronizationManager.registerSynchronization(synch);
-				assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
+			status.setRollbackOnly();
-				TransactionSynchronizationManager.registerSynchronization(synch);
-				status.setRollbackOnly();
-			}
 		});
 		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
 		assertThat(tx.getSynchronization()).isNotNull();
@@ -448,13 +411,10 @@ class JtaTransactionManagerTests {
 		TransactionTemplate tt = new TransactionTemplate(ptm);
 		ptm.setTransactionSynchronization(JtaTransactionManager.SYNCHRONIZATION_ON_ACTUAL_TRANSACTION);
 		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
-		tt.execute(new TransactionCallbackWithoutResult() {
+		tt.executeWithoutResult(status -> {
-			@Override
+			assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
-			protected void doInTransactionWithoutResult(TransactionStatus status) {
+			TransactionSynchronizationManager.registerSynchronization(synch);
-				assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
+			status.setRollbackOnly();
-				TransactionSynchronizationManager.registerSynchronization(synch);
-				status.setRollbackOnly();
-			}
 		});
 		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
 
@@ -474,12 +434,9 @@ class JtaTransactionManagerTests {
 		ptm.afterPropertiesSet();
 
 		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
-		tt.execute(new TransactionCallbackWithoutResult() {
+		tt.executeWithoutResult(status -> {
-			@Override
+			assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
-			protected void doInTransactionWithoutResult(TransactionStatus status) {
+			status.setRollbackOnly();
-				assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
-				status.setRollbackOnly();
-			}
 		});
 		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
 
@@ -497,13 +454,10 @@ class JtaTransactionManagerTests {
 		TransactionTemplate tt = new TransactionTemplate(ptm);
 		tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_SUPPORTS);
 		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
-		tt.execute(new TransactionCallbackWithoutResult() {
+		tt.executeWithoutResult(status -> {
-			@Override
+			assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
-			protected void doInTransactionWithoutResult(TransactionStatus status) {
+			TransactionSynchronizationManager.registerSynchronization(synch);
-				assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
+			status.setRollbackOnly();
-				TransactionSynchronizationManager.registerSynchronization(synch);
-				status.setRollbackOnly();
-			}
 		});
 		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
 
@@ -523,13 +477,10 @@ class JtaTransactionManagerTests {
 		TransactionTemplate tt = new TransactionTemplate(ptm);
 		tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_SUPPORTS);
 		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
-		tt.execute(new TransactionCallbackWithoutResult() {
+		tt.executeWithoutResult(status -> {
-			@Override
+			assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
-			protected void doInTransactionWithoutResult(TransactionStatus status) {
+			TransactionSynchronizationManager.registerSynchronization(synch);
-				assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
+			status.setRollbackOnly();
-				TransactionSynchronizationManager.registerSynchronization(synch);
-				status.setRollbackOnly();
-			}
 		});
 		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
 
@@ -549,12 +500,9 @@ class JtaTransactionManagerTests {
 		ptm.afterPropertiesSet();
 
 		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
-		tt.execute(new TransactionCallbackWithoutResult() {
+		tt.executeWithoutResult(status -> {
-			@Override
+			assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
-			protected void doInTransactionWithoutResult(TransactionStatus status) {
+			status.setRollbackOnly();
-				assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
-				status.setRollbackOnly();
-			}
 		});
 		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
 	}
@@ -571,12 +519,9 @@ class JtaTransactionManagerTests {
 		ptm.afterPropertiesSet();
 
 		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
-		tt.execute(new TransactionCallbackWithoutResult() {
+		tt.executeWithoutResult(status -> {
-			@Override
+			assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
-			protected void doInTransactionWithoutResult(TransactionStatus status) {
+			status.setRollbackOnly();
-				assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
-				status.setRollbackOnly();
-			}
 		});
 		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
 	}
@@ -593,12 +538,9 @@ class JtaTransactionManagerTests {
 		TransactionTemplate tt = new TransactionTemplate(ptm);
 		tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_NOT_SUPPORTED);
 		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
-		tt.execute(new TransactionCallbackWithoutResult() {
+		tt.executeWithoutResult(status -> {
-			@Override
+			assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
-			protected void doInTransactionWithoutResult(TransactionStatus status) {
+			status.setRollbackOnly();
-				assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
-				status.setRollbackOnly();
-			}
 		});
 		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
 
@@ -621,30 +563,24 @@ class JtaTransactionManagerTests {
 		tt.setName("txName");
 
 		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
-		tt.execute(new TransactionCallbackWithoutResult() {
+		tt.executeWithoutResult(status1 -> {
-			@Override
+			assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
-			protected void doInTransactionWithoutResult(TransactionStatus status) {
+			assertThat(TransactionSynchronizationManager.getCurrentTransactionName()).isEqualTo("txName");
-				assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
+			assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
-				assertThat(TransactionSynchronizationManager.getCurrentTransactionName()).isEqualTo("txName");
-				assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
-
-				TransactionTemplate tt2 = new TransactionTemplate(ptm);
-				tt2.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
-				tt2.setReadOnly(true);
-				tt2.setName("txName2");
-				tt2.execute(new TransactionCallbackWithoutResult() {
-					@Override
-					protected void doInTransactionWithoutResult(TransactionStatus status) {
-						assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
-						assertThat(TransactionSynchronizationManager.getCurrentTransactionName()).isEqualTo("txName2");
-						assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isTrue();
-					}
-				});
 
+			TransactionTemplate tt2 = new TransactionTemplate(ptm);
+			tt2.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
+			tt2.setReadOnly(true);
+			tt2.setName("txName2");
+			tt2.executeWithoutResult(status2 -> {
 				assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
-				assertThat(TransactionSynchronizationManager.getCurrentTransactionName()).isEqualTo("txName");
+				assertThat(TransactionSynchronizationManager.getCurrentTransactionName()).isEqualTo("txName2");
-				assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
+				assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isTrue();
-			}
+			});
+
+			assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
+			assertThat(TransactionSynchronizationManager.getCurrentTransactionName()).isEqualTo("txName");
+			assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
 		});
 		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
 
@@ -664,28 +600,22 @@ class JtaTransactionManagerTests {
 		tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_SUPPORTS);
 
 		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
-		tt.execute(new TransactionCallbackWithoutResult() {
+		tt.executeWithoutResult(status1 -> {
-			@Override
+			assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
-			protected void doInTransactionWithoutResult(TransactionStatus status) {
+			assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
+			assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
+
+			TransactionTemplate tt2 = new TransactionTemplate(ptm);
+			tt2.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
+			tt2.executeWithoutResult(status2 -> {
 				assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
 				assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
-				assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
+				assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue();
+			});
 
-				TransactionTemplate tt2 = new TransactionTemplate(ptm);
+			assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
-				tt2.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
+			assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
-				tt2.execute(new TransactionCallbackWithoutResult() {
+			assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
-					@Override
-					protected void doInTransactionWithoutResult(TransactionStatus status) {
-						assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
-						assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
-						assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue();
-					}
-				});
-
-				assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
-				assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
-				assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
-			}
 		});
 		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
 
@@ -705,12 +635,8 @@ class JtaTransactionManagerTests {
 		TransactionTemplate tt = new TransactionTemplate(ptm);
 		tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
 		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
-		tt.execute(new TransactionCallbackWithoutResult() {
+		tt.executeWithoutResult(status ->
-			@Override
+				assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue());
-			protected void doInTransactionWithoutResult(TransactionStatus status) {
-				assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
-			}
-		});
 		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
 
 		verify(ut).begin();
@@ -730,12 +656,8 @@ class JtaTransactionManagerTests {
 		tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
 		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
 		assertThatExceptionOfType(TransactionSystemException.class).isThrownBy(() ->
-			tt.execute(new TransactionCallbackWithoutResult() {
+			tt.executeWithoutResult(status ->
-				@Override
+					assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue()));
-				protected void doInTransactionWithoutResult(TransactionStatus status) {
-					assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
-				}
-			}));
 		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
 	}
 
@@ -753,12 +675,8 @@ class JtaTransactionManagerTests {
 		tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
 		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
 		assertThatExceptionOfType(CannotCreateTransactionException.class).isThrownBy(() ->
-		tt.execute(new TransactionCallbackWithoutResult() {
+			tt.executeWithoutResult(status ->
-				@Override
+					assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue()));
-				protected void doInTransactionWithoutResult(TransactionStatus status) {
-					assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
-				}
-			}));
 		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
 		verify(tm).resume(tx);
 	}
@@ -774,12 +692,8 @@ class JtaTransactionManagerTests {
 		TransactionTemplate tt = new TransactionTemplate(ptm);
 		tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
 		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
-		tt.execute(new TransactionCallbackWithoutResult() {
+		tt.executeWithoutResult(status ->
-			@Override
+				assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue());
-			protected void doInTransactionWithoutResult(TransactionStatus status) {
-				assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
-			}
-		});
 		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
 
 		verify(tm).begin();
@@ -797,10 +711,8 @@ class JtaTransactionManagerTests {
 		tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
 		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
 		assertThatExceptionOfType(TransactionSuspensionNotSupportedException.class).isThrownBy(() ->
-			tt.execute(new TransactionCallbackWithoutResult() {
+			tt.executeWithoutResult(status -> {
-				@Override
+				// something transactional
-				protected void doInTransactionWithoutResult(TransactionStatus status) {
-				}
 			}));
 		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
 	}
@@ -814,11 +726,8 @@ class JtaTransactionManagerTests {
 			JtaTransactionManager ptm = newJtaTransactionManager(ut);
 			TransactionTemplate tt = new TransactionTemplate(ptm);
 			tt.setIsolationLevel(TransactionDefinition.ISOLATION_SERIALIZABLE);
-			tt.execute(new TransactionCallbackWithoutResult() {
+			tt.executeWithoutResult(status -> {
-				@Override
+				// something transactional
-				protected void doInTransactionWithoutResult(TransactionStatus status) {
-					// something transactional
-				}
 			});
 		});
 	}
@@ -831,11 +740,8 @@ class JtaTransactionManagerTests {
 		assertThatExceptionOfType(TransactionSystemException.class).isThrownBy(() -> {
 			JtaTransactionManager ptm = newJtaTransactionManager(ut);
 			TransactionTemplate tt = new TransactionTemplate(ptm);
-			tt.execute(new TransactionCallbackWithoutResult() {
+			tt.executeWithoutResult(status -> {
-				@Override
+				// something transactional
-				protected void doInTransactionWithoutResult(TransactionStatus status) {
-					// something transactional
-				}
 			});
 		});
 	}
@@ -848,18 +754,15 @@ class JtaTransactionManagerTests {
 		JtaTransactionManager ptm = newJtaTransactionManager(ut);
 		TransactionTemplate tt = new TransactionTemplate(ptm);
 		tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_NESTED);
-		tt.execute(new TransactionCallbackWithoutResult() {
+		tt.executeWithoutResult(status -> {
-			@Override
+			// something transactional
-			protected void doInTransactionWithoutResult(TransactionStatus status) {
+			assertThat(status.getTransactionName()).isEmpty();
-				// something transactional
+			assertThat(status.hasTransaction()).isTrue();
-				assertThat(status.getTransactionName()).isEmpty();
+			assertThat(status.isNewTransaction()).isTrue();
-				assertThat(status.hasTransaction()).isTrue();
+			assertThat(status.isNested()).isTrue();
-				assertThat(status.isNewTransaction()).isTrue();
+			assertThat(status.isReadOnly()).isFalse();
-				assertThat(status.isNested()).isTrue();
+			assertThat(status.isRollbackOnly()).isFalse();
-				assertThat(status.isReadOnly()).isFalse();
+			assertThat(status.isCompleted()).isFalse();
-				assertThat(status.isRollbackOnly()).isFalse();
-				assertThat(status.isCompleted()).isFalse();
-			}
 		});
 
 		verify(ut).begin();
@@ -876,11 +779,8 @@ class JtaTransactionManagerTests {
 			JtaTransactionManager ptm = newJtaTransactionManager(ut);
 			TransactionTemplate tt = new TransactionTemplate(ptm);
 			tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_NESTED);
-			tt.execute(new TransactionCallbackWithoutResult() {
+			tt.executeWithoutResult(status -> {
-				@Override
+				// something transactional
-				protected void doInTransactionWithoutResult(TransactionStatus status) {
-					// something transactional
-				}
 			});
 		});
 	}
@@ -895,11 +795,8 @@ class JtaTransactionManagerTests {
 			JtaTransactionManager ptm = newJtaTransactionManager(ut);
 			TransactionTemplate tt = new TransactionTemplate(ptm);
 			tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_NESTED);
-			tt.execute(new TransactionCallbackWithoutResult() {
+			tt.executeWithoutResult(status -> {
-				@Override
+				// something transactional
-				protected void doInTransactionWithoutResult(TransactionStatus status) {
-					// something transactional
-				}
 			});
 		});
 	}
@@ -915,12 +812,8 @@ class JtaTransactionManagerTests {
 		ptm.addListener(tl);
 
 		assertThatExceptionOfType(CannotCreateTransactionException.class).isThrownBy(() -> {
-			TransactionTemplate tt = new TransactionTemplate(ptm);
+			new TransactionTemplate(ptm).executeWithoutResult(status -> {
-			tt.execute(new TransactionCallbackWithoutResult() {
+				// something transactional
-				@Override
-				protected void doInTransactionWithoutResult(TransactionStatus status) {
-					// something transactional
-				}
 			});
 		});
 
@@ -948,18 +841,15 @@ class JtaTransactionManagerTests {
 
 		assertThatExceptionOfType(UnexpectedRollbackException.class).isThrownBy(() -> {
 			TransactionTemplate tt = new TransactionTemplate(ptm);
-			tt.execute(new TransactionCallbackWithoutResult() {
+			tt.executeWithoutResult(status -> {
-				@Override
+				// something transactional
-				protected void doInTransactionWithoutResult(TransactionStatus status) {
+				TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronization() {
-					// something transactional
+					@Override
-					TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronization() {
+					public void afterCompletion(int status) {
-						@Override
+						assertThat(status).as("Correct completion status")
-						public void afterCompletion(int status) {
+								.isEqualTo(TransactionSynchronization.STATUS_ROLLED_BACK);
-							assertThat(status).as("Correct completion status")
+					}
-									.isEqualTo(TransactionSynchronization.STATUS_ROLLED_BACK);
+				});
-						}
-					});
-				}
 			});
 		});
 
@@ -1003,18 +893,15 @@ class JtaTransactionManagerTests {
 			assertThat(ts.isNewTransaction()).as("Is new transaction").isTrue();
 
 			TransactionTemplate tt = new TransactionTemplate(tm);
-			tt.execute(new TransactionCallbackWithoutResult() {
+			tt.executeWithoutResult(status -> {
-				@Override
+				// something transactional
-				protected void doInTransactionWithoutResult(TransactionStatus status) {
+				TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronization() {
-					// something transactional
+					@Override
-					TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronization() {
+					public void afterCompletion(int status) {
-						@Override
+						assertThat(status).as("Correct completion status")
-						public void afterCompletion(int status) {
+								.isEqualTo(TransactionSynchronization.STATUS_ROLLED_BACK);
-							assertThat(status).as("Correct completion status")
+					}
-									.isEqualTo(TransactionSynchronization.STATUS_ROLLED_BACK);
+				});
-						}
-					});
-				}
 			});
 
 			outerTransactionBoundaryReached = true;
@@ -1049,17 +936,15 @@ class JtaTransactionManagerTests {
 		assertThatExceptionOfType(HeuristicCompletionException.class).isThrownBy(() -> {
 			JtaTransactionManager ptm = newJtaTransactionManager(ut);
 			TransactionTemplate tt = new TransactionTemplate(ptm);
-			tt.execute(new TransactionCallbackWithoutResult() {
+			tt.executeWithoutResult(status -> {
-				@Override
+				// something transactional
-				protected void doInTransactionWithoutResult(TransactionStatus status) {
+				TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronization() {
-					// something transactional
+					@Override
-					TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronization() {
+					public void afterCompletion(int status) {
-						@Override
+						assertThat(status).as("Correct completion status")
-						public void afterCompletion(int status) {
+								.isEqualTo(TransactionSynchronization.STATUS_UNKNOWN);
-							assertThat(status == TransactionSynchronization.STATUS_UNKNOWN).as("Correct completion status").isTrue();
+					}
-						}
+				});
-					});
-				}
 			});
 		}).satisfies(ex -> assertThat(ex.getOutcomeState()).isEqualTo(HeuristicCompletionException.STATE_MIXED));
 
@@ -1076,17 +961,15 @@ class JtaTransactionManagerTests {
 		assertThatExceptionOfType(HeuristicCompletionException.class).isThrownBy(() -> {
 			JtaTransactionManager ptm = newJtaTransactionManager(ut);
 			TransactionTemplate tt = new TransactionTemplate(ptm);
-			tt.execute(new TransactionCallbackWithoutResult() {
+			tt.executeWithoutResult(status -> {
-				@Override
+				// something transactional
-				protected void doInTransactionWithoutResult(TransactionStatus status) {
+				TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronization() {
-					// something transactional
+					@Override
-					TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronization() {
+					public void afterCompletion(int status) {
-						@Override
+						assertThat(status).as("Correct completion status")
-						public void afterCompletion(int status) {
+								.isEqualTo(TransactionSynchronization.STATUS_UNKNOWN);
-							assertThat(status == TransactionSynchronization.STATUS_UNKNOWN).as("Correct completion status").isTrue();
+					}
-						}
+				});
-					});
-				}
 			});
 		}).satisfies(ex -> assertThat(ex.getOutcomeState()).isEqualTo(HeuristicCompletionException.STATE_ROLLED_BACK));
 
@@ -1106,18 +989,15 @@ class JtaTransactionManagerTests {
 
 		assertThatExceptionOfType(TransactionSystemException.class).isThrownBy(() -> {
 			TransactionTemplate tt = new TransactionTemplate(ptm);
-			tt.execute(new TransactionCallbackWithoutResult() {
+			tt.executeWithoutResult(status -> {
-				@Override
+				// something transactional
-				protected void doInTransactionWithoutResult(TransactionStatus status) {
+				TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronization() {
-					// something transactional
+					@Override
-					TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronization() {
+					public void afterCompletion(int status) {
-						@Override
+						assertThat(status).as("Correct completion status")
-						public void afterCompletion(int status) {
+								.isEqualTo(TransactionSynchronization.STATUS_UNKNOWN);
-							assertThat(status).as("Correct completion status")
+					}
-									.isEqualTo(TransactionSynchronization.STATUS_UNKNOWN);
+				});
-						}
-					});
-				}
 			});
 		});
 
@@ -1146,18 +1026,15 @@ class JtaTransactionManagerTests {
 
 		assertThatExceptionOfType(TransactionSystemException.class).isThrownBy(() -> {
 			TransactionTemplate tt = new TransactionTemplate(ptm);
-			tt.execute(new TransactionCallbackWithoutResult() {
+			tt.executeWithoutResult(status -> {
-				@Override
+				TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronization() {
-				protected void doInTransactionWithoutResult(TransactionStatus status) {
+					@Override
-					TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronization() {
+					public void afterCompletion(int status) {
-						@Override
+						assertThat(status).as("Correct completion status")
-						public void afterCompletion(int status) {
+								.isEqualTo(TransactionSynchronization.STATUS_UNKNOWN);
-							assertThat(status).as("Correct completion status")
+					}
-									.isEqualTo(TransactionSynchronization.STATUS_UNKNOWN);
+				});
-						}
+				status.setRollbackOnly();
-					});
-					status.setRollbackOnly();
-				}
 			});
 		});
 
@@ -1183,12 +1060,7 @@ class JtaTransactionManagerTests {
 		assertThatExceptionOfType(TransactionSystemException.class).isThrownBy(() -> {
 			JtaTransactionManager ptm = newJtaTransactionManager(ut);
 			TransactionTemplate tt = new TransactionTemplate(ptm);
-			tt.execute(new TransactionCallbackWithoutResult() {
+			tt.executeWithoutResult(TransactionExecution::setRollbackOnly);
-				@Override
-				protected void doInTransactionWithoutResult(TransactionStatus status) {
-					status.setRollbackOnly();
-				}
-			});
 		});
 	}
 
@@ -1201,18 +1073,15 @@ class JtaTransactionManagerTests {
 		assertThatExceptionOfType(TransactionSystemException.class).isThrownBy(() -> {
 			JtaTransactionManager ptm = newJtaTransactionManager(ut);
 			TransactionTemplate tt = new TransactionTemplate(ptm);
-			tt.execute(new TransactionCallbackWithoutResult() {
+			tt.executeWithoutResult(status -> {
-				@Override
+				status.setRollbackOnly();
-				protected void doInTransactionWithoutResult(TransactionStatus status) {
+				TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronization() {
-					status.setRollbackOnly();
+					@Override
-					TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronization() {
+					public void afterCompletion(int status) {
-						@Override
+						assertThat(status).as("Correct completion status")
-						public void afterCompletion(int status) {
+								.isEqualTo(TransactionSynchronization.STATUS_UNKNOWN);
-							assertThat(status).as("Correct completion status")
+					}
-									.isEqualTo(TransactionSynchronization.STATUS_UNKNOWN);
+				});
-						}
-					});
-				}
 			});
 		});
 	}

spring-tx/src/test/java/org/springframework/transaction/support/TransactionSupportTests.java

@@ -233,6 +233,7 @@ class TransactionSupportTests {
 	}
 
 	@Test
+	@SuppressWarnings("deprecation")
 	void transactionTemplate() {
 		TestTransactionManager tm = new TestTransactionManager(false, true);
 		TransactionTemplate template = new TransactionTemplate(tm);
@@ -249,6 +250,7 @@ class TransactionSupportTests {
 	}
 
 	@Test
+	@SuppressWarnings("deprecation")
 	void transactionTemplateWithCallbackPreference() {
 		MockCallbackPreferringTransactionManager ptm = new MockCallbackPreferringTransactionManager();
 		TransactionTemplate template = new TransactionTemplate(ptm);
@@ -263,6 +265,7 @@ class TransactionSupportTests {
 	}
 
 	@Test
+	@SuppressWarnings("deprecation")
 	void transactionTemplateWithException() {
 		TestTransactionManager tm = new TestTransactionManager(false, true);
 		TransactionTemplate template = new TransactionTemplate(tm);
@@ -281,10 +284,10 @@ class TransactionSupportTests {
 		assertThat(tm.rollbackOnly).as("no rollbackOnly").isFalse();
 	}
 
-	@SuppressWarnings("serial")
 	@Test
 	void transactionTemplateWithRollbackException() {
 		final TransactionSystemException tex = new TransactionSystemException("system exception");
+		@SuppressWarnings("serial")
 		TestTransactionManager tm = new TestTransactionManager(false, true) {
 			@Override
 			protected void doRollback(DefaultTransactionStatus status) {