Modified: jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/graph/TestTriple.java URL: http://svn.apache.org/viewvc/jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/graph/TestTriple.java?rev=1520788&r1=1520787&r2=1520788&view=diff ============================================================================== --- jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/graph/TestTriple.java (original) +++ jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/graph/TestTriple.java Sat Sep 7 18:58:59 2013 @@ -23,260 +23,273 @@ import static com.hp.hpl.jena.testing_fr import org.junit.Test; -import com.hp.hpl.jena.graph.Node ; -import com.hp.hpl.jena.graph.NodeFactory ; -import com.hp.hpl.jena.graph.Triple ; -import com.hp.hpl.jena.graph.impl.LiteralLabel ; -import com.hp.hpl.jena.graph.impl.LiteralLabelFactory ; -import com.hp.hpl.jena.rdf.model.AnonId ; -import com.hp.hpl.jena.shared.PrefixMapping ; - -public class TestTriple - { - - private static final String U = "http://some.domain.name/magic/spells.incant";; - private static final String N = "Alice"; - private static final LiteralLabel L = LiteralLabelFactory.create( "ashes are burning", "en", false ); - - @Test - public void testTripleEquals() { - // create some nodes to test - AnonId id = AnonId.create(); - LiteralLabel L2 = LiteralLabelFactory.create(id.toString(), "", false); - String U2 = id.toString(); - String N2 = id.toString(); - - Node[] nodes = new Node[] { - Node.ANY, - NodeFactory.createAnon(id), NodeFactory.createAnon(), - NodeFactory.createLiteral(L), NodeFactory.createLiteral(L2), - NodeFactory.createURI(U), NodeFactory.createURI(U2), - NodeFactory.createVariable(N), NodeFactory.createVariable(N2) - }; - - Triple[] triples = - new Triple [nodes.length * nodes.length * nodes.length]; - for (int i=0; i<nodes.length; i++) { - for (int j=0; j<nodes.length; j++) { - for (int k=0; k<nodes.length; k++) { - triples[i*nodes.length*nodes.length + - j*nodes.length + - k] = new Triple(nodes[i], nodes[j], nodes[k]); - } - } - } - - // set up the expected results matrix - // a expected[i][j] is true if triples[i] equals triples[j] - // triples are expected to be equals if there components are equal - boolean[][] expected = new boolean[triples.length][triples.length]; - for (int i1=0; i1<nodes.length; i1++) { - for (int j1=0; j1<nodes.length; j1++) { - for (int k1=0; k1<nodes.length; k1++) { - for (int i2=0; i2<nodes.length; i2++) { - for (int j2=0; j2<nodes.length; j2++) { - for (int k2=0; k2<nodes.length; k2++) { - expected[i1*nodes.length*nodes.length + - j1*nodes.length + - k1] - [i2*nodes.length*nodes.length + - j2*nodes.length + - k2] = - nodes[i1].equals(nodes[i2]) && - nodes[j1].equals(nodes[j2]) && - nodes[k1].equals(nodes[k2]); - } - } - } - } - } - } - - assertEquals("triple, null", triples[0].equals(null), false); - assertDiffer("triple, string", triples[0], "string"); - - // now compare each triple with each other triple - for (int i=0; i<triples.length; i++) { - for (int j=0; j<triples.length; j++) { - if (expected[i][j]) { - assertEquivalent("triples " + i + ", " + j , - triples[i], triples[j]); - } else { - assertDiffer("triples" + i + ", " + j, - triples[i], triples[j]); - } - } - } - } - - @Test - public void testTripleCreate() - { - Node S = NodeCreateUtils.create( "s" ), P = NodeCreateUtils.create( "p" ), O = NodeCreateUtils.create( "o" ); - assertEquals( new Triple( S, P, O ), Triple.create( S, P, O ) ); - } - - @Test - public void testTripleCreateFromString() - { - Node S = NodeCreateUtils.create( "a" ), P = NodeCreateUtils.create( "_P" ), O = NodeCreateUtils.create( "?c" ); - assertEquals( new Triple( S, P, O ), NodeCreateUtils.createTriple( "a _P ?c") ); - } - - /** - Test that triple-creation respects prefixes, assuming that node creation - does. - */ - @Test - public void testTriplePrefixes() - { - Node S = NodeCreateUtils.create( "rdf:alpha" ), P = NodeCreateUtils.create( "dc:creator" ); - Node O = NodeCreateUtils.create( "spoo:notmapped" ); - Triple t = NodeCreateUtils.createTriple( "rdf:alpha dc:creator spoo:notmapped" ); - assertEquals( new Triple( S, P, O ), t ); - } - - @Test - public void testTripleCreationMapped() - { - PrefixMapping pm = PrefixMapping.Factory.create() - .setNsPrefix( "a", "ftp://foo/"; ) - .setNsPrefix( "b", "http://spoo/"; ) - ; - Triple wanted = NodeCreateUtils.createTriple( "ftp://foo/x http://spoo/y c:z" ); - Triple got = NodeCreateUtils.createTriple( pm, "a:x b:y c:z" ); - assertEquals( wanted, got ); - } - - @Test - public void testPlainTripleMatches() - { - testMatches( "S P O" ); - testMatches( "_S _P _O" ); - testMatches( "1 2 3" ); - } - - @Test - public void testAnyTripleMatches() - { - testMatches( "?? P O", "Z P O" ); - testMatches( "S ?? O", "S Q O" ); - testMatches( "S P ??", "S P oh" ); - testMatches( "?? ?? ??", "X Y Z" ); - testMatches( "?? ?? ??", "X Y 1" ); - testMatches( "?? ?? ??", "_X Y Z" ); - testMatches( "?? ?? ??", "X _Y Z" ); - } - - private void testMatches( String triple ) - { testMatches( triple, triple ); } - - private void testMatches( String pattern, String triple ) - { assertTrue( NodeCreateUtils.createTriple( pattern ).matches( NodeCreateUtils.createTriple( triple ) ) ); } - - @Test - public void testPlainTripleDoesntMatch() - { - testMatchFails( "S P O", "Z P O" ); - testMatchFails( "S P O", "S Q O" ); - testMatchFails( "S P O", "S P oh" ); - } - - @Test - public void testAnyTripleDoesntMatch() - { - testMatchFails( "?? P O", "S P oh" ); - testMatchFails( "S ?? O", "Z R O" ); - testMatchFails( "S P ??", "Z P oh" ); - } - - - private void testMatchFails( String pattern, String triple ) - { assertFalse( NodeCreateUtils.createTriple( pattern ).matches( NodeCreateUtils.createTriple( triple ) ) ); } - - @Test - public void testMatchesNodes() - { - assertTrue( NodeCreateUtils.createTriple( "S P O" ).matches( node("S" ), node( "P" ), node( "O" ) ) ); - assertTrue( NodeCreateUtils.createTriple( "?? P O" ).matches( node("Z" ), node( "P" ), node( "O" ) ) ); - assertTrue( NodeCreateUtils.createTriple( "S ?? O" ).matches( node("S" ), node( "Q" ), node( "O" ) ) ); - assertTrue( NodeCreateUtils.createTriple( "S P ??" ).matches( node("S" ), node( "P" ), node( "I" ) ) ); - /* */ - assertFalse( NodeCreateUtils.createTriple( "S P O" ).matches( node("Z" ), node( "P" ), node( "O" ) ) ); - assertFalse( NodeCreateUtils.createTriple( "S P O" ).matches( node("S" ), node( "Q" ), node( "O" ) ) ); - assertFalse( NodeCreateUtils.createTriple( "S P O" ).matches( node("Z" ), node( "P" ), node( "I" ) ) ); - } - - @Test - public void testElementMatches() - { - assertTrue( NodeCreateUtils.createTriple( "S P O" ).subjectMatches( node( "S" ) ) ); - assertTrue( NodeCreateUtils.createTriple( "S P O" ).predicateMatches( node( "P" ) ) ); - assertTrue( NodeCreateUtils.createTriple( "S P O" ).objectMatches( node( "O" ) ) ); - /* */ - assertFalse( NodeCreateUtils.createTriple( "S P O" ).subjectMatches( node( "Z" ) ) ); - assertFalse( NodeCreateUtils.createTriple( "S P O" ).predicateMatches( node( "Q" ) ) ); - assertFalse( NodeCreateUtils.createTriple( "S P O" ).objectMatches( node( "I" ) ) ); - /* */ - assertTrue( NodeCreateUtils.createTriple( "?? P O" ).subjectMatches( node( "SUB" ) ) ); - assertTrue( NodeCreateUtils.createTriple( "S ?? O" ).predicateMatches( node( "PRED" ) ) ); - assertTrue( NodeCreateUtils.createTriple( "S P ??" ).objectMatches( node( "OBJ" ) ) ); - } - - @Test - public void testConcrete() - { - assertTrue( NodeCreateUtils.createTriple( "S P O" ).isConcrete() ); - assertTrue( NodeCreateUtils.createTriple( "S P 11").isConcrete() ); - assertTrue( NodeCreateUtils.createTriple( "S P _X").isConcrete() ); - assertTrue( NodeCreateUtils.createTriple( "S _P 11").isConcrete() ); - assertTrue( NodeCreateUtils.createTriple( "_S _P _O").isConcrete() ); - assertTrue( NodeCreateUtils.createTriple( "10 11 12").isConcrete() ); - assertTrue( NodeCreateUtils.createTriple( "S P 11").isConcrete() ); - assertFalse( NodeCreateUtils.createTriple( "?? P 11").isConcrete() ); - assertFalse( NodeCreateUtils.createTriple( "S ?? 11").isConcrete() ); - assertFalse( NodeCreateUtils.createTriple( "S P ??").isConcrete() ); - assertFalse( NodeCreateUtils.createTriple( "?S P 11").isConcrete() ); - assertFalse( NodeCreateUtils.createTriple( "S ?P 11").isConcrete() ); - assertFalse( NodeCreateUtils.createTriple( "S P ?O").isConcrete() ); - } - - /** - Primarily to make sure that literals get quoted and stuff comes out in some - kind of coherent order. - */ - @Test - public void testTripleToStringOrdering() - { - Triple t1 = NodeCreateUtils.createTriple( "subject predicate object" ); - assertTrue( "subject must be present", t1.toString().indexOf( "subject" ) >= 0 ); - assertTrue( "subject must preceed predicate", t1.toString().indexOf( "subject" ) < t1.toString().indexOf( "predicate" ) ); - assertTrue( "predicate must preceed object", t1.toString().indexOf( "predicate" ) < t1.toString().indexOf( "object" ) ); - } - - @Test - public void testTripleToStringQuoting() - { - Triple t1 = NodeCreateUtils.createTriple( "subject predicate 'object'" ); - assertTrue( t1.toString().indexOf( "\"object\"") > 0 ); - } - - @Test - public void testTripleToStringWithPrefixing() - { - PrefixMapping pm = PrefixMapping.Factory.create(); - pm.setNsPrefix( "spoo", "eg://domain.dom/spoo#" ); - Triple t1 = NodeCreateUtils.createTriple( "eg://domain.dom/spoo#a b c" ); - assertEquals( "spoo:a @eh:/b eh:/c", t1.toString( pm ) ); - } - - @Test - public void testTripleMaps() - { - assertEquals( node( "x" ), Triple.getSubject.map1( NodeCreateUtils.createTriple( "x P z" ) ) ); - assertEquals( node( "P" ), Triple.getPredicate.map1( NodeCreateUtils.createTriple( "x P z" ) ) ); - assertEquals( node( "z" ), Triple.getObject.map1( NodeCreateUtils.createTriple( "x P z" ) ) ); - } - +import com.hp.hpl.jena.graph.Node; +import com.hp.hpl.jena.graph.NodeFactory; +import com.hp.hpl.jena.graph.Triple; +import com.hp.hpl.jena.graph.impl.LiteralLabel; +import com.hp.hpl.jena.graph.impl.LiteralLabelFactory; +import com.hp.hpl.jena.rdf.model.AnonId; +import com.hp.hpl.jena.shared.PrefixMapping; - } +public class TestTriple { + + private static final String U = "http://some.domain.name/magic/spells.incant";; + private static final String N = "Alice"; + private static final LiteralLabel L = LiteralLabelFactory.create( + "ashes are burning", "en", false); + + @Test + public void testTripleEquals() { + // create some nodes to test + AnonId id = AnonId.create(); + LiteralLabel L2 = LiteralLabelFactory.create(id.toString(), "", false); + String U2 = id.toString(); + String N2 = id.toString(); + + Node[] nodes = new Node[] { Node.ANY, NodeFactory.createAnon(id), + NodeFactory.createAnon(), NodeFactory.createLiteral(L), + NodeFactory.createLiteral(L2), NodeFactory.createURI(U), + NodeFactory.createURI(U2), NodeFactory.createVariable(N), + NodeFactory.createVariable(N2) }; + + Triple[] triples = new Triple[nodes.length * nodes.length + * nodes.length]; + for (int i = 0; i < nodes.length; i++) { + for (int j = 0; j < nodes.length; j++) { + for (int k = 0; k < nodes.length; k++) { + triples[i * nodes.length * nodes.length + j * nodes.length + + k] = new Triple(nodes[i], nodes[j], nodes[k]); + } + } + } + + // set up the expected results matrix + // a expected[i][j] is true if triples[i] equals triples[j] + // triples are expected to be equals if there components are equal + boolean[][] expected = new boolean[triples.length][triples.length]; + for (int i1 = 0; i1 < nodes.length; i1++) { + for (int j1 = 0; j1 < nodes.length; j1++) { + for (int k1 = 0; k1 < nodes.length; k1++) { + for (int i2 = 0; i2 < nodes.length; i2++) { + for (int j2 = 0; j2 < nodes.length; j2++) { + for (int k2 = 0; k2 < nodes.length; k2++) { + expected[i1 * nodes.length * nodes.length + j1 + * nodes.length + k1][i2 * nodes.length + * nodes.length + j2 * nodes.length + k2] = nodes[i1] + .equals(nodes[i2]) + && nodes[j1].equals(nodes[j2]) + && nodes[k1].equals(nodes[k2]); + } + } + } + } + } + } + + assertEquals("triple, null", triples[0].equals(null), false); + assertDiffer("triple, string", triples[0], "string"); + + // now compare each triple with each other triple + for (int i = 0; i < triples.length; i++) { + for (int j = 0; j < triples.length; j++) { + if (expected[i][j]) { + assertEquivalent("triples " + i + ", " + j, triples[i], + triples[j]); + } else { + assertDiffer("triples" + i + ", " + j, triples[i], + triples[j]); + } + } + } + } + + @Test + public void testTripleCreate() { + Node S = NodeCreateUtils.create("s"), P = NodeCreateUtils.create("p"), O = NodeCreateUtils + .create("o"); + assertEquals(new Triple(S, P, O), Triple.create(S, P, O)); + } + + @Test + public void testTripleCreateFromString() { + Node S = NodeCreateUtils.create("a"), P = NodeCreateUtils.create("_P"), O = NodeCreateUtils + .create("?c"); + assertEquals(new Triple(S, P, O), + NodeCreateUtils.createTriple("a _P ?c")); + } + + /** + * Test that triple-creation respects prefixes, assuming that node creation + * does. + */ + @Test + public void testTriplePrefixes() { + Node S = NodeCreateUtils.create("rdf:alpha"), P = NodeCreateUtils + .create("dc:creator"); + Node O = NodeCreateUtils.create("spoo:notmapped"); + Triple t = NodeCreateUtils + .createTriple("rdf:alpha dc:creator spoo:notmapped"); + assertEquals(new Triple(S, P, O), t); + } + + @Test + public void testTripleCreationMapped() { + PrefixMapping pm = PrefixMapping.Factory.create() + .setNsPrefix("a", "ftp://foo/";) + .setNsPrefix("b", "http://spoo/";); + Triple wanted = NodeCreateUtils + .createTriple("ftp://foo/x http://spoo/y c:z"); + Triple got = NodeCreateUtils.createTriple(pm, "a:x b:y c:z"); + assertEquals(wanted, got); + } + + @Test + public void testPlainTripleMatches() { + testMatches("S P O"); + testMatches("_S _P _O"); + testMatches("1 2 3"); + } + + @Test + public void testAnyTripleMatches() { + testMatches("?? P O", "Z P O"); + testMatches("S ?? O", "S Q O"); + testMatches("S P ??", "S P oh"); + testMatches("?? ?? ??", "X Y Z"); + testMatches("?? ?? ??", "X Y 1"); + testMatches("?? ?? ??", "_X Y Z"); + testMatches("?? ?? ??", "X _Y Z"); + } + + private void testMatches(String triple) { + testMatches(triple, triple); + } + + private void testMatches(String pattern, String triple) { + assertTrue(NodeCreateUtils.createTriple(pattern).matches( + NodeCreateUtils.createTriple(triple))); + } + + @Test + public void testPlainTripleDoesntMatch() { + testMatchFails("S P O", "Z P O"); + testMatchFails("S P O", "S Q O"); + testMatchFails("S P O", "S P oh"); + } + + @Test + public void testAnyTripleDoesntMatch() { + testMatchFails("?? P O", "S P oh"); + testMatchFails("S ?? O", "Z R O"); + testMatchFails("S P ??", "Z P oh"); + } + + private void testMatchFails(String pattern, String triple) { + assertFalse(NodeCreateUtils.createTriple(pattern).matches( + NodeCreateUtils.createTriple(triple))); + } + + @Test + public void testMatchesNodes() { + assertTrue(NodeCreateUtils.createTriple("S P O").matches(node("S"), + node("P"), node("O"))); + assertTrue(NodeCreateUtils.createTriple("?? P O").matches(node("Z"), + node("P"), node("O"))); + assertTrue(NodeCreateUtils.createTriple("S ?? O").matches(node("S"), + node("Q"), node("O"))); + assertTrue(NodeCreateUtils.createTriple("S P ??").matches(node("S"), + node("P"), node("I"))); + /* */ + assertFalse(NodeCreateUtils.createTriple("S P O").matches(node("Z"), + node("P"), node("O"))); + assertFalse(NodeCreateUtils.createTriple("S P O").matches(node("S"), + node("Q"), node("O"))); + assertFalse(NodeCreateUtils.createTriple("S P O").matches(node("Z"), + node("P"), node("I"))); + } + + @Test + public void testElementMatches() { + assertTrue(NodeCreateUtils.createTriple("S P O").subjectMatches( + node("S"))); + assertTrue(NodeCreateUtils.createTriple("S P O").predicateMatches( + node("P"))); + assertTrue(NodeCreateUtils.createTriple("S P O").objectMatches( + node("O"))); + /* */ + assertFalse(NodeCreateUtils.createTriple("S P O").subjectMatches( + node("Z"))); + assertFalse(NodeCreateUtils.createTriple("S P O").predicateMatches( + node("Q"))); + assertFalse(NodeCreateUtils.createTriple("S P O").objectMatches( + node("I"))); + /* */ + assertTrue(NodeCreateUtils.createTriple("?? P O").subjectMatches( + node("SUB"))); + assertTrue(NodeCreateUtils.createTriple("S ?? O").predicateMatches( + node("PRED"))); + assertTrue(NodeCreateUtils.createTriple("S P ??").objectMatches( + node("OBJ"))); + } + + @Test + public void testConcrete() { + assertTrue(NodeCreateUtils.createTriple("S P O").isConcrete()); + assertTrue(NodeCreateUtils.createTriple("S P 11").isConcrete()); + assertTrue(NodeCreateUtils.createTriple("S P _X").isConcrete()); + assertTrue(NodeCreateUtils.createTriple("S _P 11").isConcrete()); + assertTrue(NodeCreateUtils.createTriple("_S _P _O").isConcrete()); + assertTrue(NodeCreateUtils.createTriple("10 11 12").isConcrete()); + assertTrue(NodeCreateUtils.createTriple("S P 11").isConcrete()); + assertFalse(NodeCreateUtils.createTriple("?? P 11").isConcrete()); + assertFalse(NodeCreateUtils.createTriple("S ?? 11").isConcrete()); + assertFalse(NodeCreateUtils.createTriple("S P ??").isConcrete()); + assertFalse(NodeCreateUtils.createTriple("?S P 11").isConcrete()); + assertFalse(NodeCreateUtils.createTriple("S ?P 11").isConcrete()); + assertFalse(NodeCreateUtils.createTriple("S P ?O").isConcrete()); + } + + /** + * Primarily to make sure that literals get quoted and stuff comes out in + * some kind of coherent order. + */ + @Test + public void testTripleToStringOrdering() { + Triple t1 = NodeCreateUtils.createTriple("subject predicate object"); + assertTrue("subject must be present", + t1.toString().indexOf("subject") >= 0); + assertTrue( + "subject must preceed predicate", + t1.toString().indexOf("subject") < t1.toString().indexOf( + "predicate")); + assertTrue( + "predicate must preceed object", + t1.toString().indexOf("predicate") < t1.toString().indexOf( + "object")); + } + + @Test + public void testTripleToStringQuoting() { + Triple t1 = NodeCreateUtils.createTriple("subject predicate 'object'"); + assertTrue(t1.toString().indexOf("\"object\"") > 0); + } + + @Test + public void testTripleToStringWithPrefixing() { + PrefixMapping pm = PrefixMapping.Factory.create(); + pm.setNsPrefix("spoo", "eg://domain.dom/spoo#"); + Triple t1 = NodeCreateUtils.createTriple("eg://domain.dom/spoo#a b c"); + assertEquals("spoo:a @eh:/b eh:/c", t1.toString(pm)); + } + + @Test + public void testTripleMaps() { + assertEquals(node("x"), + Triple.getSubject.map1(NodeCreateUtils.createTriple("x P z"))); + assertEquals(node("P"), + Triple.getPredicate.map1(NodeCreateUtils.createTriple("x P z"))); + assertEquals(node("z"), + Triple.getObject.map1(NodeCreateUtils.createTriple("x P z"))); + } + +}
Modified: jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/graph/TestTripleField.java URL: http://svn.apache.org/viewvc/jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/graph/TestTripleField.java?rev=1520788&r1=1520787&r2=1520788&view=diff ============================================================================== --- jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/graph/TestTripleField.java (original) +++ jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/graph/TestTripleField.java Sat Sep 7 18:58:59 2013 @@ -25,69 +25,66 @@ import org.junit.Test; import com.hp.hpl.jena.graph.Triple.Field; +public class TestTripleField { -public class TestTripleField - { - - @Test - public void testFieldsExistAndAreTyped() - { - assertInstanceOf( Triple.Field.class, Triple.Field.fieldSubject ); - assertInstanceOf( Triple.Field.class, Triple.Field.fieldObject ); - assertInstanceOf( Triple.Field.class, Triple.Field.fieldPredicate ); - } - - @Test - public void testGetSubject() - { - assertEquals( node( "s" ), Field.fieldSubject.getField( triple( "s p o" ) ) ); - } - - @Test - public void testGetObject() - { - assertEquals( node( "o" ), Field.fieldObject.getField( triple( "s p o" ) ) ); - } - - @Test - public void testGetPredicate() - { - assertEquals( node( "p" ), Field.fieldPredicate.getField( triple( "s p o" ) ) ); - } - - @Test - public void testFilterSubject() - { - assertTrue( Field.fieldSubject.filterOn( node( "a" ) ).accept( triple( "a P b" ) ) ); - assertFalse( Field.fieldSubject.filterOn( node( "x" ) ).accept( triple( "a P b" ) ) ); - } - - @Test - public void testFilterObject() - { - assertTrue( Field.fieldObject.filterOn( node( "b" ) ).accept( triple( "a P b" ) ) ); - assertFalse( Field.fieldObject.filterOn( node( "c" ) ).accept( triple( "a P b" ) ) ); - } - - @Test - public void testFilterPredicate() - { - assertTrue( Field.fieldPredicate.filterOn( node( "P" ) ).accept( triple( "a P b" ) ) ); - assertFalse( Field.fieldPredicate.filterOn( node( "Q" ) ).accept( triple( "a P b" ) ) ); - } - - @Test - public void testFilterByTriple() - { - assertTrue( Field.fieldSubject.filterOn( triple( "s P o" ) ).accept( triple( "s Q p" ) ) ); - assertFalse( Field.fieldSubject.filterOn( triple( "s P o" ) ).accept( triple( "x Q p" ) ) ); - } - - @Test - public void testWildcardFilterIsAny() - { - assertTrue( Field.fieldSubject.filterOn( triple( "?x R s" ) ).isAny() ); - assertTrue( Field.fieldObject.filterOn( triple( "x R ?s" ) ).isAny() ); - assertTrue( Field.fieldPredicate.filterOn( triple( "x ?R s" ) ).isAny() ); - } - } + @Test + public void testFieldsExistAndAreTyped() { + assertInstanceOf(Triple.Field.class, Triple.Field.fieldSubject); + assertInstanceOf(Triple.Field.class, Triple.Field.fieldObject); + assertInstanceOf(Triple.Field.class, Triple.Field.fieldPredicate); + } + + @Test + public void testGetSubject() { + assertEquals(node("s"), Field.fieldSubject.getField(triple("s p o"))); + } + + @Test + public void testGetObject() { + assertEquals(node("o"), Field.fieldObject.getField(triple("s p o"))); + } + + @Test + public void testGetPredicate() { + assertEquals(node("p"), Field.fieldPredicate.getField(triple("s p o"))); + } + + @Test + public void testFilterSubject() { + assertTrue(Field.fieldSubject.filterOn(node("a")).accept( + triple("a P b"))); + assertFalse(Field.fieldSubject.filterOn(node("x")).accept( + triple("a P b"))); + } + + @Test + public void testFilterObject() { + assertTrue(Field.fieldObject.filterOn(node("b")) + .accept(triple("a P b"))); + assertFalse(Field.fieldObject.filterOn(node("c")).accept( + triple("a P b"))); + } + + @Test + public void testFilterPredicate() { + assertTrue(Field.fieldPredicate.filterOn(node("P")).accept( + triple("a P b"))); + assertFalse(Field.fieldPredicate.filterOn(node("Q")).accept( + triple("a P b"))); + } + + @Test + public void testFilterByTriple() { + assertTrue(Field.fieldSubject.filterOn(triple("s P o")).accept( + triple("s Q p"))); + assertFalse(Field.fieldSubject.filterOn(triple("s P o")).accept( + triple("x Q p"))); + } + + @Test + public void testWildcardFilterIsAny() { + assertTrue(Field.fieldSubject.filterOn(triple("?x R s")).isAny()); + assertTrue(Field.fieldObject.filterOn(triple("x R ?s")).isAny()); + assertTrue(Field.fieldPredicate.filterOn(triple("x ?R s")).isAny()); + } +}
