public void ConformanceTestPasses(string id, string testname, ConformanceCase conformanceCase)
{
JToken result = conformanceCase.run();
if (conformanceCase.error != null)
{
Assert.True(((string)result["error"]).StartsWith((string)conformanceCase.error), "Resulting error doesn't match expectations.");
}
else
{
if (!JsonLdUtils.DeepCompare(result, conformanceCase.output))
{
#if DEBUG
Console.WriteLine(id);
Console.WriteLine("Actual:");
Console.Write(JSONUtils.ToPrettyString(result));
Console.WriteLine("--------------------------");
Console.WriteLine("Expected:");
Console.Write(JSONUtils.ToPrettyString(conformanceCase.output));
Console.WriteLine("--------------------------");
#endif
Assert.True(false, "Returned JSON doesn't match expectations.");
}
}
}
public void ExtendedFunctionalityTestPasses(string id, ExtendedFunctionalityTestCase testCase)
{
JToken result = testCase.run();
if (testCase.error != null)
{
Assert.True(((string)result["error"]).StartsWith((string)testCase.error), "Resulting error doesn't match expectations.");
}
else
{
if (!JsonLdUtils.DeepCompare(result, testCase.output, true))
{
#if DEBUG
Console.WriteLine(id);
Console.WriteLine("Actual:");
Console.Write(JSONUtils.ToPrettyString(result));
Console.WriteLine("--------------------------");
Console.WriteLine("Expected:");
Console.Write(JSONUtils.ToPrettyString(testCase.output));
Console.WriteLine("--------------------------");
#endif
Assert.True(false, "Returned JSON doesn't match expectations.");
}
}
}
static void Main(string[] args)
{
var input = GetJson("TestCases\\event-input.jsonld");
var expected = File.ReadAllText("TestCases\\event-output.nq").Replace("\\", "");
var options = new JsonLdOptions("http://json-ld.org/test-suite/tests/startup");
options.format = "application/nquads";
var result = new JValue(((string)JsonLdProcessor.ToRDF(input, options)).Replace("\n", "\r\n"));
Console.WriteLine(JSONUtils.ToPrettyString(result));
Console.WriteLine(JSONUtils.ToPrettyString(result) == JSONUtils.ToPrettyString(expected));
bool isSame = JsonLdUtils.DeepCompare(result, expected);
Console.WriteLine(JsonLdUtils.DeepCompare(result, expected));
}
private INode MakeNode(IRdfHandler handler, JToken token, Uri graphIri, bool allowRelativeIri = false)
{
if (token is JValue)
{
var stringValue = token.Value <string>();
if (JsonLdUtils.IsBlankNodeIdentifier(stringValue))
{
return(handler.CreateBlankNode(stringValue.Substring(2)));
}
if (Uri.TryCreate(stringValue, allowRelativeIri ? UriKind.RelativeOrAbsolute : UriKind.Absolute, out Uri iri))
{
if (!Uri.IsWellFormedUriString(stringValue, allowRelativeIri ? UriKind.RelativeOrAbsolute : UriKind.Absolute))
{
return(null);
}
return(handler.CreateUriNode(iri));
}
return(null);
}
if (JsonLdUtils.IsValueObject(token))
{
string literalValue = null;
var valueObject = token as JObject;
var value = valueObject["@value"];
var datatype = valueObject.Property("@type")?.Value.Value <string>();
var language = valueObject.Property("@language")?.Value.Value <string>();
if (datatype == "@json")
{
datatype = RdfNs + "JSON";
var serializer = new JsonLiteralSerializer();
literalValue = serializer.Serialize(value);
}
else if (value.Type == JTokenType.Boolean)
{
literalValue = value.Value <bool>() ? "true" : "false";
if (datatype == null)
{
datatype = XsdNs + "boolean";
}
}
else if (value.Type == JTokenType.Float ||
value.Type == JTokenType.Integer && datatype != null && datatype.Equals(XsdNs + "double"))
{
var doubleValue = value.Value <double>();
var roundedValue = Math.Round(doubleValue);
if (doubleValue.Equals(roundedValue) && doubleValue < 1000000000000000000000.0 && datatype == null)
{
// Integer values up to 10^21 should be rendered as a fixed-point integer
literalValue = roundedValue.ToString("F0");
datatype = XsdNs + "integer";
}
else
{
literalValue = value.Value <double>().ToString("E15", CultureInfo.InvariantCulture);
literalValue = ExponentialFormatMatcher.Replace(literalValue, "$1E");
if (literalValue.EndsWith("E"))
{
literalValue = literalValue + "0";
}
if (datatype == null)
{
datatype = XsdNs + "double";
}
}
}
else if (value.Type == JTokenType.Integer ||
value.Type == JTokenType.Float && datatype != null && datatype.Equals(XsdNs + "integer"))
{
literalValue = value.Value <long>().ToString("D", CultureInfo.InvariantCulture);
if (datatype == null)
{
datatype = XsdNs + "integer";
}
}
else if (valueObject.ContainsKey("@direction") && ParserOptions.RdfDirection.HasValue)
{
literalValue = value.Value <string>();
var direction = valueObject["@direction"].Value <string>();
language = valueObject.ContainsKey("@language")
? valueObject["@language"].Value <string>().ToLowerInvariant()
: string.Empty;
if (ParserOptions.RdfDirection == JsonLdRdfDirectionMode.I18NDatatype)
{
datatype = "https://www.w3.org/ns/i18n#" + language + "_" + direction;
return(handler.CreateLiteralNode(literalValue, new Uri(datatype)));
}
// Otherwise direction mode is CompoundLiteral
var literalNode = handler.CreateBlankNode();
var xsdString =
UriFactory.Create(XmlSpecsHelper.XmlSchemaDataTypeString);
handler.HandleTriple(new Triple(
literalNode,
handler.CreateUriNode(UriFactory.Create(RdfSpecsHelper.RdfValue)),
handler.CreateLiteralNode(literalValue, xsdString),
graphIri));
if (!string.IsNullOrEmpty(language))
{
handler.HandleTriple(new Triple(
literalNode,
handler.CreateUriNode(UriFactory.Create(RdfSpecsHelper.RdfLanguage)),
handler.CreateLiteralNode(language, xsdString),
graphIri));
}
handler.HandleTriple(new Triple(
literalNode,
handler.CreateUriNode(UriFactory.Create(RdfSpecsHelper.RdfDirection)),
handler.CreateLiteralNode(direction, xsdString),
graphIri));
return(literalNode);
}
else
{
literalValue = value.Value <string>();
if (datatype == null && language == null)
{
datatype = XsdNs + "string";
}
}
if (language != null)
{
return(LanguageTag.IsWellFormed(language) ? handler.CreateLiteralNode(literalValue, language) : null);
}
return(handler.CreateLiteralNode(literalValue, new Uri(datatype)));
}
if (JsonLdUtils.IsListObject(token))
{
var listArray = token["@list"] as JArray;
return(MakeRdfList(handler, listArray, graphIri));
}
if ((token as JObject)?.Property("@id") != null)
{
// Must be a node object
var nodeObject = (JObject)token;
return(MakeNode(handler, nodeObject["@id"], graphIri));
}
return(null);
}
/// <inheritdoc/>
public void Load(IRdfHandler handler, TextReader input)
{
handler.StartRdf();
var rdfTypeNode = handler.CreateUriNode(new Uri(RdfNs + "type"));
try
{
JToken element;
using (var reader = new JsonTextReader(input)
{
DateParseHandling = DateParseHandling.None
})
{
element = JToken.ReadFrom(reader);
}
var expandedElement = JsonLdProcessor.Expand(element, ParserOptions);
var nodeMapGenerator = new NodeMapGenerator();
var nodeMap = nodeMapGenerator.GenerateNodeMap(expandedElement);
foreach (var p in nodeMap.Properties())
{
var graphName = p.Name;
var graph = p.Value as JObject;
if (graph == null)
{
continue;
}
Uri graphIri;
if (graphName == "@default")
{
graphIri = null;
}
else
{
if (IsBlankNodeIdentifier(graphName))
{
graphIri = new Uri("nquads:bnode:" + graphName.Substring(2));
}
else if (!(Uri.TryCreate(graphName, UriKind.Absolute, out graphIri) && graphIri.IsWellFormedOriginalString()))
{
continue;
}
}
foreach (var gp in graph.Properties())
{
var subject = gp.Name;
var node = gp.Value as JObject;
INode subjectNode;
if (IsBlankNodeIdentifier(subject))
{
subjectNode = handler.CreateBlankNode(subject.Substring(2));
}
else
{
if (!(Uri.TryCreate(subject, UriKind.Absolute, out var subjectIri) && subjectIri.IsWellFormedOriginalString()))
{
continue;
}
subjectNode = handler.CreateUriNode(subjectIri);
}
foreach (var np in node.Properties())
{
var property = np.Name;
var values = np.Value as JArray;
if (property.Equals("@type"))
{
foreach (var type in values)
{
var typeNode = MakeNode(handler, type, graphIri);
if (typeNode != null)
{
handler.HandleTriple(new Triple(subjectNode, rdfTypeNode, typeNode, graphIri));
}
}
}
else if (JsonLdUtils.IsBlankNodeIdentifier(property) && ParserOptions.ProduceGeneralizedRdf ||
Uri.IsWellFormedUriString(property, UriKind.Absolute))
{
foreach (var item in values)
{
var predicateNode = MakeNode(handler, property, graphIri);
var objectNode = MakeNode(handler, item, graphIri);
if (predicateNode != null && objectNode != null)
{
handler.HandleTriple(new Triple(subjectNode, predicateNode, objectNode,
graphIri));
}
}
}
}
}
}
}
catch (Exception)
{
handler.EndRdf(false);
throw;
}
handler.EndRdf(true);
}
