/**
* Helper. Adds to the target model a translation of the given RDF list with each element replaced
* according to the map.
*/
private Resource mapList(Model target, Resource list, Map<Resource, Resource> map) {
if (list.equals(RDF.nil)) {
return RDF.nil;
} else {
Resource head = (Resource) list.getRequiredProperty(RDF.first).getObject();
Resource rest = (Resource) list.getRequiredProperty(RDF.rest).getObject();
Resource mapElt = target.createResource();
Resource mapHead = map.get(head);
if (mapHead == null) mapHead = head;
mapElt.addProperty(RDF.first, mapHead);
mapElt.addProperty(RDF.rest, mapList(target, rest, map));
return mapElt;
}
}
public void testQuintetOfQuadlets() {
Resource rs = model.createResource();
rs.addProperty(RDF.type, RDF.Statement);
model.createResource().addProperty(RDF.value, rs);
rs.addProperty(RDF.subject, model.createResource());
rs.addProperty(RDF.predicate, model.createProperty("http://example.org/foo"));
rs.addProperty(RDF.object, model.createResource());
rs.addProperty(RDF.object, model.createResource());
StmtIterator it = model.listStatements();
while (it.hasNext()) {
Statement s = it.nextStatement();
assertFalse(s.getObject().equals(s.getSubject()));
}
}
/** Initialize the result model. */
public void initResults() {
testResults = ModelFactory.createDefaultModel();
jena2 = testResults.createResource(BASE_RESULTS_URI + "#jena2");
jena2.addProperty(
RDFS.comment,
testResults.createLiteral(
"<a xmlns=\"http://www.w3.org/1999/xhtml\" href=\"http://jena.sourceforce.net/\">Jena2</a> includes a rule-based inference engine for RDF processing, "
+ "supporting both forward and backward chaining rules. Its OWL rule set is designed to provide sound "
+ "but not complete instance resasoning for that fragment of OWL/Full limited to the OWL/lite vocabulary. In"
+ "particular it does not support unionOf/complementOf.",
true));
jena2.addProperty(RDFS.label, "Jena2");
testResults.setNsPrefix("results", OWLResults.NS);
}
public void testBackwardCompatibility() throws RegistryException {
Registry rootRegistry = embeddedRegistryService.getSystemRegistry();
Resource r1 = rootRegistry.newResource();
r1.setContent("r1 content");
rootRegistry.put("/test/comments/r1", r1);
rootRegistry.addComment(
"/test/comments/r1", new Comment("backward-compatibility1 on this resource :)"));
rootRegistry.addComment(
"/test/comments/r1", new Comment("backward-compatibility2 on this resource :)"));
String sql =
"SELECT REG_COMMENT_ID FROM REG_COMMENT C, REG_RESOURCE_COMMENT RC "
+ "WHERE C.REG_COMMENT_TEXT LIKE ? AND C.REG_ID=RC.REG_COMMENT_ID";
Resource queryR = rootRegistry.newResource();
queryR.setMediaType(RegistryConstants.SQL_QUERY_MEDIA_TYPE);
queryR.addProperty(
RegistryConstants.RESULT_TYPE_PROPERTY_NAME, RegistryConstants.COMMENTS_RESULT_TYPE);
rootRegistry.put("/beep/x", queryR);
Map<String, String> params = new HashMap<String, String>();
params.put("query", sql);
params.put(RegistryConstants.RESULT_TYPE_PROPERTY_NAME, RegistryConstants.COMMENTS_RESULT_TYPE);
params.put("1", "backward-compatibility1%");
Collection qResults = rootRegistry.executeQuery("/beep/x", params);
String[] qPaths = (String[]) qResults.getContent();
assertEquals("Query result count should be 1", qPaths.length, 1);
}
private static void addTypeToAll(Resource type, Set<Resource> candidates) {
List<Resource> types = equivalentTypes(type);
for (Resource element : candidates) {
Resource resource = element;
for (int i = 0; i < types.size(); i += 1) resource.addProperty(RDF.type, types.get(i));
}
}
public static void main(String args[]) {
OntModel m = ModelFactory.createOntologyModel();
OntDocumentManager dm = m.getDocumentManager();
dm.addAltEntry(
"http://www.eswc2006.org/technologies/ontology",
"file:" + JENA + "src/examples/resources/eswc-2006-09-21.rdf");
m.read("http://www.eswc2006.org/technologies/ontology");
// create an empty model
Model model = ModelFactory.createDefaultModel();
// create the resource
Resource johnSmith = model.createResource(personURI);
// add the property
johnSmith.addProperty(VCARD.FN, fullName);
johnSmith.addProperty(
VCARD.N,
model.createResource().addProperty(VCARD.Given, "jon").addProperty(VCARD.Family, "Smit"));
// list the statements in the Model
StmtIterator iter = model.listStatements();
// print out the predicate, subject and object of each statement
while (iter.hasNext()) {
Statement stmt = iter.nextStatement(); // get next statement
Resource subject = stmt.getSubject(); // get the subject
Property predicate = stmt.getPredicate(); // get the predicate
RDFNode object = stmt.getObject(); // get the object
System.out.print(subject.toString());
System.out.print(" " + predicate.toString() + " ");
if (object instanceof Resource) {
System.out.print(object.toString());
} else {
// object is a literal
System.out.print(" \"" + object.toString() + "\"");
}
System.out.println(" .");
}
}
public static void main(String args[]) {
// create an empty model
Model model = ModelFactory.createDefaultModel();
// create the resource
Resource johnSmith = model.createResource(personURI);
// add the property
johnSmith.addProperty(VCARD.FN, fullName);
}
public void testDefaultQuery() throws Exception {
Resource r1 = registry.newResource();
String r1Content = "this is r1 content";
r1.setContent(r1Content.getBytes());
r1.setDescription("production ready.");
String r1Path = "/c3/r1";
registry.put(r1Path, r1);
Resource r2 = registry.newResource();
String r2Content = "content for r2 :)";
r2.setContent(r2Content);
r2.setDescription("ready for production use.");
String r2Path = "/c3/r2";
registry.put(r2Path, r2);
Resource r3 = registry.newResource();
String r3Content = "content for r3 :)";
r3.setContent(r3Content);
r3.setDescription("only for government use.");
String r3Path = "/c3/r3";
registry.put(r3Path, r3);
registry.applyTag("/c3/r1", "java");
registry.applyTag("/c3/r2", "jsp");
registry.applyTag("/c3/r3", "ajax");
String sql1 =
"SELECT RT.REG_TAG_ID FROM REG_RESOURCE_TAG RT, REG_RESOURCE R "
+ "WHERE (R.REG_VERSION=RT.REG_VERSION OR "
+ "(R.REG_PATH_ID=RT.REG_PATH_ID AND R.REG_NAME=RT.REG_RESOURCE_NAME)) "
+ "AND R.REG_DESCRIPTION LIKE ? ORDER BY RT.REG_TAG_ID";
Resource q1 = systemRegistry.newResource();
q1.setContent(sql1);
q1.setMediaType(RegistryConstants.SQL_QUERY_MEDIA_TYPE);
q1.addProperty(RegistryConstants.RESULT_TYPE_PROPERTY_NAME, RegistryConstants.TAGS_RESULT_TYPE);
systemRegistry.put("/qs/q3", q1);
Map<String, String> parameters = new HashMap<String, String>();
parameters.put("1", "%production%");
Collection result = registry.executeQuery("/qs/q3", parameters);
String[] tagPaths = result.getChildren();
assertEquals("There should be two matching tags.", tagPaths.length, 2);
Resource tag2 = registry.get(tagPaths[0]);
assertEquals("First matching tag should be 'java'", (String) tag2.getContent(), "java");
Resource tag1 = registry.get(tagPaths[1]);
assertEquals("Second matching tag should be 'jsp'", (String) tag1.getContent(), "jsp");
}
public void testWithoutTableParamsQuery() throws Exception {
Resource r1 = registry.newResource();
String r1Content = "this is r1 content";
r1.setContent(r1Content.getBytes());
r1.setDescription("production ready.");
String r1Path = "/c1/r1";
registry.put(r1Path, r1);
Resource r2 = registry.newResource();
String r2Content = "content for r2 :)";
r2.setContent(r2Content);
r2.setDescription("ready for production use.");
String r2Path = "/c2/r2";
registry.put(r2Path, r2);
Resource r3 = registry.newResource();
String r3Content = "content for r3 :)";
r3.setContent(r3Content);
r3.setDescription("only for government use.");
String r3Path = "/c2/r3";
registry.put(r3Path, r3);
String sql1 =
"SELECT REG_PATH_ID, REG_NAME FROM REG_RESOURCE, " + "REG_TAG WHERE REG_DESCRIPTION LIKE ?";
Resource q1 = systemRegistry.newResource();
q1.setContent(sql1);
q1.setMediaType(RegistryConstants.SQL_QUERY_MEDIA_TYPE);
q1.addProperty(
RegistryConstants.RESULT_TYPE_PROPERTY_NAME, RegistryConstants.RESOURCES_RESULT_TYPE);
systemRegistry.put("/qs/q1", q1);
Map<String, String> parameters = new HashMap<String, String>();
parameters.put("1", "%production%");
Resource result = registry.executeQuery("/qs/q1", parameters);
assertTrue(
"Search with result type Resource should return a directory.",
result instanceof org.wso2.carbon.registry.core.Collection);
List<String> matchingPaths = new ArrayList<String>();
String[] paths = (String[]) result.getContent();
matchingPaths.addAll(Arrays.asList(paths));
assertTrue("Path /c1/r1 should be in the results.", matchingPaths.contains("/c1/r1"));
assertTrue("Path /c2/r2 should be in the results.", matchingPaths.contains("/c2/r2"));
}
public void testWithoutWhereQuery() throws Exception {
Resource r1 = registry.newResource();
String r1Content = "this is r1 content";
r1.setContent(r1Content.getBytes());
r1.setDescription("production ready.");
String r1Path = "/c1/r1";
registry.put(r1Path, r1);
Resource r2 = registry.newResource();
String r2Content = "content for r2 :)";
r2.setContent(r2Content);
r2.setDescription("ready for production use.");
String r2Path = "/c2/r2";
registry.put(r2Path, r2);
Resource r3 = registry.newResource();
String r3Content = "content for r3 :)";
r3.setContent(r3Content);
r3.setDescription("only for government use.");
String r3Path = "/c2/r3";
registry.put(r3Path, r3);
String sql1 = "SELECT REG_PATH_ID, REG_NAME FROM REG_RESOURCE, REG_TAG";
Resource q1 = systemRegistry.newResource();
q1.setContent(sql1);
q1.setMediaType(RegistryConstants.SQL_QUERY_MEDIA_TYPE);
q1.addProperty(
RegistryConstants.RESULT_TYPE_PROPERTY_NAME, RegistryConstants.RESOURCES_RESULT_TYPE);
systemRegistry.put("/qs/q1", q1);
Map parameters = new HashMap();
Resource result = registry.executeQuery("/qs/q1", parameters);
assertTrue(
"Search with result type Resource should return a directory.",
result instanceof org.wso2.carbon.registry.core.Collection);
String[] paths = (String[]) result.getContent();
assertTrue("Should return all the resources", paths.length >= 3);
}
private Resource createMetadata(final boolean isListEndpoint, Integer totalResults)
throws URISyntaxException {
Model objectModel = ModelFactory.createDefaultModel();
MergedModels mergedModels = new MergedModels(objectModel);
//
Model meta = mergedModels.getMetaModel();
//
Resource thisMetaPage = meta.createResource("eh:/thisMetaPage");
Resource SEP = meta.createResource("eh:/sparqlEndpoint");
thisMetaPage.addProperty(API.sparqlEndpoint, SEP);
Bindings bindings = new Bindings();
URI ru = new URI(thisMetaPage.getURI());
Resource uriForDefinition = objectModel.createResource(thisMetaPage.getURI());
boolean suppressIPTO = true;
int page = 1, perPage = 10;
boolean hasMorePages = true;
Context context = new Context();
CompleteContext cc = new CompleteContext(Mode.PreferLocalnames, context, objectModel);
//
SetsMetadata setsMeta =
new SetsMetadata() {
@Override
public void setMetadata(String type, Model meta) {}
};
WantsMetadata wantsMeta =
new WantsMetadata() {
@Override
public boolean wantsMetadata(String name) {
return true;
}
};
//
Map<String, View> views = new HashMap<String, View>();
Set<FormatNameAndType> formats = new HashSet<FormatNameAndType>();
//
EndpointDetails details =
new EndpointDetails() {
@Override
public boolean isListEndpoint() {
return isListEndpoint;
}
@Override
public boolean hasParameterBasedContentNegotiation() {
return false;
}
};
//
EndpointMetadata.addAllMetadata(
mergedModels,
ru,
uriForDefinition,
bindings,
cc,
suppressIPTO,
thisMetaPage,
page,
perPage,
totalResults,
hasMorePages,
CollectionUtils.list(objectModel.createResource("eh:/item/_1")),
setsMeta,
wantsMeta,
"SELECT",
"VIEW",
new TestCaches.FakeSource("Nemos"),
views,
formats,
details);
return thisMetaPage;
}