Polishing in tests of ThreadLocalAccessor implementations

See gh-32296

spring-context/src/test/java/org/springframework/context/i18n/LocaleContextThreadLocalAccessorTests.java

@@ -17,72 +17,71 @@
 package org.springframework.context.i18n;
 
 import java.util.Locale;
-import java.util.concurrent.CountDownLatch;
-import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicReference;
 import java.util.stream.Stream;
 
 import io.micrometer.context.ContextRegistry;
 import io.micrometer.context.ContextSnapshot;
 import io.micrometer.context.ContextSnapshotFactory;
-import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.Arguments;
 import org.junit.jupiter.params.provider.MethodSource;
 
-import org.springframework.lang.Nullable;
-
 import static org.assertj.core.api.Assertions.assertThat;
 
 /**
  * Tests for {@link LocaleContextThreadLocalAccessor}.
  *
  * @author Tadaya Tsuyukubo
+ * @author Rossen Stoyanchev
  */
 class LocaleContextThreadLocalAccessorTests {
 
-	private final ContextRegistry registry = new ContextRegistry()
+	private final ContextRegistry registry =
-			.registerThreadLocalAccessor(new LocaleContextThreadLocalAccessor());
+			new ContextRegistry().registerThreadLocalAccessor(new LocaleContextThreadLocalAccessor());
+
 
-	@AfterEach
+	private static Stream<Arguments> propagation() {
-	void cleanUp() {
+		LocaleContext previousContext = new SimpleLocaleContext(Locale.ENGLISH);
-		LocaleContextHolder.resetLocaleContext();
+		LocaleContext currentContext = new SimpleLocaleContext(Locale.ENGLISH);
+		return Stream.of(Arguments.of(null, currentContext), Arguments.of(previousContext, currentContext));
 	}
 
 	@ParameterizedTest
 	@MethodSource
-	@SuppressWarnings("try")
+	@SuppressWarnings({ "try", "unused" })
-	void propagation(@Nullable LocaleContext previous, LocaleContext current) throws Exception {
+	void propagation(LocaleContext previousContext, LocaleContext currentContext) throws Exception {
-		LocaleContextHolder.setLocaleContext(current);
+
-		ContextSnapshot snapshot = ContextSnapshotFactory.builder()
+		ContextSnapshot snapshot = createContextSnapshotFor(currentContext);
-				.contextRegistry(this.registry)
+
-				.clearMissing(true)
+		AtomicReference<LocaleContext> contextInScope = new AtomicReference<>();
-				.build()
+		AtomicReference<LocaleContext> contextAfterScope = new AtomicReference<>();
-				.captureAll();
+
-
+		Thread thread = new Thread(() -> {
-		AtomicReference<LocaleContext> previousHolder = new AtomicReference<>();
+			LocaleContextHolder.setLocaleContext(previousContext);
-		AtomicReference<LocaleContext> currentHolder = new AtomicReference<>();
-		CountDownLatch latch = new CountDownLatch(1);
-		new Thread(() -> {
-			LocaleContextHolder.setLocaleContext(previous);
 			try (ContextSnapshot.Scope scope = snapshot.setThreadLocals()) {
-				currentHolder.set(LocaleContextHolder.getLocaleContext());
+				contextInScope.set(LocaleContextHolder.getLocaleContext());
 			}
-			previousHolder.set(LocaleContextHolder.getLocaleContext());
+			contextAfterScope.set(LocaleContextHolder.getLocaleContext());
-			latch.countDown();
+		});
-		}).start();
+
+		thread.start();
+		thread.join(1000);
 
-		latch.await(1, TimeUnit.SECONDS);
+		assertThat(contextAfterScope).hasValueSatisfying(value -> assertThat(value).isSameAs(previousContext));
-		assertThat(previousHolder).hasValueSatisfying(value -> assertThat(value).isSameAs(previous));
+		assertThat(contextInScope).hasValueSatisfying(value -> assertThat(value).isSameAs(currentContext));
-		assertThat(currentHolder).hasValueSatisfying(value -> assertThat(value).isSameAs(current));
 	}
 
-	private static Stream<Arguments> propagation() {
+	private ContextSnapshot createContextSnapshotFor(LocaleContext context) {
-		LocaleContext previous = new SimpleLocaleContext(Locale.ENGLISH);
+		LocaleContextHolder.setLocaleContext(context);
-		LocaleContext current = new SimpleLocaleContext(Locale.ENGLISH);
+		try {
-		return Stream.of(
+			return ContextSnapshotFactory.builder()
-				Arguments.of(null, current),
+					.contextRegistry(this.registry).clearMissing(true).build()
-				Arguments.of(previous, current)
+					.captureAll();
-		);
+		}
+		finally {
+			LocaleContextHolder.resetLocaleContext();
+		}
 	}
+
 }

spring-web/src/test/java/org/springframework/web/context/request/RequestAttributesThreadLocalAccessorTests.java

@@ -16,8 +16,6 @@
 
 package org.springframework.web.context.request;
 
-import java.util.concurrent.CountDownLatch;
-import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicReference;
 import java.util.stream.Stream;
 
@@ -25,13 +23,10 @@ import io.micrometer.context.ContextRegistry;
 import io.micrometer.context.ContextSnapshot;
 import io.micrometer.context.ContextSnapshot.Scope;
 import io.micrometer.context.ContextSnapshotFactory;
-import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.Arguments;
 import org.junit.jupiter.params.provider.MethodSource;
 
-import org.springframework.lang.Nullable;
-
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.mockito.Mockito.mock;
 
@@ -39,52 +34,55 @@ import static org.mockito.Mockito.mock;
  * Tests for {@link RequestAttributesThreadLocalAccessor}.
  *
  * @author Tadaya Tsuyukubo
+ * @author Rossen Stoyanchev
  */
 class RequestAttributesThreadLocalAccessorTests {
 
-	private final ContextRegistry registry = new ContextRegistry()
+	private final ContextRegistry registry =
-			.registerThreadLocalAccessor(new RequestAttributesThreadLocalAccessor());
+			new ContextRegistry().registerThreadLocalAccessor(new RequestAttributesThreadLocalAccessor());
+
 
-	@AfterEach
+	private static Stream<Arguments> propagation() {
-	void cleanUp() {
+		RequestAttributes previous = mock(RequestAttributes.class);
-		RequestContextHolder.resetRequestAttributes();
+		RequestAttributes current = mock(RequestAttributes.class);
+		return Stream.of(Arguments.of(null, current), Arguments.of(previous, current));
 	}
 
 	@ParameterizedTest
 	@MethodSource
 	@SuppressWarnings({ "try", "unused" })
-	void propagation(@Nullable RequestAttributes previous, RequestAttributes current) throws Exception {
+	void propagation(RequestAttributes previousRequest, RequestAttributes currentRequest) throws Exception {
-		RequestContextHolder.setRequestAttributes(current);
+
-		ContextSnapshot snapshot = ContextSnapshotFactory.builder()
+		ContextSnapshot snapshot = getSnapshotFor(currentRequest);
-				.contextRegistry(this.registry)
+
-				.clearMissing(true)
+		AtomicReference<RequestAttributes> requestInScope = new AtomicReference<>();
-				.build()
+		AtomicReference<RequestAttributes> requestAfterScope = new AtomicReference<>();
-				.captureAll();
+
-
+		Thread thread = new Thread(() -> {
-		AtomicReference<RequestAttributes> previousHolder = new AtomicReference<>();
+			RequestContextHolder.setRequestAttributes(previousRequest);
-		AtomicReference<RequestAttributes> currentHolder = new AtomicReference<>();
-		CountDownLatch latch = new CountDownLatch(1);
-		new Thread(() -> {
-			RequestContextHolder.setRequestAttributes(previous);
 			try (Scope scope = snapshot.setThreadLocals()) {
-				currentHolder.set(RequestContextHolder.getRequestAttributes());
+				requestInScope.set(RequestContextHolder.getRequestAttributes());
 			}
-			previousHolder.set(RequestContextHolder.getRequestAttributes());
+			requestAfterScope.set(RequestContextHolder.getRequestAttributes());
-			latch.countDown();
+		});
-		}).start();
+
+		thread.start();
+		thread.join(1000);
 
-		latch.await(1, TimeUnit.SECONDS);
+		assertThat(requestInScope).hasValueSatisfying(value -> assertThat(value).isSameAs(currentRequest));
-		assertThat(previousHolder).hasValueSatisfying(value -> assertThat(value).isSameAs(previous));
+		assertThat(requestAfterScope).hasValueSatisfying(value -> assertThat(value).isSameAs(previousRequest));
-		assertThat(currentHolder).hasValueSatisfying(value -> assertThat(value).isSameAs(current));
 	}
 
-	private static Stream<Arguments> propagation() {
+	private ContextSnapshot getSnapshotFor(RequestAttributes request) {
-		RequestAttributes previous = mock(RequestAttributes.class);
+		RequestContextHolder.setRequestAttributes(request);
-		RequestAttributes current = mock(RequestAttributes.class);
+		try {
-		return Stream.of(
+			return ContextSnapshotFactory.builder()
-				Arguments.of(null, current),
+					.contextRegistry(this.registry).clearMissing(true).build()
-				Arguments.of(previous, current)
+					.captureAll();
-		);
+		}
+		finally {
+			RequestContextHolder.resetRequestAttributes();
+		}
 	}
 
 }