refactor: Add Result.fromExc, 'fix' coverage

Author: MarcellPerger1

src/main/java/net/marcellperger/mathexpr/util/JacocoIgnoreNotGenerated.java

@@ -0,0 +1,4 @@
+package net.marcellperger.mathexpr.util;
+
+public @interface JacocoIgnoreNotGenerated {
+}

src/main/java/net/marcellperger/mathexpr/util/rs/Result.java

@@ -1,5 +1,6 @@
 package net.marcellperger.mathexpr.util.rs;
 
+import net.marcellperger.mathexpr.util.JacocoIgnoreNotGenerated;
 import net.marcellperger.mathexpr.util.ThrowingSupplier;
 import net.marcellperger.mathexpr.util.Util;
 import org.jetbrains.annotations.NotNull;
@@ -52,17 +53,30 @@ static <T, E> Result<T, E> newErr(E err) {
         return new Err<>(err);
     }
 
+    /** Same as fromExc but also fills in the stack trace using
+     * {@link Throwable#fillInStackTrace()} for more useful error messages */
+    static <T, E extends Throwable> @NotNull Result<T, E> fromExc(@NotNull E exc) {
+        exc.fillInStackTrace();
+        return newErr(exc);
+    }
+
     static <T, E extends Throwable> Result<T, E> fromTry(ThrowingSupplier<? extends T, E> inner, Class<E> catchThis) {
         try {
             return newOk(inner.get());
         } catch (Throwable exc) {
-            try {
-                return newErr(catchThis.cast(exc));
-            } catch (ClassCastException c) {
-                // We've handled E, so only unchecked exceptions should reach here
-                // so it's safe to throw them (but Java doesn't know that so we trick it)
-                return Util.throwAsUnchecked(exc);
-            }
+            return _makeErrTypeOrFailUnchecked(exc, catchThis);
+        }
+    }
+
+    @NotNull
+    @JacocoIgnoreNotGenerated
+    private static <T, E extends Throwable> Result<T, E> _makeErrTypeOrFailUnchecked(Throwable exc, Class<E> catchThis) {
+        try {
+            return newErr(catchThis.cast(exc));
+        } catch (ClassCastException c) {
+            // We've handled E, so only unchecked exceptions should reach here
+            // so it's safe to throw them (but Java doesn't know that so we trick it)
+            return Util.throwAsUnchecked(exc);  // Jacoco doesn't realize that the `return` is unreachable
         }
     }
 

src/test/java/net/marcellperger/mathexpr/util/rs/ResultTest.java

@@ -4,10 +4,7 @@
 import net.marcellperger.mathexpr.util.rs.Result.Ok;
 import org.junit.jupiter.api.Test;
 
-import java.util.ArrayList;
-import java.util.Iterator;
-import java.util.List;
-import java.util.Optional;
+import java.util.*;
 
 import static net.marcellperger.mathexpr.MiniMock.*;
 import static org.junit.jupiter.api.Assertions.*;
@@ -479,4 +476,42 @@ public UnexpectedCheckedCustomException(String message) {
             super(message);
         }
     }
-}
+
+    @Test
+    void fromExc() {
+        CheckedCustomException cce = new CheckedCustomException("Message");
+        Result<Object, CheckedCustomException> result = inner0(cce);
+        CheckedCustomException cceOut = result.expectErr("fromExc() didn't return Err value");
+        assertEquals(cce, cceOut);
+
+        StackTraceElement currFrame = getCurrentStack();
+        List<StackTraceElement> st = Arrays.stream(cceOut.getStackTrace())
+            .filter(f -> f.getClassName().equals(currFrame.getClassName()))
+            .filter(f -> Objects.equals(f.getFileName(), currFrame.getFileName()))
+            .filter(f -> Objects.equals(f.getModuleName(), currFrame.getModuleName()))
+            .filter(f -> Objects.equals(f.getModuleVersion(), currFrame.getModuleVersion()))
+            .filter(f -> Objects.equals(f.getClassLoaderName(), currFrame.getClassLoaderName()))
+            .toList();
+        List<StackTraceElement> i0 = st.stream()
+            .filter(f -> f.getMethodName().equals("inner0"))
+            .toList();
+        assertEquals(1, i0.size(), "Expected exactly 1 inner0 frame");
+        List<StackTraceElement> i1 = st.stream()
+            .filter(f -> f.getMethodName().equals("inner0"))
+            .toList();
+        assertEquals(1, i1.size(), "Expected exactly 1 inner1 frame");
+    }
+
+    private StackTraceElement getCurrentStack() {
+        return StackWalker.getInstance()
+            .walk(s -> /*Skip this methods*/s.skip(1).findFirst())
+            .orElseThrow().toStackTraceElement();
+    }
+
+    private Result<Object, CheckedCustomException> inner0(CheckedCustomException exc) {
+        return inner1(exc);
+    }
+    private Result<Object, CheckedCustomException> inner1(CheckedCustomException exc) {
+        return Result.fromExc(exc);
+    }
+}