| /* |
| * 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 org.apache.jena.shared; |
| |
| import java.util.HashMap; |
| import java.util.List; |
| import java.util.Map; |
| |
| import org.apache.jena.graph.test.GraphTestBase ; |
| |
| /** |
| Test prefix mappings - subclass this test and override getMapping() to |
| deliver the prefixMapping to be tested. |
| */ |
| |
| public abstract class AbstractTestPrefixMapping extends GraphTestBase |
| { |
| public AbstractTestPrefixMapping( String name ) |
| { super( name ); } |
| |
| /** |
| Subclasses implement to return a new, empty prefixMapping of their |
| preferred kind. |
| */ |
| abstract protected PrefixMapping getMapping(); |
| |
| static final String crispURI = "http://crisp.nosuch.net/"; |
| static final String ropeURI = "scheme:rope/string#"; |
| static final String butterURI = "ftp://ftp.nowhere.at.all/cream#"; |
| |
| /** |
| The empty prefix is specifically allowed [for the default namespace]. |
| */ |
| public void testEmptyPrefix() |
| { |
| PrefixMapping pm = getMapping(); |
| pm.setNsPrefix( "", crispURI ); |
| assertEquals( crispURI, pm.getNsPrefixURI( "" ) ); |
| } |
| |
| static final String [] badNames = |
| { |
| "<hello>", |
| "foo:bar", |
| "with a space", |
| "-argument" |
| }; |
| |
| /** |
| Test that various illegal names are trapped. |
| */ |
| public void testCheckNames() |
| { |
| PrefixMapping ns = getMapping(); |
| for ( String bad : badNames ) |
| { |
| try |
| { |
| ns.setNsPrefix( bad, crispURI ); |
| fail( "'" + bad + "' is an illegal prefix and should be trapped" ); |
| } |
| catch ( PrefixMapping.IllegalPrefixException e ) |
| { |
| pass(); |
| } |
| } |
| } |
| |
| public void testNullURITrapped() |
| { |
| try |
| { |
| getMapping().setNsPrefix( "xy", null ); |
| fail( "should trap null URI in setNsPrefix" ); |
| } |
| catch (NullPointerException e) |
| { pass(); } |
| } |
| |
| /** |
| test that a PrefixMapping maps names to URIs. The names and URIs are |
| all fully distinct - overlapping names/uris are dealt with in other tests. |
| */ |
| public void testPrefixMappingMapping() |
| { |
| String toast = "ftp://ftp.nowhere.not/"; |
| assertDiffer( "crisp and toast must differ", crispURI, toast ); |
| /* */ |
| PrefixMapping ns = getMapping(); |
| assertEquals( "crisp should be unset", null, ns.getNsPrefixURI( "crisp" ) ); |
| assertEquals( "toast should be unset", null, ns.getNsPrefixURI( "toast" ) ); |
| assertEquals( "butter should be unset", null, ns.getNsPrefixURI( "butter" ) ); |
| /* */ |
| ns.setNsPrefix( "crisp", crispURI ); |
| assertEquals( "crisp should be set", crispURI, ns.getNsPrefixURI( "crisp" ) ); |
| assertEquals( "toast should still be unset", null, ns.getNsPrefixURI( "toast" ) ); |
| assertEquals( "butter should still be unset", null, ns.getNsPrefixURI( "butter" ) ); |
| /* */ |
| ns.setNsPrefix( "toast", toast ); |
| assertEquals( "crisp should be set", crispURI, ns.getNsPrefixURI( "crisp" ) ); |
| assertEquals( "toast should be set", toast, ns.getNsPrefixURI( "toast" ) ); |
| assertEquals( "butter should still be unset", null, ns.getNsPrefixURI( "butter" ) ); |
| } |
| |
| /** |
| Test that we can run the prefix mapping in reverse - from URIs to prefixes. |
| uriB is a prefix of uriA to try and ensure that the ordering of the map doesn't matter. |
| */ |
| public void testReversePrefixMapping() |
| { |
| PrefixMapping ns = getMapping(); |
| String uriA = "http://jena.hpl.hp.com/A#", uriB = "http://jena.hpl.hp.com/"; |
| String uriC = "http://jena.hpl.hp.com/Csharp/"; |
| String prefixA = "aa", prefixB = "bb"; |
| ns.setNsPrefix( prefixA, uriA ).setNsPrefix( prefixB, uriB ); |
| assertEquals( null, ns.getNsURIPrefix( uriC) ); |
| assertEquals( prefixA, ns.getNsURIPrefix( uriA ) ); |
| assertEquals( prefixB, ns.getNsURIPrefix( uriB ) ); |
| } |
| |
| /** |
| test that we can extract a proper Map from a PrefixMapping |
| */ |
| public void testPrefixMappingMap() |
| { |
| PrefixMapping ns = getCrispyRope(); |
| Map<String, String> map = ns.getNsPrefixMap(); |
| assertEquals( "map should have two elements", 2, map.size() ); |
| assertEquals( crispURI, map.get( "crisp" ) ); |
| assertEquals( "scheme:rope/string#", map.get( "rope" ) ); |
| } |
| |
| /** |
| test that the Map returned by getNsPrefixMap does not alias (parts of) |
| the secret internal map of the PrefixMapping |
| */ |
| public void testPrefixMappingSecret() |
| { |
| PrefixMapping ns = getCrispyRope(); |
| Map<String, String> map = ns.getNsPrefixMap(); |
| /* */ |
| map.put( "crisp", "with/onions" ); |
| map.put( "sandwich", "with/cheese" ); |
| assertEquals( crispURI, ns.getNsPrefixURI( "crisp" ) ); |
| assertEquals( ropeURI, ns.getNsPrefixURI( "rope" ) ); |
| assertEquals( null, ns.getNsPrefixURI( "sandwich" ) ); |
| } |
| |
| private PrefixMapping getCrispyRope() |
| { |
| PrefixMapping ns = getMapping(); |
| ns.setNsPrefix( "crisp", crispURI); |
| ns.setNsPrefix( "rope", ropeURI ); |
| return ns; |
| } |
| |
| /** |
| these are strings that should not change when they are prefix-expanded |
| with crisp and rope as legal prefixes. |
| */ |
| static final String [] dontChange = |
| { |
| "", |
| "http://www.somedomain.something/whatever#", |
| "crispy:cabbage", |
| "cris:isOnInfiniteEarths", |
| "rop:tangled/web", |
| "roped:abseiling" |
| }; |
| |
| /** |
| these are the required mappings which the test cases below should |
| satisfy: an array of 2-arrays, where element 0 is the string to expand |
| and element 1 is the string it should expand to. |
| */ |
| static final String [][] expansions = |
| { |
| { "crisp:pathPart", crispURI + "pathPart" }, |
| { "rope:partPath", ropeURI + "partPath" }, |
| { "crisp:path:part", crispURI + "path:part" }, |
| }; |
| |
| public void testExpandPrefix() |
| { |
| PrefixMapping ns = getMapping(); |
| ns.setNsPrefix( "crisp", crispURI ); |
| ns.setNsPrefix( "rope", ropeURI ); |
| /* */ |
| for ( String aDontChange : dontChange ) |
| { |
| assertEquals( "should be unchanged", aDontChange, ns.expandPrefix( aDontChange ) ); |
| } |
| /* */ |
| for ( String[] expansion : expansions ) |
| { |
| assertEquals( "should expand correctly", expansion[1], ns.expandPrefix( expansion[0] ) ); |
| } |
| } |
| |
| public void testUseEasyPrefix() |
| { |
| testUseEasyPrefix( "prefix mapping impl", getMapping() ); |
| testShortForm( "prefix mapping impl", getMapping() ); |
| } |
| |
| public static void testUseEasyPrefix( String title, PrefixMapping ns ) |
| { |
| testShortForm( title, ns ); |
| } |
| |
| public static void testShortForm( String title, PrefixMapping ns ) |
| { |
| ns.setNsPrefix( "crisp", crispURI ); |
| ns.setNsPrefix( "butter", butterURI ); |
| assertEquals( title, "", ns.shortForm( "" ) ); |
| assertEquals( title, ropeURI, ns.shortForm( ropeURI ) ); |
| assertEquals( title, "crisp:tail", ns.shortForm( crispURI + "tail" ) ); |
| assertEquals( title, "butter:here:we:are", ns.shortForm( butterURI + "here:we:are" ) ); |
| } |
| |
| public void testEasyQName() |
| { |
| PrefixMapping ns = getMapping(); |
| String alphaURI = "http://seasonal.song/preamble/"; |
| ns.setNsPrefix( "alpha", alphaURI ); |
| assertEquals( "alpha:rowboat", ns.qnameFor( alphaURI + "rowboat" ) ); |
| } |
| |
| public void testNoQNameNoPrefix() |
| { |
| PrefixMapping ns = getMapping(); |
| String alphaURI = "http://seasonal.song/preamble/"; |
| ns.setNsPrefix( "alpha", alphaURI ); |
| assertEquals( null, ns.qnameFor( "eg:rowboat" ) ); |
| } |
| |
| public void testNoQNameBadLocal() |
| { |
| PrefixMapping ns = getMapping(); |
| String alphaURI = "http://seasonal.song/preamble/"; |
| ns.setNsPrefix( "alpha", alphaURI ); |
| assertEquals( null, ns.qnameFor( alphaURI + "12345" ) ); |
| } |
| |
| /** |
| The tests implied by the email where Chris suggested adding qnameFor; |
| shortForm generates illegal qnames but qnameFor does not. |
| */ |
| public void testQnameFromEmail() |
| { |
| String uri = "http://some.long.uri/for/a/namespace#"; |
| PrefixMapping ns = getMapping(); |
| ns.setNsPrefix( "x", uri ); |
| assertEquals( null, ns.qnameFor( uri ) ); |
| assertEquals( null, ns.qnameFor( uri + "non/fiction" ) ); |
| } |
| |
| |
| /** |
| test that we can add the maplets from another PrefixMapping without |
| losing our own. |
| */ |
| public void testAddOtherPrefixMapping() |
| { |
| PrefixMapping a = getMapping(); |
| PrefixMapping b = getMapping(); |
| assertFalse( "must have two diffferent maps", a == b ); |
| a.setNsPrefix( "crisp", crispURI ); |
| a.setNsPrefix( "rope", ropeURI ); |
| b.setNsPrefix( "butter", butterURI ); |
| assertEquals( null, b.getNsPrefixURI( "crisp") ); |
| assertEquals( null, b.getNsPrefixURI( "rope") ); |
| b.setNsPrefixes( a ); |
| checkContainsMapping( b ); |
| } |
| |
| private void checkContainsMapping( PrefixMapping b ) |
| { |
| assertEquals( crispURI, b.getNsPrefixURI( "crisp") ); |
| assertEquals( ropeURI, b.getNsPrefixURI( "rope") ); |
| assertEquals( butterURI, b.getNsPrefixURI( "butter") ); |
| } |
| |
| /** |
| as for testAddOtherPrefixMapping, except that it's a plain Map |
| we're adding. |
| */ |
| public void testAddMap() |
| { |
| PrefixMapping b = getMapping(); |
| Map<String, String> map = new HashMap<>(); |
| map.put( "crisp", crispURI ); |
| map.put( "rope", ropeURI ); |
| b.setNsPrefix( "butter", butterURI ); |
| b.setNsPrefixes( map ); |
| checkContainsMapping( b ); |
| } |
| |
| public void testAddDefaultMap() |
| { |
| PrefixMapping pm = getMapping(); |
| PrefixMapping root = PrefixMapping.Factory.create(); |
| pm.setNsPrefix( "a", "aPrefix:" ); |
| pm.setNsPrefix( "b", "bPrefix:" ); |
| root.setNsPrefix( "a", "pootle:" ); |
| root.setNsPrefix( "z", "bPrefix:" ); |
| root.setNsPrefix( "c", "cootle:" ); |
| assertSame( pm, pm.withDefaultMappings( root ) ); |
| assertEquals( "aPrefix:", pm.getNsPrefixURI( "a" ) ); |
| assertEquals( null, pm.getNsPrefixURI( "z" ) ); |
| assertEquals( "bPrefix:", pm.getNsPrefixURI( "b" ) ); |
| assertEquals( "cootle:", pm.getNsPrefixURI( "c" ) ); |
| } |
| |
| |
| public void testSecondPrefixRetainsExistingMap() |
| { |
| PrefixMapping A = getMapping(); |
| A.setNsPrefix( "a", crispURI ); |
| A.setNsPrefix( "b", crispURI ); |
| assertEquals( crispURI, A.getNsPrefixURI( "a" ) ); |
| assertEquals( crispURI, A.getNsPrefixURI( "b" ) ); |
| } |
| |
| public void testSecondPrefixReplacesReverseMap() |
| { |
| PrefixMapping A = getMapping(); |
| A.setNsPrefix( "a", crispURI ); |
| A.setNsPrefix( "b", crispURI ); |
| assertEquals( "b", A.getNsURIPrefix( crispURI ) ); |
| } |
| |
| public void testSecondPrefixDeletedUncoversPreviousMap() |
| { |
| PrefixMapping A = getMapping(); |
| A.setNsPrefix( "x", crispURI ); |
| A.setNsPrefix( "y", crispURI ); |
| A.removeNsPrefix( "y" ); |
| assertEquals( "x", A.getNsURIPrefix( crispURI ) ); |
| } |
| |
| /** |
| Test that the empty prefix does not wipe an existing prefix for the same URI. |
| */ |
| public void testEmptyDoesNotWipeURI() |
| { |
| PrefixMapping pm = getMapping(); |
| pm.setNsPrefix( "frodo", ropeURI ); |
| pm.setNsPrefix( "", ropeURI ); |
| assertEquals( ropeURI, pm.getNsPrefixURI( "frodo" ) ); |
| } |
| |
| /** |
| Test that adding a new prefix mapping for U does not throw away a default |
| mapping for U. |
| */ |
| public void testSameURIKeepsDefault() |
| { |
| PrefixMapping A = getMapping(); |
| A.setNsPrefix( "", crispURI ); |
| A.setNsPrefix( "crisp", crispURI ); |
| assertEquals( crispURI, A.getNsPrefixURI( "" ) ); |
| } |
| |
| public void testReturnsSelf() |
| { |
| PrefixMapping A = getMapping(); |
| assertSame( A, A.setNsPrefix( "crisp", crispURI ) ); |
| assertSame( A, A.setNsPrefixes( A ) ); |
| assertSame( A, A.setNsPrefixes( new HashMap<String, String>() ) ); |
| assertSame( A, A.removeNsPrefix( "rhubarb" ) ); |
| } |
| |
| public void testRemovePrefix() |
| { |
| String hURI = "http://test.remove.prefixes/prefix#"; |
| String bURI = "http://other.test.remove.prefixes/prefix#"; |
| PrefixMapping A = getMapping(); |
| A.setNsPrefix( "hr", hURI ); |
| A.setNsPrefix( "br", bURI ); |
| A.removeNsPrefix( "hr" ); |
| assertEquals( null, A.getNsPrefixURI( "hr" ) ); |
| assertEquals( bURI, A.getNsPrefixURI( "br" ) ); |
| } |
| |
| public void testClear() |
| { |
| String hURI = "http://test.remove.prefixes/prefix#"; |
| String bURI = "http://other.test.remove.prefixes/prefix#"; |
| PrefixMapping A = getMapping(); |
| A.setNsPrefix( "hr", hURI ); |
| A.setNsPrefix( "br", bURI ); |
| A.clearNsPrefixMap() ; |
| |
| assertEquals( null, A.getNsPrefixURI( "hr" ) ); |
| assertEquals( null, A.getNsPrefixURI( "br" ) ); |
| |
| assertEquals( null, A.getNsURIPrefix(hURI) ) ; |
| assertEquals( null, A.getNsURIPrefix(bURI) ) ; |
| } |
| |
| public void testNoMapping() { |
| String hURI = "http://test.prefixes/prefix#"; |
| PrefixMapping A = getMapping(); |
| assertTrue(A.hasNoMappings()) ; |
| A.setNsPrefix( "hr", hURI ); |
| assertFalse(A.hasNoMappings()) ; |
| } |
| |
| public void testNumPrefixes() { |
| String hURI = "http://test.prefixes/prefix#"; |
| PrefixMapping A = getMapping(); |
| assertEquals(0, A.numPrefixes()) ; |
| A.setNsPrefix( "hr", hURI ); |
| assertEquals(1, A.numPrefixes()) ; |
| } |
| |
| public void testEquality() |
| { |
| testEquals( "" ); |
| testEquals( "", "x=a", false ); |
| testEquals( "x=a", "", false ); |
| testEquals( "x=a" ); |
| testEquals( "x=a y=b", "y=b x=a", true ); |
| testEquals( "x=a x=b", "x=b x=a", false ); |
| } |
| |
| protected void testEquals( String S ) |
| { testEquals( S, S, true ); } |
| |
| protected void testEquals( String S, String T, boolean expected ) |
| { |
| testEqualsBase( S, T, expected ); |
| testEqualsBase( T, S, expected ); |
| } |
| |
| public void testEqualsBase( String S, String T, boolean expected ) |
| { |
| testEquals( S, T, expected, getMapping(), getMapping() ); |
| testEquals( S, T, expected, PrefixMapping.Factory.create(), getMapping() ); |
| } |
| |
| protected void testEquals( String S, String T, boolean expected, PrefixMapping A, PrefixMapping B ) |
| { |
| fill( A, S ); |
| fill( B, T ); |
| String title = "usual: '" + S + "', testing: '" + T + "', should be " + (expected ? "equal" : "different"); |
| assertEquals( title, expected, A.samePrefixMappingAs( B ) ); |
| assertEquals( title, expected, B.samePrefixMappingAs( A ) ); |
| } |
| |
| protected void fill( PrefixMapping pm, String settings ) |
| { |
| List<String> L = listOfStrings( settings ); |
| for ( String setting : L ) |
| { |
| int eq = setting.indexOf( '=' ); |
| pm.setNsPrefix( setting.substring( 0, eq ), setting.substring( eq + 1 ) ); |
| } |
| } |
| |
| public void testAllowNastyNamespace() |
| { // we now allow namespaces to end with non-punctuational characters |
| getMapping().setNsPrefix( "abc", "def" ); |
| } |
| |
| public void testLock() |
| { |
| PrefixMapping A = getMapping(); |
| assertSame( A, A.lock() ); |
| /* */ |
| try { A.setNsPrefix( "crisp", crispURI ); fail( "mapping should be frozen" ); } |
| catch (PrefixMapping.JenaLockedException e) { pass(); } |
| /* */ |
| try { A.setNsPrefixes( A ); fail( "mapping should be frozen" ); } |
| catch (PrefixMapping.JenaLockedException e) { pass(); } |
| /* */ |
| try { A.setNsPrefixes( new HashMap<String, String>() ); fail( "mapping should be frozen" ); } |
| catch (PrefixMapping.JenaLockedException e) { pass(); } |
| /* */ |
| try { A.removeNsPrefix( "toast" ); fail( "mapping should be frozen" ); } |
| catch (PrefixMapping.JenaLockedException e) { pass(); } |
| } |
| } |