From 1635a6aa0ae9d95b822ada6f274f483ee0acc006 Mon Sep 17 00:00:00 2001 From: Didac Montero Date: Mon, 8 Mar 2021 13:35:09 +0100 Subject: [PATCH] Added support for @json @type --- core/reports/json-ld-api-tests-skip | 18 ---- .../com/github/jsonldjava/core/JsonLdApi.java | 40 ++++++--- .../github/jsonldjava/core/JsonLdConsts.java | 10 +++ .../github/jsonldjava/core/JsonLdOptions.java | 4 + .../github/jsonldjava/core/RDFDataset.java | 30 +++---- .../jsonldjava/core/RDFDatasetUtils.java | 83 +++++++++++------- .../github/jsonldjava/utils/JsonUtils.java | 87 ++++++++++++++----- .../github/jsonldjava/utils/SuiteUtils.java | 3 + 8 files changed, 171 insertions(+), 104 deletions(-) diff --git a/core/reports/json-ld-api-tests-skip b/core/reports/json-ld-api-tests-skip index 9216301e..646df1f1 100644 --- a/core/reports/json-ld-api-tests-skip +++ b/core/reports/json-ld-api-tests-skip @@ -78,7 +78,6 @@ https://w3c.github.io/json-ld-api/tests/compact-manifest#tin02 https://w3c.github.io/json-ld-api/tests/compact-manifest#tin03 https://w3c.github.io/json-ld-api/tests/compact-manifest#tin04 https://w3c.github.io/json-ld-api/tests/compact-manifest#tin05 -https://w3c.github.io/json-ld-api/tests/compact-manifest#tjs11 https://w3c.github.io/json-ld-api/tests/compact-manifest#tli01 https://w3c.github.io/json-ld-api/tests/compact-manifest#tli02 https://w3c.github.io/json-ld-api/tests/compact-manifest#tli03 @@ -290,9 +289,6 @@ https://w3c.github.io/json-ld-api/tests/expand-manifest#tin06 https://w3c.github.io/json-ld-api/tests/expand-manifest#tin07 https://w3c.github.io/json-ld-api/tests/expand-manifest#tin08 https://w3c.github.io/json-ld-api/tests/expand-manifest#tin09 -https://w3c.github.io/json-ld-api/tests/expand-manifest#tjs16 -https://w3c.github.io/json-ld-api/tests/expand-manifest#tjs19 -https://w3c.github.io/json-ld-api/tests/expand-manifest#tjs22 https://w3c.github.io/json-ld-api/tests/expand-manifest#tli01 https://w3c.github.io/json-ld-api/tests/expand-manifest#tli02 https://w3c.github.io/json-ld-api/tests/expand-manifest#tli03 @@ -401,8 +397,6 @@ https://w3c.github.io/json-ld-api/tests/fromRdf-manifest#tdi05 https://w3c.github.io/json-ld-api/tests/fromRdf-manifest#tdi06 https://w3c.github.io/json-ld-api/tests/fromRdf-manifest#tdi11 https://w3c.github.io/json-ld-api/tests/fromRdf-manifest#tdi12 -https://w3c.github.io/json-ld-api/tests/fromRdf-manifest#tjs08 -https://w3c.github.io/json-ld-api/tests/fromRdf-manifest#tjs09 https://w3c.github.io/json-ld-api/tests/fromRdf-manifest#tli01 https://w3c.github.io/json-ld-api/tests/fromRdf-manifest#tli02 https://w3c.github.io/json-ld-api/tests/fromRdf-manifest#tli03 @@ -573,24 +567,12 @@ https://w3c.github.io/json-ld-api/tests/toRdf-manifest#tin06 https://w3c.github.io/json-ld-api/tests/toRdf-manifest#tin07 https://w3c.github.io/json-ld-api/tests/toRdf-manifest#tin08 https://w3c.github.io/json-ld-api/tests/toRdf-manifest#tin09 -https://w3c.github.io/json-ld-api/tests/toRdf-manifest#tjs01 -https://w3c.github.io/json-ld-api/tests/toRdf-manifest#tjs02 -https://w3c.github.io/json-ld-api/tests/toRdf-manifest#tjs03 -https://w3c.github.io/json-ld-api/tests/toRdf-manifest#tjs04 -https://w3c.github.io/json-ld-api/tests/toRdf-manifest#tjs05 -https://w3c.github.io/json-ld-api/tests/toRdf-manifest#tjs08 -https://w3c.github.io/json-ld-api/tests/toRdf-manifest#tjs10 -https://w3c.github.io/json-ld-api/tests/toRdf-manifest#tjs11 https://w3c.github.io/json-ld-api/tests/toRdf-manifest#tjs12 -https://w3c.github.io/json-ld-api/tests/toRdf-manifest#tjs13 https://w3c.github.io/json-ld-api/tests/toRdf-manifest#tjs14 https://w3c.github.io/json-ld-api/tests/toRdf-manifest#tjs15 https://w3c.github.io/json-ld-api/tests/toRdf-manifest#tjs16 https://w3c.github.io/json-ld-api/tests/toRdf-manifest#tjs17 -https://w3c.github.io/json-ld-api/tests/toRdf-manifest#tjs18 -https://w3c.github.io/json-ld-api/tests/toRdf-manifest#tjs19 https://w3c.github.io/json-ld-api/tests/toRdf-manifest#tjs21 -https://w3c.github.io/json-ld-api/tests/toRdf-manifest#tjs22 https://w3c.github.io/json-ld-api/tests/toRdf-manifest#tli01 https://w3c.github.io/json-ld-api/tests/toRdf-manifest#tli02 https://w3c.github.io/json-ld-api/tests/toRdf-manifest#tli03 diff --git a/core/src/main/java/com/github/jsonldjava/core/JsonLdApi.java b/core/src/main/java/com/github/jsonldjava/core/JsonLdApi.java index 1f7091ed..887a6ab1 100644 --- a/core/src/main/java/com/github/jsonldjava/core/JsonLdApi.java +++ b/core/src/main/java/com/github/jsonldjava/core/JsonLdApi.java @@ -8,6 +8,7 @@ import static com.github.jsonldjava.core.JsonLdUtils.isKeyword; import static com.github.jsonldjava.utils.Obj.newMap; +import java.io.IOException; import java.util.ArrayList; import java.util.Collection; import java.util.Collections; @@ -20,6 +21,7 @@ import java.util.Set; import java.util.TreeMap; +import com.github.jsonldjava.utils.JsonUtils; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -565,6 +567,7 @@ else if (element instanceof Map) { // 7) final List keys = new ArrayList(elem.keySet()); Collections.sort(keys); + Map valueKeys = newMap(); // GK: This is the place to check for a type-scoped context by checking any key that expands to `@type` to see the current context has a term that equals that key where the term definition includes `@context`, updating the activeCtx as you go (but using termScopedContext when checking the keys). // GK: 1.1 made the following loop somewhat recursive, due to nesting, so might want to extract into a method. for (final String key : keys) { @@ -594,7 +597,6 @@ else if (element instanceof Map) { expandedProperty + " already exists in result"); } // jsonld 1.1: 12 in https://w3c.github.io/json-ld-api/#algorithm-3 - Object inputType = elem.get(JsonLdConsts.TYPE); // 7.4.3) if (JsonLdConsts.ID.equals(expandedProperty)) { if (value instanceof String) { @@ -660,15 +662,9 @@ else if (JsonLdConsts.GRAPH.equals(expandedProperty)) { } // 7.4.6) else if (JsonLdConsts.VALUE.equals(expandedProperty)) { - // jsonld 1.1: 13.4.7.1 in https://w3c.github.io/json-ld-api/#algorithm-3 - if(JsonLdConsts.JSON.equals(inputType)) { - expandedValue = value; - if(opts.getProcessingMode().equals(JsonLdOptions.JSON_LD_1_0)) { - throw new JsonLdError(Error.INVALID_VALUE_OBJECT_VALUE, value); - } - } // jsonld 1.1: 13.4.7.2 in https://w3c.github.io/json-ld-api/#algorithm-3 - else if (value != null && (value instanceof Map || value instanceof List)) { + if (value != null && (value instanceof Map || value instanceof List) && + !opts.isProcessingMode11()) { throw new JsonLdError(Error.INVALID_VALUE_OBJECT_VALUE, "value of " + expandedProperty + " must be a scalar or null, but was: " + value); } @@ -981,14 +977,20 @@ else if (JsonLdConsts.INDEX.equals(activeCtx.getContainer(key)) } // 8.2) final Object rval = result.get(JsonLdConsts.VALUE); - if (rval == null) { + if (result.getOrDefault(JsonLdConsts.TYPE,"").equals(JsonLdConsts.JSON)) { + // jsonld 1.1: 14.3 in https://w3c.github.io/json-ld-api/#algorithm-3 + } + else if(opts.isProcessingMode11() && (rval instanceof Map || rval instanceof List)) { + // jsonld 1.1: 13.4.7.1 https://w3c.github.io/json-ld-api/#algorithm-3 + throw new JsonLdError(Error.INVALID_VALUE_OBJECT_VALUE, + "value of " + activeProperty + " must be a scalar or null"); + } + + else if (rval == null) { // nothing else is possible with result if we set it to // null, so simply return it return null; } - else if (result.getOrDefault(JsonLdConsts.TYPE,"").equals(JsonLdConsts.JSON)) { - // jsonld 1.1: 14.3 in https://w3c.github.io/json-ld-api/#algorithm-3 - } // 8.3) else if (!(rval instanceof String) && result.containsKey(JsonLdConsts.LANGUAGE)) { throw new JsonLdError(Error.INVALID_LANGUAGE_TAGGED_VALUE, @@ -2051,6 +2053,18 @@ public List fromRDF(final RDFDataset dataset, boolean noDuplicatesInData nodeMap.computeIfAbsent(object.getValue(), k -> new NodeMapNode(k)); } + if (opts.isProcessingMode11() && JsonLdConsts.RDF_JSON.equals(object.getDatatype())) { + try { + final Object json = JsonUtils.fromString(object.getValue()); + Map entries = newMap(JsonLdConsts.TYPE, JsonLdConsts.JSON); + entries.put(JsonLdConsts.VALUE, json); + JsonLdUtils.mergeValue(node, predicate, entries); + } catch (IOException e) { + throw new JsonLdError(JsonLdError.Error.INVALID_JSON_LITERAL); + } + continue; + } + // 3.5.4) if (RDF_TYPE.equals(predicate) && (object.isIRI() || object.isBlankNode()) && !opts.getUseRdfType() && !nodes.containsKey(object.getValue())) { diff --git a/core/src/main/java/com/github/jsonldjava/core/JsonLdConsts.java b/core/src/main/java/com/github/jsonldjava/core/JsonLdConsts.java index f88be694..ade6dc96 100644 --- a/core/src/main/java/com/github/jsonldjava/core/JsonLdConsts.java +++ b/core/src/main/java/com/github/jsonldjava/core/JsonLdConsts.java @@ -1,5 +1,9 @@ package com.github.jsonldjava.core; +import java.text.DecimalFormat; +import java.text.DecimalFormatSymbols; +import java.util.Locale; + /** * URI Constants used in the JSON-LD parser. */ @@ -70,4 +74,10 @@ public final class JsonLdConsts { public enum Embed { ALWAYS, NEVER, LAST, LINK; } + + public final static DecimalFormat DOUBLE_DECIMAL_FORMAT = new DecimalFormat("0.0###############E0", + DecimalFormatSymbols.getInstance(Locale.US)); + + public final static DecimalFormat INT_DECIMAL_FORMAT = new DecimalFormat("0", + DecimalFormatSymbols.getInstance(Locale.US)); } \ No newline at end of file diff --git a/core/src/main/java/com/github/jsonldjava/core/JsonLdOptions.java b/core/src/main/java/com/github/jsonldjava/core/JsonLdOptions.java index 1786aae7..a5a6877b 100644 --- a/core/src/main/java/com/github/jsonldjava/core/JsonLdOptions.java +++ b/core/src/main/java/com/github/jsonldjava/core/JsonLdOptions.java @@ -246,6 +246,10 @@ public String getProcessingMode() { return processingMode; } + public boolean isProcessingMode11() { + return JSON_LD_1_1.equals(getProcessingMode()); + } + public void setProcessingMode(String processingMode) { this.processingMode = processingMode; if (processingMode.equals(JSON_LD_1_1)) { diff --git a/core/src/main/java/com/github/jsonldjava/core/RDFDataset.java b/core/src/main/java/com/github/jsonldjava/core/RDFDataset.java index 6226f45c..c88c528d 100644 --- a/core/src/main/java/com/github/jsonldjava/core/RDFDataset.java +++ b/core/src/main/java/com/github/jsonldjava/core/RDFDataset.java @@ -172,8 +172,6 @@ public int compareTo(Node o) { /** * Converts an RDF triple object to a JSON-LD object. * - * @param o - * the RDF triple object to convert. * @param useNativeTypes * true to output native types, false not to. * @@ -251,7 +249,6 @@ else if(RDF_JSON.equals(type)) { try { rval.put("@value", JsonUtils.fromString(value)); } catch (IOException e) { - e.printStackTrace(); throw new JsonLdError(JsonLdError.Error.INVALID_JSON_LITERAL, value, e); } } @@ -667,7 +664,16 @@ private Node objectToRDF(Object item) { final Object datatype = ((Map) item).get("@type"); // convert to XSD datatypes as appropriate - if (value instanceof Boolean || value instanceof Number) { + if(JsonLdConsts.JSON.equals(datatype)) { + try { + // jsonld 1.1: 8 in https://w3c.github.io/json-ld-api/#algorithm-13 + return new Literal(JsonUtils.toJcsString(value), RDF_JSON, null); + } catch (IOException e) { + e.printStackTrace(); + throw new JsonLdError(JsonLdError.Error.INVALID_JSON_LITERAL); + } + } + else if (value instanceof Boolean || value instanceof Number) { // convert to XSD datatype if (value instanceof Boolean) { return new Literal(value.toString(), @@ -685,14 +691,11 @@ private Node objectToRDF(Object item) { if (XSD_DECIMAL.equals(datatype)) { return new Literal(value.toString(), XSD_DECIMAL, null); } - final DecimalFormat df = new DecimalFormat("0.0###############E0"); - df.setDecimalFormatSymbols(DecimalFormatSymbols.getInstance(Locale.US)); - return new Literal(df.format(value), + return new Literal(JsonLdConsts.DOUBLE_DECIMAL_FORMAT.format(value), datatype == null ? XSD_DOUBLE : (String) datatype, null); } } else { - final DecimalFormat df = new DecimalFormat("0"); - return new Literal(df.format(value), + return new Literal(JsonLdConsts.INT_DECIMAL_FORMAT.format(value), datatype == null ? XSD_INTEGER : (String) datatype, null); } } else if (((Map) item).containsKey("@language")) { @@ -700,15 +703,6 @@ private Node objectToRDF(Object item) { datatype == null ? RDF_LANGSTRING : (String) datatype, (String) ((Map) item).get("@language")); } - // jsonld 1.1: 8 in https://w3c.github.io/json-ld-api/#algorithm-13 - else if(JsonLdConsts.JSON.equals(datatype)) { - try { - return new Literal(JsonUtils.toString(value), RDF_JSON, null); - } catch (IOException e) { - e.printStackTrace(); - return null; - } - } else { return new Literal((String) value, datatype == null ? XSD_STRING : (String) datatype, null); diff --git a/core/src/main/java/com/github/jsonldjava/core/RDFDatasetUtils.java b/core/src/main/java/com/github/jsonldjava/core/RDFDatasetUtils.java index a2739e64..99c0ca2c 100644 --- a/core/src/main/java/com/github/jsonldjava/core/RDFDatasetUtils.java +++ b/core/src/main/java/com/github/jsonldjava/core/RDFDatasetUtils.java @@ -91,7 +91,11 @@ else if (bnode != null) { } } else { output.append("\""); - escape(o.getValue(), output); + if(JsonLdConsts.RDF_JSON.equals(o.getDatatype())) { + escapeJcs(o.getValue(), output); + }else { + escape(o.getValue(), output); + } output.append("\""); if (RDF_LANGSTRING.equals(o.getDatatype())) { output.append("@").append(o.getLanguage()); @@ -192,6 +196,51 @@ public static String unescape(String str) { return rval; } + private static void specialCharactersEscaped(char c, StringBuilder rval) { + switch (c) { + case '\b': + rval.append("\\b"); + break; + case '\n': + rval.append("\\n"); + break; + case '\t': + rval.append("\\t"); + break; + case '\f': + rval.append("\\f"); + break; + case '\r': + rval.append("\\r"); + break; + case '\"': + rval.append("\\\""); + break; + case '\\': + rval.append("\\\\"); + break; + default: + rval.append(c); + break; + } + } + + + /** + * Escapes the given JSON Canonicalization Scheme string + * + * @param str + * The string to escape + * @param rval + * The {@link StringBuilder} to append to. + */ + public static void escapeJcs(String str, StringBuilder rval) { + for (int i = 0; i < str.length(); i++) { + final char hi = str.charAt(i); + specialCharactersEscaped(hi, rval); + } + } + /** * Escapes the given string according to the N-Quads escape rules * @@ -221,37 +270,7 @@ public static void escape(String str, StringBuilder rval) { final int c = (hi << 10) + lo + (0x10000 - (0xD800 << 10) - 0xDC00); rval.append(String.format("\\U%08x", c)); } else { - switch (hi) { - case '\b': - rval.append("\\b"); - break; - case '\n': - rval.append("\\n"); - break; - case '\t': - rval.append("\\t"); - break; - case '\f': - rval.append("\\f"); - break; - case '\r': - rval.append("\\r"); - break; - // case '\'': - // rval += "\\'"; - // break; - case '\"': - rval.append("\\\""); - // rval += "\\u0022"; - break; - case '\\': - rval.append("\\\\"); - break; - default: - // just put the char as is - rval.append(hi); - break; - } + specialCharactersEscaped(hi, rval); } } // return rval; diff --git a/core/src/main/java/com/github/jsonldjava/utils/JsonUtils.java b/core/src/main/java/com/github/jsonldjava/utils/JsonUtils.java index c24c8467..de975b85 100644 --- a/core/src/main/java/com/github/jsonldjava/utils/JsonUtils.java +++ b/core/src/main/java/com/github/jsonldjava/utils/JsonUtils.java @@ -13,16 +13,16 @@ import java.net.URL; import java.nio.charset.Charset; import java.nio.charset.StandardCharsets; +import java.text.DecimalFormat; +import java.text.DecimalFormatSymbols; import java.util.List; +import java.util.Locale; import java.util.Map; -import com.fasterxml.jackson.core.JsonFactory; -import com.fasterxml.jackson.core.JsonGenerationException; -import com.fasterxml.jackson.core.JsonGenerator; -import com.fasterxml.jackson.core.JsonParseException; -import com.fasterxml.jackson.core.JsonParser; -import com.fasterxml.jackson.core.JsonToken; -import com.fasterxml.jackson.databind.ObjectMapper; +import com.fasterxml.jackson.core.*; +import com.fasterxml.jackson.databind.*; +import com.fasterxml.jackson.databind.json.JsonMapper; +import com.fasterxml.jackson.databind.module.SimpleModule; import com.github.jsonldjava.core.DocumentLoader; import com.github.jsonldjava.core.JsonLdApi; import com.github.jsonldjava.core.JsonLdProcessor; @@ -42,8 +42,6 @@ import org.apache.http.impl.client.cache.BasicHttpCacheStorage; import org.apache.http.impl.client.cache.CacheConfig; import org.apache.http.impl.client.cache.CachingHttpClientBuilder; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; /** * Functions used to make loading, parsing, and serializing JSON easy using @@ -69,6 +67,34 @@ public class JsonUtils { private static final ObjectMapper JSON_MAPPER = new ObjectMapper(); private static final JsonFactory JSON_FACTORY = new JsonFactory(JSON_MAPPER); + private static final ObjectMapper JCS_MAPPER = JsonMapper.builder().configure(SerializationFeature.ORDER_MAP_ENTRIES_BY_KEYS, true).build(); + private static final SimpleModule module = new SimpleModule(); + private static final JsonFactory JCS_FACTORY = new JsonFactory(JCS_MAPPER); + + private static final JsonSerializer doubleSerializer = new JsonSerializer() { + + private DecimalFormat bigDecimalFor(String exponentSeparator) { + DecimalFormatSymbols symbol = DecimalFormatSymbols.getInstance(Locale.US); + symbol.setExponentSeparator(exponentSeparator); + return new DecimalFormat("0E00", symbol); + } + + private final DecimalFormat DOUBLE_JCS = new DecimalFormat("0.#######", + DecimalFormatSymbols.getInstance(Locale.US)); + private final DecimalFormat BIG_POSITIVE_DOUBLE_JCS = bigDecimalFor("e+"); + private final DecimalFormat BIG_NEGATIVE_DOUBLE_JCS = bigDecimalFor("e"); + + @Override + public void serialize(Double value, JsonGenerator jgen, SerializerProvider serializerProvider) throws IOException { + if(value >= 1.0E21) + jgen.writeNumber(BIG_POSITIVE_DOUBLE_JCS.format(value).toLowerCase()); + else if (value != 0 && value <= 1.0E-21) + jgen.writeNumber(BIG_NEGATIVE_DOUBLE_JCS.format(value).toLowerCase()); + else + jgen.writeNumber(DOUBLE_JCS.format(value)); + + } + }; private static volatile CloseableHttpClient DEFAULT_HTTP_CLIENT; // Avoid possible endless loop when following alternate locations @@ -83,6 +109,10 @@ public class JsonUtils { // where a wide range of URIs are used for subjects and predicates JSON_FACTORY.disable(JsonFactory.Feature.INTERN_FIELD_NAMES); JSON_FACTORY.disable(JsonFactory.Feature.CANONICALIZE_FIELD_NAMES); + //adding our custom serializer + module.addSerializer(Double.class ,doubleSerializer); + //registering the module with ObjectMapper + JCS_MAPPER.registerModule(module); } /** @@ -259,13 +289,10 @@ public static Object fromString(String jsonString) throws JsonParseException, IO * @param jsonObject * The JSON-LD Object to serialize. * @return A JSON document serialised to a String. - * @throws JsonGenerationException - * If there is a JSON error during serialization. * @throws IOException * If there is an IO error during serialization. */ - public static String toPrettyString(Object jsonObject) - throws JsonGenerationException, IOException { + public static String toPrettyString(Object jsonObject) throws IOException { final StringWriter sw = new StringWriter(); writePrettyPrint(sw, jsonObject); return sw.toString(); @@ -277,17 +304,36 @@ public static String toPrettyString(Object jsonObject) * @param jsonObject * The JSON-LD Object to serialize. * @return A JSON document serialised to a String. - * @throws JsonGenerationException - * If there is a JSON error during serialization. * @throws IOException * If there is an IO error during serialization. */ - public static String toString(Object jsonObject) throws JsonGenerationException, IOException { + public static String toString(Object jsonObject) throws IOException { final StringWriter sw = new StringWriter(); write(sw, jsonObject); return sw.toString(); } + /** + * Writes the given JSON-LD Object out to a String as JSON Canonicalization Scheme (JCS). + * + * @param jsonObject + * The JSON-LD Object to serialize. + * @return A JSON document serialised to a String. + * @throws IOException + * If there is an IO error during serialization. + */ + public static String toJcsString(Object jsonObject) throws IOException { + if(jsonObject == null) { + return "null"; + } + + final StringWriter sw = new StringWriter(); + + final JsonGenerator jw = JCS_FACTORY.createGenerator(sw); + jw.writeObject(jsonObject); + return sw.toString(); + } + /** * Writes the given JSON-LD Object out to the given Writer. * @@ -295,13 +341,10 @@ public static String toString(Object jsonObject) throws JsonGenerationException, * The writer that is to receive the serialized JSON-LD object. * @param jsonObject * The JSON-LD Object to serialize. - * @throws JsonGenerationException - * If there is a JSON error during serialization. * @throws IOException * If there is an IO error during serialization. */ - public static void write(Writer writer, Object jsonObject) - throws JsonGenerationException, IOException { + public static void write(Writer writer, Object jsonObject) throws IOException { final JsonGenerator jw = JSON_FACTORY.createGenerator(writer); jw.writeObject(jsonObject); } @@ -314,13 +357,11 @@ public static void write(Writer writer, Object jsonObject) * The writer that is to receive the serialized JSON-LD object. * @param jsonObject * The JSON-LD Object to serialize. - * @throws JsonGenerationException - * If there is a JSON error during serialization. * @throws IOException * If there is an IO error during serialization. */ public static void writePrettyPrint(Writer writer, Object jsonObject) - throws JsonGenerationException, IOException { + throws IOException { final JsonGenerator jw = JSON_FACTORY.createGenerator(writer); jw.useDefaultPrettyPrinter(); jw.writeObject(jsonObject); diff --git a/core/src/test/java/com/github/jsonldjava/utils/SuiteUtils.java b/core/src/test/java/com/github/jsonldjava/utils/SuiteUtils.java index a444f20d..8740c193 100644 --- a/core/src/test/java/com/github/jsonldjava/utils/SuiteUtils.java +++ b/core/src/test/java/com/github/jsonldjava/utils/SuiteUtils.java @@ -396,6 +396,9 @@ public static void run(String dir, String group, String testId, Map