static Node stringToNode(String string, PrefixMapping pmap) { return SSE.parseNode(string, pmap) ; } }
/** Parse a string to obtain a Node */ public static Node parseNode(String str, PrefixMapping pmap) { return parseNode(new StringReader(str), pmap) ; }
private Node parseNode(String str) { // Not NodeFactory.parseNode which does not have all the features (e.g. "_" and "?") return SSE.parseNode(str) ; }
private static void eval(Graph graph, Node start, Path path, String... expected) { Node[] r = new Node[expected.length] ; for ( int i = 0 ; i < expected.length ; i++ ) { r[i] = SSE.parseNode(expected[i]) ; } eval(graph, start, path, r) ; }
private RDF_Term testTerm(String str) { RDF_Term rt = testTerm(SSE.parseNode(str), prefixMap, false) ; return rt ; }
private static NodeValue nv(String str) { return NodeValue.makeNode(SSE.parseNode(str)); } }
private static NodeValue parse(String str) { Node n = SSE.parseNode(str) ; return NodeValue.makeNode(n) ; } // abs is a test of Function.unaryOp machinary
private void test(String nodeStr, JsonValue expected) { Node n = SSE.parseNode(nodeStr); JsonValue jv = RDFTerm2Json.fromNode(n); assertEquals(expected, jv); }
private void testQuery(String input, String output, String varStr, String valStr) { Query q1 = QueryFactory.create(PREFIX+input) ; Query qExpected = QueryFactory.create(PREFIX+output) ; Map<Var, Node> map = new HashMap<>() ; map.put(Var.alloc(varStr), SSE.parseNode(valStr)) ; Query qTrans = QueryTransformOps.transform(q1, map) ; assertEquals(qExpected, qTrans) ; }
private void testCast(String input, String output) { NodeValue nv2 = cast(input) ; Node expected = SSE.parseNode(output) ; Assert.assertEquals(expected, nv2.asNode()) ; }
@Test public void serialize_node_02() throws Exception { Node n = SSE.parseNode("123"); Node n1 = roundTrip(n); assertTrue(n1.isLiteral()); assertEquals(n, n1); }
@Test public void serialize_node_03() throws Exception { Node n = SSE.parseNode("_:b"); Node n1 = roundTrip(n); assertTrue(n1.isBlank()); assertEquals(n, n1); }
@Test public void serialize_node_01() throws Exception { Node n = SSE.parseNode("<http://example/>"); Node n1 = roundTrip(n); assertTrue(n1.isURI()); assertEquals(n, n1); }
@Test public void term_bnode_01() { Node n = SSE.parseNode("_:blanknode") ; RDF_Term rt = testTerm(n) ; assertEquals(rt.getBnode().getLabel(), n.getBlankNodeLabel()) ; }
private void testNormalization(String input, String output, RDFParserBuilder builder) { Graph graph = GraphFactory.createGraphMem(); String x = PREFIX+":s :p "+input; builder.source(new StringReader(x)).parse(graph); assertEquals(1, graph.size()); Node objExpected = SSE.parseNode(output); Node objObtained = graph.find(s, p, null).next().getObject(); assertEquals(objExpected, objObtained); } }
@Test public void graphDSG_basic_2() { Node gn1 = SSE.parseNode("<g1>") ; Graph g = makeNamedGraph(baseDSG, gn1) ; assertTrue(g instanceof GraphView) ; GraphView gv = (GraphView)g ; assertEquals(baseDSG, gv.getDataset()) ; assertEquals(gn1, gv.getGraphName()) ; }
@Test public void copyAdd_01() { Graph graph = SSE.parseGraph("(graph (:s :p :o))") ; Node g = SSE.parseNode(":g") ; DatasetGraph dsg = emptyDataset() ; dsg.addGraph(g, graph); graph.clear(); assertTrue(graph.isEmpty()) ; assertFalse(dsg.getGraph(g).isEmpty()) ; } }
@Test public void graph_txn_3() { Node gn = SSE.parseNode(":gn"); Graph g = dsg.getGraph(gn); Triple t = SSE.parseTriple("(:S :P :O)"); Quad q = Quad.create(gn, t); g.getTransactionHandler().execute(()->g.add(t)); g.getTransactionHandler().execute(()->{ Assert.assertTrue(g.contains(t)); dsg.contains(q); }); } }
@Test public void clear_01() { DatasetGraph dsg = emptyDataset() ; Quad quad = SSE.parseQuad("(quad <g> <s> <p> <o>)") ; Node gn = SSE.parseNode("<g>") ; assertTrue(dsg.isEmpty()) ; dsg.add(quad) ; assertFalse(dsg.isEmpty()) ; assertTrue(dsg.containsGraph(gn)) ; dsg.clear() ; assertTrue(dsg.isEmpty()) ; assertFalse(dsg.containsGraph(gn)) ; }