/**
* Test method for {@link
* RDFJSONUtility.kmr.scam.rest.util.RDFJSON#rdfJsonToGraph(java.lang.String)}.
*
* @throws IOException
* @throws RDFParseException
* @throws RDFHandlerException
*/
@Test
public void testRdfJsonToGraph5() throws IOException, RDFParseException, RDFHandlerException {
this.testInputFile = "example5.json";
final Model rdfJsonToGraph =
Rio.parse(this.getClass().getResourceAsStream(this.testInputFile), "", RDFFormat.RDFJSON);
// RDFJSONUtility.rdfJsonToHandler(new
// InputStreamReader(this.getClass().getResourceAsStream(this.testInputFile),
// StandardCharsets.UTF_8), new StatementCollector(rdfJsonToGraph),
// ValueFactoryImpl.getInstance());
Assert.assertEquals(1, rdfJsonToGraph.size());
}
/** Test successful search for a Platform in Turtle */
@Test
public void testSearchTurtle() throws Exception {
final String[] searchTypes = {"http://purl.org/podd/ns/poddScience#Platform"}; // ,
// OWL.THING.stringValue()
// };
final MediaType requestMediaType = MediaType.APPLICATION_RDF_TURTLE;
final Model resultModel =
this.internalTestSearchRdf("Scan", searchTypes, requestMediaType, null);
Assert.assertEquals("Not the expected number of results", 5, resultModel.size());
System.out.println(resultModel.toString());
Assert.assertEquals(
"Expected Platform CabScan not found",
1,
resultModel.filter(null, null, PODD.VF.createLiteral("CabScan")).size());
Assert.assertEquals(
"Expected Platform PlantScan not found",
1,
resultModel.filter(null, null, PODD.VF.createLiteral("PlantScan")).size());
}
/** Test successful search for a custom Platform in RDF/XML */
@Test
public void testSearchRdfForCustomPlatforms() throws Exception {
// prepare:
final InferredOWLOntologyID testArtifact =
this.loadTestArtifact(
TestConstants.TEST_ARTIFACT_20130206, MediaType.APPLICATION_RDF_TURTLE);
final String[] searchTypes = {"http://purl.org/podd/ns/poddScience#Platform"};
final MediaType requestMediaType = MediaType.APPLICATION_RDF_XML;
final Model resultModel =
this.internalTestSearchRdf(
"lat", searchTypes, requestMediaType, testArtifact.getOntologyIRI().toString());
// verify:
Assert.assertEquals("Not the expected number of results", 1, resultModel.size());
Assert.assertEquals(
"Expected Platform 1 not found",
1,
resultModel.filter(null, null, PODD.VF.createLiteral("Platform 1")).size());
}
/** Test successful search for a FOR Codes in RDF/XML */
@Test
public void testSearchRdfForWildtTypeAssertion() throws Exception {
final String[] searchTypes = {"http://purl.org/podd/ns/poddScience#WildTypeAssertion"};
final MediaType requestMediaType = MediaType.APPLICATION_RDF_XML;
final Model resultModel = this.internalTestSearchRdf("", searchTypes, requestMediaType, null);
// verify:
Assert.assertEquals("Not the expected number of results", 4, resultModel.size());
Assert.assertEquals(
"Expected Assertion 'Yes' not found",
1,
resultModel.filter(null, null, PODD.VF.createLiteral("Yes")).size());
Assert.assertEquals(
"Expected Assertion 'Unknown' not found",
1,
resultModel.filter(null, null, PODD.VF.createLiteral("Unknown")).size());
Assert.assertEquals(
"Expected Assertion 'Not Applicable' not found",
1,
resultModel.filter(null, null, PODD.VF.createLiteral("Not Applicable")).size());
}
/** Test successful search for a PODD Project in RDF/XML */
@Test
public void testSearchRdfForProjects() throws Exception {
// prepare:
final InferredOWLOntologyID testArtifact =
this.loadTestArtifact(
TestConstants.TEST_ARTIFACT_20130206, MediaType.APPLICATION_RDF_TURTLE);
final String[] searchTypes = {"http://purl.org/podd/ns/poddScience#Project"};
final MediaType requestMediaType = MediaType.APPLICATION_RDF_XML;
final Model resultModel =
this.internalTestSearchRdf(
"Cot", searchTypes, requestMediaType, testArtifact.getOntologyIRI().toString());
// verify:
Assert.assertEquals("Not the expected number of results", 1, resultModel.size());
Assert.assertTrue(
"Expected Project not found",
resultModel
.filter(null, RDFS.LABEL, null)
.objectString()
.contains("Cotton Leaf Morphology"));
}
/** Test a search in RDF/XML, with no "searchTypes" specified. */
@Test
public void testSearchRdfWithoutSearchTypes() throws Exception {
final String[] searchTypes = {}; // EVERYTHING in the search space is
// compared
final MediaType requestMediaType = MediaType.APPLICATION_RDF_XML;
final Model resultModel = this.internalTestSearchRdf("e", searchTypes, requestMediaType, null);
// verify:
Assert.assertEquals("Not the expected number of results", 224, resultModel.size());
Assert.assertEquals(
"dcTerms not found",
1,
resultModel
.filter(null, null, PODD.VF.createLiteral("The PODD Ontology for Dublin Core Terms"))
.size());
Assert.assertEquals(
"The PODD Ontology for Dublin Core Terms not found",
1,
resultModel
.filter(null, null, PODD.VF.createLiteral("The PODD Ontology for Dublin Core Terms"))
.size());
}
/** Test successful search for PoddScience:Sex values in RDF/XML */
@Test
public void testSearchRdfForSex() throws Exception {
// prepare: add an artifact
final InferredOWLOntologyID testArtifact =
this.loadTestArtifact(
TestConstants.TEST_ARTIFACT_20130206, MediaType.APPLICATION_RDF_TURTLE);
final String[] searchTypes = {"http://purl.org/podd/ns/poddScience#Sex"};
final MediaType requestMediaType = MediaType.APPLICATION_RDF_XML;
final Model resultModel =
this.internalTestSearchRdf(
"", searchTypes, requestMediaType, testArtifact.getOntologyIRI().toString());
Assert.assertEquals("Not the expected number of results", 5, resultModel.size());
Assert.assertEquals(
"Value Hermaphrodite not found",
1,
resultModel.filter(null, null, PODD.VF.createLiteral("Hermaphrodite")).size());
Assert.assertEquals(
"Value Male not found",
1,
resultModel.filter(null, null, PODD.VF.createLiteral("Male")).size());
}
/**
* Test successful search for a Platform in RDF/XML including owl:Thing in the list to verify that
* it doesn't expand the search space, as the search types must all match. Ie, it is not the case
* that if "any" types match the search will succeed.
*/
@Test
public void testSearchRdfForPlatformsWithOWLThing() throws Exception {
final String[] searchTypes = {
"http://purl.org/podd/ns/poddScience#Platform", OWL.THING.stringValue()
};
final MediaType requestMediaType = MediaType.APPLICATION_RDF_XML;
final Model resultModel = this.internalTestSearchRdf("me", searchTypes, requestMediaType, null);
// verify:
Assert.assertEquals("Not the expected number of results", 9, resultModel.size());
Assert.assertEquals(
"Expected Platform SPAD Meter not found",
1,
resultModel.filter(null, null, PODD.VF.createLiteral("SPAD Meter")).size());
Assert.assertEquals(
"Expected Platform Pyrometer not found",
1,
resultModel.filter(null, null, PODD.VF.createLiteral("Pyrometer")).size());
Assert.assertEquals(
"Expected Platform SC1 Porometer not found",
1,
resultModel.filter(null, null, PODD.VF.createLiteral("SC1 Porometer")).size());
}
@Override
public void endRDF() throws RDFHandlerException {
final SesameRDFParser serialiser = new SesameRDFParser();
try {
Object output = JsonLdProcessor.fromRDF(model, serialiser);
final JSONLDMode mode = getWriterConfig().get(JSONLDSettings.JSONLD_MODE);
final JsonLdOptions opts = new JsonLdOptions();
// opts.addBlankNodeIDs =
// getWriterConfig().get(BasicParserSettings.PRESERVE_BNODE_IDS);
opts.setUseRdfType(getWriterConfig().get(JSONLDSettings.USE_RDF_TYPE));
opts.setUseNativeTypes(getWriterConfig().get(JSONLDSettings.USE_NATIVE_TYPES));
// opts.optimize = getWriterConfig().get(JSONLDSettings.OPTIMIZE);
if (mode == JSONLDMode.EXPAND) {
output = JsonLdProcessor.expand(output, opts);
}
// TODO: Implement inframe in JSONLDSettings
final Object inframe = null;
if (mode == JSONLDMode.FLATTEN) {
output = JsonLdProcessor.frame(output, inframe, opts);
}
if (mode == JSONLDMode.COMPACT) {
final Map<String, Object> ctx = new LinkedHashMap<String, Object>();
addPrefixes(ctx, model.getNamespaces());
final Map<String, Object> localCtx = new HashMap<String, Object>();
localCtx.put("@context", ctx);
output = JsonLdProcessor.compact(output, localCtx, opts);
}
if (getWriterConfig().get(BasicWriterSettings.PRETTY_PRINT)) {
JSONUtils.writePrettyPrint(writer, output);
} else {
JSONUtils.write(writer, output);
}
} catch (final JsonLdError e) {
throw new RDFHandlerException("Could not render JSONLD", e);
} catch (final JsonGenerationException e) {
throw new RDFHandlerException("Could not render JSONLD", e);
} catch (final JsonMappingException e) {
throw new RDFHandlerException("Could not render JSONLD", e);
} catch (final IOException e) {
throw new RDFHandlerException("Could not render JSONLD", e);
}
}
public VocabBuilder(String filename, RDFFormat format) throws IOException, RDFParseException {
Path file = Paths.get(filename);
if (!Files.exists(file)) throw new FileNotFoundException(filename);
if (format == null) {
format = Rio.getParserFormatForFileName(filename);
log.trace("detected input format from filename {}: {}", filename, format);
}
try (final InputStream inputStream = Files.newInputStream(file)) {
log.trace("Loading input file");
model = Rio.parse(inputStream, "", format);
}
// import
Set<Resource> owlOntologies = model.filter(null, RDF.TYPE, OWL.ONTOLOGY).subjects();
if (!owlOntologies.isEmpty()) {
setPrefix(owlOntologies.iterator().next().stringValue());
}
}
@Test
public void testPostRdfBasic() throws Exception {
// prepare: add an artifact
final InferredOWLOntologyID testArtifact =
this.loadTestArtifact(
TestConstants.TEST_ARTIFACT_20130206, MediaType.APPLICATION_RDF_TURTLE);
final ClientResource searchClientResource =
new ClientResource(this.getUrl(PoddWebConstants.PATH_SEARCH));
try {
searchClientResource.addQueryParameter(
PoddWebConstants.KEY_ARTIFACT_IDENTIFIER, testArtifact.getOntologyIRI().toString());
// prepare: the test input
final String[] objectUris = {
"http://purl.org/podd/basic-1-20130206/object:2966",
"http://purl.org/podd/basic-2-20130206/artifact:1#Demo-Genotype",
"http://purl.org/podd/basic-2-20130206/artifact:1#SqueekeeMaterial",
"http://purl.org/podd/ns/poddScience#WildType_NotApplicable",
"http://purl.org/podd/ns/poddPlant#DeltaTporometer-63",
"http://purl.org/podd/ns/poddBase#DisplayType_LongText"
};
final String[] expectedLabels = {
"Project#2012-0006_ Cotton Leaf Morphology",
"Demo genotype",
"Squeekee material",
"Not Applicable",
"Delta-T porometer",
null
};
final Model testModel = new LinkedHashModel();
for (final String s : objectUris) {
testModel.add(PODD.VF.createURI(s), RDFS.LABEL, PODD.VF.createLiteral("?blank"));
}
final RDFFormat inputFormat = RDFFormat.RDFXML;
final MediaType inputMediaType = MediaType.valueOf(inputFormat.getDefaultMIMEType());
// build input representation
final ByteArrayOutputStream output = new ByteArrayOutputStream(8096);
Rio.write(testModel, output, inputFormat);
final Representation input = new StringRepresentation(output.toString(), inputMediaType);
// invoke service
final Representation results =
this.doTestAuthenticatedRequest(
searchClientResource,
Method.POST,
input,
inputMediaType,
Status.SUCCESS_OK,
AbstractResourceImplTest.WITH_ADMIN);
// verify: response
final Model resultModel = this.assertRdf(results, RDFFormat.RDFXML, 5);
// verify: each URI has the expected label
for (int i = 0; i < objectUris.length; i++) {
final String objectString =
resultModel.filter(PODD.VF.createURI(objectUris[i]), RDFS.LABEL, null).objectString();
Assert.assertEquals("Not the expected label", expectedLabels[i], objectString);
}
} finally {
this.releaseClient(searchClientResource);
}
}
@Override
public void startRDF() throws RDFHandlerException {
statementCollector.clear();
model.clear();
}
@Override
public void handleNamespace(String prefix, String uri) throws RDFHandlerException {
model.setNamespace(prefix, uri);
}
public HashMap<String, Properties> generateResourceBundle(String baseName)
throws GenerationException {
// be sure to have at least the default URI constant settings
if (uriGeneration == null) {
uriGeneration = GenerationSetting.createDefault(caseFormat, "", "");
}
Pattern pattern = Pattern.compile(Pattern.quote(getPrefix()) + "(.+)");
HashMap<String, URI> splitUris = new HashMap<>();
for (Resource nextSubject : model.subjects()) {
if (nextSubject instanceof URI) {
Matcher matcher = pattern.matcher(nextSubject.stringValue());
if (matcher.find()) {
String k = matcher.group(1);
splitUris.put(k, (URI) nextSubject);
}
}
}
List<String> keys = new ArrayList<>();
keys.addAll(splitUris.keySet());
Collections.sort(keys, String.CASE_INSENSITIVE_ORDER);
HashMap<String, Properties> bundles = new HashMap<>();
// Default we have for sure
bundles.put(baseName, new Properties());
for (String key : keys) {
final URI resource = splitUris.get(key);
//
String nextKey = cleanKey(doCaseFormatting(key, uriGeneration.getCaseFormat()));
for (URI p : LABEL_PROPERTIES) {
for (Value v : GraphUtil.getObjects(model, resource, p)) {
if (v instanceof Literal) {
final Literal lit = (Literal) v;
final String lang = lit.getLanguage();
final Properties bundle;
if (lang == null) {
bundle = bundles.get(baseName);
} else if (bundles.containsKey(baseName + "_" + lang)) {
bundle = bundles.get(baseName + "_" + lang);
} else {
bundle = new Properties();
bundles.put(baseName + "_" + lang, bundle);
}
if (!bundle.containsKey(nextKey + ".label")) {
bundle.put(nextKey + ".label", lit.getLabel().replaceAll("\\s+", " "));
}
}
}
}
for (URI p : COMMENT_PROPERTIES) {
for (Value v : GraphUtil.getObjects(model, resource, p)) {
if (v instanceof Literal) {
final Literal lit = (Literal) v;
final String lang = lit.getLanguage();
final Properties bundle;
if (lang == null) {
bundle = bundles.get(baseName);
} else if (bundles.containsKey(baseName + "_" + lang)) {
bundle = bundles.get(baseName + "_" + lang);
} else {
bundle = new Properties();
bundles.put(baseName + "_" + lang, bundle);
}
if (!bundle.containsKey(nextKey + ".comment")) {
bundle.put(nextKey + ".comment", lit.getLabel().replaceAll("\\s+", " "));
}
}
}
}
}
if (getPreferredLanguage() != null) {
log.debug("completing default Bundle with preferred language {}", getPreferredLanguage());
final Properties defaultBundle = bundles.get(baseName);
final Properties prefBundle = bundles.get(baseName + "_" + getPreferredLanguage());
if (prefBundle != null) {
for (Entry<Object, Object> key : prefBundle.entrySet()) {
String nextKey = (String) key.getKey();
if (!defaultBundle.containsKey(nextKey)) {
log.trace("copying {} from {} to default Bundle", nextKey, getPreferredLanguage());
defaultBundle.setProperty(nextKey, (String) key.getValue());
}
}
} else {
log.warn("No Bundle data found for preferred language {}", getPreferredLanguage());
}
}
return bundles;
}
public void generate(String className, PrintWriter out)
throws IOException, GraphUtilException, GenerationException {
// be sure to have at least the uri constants generated
if (stringGeneration == null && uriGeneration == null) {
uriGeneration = GenerationSetting.createDefault(caseFormat, "", "");
// throw new GenerationException("no generation settings present, please set explicitly");
}
log.trace("classname: {}", className);
if (StringUtils.isBlank(name)) {
name = className;
}
if (StringUtils.isBlank(prefix)) {
throw new GenerationException("could not detect prefix, please set explicitly");
} else {
log.debug("prefix: {}", prefix);
}
Pattern pattern = Pattern.compile(Pattern.quote(getPrefix()) + "(.+)");
ConcurrentMap<String, URI> splitUris = new ConcurrentHashMap<>();
for (Resource nextSubject : model.subjects()) {
if (nextSubject instanceof URI) {
Matcher matcher = pattern.matcher(nextSubject.stringValue());
if (matcher.find()) {
String k = matcher.group(1);
URI putIfAbsent = splitUris.putIfAbsent(k, (URI) nextSubject);
if (putIfAbsent != null) {
log.warn(
"Conflicting keys found: uri={} key={} existing={}",
nextSubject.stringValue(),
k,
putIfAbsent);
}
}
}
}
// print
// package is optional
if (StringUtils.isNotBlank(packageName)) {
out.printf("package %s;%n%n", getPackageName());
}
// imports
out.println("import org.openrdf.model.URI;");
out.println("import org.openrdf.model.ValueFactory;");
out.println("import org.openrdf.model.impl.ValueFactoryImpl;");
out.println();
final URI pfx = new URIImpl(prefix);
Literal oTitle =
getFirstExistingObjectLiteral(model, pfx, getPreferredLanguage(), LABEL_PROPERTIES);
Literal oDescr =
getFirstExistingObjectLiteral(model, pfx, getPreferredLanguage(), COMMENT_PROPERTIES);
Set<Value> oSeeAlso = model.filter(pfx, RDFS.SEEALSO, null).objects();
// class JavaDoc
out.println("/**");
if (oTitle != null) {
out.printf(
" * %s.%n",
WordUtils.wrap(oTitle.getLabel().replaceAll("\\s+", " "), 70, "\n * ", false));
out.println(" * <p>");
}
if (oDescr != null) {
out.printf(
" * %s.%n",
WordUtils.wrap(oDescr.getLabel().replaceAll("\\s+", " "), 70, "\n * ", false));
out.println(" * <p>");
}
out.printf(" * Namespace %s.%n", name);
out.printf(" * Prefix: {@code <%s>}%n", prefix);
if (!oSeeAlso.isEmpty()) {
out.println(" *");
for (Value s : oSeeAlso) {
if (s instanceof URI) {
out.printf(" * @see <a href=\"%s\">%s</a>%n", s.stringValue(), s.stringValue());
}
}
}
out.println(" */");
// class Definition
out.printf("public class %s {%n", className);
out.println();
// constants
out.printf(getIndent(1) + "/** {@code %s} **/%n", prefix);
out.printf(getIndent(1) + "public static final String NAMESPACE = \"%s\";%n", prefix);
out.println();
out.printf(getIndent(1) + "/** {@code %s} **/%n", name.toLowerCase());
out.printf(getIndent(1) + "public static final String PREFIX = \"%s\";%n", name.toLowerCase());
out.println();
List<String> keys = new ArrayList<>();
keys.addAll(splitUris.keySet());
Collections.sort(keys, String.CASE_INSENSITIVE_ORDER);
// do the string constant generation (if set)
if (stringGeneration != null) {
for (String key : keys) {
final Literal comment =
getFirstExistingObjectLiteral(
model, splitUris.get(key), getPreferredLanguage(), COMMENT_PROPERTIES);
final Literal label =
getFirstExistingObjectLiteral(
model, splitUris.get(key), getPreferredLanguage(), LABEL_PROPERTIES);
out.println(getIndent(1) + "/**");
if (label != null) {
out.printf(getIndent(1) + " * %s%n", label.getLabel());
out.println(getIndent(1) + " * <p>");
}
out.printf(getIndent(1) + " * {@code %s}.%n", splitUris.get(key).stringValue());
if (comment != null) {
out.println(getIndent(1) + " * <p>");
out.printf(
getIndent(1) + " * %s%n",
WordUtils.wrap(
comment.getLabel().replaceAll("\\s+", " "),
70,
"\n" + getIndent(1) + " * ",
false));
}
out.println(getIndent(1) + " *");
out.printf(getIndent(1) + " * @see <a href=\"%s\">%s</a>%n", splitUris.get(key), key);
out.println(getIndent(1) + " */");
final String nextKey =
cleanKey(
// NOTE: CONSTANT PREFIX and constant SUFFIX are NOT part of caseFormatting
String.format(
"%s%s%s",
StringUtils.defaultString(stringGeneration.getConstantPrefix()),
doCaseFormatting(key, stringGeneration.getCaseFormat()),
StringUtils.defaultString(stringGeneration.getConstantSuffix())));
checkField(className, nextKey);
out.printf(
getIndent(1) + "public static final String %s = %s.NAMESPACE + \"%s\";%n",
nextKey,
className,
key);
out.println();
}
}
// do the entire uri constant generation
if (uriGeneration != null) {
for (String key : keys) {
Literal comment =
getFirstExistingObjectLiteral(
model, splitUris.get(key), getPreferredLanguage(), COMMENT_PROPERTIES);
Literal label =
getFirstExistingObjectLiteral(
model, splitUris.get(key), getPreferredLanguage(), LABEL_PROPERTIES);
out.println(getIndent(1) + "/**");
if (label != null) {
out.printf(getIndent(1) + " * %s%n", label.getLabel());
out.println(getIndent(1) + " * <p>");
}
out.printf(getIndent(1) + " * {@code %s}.%n", splitUris.get(key).stringValue());
if (comment != null) {
out.println(getIndent(1) + " * <p>");
out.printf(
getIndent(1) + " * %s%n",
WordUtils.wrap(
comment.getLabel().replaceAll("\\s+", " "),
70,
"\n" + getIndent(1) + " * ",
false));
}
out.println(getIndent(1) + " *");
out.printf(getIndent(1) + " * @see <a href=\"%s\">%s</a>%n", splitUris.get(key), key);
out.println(getIndent(1) + " */");
final String nextKey =
cleanKey(
// NOTE: CONSTANT PREFIX and constant SUFFIX are NOT part of caseFormatting
String.format(
"%s%s%s",
StringUtils.defaultString(uriGeneration.getConstantPrefix()),
doCaseFormatting(key, uriGeneration.getCaseFormat()),
StringUtils.defaultString(uriGeneration.getConstantSuffix())));
// String nextKey = cleanKey(doCaseFormatting(key, uriGeneration.getCaseFormat()));
checkField(className, nextKey);
out.printf(getIndent(1) + "public static final URI %s;%n", nextKey);
out.println();
}
// static init
out.println(getIndent(1) + "static {");
out.printf(getIndent(2) + "ValueFactory factory = ValueFactoryImpl.getInstance();%n");
out.println();
for (String key : keys) {
final String nextKey =
cleanKey(
// NOTE: CONSTANT PREFIX and constant SUFFIX are NOT part of caseFormatting
String.format(
"%s%s%s",
StringUtils.defaultString(uriGeneration.getConstantPrefix()),
doCaseFormatting(key, uriGeneration.getCaseFormat()),
StringUtils.defaultString(uriGeneration.getConstantSuffix())));
out.printf(
getIndent(2) + "%s = factory.createURI(%s.NAMESPACE, \"%s\");%n",
nextKey,
className,
key);
}
out.println(getIndent(1) + "}");
out.println();
}
// private contructor to avoid instances
out.printf(getIndent(1) + "private %s() {%n", className);
out.println(getIndent(2) + "//static access only");
out.println(getIndent(1) + "}");
out.println();
// class end
out.println("}");
out.flush();
}
/**
* Test method for {@link
* RDFJSONUtility.kmr.scam.rest.util.RDFJSON#graphToRdfJsonPreordered(java.util.Set,
* java.io.Writer)} .
*
* @throws JSONException
*/
@Test
public void testModelToRdfJsonPreorderedSetOfStatementWriter() throws Exception {
// final Set<Statement> testStatements = new TreeSet<Statement>(new StatementComparator());
final Model testStatements = new TreeModel();
final ValueFactoryImpl vf = ValueFactoryImpl.getInstance();
final BNode testBNode1 = vf.createBNode();
final BNode testBNode2 = vf.createBNode();
final URI testURI1 = vf.createURI("http://example.org/test/rdf/json/1");
final URI testURI2 = vf.createURI("http://my.test.org/rdf/type/2");
final URI testURI3 = vf.createURI("http://example.org/test/rdf/json/3");
final URI testURI4 = vf.createURI("http://example.org/test/rdf/json/4");
final URI testURI5 = vf.createURI("http://my.test.org/rdf/type/5");
final Statement testStatement1 = vf.createStatement(testURI1, testURI2, testURI3);
testStatements.add(testStatement1);
final Statement testStatement2 = vf.createStatement(testURI1, testURI2, testBNode1);
testStatements.add(testStatement2);
final Statement testStatement3 = vf.createStatement(testURI1, testURI2, testBNode2);
testStatements.add(testStatement3);
final Statement testStatement4 = vf.createStatement(testURI4, testURI2, testURI3);
testStatements.add(testStatement4);
final Statement testStatement5 = vf.createStatement(testURI4, testURI2, testBNode2);
testStatements.add(testStatement5);
final Statement testStatement6 = vf.createStatement(testURI4, testURI2, testBNode1);
testStatements.add(testStatement6);
final Statement testStatement7 = vf.createStatement(testBNode1, testURI5, testBNode2);
testStatements.add(testStatement7);
final Statement testStatement8 = vf.createStatement(testBNode1, testURI5, testURI1);
testStatements.add(testStatement8);
final Statement testStatement9 = vf.createStatement(testBNode1, testURI5, testURI4);
testStatements.add(testStatement9);
// RDFJSONUnitTest.log.info("testStatements=" + testStatements);
Assert.assertEquals(9, testStatements.size());
// Verify that the statements are in an acceptable order (testStatement5 and testStatement6
// can be legitimately swapped)
final Iterator<Statement> testStatementIterator = testStatements.iterator();
Assert.assertTrue(testStatementIterator.hasNext());
// testStatement7 should always be first by virtue of the fact that it has two blank nodes
// and no other statements have two blank nodes
Assert.assertEquals(testStatement7, testStatementIterator.next());
Assert.assertTrue(testStatementIterator.hasNext());
// Then testStatement8
Assert.assertEquals(testStatement8, testStatementIterator.next());
Assert.assertTrue(testStatementIterator.hasNext());
// Then testStatement9
Assert.assertEquals(testStatement9, testStatementIterator.next());
Assert.assertTrue(testStatementIterator.hasNext());
Rio.write(testStatements, this.testWriter, RDFFormat.RDFJSON);
// RDFJSONUtility.modelToRdfJson(testStatements, this.testWriter, this.testWriterConfig);
this.testOutput = this.testWriter.toString();
Assert.assertTrue(this.testOutput.length() > 0);
Assert.assertTrue(this.testOutput.startsWith("{"));
Assert.assertTrue(this.testOutput.endsWith("}"));
// RDFJSONUnitTest.log.info("testOutput=" + this.testOutput);
final int firstBlankNode = this.testOutput.indexOf("\"_:");
// Test that a bnode exists after the opening brace
Assert.assertTrue(firstBlankNode > 0);
// The first value after the first blank node should be a blank node identifier
final int firstValue = this.testOutput.indexOf("\"value\" : \"_:", firstBlankNode);
Assert.assertTrue("A suitable blank node value was not found", firstValue > 0);
// This should be guaranteed by the indexOf contract, but doing a quick check anyway
Assert.assertTrue(firstValue > firstBlankNode);
// Do a quick check to see if the testOutput is valid JSON
// FIXME: TODO: Test using Jackson
// Assert.fail("TODO: Implement me using Jackson");
// final JSONObject testJSONObject = new JSONObject(this.testOutput);
// Assert.assertNotNull(testJSONObject);
// Assert.assertTrue(testJSONObject.length() > 0);
// Assert.assertTrue(testJSONObject.names().length() > 0);
// Assert.assertTrue(testJSONObject.keys().hasNext());
}
@BeforeMethod
public void setUp() {
model.clear();
}
