johnzon.david.diff

diff --git a/johnzon-core/src/main/java/org/apache/johnzon/core/Snippet.java b/johnzon-core/src/main/java/org/apache/johnzon/core/Snippet.java
index 1afaceb..23fd3d7 100644
--- a/johnzon-core/src/main/java/org/apache/johnzon/core/Snippet.java
+++ b/johnzon-core/src/main/java/org/apache/johnzon/core/Snippet.java
@@ -16,25 +16,26 @@
  */
 package org.apache.johnzon.core;
 
-import javax.json.Json;
 import javax.json.JsonArray;
 import javax.json.JsonObject;
 import javax.json.JsonValue;
 import javax.json.stream.JsonGenerator;
+import javax.json.stream.JsonGeneratorFactory;
 import java.io.ByteArrayOutputStream;
 import java.io.IOException;
 import java.io.OutputStream;
-import java.io.UncheckedIOException;
 import java.util.Map;
 
 public class Snippet {
 
-    private final JsonGenerator generator;
+    private final JsonGeneratorFactory generatorFactory;
     private final SnippetOutputStream snippet;
 
-    private Snippet(final int max) {
+    private JsonGenerator generator;
+
+    private Snippet(final int max, final JsonGeneratorFactory generatorFactory) {
         this.snippet = new SnippetOutputStream(max);
-        this.generator = Json.createGenerator(snippet);
+        this.generatorFactory = generatorFactory; // ensure we reuse the mapper config, including the encoding
     }
 
     private void write(final JsonValue value) {
@@ -42,17 +43,25 @@ public class Snippet {
             return;
         }
 
-        switch (value.getValueType()) {
-            case ARRAY: {
-                write((JsonArray) value);
-                break;
-            }
-            case OBJECT: {
-                write((JsonObject) value);
-                break;
+        final boolean created = generator == null;
+        if (created) {
+            generator = generatorFactory.createGenerator(snippet);
+        }
+
+        try {
+            switch (value.getValueType()) {
+                case ARRAY:
+                    write(value.asJsonArray());
+                    break;
+                case OBJECT:
+                    write(value.asJsonObject());
+                    break;
+                default:
+                    generator.write(value);
             }
-            default: {
-                generator.write(value);
+        } finally {
+            if (created) {
+                generator.close();
             }
         }
     }
@@ -107,6 +116,9 @@ public class Snippet {
                 generator.writeStartArray(name);
                 final JsonArray array = value.asJsonArray();
                 for (final JsonValue jsonValue : array) {
+                    if (snippet.isComplete()) {
+                        break;
+                    }
                     write(jsonValue);
                 }
                 generator.writeEnd();
@@ -116,6 +128,9 @@ public class Snippet {
                 generator.writeStartObject(name);
                 final JsonObject object = value.asJsonObject();
                 for (final Map.Entry<String, JsonValue> keyval : object.entrySet()) {
+                    if (snippet.isComplete()) {
+                        break;
+                    }
                     write(keyval.getKey(), keyval.getValue());
                 }
                 generator.writeEnd();
@@ -125,25 +140,20 @@ public class Snippet {
         }
     }
 
-    private String get() {
-        generator.close();
-        return snippet.get();
-    }
+    public static class Factory {
+        private final JsonGeneratorFactory generatorFactory;
+        private final int max;
 
-    public static String of(final JsonValue object) {
-        return of(object, 50);
-    }
+        public Factory(final JsonGeneratorFactory generatorFactory,
+                       final int max) {
+            this.generatorFactory = generatorFactory;
+            this.max = max;
+        }
 
-    public static String of(final JsonValue value, final int max) {
-        final Snippet snippet = new Snippet(max);
-        switch (value.getValueType()) {
-            case TRUE: return "true";
-            case FALSE: return "false";
-            case NULL: return "null";
-            default: {
-                snippet.write(value);
-                return snippet.get();
-            }
+        public String of(final JsonValue value) {
+            final Snippet snippet = new Snippet(max, generatorFactory);
+            snippet.write(value);
+            return snippet.snippet.get();
         }
     }
 
@@ -159,10 +169,9 @@ public class Snippet {
 
         public String get() {
             if (isComplete()) {
-                return buffer.toString() + "...";
-            } else {
-                return buffer.toString();
+                return buffer + "...";
             }
+            return buffer.toString();
         }
 
         public boolean isComplete() {
@@ -194,14 +203,6 @@ public class Snippet {
             mode.close();
         }
 
-        public void print(final String string) {
-            try {
-                mode.write(string.getBytes());
-            } catch (IOException e) {
-                throw new UncheckedIOException(e);
-            }
-        }
-
         class Writing extends OutputStream {
             private final int max;
             private int count;
@@ -254,8 +255,8 @@ public class Snippet {
         static class Ignoring extends OutputStream {
             @Override
             public void write(final int b) throws IOException {
+                // no-op
             }
         }
-
     }
 }
diff --git a/johnzon-core/src/test/java/org/apache/johnzon/core/SnippetTest.java b/johnzon-core/src/test/java/org/apache/johnzon/core/SnippetTest.java
index 7ccf90c..004cb31 100644
--- a/johnzon-core/src/test/java/org/apache/johnzon/core/SnippetTest.java
+++ b/johnzon-core/src/test/java/org/apache/johnzon/core/SnippetTest.java
@@ -16,43 +16,78 @@
  */
 package org.apache.johnzon.core;
 
+import org.junit.Before;
 import org.junit.Test;
 
 import javax.json.Json;
 import javax.json.JsonObject;
 import javax.json.JsonValue;
+import javax.json.stream.JsonGenerator;
+import javax.json.stream.JsonGeneratorFactory;
 import javax.json.stream.JsonParser;
 import java.io.ByteArrayInputStream;
+import java.io.OutputStream;
+import java.math.BigDecimal;
+import java.math.BigInteger;
 
 import static org.junit.Assert.assertEquals;
 
 public class SnippetTest {
+    private int generatedCloseCalls = 0;
+    private final JsonGeneratorFactory generatorFactory = new JsonGeneratorFactoryImpl(null) {
+        @Override
+        public JsonGenerator createGenerator(final OutputStream out) {
+            return new DelegatingGenerator(super.createGenerator(out)) {
+                @Override
+                public void close() {
+                    super.close();
+                    generatedCloseCalls++;
+                }
+            };
+        }
+    };
+    private final Snippet.Factory snippets1 = new Snippet.Factory(generatorFactory, 1);
+    private final Snippet.Factory snippets15 = new Snippet.Factory(generatorFactory, 15);
+    private final Snippet.Factory snippets30 = new Snippet.Factory(generatorFactory, 30);
+    private final Snippet.Factory snippets40 = new Snippet.Factory(generatorFactory, 40);
+    private final Snippet.Factory snippets50 = new Snippet.Factory(generatorFactory, 50);
+    private final Snippet.Factory snippets100 = new Snippet.Factory(generatorFactory, 100);
+    private final Snippet.Factory snippets200 = new Snippet.Factory(generatorFactory, 200);
+
+    @Before
+    public void reset() {
+        generatedCloseCalls = 0;
+    }
 
     @Test
     public void simple() {
         final String jsonText = "{\"name\":\"string\",\"value\":\"string\",\"type\":\"string\"}";
-        final JsonParser jsonParser = Json.createParser(new ByteArrayInputStream(jsonText.getBytes()));
-        final JsonObject object = jsonParser.getObject();
+        final JsonObject object = load(jsonText).asJsonObject();
 
         // This snippet is smaller than the allowed size.  It should show in entirety.
-        assertEquals("{\"name\":\"string\",\"value\":\"string\",\"type\":\"string\"}", Snippet.of(object, 100));
+        assertEquals("{\"name\":\"string\",\"value\":\"string\",\"type\":\"string\"}", snippets100.of(object));
+        assertEquals(1, generatedCloseCalls);
 
         // This snippet is exactly 50 characters when formatted.  We should see no "..." at the end.
-        assertEquals("{\"name\":\"string\",\"value\":\"string\",\"type\":\"string\"}", Snippet.of(object, 50));
+        assertEquals("{\"name\":\"string\",\"value\":\"string\",\"type\":\"string\"}", snippets50.of(object));
+        assertEquals(2, generatedCloseCalls);
 
         // This snippet is too large.  We should see the "..." at the end.
-        assertEquals("{\"name\":\"string\",\"value\":\"stri...", Snippet.of(object, 30));
+        assertEquals("{\"name\":\"string\",\"value\":\"stri...", snippets30.of(object));
+        assertEquals(3, generatedCloseCalls);
     }
 
     @Test
     public void mapOfArray() {
         final String jsonText = "{\"name\": [\"red\", \"green\", \"blue\"], \"value\": [\"orange\", \"yellow\", \"purple\"]}";
 
-        final JsonParser jsonParser = Json.createParser(new ByteArrayInputStream(jsonText.getBytes()));
-        final JsonObject object = jsonParser.getObject();
+        final JsonObject object = load(jsonText).asJsonObject();
+
+        assertEquals("{\"name\":[\"red\",\"green\",\"blue\"],\"value\":[\"orange\",\"yellow\",\"purple\"]}", snippets200.of(object));
+        assertEquals(1, generatedCloseCalls);
 
-        assertEquals("{\"name\":[\"red\",\"green\",\"blue\"],\"value\":[\"orange\",\"yellow\",\"purple\"]}", Snippet.of(object, 200));
-        assertEquals("{\"name\":[\"red\",\"green\",\"blue\"],\"value\":[\"orange\",\"...", Snippet.of(object, 50));
+        assertEquals("{\"name\":[\"red\",\"green\",\"blue\"],\"value\":[\"orange\",\"...", snippets50.of(object));
+        assertEquals(2, generatedCloseCalls);
     }
 
     @Test
@@ -60,199 +95,343 @@ public class SnippetTest {
         final String jsonText = "{\"name\": {\"name\": \"red\", \"value\": \"green\", \"type\": \"blue\"}," +
                 " \"value\": {\"name\": \"orange\", \"value\": \"purple\", \"type\": \"yellow\"}}";
 
-        final JsonParser jsonParser = Json.createParser(new ByteArrayInputStream(jsonText.getBytes()));
-        final JsonObject object = jsonParser.getObject();
+        final JsonObject object = load(jsonText).asJsonObject();
 
         assertEquals("{\"name\":{\"name\":\"red\",\"value\":\"green\",\"type\":\"blue\"}," +
-                "\"value\":{\"name\":\"orange\",\"value\":\"purple\",\"type\":\"yellow\"}}", Snippet.of(object, 200));
+                "\"value\":{\"name\":\"orange\",\"value\":\"purple\",\"type\":\"yellow\"}}", snippets200.of(object));
+        assertEquals(1, generatedCloseCalls);
 
         assertEquals("{\"name\":{\"name\":\"red\",\"value\":\"green\",\"type\":\"blue\"}," +
-                "\"value\":{\"name\":\"orange\",\"value\":\"purple\",\"type...", Snippet.of(object, 100));
+                "\"value\":{\"name\":\"orange\",\"value\":\"purple\",\"type...", snippets100.of(object));
+        assertEquals(2, generatedCloseCalls);
     }
 
     @Test
     public void mapOfNestedMaps() {
         final String jsonText = "{\"name\": {\"name\": {\"name\": {\"name\": \"red\", \"value\": \"green\", \"type\": \"blue\"}}}}";
 
-        final JsonParser jsonParser = Json.createParser(new ByteArrayInputStream(jsonText.getBytes()));
-        final JsonObject object = jsonParser.getObject();
+        final JsonObject object = load(jsonText).asJsonObject();
 
         assertEquals("{\"name\":{\"name\":{\"name\":{\"name\":\"red\"," +
-                "\"value\":\"green\",\"type\":\"blue\"}}}}", Snippet.of(object, 100));
+                "\"value\":\"green\",\"type\":\"blue\"}}}}", snippets100.of(object));
 
-        assertEquals("{\"name\":{\"name\":{\"name\":{\"name\":\"red\",\"value\":\"gre...", Snippet.of(object, 50));
+        assertEquals("{\"name\":{\"name\":{\"name\":{\"name\":\"red\",\"value\":\"gre...", snippets50.of(object));
     }
 
     @Test
     public void mapOfString() {
         final String jsonText = "{\"name\":\"string\",\"value\":\"string\",\"type\":\"string\"}";
-        final JsonParser jsonParser = Json.createParser(new ByteArrayInputStream(jsonText.getBytes()));
-        final JsonObject object = jsonParser.getObject();
-        assertEquals("{\"name\":\"string\",\"value\":\"string\",\"type\":\"string\"}", Snippet.of(object, 50));
-        assertEquals("{\"name\":\"string\",\"value\":\"stri...", Snippet.of(object, 30));
+        final JsonObject object = load(jsonText).asJsonObject();
+        assertEquals("{\"name\":\"string\",\"value\":\"string\",\"type\":\"string\"}", snippets50.of(object));
+        assertEquals("{\"name\":\"string\",\"value\":\"stri...", snippets30.of(object));
     }
 
     @Test
     public void mapOfNumber() {
         final String jsonText = "{\"name\":1234,\"value\":5,\"type\":67890}";
-        final JsonParser jsonParser = Json.createParser(new ByteArrayInputStream(jsonText.getBytes()));
-        final JsonObject object = jsonParser.getObject();
+        final JsonObject object = load(jsonText).asJsonObject();
 
-        assertEquals("{\"name\":1234,\"value\":5,\"type\":67890}", Snippet.of(object, 40));
-        assertEquals("{\"name\":1234,\"value\":5,\"type\":...", Snippet.of(object, 30));
+        assertEquals("{\"name\":1234,\"value\":5,\"type\":67890}", snippets40.of(object));
+        assertEquals("{\"name\":1234,\"value\":5,\"type\":...", snippets30.of(object));
     }
 
     @Test
     public void mapOfTrue() {
         final String jsonText = "{\"name\":true,\"value\":true,\"type\":true}";
-        final JsonParser jsonParser = Json.createParser(new ByteArrayInputStream(jsonText.getBytes()));
-        final JsonObject object = jsonParser.getObject();
+        final JsonObject object = load(jsonText).asJsonObject();
 
-        assertEquals("{\"name\":true,\"value\":true,\"type\":true}", Snippet.of(object, 40));
-        assertEquals("{\"name\":true,\"value\":true,\"typ...", Snippet.of(object, 30));
+        assertEquals("{\"name\":true,\"value\":true,\"type\":true}", snippets40.of(object));
+        assertEquals("{\"name\":true,\"value\":true,\"typ...", snippets30.of(object));
     }
 
     @Test
     public void mapOfFalse() {
         final String jsonText = "{\"name\":false,\"value\":false,\"type\":false}";
-        final JsonParser jsonParser = Json.createParser(new ByteArrayInputStream(jsonText.getBytes()));
-        final JsonObject object = jsonParser.getObject();
+        final JsonObject object = load(jsonText).asJsonObject();
 
-        assertEquals("{\"name\":false,\"value\":false,\"type\":false}", Snippet.of(object, 50));
-        assertEquals("{\"name\":false,\"value\":false,\"t...", Snippet.of(object, 30));
+        assertEquals("{\"name\":false,\"value\":false,\"type\":false}", snippets50.of(object));
+        assertEquals("{\"name\":false,\"value\":false,\"t...", snippets30.of(object));
     }
 
     @Test
     public void mapOfNull() {
         final String jsonText = "{\"name\":null,\"value\":null,\"type\":null}";
-        final JsonParser jsonParser = Json.createParser(new ByteArrayInputStream(jsonText.getBytes()));
-        final JsonObject object = jsonParser.getObject();
+        final JsonObject object = load(jsonText).asJsonObject();
 
-        assertEquals("{\"name\":null,\"value\":null,\"type\":null}", Snippet.of(object, 50));
-        assertEquals("{\"name\":null,\"value\":null,\"typ...", Snippet.of(object, 30));
+        assertEquals("{\"name\":null,\"value\":null,\"type\":null}", snippets50.of(object));
+        assertEquals("{\"name\":null,\"value\":null,\"typ...", snippets30.of(object));
     }
 
     @Test
     public void arrayOfArray() {
         final String jsonText = "[[\"red\",\"green\"], [1,22,333], [{\"r\":  255,\"g\": 165}], [true, false]]";
-        final JsonParser jsonParser = Json.createParser(new ByteArrayInputStream(jsonText.getBytes()));
-        final JsonValue object = jsonParser.getValue();
+        final JsonValue object = load(jsonText);
 
-        assertEquals("[[\"red\",\"green\"],[1,22,333],[{\"r\":255,\"g\":165}],[true,false]]", Snippet.of(object, 100));
-        assertEquals("[[\"red\",\"green\"],[1,22,333],[{\"r\":255,\"g...", Snippet.of(object, 40));
+        assertEquals("[[\"red\",\"green\"],[1,22,333],[{\"r\":255,\"g\":165}],[true,false]]", snippets100.of(object));
+        assertEquals("[[\"red\",\"green\"],[1,22,333],[{\"r\":255,\"g...", snippets40.of(object));
     }
 
     @Test
     public void arrayOfObject() {
         final String jsonText = "[{\"r\":  255,\"g\": \"165\"},{\"g\":  0,\"a\": \"0\"},{\"transparent\": false}]";
-        final JsonParser jsonParser = Json.createParser(new ByteArrayInputStream(jsonText.getBytes()));
-        final JsonValue object = jsonParser.getValue();
+        final JsonValue object = load(jsonText);
 
-        assertEquals("[{\"r\":255,\"g\":\"165\"},{\"g\":0,\"a\":\"0\"},{\"transparent\":false}]", Snippet.of(object, 100));
-        assertEquals("[{\"r\":255,\"g\":\"165\"},{\"g\":0,\"a...", Snippet.of(object, 30));
+        assertEquals("[{\"r\":255,\"g\":\"165\"},{\"g\":0,\"a\":\"0\"},{\"transparent\":false}]", snippets100.of(object));
+        assertEquals("[{\"r\":255,\"g\":\"165\"},{\"g\":0,\"a...", snippets30.of(object));
     }
 
     @Test
     public void arrayOfString() {
         final String jsonText = "[\"red\", \"green\", \"blue\", \"orange\", \"yellow\", \"purple\"]";
-        final JsonParser jsonParser = Json.createParser(new ByteArrayInputStream(jsonText.getBytes()));
-        final JsonValue object = jsonParser.getValue();
+        final JsonValue object = load(jsonText);
 
-        assertEquals("[\"red\",\"green\",\"blue\",\"orange\",\"yellow\",\"purple\"]", Snippet.of(object, 100));
-        assertEquals("[\"red\",\"green\",\"blue\",\"orange\"...", Snippet.of(object, 30));
+        assertEquals("[\"red\",\"green\",\"blue\",\"orange\",\"yellow\",\"purple\"]", snippets100.of(object));
+        assertEquals("[\"red\",\"green\",\"blue\",\"orange\"...", snippets30.of(object));
     }
 
     @Test
     public void arrayOfNumber() {
         final String jsonText = "[1,22,333,4444,55555,666666,7777777,88888888,999999999]";
-        final JsonParser jsonParser = Json.createParser(new ByteArrayInputStream(jsonText.getBytes()));
-        final JsonValue object = jsonParser.getValue();
+        final JsonValue object = load(jsonText);
 
-        assertEquals("[1,22,333,4444,55555,666666,7777777,88888888,999999999]", Snippet.of(object, 100));
-        assertEquals("[1,22,333,4444,55555,666666,77...", Snippet.of(object, 30));
+        assertEquals("[1,22,333,4444,55555,666666,7777777,88888888,999999999]", snippets100.of(object));
+        assertEquals("[1,22,333,4444,55555,666666,77...", snippets30.of(object));
     }
 
     @Test
     public void arrayOfTrue() {
         final String jsonText = "[true,true,true,true,true,true,true,true]";
-        final JsonParser jsonParser = Json.createParser(new ByteArrayInputStream(jsonText.getBytes()));
-        final JsonValue object = jsonParser.getValue();
+        final JsonValue object = load(jsonText);
 
-        assertEquals("[true,true,true,true,true,true,true,true]", Snippet.of(object, 100));
-        assertEquals("[true,true,true,true,true,true...", Snippet.of(object, 30));
+        assertEquals("[true,true,true,true,true,true,true,true]", snippets100.of(object));
+        assertEquals("[true,true,true,true,true,true...", snippets30.of(object));
     }
 
     @Test
     public void arrayOfFalse() {
         final String jsonText = "[false,false,false,false,false,false,false]";
-        final JsonParser jsonParser = Json.createParser(new ByteArrayInputStream(jsonText.getBytes()));
-        final JsonValue object = jsonParser.getValue();
+        final JsonValue object = load(jsonText);
 
-        assertEquals("[false,false,false,false,false,false,false]", Snippet.of(object, 100));
-        assertEquals("[false,false,false,false,false...", Snippet.of(object, 30));
+        assertEquals("[false,false,false,false,false,false,false]", snippets100.of(object));
+        assertEquals("[false,false,false,false,false...", snippets30.of(object));
     }
 
     @Test
     public void arrayOfNull() {
         final String jsonText = "[null,null,null,null,null,null]";
-        final JsonParser jsonParser = Json.createParser(new ByteArrayInputStream(jsonText.getBytes()));
-        final JsonValue object = jsonParser.getValue();
+        final JsonValue object = load(jsonText);
 
-        assertEquals("[null,null,null,null,null,null]", Snippet.of(object, 50));
-        assertEquals("[null,null,null...", Snippet.of(object, 15));
+        assertEquals("[null,null,null,null,null,null]", snippets50.of(object));
+        assertEquals("[null,null,null...", snippets15.of(object));
     }
 
     @Test
     public void string() {
         final String jsonText = "\"This is a \\\"string\\\" with quotes in it.  It should be properly escaped.\"";
-        final JsonParser jsonParser = Json.createParser(new ByteArrayInputStream(jsonText.getBytes()));
-        final JsonValue object = jsonParser.getValue();
+        final JsonValue object = load(jsonText);
 
-        assertEquals("\"This is a \\\"string\\\" with quotes in it.  It should be properly escaped.\"", Snippet.of(object, 100));
-        assertEquals("\"This is a \\\"string\\\" with quotes in it.  It shoul...", Snippet.of(object, 50));
+        assertEquals("\"This is a \\\"string\\\" with quotes in it.  It should be properly escaped.\"", snippets100.of(object));
+        assertEquals("\"This is a \\\"string\\\" with quotes in it.  It shoul...", snippets50.of(object));
     }
 
     @Test
     public void number() {
         final String jsonText = "1223334444555556666667777777.88888888999999999";
-        final JsonParser jsonParser = Json.createParser(new ByteArrayInputStream(jsonText.getBytes()));
-        final JsonValue object = jsonParser.getValue();
+        final JsonValue object = load(jsonText);
 
-        assertEquals("1223334444555556666667777777.88888888999999999", Snippet.of(object, 50));
-        assertEquals("1223334444555556666667777777.8...", Snippet.of(object, 30));
+        assertEquals("1223334444555556666667777777.88888888999999999", snippets50.of(object));
+        assertEquals("1223334444555556666667777777.8...", snippets30.of(object));
     }
 
     @Test
     public void trueValue() {
         final String jsonText = "true";
-        final JsonParser jsonParser = Json.createParser(new ByteArrayInputStream(jsonText.getBytes()));
-        final JsonValue object = jsonParser.getValue();
+        final JsonValue object = load(jsonText);
 
-        assertEquals("true", Snippet.of(object, 50));
-        // we don't trim 'true' -- showing users something like 't...' doesn't make much sense
-        assertEquals("true", Snippet.of(object, 1));
+        assertEquals("true", snippets50.of(object));
+        assertEquals("t...", snippets1.of(object));
     }
 
     @Test
     public void falseValue() {
         final String jsonText = "false";
-        final JsonParser jsonParser = Json.createParser(new ByteArrayInputStream(jsonText.getBytes()));
-        final JsonValue object = jsonParser.getValue();
+        final JsonValue object = load(jsonText);
 
-        assertEquals("false", Snippet.of(object, 50));
-        // we don't trim 'false' -- showing users something like 'f...' doesn't make much sense
-        assertEquals("false", Snippet.of(object, 1));
+        assertEquals("false", snippets50.of(object));
+        // we do trim 'false' -- showing users something like 'f...' doesn't make much sense but actually len=1 does not make sense
+        assertEquals("f...", snippets1.of(object));
     }
 
     @Test
     public void nullValue() {
         final String jsonText = "null";
-        final JsonParser jsonParser = Json.createParser(new ByteArrayInputStream(jsonText.getBytes()));
-        final JsonValue object = jsonParser.getValue();
+        final JsonValue object = load(jsonText);
 
-        assertEquals("null", Snippet.of(object, 50));
-        // we don't trim 'null' -- showing users something like 'n...' doesn't make much sense
-        assertEquals("null", Snippet.of(object, 1));
+        assertEquals("null", snippets50.of(object));
+        // we do trim 'null' -- showing users something like 'n...' doesn't make much sense but is the request (len=1 does not make sense)
+        assertEquals("n...", snippets1.of(object));
     }
 
+    private JsonValue load(final String jsonText) {
+        try (final JsonParser jsonParser = Json.createParser(new ByteArrayInputStream(jsonText.getBytes()))) {
+            return jsonParser.getValue();
+        }
+    }
+
+    private static abstract class DelegatingGenerator implements JsonGenerator {
+        protected final JsonGenerator delegate;
+
+        protected DelegatingGenerator(final JsonGenerator generator) {
+            this.delegate = generator;
+        }
+
+        @Override
+        public JsonGenerator writeStartObject() {
+            return delegate.writeStartObject();
+        }
+
+        @Override
+        public JsonGenerator writeStartObject(final String name) {
+            return delegate.writeStartObject(name);
+        }
+
+        @Override
+        public JsonGenerator writeStartArray() {
+            return delegate.writeStartArray();
+        }
+
+        @Override
+        public JsonGenerator writeStartArray(final String name) {
+            return delegate.writeStartArray(name);
+        }
+
+        @Override
+        public JsonGenerator writeEnd() {
+            return delegate.writeEnd();
+        }
+
+        @Override
+        public JsonGenerator writeKey(final String name) {
+            delegate.writeKey(name);
+            return this;
+        }
+
+        @Override
+        public JsonGenerator write(final String name, final JsonValue value) {
+            delegate.write(name, value);
+            return this;
+        }
+
+        @Override
+        public JsonGenerator write(final String name, final String value) {
+            delegate.write(name, value);
+            return this;
+        }
+
+        @Override
+        public JsonGenerator write(final String name, final BigInteger value) {
+            delegate.write(name, value);
+            return this;
+        }
+
+        @Override
+        public JsonGenerator write(final String name, final BigDecimal value) {
+            delegate.write(name, value);
+            return this;
+        }
+
+        @Override
+        public JsonGenerator write(final String name, final int value) {
+            delegate.write(name, value);
+            return this;
+        }
+
+        @Override
+        public JsonGenerator write(final String name, final long value) {
+            delegate.write(name, value);
+            return this;
+        }
+
+        @Override
+        public JsonGenerator write(final String name, final double value) {
+            delegate.write(name, value);
+            return this;
+        }
+
+        @Override
+        public JsonGenerator write(final String name, final boolean value) {
+            delegate.write(name, value);
+            return this;
+        }
+
+        @Override
+        public JsonGenerator writeNull(final String name) {
+            delegate.writeNull(name);
+            return this;
+        }
+
+        @Override
+        public JsonGenerator write(final JsonValue value) {
+            delegate.write(value);
+            return this;
+        }
+
+        @Override
+        public JsonGenerator write(final String value) {
+            delegate.write(value);
+            return this;
+        }
+
+        @Override
+        public JsonGenerator write(final BigDecimal value) {
+            delegate.write(value);
+            return this;
+        }
+
+        @Override
+        public JsonGenerator write(final BigInteger value) {
+            delegate.write(value);
+            return this;
+        }
+
+        @Override
+        public JsonGenerator write(final int value) {
+            delegate.write(value);
+            return this;
+        }
+
+        @Override
+        public JsonGenerator write(final long value) {
+            delegate.write(value);
+            return this;
+        }
+
+        @Override
+        public JsonGenerator write(final double value) {
+            delegate.write(value);
+            return this;
+        }
+
+        @Override
+        public JsonGenerator write(boolean value) {
+            delegate.write(value);
+            return this;
+        }
+
+        @Override
+        public JsonGenerator writeNull() {
+            delegate.writeNull();
+            return this;
+        }
+
+        @Override
+        public void close() {
+            delegate.close();
+        }
+
+        @Override
+        public void flush() {
+            delegate.flush();
+        }
+    }
 }
diff --git a/johnzon-jaxrs/src/main/java/org/apache/johnzon/jaxrs/ConfigurableJohnzonProvider.java b/johnzon-jaxrs/src/main/java/org/apache/johnzon/jaxrs/ConfigurableJohnzonProvider.java
index ab616cc..f841e30 100644
--- a/johnzon-jaxrs/src/main/java/org/apache/johnzon/jaxrs/ConfigurableJohnzonProvider.java
+++ b/johnzon-jaxrs/src/main/java/org/apache/johnzon/jaxrs/ConfigurableJohnzonProvider.java
@@ -108,6 +108,10 @@ public class ConfigurableJohnzonProvider<T> implements MessageBodyWriter<T>, Mes
         instance().writeTo(t, rawType, genericType, annotations, mediaType, httpHeaders, entityStream);
     }
 
+    public void setSnippetMaxLength(final int value) {
+        builder.setSnippetMaxLength(value);
+    }
+
     public void setUseJsRange(final boolean value) {
         builder.setUseJsRange(value);
     }
diff --git a/johnzon-jaxrs/src/main/java/org/apache/johnzon/jaxrs/WildcardConfigurableJohnzonProvider.java b/johnzon-jaxrs/src/main/java/org/apache/johnzon/jaxrs/WildcardConfigurableJohnzonProvider.java
index e841125..8b9be38 100644
--- a/johnzon-jaxrs/src/main/java/org/apache/johnzon/jaxrs/WildcardConfigurableJohnzonProvider.java
+++ b/johnzon-jaxrs/src/main/java/org/apache/johnzon/jaxrs/WildcardConfigurableJohnzonProvider.java
@@ -126,6 +126,10 @@ public class WildcardConfigurableJohnzonProvider<T> implements MessageBodyWriter
         }
     }
 
+    public void setSnippetMaxLength(final int value) {
+        builder.setSnippetMaxLength(value);
+    }
+
     public void setFailOnUnknownProperties(final boolean active) {
         builder.setFailOnUnknownProperties(active);
     }
diff --git a/johnzon-jsonb/src/main/java/org/apache/johnzon/jsonb/JohnzonBuilder.java b/johnzon-jsonb/src/main/java/org/apache/johnzon/jsonb/JohnzonBuilder.java
index c068809..5afe718 100644
--- a/johnzon-jsonb/src/main/java/org/apache/johnzon/jsonb/JohnzonBuilder.java
+++ b/johnzon-jsonb/src/main/java/org/apache/johnzon/jsonb/JohnzonBuilder.java
@@ -234,6 +234,12 @@ public class JohnzonBuilder implements JsonbBuilder {
                                 .orElse(false)));
         builder.setAccessMode(accessMode);
 
+        config.getProperty("johnzon.snippetMaxLength")
+                .map(it -> Number.class.isInstance(it)?
+                        Number.class.cast(it).intValue() :
+                        Integer.parseInt(it.toString()))
+                .ifPresent(builder::setSnippetMaxLength);
+
         // user adapters
         config.getProperty(JsonbConfig.ADAPTERS).ifPresent(adapters -> Stream.of(JsonbAdapter[].class.cast(adapters)).forEach(adapter -> {
             final ParameterizedType pt = ParameterizedType.class.cast(
diff --git a/johnzon-mapper/src/main/java/org/apache/johnzon/mapper/MapperBuilder.java b/johnzon-mapper/src/main/java/org/apache/johnzon/mapper/MapperBuilder.java
index 5075ed4..4cd8372 100644
--- a/johnzon-mapper/src/main/java/org/apache/johnzon/mapper/MapperBuilder.java
+++ b/johnzon-mapper/src/main/java/org/apache/johnzon/mapper/MapperBuilder.java
@@ -23,6 +23,7 @@ import static java.util.Collections.emptyMap;
 import static java.util.Locale.ROOT;
 
 // import org.apache.johnzon.core.JsonParserFactoryImpl; // don't depend on core in mapper
+import org.apache.johnzon.core.Snippet;
 import org.apache.johnzon.mapper.access.AccessMode;
 import org.apache.johnzon.mapper.access.BaseAccessMode;
 import org.apache.johnzon.mapper.access.FieldAccessMode;
@@ -81,6 +82,7 @@ public class MapperBuilder {
     private boolean pretty;
     private final Collection<Closeable> closeables = new ArrayList<Closeable>();
     private int version = -1;
+    private int snippetMaxLength = 50;
     private boolean close;
     private boolean skipNull = true;
     private boolean skipEmptyArray;
@@ -236,7 +238,8 @@ public class MapperBuilder {
                         supportEnumContainerDeserialization,
                         typeLoader, discriminatorMapper, discriminator,
                         deserializationPredicate, serializationPredicate,
-                        enumConverterFactory),
+                        enumConverterFactory,
+                        new Snippet.Factory(generatorFactory, snippetMaxLength)),
                 closeables);
     }
 
@@ -248,6 +251,11 @@ public class MapperBuilder {
         return adapters;
     }
 
+    public MapperBuilder setSnippetMaxLength(final int snippetMaxLength) {
+        this.snippetMaxLength = snippetMaxLength;
+        return this;
+    }
+
     public MapperBuilder setUseShortISO8601Format(final boolean useShortISO8601Format) {
         adapters.setUseShortISO8601Format(useShortISO8601Format);
         return this;
diff --git a/johnzon-mapper/src/main/java/org/apache/johnzon/mapper/MapperConfig.java b/johnzon-mapper/src/main/java/org/apache/johnzon/mapper/MapperConfig.java
index 4d8bceb..a355bb4 100644
--- a/johnzon-mapper/src/main/java/org/apache/johnzon/mapper/MapperConfig.java
+++ b/johnzon-mapper/src/main/java/org/apache/johnzon/mapper/MapperConfig.java
@@ -18,11 +18,13 @@
  */
 package org.apache.johnzon.mapper;
 
+import org.apache.johnzon.core.Snippet;
 import org.apache.johnzon.mapper.access.AccessMode;
 import org.apache.johnzon.mapper.internal.AdapterKey;
 import org.apache.johnzon.mapper.internal.ConverterAdapter;
 import org.apache.johnzon.mapper.map.LazyConverterMap;
 
+import javax.json.Json;
 import javax.json.JsonValue;
 import java.lang.reflect.Type;
 import java.nio.charset.Charset;
@@ -36,6 +38,7 @@ import java.util.concurrent.ConcurrentMap;
 import java.util.function.Function;
 import java.util.function.Predicate;
 
+import static java.util.Collections.emptyMap;
 import static java.util.stream.Collectors.toList;
 
 /**
@@ -94,8 +97,11 @@ public /* DON'T MAKE IT HIDDEN */ class MapperConfig implements Cloneable {
 
     private final Function<Class<?>, CustomEnumConverter<?>> enumConverterFactory;
 
-    //disable checkstyle for 10+ parameters
+    private final Snippet.Factory snippetFactory;
+
+
     //CHECKSTYLE:OFF
+    @Deprecated
     public MapperConfig(final LazyConverterMap adapters,
                         final Map<Class<?>, ObjectConverter.Writer<?>> objectConverterWriters,
                         final Map<Class<?>, ObjectConverter.Reader<?>> objectConverterReaders,
@@ -119,6 +125,41 @@ public /* DON'T MAKE IT HIDDEN */ class MapperConfig implements Cloneable {
                         final Predicate<Class<?>> deserializationPredicate,
                         final Predicate<Class<?>> serializationPredicate,
                         final Function<Class<?>, CustomEnumConverter<?>> enumConverterFactory) {
+        //CHECKSTYLE:ON
+        this(adapters, objectConverterWriters, objectConverterReaders, version, close, skipNull, skipEmptyArray,
+                treatByteArrayAsBase64, treatByteArrayAsBase64URL, readAttributeBeforeWrite, accessMode, encoding,
+                attributeOrder, failOnUnknown, serializeValueFilter, useBigDecimalForFloats, deduplicateObjects, interfaceImplementationMapping,
+                useJsRange, useBigDecimalForObjectNumbers, supportEnumMapDeserialization, typeLoader,
+                discriminatorMapper, discriminator, deserializationPredicate, serializationPredicate, enumConverterFactory,
+                new Snippet.Factory(Json.createGeneratorFactory(emptyMap()), 50));
+    }
+
+    //disable checkstyle for 10+ parameters
+    //CHECKSTYLE:OFF
+    public MapperConfig(final LazyConverterMap adapters,
+                        final Map<Class<?>, ObjectConverter.Writer<?>> objectConverterWriters,
+                        final Map<Class<?>, ObjectConverter.Reader<?>> objectConverterReaders,
+                        final int version, final boolean close,
+                        final boolean skipNull, final boolean skipEmptyArray,
+                        final boolean treatByteArrayAsBase64, final boolean treatByteArrayAsBase64URL,
+                        final boolean readAttributeBeforeWrite,
+                        final AccessMode accessMode, final Charset encoding,
+                        final Comparator<String> attributeOrder,
+                        final boolean failOnUnknown,
+                        final SerializeValueFilter serializeValueFilter,
+                        final boolean useBigDecimalForFloats,
+                        final Boolean deduplicateObjects,
+                        final Map<Class<?>, Class<?>> interfaceImplementationMapping,
+                        final boolean useJsRange,
+                        final boolean useBigDecimalForObjectNumbers,
+                        final boolean supportEnumMapDeserialization,
+                        final Function<String, Class<?>> typeLoader,
+                        final Function<Class<?>, String> discriminatorMapper,
+                        final String discriminator,
+                        final Predicate<Class<?>> deserializationPredicate,
+                        final Predicate<Class<?>> serializationPredicate,
+                        final Function<Class<?>, CustomEnumConverter<?>> enumConverterFactory,
+                        final Snippet.Factory snippetFactory) {
     //CHECKSTYLE:ON
         this.objectConverterWriters = objectConverterWriters;
         this.objectConverterReaders = objectConverterReaders;
@@ -156,6 +197,11 @@ public /* DON'T MAKE IT HIDDEN */ class MapperConfig implements Cloneable {
         this.objectConverterReaderCache = new HashMap<>(objectConverterReaders.size());
         this.useBigDecimalForFloats = useBigDecimalForFloats;
         this.deduplicateObjects = deduplicateObjects;
+        this.snippetFactory = snippetFactory;
+    }
+
+    public Snippet.Factory getSnippetFactory() {
+        return snippetFactory;
     }
 
     public Function<Class<?>, CustomEnumConverter<?>> getEnumConverterFactory() {
diff --git a/johnzon-mapper/src/main/java/org/apache/johnzon/mapper/MappingParserImpl.java b/johnzon-mapper/src/main/java/org/apache/johnzon/mapper/MappingParserImpl.java
index 0b86263..378b048 100644
--- a/johnzon-mapper/src/main/java/org/apache/johnzon/mapper/MappingParserImpl.java
+++ b/johnzon-mapper/src/main/java/org/apache/johnzon/mapper/MappingParserImpl.java
@@ -18,7 +18,6 @@
  */
 package org.apache.johnzon.mapper;
 
-import org.apache.johnzon.core.Snippet;
 import org.apache.johnzon.mapper.access.AccessMode;
 import org.apache.johnzon.mapper.converter.CharacterConverter;
 import org.apache.johnzon.mapper.internal.AdapterKey;
@@ -108,7 +107,6 @@ public class MappingParserImpl implements MappingParser {
      */
     private Map<String, Object> jsonPointers;
 
-
     public MappingParserImpl(MapperConfig config, Mappings mappings, JsonReader jsonReader, Map<String, Object> jsonPointers) {
         this.config = config;
         this.mappings = mappings;
@@ -346,7 +344,7 @@ public class MappingParserImpl implements MappingParser {
             }
         }
         if (classMapping == null) {
-            throw new MapperException("Can't map JSON Object to " + type + ": " + Snippet.of(object));
+            throw new MapperException("Can't map JSON Object to " + type + ": " + config.getSnippetFactory().of(object));
         }
 
         if (applyObjectConverter && classMapping.reader != null && (skippedConverters == null || !skippedConverters.contains(type))) {