try to use IllegalStateException instead of RuntimeException

git-svn-id: https://svn.apache.org/repos/asf/poi/trunk@1904050 13f79535-47bb-0310-9956-ffa450edef68

poi-scratchpad/src/main/java/org/apache/poi/hemf/record/emfplus/HemfPlusImage.java

             return new Rectangle2D.Double(1,1,1,1);
         }
 
+        /**
+         * @param continuedObjectData list of object data
+         * @return byte array
+         * @throws IllegalStateException if the data cannot be read
+         */
         public byte[] getRawData(List<? extends EmfPlusObjectData> continuedObjectData) {
             try (UnsynchronizedByteArrayOutputStream bos = new UnsynchronizedByteArrayOutputStream()) {
                 bos.write(getImageData());
                 }
                 return bos.toByteArray();
             } catch (IOException e) {
-                throw new RuntimeException(e);
+                throw new IllegalStateException(e);
             }
         }
 
 
         private HemfPlusGDIImageRenderer getGDIRenderer() {
             if (getImageDataType() != EmfPlusImageDataType.BITMAP || getBitmapType() != EmfPlusBitmapDataType.PIXEL) {
-                throw new RuntimeException("image data is not a GDI image");
+                throw new IllegalStateException("image data is not a GDI image");
             }
             HemfPlusGDIImageRenderer renderer = new HemfPlusGDIImageRenderer();
             renderer.setWidth(getBitmapWidth());

poi-scratchpad/src/main/java/org/apache/poi/hemf/record/emfplus/HemfPlusPen.java

                 // A 32-bit unsigned integer that specifies the number of elements in the DashedLineData field.
                 int dashesSize = leis.readInt();
                 if (dashesSize < 0 || dashesSize > 1000) {
-                    throw new RuntimeException("Invalid dash data size");
+                    throw new IllegalStateException("Invalid dash data size");
                 }
 
                 // An array of DashedLineDataSize floating-point values that specify the lengths of the dashes and spaces in a dashed line.
                 // A 32-bit unsigned integer that specifies the number of elements in the CompoundLineData field.
                 int compoundSize = leis.readInt();
                 if (compoundSize < 0 || compoundSize > 1000) {
-                    throw new RuntimeException("Invalid compound line data size");
+                    throw new IllegalStateException("Invalid compound line data size");
                 }
 
                 // An array of CompoundLineDataSize floating-point values that specify the compound line of a pen.

poi/src/main/java/org/apache/poi/common/usermodel/fonts/FontHeader.java

         fontDataSize = leis.readInt();
         version = leis.readInt();
         if (version != 0x00010000 && version != 0x00020001 && version != 0x00020002) {
-            throw new RuntimeException("not a EOT font data stream");
+            throw new IllegalStateException("not a EOT font data stream");
         }
         flags = leis.readInt();
         leis.readFully(panose);
         fsType = leis.readUShort();
         magic = leis.readUShort();
         if (magic != 0x504C) {
-            throw new RuntimeException("not a EOT font data stream");
+            throw new IllegalStateException("not a EOT font data stream");
         }
         unicodeRange1 = leis.readInt();
         unicodeRange2 = leis.readInt();

poi/src/main/java/org/apache/poi/ddf/EscherChildAnchorRecord.java

             field_4_dy2 =  LittleEndian.getShort( data, pos + size );size+=2;
             break;
         default:
-            throw new RuntimeException("Invalid EscherChildAnchorRecord - neither 8 nor 16 bytes.");
+            throw new IllegalStateException("Invalid EscherChildAnchorRecord - neither 8 nor 16 bytes.");
         }
 
         return 8 + size;

poi/src/main/java/org/apache/poi/ddf/EscherMetafileBlip.java

             }
             raw_pictureData = bos.toByteArray();
         } catch (IOException e) {
-            throw new RuntimeException("Can't compress metafile picture data", e);
+            throw new IllegalStateException("Can't compress metafile picture data", e);
         }
 
         setCompressedSize(raw_pictureData.length);

poi/src/main/java/org/apache/poi/hpsf/VariantSupport.java

                 final byte[] v = IOUtils.toByteArray(lei, length, CodePageString.getMaxRecordLength());
                 throw new ReadingNotSupportedException( type, v );
             } catch (IOException e) {
-                throw new RuntimeException(e);
+                throw new IllegalStateException(e);
             }
         }
 

poi/src/main/java/org/apache/poi/hssf/extractor/EventBasedExcelExtractor.java

                text = text + "\n";
            }
        } catch(IOException e) {
-           throw new RuntimeException(e);
+           throw new IllegalStateException(e);
        }
 
        return text;

poi/src/main/java/org/apache/poi/hssf/extractor/ExcelExtractor.java

                                 }
                                 break;
                             default:
-                                throw new RuntimeException("Unexpected cell type (" + cell.getCellType() + ")");
+                                throw new IllegalStateException("Unexpected cell type (" + cell.getCellType() + ")");
                         }
 
                         // Output the comment, if requested and exists

poi/src/main/java/org/apache/poi/hssf/model/InternalWorkbook.java

     private void checkSheets(int sheetnum) {
         if ((boundsheets.size()) <= sheetnum) {   // if we're short one add another..
             if ((boundsheets.size() + 1) <= sheetnum) {
-                throw new RuntimeException("Sheet number out of bounds!");
+                throw new IllegalStateException("Sheet number out of bounds!");
             }
             BoundSheetRecord bsr = createBoundSheet(sheetnum);
 
         NameRecord name = new NameRecord(builtInName, sheetNumber);
 
         if(linkTable.nameAlreadyExists(name)) {
-            throw new RuntimeException("Builtin (" + builtInName
+            throw new IllegalStateException("Builtin (" + builtInName
                     + ") already exists for sheet (" + sheetNumber + ")");
         }
         addName(name);
             if (rec instanceof PaletteRecord) {
                 palette = (PaletteRecord) rec;
             } else {
-                throw new RuntimeException("InternalError: Expected PaletteRecord but got a '"+rec+"'");
+                throw new IllegalStateException("InternalError: Expected PaletteRecord but got a '"+rec+"'");
             }
         } else {
             palette = createPalette();

poi/src/main/java/org/apache/poi/hssf/model/LinkTable.java

 
         int nItems = temp.size();
         if (nItems < 1) {
-            throw new RuntimeException("Expected an EXTERNSHEET record but got ("
+            throw new IllegalStateException("Expected an EXTERNSHEET record but got ("
                     + rs.peekNextClass().getName() + ")");
         }
         if (nItems == 1) {
         if (idx < 0) {
             idx = findFirstRecordLocBySid(SSTRecord.sid) - 1;
             if (idx < 0) {
-                throw new RuntimeException("CountryRecord or SSTRecord not found");
+                throw new IllegalStateException("CountryRecord or SSTRecord not found");
             }
         }
         _workbookRecordList.add(idx + 1, _externSheetRecord);
     public int getExternalSheetIndex(String workbookName, String firstSheetName, String lastSheetName) {
         int externalBookIndex = getExternalWorkbookIndex(workbookName);
         if (externalBookIndex == -1) {
-            throw new RuntimeException("No external workbook with name '" + workbookName + "'");
+            throw new IllegalStateException("No external workbook with name '" + workbookName + "'");
         }
         SupBookRecord ebrTarget = _externalBookBlocks[externalBookIndex].getExternalBookRecord();
 
             }
 
         }
-        throw new RuntimeException("External workbook does not contain sheet '" + sheetName + "'");
+        throw new IllegalStateException("External workbook does not contain sheet '" + sheetName + "'");
     }
 
     /**
             }
         }
         if (thisWbIndex < 0) {
-            throw new RuntimeException("Could not find 'internal references' EXTERNALBOOK");
+            throw new IllegalStateException("Could not find 'internal references' EXTERNALBOOK");
         }
         if (_externSheetRecord == null) {
-            throw new RuntimeException("Did not have an external sheet record, having blocks: " +
+            throw new IllegalStateException("Did not have an external sheet record, having blocks: " +
                     _externalBookBlocks.length);
         }
 
         int firstTabIndex = _externSheetRecord.getFirstSheetIndexFromRefIndex(refIndex);
         if (firstTabIndex == -1) {
             // The referenced sheet could not be found
-            throw new RuntimeException("Referenced sheet could not be found");
+            throw new IllegalStateException("Referenced sheet could not be found");
         }
 
         // Does it exist via the external book block?

poi/src/main/java/org/apache/poi/hssf/record/EmbeddedObjectRefSubRecord.java

             }
             return null;
         } catch (IOException e) {
-            throw new RuntimeException("Unexpected exception in readRefPtg", e);
+            throw new IllegalStateException("Unexpected exception in readRefPtg", e);
         }
     }
 

poi/src/main/java/org/apache/poi/hssf/record/EscherAggregate.java

             try {
                 buffer.write(data);
             } catch (IOException e) {
-                throw new RuntimeException("Couldn't get data from drawing/continue records", e);
+                throw new IllegalStateException("Couldn't get data from drawing/continue records", e);
             }
         }
 

poi/src/main/java/org/apache/poi/hssf/record/SharedFormulaRecord.java

         int formulaColumn = formula.getColumn();
         //Sanity checks
         if (!isInRange(formulaRow, formulaColumn)) {
-            throw new RuntimeException("Shared Formula Conversion: Coding Error");
+            throw new IllegalStateException("Shared Formula Conversion: Coding Error");
         }
 
         SharedFormula sf = new SharedFormula(SpreadsheetVersion.EXCEL97);

poi/src/main/java/org/apache/poi/hssf/record/SubRecord.java

         UnsynchronizedByteArrayOutputStream baos = new UnsynchronizedByteArrayOutputStream(size);
         serialize(new LittleEndianOutputStream(baos));
         if (baos.size() != size) {
-            throw new RuntimeException("write size mismatch");
+            throw new IllegalStateException("write size mismatch");
         }
         return baos.toByteArray();
     }

poi/src/main/java/org/apache/poi/hssf/record/aggregates/ColumnInfoRecordsAggregate.java

             cirPrev = cir;
         }
         if (records.size() < 1) {
-            throw new RuntimeException("No column info records found");
+            throw new IllegalStateException("No column info records found");
         }
         if (!isInOrder) {
             records.sort(ColumnInfoRecordsAggregate::compareColInfos);
             if (cirPrev != null && compareColInfos(cirPrev, cir) > 0) {
                 // Excel probably wouldn't mind, but there is much logic in this class
                 // that assumes the column info records are kept in order
-                throw new RuntimeException("Column info records are out of order");
+                throw new IllegalStateException("Column info records are out of order");
             }
             cirPrev = cir;
         }

poi/src/main/java/org/apache/poi/hssf/record/aggregates/ValueRecordsAggregate.java

         }
         int row = cell.getRow();
         if (row >= records.length) {
-            throw new RuntimeException("cell row is out of range");
+            throw new IllegalStateException("cell row is out of range");
         }
         CellValueRecordInterface[] rowCells = records[row];
         if (rowCells == null) {
-            throw new RuntimeException("cell row is already empty");
+            throw new IllegalStateException("cell row is already empty");
         }
         short column = cell.getColumn();
         if (column >= rowCells.length) {
-            throw new RuntimeException("cell column is out of range");
+            throw new IllegalStateException("cell column is out of range");
         }
         rowCells[column] = null;
     }

poi/src/main/java/org/apache/poi/hssf/record/crypto/Biff8DecryptingStream.java

         double result = Double.longBitsToDouble(valueLongBits);
         if (Double.isNaN(result)) {
             // (Because Excel typically doesn't write NaN
-            throw new RuntimeException("Did not expect to read NaN");
+            throw new IllegalStateException("Did not expect to read NaN");
         }
         return result;
     }

poi/src/main/java/org/apache/poi/hssf/usermodel/DVConstraint.java

         try {
             return Double.valueOf(numberStr);
         } catch (NumberFormatException e) {
-            throw new RuntimeException("The supplied text '" + numberStr
+            throw new IllegalStateException("The supplied text '" + numberStr
                     + "' could not be parsed as a number");
         }
     }
             try {
                 dateVal = dateFormat.parse(dateStr);
             } catch (ParseException e) {
-                throw new RuntimeException("Failed to parse date '" + dateStr
+                throw new IllegalStateException("Failed to parse date '" + dateStr
                         + "' using specified format '" + dateFormat + "'", e);
             }
         }
     @Override
     public void setExplicitListValues(String[] explicitListValues) {
         if (_validationType != ValidationType.LIST) {
-            throw new RuntimeException("Cannot setExplicitListValues on non-list constraint");
+            throw new IllegalStateException("Cannot setExplicitListValues on non-list constraint");
         }
         _formula1 = null;
         _explicitListValues = explicitListValues;

poi/src/main/java/org/apache/poi/hssf/usermodel/FontDetails.java

         String[] charactersStrArray = split(charactersStr, ",", -1);
         String[] widthsStrArray = split(widthsStr, ",", -1);
         if (charactersStrArray.length != widthsStrArray.length)
-            throw new RuntimeException("Number of characters does not number of widths for font " + fontName);
+            throw new IllegalStateException("Number of characters does not number of widths for font " + fontName);
         for ( int i = 0; i < widthsStrArray.length; i++ )
         {
             if (charactersStrArray[i].length() != 0)

poi/src/main/java/org/apache/poi/hssf/usermodel/HSSFCell.java

                          ? CellType.BOOLEAN
                          : CellType.ERROR;
         }
-        throw new RuntimeException("Bad cell value rec (" + cval.getClass().getName() + ")");
+        throw new IllegalStateException("Bad cell value rec (" + cval.getClass().getName() + ")");
     }
 
     /**

poi/src/main/java/org/apache/poi/hssf/usermodel/HSSFFormulaEvaluator.java

         if (eval instanceof ErrorEval) {
             return CellValue.getError(((ErrorEval)eval).getErrorCode());
         }
-        throw new RuntimeException("Unexpected eval class (" + eval.getClass().getName() + ")");
+        throw new IllegalStateException("Unexpected eval class (" + eval.getClass().getName() + ")");
     }
 
     @Override

poi/src/main/java/org/apache/poi/hssf/usermodel/HSSFPalette.java

                 return getColor(i);
             }
         }
-        throw new RuntimeException("Could not find free color index");
+        throw new IllegalStateException("Could not find free color index");
     }
 
     private static final class CustomColor extends HSSFColor {

poi/src/main/java/org/apache/poi/hssf/usermodel/HSSFRow.java

 
         int column=cell.getColumnIndex();
         if(column < 0) {
-            throw new RuntimeException("Negative cell indexes not allowed");
+            throw new IllegalStateException("Negative cell indexes not allowed");
         }
         if(column >= cells.length || cell != cells[column]) {
-            throw new RuntimeException("Specified cell is not from this row");
+            throw new IllegalStateException("Specified cell is not from this row");
         }
         if(cell.isPartOfArrayFormulaGroup()){
             cell.tryToDeleteArrayFormula(null);

poi/src/main/java/org/apache/poi/hssf/usermodel/HSSFSheet.java

                     // Excel, OpenOffice.org and GoogleDocs are all OK with this, so POI should be too.
                     if (rowRecordsAlreadyPresent) {
                         // if at least one row record is present, all should be present.
-                        throw new RuntimeException("Unexpected missing row when some rows already present");
+                        throw new IllegalStateException("Unexpected missing row when some rows already present");
                     }*/
 
                     // create the row record on the fly now.

poi/src/main/java/org/apache/poi/hssf/usermodel/HSSFWorkbook.java

         for (int defNameIndex = 0; defNameIndex < names.size(); defNameIndex++) {
             NameRecord r = workbook.getNameRecord(defNameIndex);
             if (r == null) {
-                throw new RuntimeException("Unable to find all defined names to iterate over");
+                throw new IllegalStateException("Unable to find all defined names to iterate over");
             }
             if (!r.isBuiltInName() || r.getBuiltInName() != builtinCode) {
                 continue;

poi/src/main/java/org/apache/poi/hssf/usermodel/StaticFontMetrics.java

             try {
                 fontMetricsProps = loadMetrics();
             } catch (IOException e) {
-                throw new RuntimeException("Could not load font metrics", e);
+                throw new IllegalStateException("Could not load font metrics", e);
             }
         }
 

poi/src/main/java/org/apache/poi/poifs/crypt/ChunkedCipherInputStream.java

             }
         } catch (IOException e) {
             // need to wrap checked exception, because of LittleEndianInput interface :(
-            throw new RuntimeException(e);
+            throw new IllegalStateException(e);
         }
     }
 

poi/src/main/java/org/apache/poi/poifs/filesystem/DirectoryNode.java

                 _filesystem.remove(entry);
             } catch (IOException e) {
                 // TODO Work out how to report this, given we can't change the method signature...
-                throw new RuntimeException(e);
+                throw new IllegalStateException(e);
             }
         }
         return rval;

poi/src/main/java/org/apache/poi/poifs/filesystem/EntryUtils.java

                     return isEqual(inpA, inpB);
                 }
             } catch (NoPropertySetStreamException | IOException ex) {
-                throw new RuntimeException(ex);
+                throw new IllegalStateException(ex);
             }
         }
 

poi/src/main/java/org/apache/poi/poifs/filesystem/POIFSFileSystem.java

             stream.close();
         } catch (IOException e) {
             if (success) {
-                throw new RuntimeException(e);
+                throw new IllegalStateException(e);
             }
             // else not success? Try block did not complete normally
             // just print stack trace and leave original ex to be thrown

poi/src/main/java/org/apache/poi/poifs/filesystem/POIFSStream.java

             try {
                 this.loopDetector = blockStore.getChainLoopDetector();
             } catch (IOException e) {
-                throw new RuntimeException(e);
+                throw new IllegalStateException(e);
             }
         }
 
             try {
                 this.loopDetector = blockStore.getChainLoopDetector();
             } catch(IOException e) {
-                throw new RuntimeException(e);
+                throw new IllegalStateException(e);
             }
         }
 
                 nextBlock = blockStore.getNextBlock(nextBlock);
                 return data;
             } catch(IOException e) {
-                throw new RuntimeException(e);
+                throw new IllegalStateException(e);
             }
         }
 

poi/src/main/java/org/apache/poi/poifs/filesystem/TempFilePOIFSFileSystem.java

             tempFile = TempFile.createTempFile("poifs", ".tmp");
             _data = new FileBackedDataSource(tempFile, false);
         } catch (IOException e) {
-            throw new RuntimeException("Failed to create data source", e);
+            throw new IllegalStateException("Failed to create data source", e);
         }
     }
 

poi/src/main/java/org/apache/poi/sl/draw/SLGraphics.java

         try {
             return (Graphics)clone();
         } catch (CloneNotSupportedException e){
-            throw new RuntimeException(e);
+            throw new IllegalStateException(e);
         }
     }
 

poi/src/main/java/org/apache/poi/sl/draw/geom/PresetGeometries.java

                 }
             }
         } catch (IOException | XMLStreamException e){
-            throw new RuntimeException(e);
+            throw new IllegalStateException(e);
         }
     }
 

poi/src/main/java/org/apache/poi/ss/format/SimpleFraction.java

                 return new SimpleFraction((int)p1, (int)q1);
             }
             if ((p2 > overflow) || (q2 > overflow)) {
-                throw new RuntimeException("Overflow trying to convert "+value+" to fraction ("+p2+"/"+q2+")");
+                throw new IllegalStateException("Overflow trying to convert "+value+" to fraction ("+p2+"/"+q2+")");
             }
 
             double convergent = (double)p2 / (double)q2;
         } while (!stop);
 
         if (n >= maxIterations) {
-            throw new RuntimeException("Unable to convert "+value+" to fraction after "+maxIterations+" iterations");
+            throw new IllegalStateException("Unable to convert "+value+" to fraction after "+maxIterations+" iterations");
         }
 
         if (q2 < maxDenominator) {

poi/src/main/java/org/apache/poi/ss/formula/CollaboratingWorkbooksEnvironment.java

         for (WorkbookEvaluator evaluator : evaluators) {
             if (evalListener != evaluator.getEvaluationListener()) {
                 // This would be very complex to support
-                throw new RuntimeException("Workbook evaluators must all have the same evaluation listener");
+                throw new IllegalStateException("Workbook evaluators must all have the same evaluation listener");
             }
         }
         EvaluationCache cache = new EvaluationCache(evalListener);

poi/src/main/java/org/apache/poi/ss/formula/FormulaParser.java

     }
 
     /** Read New Character From Input Stream */
-    private void GetChar() {
+    private void nextChar() {
         // The intersection operator is a space.  We track whether the run of
         // whitespace preceding "look" counts as an intersection operator.
-        if (IsWhite(look)) {
+        if (isWhite(look)) {
             if (look == ' ') {
                 _inIntersection = true;
             }
 
         // Check to see if we've walked off the end of the string.
         if (_pointer > _formulaLength) {
-            throw new RuntimeException("Parsed past the end of the formula, pos: " + _pointer +
+            throw new IllegalStateException("Parsed past the end of the formula, pos: " + _pointer +
                     ", length: " + _formulaLength + ", formula: " + _formulaString);
         }
         if (_pointer < _formulaLength) {
     }
 
     /** Recognize an Alpha Character */
-    private static boolean IsAlpha(int c) {
+    private static boolean isAlpha(int c) {
         return Character.isLetter(c) || c == '$' || c=='_';
     }
 
     /** Recognize a Decimal Digit */
-    private static boolean IsDigit(int c) {
+    private static boolean isDigit(int c) {
         return Character.isDigit(c);
     }
 
     /** Recognize White Space */
-    private static boolean IsWhite(int c) {
+    private static boolean isWhite(int c) {
         return  c ==' ' || c== TAB || c == CR || c == LF;
     }
 
     /** Skip Over Leading White Space */
-    private void SkipWhite() {
-        while (IsWhite(look)) {
-            GetChar();
+    private void skipWhite() {
+        while (isWhite(look)) {
+            nextChar();
         }
     }
 
      *  unchecked exception. This method does <b>not</b> consume whitespace (before or after the
      *  matched character).
      */
-    private void Match(int x) {
+    private void match(int x) {
         if (look != x) {
             throw expected(new StringBuilder()
                     .append("'")
                     .append("'")
                     .toString());
         }
-        GetChar();
+        nextChar();
     }
 
     /** Get a Number */
-    private String GetNum() {
+    private String nextNum() {
         StringBuilder value = new StringBuilder();
 
-        while (IsDigit(this.look)){
+        while (isDigit(this.look)){
             value.appendCodePoint(this.look);
-            GetChar();
+            nextChar();
         }
         return value.length() == 0 ? null : value.toString();
     }
         boolean hasRange = false;
         while (look == ':') {
             int pos = _pointer;
-            GetChar();
+            nextChar();
             ParseNode nextPart = parseRangeable();
             // Note - no range simplification here. An expr like "A1:B2:C3:D4:E5" should be
             // grouped into area ref pairs like: "(A1:B2):(C3:D4):E5"
      *
      */
     private ParseNode parseRangeable() {
-        SkipWhite();
+        skipWhite();
         int savePointer = _pointer;
         SheetIdentifier sheetIden = parseSheetName(false);
 
         if (sheetIden == null) {
             resetPointer(savePointer);
         } else {
-            SkipWhite();
+            skipWhite();
             savePointer = _pointer;
         }
 
             }
             return parseNonRange(savePointer);
         }
-        boolean whiteAfterPart1 = IsWhite(look);
+        boolean whiteAfterPart1 = isWhite(look);
         if (whiteAfterPart1) {
-            SkipWhite();
+            skipWhite();
         }
 
         if (look == ':') {
             int colonPos = _pointer;
-            GetChar();
-            SkipWhite();
+            nextChar();
+            skipWhite();
             SimpleRangePart part2 = parseSimpleRangePart();
             if (part2 != null && !part1.isCompatibleForArea(part2)) {
                 // second part is not compatible with an area ref e.g. S!A1:S!B2
         }
 
         if (look == '.') {
-            GetChar();
+            nextChar();
             int dotCount = 1;
             while (look =='.') {
                 dotCount ++;
-                GetChar();
+                nextChar();
             }
-            boolean whiteBeforePart2 = IsWhite(look);
+            boolean whiteBeforePart2 = isWhite(look);
 
-            SkipWhite();
+            skipWhite();
             SimpleRangePart part2 = parseSimpleRangePart();
             String part1And2 = _formulaString.substring(savePointer-1, _pointer-1);
             if (part2 == null) {
         // Do NOT return before done reading all the structured reference tokens from the input stream.
         // Throwing exceptions is okay.
         int savePtr0 = _pointer;
-        GetChar();
+        nextChar();
 
         boolean isTotalsSpec = false;
         boolean isThisRowSpec = false;
             }
             nSpecQuantifiers++;
             if (look == ','){
-                GetChar();
+                nextChar();
             } else {
                 break;
             }
         }
         boolean isThisRow = false;
-        SkipWhite();
+        skipWhite();
         if (look == '@') {
             isThisRow = true;
-            GetChar();
+            nextChar();
         }
         // parse column quantifier
         String endColumnName = null;
             if (look == ','){
                 throw new FormulaParseException("The formula "+ _formulaString + " is illegal: you should not use ',' with column quantifiers");
             } else if (look == ':') {
-                GetChar();
+                nextChar();
                 endColumnName = parseAsColumnQuantifier();
                 nColQuantifiers++;
                 if (endColumnName == null) {
                 }
             }
         } else {
-            Match(']');
+            match(']');
         }
         // Done reading from input stream
         // Ok to return now
         if ( look != '[') {
             return null;
         }
-        GetChar();
+        nextChar();
         if (look == '#') {
             return null;
         }
         if (look == '@') {
-            GetChar();
+            nextChar();
         }
         StringBuilder name = new StringBuilder();
         while (look!=']') {
            name.appendCodePoint(look);
-           GetChar();
+           nextChar();
         }
-        Match(']');
+        match(']');
         return name.toString();
     }
     /**
         if ( look != '[') {
             return null;
         }
-        GetChar();
+        nextChar();
         if( look != '#') {
             return null;
         }
-        GetChar();
+        nextChar();
         String name = parseAsName();
         if ( name.equals("This")) {
             name = name + ' ' + parseAsName();
         }
-        Match(']');
+        match(']');
         return name;
     }
 
         }
         while (isValidDefinedNameChar(look)) {
             sb.appendCodePoint(look);
-            GetChar();
+            nextChar();
         }
-        SkipWhite();
+        skipWhite();
 
         return sb.toString();
     }
 
     private String getBookName() {
         StringBuilder sb = new StringBuilder();
-        GetChar();
+        nextChar();
         while (look != ']') {
             sb.appendCodePoint(look);
-            GetChar();
+            nextChar();
         }
-        GetChar();
+        nextChar();
         return sb.toString();
     }
 
 
         if (look == '\'' || isSndPartOfQuotedRange) {
             if (!isSndPartOfQuotedRange) {
-                Match('\'');
+                match('\'');
             }
 
             if (look == '[')
             boolean done = look == '\'';
             while(!done) {
                 sb.appendCodePoint(look);
-                GetChar();
+                nextChar();
                 switch (look){
                     case '\'' : {
-                        GetChar();
+                        nextChar();
                         if (look == '\''){
                             // Any single quotes which were already present in the sheet name will be converted to double single quotes ('')
                             // so switch back to single quote
-                            GetChar();
+                            nextChar();
                             break;
                         }
                     }
 
             NameIdentifier iden = new NameIdentifier(sb.toString(), true);
             // quoted identifier - can't concatenate anything more
-            SkipWhite();
+            skipWhite();
             if (look == '!') {
-                GetChar();
+                nextChar();
                 return new SheetIdentifier(bookName, iden);
             }
             // See if it's a multi-sheet range, eg Sheet1:Sheet3!A1
             // can concatenate idens with dots
             while (isUnquotedSheetNameChar(look)) {
                 sb.appendCodePoint(look);
-                GetChar();
+                nextChar();
             }
             if (look == '\'') {
-                GetChar();
+                nextChar();
             }
             NameIdentifier iden = new NameIdentifier(sb.toString(), false);
-            SkipWhite();
+            skipWhite();
             if (look == '!') {
-                GetChar();
+                nextChar();
                 return new SheetIdentifier(bookName, iden);
             }
             // See if it's a multi-sheet range, eg Sheet1:Sheet3!A1
         }
         if (look == '!' && bookName != null) {
             // Raw book reference, without a sheet
-            GetChar();
+            nextChar();
             return new SheetIdentifier(bookName, null);
         }
         return null;
      *  Sheet1, see if it's actually a range eg Sheet1:Sheet2!
      */
     private SheetIdentifier parseSheetRange(String bookname, NameIdentifier sheet1Name, boolean isSndPartOfQuotedRange) {
-        GetChar();
+        nextChar();
         SheetIdentifier sheet2 = parseSheetName(isSndPartOfQuotedRange);
         if (sheet2 != null) {
            return new SheetRangeIdentifier(bookname, sheet1Name, sheet2.getSheetIdentifier());
             if(isFunc){
                 int savePointer = _pointer;
                 resetPointer(_pointer + str.length());
-                SkipWhite();
+                skipWhite();
                 // open bracket indicates that the argument is a function,
                 // the returning value should be false, i.e. "not a valid cell reference"
                 result = look != '(';
             }
         }
 
-        Match('(');
+        match('(');
         ParseNode[] args = Arguments();
-        Match(')');
+        match(')');
 
         return getFunction(name, nameToken, args);
     }
     private ParseNode[] Arguments() {
         //average 2 args per function
         List<ParseNode> temp = new ArrayList<>(2);
-        SkipWhite();
+        skipWhite();
         if(look == ')') {
             return ParseNode.EMPTY_ARRAY;
         }
 
         boolean missedPrevArg = true;
         while (true) {
-            SkipWhite();
+            skipWhite();
             if (isArgumentDelimiter(look)) {
                 if (missedPrevArg) {
                     temp.add(new ParseNode(MissingArgPtg.instance));
                 if (look == ')') {
                     break;
                 }
-                Match(',');
+                match(',');
                 missedPrevArg = true;
                 continue;
             }
             temp.add(intersectionExpression());
             missedPrevArg = false;
-            SkipWhite();
+            skipWhite();
             if (!isArgumentDelimiter(look)) {
                 throw expected("',' or ')'");
             }
     private ParseNode powerFactor() {
         ParseNode result = percentFactor();
         while(true) {
-            SkipWhite();
+            skipWhite();
             if(look != '^') {
                 return result;
             }
-            Match('^');
+            match('^');
             ParseNode other = percentFactor();
             result = new ParseNode(PowerPtg.instance, result, other);
         }
     private ParseNode percentFactor() {
         ParseNode result = parseSimpleFactor();
         while(true) {
-            SkipWhite();
+            skipWhite();
             if(look != '%') {
                 return result;
             }
-            Match('%');
+            match('%');
             result = new ParseNode(PercentPtg.instance, result);
         }
     }
      * factors (without ^ or % )
      */
     private ParseNode parseSimpleFactor() {
-        SkipWhite();
+        skipWhite();
         switch(look) {
             case '#':
                 return new ParseNode(ErrPtg.valueOf(parseErrorLiteral()));
             case '-':
-                Match('-');
+                match('-');
                 return parseUnary(false);
             case '+':
-                Match('+');
+                match('+');
                 return parseUnary(true);
             case '(':
-                Match('(');
+                match('(');
                 ParseNode inside = unionExpression();
-                Match(')');
+                match(')');
                 return new ParseNode(ParenthesisPtg.instance, inside);
             case '"':
                 return new ParseNode(new StringPtg(parseStringLiteral()));
             case '{':
-                Match('{');
+                match('{');
                 ParseNode arrayNode = parseArray();
-                Match('}');
+                match('}');
                 return arrayNode;
         }
         // named ranges and tables can start with underscore or backslash
         // see https://support.office.com/en-us/article/Define-and-use-names-in-formulas-4d0f13ac-53b7-422e-afd2-abd7ff379c64?ui=en-US&rs=en-US&ad=US#bmsyntax_rules_for_names
-        if (IsAlpha(look) || Character.isDigit(look) || look == '\'' || look == '[' || look == '_' || look == '\\' ) {
+        if (isAlpha(look) || Character.isDigit(look) || look == '\'' || look == '[' || look == '_' || look == '\\' ) {
             return parseRangeExpression();
         }
         if (look == '.') {
 
     private ParseNode parseUnary(boolean isPlus) {
 
-        boolean numberFollows = IsDigit(look) || look=='.';
+        boolean numberFollows = isDigit(look) || look=='.';
         ParseNode factor = powerFactor();
 
         if (numberFollows) {
             if (look != ';') {
                 throw expected("'}' or ';'");
             }
-            Match(';');
+            match(';');
         }
         int nRows = rowsData.size();
         Object[][] values2d = new Object[nRows][];
         List<Object> temp = new ArrayList<>();
         while (true) {
             temp.add(parseArrayItem());
-            SkipWhite();
+            skipWhite();
             switch(look) {
                 case '}':
                 case ';':
                     break;
                 case ',':
-                    Match(',');
+                    match(',');
                     continue;
                 default:
                     throw expected("'}' or ','");
     }
 
     private Object parseArrayItem() {
-        SkipWhite();
+        skipWhite();
         switch(look) {
             case '"': return parseStringLiteral();
             case '#': return ErrorConstant.valueOf(parseErrorLiteral());
             case 'T': case 't':
                 return parseBooleanLiteral();
             case '-':
-                Match('-');
-                SkipWhite();
+                match('-');
+                skipWhite();
                 return convertArrayNumber(parseNumber(), false);
         }
         // else assume number
         } else  if (ptg instanceof NumberPtg) {
             value = ((NumberPtg)ptg).getValue();
         } else {
-            throw new RuntimeException("Unexpected ptg (" + ptg.getClass().getName() + ")");
+            throw new IllegalStateException("Unexpected ptg (" + ptg.getClass().getName() + ")");
         }
         if (!isPositive) {
             value = -value;
     private Ptg parseNumber() {
         String number2 = null;
         String exponent = null;
-        String number1 = GetNum();
+        String number1 = nextNum();
 
         if (look == '.') {
-            GetChar();
-            number2 = GetNum();
+            nextChar();
+            number2 = nextNum();
         }
 
         if (look == 'E') {
-            GetChar();
+            nextChar();
 
             String sign = "";
             if (look == '+') {
-                GetChar();
+                nextChar();
             } else if (look == '-') {
-                GetChar();
+                nextChar();
                 sign = "-";
             }
 
-            String number = GetNum();
+            String number = nextNum();
             if (number == null) {
                 throw expected("Integer");
             }
 
 
     private int parseErrorLiteral() {
-        Match('#');
+        match('#');
         String part1 = parseUnquotedIdentifier();
         if (part1 == null) {
             throw expected("remainder of error constant literal");
             case 'V': {
                 FormulaError fe = FormulaError.VALUE;
                 if(part1.equals(fe.name())) {
-                    Match('!');
+                    match('!');
                     return fe.getCode();
                 }
                 throw expected(fe.getString());
             case 'R': {
                 FormulaError fe = FormulaError.REF;
                 if(part1.equals(fe.name())) {
-                    Match('!');
+                    match('!');
                     return fe.getCode();
                 }
                 throw expected(fe.getString());
             case 'D': {
                 FormulaError fe = FormulaError.DIV0;
                 if(part1.equals("DIV")) {
-                    Match('/');
-                    Match('0');
-                    Match('!');
+                    match('/');
+                    match('0');
+                    match('!');
                     return fe.getCode();
                 }
                 throw expected(fe.getString());
                 FormulaError fe = FormulaError.NAME;
                 if(part1.equals(fe.name())) {
                     // only one that ends in '?'
-                    Match('?');
+                    match('?');
                     return fe.getCode();
                 }
                 fe = FormulaError.NUM;
                 if(part1.equals(fe.name())) {
-                    Match('!');
+                    match('!');
                     return fe.getCode();
                 }
                 fe = FormulaError.NULL;
                 if(part1.equals(fe.name())) {
-                    Match('!');
+                    match('!');
                     return fe.getCode();
                 }
                 fe = FormulaError.NA;
                 if(part1.equals("N")) {
-                    Match('/');
+                    match('/');
                     if(look != 'A' && look != 'a') {
                         throw expected(fe.getString());
                     }
-                    Match(look);
+                    match(look);
                     // Note - no '!' or '?' suffix
                     return fe.getCode();
                 }
         StringBuilder sb = new StringBuilder();
         while (Character.isLetterOrDigit(look) || look == '.') {
             sb.appendCodePoint(look);
-            GetChar();
+            nextChar();
         }
         if (sb.length() < 1) {
             return null;
 
 
     private String parseStringLiteral() {
-        Match('"');
+        match('"');
 
         StringBuilder token = new StringBuilder();
         while (true) {
             if (look == '"') {
-                GetChar();
+                nextChar();
                 if (look != '"') {
                     break;
                 }
              }
             token.appendCodePoint(look);
-            GetChar();
+            nextChar();
         }
         return token.toString();
     }
     private ParseNode  Term() {
         ParseNode result = powerFactor();
         while(true) {
-            SkipWhite();
+            skipWhite();
             Ptg operator;
             switch(look) {
                 case '*':
-                    Match('*');
+                    match('*');
                     operator = MultiplyPtg.instance;
                     break;
                 case '/':
-                    Match('/');
+                    match('/');
                     operator = DividePtg.instance;
                     break;
                 default:
         ParseNode result = intersectionExpression();
         boolean hasUnions = false;
         while (true) {
-            SkipWhite();
+            skipWhite();
             if (look == ',') {
-                GetChar();
+                nextChar();
                 hasUnions = true;
                 ParseNode other = intersectionExpression();
                 result = new ParseNode(UnionPtg.instance, result, other);
         ParseNode result = comparisonExpression();
         boolean hasIntersections = false;
         while (true) {
-            SkipWhite();
+            skipWhite();
             if (_inIntersection) {
                 int savePointer = _pointer;
 
     private ParseNode comparisonExpression() {
         ParseNode result = concatExpression();
         while (true) {
-            SkipWhite();
+            skipWhite();
             switch(look) {
                 case '=':
                 case '>':
 
     private Ptg getComparisonToken() {
         if(look == '=') {
-            Match(look);
+            match(look);
             return EqualPtg.instance;
         }
         boolean isGreater = look == '>';
-        Match(look);
+        match(look);
         if(isGreater) {
             if(look == '=') {
-                Match('=');
+                match('=');
                 return GreaterEqualPtg.instance;
             }
             return GreaterThanPtg.instance;
         }
         switch(look) {
             case '=':
-                Match('=');
+                match('=');
                 return LessEqualPtg.instance;
             case '>':
-                Match('>');
+                match('>');
                 return NotEqualPtg.instance;
         }
         return LessThanPtg.instance;
     private ParseNode concatExpression() {
         ParseNode result = additiveExpression();
         while (true) {
-            SkipWhite();
+            skipWhite();
             if(look != '&') {
                 break; // finished with concat expression
             }
-            Match('&');
+            match('&');
             ParseNode other = additiveExpression();
             result = new ParseNode(ConcatPtg.instance, result, other);
         }
     private ParseNode additiveExpression() {
         ParseNode result = Term();
         while (true) {
-            SkipWhite();
+            skipWhite();
             Ptg operator;
             switch(look) {
                 case '+':
-                    Match('+');
+                    match('+');
                     operator = AddPtg.instance;
                     break;
                 case '-':
-                    Match('-');
+                    match('-');
                     operator = SubtractPtg.instance;
                     break;
                 default:
      */
     private void parse() {
         _pointer=0;
-        GetChar();
+        nextChar();
         _rootNode = unionExpression();
 
         if(_pointer <= _formulaLength) {

poi/src/main/java/org/apache/poi/ss/formula/FormulaRenderer.java

                     stack.push(attrPtg.toFormulaString(operands));
                     continue;
                 }
-                throw new RuntimeException("Unexpected tAttr: " + attrPtg);
+                throw new IllegalStateException("Unexpected tAttr: " + attrPtg);
             }
 
             if (ptg instanceof WorkbookDependentFormula) {

poi/src/main/java/org/apache/poi/ss/formula/OperandClassTransformer.java

                 rootNodeOperandClass = Ptg.CLASS_REF;
                 break;
             default:
-                throw new RuntimeException("Incomplete code - formula type ("
+                throw new IllegalStateException("Incomplete code - formula type ("
                         + _formulaType + ") not supported yet");
 
         }

poi/src/main/java/org/apache/poi/ss/formula/OperationEvaluationContext.java

             try {
                 targetEvaluator = _bookEvaluator.getOtherWorkbookEvaluator(workbookName);
             } catch (WorkbookNotFoundException e) {
-                throw new RuntimeException(e.getMessage(), e);
+                throw new IllegalStateException(e.getMessage(), e);
             }
 
             otherFirstSheetIndex = targetEvaluator.getSheetIndex(externalSheet.getSheetName());
             }
 
             if (otherFirstSheetIndex < 0) {
-                throw new RuntimeException("Invalid sheet name '" + externalSheet.getSheetName()
+                throw new IllegalStateException("Invalid sheet name '" + externalSheet.getSheetName()
                         + "' in bool '" + workbookName + "'.");
             }
         }
             case NAMED_RANGE:
                 EvaluationName nm = _workbook.getName(refStrPart1, _sheetIndex);
                 if (nm == null) {
-                    throw new RuntimeException("Specified name '" + refStrPart1 +
+                    throw new IllegalStateException("Specified name '" + refStrPart1 +
                             "' is not found in the workbook (sheetIndex=" + _sheetIndex + ").");
                 }
                 if (!nm.isRange()) {
-                    throw new RuntimeException("Specified name '" + refStrPart1 + "' is not a range as expected.");
+                    throw new IllegalStateException("Specified name '" + refStrPart1 + "' is not a range as expected.");
                 }
                 return _bookEvaluator.evaluateNameFormula(nm.getNameDefinition(), this);
         }
             case BAD_CELL_OR_NAMED_RANGE:
                 return ErrorEval.REF_INVALID;
             case NAMED_RANGE:
-                throw new RuntimeException("Cannot evaluate '" + refStrPart1
+                throw new IllegalStateException("Cannot evaluate '" + refStrPart1
                         + "'. Indirect evaluation of defined names not supported yet");
         }
 
 
     private ValueEval convertObjectEval(Object token) {
         if (token == null) {
-            throw new RuntimeException("Array item cannot be null");
+            throw new IllegalStateException("Array item cannot be null");
         }
         if (token instanceof String) {
             return new StringEval((String) token);
             EvaluationName evaluationName = refWorkbookEvaluator.getName(externName.getName(), externName.getIx() - 1);
             if (evaluationName != null && evaluationName.hasFormula()) {
                 if (evaluationName.getNameDefinition().length > 1) {
-                    throw new RuntimeException("Complex name formulas not supported yet");
+                    throw new IllegalStateException("Complex name formulas not supported yet");
                 }
 
                 // Need to evaluate the reference in the context of the other book

poi/src/main/java/org/apache/poi/ss/formula/OperationEvaluatorFactory.java

             return udfFunc.evaluate(args, ec);
         }
 
-        throw new RuntimeException("Unexpected operation ptg class (" + ptg.getClass().getName() + ")");
+        throw new IllegalStateException("Unexpected operation ptg class (" + ptg.getClass().getName() + ")");
     }
 
     static ValueEval evaluateArrayFunction(ArrayFunction func, ValueEval[] args,

poi/src/main/java/org/apache/poi/ss/formula/SheetNameFormatter.java

                 appendAndEscape(out, rawSheetName);
             }
         } catch (Exception e) {
-            throw new RuntimeException(e);
+            throw new IllegalStateException(e);
         }
     }
 
                 appendOrREF(out, rawSheetName);
             }
         } catch (Exception e) {
-            throw new RuntimeException(e);
+            throw new IllegalStateException(e);
         }
     }
 
                 sb.append(ch);
             }
         } catch (Exception e) {
-            throw new RuntimeException(e);
+            throw new IllegalStateException(e);
         }
     }
 
             case '\n':
             case '\r':
             case '\t':
-                throw new RuntimeException("Illegal character (0x"
+                throw new IllegalStateException("Illegal character (0x"
                         + Integer.toHexString(ch) + ") found in sheet name");
         }
         return true;

poi/src/main/java/org/apache/poi/ss/formula/UserDefinedFunction.java

         // enforce singleton
     }
 
+    /**
+     * @param args the pre-evaluated arguments for this function. args is never {@code null},
+     *             nor are any of its elements.
+     * @param ec primarily used to identify the source cell containing the formula being evaluated.
+     *             may also be used to dynamically create reference evals.
+     * @return value
+     * @throws IllegalStateException if first arg is not a {@link FunctionNameEval}
+     * @throws NotImplementedFunctionException if function is not implemented
+     */
     @Override
     public ValueEval evaluate(ValueEval[] args, OperationEvaluationContext ec) {
         int nIncomingArgs = args.length;
-        if(nIncomingArgs < 1) {
-            throw new RuntimeException("function name argument missing");
+        if (nIncomingArgs < 1) {
+            throw new IllegalStateException("function name argument missing");
         }
 
         ValueEval nameArg = args[0];
         if (nameArg instanceof FunctionNameEval) {
             functionName = ((FunctionNameEval) nameArg).getFunctionName();
         } else {
-            throw new RuntimeException("First argument should be a NameEval, but got ("
+            throw new IllegalStateException("First argument should be a NameEval, but got ("
                     + nameArg.getClass().getName() + ")");
         }
         FreeRefFunction targetFunc = ec.findUserDefinedFunction(functionName);

poi/src/main/java/org/apache/poi/ss/formula/WorkbookEvaluator.java

         if (result == null) {
             int sheetIndex = _workbook.getSheetIndex(sheet);
             if (sheetIndex < 0) {
-                throw new RuntimeException("Specified sheet from a different book");
+                throw new IllegalStateException("Specified sheet from a different book");
             }
             result = sheetIndex;
             _sheetIndexesBySheet.put(sheet, result);
                             break;
                         case FORMULA:
                         default:
-                            throw new RuntimeException("Unexpected cell type '" + srcCell.getCellType() + "' found!");
+                            throw new IllegalStateException("Unexpected cell type '" + srcCell.getCellType() + "' found!");
                     }
                 } else {
                     throw re;
             case ERROR:
                 return ErrorEval.valueOf(cell.getErrorCellValue());
             default:
-                throw new RuntimeException("Unexpected cell type (" + cellType + ")");
+                throw new IllegalStateException("Unexpected cell type (" + cellType + ")");
         }
 
     }
                 opResult = getEvalForPtg(ptg, ec);
             }
             if (opResult == null) {
-                throw new RuntimeException("Evaluation result must not be null");
+                throw new IllegalStateException("Evaluation result must not be null");
             }
 //            logDebug("push " + opResult);
             stack.push(opResult);
         while (remBytes != 0) {
             index++;
             if (index >= ptgs.length) {
-                throw new RuntimeException("Skip distance too far (ran out of formula tokens).");
+                throw new IllegalStateException("Skip distance too far (ran out of formula tokens).");
             }
             remBytes -= ptgs[index].getSize();
             if (remBytes < 0) {
-                throw new RuntimeException("Bad skip distance (wrong token size calculation).");
+                throw new IllegalStateException("Bad skip distance (wrong token size calculation).");
             }
         }
         return index - startIndex;
             // POI uses UnknownPtg when the encoded Ptg array seems to be corrupted.
             // This seems to occur in very rare cases (e.g. unused name formulas in bug 44774, attachment 21790)
             // In any case, formulas are re-parsed before execution, so UnknownPtg should not get here
-            throw new RuntimeException("UnknownPtg not allowed");
+            throw new IllegalStateException("UnknownPtg not allowed");
         }
         if (ptg instanceof ExpPtg) {
             // ExpPtg is used for array formulas and shared formulas.
             // it is currently unsupported, and may not even get implemented here
-            throw new RuntimeException("ExpPtg currently not supported");
+            throw new IllegalStateException("ExpPtg currently not supported");
         }
 
-        throw new RuntimeException("Unexpected ptg class (" + ptg.getClass().getName() + ")");
+        throw new IllegalStateException("Unexpected ptg class (" + ptg.getClass().getName() + ")");
     }
 
     private ValueEval processNameEval(ValueEval eval, OperationEvaluationContext ec) {
             return evaluateNameFormula(nameRecord.getNameDefinition(), ec);
         }
 
-        throw new RuntimeException("Don't know how to evaluate name '" + nameRecord.getNameText() + "'");
+        throw new IllegalStateException("Don't know how to evaluate name '" + nameRecord.getNameText() + "'");
     }
 
     /**

poi/src/main/java/org/apache/poi/ss/formula/atp/YearFracCalculator.java

             case 23: // transition from daylight savings adjusted to normal time
                 // Unexpected since we are using UTC_TIME_ZONE
             default:
-                throw new RuntimeException("Unexpected date diff between " + startDateMS + " and " + endDateMS);
+                throw new IllegalStateException("Unexpected date diff between " + startDateMS + " and " + endDateMS);
 
         }
         return (int) (0.5 + ((double)msDiff / MS_PER_DAY));

poi/src/main/java/org/apache/poi/ss/formula/eval/ErrorEval.java

         if (eval != null) {
             return eval;
         } else {
-            throw new RuntimeException("Unhandled error type for code " + errorCode);
+            throw new IllegalStateException("Unhandled error type for code " + errorCode);
         }
     }
 

poi/src/main/java/org/apache/poi/ss/formula/eval/OperandResolver.java

             }
             return dd;
         }
-        throw new RuntimeException("Unexpected arg eval type (" + ev.getClass().getName() + ")");
+        throw new IllegalStateException("Unexpected arg eval type (" + ev.getClass().getName() + ")");
     }
 
     /**
         if (ve instanceof ErrorEval) {
             throw new EvaluationException((ErrorEval) ve);
         }
-        throw new RuntimeException("Unexpected eval (" + ve.getClass().getName() + ")");
+        throw new IllegalStateException("Unexpected eval (" + ve.getClass().getName() + ")");
     }
 }

poi/src/main/java/org/apache/poi/ss/formula/eval/forked/ForkedEvaluationCell.java

 
     private void checkCellType(CellType expectedCellType) {
         if (_cellType != expectedCellType) {
-            throw new RuntimeException("Wrong data type (" + _cellType + ")");
+            throw new IllegalStateException("Wrong data type (" + _cellType + ")");
         }
     }
 

poi/src/main/java/org/apache/poi/ss/formula/eval/forked/ForkedEvaluationWorkbook.java

     public Ptg[] getFormulaTokens(EvaluationCell cell) {
         if (cell instanceof ForkedEvaluationCell) {
             // doesn't happen yet because formulas cannot be modified from the master workbook
-            throw new RuntimeException("Updated formulas not supported yet");
+            throw new IllegalStateException("Updated formulas not supported yet");
         }
         return _masterBook.getFormulaTokens(cell);
     }

poi/src/main/java/org/apache/poi/ss/formula/function/FunctionDataBuilder.java

         prevFM = _functionDataByName.get(functionName);
         if(prevFM != null) {
             if(!hasFootnote || !_mutatingFunctionIndexes.contains(indexKey)) {
-                throw new RuntimeException("Multiple entries for function name '" + functionName + "'");
+                throw new IllegalStateException("Multiple entries for function name '" + functionName + "'");
             }
             _functionDataByIndex.remove(prevFM.getIndex());
         }
         prevFM = _functionDataByIndex.get(indexKey);
         if(prevFM != null) {
             if(!hasFootnote || !_mutatingFunctionIndexes.contains(indexKey)) {
-                throw new RuntimeException("Multiple entries for function index (" + functionIndex + ")");
+                throw new IllegalStateException("Multiple entries for function index (" + functionIndex + ")");
             }
             _functionDataByName.remove(prevFM.getName());
         }

poi/src/main/java/org/apache/poi/ss/formula/function/FunctionMetadataReader.java

     private static void readResourceFile(FunctionDataBuilder fdb, String resourceFile) {
         try (InputStream is = FunctionMetadataReader.class.getResourceAsStream(resourceFile)) {
             if (is == null) {
-                throw new RuntimeException("resource '" + resourceFile + "' not found");
+                throw new IllegalStateException("resource '" + resourceFile + "' not found");
             }
 
             try(BufferedReader br = new BufferedReader(new InputStreamReader(is, StandardCharsets.UTF_8))) {
                 }
             }
         } catch (IOException e) {
-            throw new RuntimeException(e);
+            throw new IllegalStateException(e);
         }
     }
 
 
         String[] parts = TAB_DELIM_PATTERN.split(line, -2);
         if(parts.length != 8) {
-            throw new RuntimeException("Bad line format '" + line + "' - expected 8 data fields delimited by tab, " +
+            throw new IllegalStateException("Bad line format '" + line + "' - expected 8 data fields delimited by tab, " +
                     "but had " + parts.length + ": " + Arrays.toString(parts));
         }
         int functionIndex = parseInt(parts[0]);
 
     private static byte parseOperandTypeCode(String code) {
         if(code.length() != 1) {
-            throw new RuntimeException("Bad operand type code format '" + code  + "' expected single char");
+            throw new IllegalStateException("Bad operand type code format '" + code  + "' expected single char");
         }
         switch(code.charAt(0)) {
             case 'V': return Ptg.CLASS_VALUE;
         if(DIGIT_ENDING_FUNCTION_NAMES_SET.contains(functionName)) {
             return;
         }
-        throw new RuntimeException("Invalid function name '" + functionName
+        throw new IllegalStateException("Invalid function name '" + functionName
                 + "' (is footnote number incorrectly appended)");
     }
 
         try {
             return Integer.parseInt(valStr);
         } catch (NumberFormatException e) {
-            throw new RuntimeException("Value '" + valStr + "' could not be parsed as an integer");
+            throw new IllegalStateException("Value '" + valStr + "' could not be parsed as an integer");
         }
     }
 }

poi/src/main/java/org/apache/poi/ss/formula/functions/ArrayFunctionUtils.java

         if (ve == BlankEval.instance) {
             return null;
         }
-        throw new RuntimeException("Invalid ValueEval type passed for conversion: ("
+        throw new IllegalStateException("Invalid ValueEval type passed for conversion: ("
                 + ve.getClass() + ")");
     }
 

poi/src/main/java/org/apache/poi/ss/formula/functions/Countif.java

                 case NE:
                     return !cmpResult;
             }
-            throw new RuntimeException("Cannot call boolean evaluate on non-equality operator '"
+            throw new IllegalStateException("Cannot call boolean evaluate on non-equality operator '"
                     + _representation + "'");
         }
         public boolean evaluate(int cmpResult) {
                 case GT: return cmpResult >  0;
                 case GE: return cmpResult >= 0;
             }
-            throw new RuntimeException("Cannot call boolean evaluate on non-equality operator '"
+            throw new IllegalStateException("Cannot call boolean evaluate on non-equality operator '"
                     + _representation + "'");
         }
         @Override
         if(evaluatedCriteriaArg == BlankEval.instance) {
             return null;
         }
-        throw new RuntimeException("Unexpected type for criteria ("
+        throw new IllegalStateException("Unexpected type for criteria ("
                 + evaluatedCriteriaArg.getClass().getName() + ")");
     }
 

poi/src/main/java/org/apache/poi/ss/formula/functions/Index.java

     @Override
     public ValueEval evaluate(int srcRowIndex, int srcColumnIndex, ValueEval arg0, ValueEval arg1,
             ValueEval arg2, ValueEval arg3) {
-        throw new RuntimeException("Incomplete code"
+        throw new IllegalStateException("Incomplete code"
                 + " - don't know how to support the 'area_num' parameter yet)");
         // Excel expression might look like this "INDEX( (A1:B4, C3:D6, D2:E5 ), 1, 2, 3)
         // In this example, the 3rd area would be used i.e. D2:E5, and the overall result would be E2
         }
         // else the other variation of this function takes an array as the first argument
         // it seems like interface 'ArrayEval' does not even exist yet
-        throw new RuntimeException("Incomplete code - cannot handle first arg of type ("
+        throw new IllegalStateException("Incomplete code - cannot handle first arg of type ("
                 + arg0.getClass().getName() + ")");
 
     }

poi/src/main/java/org/apache/poi/ss/formula/functions/Lookup.java

             ValueVector resultVector = createVector(aeResultVector);
             if(lookupVector.getSize() > resultVector.getSize()) {
                 // Excel seems to handle this by accessing past the end of the result vector.
-                throw new RuntimeException("Lookup vector and result vector of differing sizes not supported yet");
+                throw new IllegalStateException("Lookup vector and result vector of differing sizes not supported yet");
             }
             int index = LookupUtils.lookupFirstIndexOfValue(lookupValue, lookupVector, true);
 
             return result;
         }
         // extra complexity required to emulate the way LOOKUP can handles these abnormal cases.
-        throw new RuntimeException("non-vector lookup or result areas not supported yet");
+        throw new IllegalStateException("non-vector lookup or result areas not supported yet");
     }
 }

poi/src/main/java/org/apache/poi/ss/formula/functions/LookupUtils.java

         private final Class<? extends ValueEval> _targetClass;
         protected LookupValueComparerBase(ValueEval targetValue) {
             if(targetValue == null) {
-                throw new RuntimeException("targetValue cannot be null");
+                throw new IllegalStateException("targetValue cannot be null");
             }
             _targetClass = targetValue.getClass();
         }
         @Override
         public final CompareResult compareTo(ValueEval other) {
             if (other == null) {
-                throw new RuntimeException("compare to value cannot be null");
+                throw new IllegalStateException("compare to value cannot be null");
             }
             if (_targetClass != other.getClass()) {
                 return CompareResult.TYPE_MISMATCH;
             // zero is FALSE, everything else is TRUE
             return 0.0 != nve.getNumberValue();
         }
-        throw new RuntimeException("Unexpected eval type (" + valEval + ")");
+        throw new IllegalStateException("Unexpected eval type (" + valEval + ")");
     }
 
     public static int lookupFirstIndexOfValue(ValueEval lookupValue, ValueVector vector, boolean isRangeLookup) throws EvaluationException {

poi/src/main/java/org/apache/poi/ss/formula/functions/Match.java

         @Override
         public ValueEval getItem(int index) {
             if (index != 0) {
-                throw new RuntimeException("Invalid index ("
+                throw new IllegalStateException("Invalid index ("
                         + index + ") only zero is allowed");
             }
             return _value;
             // else looks like a number
             throw new EvaluationException(ErrorEval.NA);
         }
-        throw new RuntimeException("Unexpected eval type (" + eval + ")");
+        throw new IllegalStateException("Unexpected eval type (" + eval + ")");
     }
 
 
             // uses the default-value instead
             return 1;
         }
-        throw new RuntimeException("Unexpected match_type type (" + match_type.getClass().getName() + ")");
+        throw new IllegalStateException("Unexpected match_type type (" + match_type.getClass().getName() + ")");
     }
 
     /**

poi/src/main/java/org/apache/poi/ss/formula/functions/Mode.java

             temp.add(Double.valueOf(((NumberEval) arg).getNumberValue()));
             return;
         }
-        throw new RuntimeException("Unexpected value type (" + arg.getClass().getName() + ")");
+        throw new IllegalStateException("Unexpected value type (" + arg.getClass().getName() + ")");
     }
 }

poi/src/main/java/org/apache/poi/ss/formula/functions/MultiOperandNumericFunction.java

             missingArgConsumer.accept((MissingArgEval) ve, temp);
             return;
         }
-        throw new RuntimeException("Invalid ValueEval type passed for conversion: ("
+        throw new IllegalStateException("Invalid ValueEval type passed for conversion: ("
                 + ve.getClass() + ")");
     }
 

poi/src/main/java/org/apache/poi/ss/formula/functions/Offset.java

         public LinearOffsetRange(int offset, int length) {
             if(length == 0) {
                 // handled that condition much earlier
-                throw new RuntimeException("length may not be zero");
+                throw new IllegalStateException("length may not be zero");
             }
             _offset = offset;
             _length = length;

poi/src/main/java/org/apache/poi/ss/formula/functions/Sumproduct.java

         } catch (EvaluationException e) {
             return e.getErrorEval();
         }
-        throw new RuntimeException("Invalid arg type for SUMPRODUCT: ("
+        throw new IllegalStateException("Invalid arg type for SUMPRODUCT: ("
                 + firstArg.getClass().getName() + ")");
     }
 
         }
 
         if (eval == null) {
-            throw new RuntimeException("parameter may not be null");
+            throw new IllegalStateException("parameter may not be null");
         }
         if (eval instanceof AreaEval) {
             AreaEval ae = (AreaEval) eval;
             NumericValueEval nve = (NumericValueEval) ve;
             return nve.getNumberValue();
         }
-        throw new RuntimeException("Unexpected value eval class ("
+        throw new IllegalStateException("Unexpected value eval class ("
                 + ve.getClass().getName() + ")");
     }
 }

poi/src/main/java/org/apache/poi/ss/formula/functions/Trend.java

             eval = arg;
         }
         if (eval == null) {
-            throw new RuntimeException("Parameter may not be null.");
+            throw new IllegalStateException("Parameter may not be null.");
         }
 
         if (eval instanceof AreaEval) {

poi/src/main/java/org/apache/poi/ss/formula/ptg/AbstractFunctionPtg.java

     protected AbstractFunctionPtg(int functionIndex, int pReturnClass, byte[] paramTypes, int nParams) {
         _numberOfArgs = nParams;
         if (functionIndex < Short.MIN_VALUE || functionIndex > Short.MAX_VALUE)
-            throw new RuntimeException("functionIndex " + functionIndex + " cannot be cast to short");
+            throw new IllegalStateException("functionIndex " + functionIndex + " cannot be cast to short");
         _functionIndex = (short) functionIndex;
         if (pReturnClass < Byte.MIN_VALUE || pReturnClass > Byte.MAX_VALUE)
-            throw new RuntimeException("pReturnClass " + pReturnClass + " cannot be cast to byte");
+            throw new IllegalStateException("pReturnClass " + pReturnClass + " cannot be cast to byte");
         returnClass = (byte) pReturnClass;
         paramClass = paramTypes;
     }
             fm = FunctionMetadataRegistry.getFunctionByIndex(index);
         }
         if(fm == null) {
-            throw new RuntimeException("bad function index (" + index + ", " + isCetab + ")");
+            throw new IllegalStateException("bad function index (" + index + ", " + isCetab + ")");
         }
         return fm.getName();
     }

poi/src/main/java/org/apache/poi/ss/formula/ptg/Area3DPtg.java

 
     @Override
     public String toFormulaString() {
-        throw new RuntimeException("3D references need a workbook to determine formula text");
+        throw new IllegalStateException("3D references need a workbook to determine formula text");
     }
 
     @Override

poi/src/main/java/org/apache/poi/ss/formula/ptg/ArrayPtg.java

     private static String getConstantText(Object o) {
 
         if (o == null) {
-            throw new RuntimeException("Array item cannot be null");
+            throw new IllegalStateException("Array item cannot be null");
         }
         if (o instanceof String) {
             return "\"" + o + "\"";

poi/src/main/java/org/apache/poi/ss/formula/ptg/DeletedArea3DPtg.java

         return ExternSheetNameResolver.prependSheetName(book, field_1_index_extern_sheet, FormulaError.REF.getString());
     }
     public String toFormulaString() {
-        throw new RuntimeException("3D references need a workbook to determine formula text");
+        throw new IllegalStateException("3D references need a workbook to determine formula text");
     }
     @Override
     public byte getDefaultOperandClass() {

poi/src/main/java/org/apache/poi/ss/formula/ptg/DeletedRef3DPtg.java

         return ExternSheetNameResolver.prependSheetName(book, field_1_index_extern_sheet, FormulaError.REF.getString());
     }
     public String toFormulaString() {
-        throw new RuntimeException("3D references need a workbook to determine formula text");
+        throw new IllegalStateException("3D references need a workbook to determine formula text");
     }
     @Override
     public byte getDefaultOperandClass() {

poi/src/main/java/org/apache/poi/ss/formula/ptg/ErrPtg.java

             case REF: return REF_INVALID;
             case VALUE: return VALUE_INVALID;
             default:
-                throw new RuntimeException("Unexpected error code (" + code + ")");
+                throw new IllegalStateException("Unexpected error code (" + code + ")");
         }
     }
 

poi/src/main/java/org/apache/poi/ss/formula/ptg/ExpPtg.java

 
     @Override
     public String toFormulaString() {
-        throw new RuntimeException("Coding Error: Expected ExpPtg to be converted from Shared to Non-Shared Formula by ValueRecordsAggregate, but it wasn't");
+        throw new IllegalStateException("Coding Error: Expected ExpPtg to be converted from Shared to Non-Shared Formula by ValueRecordsAggregate, but it wasn't");
     }
 
     @Override

poi/src/main/java/org/apache/poi/ss/formula/ptg/FuncPtg.java

     public static FuncPtg create(int functionIndex) {
         FunctionMetadata fm = FunctionMetadataRegistry.getFunctionByIndex(functionIndex);
         if(fm == null) {
-            throw new RuntimeException("Invalid built-in function index (" + functionIndex + ")");
+            throw new IllegalStateException("Invalid built-in function index (" + functionIndex + ")");
         }
         return new FuncPtg(functionIndex, fm);
     }

poi/src/main/java/org/apache/poi/ss/formula/ptg/NamePtg.java

 
     @Override
     public String toFormulaString() {
-        throw new RuntimeException("3D references need a workbook to determine formula text");
+        throw new IllegalStateException("3D references need a workbook to determine formula text");
     }
 
     @Override

poi/src/main/java/org/apache/poi/ss/formula/ptg/NameXPtg.java

         return book.resolveNameXText(this);
     }
     public String toFormulaString() {
-        throw new RuntimeException("3D references need a workbook to determine formula text");
+        throw new IllegalStateException("3D references need a workbook to determine formula text");
     }
 
     @Override

poi/src/main/java/org/apache/poi/ss/formula/ptg/Ref3DPtg.java

         return ExternSheetNameResolver.prependSheetName(book, field_1_index_extern_sheet, formatReferenceAsString());
     }
     public String toFormulaString() {
-        throw new RuntimeException("3D references need a workbook to determine formula text");
+        throw new IllegalStateException("3D references need a workbook to determine formula text");
     }
 
     @Override

poi/src/main/java/org/apache/poi/ss/formula/ptg/TblPtg.java

     public String toFormulaString()
     {
         // table(....)[][]
-        throw new RuntimeException("Table and Arrays are not yet supported");
+        throw new IllegalStateException("Table and Arrays are not yet supported");
     }
 
     @Override

poi/src/main/java/org/apache/poi/ss/formula/ptg/ValueOperatorPtg.java

     @Override
     public final String toFormulaString() {
         // TODO - prune this method out of the hierarchy
-        throw new RuntimeException("toFormulaString(String[] operands) should be used for subclasses of OperationPtgs");
+        throw new IllegalStateException("toFormulaString(String[] operands) should be used for subclasses of OperationPtgs");
     }
 }

poi/src/main/java/org/apache/poi/ss/usermodel/DataFormatter.java

             case ERROR:
                 return FormulaError.forInt(cell.getErrorCellValue()).getString();
             default:
-                throw new RuntimeException("Unexpected celltype (" + cellType + ")");
+                throw new IllegalStateException("Unexpected celltype (" + cellType + ")");
         }
     }
 

poi/src/main/java/org/apache/poi/ss/util/AreaReference.java

         String part1 = parts[1];
         if (isPlainColumn(part0)) {
             if (!isPlainColumn(part1)) {
-                throw new RuntimeException("Bad area ref '" + reference + "'");
+                throw new IllegalStateException("Bad area ref '" + reference + "'");
             }
             // Special handling for whole-column references
             // Represented internally as x$1 to x$65536
             // TODO - are references like "Sheet1!A1:Sheet1:B2" ever valid?
             // FormulaParser has code to handle that.
 
-            throw new RuntimeException("Unexpected " + SHEET_NAME_DELIMITER
+            throw new IllegalStateException("Unexpected " + SHEET_NAME_DELIMITER
                     + " in second cell reference of '" + reference + "'");
         }
 

poi/src/main/java/org/apache/poi/ss/util/CellRangeAddressList.java

     }
     public CellRangeAddress remove(int rangeIndex) {
         if (_list.isEmpty()) {
-            throw new RuntimeException("List is empty");
+            throw new IllegalStateException("List is empty");
         }
         if (rangeIndex < 0 || rangeIndex >= _list.size()) {
-            throw new RuntimeException("Range index (" + rangeIndex
+            throw new IllegalStateException("Range index (" + rangeIndex
                     + ") is outside allowable range (0.." + (_list.size()-1) + ")");
         }
         return _list.remove(rangeIndex);

poi/src/main/java/org/apache/poi/ss/util/CellRangeUtil.java

                 // range2 encloses range1, so replace it with the enclosing one
                 return new CellRangeAddress[] { range2 };
         }
-        throw new RuntimeException("unexpected intersection result (" + x + ")");
+        throw new IllegalStateException("unexpected intersection result (" + x + ")");
     }
 
     private static CellRangeAddress[] toArray(List<CellRangeAddress> temp) {

poi/src/main/java/org/apache/poi/ss/util/NumberToTextConverter.java

         NormalisedDecimal rnd = pnd.roundUnits();
         int decExponent = rnd.getDecimalExponent();
         String decimalDigits;
-        if (Math.abs(decExponent)>98) {
+        if (Math.abs(decExponent) > 98) {
             decimalDigits = rnd.getSignificantDecimalDigitsLastDigitRounded();
             if (decimalDigits.length() == 16) {
                 // rounding caused carry
         } else {
             decimalDigits = rnd.getSignificantDecimalDigits();
         }
-        int countSigDigits = countSignifantDigits(decimalDigits);
+        int countSigDigits = countSignificantDigits(decimalDigits);
         if (decExponent < 0) {
             formatLessThanOne(sb, decimalDigits, decExponent, countSigDigits);
         } else {
         return nDigits > MAX_TEXT_LEN;
     }
 
-    private static int countSignifantDigits(String sb) {
-        int result=sb.length()-1;
+    private static int countSignificantDigits(String sb) {
+        int result = sb.length()-1;
         while(sb.charAt(result) == '0') {
             result--;
-            if(result < 0) {
-                throw new RuntimeException("No non-zero digits found");
+            if (result < 0) {
+                throw new IllegalStateException("No non-zero digits found");
             }
         }
         return result + 1;

poi/src/main/java/org/apache/poi/util/HexRead.java

         try {
             return readData(new ByteArrayInputStream( data.getBytes(StringUtil.UTF8) ), -1);
         } catch (IOException e) {
-            throw new RuntimeException(e);
+            throw new IllegalStateException(e);
         }
     }
 

poi/src/main/java/org/apache/poi/util/IOUtils.java

     public static long copy(InputStream srcStream, File destFile) throws IOException {
         File destDirectory = destFile.getParentFile();
         if (!(destDirectory.exists() || destDirectory.mkdirs())) {
-            throw new RuntimeException("Can't create destination directory: "+destDirectory);
+            throw new IllegalStateException("Can't create destination directory: "+destDirectory);
         }
         try (OutputStream destStream = new FileOutputStream(destFile)) {
             return IOUtils.copy(srcStream, destStream);

poi/src/main/java/org/apache/poi/util/LittleEndianByteArrayOutputStream.java

 
     private void checkPosition(int i) {
         if (i > _endIndex - _writeIndex) {
-            throw new RuntimeException("Buffer overrun");
+            throw new IllegalStateException("Buffer overrun");
         }
     }
 

poi/src/main/java/org/apache/poi/util/LittleEndianInputStream.java

         try {
             return super.available();
         } catch (IOException e) {
-            throw new RuntimeException(e);
+            throw new IllegalStateException(e);
         }
     }
 
         try {
             checkEOF(read(buf), 1);
         } catch (IOException e) {
-            throw new RuntimeException(e);
+            throw new IllegalStateException(e);
         }
         return LittleEndian.getUByte(buf);
     }
         try {
             checkEOF(read(buf), buf.length);
         } catch (IOException e) {
-            throw new RuntimeException(e);
+            throw new IllegalStateException(e);
         }
         return LittleEndian.getInt(buf);
     }
         try {
             checkEOF(read(buf), LittleEndianConsts.LONG_SIZE);
         } catch (IOException e) {
-            throw new RuntimeException(e);
+            throw new IllegalStateException(e);
         }
         return LittleEndian.getLong(buf);
     }
         try {
             checkEOF(read(buf), LittleEndianConsts.SHORT_SIZE);
         } catch (IOException e) {
-            throw new RuntimeException(e);
+            throw new IllegalStateException(e);
         }
         return LittleEndian.getUShort(buf);
     }
 
     private static void checkEOF(int actualBytes, int expectedBytes) {
         if (expectedBytes != 0 && (actualBytes == -1 || actualBytes != expectedBytes)) {
-            throw new RuntimeException("Unexpected end-of-file");
+            throw new IllegalStateException("Unexpected end-of-file");
         }
     }
 
         try {
             checkEOF(_read(buf, off, len), len);
         } catch (IOException e) {
-            throw new RuntimeException(e);
+            throw new IllegalStateException(e);
         }
     }
 

poi/src/main/java/org/apache/poi/util/LittleEndianOutputStream.java

         try {
             out.write(v);
         } catch (IOException e) {
-            throw new RuntimeException(e);
+            throw new IllegalStateException(e);
         }
     }
 
             out.write(b2);
             out.write(b3);
         } catch (IOException e) {
-            throw new RuntimeException(e);
+            throw new IllegalStateException(e);
         }
     }
 
             out.write(b0);
             out.write(b1);
         } catch (IOException e) {
-            throw new RuntimeException(e);
+            throw new IllegalStateException(e);
         }
     }
     @Override
         try {
             super.write(b);
         } catch (IOException e) {
-            throw new RuntimeException(e);
+            throw new IllegalStateException(e);
         }
     }
     @Override
         try {
             super.write(b, off, len);
         } catch (IOException e) {
-            throw new RuntimeException(e);
+            throw new IllegalStateException(e);
         }
     }
 
             out.write( (byte) ( ( value >>> 16 ) & 0xFF ) );
             out.write( (byte) ( ( value >>> 24 ) & 0xFF ) );
         } catch (IOException e) {
-            throw new RuntimeException(e);
+            throw new IllegalStateException(e);
         }
     }
 
             out.write( (byte) ( ( value ) & 0xFF ) );
             out.write( (byte) ( ( value >>> 8 ) & 0xFF ) );
         } catch (IOException e) {
-            throw new RuntimeException(e);
+            throw new IllegalStateException(e);
         }
     }
 }

poi/src/main/java/org/apache/poi/util/XMLHelper.java

             throw re;
         } catch (Exception e) {
             logThrowable(e, "Failed to create SAXParserFactory", "-");
-            throw new RuntimeException("Failed to create SAXParserFactory", e);
+            throw new IllegalStateException("Failed to create SAXParserFactory", e);
         }
     }