jena-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From cla...@apache.org
Subject svn commit: r1520740 [2/4] - in /jena/Experimental/new-test/src/test/java/com/hp/hpl/jena: graph/ graph/impl/ shared/ test/ testing_framework/
Date Sat, 07 Sep 2013 07:48:52 GMT
Added: jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/graph/TestNode.java
URL: http://svn.apache.org/viewvc/jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/graph/TestNode.java?rev=1520740&view=auto
==============================================================================
--- jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/graph/TestNode.java (added)
+++ jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/graph/TestNode.java Sat Sep  7 07:48:51 2013
@@ -0,0 +1,756 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.hp.hpl.jena.graph;
+
+import static org.junit.Assert.*;
+
+import org.junit.Test;
+
+import com.hp.hpl.jena.datatypes.RDFDatatype ;
+import com.hp.hpl.jena.datatypes.TypeMapper ;
+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.rdf.model.impl.Util ;
+import com.hp.hpl.jena.shared.JenaException ;
+import com.hp.hpl.jena.shared.PrefixMapping ;
+import com.hp.hpl.jena.vocabulary.DC ;
+import com.hp.hpl.jena.vocabulary.OWL ;
+import com.hp.hpl.jena.vocabulary.RSS ;
+import com.hp.hpl.jena.vocabulary.VCARD ;
+
+/**
+    Exercise nodes. Make sure that the different node types do not overlap
+    and that the test predicates work properly on the different node kinds.
+*/
+public class TestNode {  
+    
+    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 );
+    private static final AnonId A = AnonId.create();
+
+    @Test
+    public void testBlanks()
+        {
+        assertTrue( "anonymous nodes are blank", NodeFactory.createAnon().isBlank() );
+        assertFalse( "anonymous nodes aren't literal", NodeFactory.createAnon().isLiteral() );
+        assertFalse( "anonymous nodes aren't URIs", NodeFactory.createAnon().isURI() );
+        assertFalse( "anonymous nodes aren't variables", NodeFactory.createAnon().isVariable() );
+        assertEquals( "anonymous nodes have the right id", NodeFactory.createAnon(A).getBlankNodeId(), A );
+        }
+        
+    @Test
+    public void testLiterals()
+        {
+        assertFalse( "literal nodes aren't blank", NodeFactory.createLiteral( L ).isBlank() );
+        assertTrue( "literal nodes are literal", NodeFactory.createLiteral( L ).isLiteral() );
+        assertFalse( "literal nodes aren't variables", NodeFactory.createLiteral( L ).isVariable() );
+        assertFalse( "literal nodes aren't URIs", NodeFactory.createLiteral( L ).isURI() );
+        assertEquals( "literal nodes preserve value", NodeFactory.createLiteral( L ).getLiteral(), L );
+        }
+        
+    @Test
+    public void testURIs()
+        {
+        assertFalse( "URI nodes aren't blank", NodeFactory.createURI( U ).isBlank() );
+        assertFalse( "URI nodes aren't literal", NodeFactory.createURI( U ).isLiteral() );
+        assertFalse( "URI nodes aren't variables", NodeFactory.createURI( U ).isVariable() );
+        assertTrue( "URI nodes are URIs", NodeFactory.createURI( U ).isURI() );
+        assertEquals( "URI nodes preserve URI", NodeFactory.createURI( U ).getURI(), U );
+        }
+        
+    @Test
+    public void testVariables()
+        {
+        assertFalse( "variable nodes aren't blank", NodeFactory.createVariable( N ).isBlank() );
+        assertFalse( "variable nodes aren't literal", NodeFactory.createVariable( N ).isLiteral() );        
+        assertFalse( "variable nodes aren't URIs", NodeFactory.createVariable( N ).isURI() );
+        assertTrue( "variable nodes are variable", NodeFactory.createVariable( N ).isVariable() );
+        assertEquals( "variable nodes keep their name", N, NodeFactory.createVariable( N ).getName() );
+        assertEquals( "variable nodes keep their name", N + "x", NodeFactory.createVariable( N + "x" ).getName() );
+        }
+        
+    @Test
+    public void testANY()
+        {
+        assertFalse( "ANY nodes aren't blank", Node.ANY.isBlank() );
+        assertFalse( "ANY nodes aren't literals", Node.ANY.isLiteral() );
+        assertFalse( "ANY nodes aren't URIs", Node.ANY.isURI() );
+        assertFalse( "ANY nodes aren't variables", Node.ANY.isVariable() );
+        assertFalse( "ANY nodes aren't blank", Node.ANY.isBlank() );
+        assertFalse( "ANY nodes aren't blank", Node.ANY.isBlank() );
+        }
+    
+    @Test
+    public void testNodeVariableConstructor()
+        {
+        assertEquals( NodeFactory.createVariable( "hello" ), new Node_Variable( "hello" ) );
+        assertEquals( NodeFactory.createVariable( "world" ), new Node_Variable( "world" ) );
+        GraphTestUtils.assertDiffer( NodeFactory.createVariable( "hello" ), new Node_Variable( "world" ) );
+        assertEquals( "myName", new Node_Variable( "myName" ).getName() );
+        }
+        
+    /**
+        test cases for equality: an array of (Node, String) pairs. [It's not worth
+        making a special class for these pairs.] The nodes are created with caching
+        off, to make sure that caching effects don't hide the effect of using .equals().
+        The strings are "equality groups": the nodes should test equal iff their
+        associated strings test equal. 
+    */
+    private Object [][] eqTestCases()
+    {
+        AnonId id = AnonId.create();
+        LiteralLabel L2 = LiteralLabelFactory.create( id.toString(), "", false );
+
+        LiteralLabel LLang1 = LiteralLabelFactory.create( "xyz", "en", null) ;
+        LiteralLabel LLang2 = LiteralLabelFactory.create( "xyz", "EN", null) ;
+
+        String U2 = id.toString();
+        String N2 = id.toString();
+        return new Object [][]
+            {
+            { Node.ANY, "0" },
+            { NodeFactory.createAnon( id ), "1" },
+            { NodeFactory.createAnon(), "2" },
+            { NodeFactory.createAnon( id ), "1" },
+            { NodeFactory.createLiteral( L ), "3" },
+
+            { NodeFactory.createLiteral( L2 ), "4" },
+            { NodeFactory.createLiteral( L ), "3" },
+            { NodeFactory.createURI( U ), "5" },
+            { NodeFactory.createURI( U2 ), "6" },
+            { NodeFactory.createURI( U ), "5" },
+            { NodeFactory.createVariable( N ), "7" },
+            { NodeFactory.createVariable( N2 ), "8" },
+            { NodeFactory.createVariable( N ), "7" } ,
+
+            { NodeFactory.createLiteral( LLang1 ), "9" },
+            { NodeFactory.createLiteral( LLang2 ), "10" },
+            };
+    }
+        
+    @Test
+    public void testNodeEquals() 
+        {
+        Object [][] tests = eqTestCases();
+        for (int i = 0; i < tests.length; i += 1)
+            {
+            Object [] I = tests[i];
+            assertFalse( I[0] + " should not equal null", I[0].equals( null ) );
+            assertFalse( I[0] + "should not equal 'String'", I[0].equals( "String" ) );
+            for (int j = 0; j < tests.length; j += 1)
+                {
+                Object [] J = tests[j];
+                testEquality( I[1].equals( J[1] ), I[0], J[0] );
+                }
+            }
+        }
+
+    private void testEquality( boolean testEq, Object x, Object y )
+        {
+        String testName = getType( x ) + " " + x + " and " + getType( y ) + " " + y;
+        if (testEq)
+            assertEquals( testName + "should be equal", x, y );
+        else
+        	GraphTestUtils.assertDiffer( testName + " should differ", x, y );
+        }
+        
+
+    private String getType( Object x )
+        {
+        String fullName = x.getClass().getName();
+        return fullName.substring( fullName.lastIndexOf( '.' ) + 1 );
+        }
+        
+    @Test
+    public void testEquals()
+    {
+    	GraphTestUtils.assertDiffer( "different variables", NodeFactory.createVariable( "xx" ), NodeFactory.createVariable( "yy" ) );
+        assertEquals( "same vars", NodeFactory.createVariable( "aa" ), NodeFactory.createVariable( "aa" ) );
+        assertEquals( "same URI", NodeFactory.createURI( U ), NodeFactory.createURI( U ) );
+        assertEquals( "same anon", NodeFactory.createAnon( A ), NodeFactory.createAnon( A ) );
+        assertEquals( "same literal", NodeFactory.createLiteral( L ), NodeFactory.createLiteral( L ) );
+        assertFalse( "distinct URIs", NodeFactory.createURI( U ) == NodeFactory.createURI( U ) );
+        assertFalse( "distinct hyphens", NodeFactory.createAnon( A ) == NodeFactory.createAnon( A ) );
+        assertFalse( "distinct literals", NodeFactory.createLiteral( L ) == NodeFactory.createLiteral( L ) );
+        assertFalse( "distinct vars", NodeFactory.createVariable( "aa" ) == NodeFactory.createVariable( "aa" ) );
+    }
+
+    /**
+        test that the label of a Node can be retrieved from that Node in
+        a way appropriate to that Node.
+    */
+    @Test
+    public void testLabels()
+        {
+        AnonId id = AnonId.create();
+        assertEquals( "get URI value", U, NodeFactory.createURI( U ).getURI() );
+        assertEquals( "get blank value", id, NodeFactory.createAnon( id ).getBlankNodeId() );
+        assertEquals( "get literal value", L, NodeFactory.createLiteral( L ).getLiteral() );
+        assertEquals( "get variable name", N, NodeFactory.createVariable( N ).getName() );
+        }
+        
+    /**
+        this is where we test that using the wrong accessor on a Node gets you
+        an exception. 
+    */
+    @Test
+    public void testFailingLabels()
+        {
+        Node u = NodeFactory.createURI( U ), b = NodeFactory.createAnon();
+        Node l = NodeFactory.createLiteral( L ), v = NodeFactory.createVariable( N );
+        Node a = Node.ANY;
+    /* */
+        testGetURIFails( a );
+        testGetURIFails( b );
+        testGetURIFails( l );
+        testGetURIFails( v );
+    /* */
+        testGetLiteralFails( a );
+        testGetLiteralFails( u );
+        testGetLiteralFails( b );
+        testGetLiteralFails( v );
+    /* */
+        testGetNameFails( a );
+        testGetNameFails( u );
+        testGetNameFails( b );
+        testGetNameFails( l );
+    /* */
+        testGetBlankNodeIdFails( a );
+        testGetBlankNodeIdFails( u );
+        testGetBlankNodeIdFails( l );
+        testGetBlankNodeIdFails( v );
+        }
+        
+    public void testGetBlankNodeIdFails( Node n )
+        { try { n.getBlankNodeId(); fail( n.getClass() + " should fail getName()" ); } catch (UnsupportedOperationException e) {} }
+
+    public void testGetURIFails( Node n )
+        { try { n.getURI(); fail( n.getClass() + " should fail getURI()" ); } catch (UnsupportedOperationException e) {} }
+        
+    public void testGetNameFails( Node n )
+        { try { n.getName(); fail( n.getClass() + " should fail getName()" ); } catch (UnsupportedOperationException e) {} }
+    
+    public void testGetLiteralFails( Node n )
+        { try { n.getLiteral(); fail( n.getClass() + " should fail getLiteral()" ); } catch (UnsupportedOperationException e) {} }
+        
+    
+    @Test
+     public void testGetBlankNodeLabelString()
+        {
+        Node n = NodeFactory.createAnon();
+        assertEquals( n.getBlankNodeId().getLabelString(), n.getBlankNodeLabel() );
+        }
+    
+    @Test
+    public void testVariableSupport()
+        {
+        assertEquals( Node_Variable.variable( "xxx" ), Node_Variable.variable( "xxx" ) );
+        GraphTestUtils.assertDiffer( Node_Variable.variable( "xxx" ), Node_Variable.variable( "yyy" ) );
+        assertEquals( Node_Variable.variable( "aaa" ), Node_Variable.variable( "aaa" ) );
+        GraphTestUtils.assertDiffer( Node_Variable.variable( "aaa" ), Node_Variable.variable( "yyy" ) );
+        }
+    
+    /** 
+        Test that the create method does sensible things on null and ""
+    */
+    @Test
+    public void testCreateBadString()
+        {
+        try { NodeCreateUtils.create( null ); fail( "must catch null argument" ); }
+        catch (NullPointerException e) {}
+        catch (JenaException e) {}
+        try { NodeCreateUtils.create( "" ); fail("must catch empty argument" ); }
+        catch (JenaException e) {}
+        }
+        
+    /**
+        Test that anonymous nodes are created with the correct labels
+    */
+    @Test
+    public void testCreateAnon()
+        {
+        String idA = "_xxx", idB = "_yyy";
+        Node a = NodeCreateUtils.create( idA ), b = NodeCreateUtils.create( idB );
+        assertTrue( "both must be bnodes", a.isBlank() && b.isBlank() );
+        assertEquals( new AnonId( idA ), a.getBlankNodeId() );
+        assertEquals( new AnonId( idB ), b.getBlankNodeId() );
+        }
+        
+    @Test
+    public void testCreateVariable()
+        {
+        String V = "wobbly";
+        Node v = NodeCreateUtils.create( "?" + V );
+        assertTrue( "must be a variable", v.isVariable() );
+        assertEquals( "name must be correct", V, v.getName() );
+        }
+        
+    @Test
+    public void testCreateANY()
+        {
+        assertEquals( "?? must denote ANY", Node.ANY, NodeCreateUtils.create( "??" ) );
+        }
+    
+    @Test
+     public void testCreatePlainLiteralSingleQuotes()
+        {
+        Node n = NodeCreateUtils.create( "'xxx'" );
+        assertEquals( "xxx", n.getLiteralLexicalForm() );
+        assertEquals( "", n.getLiteralLanguage() );
+        assertEquals( null, n.getLiteralDatatypeURI() );
+        }
+    
+    @Test
+    public void testCreatePlainLiteralDoubleQuotes()
+        {
+        Node n = NodeCreateUtils.create( "\"xxx\"" );
+        assertEquals( "xxx", n.getLiteralLexicalForm() );
+        assertEquals( "", n.getLiteralLanguage() );
+        assertEquals( null, n.getLiteralDatatypeURI() );
+        }
+    
+    @Test
+    public void testCreateLiteralBackslashEscape()
+        {
+        testStringConversion( "xx\\x", "'xx\\\\x'" );
+        testStringConversion( "xx\\x\\y", "'xx\\\\x\\\\y'" );
+        testStringConversion( "\\xyz\\", "'\\\\xyz\\\\'" );
+        }
+    
+    @Test
+    public void testCreateLiteralQuoteEscapes()
+        {
+        testStringConversion( "x\'y", "'x\\'y'" );
+        testStringConversion( "x\"y", "'x\\\"y'" );
+        testStringConversion( "x\'y\"z", "'x\\\'y\\\"z'" );
+        }
+    
+    @Test
+    public void testCreateLiteralOtherEscapes()
+        {
+        testStringConversion( " ", "'\\s'" );
+        testStringConversion( "\t", "'\\t'" );
+        testStringConversion( "\n", "'\\n'" );
+        }
+    
+    protected void testStringConversion( String wanted, String template )
+        {
+        Node n = NodeCreateUtils.create( template );
+        assertEquals( wanted, n.getLiteralLexicalForm() );
+        assertEquals( "", n.getLiteralLanguage() );
+        assertEquals( null, n.getLiteralDatatypeURI() );
+        }
+
+    @Test
+    public void testCreateLanguagedLiteralEN1()
+        {
+        Node n = NodeCreateUtils.create( "'chat'en-UK" );
+        assertEquals( "chat", n.getLiteralLexicalForm() );
+        assertEquals( "en-UK", n.getLiteralLanguage() );
+        assertEquals( null, n.getLiteralDatatypeURI() );
+        }    
+
+    @Test
+    public void testCreateLanguagedLiteralEN2()
+        {
+        Node n1 = NodeCreateUtils.create( "'chat'en-UK" );
+        Node n2 = NodeCreateUtils.create( "'chat'EN-UK" );
+        assertTrue( n1.sameValueAs(n2) ) ;
+        assertFalse( n1.equals(n2) ) ;
+        }    
+    
+    @Test
+    public void testCreateLanguagedLiteralXY()
+        {
+        Node n = NodeCreateUtils.create( "\"chat\"xy-AB" );
+        assertEquals( "chat", n.getLiteralLexicalForm() );
+        assertEquals( "xy-AB", n.getLiteralLanguage() );
+        assertEquals( null, n.getLiteralDatatypeURI() );
+        }
+    
+    @Test
+    public void testCreateTypedLiteralInteger()
+        {
+        Node n = NodeCreateUtils.create( "'42'xsd:integer" );
+        assertEquals( "42", n.getLiteralLexicalForm() );
+        assertEquals( "", n.getLiteralLanguage() );
+        assertEquals( expand( "xsd:integer" ), n.getLiteralDatatypeURI() );
+        }
+    
+    @Test
+    public void testCreateTypedLiteralBoolean()
+        {
+        Node n = NodeCreateUtils.create( "\"true\"xsd:boolean" );
+        assertEquals( "true", n.getLiteralLexicalForm() );
+        assertEquals( "", n.getLiteralLanguage() );
+        assertEquals( expand( "xsd:boolean" ), n.getLiteralDatatypeURI() );
+        }
+        
+    @Test
+    public void testGetPlainLiteralLexicalForm()
+        {
+        Node n = NodeCreateUtils.create( "'stuff'" );
+        assertEquals( "stuff", n.getLiteralLexicalForm() );
+        }
+    
+    @Test
+    public void testGetNumericLiteralLexicalForm()
+        {
+        Node n = NodeCreateUtils.create( "17" );
+        assertEquals( "17", n.getLiteralLexicalForm() );
+        }
+    
+    @Test
+    public void testTypesExpandPrefix()
+        {
+        testTypeExpandsPrefix( "rdf:spoo" );
+        testTypeExpandsPrefix( "rdfs:bar" );
+        testTypeExpandsPrefix( "owl:henry" );
+        testTypeExpandsPrefix( "xsd:bool" );
+        testTypeExpandsPrefix( "unknown:spoo" );
+        }
+    
+    private void testTypeExpandsPrefix( String type )
+        {
+        Node n = NodeCreateUtils.create( "'stuff'" + type );
+        String wanted = PrefixMapping.Extended.expandPrefix( type );
+        assertEquals( wanted, n.getLiteralDatatypeURI() );
+        }
+
+    @Test
+    public void testCreateURI()
+        {
+        String uri = "http://www.electric-hedgehog.net/";
+        testCreateURI( uri );
+        testCreateURI( "rdf:trinket", "http://www.w3.org/1999/02/22-rdf-syntax-ns#trinket" );
+        testCreateURI( "rdfs:device", "http://www.w3.org/2000/01/rdf-schema#device" );
+        testCreateURI( "dc:creator", DC.getURI() + "creator" );
+        testCreateURI( "rss:something", RSS.getURI() + "something" );
+        testCreateURI( "vcard:TITLE", VCARD.getURI() + "TITLE" );
+        testCreateURI( "owl:wol", OWL.NAMESPACE + "wol" );
+        }
+        
+    @Test
+    public void testCreateURIOtherMap()
+        {
+        String myNS = "eh:foo/bar#", suffix = "something";
+        PrefixMapping mine = PrefixMapping.Factory.create().setNsPrefix( "mine", myNS );
+        Node n = NodeCreateUtils.create( mine, "mine:" + suffix );
+        assertEquals( myNS + suffix, n.getURI() );
+        }
+        
+    private void testCreateURI( String inOut )
+        { testCreateURI( inOut, inOut ); }
+        
+    private void testCreateURI( String in, String wanted )
+        {
+        String got = NodeCreateUtils.create( in ).getURI();
+        if (!wanted.equals( got ))
+            {
+            if (in.equals( wanted )) fail( "should preserve " + in );
+            else fail( "should translate " + in + " to " + wanted + " not " + got );
+            }
+        }
+        
+    @Test
+    public void testCreatePrefixed()
+        {
+        PrefixMapping pm = PrefixMapping.Factory.create();
+        /* TODO Node n = */ NodeCreateUtils.create( pm, "xyz" );
+        }
+        
+    @Test
+    public void testToStringWithPrefixMapping()
+        {
+        PrefixMapping pm = PrefixMapping.Factory.create();
+        String prefix = "spoo", ns = "abc:def/ghi#";
+        pm.setNsPrefix( prefix, ns );
+        String suffix = "bamboozle";
+        assertEquals( prefix + ":" + suffix, NodeCreateUtils.create( ns + suffix ).toString( pm ) );    
+        }
+        
+    @Test
+    public void testNodeHelp()
+        {
+        assertTrue( "GraphTestUtils.node() making URIs", GraphTestUtils.node( "hello" ).isURI() );
+        assertTrue( "GraphTestUtils.node() making literals", GraphTestUtils.node( "123" ).isLiteral() );
+        assertTrue( "GraphTestUtils.node() making literals", GraphTestUtils.node( "'hello'" ).isLiteral() );
+        assertTrue( "GraphTestUtils.node() making hyphens", GraphTestUtils.node( "_x" ).isBlank() );
+        assertTrue( "GraphTestUtils.node() making variables", GraphTestUtils.node( "?x" ).isVariable() );
+        }
+        
+    @Test
+    public void testVisitorPatternNode()
+        {
+       NodeVisitor returnNode = new NodeVisitor() 
+            {
+            @Override
+            public Object visitAny( Node_ANY it ) { return it; }
+            @Override
+            public Object visitBlank( Node_Blank it, AnonId id ) { return it; }
+            @Override
+            public Object visitLiteral( Node_Literal it, LiteralLabel lit ) { return it; }
+            @Override
+            public Object visitURI( Node_URI it, String uri ) { return it; }
+            @Override
+            public Object visitVariable( Node_Variable it, String name ) { return it; }
+            };
+        testVisitorPatternNode( "sortOfURI", returnNode );
+        testVisitorPatternNode( "?variable", returnNode );
+        testVisitorPatternNode( "_anon", returnNode );
+        testVisitorPatternNode( "11", returnNode );
+        testVisitorPatternNode( "??", returnNode );
+        }
+        
+    private void testVisitorPatternNode( String ns, NodeVisitor v )
+        {
+        Node n = GraphTestUtils.node( ns ); 
+        assertEquals( n, n.visitWith( v ) ); 
+        }
+        
+    private void visitExamples( NodeVisitor nv )
+        {        
+        GraphTestUtils.node( "sortOfURI" ).visitWith( nv );        
+        GraphTestUtils.node( "?variableI" ).visitWith( nv );        
+        GraphTestUtils.node( "_anon" ).visitWith( nv );        
+        GraphTestUtils.node( "11" ).visitWith( nv );        
+        GraphTestUtils.node( "??" ).visitWith( nv );
+        }
+        
+    @Test
+    public void testVisitorPatternValue()
+        {
+        NodeVisitor checkValue = new NodeVisitor() 
+            {
+            @Override
+            public Object visitAny( Node_ANY it ) 
+                { return null; }
+            @Override
+            public Object visitBlank( Node_Blank it, AnonId id ) 
+                { assertTrue( it.getBlankNodeId() == id ); return null; }
+            @Override
+            public Object visitLiteral( Node_Literal it, LiteralLabel lit ) 
+                { assertTrue( it.getLiteral() == lit ); return null; }
+            @Override
+            public Object visitURI( Node_URI it, String uri ) 
+                { assertTrue( it.getURI() == uri ); return null; }
+            @Override
+            public Object visitVariable( Node_Variable it, String name ) 
+                { assertEquals( it.getName(), name ); return null; }
+            };
+        visitExamples( checkValue );
+        }
+        
+    /**
+        Test that the appropriate elements of the visitor are called exactly once;
+        this relies on the order of the visits in visitExamples.
+    */
+    @Test
+    public void testVisitorPatternCalled()
+        {
+        final String [] strings = new String [] { "" };
+        NodeVisitor checkCalled = new NodeVisitor() 
+            {
+            @Override
+            public Object visitAny( Node_ANY it ) 
+                { strings[0] += " any"; return null; }
+            @Override
+            public Object visitBlank( Node_Blank it, AnonId id ) 
+                { strings[0] += " blank"; return null; }
+            @Override
+            public Object visitLiteral( Node_Literal it, LiteralLabel lit ) 
+                { strings[0] += " literal"; return null; }
+            @Override
+            public Object visitURI( Node_URI it, String uri ) 
+                { strings[0] += " uri"; return null; }
+            @Override
+            public Object visitVariable( Node_Variable it, String name ) 
+                { strings[0] += " variable"; return null; }
+            };
+        String desired = " uri variable blank literal any";        
+        visitExamples( checkCalled );
+        assertEquals( "all vists must have been made", desired, strings[0] );
+        }
+        
+    @Test
+    public void testSimpleMatches()
+        {
+        assertTrue( NodeCreateUtils.create( "S").matches( NodeCreateUtils.create( "S" ) ) );
+        assertFalse(  "", NodeCreateUtils.create( "S").matches( NodeCreateUtils.create( "T" ) ) );
+        assertFalse( "", NodeCreateUtils.create( "S" ).matches( null ) );
+        assertTrue( NodeCreateUtils.create( "_X").matches( NodeCreateUtils.create( "_X" ) ) );
+        assertFalse( "", NodeCreateUtils.create( "_X").matches( NodeCreateUtils.create( "_Y" ) ) );
+        assertFalse( "", NodeCreateUtils.create( "_X").matches( null ) );
+        assertTrue( NodeCreateUtils.create( "10" ).matches( NodeCreateUtils.create( "10" ) ) );
+        assertFalse( "", NodeCreateUtils.create( "10" ).matches( NodeCreateUtils.create( "11" ) ) );
+        assertFalse( "", NodeCreateUtils.create( "10" ).matches( null ) );
+        assertTrue( Node.ANY.matches( NodeCreateUtils.create( "S" ) ) );
+        assertTrue( Node.ANY.matches( NodeCreateUtils.create( "_X" ) ) );
+        assertTrue( Node.ANY.matches( NodeCreateUtils.create( "10" ) ) );
+        assertFalse( "", Node.ANY.matches( null ) );
+        }
+        
+    @Test
+    public void testDataMatches()
+        {
+        TypeMapper tm = TypeMapper.getInstance();
+        RDFDatatype dt1 = tm.getTypeByValue( new Integer( 10 ) );
+        RDFDatatype dt2 = tm.getTypeByValue( new Short( (short) 10 ) );
+        Node a = NodeFactory.createLiteral( "10", "", dt1 );
+        Node b = NodeFactory.createLiteral( "10", "", dt2 );
+        GraphTestUtils.assertDiffer( "types must make a difference", a, b );
+        assertTrue( "A and B must express the same value", a.sameValueAs( b ) );
+        assertTrue( "matching literals must respect sameValueAs", a.matches( b ) );
+        }
+        
+    @Test
+    public void testLiteralToString()
+        {
+        TypeMapper tm = TypeMapper.getInstance();
+        RDFDatatype dtInt = tm.getTypeByValue( new Integer( 10 ) );
+        Node plain = NodeFactory.createLiteral( "rhubarb", "", false );    
+        Node english = NodeFactory.createLiteral( "eccentric", "en_UK", false );
+        Node typed = NodeFactory.createLiteral( "10", "", dtInt );
+        assertEquals( "\"rhubarb\"", plain.toString() );
+        assertEquals( "rhubarb", plain.toString( false ) );
+        assertEquals( "\"eccentric\"@en_UK", english.toString() );
+        assertEquals( "10^^http://www.w3.org/2001/XMLSchema#int", typed.toString( false ) );
+        }
+    
+    @Test
+    public void testGetIndexingValueURI()
+        {
+        Node u = NodeCreateUtils.create( "eh:/telephone" );
+        assertSame( u, u.getIndexingValue() );
+        }
+    
+    @Test
+    public void testGetIndexingValueBlank()
+        {
+        Node b = NodeCreateUtils.create( "_television" );
+        assertSame( b, b.getIndexingValue() );
+        }
+    
+    @Test
+    public void testGetIndexingValuePlainString()
+        { testIndexingValueLiteral( NodeCreateUtils.create( "'literally'" ) ); }
+    
+    @Test
+    public void testGetIndexingValueLanguagedString()
+        { testIndexingValueLiteral( NodeCreateUtils.create( "'chat'fr" ) ); }
+    
+    @Test
+    public void testGetIndexingValueXSDString()
+        { testIndexingValueLiteral( NodeCreateUtils.create( "'string'xsd:string" ) ); }
+    
+    private void testIndexingValueLiteral( Node s )
+        { assertEquals( s.getLiteral().getIndexingValue(), s.getIndexingValue() ); }
+    
+    // TODO should have more of these
+    @Test
+    public void  testGetLiteralValuePlainString()
+        {
+        Node s = NodeCreateUtils.create( "'aString'" );
+        assertSame( s.getLiteral().getValue(), s.getLiteralValue() );
+        }
+    
+    @Test
+    public void testGetLiteralDatatypeNull()
+        {
+        assertEquals( null, NodeCreateUtils.create( "'plain'" ).getLiteralDatatype() );
+        }
+    
+    @Test
+    public void testLiteralIsXML()
+        {
+        assertFalse( NodeCreateUtils.create( "'notXML'" ).getLiteralIsXML() );
+        assertFalse( NodeCreateUtils.create( "17" ).getLiteralIsXML() );
+        assertFalse( NodeCreateUtils.create( "'joke'xsd:Joke" ).getLiteralIsXML() );
+        assertTrue( NodeFactory.createLiteral( "lit", "lang", true ).getLiteralIsXML() );
+        assertFalse( NodeFactory.createLiteral( "lit", "lang", false ).getLiteralIsXML() );
+        }
+   
+    @Test
+    public void testConcrete()
+        {
+        assertTrue( NodeCreateUtils.create( "S" ).isConcrete() );
+        assertTrue( NodeCreateUtils.create( "_P" ).isConcrete() );
+        assertTrue( NodeCreateUtils.create( "11" ).isConcrete() );
+        assertTrue( NodeCreateUtils.create( "'hello'" ).isConcrete() );
+        assertFalse( NodeCreateUtils.create( "??" ).isConcrete() );
+        assertFalse( NodeCreateUtils.create( "?x" ).isConcrete() );
+        }
+
+    static String [] someURIs = new String [] 
+        {
+    		"http://domainy.thing/stuff/henry",
+            "http://whatever.com/stingy-beast/bee",
+            "ftp://erewhon/12345",
+            "potatoe:rhubarb"
+        };
+    
+    /**
+        test that URI nodes have namespace/localname splits which are consistent
+        with Util.splitNamepace.
+    */
+    @Test
+    public void testNamespace()
+        {
+        for (int i = 0; i < someURIs.length; i += 1)
+            {
+            String uri = someURIs[i];
+            int split = Util.splitNamespace( uri );
+        	Node n = NodeCreateUtils.create( uri );
+        	assertEquals( "check namespace", uri.substring( 0, split ), n.getNameSpace() );
+            assertEquals( "check localname", uri.substring( split ), n.getLocalName() );
+            }
+        }
+    
+    protected static String [] someNodes =
+        {
+            "42",
+            "'hello'",
+            "_anon",
+            "'robotic'tick",
+            "'teriffic'abc:def"
+        };
+    
+    @Test
+    public void testHasURI()
+        {
+        for (int i = 0; i < someURIs.length; i += 1) testHasURI( someURIs[i] );
+        for (int i = 0; i < someNodes.length; i += 1) testHasURI( someNodes[i] );
+        }
+
+	protected void testHasURI( String uri ) 
+        {
+		Node n = NodeCreateUtils.create( uri );
+		assertTrue( uri, !n.isURI() || n.hasURI( uri ) );
+		assertFalse( uri, n.hasURI( uri + "x" ) );
+        }
+
+    /**
+     	Answer the string <code>s</code> prefix-expanded using the built-in
+     	PrefixMapping.Extended.
+    */
+    private String expand( String s )
+        { return PrefixMapping.Extended.expandPrefix( s ); }
+    }

Propchange: jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/graph/TestNode.java
------------------------------------------------------------------------------
    svn:mime-type = text/plain

Added: jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/graph/TestNodeToTriplesMap.java
URL: http://svn.apache.org/viewvc/jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/graph/TestNodeToTriplesMap.java?rev=1520740&view=auto
==============================================================================
--- jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/graph/TestNodeToTriplesMap.java (added)
+++ jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/graph/TestNodeToTriplesMap.java Sat Sep  7 07:48:51 2013
@@ -0,0 +1,248 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.hp.hpl.jena.graph;
+
+import static org.junit.Assert.*;
+
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.Set;
+
+import org.junit.Test;
+
+import com.hp.hpl.jena.graph.Triple.*;
+import com.hp.hpl.jena.mem.NodeToTriplesMap;
+
+
+/**
+ 	TestNodeToTriplesMap: added, post-hoc, by kers once NTM got
+ 	rather complicated. So these tests may be (are, at the moment)
+ 	incomplete.
+*/
+public class TestNodeToTriplesMap
+    {
+       
+    protected NodeToTriplesMap ntS = new NodeToTriplesMap( Field.fieldSubject, Field.fieldPredicate, Field.fieldObject );
+    	
+    protected NodeToTriplesMap ntP = new NodeToTriplesMap( Field.fieldPredicate, Field.fieldObject, Field.fieldSubject );
+    	
+    protected NodeToTriplesMap ntO = new NodeToTriplesMap( Field.fieldObject, Field.fieldPredicate, Field.fieldSubject );
+
+    protected static final Node x = GraphTestUtils.node( "x" );
+    
+    protected static final Node y = GraphTestUtils.node( "y" );
+    
+    @Test
+    public void testZeroSize()
+        {
+        testZeroSize( "fresh NTM", ntS );
+        }
+    
+    protected void testZeroSize( String title, NodeToTriplesMap nt )
+        {
+        assertEquals( title + " should have size 0", 0, nt.size() );
+        assertEquals( title + " should be isEmpty()", true, nt.isEmpty() );
+        assertEquals( title + " should have empty domain", false, nt.domain().hasNext() );
+        }
+    
+    @Test
+    public void testAddOne()
+        {
+        ntS.add( GraphTestUtils.triple( "x P y" ) );
+        testJustOne( x, ntS );
+        }
+    
+    @Test
+    public void testAddOneTwice()
+        {
+        addTriples( ntS, "x P y; x P y" );
+        testJustOne( x, ntS );
+        }
+    
+    protected void testJustOne( Node x, NodeToTriplesMap nt )
+        {
+        assertEquals( 1, nt.size() );
+        assertEquals( false, nt.isEmpty() );
+        assertEquals( just( x ), GraphTestUtils.iteratorToSet( nt.domain() ) );
+        }
+    
+    @Test
+    public void testAddTwoUnshared()
+        {
+        addTriples( ntS, "x P a; y Q b" );
+        assertEquals( 2, ntS.size() );
+        assertEquals( false, ntS.isEmpty() );
+        assertEquals( both( x, y ), GraphTestUtils.iteratorToSet( ntS.domain() ) );
+        }
+    
+    @Test
+    public void testAddTwoShared()
+        {
+        addTriples( ntS, "x P a; x Q b" );
+        assertEquals( 2, ntS.size() );
+        assertEquals( false, ntS.isEmpty() );
+        assertEquals( just( x ), GraphTestUtils.iteratorToSet( ntS.domain() ) );
+        }
+    
+    @Test
+    public void testClear()
+        {
+        addTriples( ntS, "x P a; x Q b; y R z" );
+        ntS.clear();
+        testZeroSize( "cleared NTM", ntS );
+        }
+    
+    @Test
+    public void testAllIterator()
+        {
+        String triples = "x P b; y P d; y P f";
+        addTriples( ntS, triples );
+        assertEquals( GraphTestUtils.tripleSet( triples ), GraphTestUtils.iteratorToSet( ntS.iterateAll() ) );
+        }
+    
+    @Test
+    public void testOneIterator()
+        {
+        addTriples( ntS, "x P b; y P d; y P f" );
+        assertEquals( GraphTestUtils.tripleSet( "x P b" ), ntS.iterator( x, null ).toSet() );
+        assertEquals( GraphTestUtils.tripleSet( "y P d; y P f" ), ntS.iterator( y, null ).toSet() );
+        }
+    
+    @Test
+    public void testRemove()
+        {
+        addTriples( ntS, "x P b; y P d; y R f" );
+        ntS.remove( GraphTestUtils.triple( "y P d" ) );
+        assertEquals( 2, ntS.size() );
+        assertEquals( GraphTestUtils.tripleSet( "x P b; y R f" ), ntS.iterateAll().toSet() );
+        }
+    
+    @Test
+     public void testRemoveByIterator()
+        {
+        addTriples( ntS, "x nice a; a nasty b; x nice c" );
+        addTriples( ntS, "y nice d; y nasty e; y nice f" );
+        Iterator<Triple> it = ntS.iterateAll();
+        while (it.hasNext())
+            {
+            Triple t = it.next();
+            if (t.getPredicate().equals( GraphTestUtils.node( "nasty") )) it.remove();
+            }
+        assertEquals( GraphTestUtils.tripleSet( "x nice a; x nice c; y nice d; y nice f" ), ntS.iterateAll().toSet() );
+        }
+    
+    @Test
+    public void testIteratorWIthPatternOnEmpty()
+        {
+        assertEquals( GraphTestUtils.tripleSet( "" ), ntS.iterateAll( GraphTestUtils.triple( "a P b" ) ).toSet() );
+        }
+
+    @Test
+    public void testIteratorWIthPatternOnSomething()
+        {
+        addTriples( ntS, "x P a; y P b; y R c" );
+        assertEquals( GraphTestUtils.tripleSet( "x P a" ), ntS.iterateAll( GraphTestUtils.triple( "x P ??" ) ).toSet() );
+        assertEquals( GraphTestUtils.tripleSet( "y P b; y R c" ), ntS.iterateAll( GraphTestUtils.triple( "y ?? ??" ) ).toSet() );
+        assertEquals( GraphTestUtils.tripleSet( "x P a; y P b" ), ntS.iterateAll( GraphTestUtils.triple( "?? P ??" ) ).toSet() );
+        assertEquals( GraphTestUtils.tripleSet( "y R c" ), ntS.iterateAll( GraphTestUtils.triple( "?? ?? c" ) ).toSet() );
+        }
+
+    @Test
+    public void testUnspecificRemoveS()
+        {
+        addTriples( ntS, "x P a; y Q b; z R c" );
+        ntS.remove( GraphTestUtils.triple( "x P a" ) );
+        assertEquals( GraphTestUtils.tripleSet( "y Q b; z R c" ), ntS.iterateAll().toSet() );
+        }
+    
+    @Test
+    public void testUnspecificRemoveP()
+        {
+        addTriples( ntP, "x P a; y Q b; z R c" );
+        ntP.remove( GraphTestUtils.triple( "y Q b" ) );
+        assertEquals( GraphTestUtils.tripleSet( "x P a; z R c" ), ntP.iterateAll().toSet() );
+        }
+    
+    @Test
+    public void testUnspecificRemoveO()
+        {
+        addTriples( ntO, "x P a; y Q b; z R c" );
+        ntO.remove( GraphTestUtils.triple( "z R c" ) );
+        assertEquals( GraphTestUtils.tripleSet( "x P a; y Q b" ), ntO.iterateAll().toSet() );
+        }
+    
+    @Test
+     public void testAddBooleanResult()
+        {
+        assertEquals( true, ntS.add( GraphTestUtils.triple( "x P y" ) ) );
+        assertEquals( false, ntS.add( GraphTestUtils.triple( "x P y" ) ) );
+    /* */
+        assertEquals( true, ntS.add( GraphTestUtils.triple( "y Q z" ) ) );
+        assertEquals( false, ntS.add( GraphTestUtils.triple( "y Q z" ) ) );
+    /* */
+        assertEquals( true, ntS.add( GraphTestUtils.triple( "y R s" ) ) );
+        assertEquals( false, ntS.add( GraphTestUtils.triple( "y R s" ) ) );
+        }
+    
+    @Test
+    public void testRemoveBooleanResult()
+        {
+        assertEquals( false, ntS.remove( GraphTestUtils.triple( "x P y" ) ) );
+        ntS.add( GraphTestUtils.triple( "x P y" ) );
+        assertEquals( false, ntS.remove( GraphTestUtils.triple( "x Q y" ) ) );
+        assertEquals( true, ntS.remove( GraphTestUtils.triple( "x P y" ) ) );
+        assertEquals( false, ntS.remove( GraphTestUtils.triple( "x P y" ) ) );
+        }
+    
+    @Test
+    public void testContains()
+        {
+        addTriples( ntS, "x P y; a P b" );
+        assertTrue( ntS.contains( GraphTestUtils.triple( "x P y" ) ) );
+        assertTrue( ntS.contains( GraphTestUtils.triple( "a P b" ) ) );
+        assertFalse( ntS.contains( GraphTestUtils.triple( "x P z" ) ) );
+        assertFalse( ntS.contains( GraphTestUtils.triple( "y P y" ) ) );
+        assertFalse( ntS.contains( GraphTestUtils.triple( "x R y" ) ) );
+        assertFalse( ntS.contains( GraphTestUtils.triple( "e T f" ) ) );
+        assertFalse( ntS.contains( GraphTestUtils.triple( "_x F 17" ) ) );
+        }
+    
+    // TODO more here
+    
+    protected void addTriples( NodeToTriplesMap nt, String facts )
+        {
+        Triple [] t = GraphTestUtils.tripleArray( facts );
+        for (int i = 0; i < t.length; i += 1) nt.add( t[i] );
+        }
+    
+    protected static <T> Set<T> just( T x )
+        {
+        Set<T> result = new HashSet<T>();
+        result.add( x );
+        return result;
+        }
+
+    protected static Set<Object> both( Object x, Object y )
+        {
+        Set<Object> result = just( x );
+        result.add( y );
+        return result;
+        }
+    
+    }

Propchange: jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/graph/TestNodeToTriplesMap.java
------------------------------------------------------------------------------
    svn:mime-type = text/plain

Added: jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/graph/TestSimpleGraphMaker.java
URL: http://svn.apache.org/viewvc/jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/graph/TestSimpleGraphMaker.java?rev=1520740&view=auto
==============================================================================
--- jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/graph/TestSimpleGraphMaker.java (added)
+++ jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/graph/TestSimpleGraphMaker.java Sat Sep  7 07:48:51 2013
@@ -0,0 +1,35 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.hp.hpl.jena.graph;
+
+
+import com.hp.hpl.jena.graph.impl.*;
+
+
+/**
+    Test the SimpleGraphFactory by extending AbstractTestGraphFactory
+    and supplying new SimplGraphFactorys via getGraph.
+*/
+public class TestSimpleGraphMaker extends AbstractGraphMakerTest
+    {
+       
+    @Override
+    public GraphMaker getGraphMaker()
+        { return new SimpleGraphMaker(); }    
+    }

Propchange: jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/graph/TestSimpleGraphMaker.java
------------------------------------------------------------------------------
    svn:mime-type = text/plain

Added: 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=1520740&view=auto
==============================================================================
--- jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/graph/TestTriple.java (added)
+++ jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/graph/TestTriple.java Sat Sep  7 07:48:51 2013
@@ -0,0 +1,282 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.hp.hpl.jena.graph;
+
+import static org.junit.Assert.*;
+import static com.hp.hpl.jena.graph.GraphTestUtils.*;
+
+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" ) ) );
+        }
+    
+
+    }

Propchange: jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/graph/TestTriple.java
------------------------------------------------------------------------------
    svn:mime-type = text/plain

Added: 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=1520740&view=auto
==============================================================================
--- jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/graph/TestTripleField.java (added)
+++ jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/graph/TestTripleField.java Sat Sep  7 07:48:51 2013
@@ -0,0 +1,93 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.hp.hpl.jena.graph;
+
+import static com.hp.hpl.jena.graph.GraphTestUtils.*;
+import static org.junit.Assert.*;
+
+import org.junit.Test;
+
+import com.hp.hpl.jena.graph.Triple.Field;
+
+
+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() );
+        }
+    }

Propchange: jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/graph/TestTripleField.java
------------------------------------------------------------------------------
    svn:mime-type = text/plain



Mime
View raw message