1 /*
2  * Licensed to the Apache Software Foundation (ASF) under one or more
3  * contributor license agreements.  See the NOTICE file distributed with
4  * this work for additional information regarding copyright ownership.
5  * The ASF licenses this file to You under the Apache License, Version 2.0
6  * (the "License"); you may not use this file except in compliance with
7  * the License.  You may obtain a copy of the License at
8  *
9  *      http://www.apache.org/licenses/LICENSE-2.0
10  *
11  * Unless required by applicable law or agreed to in writing, software
12  * distributed under the License is distributed on an "AS IS" BASIS,
13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14  * See the License for the specific language governing permissions and
15  * limitations under the License.
16  */
17 package org.apache.commons.math;
18 
19 import java.io.EOFException;
20 import java.io.IOException;
21 import java.io.PrintStream;
22 import java.io.PrintWriter;
23 import java.text.MessageFormat;
24 import java.text.ParseException;
25 import java.util.ConcurrentModificationException;
26 import java.util.Locale;
27 import java.util.NoSuchElementException;
28 
29 import org.apache.commons.math.exception.MathThrowable;
30 import org.apache.commons.math.exception.util.DummyLocalizable;
31 import org.apache.commons.math.exception.util.Localizable;
32 import org.apache.commons.math.exception.util.LocalizedFormats;
33 
34 /**
35 * Base class for commons-math unchecked exceptions.
36 *
37 * @version $Revision: 1070725 $ $Date: 2011-02-15 02:31:12 +0100 (mar. 15 févr. 2011) $
38 * @since 2.0
39 */
40 public class MathRuntimeException extends RuntimeException implements MathThrowable {
41 
42     /** Serializable version identifier. */
43     private static final long serialVersionUID = 9058794795027570002L;
44 
45     /**
46      * Pattern used to build the message.
47      */
48     private final Localizable pattern;
49 
50     /**
51      * Arguments used to build the message.
52      */
53     private final Object[] arguments;
54 
55     /**
56      * Constructs a new <code>MathRuntimeException</code> with specified
57      * formatted detail message.
58      * Message formatting is delegated to {@link java.text.MessageFormat}.
59      * @param pattern format specifier
60      * @param arguments format arguments
61      * @deprecated as of 2.2 replaced by {@link #MathRuntimeException(Localizable, Object...)}
62      */
63     @Deprecated
MathRuntimeException(final String pattern, final Object ... arguments)64     public MathRuntimeException(final String pattern, final Object ... arguments) {
65         this(new DummyLocalizable(pattern), arguments);
66     }
67 
68     /**
69      * Constructs a new <code>MathRuntimeException</code> with specified
70      * formatted detail message.
71      * Message formatting is delegated to {@link java.text.MessageFormat}.
72      * @param pattern format specifier
73      * @param arguments format arguments
74      * @since 2.2
75      */
MathRuntimeException(final Localizable pattern, final Object ... arguments)76     public MathRuntimeException(final Localizable pattern, final Object ... arguments) {
77         this.pattern   = pattern;
78         this.arguments = (arguments == null) ? new Object[0] : arguments.clone();
79     }
80 
81     /**
82      * Constructs a new <code>MathRuntimeException</code> with specified
83      * nested <code>Throwable</code> root cause.
84      *
85      * @param rootCause  the exception or error that caused this exception
86      *                   to be thrown.
87      */
MathRuntimeException(final Throwable rootCause)88     public MathRuntimeException(final Throwable rootCause) {
89         super(rootCause);
90         this.pattern   = LocalizedFormats.SIMPLE_MESSAGE;
91         this.arguments = new Object[] { (rootCause == null) ? "" : rootCause.getMessage() };
92     }
93 
94     /**
95      * Constructs a new <code>MathRuntimeException</code> with specified
96      * formatted detail message and nested <code>Throwable</code> root cause.
97      * Message formatting is delegated to {@link java.text.MessageFormat}.
98      * @param rootCause the exception or error that caused this exception
99      * to be thrown.
100      * @param pattern format specifier
101      * @param arguments format arguments
102      * @deprecated as of 2.2 replaced by {@link #MathRuntimeException(Throwable, Localizable, Object...)}
103      */
104     @Deprecated
MathRuntimeException(final Throwable rootCause, final String pattern, final Object ... arguments)105     public MathRuntimeException(final Throwable rootCause,
106                                 final String pattern, final Object ... arguments) {
107         this(rootCause, new DummyLocalizable(pattern), arguments);
108     }
109 
110     /**
111      * Constructs a new <code>MathRuntimeException</code> with specified
112      * formatted detail message and nested <code>Throwable</code> root cause.
113      * Message formatting is delegated to {@link java.text.MessageFormat}.
114      * @param rootCause the exception or error that caused this exception
115      * to be thrown.
116      * @param pattern format specifier
117      * @param arguments format arguments
118      * @since 2.2
119      */
MathRuntimeException(final Throwable rootCause, final Localizable pattern, final Object ... arguments)120     public MathRuntimeException(final Throwable rootCause,
121                                 final Localizable pattern, final Object ... arguments) {
122         super(rootCause);
123         this.pattern   = pattern;
124         this.arguments = (arguments == null) ? new Object[0] : arguments.clone();
125     }
126 
127     /**
128      * Builds a message string by from a pattern and its arguments.
129      * @param locale Locale in which the message should be translated
130      * @param pattern format specifier
131      * @param arguments format arguments
132      * @return a message string
133      * @since 2.2
134      */
buildMessage(final Locale locale, final Localizable pattern, final Object ... arguments)135     private static String buildMessage(final Locale locale, final Localizable pattern,
136                                        final Object ... arguments) {
137         return new MessageFormat(pattern.getLocalizedString(locale), locale).format(arguments);
138     }
139 
140     /** Gets the pattern used to build the message of this throwable.
141     *
142     * @return the pattern used to build the message of this throwable
143     * @deprecated as of 2.2 replaced by {@link #getSpecificPattern()} and {@link #getGeneralPattern()}
144     */
145     @Deprecated
getPattern()146     public String getPattern() {
147         return pattern.getSourceString();
148     }
149 
150     /**
151      * {@inheritDoc}
152      *
153      * @since 2.2
154      */
getSpecificPattern()155     public Localizable getSpecificPattern() {
156         return null;
157     }
158 
159     /**
160      * {@inheritDoc}
161      *
162      * @since 2.2
163      */
getGeneralPattern()164     public Localizable getGeneralPattern() {
165         return pattern;
166     }
167 
168     /** {@inheritDoc} */
getArguments()169     public Object[] getArguments() {
170         return arguments.clone();
171     }
172 
173     /** Gets the message in a specified locale.
174      *
175      * @param locale Locale in which the message should be translated
176      *
177      * @return localized message
178      */
getMessage(final Locale locale)179     public String getMessage(final Locale locale) {
180         if (pattern != null) {
181             return buildMessage(locale, pattern, arguments);
182         }
183         return "";
184     }
185 
186     /** {@inheritDoc} */
187     @Override
getMessage()188     public String getMessage() {
189         return getMessage(Locale.US);
190     }
191 
192     /** {@inheritDoc} */
193     @Override
getLocalizedMessage()194     public String getLocalizedMessage() {
195         return getMessage(Locale.getDefault());
196     }
197 
198     /**
199      * Prints the stack trace of this exception to the standard error stream.
200      */
201     @Override
printStackTrace()202     public void printStackTrace() {
203         printStackTrace(System.err);
204     }
205 
206     /**
207      * Prints the stack trace of this exception to the specified stream.
208      *
209      * @param out  the <code>PrintStream</code> to use for output
210      */
211     @Override
printStackTrace(final PrintStream out)212     public void printStackTrace(final PrintStream out) {
213         synchronized (out) {
214             PrintWriter pw = new PrintWriter(out, false);
215             printStackTrace(pw);
216             // Flush the PrintWriter before it's GC'ed.
217             pw.flush();
218         }
219     }
220 
221     /**
222      * Constructs a new <code>ArithmeticException</code> with specified formatted detail message.
223      * Message formatting is delegated to {@link java.text.MessageFormat}.
224      * @param pattern format specifier
225      * @param arguments format arguments
226      * @return built exception
227      * @deprecated as of 2.2 replaced by {@link #createArithmeticException(Localizable, Object...)}
228      */
229     @Deprecated
createArithmeticException(final String pattern, final Object ... arguments)230     public static ArithmeticException createArithmeticException(final String pattern,
231                                                                 final Object ... arguments) {
232         return createArithmeticException(new DummyLocalizable(pattern), arguments);
233     }
234 
235     /**
236      * Constructs a new <code>ArithmeticException</code> with specified formatted detail message.
237      * Message formatting is delegated to {@link java.text.MessageFormat}.
238      * @param pattern format specifier
239      * @param arguments format arguments
240      * @return built exception
241      * @since 2.2
242      */
createArithmeticException(final Localizable pattern, final Object ... arguments)243     public static ArithmeticException createArithmeticException(final Localizable pattern,
244                                                                 final Object ... arguments) {
245         return new ArithmeticException() {
246 
247             /** Serializable version identifier. */
248             private static final long serialVersionUID = 5305498554076846637L;
249 
250             /** {@inheritDoc} */
251             @Override
252             public String getMessage() {
253                 return buildMessage(Locale.US, pattern, arguments);
254             }
255 
256             /** {@inheritDoc} */
257             @Override
258             public String getLocalizedMessage() {
259                 return buildMessage(Locale.getDefault(), pattern, arguments);
260             }
261 
262         };
263     }
264 
265     /**
266      * Constructs a new <code>ArrayIndexOutOfBoundsException</code> with specified formatted detail message.
267      * Message formatting is delegated to {@link java.text.MessageFormat}.
268      * @param pattern format specifier
269      * @param arguments format arguments
270      * @return built exception
271      * @deprecated as of 2.2 replaced by {@link #createArrayIndexOutOfBoundsException(Localizable, Object...)}
272      */
273     @Deprecated
createArrayIndexOutOfBoundsException(final String pattern, final Object ... arguments)274     public static ArrayIndexOutOfBoundsException createArrayIndexOutOfBoundsException(final String pattern,
275                                                                                       final Object ... arguments) {
276         return createArrayIndexOutOfBoundsException(new DummyLocalizable(pattern), arguments);
277     }
278 
279     /**
280      * Constructs a new <code>ArrayIndexOutOfBoundsException</code> with specified formatted detail message.
281      * Message formatting is delegated to {@link java.text.MessageFormat}.
282      * @param pattern format specifier
283      * @param arguments format arguments
284      * @return built exception
285      * @since 2.2
286      */
createArrayIndexOutOfBoundsException(final Localizable pattern, final Object ... arguments)287     public static ArrayIndexOutOfBoundsException createArrayIndexOutOfBoundsException(final Localizable pattern,
288                                                                                       final Object ... arguments) {
289         return new ArrayIndexOutOfBoundsException() {
290 
291             /** Serializable version identifier. */
292             private static final long serialVersionUID = 6718518191249632175L;
293 
294             /** {@inheritDoc} */
295             @Override
296             public String getMessage() {
297                 return buildMessage(Locale.US, pattern, arguments);
298             }
299 
300             /** {@inheritDoc} */
301             @Override
302             public String getLocalizedMessage() {
303                 return buildMessage(Locale.getDefault(), pattern, arguments);
304             }
305 
306         };
307     }
308 
309     /**
310      * Constructs a new <code>EOFException</code> with specified formatted detail message.
311      * Message formatting is delegated to {@link java.text.MessageFormat}.
312      * @param pattern format specifier
313      * @param arguments format arguments
314      * @return built exception
315      * @deprecated as of 2.2 replaced by {@link #createEOFException(Localizable, Object...)}
316      */
317     @Deprecated
318     public static EOFException createEOFException(final String pattern,
319                                                   final Object ... arguments) {
320         return createEOFException(new DummyLocalizable(pattern), arguments);
321     }
322 
323     /**
324      * Constructs a new <code>EOFException</code> with specified formatted detail message.
325      * Message formatting is delegated to {@link java.text.MessageFormat}.
326      * @param pattern format specifier
327      * @param arguments format arguments
328      * @return built exception
329      * @since 2.2
330      */
331     public static EOFException createEOFException(final Localizable pattern,
332                                                   final Object ... arguments) {
333         return new EOFException() {
334 
335             /** Serializable version identifier. */
336             private static final long serialVersionUID = 6067985859347601503L;
337 
338             /** {@inheritDoc} */
339             @Override
340             public String getMessage() {
341                 return buildMessage(Locale.US, pattern, arguments);
342             }
343 
344             /** {@inheritDoc} */
345             @Override
346             public String getLocalizedMessage() {
347                 return buildMessage(Locale.getDefault(), pattern, arguments);
348             }
349 
350         };
351     }
352 
353     /**
354      * Constructs a new <code>IOException</code> with specified nested
355      * <code>Throwable</code> root cause.
356      * <p>This factory method allows chaining of other exceptions within an
357      * <code>IOException</code> even for Java 5. The constructor for
358      * <code>IOException</code> with a cause parameter was introduced only
359      * with Java 6.</p>
360      * @param rootCause the exception or error that caused this exception
361      * to be thrown.
362      * @return built exception
363      */
364     public static IOException createIOException(final Throwable rootCause) {
365         IOException ioe = new IOException(rootCause.getLocalizedMessage());
366         ioe.initCause(rootCause);
367         return ioe;
368     }
369 
370     /**
371      * Constructs a new <code>IllegalArgumentException</code> with specified formatted detail message.
372      * Message formatting is delegated to {@link java.text.MessageFormat}.
373      * @param pattern format specifier
374      * @param arguments format arguments
375      * @return built exception
376      * @deprecated as of 2.2 replaced by {@link #createIllegalArgumentException(Localizable, Object...)}
377      */
378     @Deprecated
379     public static IllegalArgumentException createIllegalArgumentException(final String pattern,
380                                                                           final Object ... arguments) {
381         return createIllegalArgumentException(new DummyLocalizable(pattern), arguments);
382     }
383 
384     /**
385      * Constructs a new <code>IllegalArgumentException</code> with specified formatted detail message.
386      * Message formatting is delegated to {@link java.text.MessageFormat}.
387      * @param pattern format specifier
388      * @param arguments format arguments
389      * @return built exception
390      * @since 2.2
391      */
392     public static IllegalArgumentException createIllegalArgumentException(final Localizable pattern,
393                                                                           final Object ... arguments) {
394         return new IllegalArgumentException() {
395 
396             /** Serializable version identifier. */
397             private static final long serialVersionUID = -4284649691002411505L;
398 
399             /** {@inheritDoc} */
400             @Override
401             public String getMessage() {
402                 return buildMessage(Locale.US, pattern, arguments);
403             }
404 
405             /** {@inheritDoc} */
406             @Override
407             public String getLocalizedMessage() {
408                 return buildMessage(Locale.getDefault(), pattern, arguments);
409             }
410 
411         };
412     }
413 
414     /**
415      * Constructs a new <code>IllegalArgumentException</code> with specified nested
416      * <code>Throwable</code> root cause.
417      * @param rootCause the exception or error that caused this exception
418      * to be thrown.
419      * @return built exception
420      */
421     public static IllegalArgumentException createIllegalArgumentException(final Throwable rootCause) {
422         IllegalArgumentException iae = new IllegalArgumentException(rootCause.getLocalizedMessage());
423         iae.initCause(rootCause);
424         return iae;
425     }
426 
427     /**
428      * Constructs a new <code>IllegalStateException</code> with specified formatted detail message.
429      * Message formatting is delegated to {@link java.text.MessageFormat}.
430      * @param pattern format specifier
431      * @param arguments format arguments
432      * @return built exception
433      * @deprecated as of 2.2 replaced by {@link #createIllegalStateException(Localizable, Object...)}
434      */
435     @Deprecated
436     public static IllegalStateException createIllegalStateException(final String pattern,
437                                                                     final Object ... arguments) {
438         return createIllegalStateException(new DummyLocalizable(pattern), arguments);
439     }
440 
441     /**
442      * Constructs a new <code>IllegalStateException</code> with specified formatted detail message.
443      * Message formatting is delegated to {@link java.text.MessageFormat}.
444      * @param pattern format specifier
445      * @param arguments format arguments
446      * @return built exception
447      * @since 2.2
448      */
449     public static IllegalStateException createIllegalStateException(final Localizable pattern,
450                                                                     final Object ... arguments) {
451         return new IllegalStateException() {
452 
453             /** Serializable version identifier. */
454             private static final long serialVersionUID = 6880901520234515725L;
455 
456             /** {@inheritDoc} */
457             @Override
458             public String getMessage() {
459                 return buildMessage(Locale.US, pattern, arguments);
460             }
461 
462             /** {@inheritDoc} */
463             @Override
464             public String getLocalizedMessage() {
465                 return buildMessage(Locale.getDefault(), pattern, arguments);
466             }
467 
468         };
469     }
470 
471     /**
472      * Constructs a new <code>ConcurrentModificationException</code> with specified formatted detail message.
473      * Message formatting is delegated to {@link java.text.MessageFormat}.
474      * @param pattern format specifier
475      * @param arguments format arguments
476      * @return built exception
477      * @deprecated as of 2.2 replaced by {@link #createConcurrentModificationException(Localizable, Object...)}
478      */
479     @Deprecated
480     public static ConcurrentModificationException createConcurrentModificationException(final String pattern,
481                                                                                         final Object ... arguments) {
482         return createConcurrentModificationException(new DummyLocalizable(pattern), arguments);
483     }
484 
485     /**
486      * Constructs a new <code>ConcurrentModificationException</code> with specified formatted detail message.
487      * Message formatting is delegated to {@link java.text.MessageFormat}.
488      * @param pattern format specifier
489      * @param arguments format arguments
490      * @return built exception
491      * @since 2.2
492      */
493     public static ConcurrentModificationException createConcurrentModificationException(final Localizable pattern,
494                                                                                         final Object ... arguments) {
495         return new ConcurrentModificationException() {
496 
497             /** Serializable version identifier. */
498             private static final long serialVersionUID = -1878427236170442052L;
499 
500             /** {@inheritDoc} */
501             @Override
502             public String getMessage() {
503                 return buildMessage(Locale.US, pattern, arguments);
504             }
505 
506             /** {@inheritDoc} */
507             @Override
508             public String getLocalizedMessage() {
509                 return buildMessage(Locale.getDefault(), pattern, arguments);
510             }
511 
512         };
513     }
514 
515     /**
516      * Constructs a new <code>NoSuchElementException</code> with specified formatted detail message.
517      * Message formatting is delegated to {@link java.text.MessageFormat}.
518      * @param pattern format specifier
519      * @param arguments format arguments
520      * @return built exception
521      * @deprecated as of 2.2 replaced by {@link #createNoSuchElementException(Localizable, Object...)}
522      */
523     @Deprecated
524     public static NoSuchElementException createNoSuchElementException(final String pattern,
525                                                                       final Object ... arguments) {
526         return createNoSuchElementException(new DummyLocalizable(pattern), arguments);
527     }
528 
529     /**
530      * Constructs a new <code>NoSuchElementException</code> with specified formatted detail message.
531      * Message formatting is delegated to {@link java.text.MessageFormat}.
532      * @param pattern format specifier
533      * @param arguments format arguments
534      * @return built exception
535      * @since 2.2
536      */
537     public static NoSuchElementException createNoSuchElementException(final Localizable pattern,
538                                                                       final Object ... arguments) {
539         return new NoSuchElementException() {
540 
541             /** Serializable version identifier. */
542             private static final long serialVersionUID = 1632410088350355086L;
543 
544             /** {@inheritDoc} */
545             @Override
546             public String getMessage() {
547                 return buildMessage(Locale.US, pattern, arguments);
548             }
549 
550             /** {@inheritDoc} */
551             @Override
552             public String getLocalizedMessage() {
553                 return buildMessage(Locale.getDefault(), pattern, arguments);
554             }
555 
556         };
557     }
558 
559     /**
560      * Constructs a new <code>UnsupportedOperationException</code> with specified formatted detail message.
561      * Message formatting is delegated to {@link java.text.MessageFormat}.
562      * @param pattern format specifier
563      * @param arguments format arguments
564      * @return built exception
565      * @since 2.2
566      * @deprecated in 2.2. Please use {@link org.apache.commons.math.exception.MathUnsupportedOperationException}
567      * instead.
568      */
569     @Deprecated
570     public static UnsupportedOperationException createUnsupportedOperationException(final Localizable pattern,
571                                                                                     final Object ... arguments) {
572         return new UnsupportedOperationException() {
573 
574             /** Serializable version identifier. */
575             private static final long serialVersionUID = -4284649691002411505L;
576 
577             /** {@inheritDoc} */
578             @Override
579             public String getMessage() {
580                 return buildMessage(Locale.US, pattern, arguments);
581             }
582 
583             /** {@inheritDoc} */
584             @Override
585             public String getLocalizedMessage() {
586                 return buildMessage(Locale.getDefault(), pattern, arguments);
587             }
588 
589         };
590     }
591 
592     /**
593      * Constructs a new <code>NullPointerException</code> with specified formatted detail message.
594      * Message formatting is delegated to {@link java.text.MessageFormat}.
595      * @param pattern format specifier
596      * @param arguments format arguments
597      * @return built exception
598      * @deprecated as of 2.2 replaced by {@link #createNullPointerException(Localizable, Object...)}
599      */
600     @Deprecated
601     public static NullPointerException createNullPointerException(final String pattern,
602                                                                   final Object ... arguments) {
603         return createNullPointerException(new DummyLocalizable(pattern), arguments);
604     }
605 
606     /**
607      * Constructs a new <code>NullPointerException</code> with specified formatted detail message.
608      * Message formatting is delegated to {@link java.text.MessageFormat}.
609      * @param pattern format specifier
610      * @param arguments format arguments
611      * @return built exception
612      * @since 2.2
613      * @deprecated in 2.2. Checks for "null" must not be performed in Commons-Math.
614      */
615     @Deprecated
616     public static NullPointerException createNullPointerException(final Localizable pattern,
617                                                                   final Object ... arguments) {
618         return new NullPointerException() {
619 
620             /** Serializable version identifier. */
621             private static final long serialVersionUID = 451965530686593945L;
622 
623             /** {@inheritDoc} */
624             @Override
625             public String getMessage() {
626                 return buildMessage(Locale.US, pattern, arguments);
627             }
628 
629             /** {@inheritDoc} */
630             @Override
631             public String getLocalizedMessage() {
632                 return buildMessage(Locale.getDefault(), pattern, arguments);
633             }
634 
635         };
636     }
637 
638    /**
639      * Constructs a new <code>ParseException</code> with specified
640      * formatted detail message.
641      * Message formatting is delegated to {@link java.text.MessageFormat}.
642      * @param offset offset at which error occurred
643      * @param pattern format specifier
644      * @param arguments format arguments
645      * @return built exception
646      * @deprecated as of 2.2 replaced by {@link #createParseException(int, Localizable, Object...)}
647      */
648     @Deprecated
649     public static ParseException createParseException(final int offset,
650                                                       final String pattern,
651                                                       final Object ... arguments) {
652         return createParseException(offset, new DummyLocalizable(pattern), arguments);
653     }
654 
655     /**
656      * Constructs a new <code>ParseException</code> with specified
657      * formatted detail message.
658      * Message formatting is delegated to {@link java.text.MessageFormat}.
659      * @param offset offset at which error occurred
660      * @param pattern format specifier
661      * @param arguments format arguments
662      * @return built exception
663      * @since 2.2
664      */
665     public static ParseException createParseException(final int offset,
666                                                       final Localizable pattern,
667                                                       final Object ... arguments) {
668         return new ParseException(null, offset) {
669 
670             /** Serializable version identifier. */
671             private static final long serialVersionUID = 8153587599409010120L;
672 
673             /** {@inheritDoc} */
674             @Override
675             public String getMessage() {
676                 return buildMessage(Locale.US, pattern, arguments);
677             }
678 
679             /** {@inheritDoc} */
680             @Override
681             public String getLocalizedMessage() {
682                 return buildMessage(Locale.getDefault(), pattern, arguments);
683             }
684 
685         };
686     }
687 
688     /** Create an {@link java.lang.RuntimeException} for an internal error.
689      * @param cause underlying cause
690      * @return an {@link java.lang.RuntimeException} for an internal error
691      */
692     public static RuntimeException createInternalError(final Throwable cause) {
693 
694         final String argument = "https://issues.apache.org/jira/browse/MATH";
695 
696         return new RuntimeException(cause) {
697 
698             /** Serializable version identifier. */
699             private static final long serialVersionUID = -201865440834027016L;
700 
701             /** {@inheritDoc} */
702             @Override
703             public String getMessage() {
704                 return buildMessage(Locale.US, LocalizedFormats.INTERNAL_ERROR, argument);
705             }
706 
707             /** {@inheritDoc} */
708             @Override
709             public String getLocalizedMessage() {
710                 return buildMessage(Locale.getDefault(), LocalizedFormats.INTERNAL_ERROR, argument);
711             }
712 
713         };
714 
715     }
716 
717 }
718