Extend and improve some test cases

spring-beans/src/test/java/org/springframework/beans/factory/BeanFactoryUtilsTests.java

@@ -43,6 +43,7 @@
 import org.springframework.util.ObjectUtils;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
 import static org.springframework.core.testfixture.io.ResourceTestUtils.qualifiedResource;
 
 /**
@@ -171,6 +172,41 @@ void testFindsBeansOfTypeWithStaticFactory() {
 		assertThat(beans.get("&t4")).isEqualTo(t4);
 	}
 
+	@Test
+	void testBeanOfType_GivenSingleBean_ThenReturnsBean() {
+		StaticListableBeanFactory lbf = new StaticListableBeanFactory();
+		TestBean t1 = new TestBean();
+		lbf.addBean("t1", t1);
+
+		ITestBean actual = BeanFactoryUtils.beanOfType(lbf, ITestBean.class);
+
+		assertThat(actual).isSameAs(t1);
+	}
+
+	@Test
+	void testBeanOfType_GivenMultipleBeans_ThenThrowsException() {
+		StaticListableBeanFactory lbf = new StaticListableBeanFactory();
+		TestBean t1 = new TestBean();
+		TestBean t2 = new TestBean();
+		DummyFactory t3 = new DummyFactory();
+		lbf.addBean("t1", t1);
+		lbf.addBean("t2", t2);
+		lbf.addBean("t3", t3);
+
+		assertThatExceptionOfType(NoUniqueBeanDefinitionException.class)
+				.isThrownBy(() -> BeanFactoryUtils.beanOfType(lbf, ITestBean.class))
+				.withMessage("No qualifying bean of type 'org.springframework.beans.testfixture.beans.ITestBean' available: expected single matching bean but found 3: t1,t2,t3");
+	}
+
+	@Test
+	void testBeanOfType_GivenBeanDoesNotExist_ThenThrowsException() {
+		StaticListableBeanFactory lbf = new StaticListableBeanFactory();
+
+		assertThatExceptionOfType(NoSuchBeanDefinitionException.class)
+				.isThrownBy(() -> BeanFactoryUtils.beanOfType(lbf, ITestBean.class))
+				.withMessage("No qualifying bean of type 'org.springframework.beans.testfixture.beans.ITestBean' available");
+	}
+
 	@Test
 	void testFindsBeansOfTypeWithDefaultFactory() {
 		Object test3 = this.listableBeanFactory.getBean("test3");

spring-core/src/test/java/org/springframework/util/AssertTests.java

@@ -109,6 +109,12 @@ void isNullWithMessage() {
 		Assert.isNull(null, "Bla");
 	}
 
+	@Test
+	void isNullWithNonNullObject() {
+		assertThatIllegalArgumentException().isThrownBy(() -> Assert.isNull("foo", "Bla"))
+				.withMessage("Bla");
+	}
+
 	@Test
 	void isNullWithMessageSupplier() {
 		Assert.isNull(null, () -> "enigma");

spring-core/src/test/java/org/springframework/util/CollectionUtilsTests.java

@@ -116,9 +116,9 @@ void containsWithEnumeration() {
 		assertThat(CollectionUtils.contains(Collections.enumeration(List.of()), "myElement")).isFalse();
 
 		List<String> list = Arrays.asList("myElement", null);
-		Enumeration<String> enumeration = Collections.enumeration(list);
-		assertThat(CollectionUtils.contains(enumeration, "myElement")).isTrue();
-		assertThat(CollectionUtils.contains(enumeration, null)).isTrue();
+		assertThat(CollectionUtils.contains(Collections.enumeration(list), "myElement")).isTrue();
+		assertThat(CollectionUtils.contains(Collections.enumeration(list), null)).isTrue();
+		assertThat(CollectionUtils.contains(Collections.enumeration(list), "nonExistingElement")).isFalse();
 	}
 
 	@Test

spring-core/src/test/java/org/springframework/util/ExponentialBackOffTests.java

@@ -81,7 +81,7 @@ void maxIntervalReached() {
 	}
 
 	@Test
-	void maxAttemptsReached() {
+	void maxElapsedTimeReached() {
 		ExponentialBackOff backOff = new ExponentialBackOff(2000L, 2.0);
 		backOff.setMaxElapsedTime(4000L);
 
@@ -162,4 +162,49 @@ void maxAttempts() {
 		assertThat(delays).containsExactly(1000L, 2000L, 4000L, 8000L, 10000L, 10000L, BackOffExecution.STOP);
 	}
 
+	@Test
+	void withJitter_ThenJitterIsApplied() {
+		// GIVEN
+		ExponentialBackOff backOff = new ExponentialBackOff();
+		backOff.setInitialInterval(1000L);
+		backOff.setJitter(100L);
+		backOff.setMaxInterval(20000L);
+		backOff.setMultiplier(2.0);
+
+		BackOffExecution execution = backOff.start();
+
+		// WHEN
+		List<Long> delays = IntStream.range(0, 7).mapToObj(i -> execution.nextBackOff()).toList();
+
+		// THEN
+		assertThat(delays).hasSize(7);
+		assertThat(delays)
+				.withFailMessage("Jitter was not applied")
+				.isNotEqualTo(List.of(1000L, 2000L, 4000L, 8000L, 16000L, 20000L, 20000L));
+	}
+
+	@Test
+	void withJitter_ThenDelaysStayInExpectedRanges() {
+		// GIVEN
+		ExponentialBackOff backOff = new ExponentialBackOff();
+		backOff.setInitialInterval(1000L);
+		backOff.setJitter(100L); // 10% of initial interval
+		backOff.setMaxInterval(20000L);
+		backOff.setMultiplier(2.0);
+
+		BackOffExecution execution = backOff.start();
+
+		// WHEN
+		List<Long> delays = IntStream.range(0, 7).mapToObj(i -> execution.nextBackOff()).toList();
+
+		// THEN
+		assertThat(delays.get(0)).isBetween(1000L, 1100L); 		// 1000  +   10% (never below initial interval)
+		assertThat(delays.get(1)).isBetween(1800L, 2200L); 		// 2000  +/- 10%
+		assertThat(delays.get(2)).isBetween(3600L, 4400L); 		// 4000  +/- 10%
+		assertThat(delays.get(3)).isBetween(7200L, 8800L);		// 8000  +/- 10%
+		assertThat(delays.get(4)).isBetween(14400L, 17600L); 	// 16000 +/- 10%
+		assertThat(delays.get(5)).isBetween(18000L, 20000L); 	// 20000 -   10% (max interval)
+		assertThat(delays.get(6)).isBetween(18000L, 20000L); 	// 20000 -   10% (max interval)
+	}
+
 }

spring-core/src/test/java/org/springframework/util/comparator/BooleanComparatorTests.java

@@ -37,28 +37,36 @@ class BooleanComparatorTests {
 	void shouldCompareWithTrueLow() {
 		Comparator<Boolean> c = new BooleanComparator(true);
 		assertThat(c.compare(true, false)).isLessThan(0);
+		assertThat(c.compare(false, true)).isGreaterThan(0);
 		assertThat(c.compare(Boolean.TRUE, Boolean.TRUE)).isEqualTo(0);
+		assertThat(c.compare(Boolean.FALSE, Boolean.FALSE)).isEqualTo(0);
 	}
 
 	@Test
 	void shouldCompareWithTrueHigh() {
 		Comparator<Boolean> c = new BooleanComparator(false);
 		assertThat(c.compare(true, false)).isGreaterThan(0);
+		assertThat(c.compare(false, true)).isLessThan(0);
 		assertThat(c.compare(Boolean.TRUE, Boolean.TRUE)).isEqualTo(0);
+		assertThat(c.compare(Boolean.FALSE, Boolean.FALSE)).isEqualTo(0);
 	}
 
 	@Test
 	void shouldCompareFromTrueLow() {
 		Comparator<Boolean> c = BooleanComparator.TRUE_LOW;
 		assertThat(c.compare(true, false)).isLessThan(0);
+		assertThat(c.compare(false, true)).isGreaterThan(0);
 		assertThat(c.compare(Boolean.TRUE, Boolean.TRUE)).isEqualTo(0);
+		assertThat(c.compare(Boolean.FALSE, Boolean.FALSE)).isEqualTo(0);
 	}
 
 	@Test
 	void shouldCompareFromTrueHigh() {
 		Comparator<Boolean> c = BooleanComparator.TRUE_HIGH;
 		assertThat(c.compare(true, false)).isGreaterThan(0);
+		assertThat(c.compare(false, true)).isLessThan(0);
 		assertThat(c.compare(Boolean.TRUE, Boolean.TRUE)).isEqualTo(0);
+		assertThat(c.compare(Boolean.FALSE, Boolean.FALSE)).isEqualTo(0);
 	}
 
 }