fix: avoid ClassCastException in Try when an undeclared RuntimeException occurs

orThrow()/orElse()/orElseApply() used the generically inferred checked
exception type as a functional-interface parameter type. Due to type
erasure, an implicit checkcast to that inferred type was generated at
the call site, so any undeclared unchecked exception (e.g. a
RuntimeException surfacing from a jackcess bug) was reported as a
misleading ClassCastException instead of the actual failure. Use
Throwable for these parameters instead.

Adjust call sites accordingly: where the concrete exception type can
no longer be inferred from context, cast explicitly (Metadata,
AbstractBaseTest, UcanaccessBaseTest) or widen the accepted function
type (UcanaccessStatement.tryCatch).

Author: spannm

src/main/java/net/ucanaccess/converters/Metadata.java

@@ -282,7 +282,7 @@ public List<String> getColumnNames(String tableName) throws SQLException {
                 result.add(rs.getString(COLUMN_NAME));
             }
             return !SYSTEM_SUBQUERY.equals(tableName) ? result : null;
-        }).orThrow(ex -> ex);
+        }).orThrow(ex -> (SQLException) ex);
     }
 
     public String getColumnName(String escapedTableName, String escapedColumnName) throws SQLException {
@@ -297,7 +297,7 @@ public String getColumnName(String escapedTableName, String escapedColumnName) t
                 }
             }
             return null;
-        }).orThrow(ex -> ex);
+        }).orThrow(ex -> (SQLException) ex);
     }
 
     public String getEscapedColumnName(String tableName, String columnName) throws SQLException {
@@ -306,15 +306,15 @@ public String getEscapedColumnName(String tableName, String columnName) throws S
             ps.setString(2, columnName);
             ResultSet rs = ps.executeQuery();
             return rs.next() ? rs.getString(ESCAPED_COLUMN_NAME) : null;
-        }).orThrow(ex -> ex);
+        }).orThrow(ex -> (SQLException) ex);
     }
 
     public String getEscapedTableName(String tableName) throws SQLException {
         return Try.withResources(() -> conn.prepareStatement(SELECT_TABLE_ESCAPED), ps -> {
             ps.setString(1, tableName);
             ResultSet rs = ps.executeQuery();
             return rs.next() ? rs.getString(ESCAPED_TABLE_NAME) : null;
-        }).orThrow(ex -> ex);
+        }).orThrow(ex -> (SQLException) ex);
     }
 
     public boolean isAutoIncrement(String tableName, String columnName) throws SQLException {
@@ -323,7 +323,7 @@ public boolean isAutoIncrement(String tableName, String columnName) throws SQLEx
             ps.setString(2, columnName);
             ResultSet rs = ps.executeQuery();
             return rs.next() && rs.getBoolean(IS_AUTOINCREMENT);
-        }).orThrow(ex -> ex);
+        }).orThrow(ex -> (SQLException) ex);
     }
 
     public boolean isCurrency(String tableName, String columnName) throws SQLException {
@@ -332,30 +332,30 @@ public boolean isCurrency(String tableName, String columnName) throws SQLExcepti
             ps.setString(2, columnName);
             ResultSet rs = ps.executeQuery();
             return rs.next() && rs.getBoolean(IS_CURRENCY);
-        }).orThrow(ex -> ex);
+        }).orThrow(ex -> (SQLException) ex);
     }
 
     public Integer getTableId(String escapedName) throws SQLException {
         return Try.withResources(() -> conn.prepareStatement(SELECT_TABLE_METADATA), ps -> {
             ps.setString(1, escapedName);
             ResultSet rs = ps.executeQuery();
             return rs.next() ? rs.getInt(TABLE_ID) : -1;
-        }).orThrow(ex -> ex);
+        }).orThrow(ex -> (SQLException) ex);
     }
 
     public String getTableName(String escapedName) throws SQLException {
         return Try.withResources(() -> conn.prepareStatement(SELECT_TABLE_METADATA), ps -> {
             ps.setString(1, escapedName);
             ResultSet rs = ps.executeQuery();
             return rs.next() ? rs.getString(TABLE_NAME) : null;
-        }).orThrow(ex -> ex);
+        }).orThrow(ex -> (SQLException) ex);
     }
 
     public void dropTable(String tableName) throws SQLException {
         Try.withResources(() -> conn.prepareStatement(DROP_TABLE), ps -> {
             ps.setString(1, tableName);
             ps.execute();
-        }).orThrow(ex -> ex);
+        }).orThrow(ex -> (SQLException) ex);
     }
 
     public void columnDef(String tableName, String columnName, String def) throws SQLException {
@@ -364,15 +364,15 @@ public void columnDef(String tableName, String columnName, String def) throws SQ
             ps.setString(2, columnName);
             ps.setString(3, tableName);
             ps.execute();
-        }).orThrow(ex -> ex);
+        }).orThrow(ex -> (SQLException) ex);
     }
 
     public void calculatedField(String tableName, String columnName) throws SQLException {
         Try.withResources(() -> conn.prepareStatement(UPDATE_IS_GENERATEDCOLUMN), ps -> {
             ps.setString(1, columnName);
             ps.setString(2, tableName);
             ps.execute();
-        }).orThrow(ex -> ex);
+        }).orThrow(ex -> (SQLException) ex);
     }
 
     public void rename(String oldTableName, String newTableName, String newEscapedTableName) throws SQLException {
@@ -381,7 +381,7 @@ public void rename(String oldTableName, String newTableName, String newEscapedTa
             ps.setString(2, newEscapedTableName);
             ps.setString(3, oldTableName);
             ps.executeUpdate();
-        }).orThrow(ex -> ex);
+        }).orThrow(ex -> (SQLException) ex);
     }
 
 }

src/main/java/net/ucanaccess/jdbc/UcanaccessStatement.java

@@ -394,7 +394,7 @@ protected static final <R, T extends Throwable> R tryCatch(IThrowingSupplier<R,
         return tryCatch(catchable, UcanaccessSQLException::wrap);
     }
 
-    protected static final <R, T extends Throwable> R tryCatch(IThrowingSupplier<R, T> catchable, Function<T, UcanaccessSQLException> exSupplier) throws UcanaccessSQLException {
+    protected static final <R, T extends Throwable> R tryCatch(IThrowingSupplier<R, T> catchable, Function<Throwable, UcanaccessSQLException> exSupplier) throws UcanaccessSQLException {
         return Try.catching(catchable).orThrow(exSupplier);
     }
 

src/main/java/net/ucanaccess/util/Try.java

@@ -246,7 +246,7 @@ public V orElse(V other) {
      * If an exception occurs during execution of the throwing consumer, that exception is thrown.
      * @param consumer consumer to execute in case of exception. The exception object is passed to the consumer.
      */
-    public void orElse(IThrowingConsumer<EC, Throwable> consumer) {
+    public void orElse(IThrowingConsumer<Throwable, Throwable> consumer) {
         if (hasThrown()) {
             catching(() -> consumer.accept(t)).orThrow();
         }
@@ -258,7 +258,7 @@ public void orElse(IThrowingConsumer<EC, Throwable> consumer) {
      * @param function function to execute in case of exception. The exception object is passed to the function.
      * @return the successful value or value returned by the function
      */
-    public V orElseApply(IThrowingFunction<EC, V, Throwable> function) {
+    public V orElseApply(IThrowingFunction<Throwable, V, Throwable> function) {
         if (hasThrown()) {
             return catching(() -> function.apply(t)).orThrow();
         }
@@ -306,7 +306,7 @@ public V orThrow() {
      * @return the successful value
      * @throws T2 the exception returned by {@code function}
      */
-    public <T2 extends Throwable> V orThrow(Function<EC, T2> function) throws T2 {
+    public <T2 extends Throwable> V orThrow(Function<Throwable, T2> function) throws T2 {
         Objects.requireNonNull(function, "Function required");
         if (hasThrown()) {
             Throwable t2 = function.apply(t);

src/test/java/net/ucanaccess/test/AbstractBaseTest.java

@@ -107,15 +107,15 @@ protected static File copyFile(Path source, File target) {
         UcanaccessRuntimeException.requireNonNull(source, "Source file required");
         UcanaccessRuntimeException.requireNonNull(target, "Target file required");
         Try.catching(() -> Files.copy(source, target.toPath(), StandardCopyOption.REPLACE_EXISTING))
-            .orThrow(e -> new UncheckedIOException("Failed to copy '" + source + "' to '" + target + "'", e));
+            .orThrow(e -> new UncheckedIOException("Failed to copy '" + source + "' to '" + target + "'", (IOException) e));
         return target;
     }
 
     protected static File copyFile(InputStream in, File target) {
         UcanaccessRuntimeException.requireNonNull(in, "Input stream required");
         UcanaccessRuntimeException.requireNonNull(target, "Target file required");
         Try.catching(() -> Files.copy(in, target.toPath(), StandardCopyOption.REPLACE_EXISTING))
-            .orThrow(e -> new UncheckedIOException("Failed to copy to '" + target + "'", e));
+            .orThrow(e -> new UncheckedIOException("Failed to copy to '" + target + "'", (IOException) e));
         return target;
     }
 

src/test/java/net/ucanaccess/test/UcanaccessBaseTest.java

@@ -284,8 +284,10 @@ private void diffResultSets(ResultSet resultSet, ResultSet verifyResultSet, Char
                         + objExpected + " in [" + query + ']');
                 } else {
                     if (objActual instanceof Blob) {
-                        byte[] barrActual = Try.withResources(((Blob) objActual)::getBinaryStream, InputStream::readAllBytes).orThrow(UncheckedIOException::new);
-                        byte[] barrExpected = Try.withResources(((Blob) objExpected)::getBinaryStream, InputStream::readAllBytes).orThrow(UncheckedIOException::new);
+                        byte[] barrActual = Try.withResources(((Blob) objActual)::getBinaryStream, InputStream::readAllBytes)
+                            .orThrow(e -> new UncheckedIOException((IOException) e));
+                        byte[] barrExpected = Try.withResources(((Blob) objExpected)::getBinaryStream, InputStream::readAllBytes)
+                            .orThrow(e -> new UncheckedIOException((IOException) e));
                         for (int y = 0; y < barrExpected.length; y++) {
                             assertEquals(barrExpected[y], barrActual[y], "Byte mismatch at position " + y + " in column " + col + " in blob");
                         }
@@ -442,14 +444,14 @@ protected File createTempFile(String prefix) {
         File f = createTempFileName(prefix);
 
         getLogger().log(Level.DEBUG, "Creating temp file {0}", f);
-        Try.catching(() -> Files.createFile(f.toPath())).orThrow(UncheckedIOException::new);
+        Try.catching(() -> Files.createFile(f.toPath())).orThrow(e -> new UncheckedIOException((IOException) e));
 
         f.deleteOnExit();
         return f;
     }
 
     void createNewDatabase(FileFormat fileFormat, File dbFile) {
-        Try.withResources(() -> DatabaseBuilder.create(fileFormat, dbFile), Database::flush).orThrow(UncheckedIOException::new);
+        Try.withResources(() -> DatabaseBuilder.create(fileFormat, dbFile), Database::flush).orThrow(e -> new UncheckedIOException((IOException) e));
         getLogger().log(Level.INFO, "Access {0} database created: {1}", fileFormat.name(), dbFile.getAbsolutePath());
     }
 

src/test/java/net/ucanaccess/util/TryTest.java

@@ -71,7 +71,8 @@ void testSupplierThrowsCheckedException() {
         assertEquals(-1L, tryCatch.orElseApply(t -> -1L));
         assertEquals(-1L, tryCatch.orElseGet(() -> -1L));
         assertSame(ex1, assertThrows(IOException.class, tryCatch::orThrow));
-        UncheckedIOException unioex = assertThrows(UncheckedIOException.class, () -> tryCatch.orThrow(UncheckedIOException::new));
+        UncheckedIOException unioex = assertThrows(UncheckedIOException.class,
+            () -> tryCatch.orThrow(t -> new UncheckedIOException((IOException) t)));
         assertSame(ex1, unioex.getCause());
 
         Try<Boolean, Throwable> mappedtc = tryCatch.map(size -> {
@@ -102,4 +103,24 @@ void testSupplierThrowsRuntimeException() {
         assertSame(exception, rtex.getCause());
     }
 
+    @Test
+    void testSupplierThrowsUndeclaredRuntimeExceptionDoesNotThrowClassCastException() {
+        // regression test: the code block is statically inferred to only throw IOException,
+        // but actually throws an unrelated, undeclared RuntimeException at runtime (e.g. a bug
+        // deeper in some library). orThrow()/orElse()/orElseApply() must not fail with a
+        // ClassCastException while trying to treat that exception as an IOException
+        Try<Integer, IOException> tryCatch = Try.catching(() -> {
+            int[] tooSmall = new int[2];
+            return tooSmall[5];
+        });
+
+        assertTrue(tryCatch.hasThrown());
+        assertInstanceOf(ArrayIndexOutOfBoundsException.class, tryCatch.getException());
+
+        assertEquals(-1, tryCatch.orElseApply(t -> -1));
+
+        RuntimeException wrapped = assertThrows(RuntimeException.class, () -> tryCatch.orThrow(RuntimeException::new));
+        assertInstanceOf(ArrayIndexOutOfBoundsException.class, wrapped.getCause());
+    }
+
 }