Update SolverException to use String.format

MessageFormat cannot show Double.MIN_VALUE or Double.MIN_NORMAL. These
are represented as 0. Changing to String.format fixes this.

This was discovered from convergence errors involving sub-normal numbers
that have no useful information in the exception message (as the numbers
are zero).

Author: aherbert

commons-numbers-rootfinder/src/main/java/org/apache/commons/numbers/rootfinder/SolverException.java

@@ -16,30 +16,29 @@
  */
 package org.apache.commons.numbers.rootfinder;
 
-import java.text.MessageFormat;
-
 /**
  * Package private exception class with constants for frequently used messages.
  */
 class SolverException extends IllegalArgumentException {
     /** Error message for "too large" condition. */
-    static final String TOO_LARGE = "{0} > {1}";
+    static final String TOO_LARGE = "%s > %s";
     /** Error message for "out of range" condition. */
-    static final String OUT_OF_RANGE = "{0} is out of range [{1}, {2}]";
+    static final String OUT_OF_RANGE = "%s is out of range [%s, %s]";
     /** Error message for "failed bracketing" condition. */
-    static final String BRACKETING = "No bracketing: f({0})={1}, f({2})={3}";
+    static final String BRACKETING = "No bracketing: f(%s)=%s, f(%s)=%s";
 
     /** Serializable version identifier. */
     private static final long serialVersionUID = 20190602L;
 
     /**
      * Create an exception where the message is constructed by applying
-     * the {@code format()} method from {@code java.text.MessageFormat}.
+     * the {@code format()} method from {@code String}.
      *
      * @param message  the exception message with replaceable parameters
      * @param formatArguments the arguments for formatting the message
+     * @see String#format(String, Object...)
      */
     SolverException(String message, Object... formatArguments) {
-        super(MessageFormat.format(message, formatArguments));
+        super(String.format(message, formatArguments));
     }
 }

commons-numbers-rootfinder/src/test/java/org/apache/commons/numbers/rootfinder/SolverExceptionTest.java

@@ -0,0 +1,61 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.commons.numbers.rootfinder;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+/**
+ * Test cases for the {@link SolverException} class.
+ */
+class SolverExceptionTest {
+    @Test
+    void testOutOfRangeFormatting() {
+        final double x = Double.MIN_NORMAL;
+        final double y = Double.MIN_VALUE;
+        final double z = 1.0;
+        final String msg = new SolverException(SolverException.OUT_OF_RANGE,
+                x, y, z).getMessage();
+        Assertions.assertTrue(msg.contains(String.valueOf(x)), () -> "Missing: " + x);
+        Assertions.assertTrue(msg.contains(String.valueOf(y)), () -> "Missing: " + y);
+        Assertions.assertTrue(msg.contains(String.valueOf(z)), () -> "Missing: " + z);
+    }
+
+    @Test
+    void testBracketingFormatting() {
+        final double w = Double.MAX_VALUE;
+        final double x = Double.MIN_NORMAL;
+        final double y = Double.MIN_VALUE;
+        final double z = 1.0;
+        final String msg = new SolverException(SolverException.BRACKETING,
+                w, x, y, z).getMessage();
+        Assertions.assertTrue(msg.contains(String.valueOf(w)), () -> "Missing: " + w);
+        Assertions.assertTrue(msg.contains(String.valueOf(x)), () -> "Missing: " + x);
+        Assertions.assertTrue(msg.contains(String.valueOf(y)), () -> "Missing: " + y);
+        Assertions.assertTrue(msg.contains(String.valueOf(z)), () -> "Missing: " + z);
+    }
+
+    @Test
+    void testTooLargeFormatting() {
+        final double x = Double.MIN_NORMAL;
+        final double y = Double.MIN_VALUE;
+        final String msg = new SolverException(SolverException.TOO_LARGE,
+                x, y).getMessage();
+        Assertions.assertTrue(msg.contains(String.valueOf(x)), () -> "Missing: " + x);
+        Assertions.assertTrue(msg.contains(String.valueOf(y)), () -> "Missing: " + y);
+    }
+}