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,17 +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() {
-				@Override
-				protected void doInTransactionWithoutResult(TransactionStatus status) {
+				tt.executeWithoutResult(status -> {
 					// something transactional
-				}
 				}));
 
 		assertThat(TransactionSynchronizationManager.hasResource(ds)).isFalse();
@@ -71,18 +66,15 @@ class JdbcTransactionManagerTests extends DataSourceTransactionManagerTests {
 	}
 
 	@Test
-	void testTransactionWithDataAccessExceptionOnCommit() 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.execute(new TransactionCallbackWithoutResult() {
-					@Override
-					protected void doInTransactionWithoutResult(TransactionStatus status) {
+				tt.executeWithoutResult(status -> {
 					// something transactional
-					}
 				}));
 
 		assertThat(TransactionSynchronizationManager.hasResource(ds)).isFalse();
@@ -90,17 +82,14 @@ class JdbcTransactionManagerTests extends DataSourceTransactionManagerTests {
 	}
 
 	@Test
-	void testTransactionWithDataAccessExceptionOnCommitFromLazyExceptionTranslator() throws Exception {
+	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() {
-					@Override
-					protected void doInTransactionWithoutResult(TransactionStatus status) {
+				tt.executeWithoutResult(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,11 +106,8 @@ class JdbcTransactionManagerTests extends DataSourceTransactionManagerTests {
 
 		// plain TransactionSystemException
 		assertThatExceptionOfType(TransactionSystemException.class).isThrownBy(() ->
-				tt.execute(new TransactionCallbackWithoutResult() {
-				@Override
-				protected void doInTransactionWithoutResult(TransactionStatus status) {
+				tt.executeWithoutResult(status -> {
 					// something transactional
-				}
 				}));
 
 		assertThat(TransactionSynchronizationManager.hasResource(ds)).isFalse();
@@ -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() {
-				@Override
-				protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException {
+				tt.executeWithoutResult(status -> {
 					assertThat(status.getTransactionName()).isEmpty();
 					assertThat(status.hasTransaction()).isTrue();
 					assertThat(status.isNewTransaction()).isTrue();
@@ -151,7 +135,6 @@ class JdbcTransactionManagerTests extends DataSourceTransactionManagerTests {
 					status.setRollbackOnly();
 					assertThat(status.isRollbackOnly()).isTrue();
 					assertThat(status.isCompleted()).isFalse();
-				}
 				}));
 
 		assertThat(TransactionSynchronizationManager.hasResource(ds)).isFalse();
@@ -163,7 +146,7 @@ class JdbcTransactionManagerTests extends DataSourceTransactionManagerTests {
 	}
 
 	@Test
-	void testTransactionWithDataAccessExceptionOnRollback() 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));
@@ -171,12 +154,7 @@ class JdbcTransactionManagerTests extends DataSourceTransactionManagerTests {
 
 		// specific ConcurrencyFailureException
 		assertThatExceptionOfType(ConcurrencyFailureException.class).isThrownBy(() ->
-				tt.execute(new TransactionCallbackWithoutResult() {
-					@Override
-					protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException {
-						status.setRollbackOnly();
-					}
-				}));
+				tt.executeWithoutResult(status -> status.setRollbackOnly()));
 
 		assertThat(TransactionSynchronizationManager.hasResource(ds)).isFalse();
 		InOrder ordered = inOrder(con);
@@ -187,16 +165,14 @@ class JdbcTransactionManagerTests extends DataSourceTransactionManagerTests {
 	}
 
 	@Test
-	void testTransactionWithDataAccessExceptionOnRollbackFromLazyExceptionTranslator() throws Exception {
+	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() {
-					@Override
-					protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException {
+				tt.executeWithoutResult(status -> {
 					assertThat(status.getTransactionName()).isEmpty();
 					assertThat(status.hasTransaction()).isTrue();
 					assertThat(status.isNewTransaction()).isTrue();
@@ -207,7 +183,6 @@ class JdbcTransactionManagerTests extends DataSourceTransactionManagerTests {
 					status.setRollbackOnly();
 					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() {
-			@Override
-			protected void doInTransactionWithoutResult(TransactionStatus status) {
+		tt.executeWithoutResult(status -> {
 			// something transactional
 			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() {
-			@Override
-			protected void doInTransactionWithoutResult(TransactionStatus status) {
+		tt.executeWithoutResult(status -> {
 			// something transactional
 			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() {
-			@Override
-			protected void doInTransactionWithoutResult(TransactionStatus status) {
+		tt.executeWithoutResult(status -> {
 			// something transactional
 			assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
 			assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
-			}
 		});
 
 		ptm.setJndiTemplate(new ExpectedLookupTemplate("java:comp/UserTransaction", ut2));
-		tt.execute(new TransactionCallbackWithoutResult() {
-			@Override
-			protected void doInTransactionWithoutResult(TransactionStatus status) {
+		tt.executeWithoutResult(status -> {
 			// something transactional
 			assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
 			assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
-			}
 		});
-		boolean condition = !TransactionSynchronizationManager.isSynchronizationActive();
-		assertThat(condition).isTrue();
+		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
 		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,9 +68,7 @@ class JtaTransactionManagerTests {
 		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
 		assertThat(TransactionSynchronizationManager.getCurrentTransactionName()).isNull();
 		assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
-		tt.execute(new TransactionCallbackWithoutResult() {
-			@Override
-			protected void doInTransactionWithoutResult(TransactionStatus status) {
+		tt.executeWithoutResult(status -> {
 			// something transactional
 			assertThat(status.getTransactionName()).isEqualTo("txName");
 			assertThat(status.hasTransaction()).isTrue();
@@ -84,7 +81,6 @@ class JtaTransactionManagerTests {
 			assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
 			assertThat(status.isRollbackOnly()).isFalse();
 			assertThat(status.isCompleted()).isFalse();
-			}
 		});
 		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
 		assertThat(TransactionSynchronizationManager.getCurrentTransactionName()).isNull();
@@ -109,9 +105,7 @@ class JtaTransactionManagerTests {
 		TransactionTemplate tt = new TransactionTemplate(ptm);
 		ptm.setTransactionSynchronization(JtaTransactionManager.SYNCHRONIZATION_ON_ACTUAL_TRANSACTION);
 		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
-		tt.execute(new TransactionCallbackWithoutResult() {
-			@Override
-			protected void doInTransactionWithoutResult(TransactionStatus status) {
+		tt.executeWithoutResult(status -> {
 			// something transactional
 			assertThat(status.getTransactionName()).isEmpty();
 			assertThat(status.hasTransaction()).isTrue();
@@ -122,7 +116,6 @@ class JtaTransactionManagerTests {
 			TransactionSynchronizationManager.registerSynchronization(synch);
 			assertThat(status.isRollbackOnly()).isFalse();
 			assertThat(status.isCompleted()).isFalse();
-			}
 		});
 		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
 
@@ -146,9 +139,7 @@ class JtaTransactionManagerTests {
 		ptm.afterPropertiesSet();
 
 		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
-		tt.execute(new TransactionCallbackWithoutResult() {
-			@Override
-			protected void doInTransactionWithoutResult(TransactionStatus status) {
+		tt.executeWithoutResult(status -> {
 			assertThat(status.getTransactionName()).isEmpty();
 			assertThat(status.hasTransaction()).isTrue();
 			assertThat(status.isNewTransaction()).isTrue();
@@ -157,7 +148,6 @@ class JtaTransactionManagerTests {
 			assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
 			assertThat(status.isRollbackOnly()).isFalse();
 			assertThat(status.isCompleted()).isFalse();
-			}
 		});
 		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
 
@@ -179,9 +169,7 @@ class JtaTransactionManagerTests {
 		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
 		assertThat(TransactionSynchronizationManager.getCurrentTransactionName()).isNull();
 		assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
-		tt.execute(new TransactionCallbackWithoutResult() {
-			@Override
-			protected void doInTransactionWithoutResult(TransactionStatus status) {
+		tt.executeWithoutResult(status -> {
 			assertThat(status.getTransactionName()).isEqualTo("txName");
 			assertThat(status.hasTransaction()).isTrue();
 			assertThat(status.isNewTransaction()).isTrue();
@@ -194,7 +182,6 @@ class JtaTransactionManagerTests {
 			status.setRollbackOnly();
 			assertThat(status.isRollbackOnly()).isTrue();
 			assertThat(status.isCompleted()).isFalse();
-			}
 		});
 		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
 		assertThat(TransactionSynchronizationManager.getCurrentTransactionName()).isNull();
@@ -218,9 +205,7 @@ class JtaTransactionManagerTests {
 		ptm.setTransactionSynchronization(JtaTransactionManager.SYNCHRONIZATION_ON_ACTUAL_TRANSACTION);
 		tt.setTimeout(10);
 		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
-		tt.execute(new TransactionCallbackWithoutResult() {
-			@Override
-			protected void doInTransactionWithoutResult(TransactionStatus status) {
+		tt.executeWithoutResult(status -> {
 			assertThat(status.getTransactionName()).isEmpty();
 			assertThat(status.hasTransaction()).isTrue();
 			assertThat(status.isNewTransaction()).isTrue();
@@ -231,7 +216,6 @@ class JtaTransactionManagerTests {
 			status.setRollbackOnly();
 			assertThat(status.isRollbackOnly()).isTrue();
 			assertThat(status.isCompleted()).isFalse();
-			}
 		});
 		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
 
@@ -254,9 +238,7 @@ class JtaTransactionManagerTests {
 		ptm.afterPropertiesSet();
 
 		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
-		tt.execute(new TransactionCallbackWithoutResult() {
-			@Override
-			protected void doInTransactionWithoutResult(TransactionStatus status) {
+		tt.executeWithoutResult(status -> {
 			assertThat(status.getTransactionName()).isEmpty();
 			assertThat(status.hasTransaction()).isTrue();
 			assertThat(status.isNewTransaction()).isTrue();
@@ -267,7 +249,6 @@ class JtaTransactionManagerTests {
 			status.setRollbackOnly();
 			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() {
-			@Override
-			protected void doInTransactionWithoutResult(TransactionStatus status) {
+		tt.executeWithoutResult(status -> {
 			assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
 			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() {
-				@Override
-				protected void doInTransactionWithoutResult(TransactionStatus status) {
+			tt.executeWithoutResult(status -> {
 				assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
 				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() {
-				@Override
-				protected void doInTransactionWithoutResult(TransactionStatus status) {
+			tt.executeWithoutResult(status -> {
 				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() {
-			@Override
-			protected void doInTransactionWithoutResult(TransactionStatus status) {
+		tt.executeWithoutResult(status -> {
 			assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
 			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() {
-				@Override
-				protected void doInTransactionWithoutResult(TransactionStatus status) {
+			tt.executeWithoutResult(status -> {
 				assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
 				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() {
-			@Override
-			protected void doInTransactionWithoutResult(TransactionStatus status) {
+		tt.executeWithoutResult(status -> {
 			assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
 			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() {
-			@Override
-			protected void doInTransactionWithoutResult(TransactionStatus status) {
+		tt.executeWithoutResult(status -> {
 			assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
 			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() {
-			@Override
-			protected void doInTransactionWithoutResult(TransactionStatus status) {
+		tt.executeWithoutResult(status -> {
 			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() {
-			@Override
-			protected void doInTransactionWithoutResult(TransactionStatus status) {
+		tt.executeWithoutResult(status -> {
 			assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
 			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() {
-			@Override
-			protected void doInTransactionWithoutResult(TransactionStatus status) {
+		tt.executeWithoutResult(status -> {
 			assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
 			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() {
-			@Override
-			protected void doInTransactionWithoutResult(TransactionStatus status) {
+		tt.executeWithoutResult(status -> {
 			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() {
-			@Override
-			protected void doInTransactionWithoutResult(TransactionStatus status) {
+		tt.executeWithoutResult(status -> {
 			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() {
-			@Override
-			protected void doInTransactionWithoutResult(TransactionStatus status) {
+		tt.executeWithoutResult(status -> {
 			assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
 			status.setRollbackOnly();
-			}
 		});
 		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
 
@@ -621,9 +563,7 @@ class JtaTransactionManagerTests {
 		tt.setName("txName");
 
 		assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
-		tt.execute(new TransactionCallbackWithoutResult() {
-			@Override
-			protected void doInTransactionWithoutResult(TransactionStatus status) {
+		tt.executeWithoutResult(status1 -> {
 			assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
 			assertThat(TransactionSynchronizationManager.getCurrentTransactionName()).isEqualTo("txName");
 			assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
@@ -632,19 +572,15 @@ class JtaTransactionManagerTests {
 			tt2.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
 			tt2.setReadOnly(true);
 			tt2.setName("txName2");
-				tt2.execute(new TransactionCallbackWithoutResult() {
-					@Override
-					protected void doInTransactionWithoutResult(TransactionStatus status) {
+			tt2.executeWithoutResult(status2 -> {
 				assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
 				assertThat(TransactionSynchronizationManager.getCurrentTransactionName()).isEqualTo("txName2");
 				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() {
-			@Override
-			protected void doInTransactionWithoutResult(TransactionStatus status) {
+		tt.executeWithoutResult(status1 -> {
 			assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
 			assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
 			assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
 
 			TransactionTemplate tt2 = new TransactionTemplate(ptm);
 			tt2.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
-				tt2.execute(new TransactionCallbackWithoutResult() {
-					@Override
-					protected void doInTransactionWithoutResult(TransactionStatus status) {
+			tt2.executeWithoutResult(status2 -> {
 				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() {
-			@Override
-			protected void doInTransactionWithoutResult(TransactionStatus status) {
-				assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
-			}
-		});
+		tt.executeWithoutResult(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() {
-				@Override
-				protected void doInTransactionWithoutResult(TransactionStatus status) {
-					assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
-				}
-			}));
+			tt.executeWithoutResult(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() {
-				@Override
-				protected void doInTransactionWithoutResult(TransactionStatus status) {
-					assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
-				}
-			}));
+			tt.executeWithoutResult(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() {
-			@Override
-			protected void doInTransactionWithoutResult(TransactionStatus status) {
-				assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
-			}
-		});
+		tt.executeWithoutResult(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() {
-				@Override
-				protected void doInTransactionWithoutResult(TransactionStatus status) {
-				}
+			tt.executeWithoutResult(status -> {
+				// something transactional
 			}));
 		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() {
-				@Override
-				protected void doInTransactionWithoutResult(TransactionStatus status) {
+			tt.executeWithoutResult(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() {
-				@Override
-				protected void doInTransactionWithoutResult(TransactionStatus status) {
+			tt.executeWithoutResult(status -> {
 				// something transactional
-				}
 			});
 		});
 	}
@@ -848,9 +754,7 @@ class JtaTransactionManagerTests {
 		JtaTransactionManager ptm = newJtaTransactionManager(ut);
 		TransactionTemplate tt = new TransactionTemplate(ptm);
 		tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_NESTED);
-		tt.execute(new TransactionCallbackWithoutResult() {
-			@Override
-			protected void doInTransactionWithoutResult(TransactionStatus status) {
+		tt.executeWithoutResult(status -> {
 			// something transactional
 			assertThat(status.getTransactionName()).isEmpty();
 			assertThat(status.hasTransaction()).isTrue();
@@ -859,7 +763,6 @@ class JtaTransactionManagerTests {
 			assertThat(status.isReadOnly()).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() {
-				@Override
-				protected void doInTransactionWithoutResult(TransactionStatus status) {
+			tt.executeWithoutResult(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() {
-				@Override
-				protected void doInTransactionWithoutResult(TransactionStatus status) {
+			tt.executeWithoutResult(status -> {
 				// something transactional
-				}
 			});
 		});
 	}
@@ -915,12 +812,8 @@ class JtaTransactionManagerTests {
 		ptm.addListener(tl);
 
 		assertThatExceptionOfType(CannotCreateTransactionException.class).isThrownBy(() -> {
-			TransactionTemplate tt = new TransactionTemplate(ptm);
-			tt.execute(new TransactionCallbackWithoutResult() {
-				@Override
-				protected void doInTransactionWithoutResult(TransactionStatus status) {
+			new TransactionTemplate(ptm).executeWithoutResult(status -> {
 				// something transactional
-				}
 			});
 		});
 
@@ -948,9 +841,7 @@ class JtaTransactionManagerTests {
 
 		assertThatExceptionOfType(UnexpectedRollbackException.class).isThrownBy(() -> {
 			TransactionTemplate tt = new TransactionTemplate(ptm);
-			tt.execute(new TransactionCallbackWithoutResult() {
-				@Override
-				protected void doInTransactionWithoutResult(TransactionStatus status) {
+			tt.executeWithoutResult(status -> {
 				// something transactional
 				TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronization() {
 					@Override
@@ -959,7 +850,6 @@ class JtaTransactionManagerTests {
 								.isEqualTo(TransactionSynchronization.STATUS_ROLLED_BACK);
 					}
 				});
-				}
 			});
 		});
 
@@ -1003,9 +893,7 @@ class JtaTransactionManagerTests {
 			assertThat(ts.isNewTransaction()).as("Is new transaction").isTrue();
 
 			TransactionTemplate tt = new TransactionTemplate(tm);
-			tt.execute(new TransactionCallbackWithoutResult() {
-				@Override
-				protected void doInTransactionWithoutResult(TransactionStatus status) {
+			tt.executeWithoutResult(status -> {
 				// something transactional
 				TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronization() {
 					@Override
@@ -1014,7 +902,6 @@ class JtaTransactionManagerTests {
 								.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() {
-				@Override
-				protected void doInTransactionWithoutResult(TransactionStatus status) {
+			tt.executeWithoutResult(status -> {
 				// something transactional
 				TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronization() {
 					@Override
 					public void afterCompletion(int status) {
-							assertThat(status == TransactionSynchronization.STATUS_UNKNOWN).as("Correct completion status").isTrue();
+						assertThat(status).as("Correct completion status")
+								.isEqualTo(TransactionSynchronization.STATUS_UNKNOWN);
 					}
 				});
-				}
 			});
 		}).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() {
-				@Override
-				protected void doInTransactionWithoutResult(TransactionStatus status) {
+			tt.executeWithoutResult(status -> {
 				// something transactional
 				TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronization() {
 					@Override
 					public void afterCompletion(int status) {
-							assertThat(status == TransactionSynchronization.STATUS_UNKNOWN).as("Correct completion status").isTrue();
+						assertThat(status).as("Correct completion status")
+								.isEqualTo(TransactionSynchronization.STATUS_UNKNOWN);
 					}
 				});
-				}
 			});
 		}).satisfies(ex -> assertThat(ex.getOutcomeState()).isEqualTo(HeuristicCompletionException.STATE_ROLLED_BACK));
 
@@ -1106,9 +989,7 @@ class JtaTransactionManagerTests {
 
 		assertThatExceptionOfType(TransactionSystemException.class).isThrownBy(() -> {
 			TransactionTemplate tt = new TransactionTemplate(ptm);
-			tt.execute(new TransactionCallbackWithoutResult() {
-				@Override
-				protected void doInTransactionWithoutResult(TransactionStatus status) {
+			tt.executeWithoutResult(status -> {
 				// something transactional
 				TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronization() {
 					@Override
@@ -1117,7 +998,6 @@ class JtaTransactionManagerTests {
 								.isEqualTo(TransactionSynchronization.STATUS_UNKNOWN);
 					}
 				});
-				}
 			});
 		});
 
@@ -1146,9 +1026,7 @@ class JtaTransactionManagerTests {
 
 		assertThatExceptionOfType(TransactionSystemException.class).isThrownBy(() -> {
 			TransactionTemplate tt = new TransactionTemplate(ptm);
-			tt.execute(new TransactionCallbackWithoutResult() {
-				@Override
-				protected void doInTransactionWithoutResult(TransactionStatus status) {
+			tt.executeWithoutResult(status -> {
 				TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronization() {
 					@Override
 					public void afterCompletion(int status) {
@@ -1157,7 +1035,6 @@ class JtaTransactionManagerTests {
 					}
 				});
 				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() {
-				@Override
-				protected void doInTransactionWithoutResult(TransactionStatus status) {
-					status.setRollbackOnly();
-				}
-			});
+			tt.executeWithoutResult(TransactionExecution::setRollbackOnly);
 		});
 	}
 
@@ -1201,9 +1073,7 @@ class JtaTransactionManagerTests {
 		assertThatExceptionOfType(TransactionSystemException.class).isThrownBy(() -> {
 			JtaTransactionManager ptm = newJtaTransactionManager(ut);
 			TransactionTemplate tt = new TransactionTemplate(ptm);
-			tt.execute(new TransactionCallbackWithoutResult() {
-				@Override
-				protected void doInTransactionWithoutResult(TransactionStatus status) {
+			tt.executeWithoutResult(status -> {
 				status.setRollbackOnly();
 				TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronization() {
 					@Override
@@ -1212,7 +1082,6 @@ class JtaTransactionManagerTests {
 								.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) {