Fixed all test failures related to #2177

cowtowncoder · cowtowncoder · commit a092470181c7 · 2021-01-16T19:30:11.000-08:00
diff --git a/src/main/java/com/fasterxml/jackson/databind/ext/jdk8/DoubleStreamSerializer.java b/src/main/java/com/fasterxml/jackson/databind/ext/jdk8/DoubleStreamSerializer.java
@@ -26,7 +26,7 @@ private DoubleStreamSerializer() {
     }
 
     @Override
-    public void serialize(DoubleStream stream, JsonGenerator g, SerializerProvider provider)
+    public void serialize(DoubleStream stream, JsonGenerator g, SerializerProvider ctxt)
         throws JacksonException
     {
         try (final DoubleStream ds = stream) {
@@ -35,6 +35,10 @@ public void serialize(DoubleStream stream, JsonGenerator g, SerializerProvider p
                 g.writeNumber(value);
             });
             g.writeEndArray();
-        } 
+        } catch (Exception e) {
+            // For most regular serializers we won't both handling but streams are typically
+            // root values so 
+            wrapAndThrow(ctxt, e, stream, g.getOutputContext().getCurrentIndex());
+        }
     }
 }
diff --git a/src/main/java/com/fasterxml/jackson/databind/ext/jdk8/IntStreamSerializer.java b/src/main/java/com/fasterxml/jackson/databind/ext/jdk8/IntStreamSerializer.java
@@ -28,16 +28,19 @@ private IntStreamSerializer() {
     }
 
     @Override
-    public void serialize(IntStream stream, JsonGenerator g, SerializerProvider provider)
+    public void serialize(IntStream stream, JsonGenerator g, SerializerProvider ctxt)
         throws JacksonException
     {
         try (IntStream is = stream) {
             g.writeStartArray(is);
             is.forEach(value -> {
                 g.writeNumber(value);
             });
-            
             g.writeEndArray();
+        } catch (Exception e) {
+            // For most regular serializers we won't both handling but streams are typically
+            // root values so 
+            wrapAndThrow(ctxt, e, stream, g.getOutputContext().getCurrentIndex());
         }
     }
 }
diff --git a/src/main/java/com/fasterxml/jackson/databind/ext/jdk8/Jdk8StreamSerializer.java b/src/main/java/com/fasterxml/jackson/databind/ext/jdk8/Jdk8StreamSerializer.java
@@ -60,20 +60,24 @@ public JsonSerializer<?> createContextual(SerializerProvider provider, BeanPrope
     }
 
     @Override
-    public void serialize(Stream<?> stream, JsonGenerator g, SerializerProvider provider)
-            throws JacksonException
+    public void serialize(Stream<?> stream, JsonGenerator g, SerializerProvider ctxt)
+        throws JacksonException
     {
         try (Stream<?> s = stream) {
             g.writeStartArray(s);
             
             s.forEach(elem -> {
                 if (elemSerializer == null) {
-                    provider.writeValue(g, elem);
+                    ctxt.writeValue(g, elem);
                 } else {
-                    elemSerializer.serialize(elem, g, provider);
+                    elemSerializer.serialize(elem, g, ctxt);
                 }
             });
             g.writeEndArray();
+        } catch (Exception e) {
+            // For most regular serializers we won't both handling but streams are typically
+            // root values so 
+            wrapAndThrow(ctxt, e, stream, g.getOutputContext().getCurrentIndex());
         }
     }
 }
diff --git a/src/main/java/com/fasterxml/jackson/databind/ext/jdk8/LongStreamSerializer.java b/src/main/java/com/fasterxml/jackson/databind/ext/jdk8/LongStreamSerializer.java
@@ -25,7 +25,7 @@ private LongStreamSerializer() {
     }
 
     @Override
-    public void serialize(LongStream stream, JsonGenerator g, SerializerProvider provider)
+    public void serialize(LongStream stream, JsonGenerator g, SerializerProvider ctxt)
         throws JacksonException
     {
         try (LongStream ls = stream) {
@@ -34,6 +34,10 @@ public void serialize(LongStream stream, JsonGenerator g, SerializerProvider pro
                 g.writeNumber(value);
             });
             g.writeEndArray();
+        } catch (Exception e) {
+            // For most regular serializers we won't both handling but streams are typically
+            // root values so 
+            wrapAndThrow(ctxt, e, stream, g.getOutputContext().getCurrentIndex());
         }
     }
 }
diff --git a/src/main/java/com/fasterxml/jackson/databind/ser/std/StdSerializer.java b/src/main/java/com/fasterxml/jackson/databind/ser/std/StdSerializer.java
@@ -9,6 +9,7 @@
 import com.fasterxml.jackson.annotation.JsonInclude;
 import com.fasterxml.jackson.core.*;
 import com.fasterxml.jackson.core.JsonParser.NumberType;
+import com.fasterxml.jackson.core.exc.WrappedIOException;
 import com.fasterxml.jackson.databind.*;
 import com.fasterxml.jackson.databind.annotation.JacksonStdImpl;
 import com.fasterxml.jackson.databind.introspect.AnnotatedMember;
@@ -234,29 +235,30 @@ protected void visitArrayFormat(JsonFormatVisitorWrapper visitor, JavaType typeH
      * Rules for wrapping and unwrapping are bit complicated; essentially:
      *<ul>
      * <li>Errors are to be passed as is (if uncovered via unwrapping)
-     * <li>"Plain" IOExceptions (ones that are not of type
-     *   {@link JsonMappingException} are to be passed as is
+     * <li>Wrapped {@code IOException}s are unpeeled
      *</ul>
      */
     public void wrapAndThrow(SerializerProvider provider,
             Throwable t, Object bean, String fieldName)
         throws JacksonException
     {
-        /* 05-Mar-2009, tatu: But one nasty edge is when we get
-         *   StackOverflow: usually due to infinite loop. But that
-         *   usually gets hidden within an InvocationTargetException...
-         */
+        // 05-Mar-2009, tatu: But one nasty edge is when we get
+        //   StackOverflow: usually due to infinite loop. But that
+        //   usually gets hidden within an InvocationTargetException...
         while (t instanceof InvocationTargetException && t.getCause() != null) {
             t = t.getCause();
         }
-        // Errors and "plain" to be passed as is
+        // 16-Jan-2021, tatu: Let's peel off useless wrapper as well
+        while (t instanceof WrappedIOException && t.getCause() != null) {
+            t = t.getCause();
+        }
+        // Errors to be passed as is, most others not
         ClassUtil.throwIfError(t);
-        // Ditto for IOExceptions... except for mapping exceptions!
-        boolean wrap = (provider == null) || provider.isEnabled(SerializationFeature.WRAP_EXCEPTIONS);
-        if (t instanceof JacksonException) {
-            throw (JacksonException) t;
-        } else if (!wrap) {
-            ClassUtil.throwIfRTE(t);
+        if (!(t instanceof JacksonException)) {
+            boolean wrap = (provider == null) || provider.isEnabled(SerializationFeature.WRAP_EXCEPTIONS);
+            if (!wrap) {
+                ClassUtil.throwIfRTE(t);
+            }
         }
         // Need to add reference information
         throw JsonMappingException.wrapWithPath(t, bean, fieldName);
@@ -269,14 +271,16 @@ public void wrapAndThrow(SerializerProvider provider,
         while (t instanceof InvocationTargetException && t.getCause() != null) {
             t = t.getCause();
         }
-        // Errors are to be passed as is
+        while (t instanceof WrappedIOException && t.getCause() != null) {
+            t = t.getCause();
+        }
+        // Errors to be passed as is, most others not
         ClassUtil.throwIfError(t);
-        // Ditto for IOExceptions... except for mapping exceptions!
-        boolean wrap = (provider == null) || provider.isEnabled(SerializationFeature.WRAP_EXCEPTIONS);
-        if (t instanceof JacksonException) {
-            throw (JacksonException) t;
-        } else if (!wrap) {
-            ClassUtil.throwIfRTE(t);
+        if (!(t instanceof JacksonException)) {
+            boolean wrap = (provider == null) || provider.isEnabled(SerializationFeature.WRAP_EXCEPTIONS);
+            if (!wrap) {
+                ClassUtil.throwIfRTE(t);
+            }
         }
         // Need to add reference information
         throw JsonMappingException.wrapWithPath(t, bean, index);
diff --git a/src/test/java/com/fasterxml/jackson/databind/exc/TestExceptionsDuringWriting.java b/src/test/java/com/fasterxml/jackson/databind/exc/TestExceptionsDuringWriting.java
@@ -4,7 +4,7 @@
 import java.util.*;
 
 import com.fasterxml.jackson.core.*;
-import com.fasterxml.jackson.core.exc.WrappedIOException;
+
 import com.fasterxml.jackson.databind.*;
 import com.fasterxml.jackson.databind.module.SimpleModule;
 import com.fasterxml.jackson.databind.testutil.BrokenStringWriter;
@@ -88,8 +88,8 @@ public void testExceptionWithSimpleMapper()
             BrokenStringWriter sw = new BrokenStringWriter("TEST");
             mapper.writeValue(sw, createLongObject());
             fail("Should have gotten an exception");
-        } catch (WrappedIOException e) {
-            verifyException(e, WrappedIOException.class, "TEST");
+        } catch (JsonMappingException e) {
+            verifyException(e, JsonMappingException.class, "TEST");
             Throwable root = e.getCause();
             assertNotNull(root);
 
diff --git a/src/test/java/com/fasterxml/jackson/databind/ext/jdk8/StreamTestBase.java b/src/test/java/com/fasterxml/jackson/databind/ext/jdk8/StreamTestBase.java
@@ -1,6 +1,5 @@
 package com.fasterxml.jackson.databind.ext.jdk8;
 
-import java.io.IOException;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.function.Consumer;
 import java.util.stream.BaseStream;
@@ -12,6 +11,7 @@
 import org.junit.Rule;
 import org.junit.rules.ExpectedException;
 
+import com.fasterxml.jackson.core.exc.WrappedIOException;
 import com.fasterxml.jackson.databind.JsonMappingException;
 import com.fasterxml.jackson.databind.ObjectMapper;
 
@@ -61,22 +61,20 @@ <T, S extends BaseStream<T, S>> void assertClosesOnRuntimeException(String excep
     <T, S extends BaseStream<T, S>> void assertClosesOnIoException(String exceptionMessage, Consumer<S> roundTrip,
             S baseStream) {
         AtomicBoolean closed = new AtomicBoolean();
-        initExpectedExceptionIoException(exceptionMessage,closed);
+        this.expectedException.expect(new IsClosedMatcher(closed));
+        this.expectedException.expect(Is.isA(JsonMappingException.class));
+        this.expectedException.expectMessage(exceptionMessage);
         roundTrip.accept(baseStream.onClose(() -> closed.set(true)));
     }
 
     <T, S extends BaseStream<T, S>> void assertClosesOnWrappedIoException(String exceptionMessage,
             Consumer<S> roundTrip, S baseStream) {
         AtomicBoolean closed = new AtomicBoolean();
-        final String actualMessage = "Unexpected IOException (of type java.io.IOException): " + exceptionMessage;
-        initExpectedExceptionIoException(actualMessage,closed);
-        roundTrip.accept(baseStream.onClose(() -> closed.set(true)));
-    }
-
-    void initExpectedExceptionIoException(final String exceptionMessage, AtomicBoolean closed) {
+        final String actualMessage = exceptionMessage;
         this.expectedException.expect(new IsClosedMatcher(closed));
-        this.expectedException.expect(Is.isA(IOException.class));
-        this.expectedException.expectMessage(exceptionMessage);
+        this.expectedException.expect(Is.isA(JsonMappingException.class));
+        this.expectedException.expectMessage(actualMessage);
+        roundTrip.accept(baseStream.onClose(() -> closed.set(true)));
     }
 
     void initExpectedException(Class<? extends Throwable> cause, final String exceptionMessage, AtomicBoolean closed) {

Original file line number	Diff line number	Diff line change
`@@ -26,7 +26,7 @@ private DoubleStreamSerializer() {`
`26`	`26`	`}`
`27`	`27`
`28`	`28`	`@Override`
`29`		`- public void serialize(DoubleStream stream, JsonGenerator g, SerializerProvider provider)`
	`29`	`+ public void serialize(DoubleStream stream, JsonGenerator g, SerializerProvider ctxt)`
`30`	`30`	`throws JacksonException`
`31`	`31`	`{`
`32`	`32`	`try (final DoubleStream ds = stream) {`
`@@ -35,6 +35,10 @@ public void serialize(DoubleStream stream, JsonGenerator g, SerializerProvider p`
`35`	`35`	`g.writeNumber(value);`
`36`	`36`	`});`
`37`	`37`	`g.writeEndArray();`
`38`		`- }`
	`38`	`+ } catch (Exception e) {`
	`39`	`+ // For most regular serializers we won't both handling but streams are typically`
	`40`	`+ // root values so`
	`41`	`+ wrapAndThrow(ctxt, e, stream, g.getOutputContext().getCurrentIndex());`
	`42`	`+ }`
`39`	`43`	`}`
`40`	`44`	`}`
Original file line number	Diff line number	Diff line change
`@@ -28,16 +28,19 @@ private IntStreamSerializer() {`
`28`	`28`	`}`
`29`	`29`
`30`	`30`	`@Override`
`31`		`- public void serialize(IntStream stream, JsonGenerator g, SerializerProvider provider)`
	`31`	`+ public void serialize(IntStream stream, JsonGenerator g, SerializerProvider ctxt)`
`32`	`32`	`throws JacksonException`
`33`	`33`	`{`
`34`	`34`	`try (IntStream is = stream) {`
`35`	`35`	`g.writeStartArray(is);`
`36`	`36`	`is.forEach(value -> {`
`37`	`37`	`g.writeNumber(value);`
`38`	`38`	`});`
`39`		`-`
`40`	`39`	`g.writeEndArray();`
	`40`	`+ } catch (Exception e) {`
	`41`	`+ // For most regular serializers we won't both handling but streams are typically`
	`42`	`+ // root values so`
	`43`	`+ wrapAndThrow(ctxt, e, stream, g.getOutputContext().getCurrentIndex());`
`41`	`44`	`}`
`42`	`45`	`}`
`43`	`46`	`}`
Original file line number	Diff line number	Diff line change
`@@ -60,20 +60,24 @@ public JsonSerializer<?> createContextual(SerializerProvider provider, BeanPrope`
`60`	`60`	`}`
`61`	`61`
`62`	`62`	`@Override`
`63`		`- public void serialize(Stream<?> stream, JsonGenerator g, SerializerProvider provider)`
`64`		`- throws JacksonException`
	`63`	`+ public void serialize(Stream<?> stream, JsonGenerator g, SerializerProvider ctxt)`
	`64`	`+ throws JacksonException`
`65`	`65`	`{`
`66`	`66`	`try (Stream<?> s = stream) {`
`67`	`67`	`g.writeStartArray(s);`
`68`	`68`
`69`	`69`	`s.forEach(elem -> {`
`70`	`70`	`if (elemSerializer == null) {`
`71`		`- provider.writeValue(g, elem);`
	`71`	`+ ctxt.writeValue(g, elem);`
`72`	`72`	`} else {`
`73`		`- elemSerializer.serialize(elem, g, provider);`
	`73`	`+ elemSerializer.serialize(elem, g, ctxt);`
`74`	`74`	`}`
`75`	`75`	`});`
`76`	`76`	`g.writeEndArray();`
	`77`	`+ } catch (Exception e) {`
	`78`	`+ // For most regular serializers we won't both handling but streams are typically`
	`79`	`+ // root values so`
	`80`	`+ wrapAndThrow(ctxt, e, stream, g.getOutputContext().getCurrentIndex());`
`77`	`81`	`}`
`78`	`82`	`}`
`79`	`83`	`}`
Original file line number	Diff line number	Diff line change
`@@ -25,7 +25,7 @@ private LongStreamSerializer() {`
`25`	`25`	`}`
`26`	`26`
`27`	`27`	`@Override`
`28`		`- public void serialize(LongStream stream, JsonGenerator g, SerializerProvider provider)`
	`28`	`+ public void serialize(LongStream stream, JsonGenerator g, SerializerProvider ctxt)`
`29`	`29`	`throws JacksonException`
`30`	`30`	`{`
`31`	`31`	`try (LongStream ls = stream) {`
`@@ -34,6 +34,10 @@ public void serialize(LongStream stream, JsonGenerator g, SerializerProvider pro`
`34`	`34`	`g.writeNumber(value);`
`35`	`35`	`});`
`36`	`36`	`g.writeEndArray();`
	`37`	`+ } catch (Exception e) {`
	`38`	`+ // For most regular serializers we won't both handling but streams are typically`
	`39`	`+ // root values so`
	`40`	`+ wrapAndThrow(ctxt, e, stream, g.getOutputContext().getCurrentIndex());`
`37`	`41`	`}`
`38`	`42`	`}`
`39`	`43`	`}`