Convert tests for Validate.notNaN overloads to @Nested test

src/test/java/org/apache/commons/lang3/ValidateTest.java

@@ -1107,31 +1107,66 @@ class ValidateTest {
         }
     }
 
-    @Test
+    @Nested
-    void testNotNaN1() {
+    class NotNaN {
-        Validate.notNaN(0.0);
+
-        Validate.notNaN(Double.POSITIVE_INFINITY);
+        @Nested
-        Validate.notNaN(Double.NEGATIVE_INFINITY);
+        class WithoutMessage {
-        try {
+
-            Validate.notNaN(Double.NaN);
+            @Test
-            fail("Expecting IllegalArgumentException");
+            void shouldNotThrowExceptionForNumber() {
-        } catch (final IllegalArgumentException ex) {
+                Validate.notNaN(0.0);
-            assertEquals("The validated value is not a number", ex.getMessage());
+            }
+
+            @Test
+            void shouldNotThrowExceptionForPositiveInfinity() {
+                Validate.notNaN(Double.POSITIVE_INFINITY);
+            }
+
+            @Test
+            void shouldNotThrowExceptionForNegativeInfinity() {
+                Validate.notNaN(Double.NEGATIVE_INFINITY);
+            }
+
+            @Test
+            void shouldThrowIllegalArgumentExceptionWithDefaultMessageForNaN() {
+                final IllegalArgumentException ex = assertThrows(
+                        IllegalArgumentException.class,
+                        () -> Validate.notNaN(Double.NaN));
+
+                assertEquals("The validated value is not a number", ex.getMessage());
+            }
+        }
+
+        @Nested
+        class WithMessage {
+
+            @Test
+            void shouldNotThrowExceptionForNumber() {
+                Validate.notNaN(0.0, "MSG");
+            }
+
+            @Test
+            void shouldNotThrowExceptionForPositiveInfinity() {
+                Validate.notNaN(Double.POSITIVE_INFINITY, "MSG");
+            }
+
+            @Test
+            void shouldNotThrowExceptionForNegativeInfinity() {
+                Validate.notNaN(Double.NEGATIVE_INFINITY, "MSG");
+            }
+
+            @Test
+            void shouldThrowIllegalArgumentExceptionWithGivenMessageForNaN() {
+                final IllegalArgumentException ex = assertThrows(
+                        IllegalArgumentException.class,
+                        () -> Validate.notNaN(Double.NaN, "MSG"));
+
+                assertEquals("MSG", ex.getMessage());
+            }
         }
     }
 
-    @Test
-    void testNotNaN2() {
-        Validate.notNaN(0.0, "MSG");
-        Validate.notNaN(Double.POSITIVE_INFINITY, "MSG");
-        Validate.notNaN(Double.NEGATIVE_INFINITY, "MSG");
-        try {
-            Validate.notNaN(Double.NaN, "MSG");
-            fail("Expecting IllegalArgumentException");
-        } catch (final IllegalArgumentException ex) {
-            assertEquals("MSG", ex.getMessage());
-        }
-    }
 
     //-----------------------------------------------------------------------
     //-----------------------------------------------------------------------