svn commit: r1523135 [5/6] - in /jena/Experimental/new-test/src/test/java/com/hp/hpl/jena: graph/ graph/compose/ graph/impl/ mem/ rdf/ rdf/model/ rdf/model/impl/ rdf/model/temp/ shared/ testing_framework/

[cl...@apache.org]

Added: jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/rdf/model/AbstractSeqMethodsTest.java
URL: http://svn.apache.org/viewvc/jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/rdf/model/AbstractSeqMethodsTest.java?rev=1523135&view=auto
==============================================================================
--- jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/rdf/model/AbstractSeqMethodsTest.java (added)
+++ jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/rdf/model/AbstractSeqMethodsTest.java Fri Sep 13 22:32:05 2013
@@ -0,0 +1,1051 @@
+/*
+ * 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.rdf.model;
+
+import com.hp.hpl.jena.rdf.model.Alt;
+import com.hp.hpl.jena.rdf.model.Bag;
+import com.hp.hpl.jena.rdf.model.Container;
+import com.hp.hpl.jena.rdf.model.Literal;
+import com.hp.hpl.jena.rdf.model.NodeIterator;
+import com.hp.hpl.jena.rdf.model.RDFNode;
+import com.hp.hpl.jena.rdf.model.Resource;
+import com.hp.hpl.jena.rdf.model.Seq;
+import com.hp.hpl.jena.rdf.model.SeqIndexBoundsException;
+import com.hp.hpl.jena.test.JenaTestBase;
+import static com.hp.hpl.jena.testing_framework.ModelHelper.*;
+import com.hp.hpl.jena.vocabulary.RDF;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.junit.Assert.*;
+import org.junit.Before;
+import org.junit.Test;
+
+public abstract class AbstractSeqMethodsTest extends
+		AbstractContainerMethodsTest {
+
+	protected LitTestObj aLitTestObj;
+
+	protected Literal tvLiteral;
+
+	protected Resource tvResource;
+
+	// protected Resource tvResObj;
+	protected Object anObject;
+
+	protected Bag tvBag;
+	protected Alt tvAlt;
+	protected Seq tvSeq;
+	protected static final String lang = "fr";
+	protected static final int num = 10;
+
+	protected boolean[] bools(final String s) {
+		final boolean[] result = new boolean[s.length()];
+		for (int i = 0; i < s.length(); i += 1) {
+			result[i] = s.charAt(i) == 't';
+		}
+		return result;
+	}
+
+	@Override
+	protected Class<? extends Container> getContainerClass() {
+		return Seq.class;
+	}
+
+	@Override
+	protected Container createContainer(String uri) {
+		return uri == null ? model.createSeq() : model.createSeq(uri);
+	}
+
+	private void error(final String test, final int n) {
+		fail(test + " -- " + n);
+	}
+
+	@Override
+	protected Resource getContainerType() {
+		return RDF.Seq;
+	}
+
+	@Before
+	public void setUpSeqMethodsTest() throws Exception {
+		aLitTestObj = new LitTestObj(12345);
+		tvLiteral = model.createLiteral("test 12 string 2");
+		tvResource = model.createResource();
+		// tvResObj = model.createResource( new ResTestObjF() );
+		anObject = new LitTestObj(1234);
+		tvBag = model.createBag();
+		tvAlt = model.createAlt();
+		tvSeq = model.createSeq();
+	}
+
+	@Test
+	public void testMoreIndexing() {
+		final int num = 10;
+		final Seq seq = model.createSeq();
+		for (int i = 0; i < num; i += 1) {
+			seq.add(i);
+		}
+
+		try {
+			seq.add(0, false);
+			fail("cannot at at position 0");
+		} catch (final SeqIndexBoundsException e) {
+			JenaTestBase.pass();
+		}
+
+		seq.add(num + 1, false);
+		assertEquals(num + 1, seq.size());
+
+		seq.remove(num + 1);
+		try {
+			seq.add(num + 2, false);
+			fail("cannot add past the end");
+		} catch (final SeqIndexBoundsException e) {
+			JenaTestBase.pass();
+		}
+
+		final int size = seq.size();
+		for (int i = 1; i <= (num - 1); i += 1) {
+			seq.add(i, 1000 + i);
+			assertEquals(1000 + i, seq.getInt(i));
+			assertEquals(0, seq.getInt(i + 1));
+			assertEquals(size + i, seq.size());
+			assertEquals(num - i - 1, seq.getInt(size));
+		}
+	}
+
+	protected void testRemove(final boolean[] retain) {
+		final int num = retain.length;
+		final Seq seq = model.createSeq();
+		for (int i = 0; i < num; i += 1) {
+			seq.add(i);
+		}
+		//
+		final List<RDFNode> retained = new ArrayList<RDFNode>();
+		//
+		final NodeIterator nIter = seq.iterator();
+		for (int i = 0; i < num; i += 1) {
+			final RDFNode x = nIter.nextNode();
+			if (retain[i]) {
+				retained.add(x);
+			} else {
+				nIter.remove();
+			}
+		}
+		//
+		assertFalse(nIter.hasNext());
+		assertEquals(retained, seq.iterator().toList());
+	}
+
+	@Test
+	public void testRemoveA() {
+		testRemove(bools("tttffffftt"));
+	}
+
+	@Test
+	public void testRemoveB() {
+		testRemove(bools("ftftttttft"));
+	}
+
+	@Test
+	public void testRemoveC() {
+		testRemove(bools("ffffffffff"));
+	}
+
+	@Test
+	public void testSeq4() {
+		final String test = "temp";
+		int n = 58305;
+		final Seq seq4 = model.createSeq();
+		n = ((n / 100) * 100) + 100;
+		n++;
+		seq4.add(tvBoolean);
+		n++;
+		if (!(seq4.getBoolean(1) == tvBoolean)) {
+			error(test, n);
+		}
+		n++;
+		seq4.add(tvByte);
+		n++;
+		if (!(seq4.getByte(2) == tvByte)) {
+			error(test, n);
+		}
+		n++;
+		seq4.add(tvShort);
+		n++;
+		if (!(seq4.getShort(3) == tvShort)) {
+			error(test, n);
+		}
+		n++;
+		seq4.add(tvInt);
+		n++;
+		if (!(seq4.getInt(4) == tvInt)) {
+			error(test, n);
+		}
+		n++;
+		seq4.add(tvLong);
+		n++;
+		if (!(seq4.getLong(5) == tvLong)) {
+			error(test, n);
+		}
+		n++;
+		seq4.add(tvChar);
+		n++;
+		if (!(seq4.getChar(6) == tvChar)) {
+			error(test, n);
+		}
+		n++;
+		seq4.add(tvFloat);
+		n++;
+		if (!(seq4.getFloat(7) == tvFloat)) {
+			error(test, n);
+		}
+		n++;
+		seq4.add(tvDouble);
+		n++;
+		if (!(seq4.getDouble(8) == tvDouble)) {
+			error(test, n);
+		}
+		n++;
+		seq4.add(tvString);
+		n++;
+		if (!(seq4.getString(9).equals(tvString))) {
+			error(test, n);
+		}
+		n++;
+		if (!(seq4.getLanguage(9).equals(""))) {
+			error(test, n);
+		}
+		n++;
+		seq4.add(tvString, AbstractSeqMethodsTest.lang);
+		n++;
+		if (!(seq4.getString(10).equals(tvString))) {
+			error(test, n);
+		}
+		n++;
+		if (!(seq4.getLanguage(10).equals(AbstractSeqMethodsTest.lang))) {
+			error(test, n);
+		}
+		n++;
+		seq4.add(anObject);
+		n++;
+		// if (!(seq4.getObject( 11, new LitTestObjF() ).equals( anObject )))
+		// error(
+		// test, n );
+		n++;
+		seq4.add(tvResource);
+		n++;
+		if (!(seq4.getResource(12).equals(tvResource))) {
+			error(test, n);
+		}
+		n++;
+		seq4.add(tvLiteral);
+		n++;
+		if (!(seq4.getLiteral(13).equals(tvLiteral))) {
+			error(test, n);
+		}
+		n++;
+		// seq4.add( tvResObj );
+		// n++;
+		// if (!(seq4.getResource( 14, new ResTestObjF() ).equals( tvResObj )))
+		// error(
+		// test, n );
+		n++;
+		seq4.add(tvBag);
+		n++;
+		if (!(seq4.getBag(14).equals(tvBag))) {
+			error(test, n);
+		}
+		n++;
+		seq4.add(tvAlt);
+		n++;
+		if (!(seq4.getAlt(15).equals(tvAlt))) {
+			error(test, n);
+		}
+		n++;
+		seq4.add(tvSeq);
+		n++;
+		if (!(seq4.getSeq(16).equals(tvSeq))) {
+			error(test, n);
+		}
+		n++;
+		try {
+			seq4.getInt(17);
+			error(test, n);
+		} catch (final SeqIndexBoundsException e) {
+			// as required
+		}
+		n++;
+		try {
+			seq4.getInt(0);
+			error(test, n);
+		} catch (final SeqIndexBoundsException e) {
+			// as required
+		}
+	}
+
+	@Test
+	public void testSeq5() {
+		final Seq seq5 = model.createSeq();
+		final String test = "seq5";
+		int n = 0;
+		for (int i = 0; i < AbstractSeqMethodsTest.num; i++) {
+			seq5.add(i);
+		}
+
+		try {
+			n++;
+			seq5.add(0, false);
+			error(test, n);
+		} catch (final SeqIndexBoundsException e) {
+			// as required
+		}
+		seq5.add(AbstractSeqMethodsTest.num + 1, false);
+		if (seq5.size() != (AbstractSeqMethodsTest.num + 1)) {
+			error(test, n);
+		}
+		seq5.remove(AbstractSeqMethodsTest.num + 1);
+		try {
+			n++;
+			seq5.add(AbstractSeqMethodsTest.num + 2, false);
+			error(test, n);
+		} catch (final SeqIndexBoundsException e) {
+			// as required
+		}
+
+		n = ((n / 100) * 100) + 100;
+		final int size = seq5.size();
+		for (int i = 1; i <= (AbstractSeqMethodsTest.num - 1); i++) {
+			n++;
+			seq5.add(i, 1000 + i);
+			n++;
+			if (!(seq5.getInt(i) == (1000 + i))) {
+				error(test, n);
+			}
+			n++;
+			if (!(seq5.getInt(i + 1) == 0)) {
+				error(test, n);
+			}
+			n++;
+			if (!(seq5.size() == (size + i))) {
+				error(test, n);
+			}
+			n++;
+			if (!(seq5.getInt(size) == (AbstractSeqMethodsTest.num - i - 1))) {
+				error(test, n);
+			}
+		}
+	}
+
+	@Test
+	public void testSeq6() {
+		final String test = "seq6";
+		int n = 0;
+		final Seq seq6 = model.createSeq();
+		seq6.add(model.createResource());
+		seq6.add(1, tvBoolean);
+		n++;
+		if (!(seq6.getBoolean(1) == tvBoolean)) {
+			error(test, n);
+		}
+		seq6.add(1, tvByte);
+		n++;
+		if (!(seq6.getByte(1) == tvByte)) {
+			error(test, n);
+		}
+		seq6.add(1, tvShort);
+		n++;
+		if (!(seq6.getShort(1) == tvShort)) {
+			error(test, n);
+		}
+		seq6.add(1, tvInt);
+		n++;
+		if (!(seq6.getInt(1) == tvInt)) {
+			error(test, n);
+		}
+		seq6.add(1, tvLong);
+		n++;
+		if (!(seq6.getLong(1) == tvLong)) {
+			error(test, n);
+		}
+		seq6.add(1, tvChar);
+		n++;
+		if (!(seq6.getChar(1) == tvChar)) {
+			error(test, n);
+		}
+		seq6.add(1, tvFloat);
+		n++;
+		if (!(seq6.getFloat(1) == tvFloat)) {
+			error(test, n);
+		}
+		seq6.add(1, tvDouble);
+		n++;
+		if (!(seq6.getDouble(1) == tvDouble)) {
+			error(test, n);
+		}
+		seq6.add(1, tvString);
+		n++;
+		if (!(seq6.getString(1).equals(tvString))) {
+			error(test, n);
+		}
+		seq6.add(1, tvString, AbstractSeqMethodsTest.lang);
+		n++;
+		if (!(seq6.getString(1).equals(tvString))) {
+			error(test, n);
+		}
+		seq6.add(1, tvResource);
+		n++;
+		if (!(seq6.getResource(1).equals(tvResource))) {
+			error(test, n);
+		}
+		seq6.add(1, tvLiteral);
+		n++;
+		if (!(seq6.getLiteral(1).equals(tvLiteral))) {
+			error(test, n);
+		}
+		seq6.add(1, anObject);
+		n++;
+		// if (!(seq6.getObject( 1, new LitTestObjF() ).equals( anObject )))
+		// error(
+		// test, n );
+
+		n = ((n / 100) * 100) + 100;
+		n++;
+		if (!(seq6.indexOf(anObject) == 1)) {
+			error(test, n);
+		}
+		n++;
+		if (!(seq6.indexOf(tvLiteral) == 2)) {
+			error(test, n);
+		}
+		n++;
+		if (!(seq6.indexOf(tvResource) == 3)) {
+			error(test, n);
+		}
+		n++;
+		if (!(seq6.indexOf(tvString, AbstractSeqMethodsTest.lang) == 4)) {
+			error(test, n);
+		}
+		n++;
+		if (!(seq6.indexOf(tvString) == 5)) {
+			error(test, n);
+		}
+		n++;
+		if (!(seq6.indexOf(tvDouble) == 6)) {
+			error(test, n);
+		}
+		n++;
+		if (!(seq6.indexOf(tvFloat) == 7)) {
+			error(test, n);
+		}
+		n++;
+		if (!(seq6.indexOf(tvChar) == 8)) {
+			error(test, n);
+		}
+		n++;
+		if (!(seq6.indexOf(tvLong) == 9)) {
+			error(test, n);
+		}
+		n++;
+		if (!(seq6.indexOf(tvInt) == 10)) {
+			error(test, n);
+		}
+		n++;
+		if (!(seq6.indexOf(tvShort) == 11)) {
+			error(test, n);
+		}
+		n++;
+		if (!(seq6.indexOf(tvByte) == 12)) {
+			error(test, n);
+		}
+		n++;
+		if (!(seq6.indexOf(tvBoolean) == 13)) {
+			error(test, n);
+		}
+		n++;
+		if (!(seq6.indexOf(1234543) == 0)) {
+			error(test, n);
+		}
+	}
+
+	@Test
+	public void testSeq7() {
+		final Seq seq7 = model.createSeq();
+		final String test = "seq7";
+		int n = 0;
+		n = ((n / 100) * 100) + 100;
+		for (int i = 0; i < AbstractSeqMethodsTest.num; i++) {
+			seq7.add(i);
+		}
+		n = ((n / 100) * 100) + 100;
+		seq7.set(5, tvBoolean);
+		n++;
+		if (!(seq7.getBoolean(5) == tvBoolean)) {
+			error(test, n);
+		}
+		n++;
+		if (!(seq7.getInt(4) == 3)) {
+			error(test, n);
+		}
+		n++;
+		if (!(seq7.getInt(6) == 5)) {
+			error(test, n);
+		}
+		n++;
+		if (!(seq7.size() == AbstractSeqMethodsTest.num)) {
+			error(test, n);
+		}
+		n = ((n / 100) * 100) + 100;
+		seq7.set(5, tvByte);
+		n++;
+		if (!(seq7.getByte(5) == tvByte)) {
+			error(test, n);
+		}
+		n++;
+		if (!(seq7.getInt(4) == 3)) {
+			error(test, n);
+		}
+		n++;
+		if (!(seq7.getInt(6) == 5)) {
+			error(test, n);
+		}
+		n++;
+		if (!(seq7.size() == AbstractSeqMethodsTest.num)) {
+			error(test, n);
+		}
+		n = ((n / 100) * 100) + 100;
+		seq7.set(5, tvShort);
+		n++;
+		if (!(seq7.getShort(5) == tvShort)) {
+			error(test, n);
+		}
+		n++;
+		if (!(seq7.getInt(4) == 3)) {
+			error(test, n);
+		}
+		n++;
+		if (!(seq7.getInt(6) == 5)) {
+			error(test, n);
+		}
+		n++;
+		if (!(seq7.size() == AbstractSeqMethodsTest.num)) {
+			error(test, n);
+		}
+		n = ((n / 100) * 100) + 100;
+		seq7.set(5, tvInt);
+		n++;
+		if (!(seq7.getInt(5) == tvInt)) {
+			error(test, n);
+		}
+		n++;
+		if (!(seq7.getInt(4) == 3)) {
+			error(test, n);
+		}
+		n++;
+		if (!(seq7.getInt(6) == 5)) {
+			error(test, n);
+		}
+		n++;
+		if (!(seq7.size() == AbstractSeqMethodsTest.num)) {
+			error(test, n);
+		}
+		n = ((n / 100) * 100) + 100;
+		seq7.set(5, tvLong);
+		n++;
+		if (!(seq7.getLong(5) == tvLong)) {
+			error(test, n);
+		}
+		n++;
+		if (!(seq7.getInt(4) == 3)) {
+			error(test, n);
+		}
+		n++;
+		if (!(seq7.getInt(6) == 5)) {
+			error(test, n);
+		}
+		n++;
+		if (!(seq7.size() == AbstractSeqMethodsTest.num)) {
+			error(test, n);
+		}
+		n = ((n / 100) * 100) + 100;
+		seq7.set(5, tvChar);
+		n++;
+		if (!(seq7.getChar(5) == tvChar)) {
+			error(test, n);
+		}
+		n++;
+		if (!(seq7.getInt(4) == 3)) {
+			error(test, n);
+		}
+		n++;
+		if (!(seq7.getInt(6) == 5)) {
+			error(test, n);
+		}
+		n++;
+		if (!(seq7.size() == AbstractSeqMethodsTest.num)) {
+			error(test, n);
+		}
+		n = ((n / 100) * 100) + 100;
+		seq7.set(5, tvFloat);
+		n++;
+		if (!(seq7.getFloat(5) == tvFloat)) {
+			error(test, n);
+		}
+		n++;
+		if (!(seq7.getInt(4) == 3)) {
+			error(test, n);
+		}
+		n++;
+		if (!(seq7.getInt(6) == 5)) {
+			error(test, n);
+		}
+		n++;
+		if (!(seq7.size() == AbstractSeqMethodsTest.num)) {
+			error(test, n);
+		}
+		n = ((n / 100) * 100) + 100;
+		seq7.set(5, tvDouble);
+		n++;
+		if (!(seq7.getDouble(5) == tvDouble)) {
+			error(test, n);
+		}
+		n++;
+		if (!(seq7.getInt(4) == 3)) {
+			error(test, n);
+		}
+		n++;
+		if (!(seq7.getInt(6) == 5)) {
+			error(test, n);
+		}
+		n++;
+		if (!(seq7.size() == AbstractSeqMethodsTest.num)) {
+			error(test, n);
+		}
+		n = ((n / 100) * 100) + 100;
+		seq7.set(5, tvString);
+		n++;
+		if (!(seq7.getString(5).equals(tvString))) {
+			error(test, n);
+		}
+		n++;
+		if (!(seq7.getLanguage(5).equals(""))) {
+			error(test, n);
+		}
+		n++;
+		if (!(seq7.getInt(4) == 3)) {
+			error(test, n);
+		}
+		n++;
+		if (!(seq7.getInt(6) == 5)) {
+			error(test, n);
+		}
+		n++;
+		if (!(seq7.size() == AbstractSeqMethodsTest.num)) {
+			error(test, n);
+		}
+		seq7.set(5, tvString, AbstractSeqMethodsTest.lang);
+		n++;
+		if (!(seq7.getString(5).equals(tvString))) {
+			error(test, n);
+		}
+		n++;
+		if (!(seq7.getLanguage(5).equals(AbstractSeqMethodsTest.lang))) {
+			error(test, n);
+		}
+		n++;
+		if (!(seq7.getInt(4) == 3)) {
+			error(test, n);
+		}
+		n++;
+		if (!(seq7.getInt(6) == 5)) {
+			error(test, n);
+		}
+		n++;
+		if (!(seq7.size() == AbstractSeqMethodsTest.num)) {
+			error(test, n);
+		}
+		n = ((n / 100) * 100) + 100;
+		seq7.set(5, tvLiteral);
+		n++;
+		if (!(seq7.getLiteral(5).equals(tvLiteral))) {
+			error(test, n);
+		}
+		n++;
+		if (!(seq7.getInt(4) == 3)) {
+			error(test, n);
+		}
+		n++;
+		if (!(seq7.getInt(6) == 5)) {
+			error(test, n);
+		}
+		n++;
+		if (!(seq7.size() == AbstractSeqMethodsTest.num)) {
+			error(test, n);
+		}
+		n = ((n / 100) * 100) + 100;
+		seq7.set(5, tvResource);
+		n++;
+		if (!(seq7.getResource(5).equals(tvResource))) {
+			error(test, n);
+		}
+		n++;
+		if (!(seq7.getInt(4) == 3)) {
+			error(test, n);
+		}
+		n++;
+		if (!(seq7.getInt(6) == 5)) {
+			error(test, n);
+		}
+		n++;
+		if (!(seq7.size() == AbstractSeqMethodsTest.num)) {
+			error(test, n);
+		}
+		n = ((n / 100) * 100) + 100;
+		seq7.set(5, anObject);
+		n++;
+		// if (!(seq7.getObject( 5, new LitTestObjF() )).equals( anObject ))
+		// error(
+		// test, n );
+		n++;
+		if (!(seq7.getInt(4) == 3)) {
+			error(test, n);
+		}
+		n++;
+		if (!(seq7.getInt(6) == 5)) {
+			error(test, n);
+		}
+		n++;
+		if (!(seq7.size() == AbstractSeqMethodsTest.num)) {
+			error(test, n);
+		}
+		n = ((n / 100) * 100) + 100;
+		// seq7.set( 5, tvResObj );
+		// n++;
+		// if (!(seq7.getResource( 5, new ResTestObjF() ).equals( tvResObj )))
+		// error(
+		// test, n );
+		n++;
+		if (!(seq7.getInt(4) == 3)) {
+			error(test, n);
+		}
+		n++;
+		if (!(seq7.getInt(6) == 5)) {
+			error(test, n);
+		}
+		n++;
+		if (!(seq7.size() == AbstractSeqMethodsTest.num)) {
+			error(test, n);
+		}
+	}
+
+	@Test
+	public void testSeqAccessByIndexing() {
+		// LitTestObj tvObject = new LitTestObj(12345);
+		final Literal tvLiteral = model.createLiteral("test 12 string 2");
+		final Resource tvResource = model.createResource();
+		// Resource tvResObj = model.createResource(new ResTestObjF());
+		final Object tvLitObj = new LitTestObj(1234);
+		final Bag tvBag = model.createBag();
+		final Alt tvAlt = model.createAlt();
+		final Seq tvSeq = model.createSeq();
+		//
+		final Seq seq = model.createSeq();
+		seq.add(true);
+		assertEquals(true, seq.getBoolean(1));
+		seq.add((byte) 1);
+		assertEquals((byte) 1, seq.getByte(2));
+		seq.add((short) 2);
+		assertEquals((short) 2, seq.getShort(3));
+		seq.add(-1);
+		assertEquals(-1, seq.getInt(4));
+		seq.add(-2);
+		assertEquals(-2, seq.getLong(5));
+		seq.add('!');
+		assertEquals('!', seq.getChar(6));
+		seq.add(123.456f);
+		assertEquals(123.456f, seq.getFloat(7), 0.00005);
+		seq.add(12345.67890);
+		assertEquals(12345.67890, seq.getDouble(8), 0.00000005);
+		seq.add("some string");
+		assertEquals("some string", seq.getString(9));
+		seq.add(tvLitObj);
+		// assertEquals( tvLitObj, seq.getObject( 10, new LitTestObjF() ) );
+		seq.add(tvResource);
+		assertEquals(tvResource, seq.getResource(11));
+		// seq.add( tvResObj );
+		// assertEquals( tvResObj, seq.getResource( 12, new ResTestObjF() ) );
+		seq.add(tvLiteral);
+		assertEquals(tvLiteral, seq.getLiteral(12));
+		seq.add(tvBag);
+		assertEquals(tvBag, seq.getBag(13));
+		seq.add(tvAlt);
+		assertEquals(tvAlt, seq.getAlt(14));
+		seq.add(tvSeq);
+		assertEquals(tvSeq, seq.getSeq(15));
+		//
+		try {
+			seq.getInt(16);
+			fail("there is no element 16");
+		} catch (final SeqIndexBoundsException e) {
+			JenaTestBase.pass();
+		}
+		try {
+			seq.getInt(0);
+			fail("there is no element 0");
+		} catch (final SeqIndexBoundsException e) {
+			JenaTestBase.pass();
+		}
+	}
+
+	@Test
+	public void testSeqAdd() {
+		final Seq seq = model.createSeq();
+		assertEquals(0, seq.size());
+		assertTrue(model.contains(seq, RDF.type, RDF.Seq));
+		//
+		seq.add(tvBoolean);
+		assertTrue(seq.contains(tvBoolean));
+		assertFalse(seq.contains(!tvBoolean));
+		//
+		seq.add(tvByte);
+		assertTrue(seq.contains(tvByte));
+		assertFalse(seq.contains((byte) 101));
+		//
+		seq.add(tvShort);
+		assertTrue(seq.contains(tvShort));
+		assertFalse(seq.contains((short) 102));
+		//
+		seq.add(tvInt);
+		assertTrue(seq.contains(tvInt));
+		assertFalse(seq.contains(-101));
+		//
+		seq.add(tvLong);
+		assertTrue(seq.contains(tvLong));
+		assertFalse(seq.contains(-102));
+		//
+		seq.add(tvChar);
+		assertTrue(seq.contains(tvChar));
+		assertFalse(seq.contains('?'));
+		//
+		seq.add(123.456f);
+		assertTrue(seq.contains(123.456f));
+		assertFalse(seq.contains(456.123f));
+		//
+		seq.add(-123.456d);
+		assertTrue(seq.contains(-123.456d));
+		assertFalse(seq.contains(-456.123d));
+		//
+		seq.add("a string");
+		assertTrue(seq.contains("a string"));
+		assertFalse(seq.contains("a necklace"));
+		//
+		seq.add(model.createLiteral("another string"));
+		assertTrue(seq.contains("another string"));
+		assertFalse(seq.contains("another necklace"));
+		//
+		seq.add(new LitTestObj(12345));
+		assertTrue(seq.contains(new LitTestObj(12345)));
+		assertFalse(seq.contains(new LitTestObj(54321)));
+		//
+		// Resource present = model.createResource( new ResTestObjF() );
+		// Resource absent = model.createResource( new ResTestObjF() );
+		// seq.add( present );
+		// assertTrue( seq.contains( present ) );
+		// assertFalse( seq.contains( absent ) );
+		//
+		assertEquals(11, seq.size());
+	}
+
+	@Test
+	public void testSeqAddInts() {
+		final int num = 10;
+		final Seq seq = model.createSeq();
+		for (int i = 0; i < num; i += 1) {
+			seq.add(i);
+		}
+		assertEquals(num, seq.size());
+		final List<RDFNode> L = seq.iterator().toList();
+		assertEquals(num, L.size());
+		for (int i = 0; i < num; i += 1) {
+			assertEquals(i, ((Literal) L.get(i)).getInt());
+		}
+	}
+
+	@Test
+	public void testSeqInsertByIndexing() {
+		// LitTestObj tvObject = new LitTestObj(12345);
+		final Literal tvLiteral = model.createLiteral("test 12 string 2");
+		final Resource tvResource = model.createResource();
+		// Resource tvResObj = model.createResource(new ResTestObjF());
+		final Object tvLitObj = new LitTestObj(1234);
+		final Bag tvBag = model.createBag();
+		final Alt tvAlt = model.createAlt();
+		final Seq tvSeq = model.createSeq();
+
+		final Seq seq = model.createSeq();
+		seq.add(model.createResource());
+		seq.add(1, true);
+		assertEquals(true, seq.getBoolean(1));
+		seq.add(1, (byte) 1);
+		assertEquals((byte) 1, seq.getByte(1));
+		seq.add(1, (short) 2);
+		assertEquals((short) 2, seq.getShort(1));
+		seq.add(1, -1);
+		assertEquals(-1, seq.getInt(1));
+		seq.add(1, -2);
+		assertEquals(-2, seq.getLong(1));
+		seq.add(1, '!');
+		assertEquals('!', seq.getChar(1));
+		seq.add(1, 123.456f);
+		assertEquals(123.456f, seq.getFloat(1), 0.00005);
+		seq.add(1, 12345.67890);
+		assertEquals(12345.67890, seq.getDouble(1), 0.00000005);
+		seq.add(1, "some string");
+		assertEquals("some string", seq.getString(1));
+		seq.add(1, tvLitObj);
+		// assertEquals( tvLitObj, seq.getObject( 1, new LitTestObjF() ) );
+		seq.add(1, tvResource);
+		assertEquals(tvResource, seq.getResource(1));
+		// seq.add( 1, tvResObj );
+		// assertEquals( tvResObj, seq.getResource( 1, new ResTestObjF() ) );
+		seq.add(1, tvLiteral);
+		assertEquals(tvLiteral, seq.getLiteral(1));
+		seq.add(1, tvBag);
+		assertEquals(tvBag, seq.getBag(1));
+		seq.add(1, tvAlt);
+		assertEquals(tvAlt, seq.getAlt(1));
+		seq.add(1, tvSeq);
+		assertEquals(tvSeq, seq.getSeq(1));
+		//
+		assertEquals(0, seq.indexOf(1234543));
+		assertEquals(1, seq.indexOf(tvSeq));
+		assertEquals(2, seq.indexOf(tvAlt));
+		assertEquals(3, seq.indexOf(tvBag));
+		assertEquals(4, seq.indexOf(tvLiteral));
+		assertEquals(5, seq.indexOf(tvResource));
+		assertEquals(6, seq.indexOf(tvLitObj));
+		assertEquals(7, seq.indexOf("some string"));
+		assertEquals(8, seq.indexOf(12345.67890));
+		assertEquals(9, seq.indexOf(123.456f));
+		assertEquals(10, seq.indexOf('!'));
+		assertEquals(11, seq.indexOf(-2));
+		assertEquals(12, seq.indexOf(-1));
+		assertEquals(13, seq.indexOf((short) 2));
+		assertEquals(14, seq.indexOf((byte) 1));
+		assertEquals(15, seq.indexOf(true));
+	}
+
+	@Test
+	public void testSet() {
+		// NodeIterator nIter;
+		// StmtIterator sIter;
+		final Literal tvLiteral = model.createLiteral("test 12 string 2");
+		final Resource tvResource = model.createResource();
+		// Resource tvResObj = model.createResource(new ResTestObjF());
+		// Bag tvBag = model.createBag();
+		// Alt tvAlt = model.createAlt();
+		// Seq tvSeq = model.createSeq();
+		final int num = 10;
+		final Seq seq = model.createSeq();
+
+		for (int i = 0; i < num; i++) {
+			seq.add(i);
+		}
+
+		seq.set(5, tvBoolean);
+		assertEquals(tvBoolean, seq.getBoolean(5));
+		assertEquals(3, seq.getInt(4));
+		assertEquals(5, seq.getInt(6));
+		assertEquals(num, seq.size());
+
+		seq.set(5, tvByte);
+		assertEquals(tvByte, seq.getByte(5));
+		assertEquals(3, seq.getInt(4));
+		assertEquals(5, seq.getInt(6));
+		assertEquals(num, seq.size());
+
+		seq.set(5, tvShort);
+		assertEquals(tvShort, seq.getShort(5));
+		assertEquals(3, seq.getInt(4));
+		assertEquals(5, seq.getInt(6));
+		assertEquals(num, seq.size());
+
+		seq.set(5, tvInt);
+		assertEquals(tvInt, seq.getInt(5));
+		assertEquals(3, seq.getInt(4));
+		assertEquals(5, seq.getInt(6));
+		assertEquals(num, seq.size());
+
+		seq.set(5, tvLong);
+		assertEquals(tvLong, seq.getLong(5));
+		assertEquals(3, seq.getInt(4));
+		assertEquals(5, seq.getInt(6));
+		assertEquals(num, seq.size());
+
+		seq.set(5, tvString);
+		assertEquals(tvString, seq.getString(5));
+		assertEquals(3, seq.getInt(4));
+		assertEquals(5, seq.getInt(6));
+		assertEquals(num, seq.size());
+
+		seq.set(5, tvBoolean);
+		assertEquals(tvBoolean, seq.getBoolean(5));
+		assertEquals(3, seq.getInt(4));
+		assertEquals(5, seq.getInt(6));
+		assertEquals(num, seq.size());
+
+		seq.set(5, tvFloat);
+		assertEquals(tvFloat, seq.getFloat(5), 0.00005);
+		assertEquals(3, seq.getInt(4));
+		assertEquals(5, seq.getInt(6));
+		assertEquals(num, seq.size());
+
+		seq.set(5, tvDouble);
+		assertEquals(tvDouble, seq.getDouble(5), 0.000000005);
+		assertEquals(3, seq.getInt(4));
+		assertEquals(5, seq.getInt(6));
+		assertEquals(num, seq.size());
+
+		seq.set(5, tvLiteral);
+		assertEquals(tvLiteral, seq.getLiteral(5));
+		assertEquals(3, seq.getInt(4));
+		assertEquals(5, seq.getInt(6));
+		assertEquals(num, seq.size());
+
+		seq.set(5, tvResource);
+		assertEquals(tvResource, seq.getResource(5));
+		assertEquals(3, seq.getInt(4));
+		assertEquals(5, seq.getInt(6));
+		assertEquals(num, seq.size());
+
+		seq.set(5, tvLitObj);
+		// assertEquals( tvLitObj, seq.getObject( 5, new LitTestObjF() ) );
+		assertEquals(3, seq.getInt(4));
+		assertEquals(5, seq.getInt(6));
+		assertEquals(num, seq.size());
+
+		// seq.set( 5, tvResObj );
+		// assertEquals( tvResObj, seq.getResource( 5, new ResTestObjF() ) );
+		// assertEquals( 3, seq.getInt( 4 ) );
+		// assertEquals( 5, seq.getInt( 6 ) );
+		// assertEquals( num, seq.size() );
+	}
+
+}

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

Added: jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/rdf/model/AbstractStatementTest.java
URL: http://svn.apache.org/viewvc/jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/rdf/model/AbstractStatementTest.java?rev=1523135&view=auto
==============================================================================
--- jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/rdf/model/AbstractStatementTest.java (added)
+++ jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/rdf/model/AbstractStatementTest.java Fri Sep 13 22:32:05 2013
@@ -0,0 +1,160 @@
+/*
+ * 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.rdf.model;
+
+import com.hp.hpl.jena.graph.FrontsTriple;
+import com.hp.hpl.jena.rdf.model.Model;
+import com.hp.hpl.jena.rdf.model.Property;
+import com.hp.hpl.jena.rdf.model.RDFNode;
+import com.hp.hpl.jena.rdf.model.Resource;
+import com.hp.hpl.jena.rdf.model.Statement;
+import com.hp.hpl.jena.testing_framework.AbstractModelProducerUser;
+import com.hp.hpl.jena.testing_framework.ModelProducerInterface;
+
+import static com.hp.hpl.jena.testing_framework.ModelHelper.*;
+import com.hp.hpl.jena.vocabulary.RDF;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public abstract class AbstractStatementTest extends AbstractModelProducerUser {
+	
+	@Test
+	public void testHasWellFormedXML()
+	{
+		Assert.assertFalse(statement("s P 1").hasWellFormedXML());
+		Assert.assertFalse(statement("S P '<x>/x>'rdf:XMLLiteral")
+				.hasWellFormedXML());
+		Assert.assertTrue(statement("S P '<x></x>'rdf:XMLLiteral")
+				.hasWellFormedXML());
+	}
+
+	@Test
+	public void testOtherStuff()
+	{
+		final Model A = getModelProducer().newModel();
+		final Model B = getModelProducer().newModel();
+		final Resource S = A.createResource("jena:S");
+		final Resource R = A.createResource("jena:R");
+		final Property P = A.createProperty("jena:P");
+		final RDFNode O = A.createResource("jena:O");
+		A.add(S, P, O);
+		B.add(S, P, O);
+		Assert.assertTrue("X1", A.isIsomorphicWith(B));
+		/* */
+		A.add(R, RDF.subject, S);
+		B.add(R, RDF.predicate, P);
+		Assert.assertFalse("X2", A.isIsomorphicWith(B));
+		/* */
+		A.add(R, RDF.predicate, P);
+		B.add(R, RDF.subject, S);
+		Assert.assertTrue("X3", A.isIsomorphicWith(B));
+		/* */
+		A.add(R, RDF.object, O);
+		B.add(R, RDF.type, RDF.Statement);
+		Assert.assertFalse("X4", A.isIsomorphicWith(B));
+		/* */
+		A.add(R, RDF.type, RDF.Statement);
+		B.add(R, RDF.object, O);
+		Assert.assertTrue("X5", A.isIsomorphicWith(B));
+	}
+
+	@Test
+	public void testPortingBlankNodes()
+	{
+		final Model B = getModelProducer().newModel();
+		final Resource anon = resource(); //model.createResource();
+		final Resource bAnon = anon.inModel(B);
+		Assert.assertTrue("moved resource should still be blank",
+				bAnon.isAnon());
+		Assert.assertEquals("move resource should equal original", anon, bAnon);
+	}
+
+	@Test
+	public void testSet()
+	{
+		final Model A = getModelProducer().newModel();
+		final Resource S = A.createResource("jena:S");
+		A.createResource("jena:R");
+		final Property P = A.createProperty("jena:P");
+		final RDFNode O = A.createResource("jena:O");
+		final Statement spo = A.createStatement(S, P, O);
+		A.add(spo);
+		final Statement sps = A.createStatement(S, P, S);
+		Assert.assertEquals(sps, spo.changeObject(S));
+		Assert.assertFalse(A.contains(spo));
+		Assert.assertTrue(A.contains(sps));
+	}
+
+	/**
+	 * Feeble test that toString'ing a Statement[Impl] will display the
+	 * data-type
+	 * of its object if it has one.
+	 */
+	@Test
+	public void testStatementPrintsType()
+	{
+		final String fakeURI = "fake:URI";
+		final Resource S = resource();
+		final Property P = property( "PP");
+		Model model = getModelProducer().newModel();
+		final RDFNode O = model.createTypedLiteral("42", fakeURI);
+		final Statement st = model.createStatement(S, P, O);
+		Assert.assertTrue(st.toString().indexOf(fakeURI) > 0);
+	}
+
+	@Test
+	public void testStatmentMap1Selectors()
+	{
+		Statement s = statement(getModelProducer().newModel(), "sub pred obj");
+		Assert.assertEquals(resource("sub"),
+				Statement.Util.getSubject.map1(s));
+		Assert.assertEquals(resource("pred"),
+				Statement.Util.getPredicate.map1(s));
+		Assert.assertEquals(resource("obj"),
+				Statement.Util.getObject.map1(s));
+	}
+
+	/**
+	 * A resource created in one
+	 * model and incorporated into a statement asserted constructed by a
+	 * different model should test equal to the resource extracted from that
+	 * statement, even if it's a bnode.
+	 */
+	@Test
+	public void testStuff()
+	{
+		final Model red = getModelProducer().newModel();
+		final Model blue = getModelProducer().newModel();
+		final Resource r = red.createResource();
+		final Property p = red.createProperty("");
+		final Statement s = blue.createStatement(r, p, r);
+		Assert.assertEquals("subject preserved", r, s.getSubject());
+		Assert.assertEquals("object preserved", r, s.getObject());
+	}
+
+	@Test
+	public void testTripleWrapper()
+	{
+		assertInstanceOf(FrontsTriple.class,
+				statement(getModelProducer().newModel(), "s p o"));
+	}
+
+	
+}

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

Added: jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/rdf/model/AnonIDTest.java
URL: http://svn.apache.org/viewvc/jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/rdf/model/AnonIDTest.java?rev=1523135&view=auto
==============================================================================
--- jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/rdf/model/AnonIDTest.java (added)
+++ jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/rdf/model/AnonIDTest.java Fri Sep 13 22:32:05 2013
@@ -0,0 +1,87 @@
+/*
+ * 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.rdf.model;
+
+import static com.hp.hpl.jena.testing_framework.ModelHelper.*;
+import com.hp.hpl.jena.rdf.model.AnonId;
+import com.hp.hpl.jena.shared.impl.JenaParameters;
+
+import static org.junit.Assert.*;
+import org.junit.Test;
+
+
+/**
+ * Test for anonID generation. (Originally test for the debugging hack
+ * that switches off anonID generation.)
+ */
+public class AnonIDTest 
+{
+
+	/**
+	 * Check that anonIDs are distinct whichever state the flag is in.
+	 */
+	@Test
+	public void doTestAnonID()
+	{
+		final AnonId id1 = AnonId.create();
+		final AnonId id2 = AnonId.create();
+		final AnonId id3 = AnonId.create();
+		final AnonId id4 = AnonId.create();
+
+		assertDiffer(id1, id2);
+		assertDiffer(id1, id3);
+		assertDiffer(id1, id4);
+		assertDiffer(id2, id3);
+		assertDiffer(id2, id4);
+	}
+
+	/**
+	 * Check that anonIDs are distinct whichever state the flag is in.
+	 */
+	@Test
+	public void testAnonID()
+	{
+		final boolean prior = JenaParameters.disableBNodeUIDGeneration;
+		try
+		{
+			JenaParameters.disableBNodeUIDGeneration = false;
+			doTestAnonID();
+			JenaParameters.disableBNodeUIDGeneration = true;
+			doTestAnonID();
+		}
+		finally
+		{
+			JenaParameters.disableBNodeUIDGeneration = prior;
+		}
+	}
+
+	/**
+	 * Test that creation of an AnonId from an AnonId string preserves that
+	 * string and is equal to the original AnonId.
+	 */
+	@Test
+	public void testAnonIdPreserved()
+	{
+		final AnonId anon = AnonId.create();
+		final String id = anon.toString();
+		assertEquals(anon, AnonId.create(id));
+		assertEquals(id, AnonId.create(id).toString());
+	}
+
+}

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

Added: jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/rdf/model/DefaultModelTest.java
URL: http://svn.apache.org/viewvc/jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/rdf/model/DefaultModelTest.java?rev=1523135&view=auto
==============================================================================
--- jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/rdf/model/DefaultModelTest.java (added)
+++ jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/rdf/model/DefaultModelTest.java Fri Sep 13 22:32:05 2013
@@ -0,0 +1,44 @@
+/*
+ * 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.rdf.model;
+
+
+import com.hp.hpl.jena.testing_framework.AbstractModelProducer;
+import com.hp.hpl.jena.testing_framework.ModelProducerInterface;
+
+
+public class DefaultModelTest extends AbstractModelTest
+    {
+
+    ModelProducerInterface producer = new AbstractModelProducer(){
+
+		@Override
+		protected Model createNewModel() {
+			return ModelFactory.createDefaultModel();
+		}
+
+		};
+
+
+	@Override
+	public ModelProducerInterface getModelProducer() {
+		return producer;
+	}   
+
+    }

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

Added: jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/rdf/model/ModelFactoryTest.java
URL: http://svn.apache.org/viewvc/jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/rdf/model/ModelFactoryTest.java?rev=1523135&view=auto
==============================================================================
--- jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/rdf/model/ModelFactoryTest.java (added)
+++ jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/rdf/model/ModelFactoryTest.java Fri Sep 13 22:32:05 2013
@@ -0,0 +1,132 @@
+/*
+ * 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.rdf.model;
+
+import static com.hp.hpl.jena.testing_framework.ModelHelper.*;
+
+import com.hp.hpl.jena.graph.compose.Union;
+import com.hp.hpl.jena.rdf.model.InfModel;
+import com.hp.hpl.jena.rdf.model.Model;
+import com.hp.hpl.jena.rdf.model.ModelFactory;
+import com.hp.hpl.jena.rdf.model.impl.ModelCom;
+import com.hp.hpl.jena.reasoner.InfGraph;
+import com.hp.hpl.jena.reasoner.Reasoner;
+import com.hp.hpl.jena.reasoner.rulesys.GenericRuleReasoner;
+import com.hp.hpl.jena.reasoner.rulesys.Rule;
+import com.hp.hpl.jena.shared.PrefixMapping;
+import com.hp.hpl.jena.test.JenaTestBase;
+import com.hp.hpl.jena.testing_framework.AbstractModelProducerUser;
+import com.hp.hpl.jena.testing_framework.ModelProducerInterface;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+/**
+ * Tests the ModelFactory code. Very skeletal at the moment. It's really
+ * testing that the methods actually exists, but it doesn't check much in
+ * the way of behaviour.
+ * 
+ */
+
+public class ModelFactoryTest 
+{
+
+	@Test
+	public void testAssembleModelFromModel()
+	{
+		// TODO Assert.assertNotNull( ModelFactory.assembleModelFrom( ModelFactory.createDefaultModel()) );
+	}
+
+	@Test
+	public void testAssmbleModelFromRoot()
+	{
+		// TODO Model assembleModelFrom( Resource root )
+	}
+
+	/**
+	 * Test that ModelFactory.createDefaultModel() exists. [Should check that
+	 * the Model
+	 * is truly a "default" model.]
+	 */
+	@Test
+	public void testCreateDefaultModel()
+	{
+		Model m = ModelFactory.createDefaultModel();
+		try {
+			Assert.assertNotNull(m);
+		}
+		finally {
+			if (m != null)
+			{
+				m.close();
+			}
+		}
+	}
+
+	@Test
+	public void testCreateInfModel()
+	{
+		Model model = ModelFactory.createDefaultModel();
+		final String rule = "-> (eg:r eg:p eg:v).";
+		final Reasoner r = new GenericRuleReasoner(Rule.parseRules(rule));
+		final InfGraph ig = r
+				.bind(model.getGraph());
+		final InfModel im = ModelFactory.createInfModel(ig);
+		JenaTestBase.assertInstanceOf(InfModel.class, im);
+		Assert.assertEquals(1, im.size());
+	}
+
+	/**
+	 * test that a union model is a model over the union of the two underlying
+	 * graphs. (We don't check that Union works - that's done in the Union
+	 * tests, we hope.)
+	 */
+	public void testCreateUnion()
+	{
+		final Model m1 = ModelFactory.createDefaultModel();
+		final Model m2 = ModelFactory.createDefaultModel();
+		final Model m = ModelFactory.createUnion(m1, m2);
+		JenaTestBase.assertInstanceOf(Union.class, m.getGraph());
+		Assert.assertSame(m1.getGraph(), ((Union) m.getGraph()).getL());
+		Assert.assertSame(m2.getGraph(), ((Union) m.getGraph()).getR());
+	}
+
+	public void testFindAssemblerRoots()
+	{
+		// TODO Set ModelFactory.findAssemblerRoots( Model model )
+	}
+
+	public void testGetDefaultPrefixMapping()
+	{
+		Assert.assertSame(ModelCom.getDefaultModelPrefixes(),
+				ModelFactory.getDefaultModelPrefixes());
+	}
+
+	public void testSetDefaultPrefixMapping()
+	{
+		final PrefixMapping original = ModelCom.getDefaultModelPrefixes();
+		final PrefixMapping pm = PrefixMapping.Factory.create();
+		ModelFactory.setDefaultModelPrefixes(pm);
+		Assert.assertSame(pm, ModelCom.getDefaultModelPrefixes());
+		Assert.assertSame(pm, ModelFactory.getDefaultModelPrefixes());
+		ModelCom.setDefaultModelPrefixes(original);
+	}
+
+	
+}

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

Added: jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/rdf/model/ModelTestBase.java
URL: http://svn.apache.org/viewvc/jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/rdf/model/ModelTestBase.java?rev=1523135&view=auto
==============================================================================
--- jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/rdf/model/ModelTestBase.java (added)
+++ jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/rdf/model/ModelTestBase.java Fri Sep 13 22:32:05 2013
@@ -0,0 +1,278 @@
+///*
+// * 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.rdf.model;
+//
+//import com.hp.hpl.jena.graph.Node;
+//import com.hp.hpl.jena.graph.test.GraphTestBase;
+//import com.hp.hpl.jena.graph.test.NodeCreateUtils;
+//import com.hp.hpl.jena.rdf.model.Literal;
+//import com.hp.hpl.jena.rdf.model.Model;
+//import com.hp.hpl.jena.rdf.model.ModelFactory;
+//import com.hp.hpl.jena.rdf.model.Property;
+//import com.hp.hpl.jena.rdf.model.RDFNode;
+//import com.hp.hpl.jena.rdf.model.Resource;
+//import com.hp.hpl.jena.rdf.model.ResourceFactory;
+//import com.hp.hpl.jena.rdf.model.Statement;
+//import com.hp.hpl.jena.shared.PrefixMapping;
+//import com.hp.hpl.jena.util.CollectionFactory;
+//
+//import java.util.ArrayList;
+//import java.util.HashSet;
+//import java.util.Map;
+//import java.util.Set;
+//import java.util.StringTokenizer;
+//
+//import org.junit.Assert;
+//
+///**
+// * provides useful functionality for testing models, eg building small models
+// * from strings, testing equality, etc.
+// */
+//
+//public class ModelTestBase extends GraphTestBase
+//{
+//	protected static Model aModel = ModelTestBase.extendedModel();
+//
+//	protected static final Model empty = ModelFactory.createDefaultModel();
+//
+//	/**
+//	 * Fail if the two models are not isomorphic. See
+//	 * assertIsoModels(String,Model,Model).
+//	 */
+//	public static void assertIsoModels( final Model wanted, final Model got )
+//	{
+//		ModelTestBase.assertIsoModels("models must be isomorphic", wanted, got);
+//	}
+//
+//	/**
+//	 * test that two models are isomorphic and fail if they are not.
+//	 * 
+//	 * @param title
+//	 *            a String appearing at the beginning of the failure message
+//	 * @param wanted
+//	 *            the model value that is expected
+//	 * @param got
+//	 *            the model value to check
+//	 * @exception if
+//	 *                the models are not isomorphic
+//	 */
+//	public static void assertIsoModels( final String title, final Model wanted,
+//			final Model got )
+//	{
+//		if (wanted.isIsomorphicWith(got) == false)
+//		{
+//			final Map<Node, Object> map = CollectionFactory.createHashedMap();
+//			Assert.fail(title + ": expected "
+//					+ GraphTestBase.nice(wanted.getGraph(), map)
+//					+ "\n but had " + GraphTestBase.nice(got.getGraph(), map));
+//		}
+//	}
+//
+//	/**
+//	 * Answer a default model; it exists merely to abbreviate the rather long
+//	 * explicit
+//	 * invocation.
+//	 * 
+//	 * @return a new default [aka memory-based] model
+//	 */
+//	public static Model createMemModel()
+//	{
+//		return ModelFactory.createDefaultModel();
+//	}
+//
+//	/**
+//	 * make a model, give it Extended prefixes
+//	 */
+//	public static Model createModel()
+//	{
+//		final Model result = ModelFactory.createDefaultModel();
+//		result.setNsPrefixes(PrefixMapping.Extended);
+//		return result;
+//	}
+//
+//	protected static Model extendedModel()
+//	{
+//		final Model result = ModelFactory.createDefaultModel();
+//		result.setNsPrefixes(PrefixMapping.Extended);
+//		return result;
+//	}
+//
+//	public static Literal literal( final Model m, final String s )
+//	{
+//		return ModelTestBase.rdfNode(m, s).as(Literal.class);
+//	}
+//
+//	/**
+//	 * add to a model all the statements expressed by a string.
+//	 * 
+//	 * @param m
+//	 *            the model to be updated
+//	 * @param facts
+//	 *            a sequence of semicolon-separated "S P O" facts
+//	 * @return the updated model
+//	 */
+//	public static Model modelAdd( final Model m, final String facts )
+//	{
+//		final StringTokenizer semis = new StringTokenizer(facts, ";");
+//		while (semis.hasMoreTokens())
+//		{
+//			m.add(ModelTestBase.statement(m, semis.nextToken()));
+//		}
+//		return m;
+//	}
+//
+//	/**
+//	 * makes a model initialised with statements parsed from a string.
+//	 * 
+//	 * @param facts
+//	 *            a string in semicolon-separated "S P O" format
+//	 * @return a model containing those facts
+//	 */
+//	public static Model modelWithStatements( final String facts )
+//	{
+//		return ModelTestBase.modelAdd(ModelTestBase.createModel(), facts);
+//	}
+//
+//	protected static String nice( final RDFNode n )
+//	{
+//		return GraphTestBase.nice(n.asNode());
+//	}
+//
+//	public static Property property( final Model m, final String s )
+//	{
+//		return ModelTestBase.rdfNode(m, s).as(Property.class);
+//	}
+//
+//	public static Property property( final String s )
+//	{
+//		return ModelTestBase.property(ModelTestBase.aModel, s);
+//	}
+//
+//	public static RDFNode rdfNode( final Model m, final String s )
+//	{
+//		return m.asRDFNode(NodeCreateUtils.create(m, s));
+//	}
+//
+//	public static <T extends RDFNode> T rdfNode( final Model m, final String s,
+//			final Class<T> c )
+//	{
+//		return ModelTestBase.rdfNode(m, s).as(c);
+//	}
+//
+//	protected static Resource resource()
+//	{
+//		return ResourceFactory.createResource();
+//	}
+//
+//	public static Resource resource( final Model m, final String s )
+//	{
+//		return (Resource) ModelTestBase.rdfNode(m, s);
+//	}
+//
+//	public static Resource resource( final String s )
+//	{
+//		return ModelTestBase.resource(ModelTestBase.aModel, s);
+//	}
+//
+//	/**
+//	 * Create an array of Resources from a whitespace-separated string
+//	 * 
+//	 * @param m
+//	 *            a model to serve as a resource factory
+//	 * @param items
+//	 *            a whitespace-separated sequence to feed to resource
+//	 * @return a RDFNode[] of the parsed resources
+//	 */
+//	public static Resource[] resources( final Model m, final String items )
+//	{
+//		final ArrayList<Resource> rl = new ArrayList<Resource>();
+//		final StringTokenizer st = new StringTokenizer(items);
+//		while (st.hasMoreTokens())
+//		{
+//			rl.add(ModelTestBase.resource(m, st.nextToken()));
+//		}
+//		return rl.toArray(new Resource[rl.size()]);
+//	}
+//
+//	/**
+//	 * Answer the set of resources given by the space-separated
+//	 * <code>items</code> string. Each resource specification is interpreted
+//	 * as per <code>resource</code>.
+//	 */
+//	public static Set<Resource> resourceSet( final String items )
+//	{
+//		final Set<Resource> result = new HashSet<Resource>();
+//		final StringTokenizer st = new StringTokenizer(items);
+//		while (st.hasMoreTokens())
+//		{
+//			result.add(ModelTestBase.resource(st.nextToken()));
+//		}
+//		return result;
+//	}
+//
+//	/**
+//	 * create a Statement in a given Model with (S, P, O) extracted by parsing a
+//	 * string.
+//	 * 
+//	 * @param m
+//	 *            the model the statement is attached to
+//	 * @param an
+//	 *            "S P O" string.
+//	 * @return m.createStatement(S, P, O)
+//	 */
+//	public static Statement statement( final Model m, final String fact )
+//	{
+//		final StringTokenizer st = new StringTokenizer(fact);
+//		final Resource sub = ModelTestBase.resource(m, st.nextToken());
+//		final Property pred = ModelTestBase.property(m, st.nextToken());
+//		final RDFNode obj = ModelTestBase.rdfNode(m, st.nextToken());
+//		return m.createStatement(sub, pred, obj);
+//	}
+//
+//	public static Statement statement( final String fact )
+//	{
+//		return ModelTestBase.statement(ModelTestBase.aModel, fact);
+//	}
+//
+//	/**
+//	 * Create an array of Statements parsed from a semi-separated string.
+//	 * 
+//	 * @param m
+//	 *            a model to serve as a statement factory
+//	 * @param facts
+//	 *            a sequence of semicolon-separated "S P O" facts
+//	 * @return a Statement[] of the (S P O) statements from the string
+//	 */
+//	public static Statement[] statements( final Model m, final String facts )
+//	{
+//		final ArrayList<Statement> sl = new ArrayList<Statement>();
+//		final StringTokenizer st = new StringTokenizer(facts, ";");
+//		while (st.hasMoreTokens())
+//		{
+//			sl.add(ModelTestBase.statement(m, st.nextToken()));
+//		}
+//		return sl.toArray(new Statement[sl.size()]);
+//	}
+//
+//	public ModelTestBase( final String name )
+//	{
+//		super(name);
+//	}
+//
+//}

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

Added: jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/rdf/model/RDFWriterFTest.java
URL: http://svn.apache.org/viewvc/jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/rdf/model/RDFWriterFTest.java?rev=1523135&view=auto
==============================================================================
--- jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/rdf/model/RDFWriterFTest.java (added)
+++ jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/rdf/model/RDFWriterFTest.java Fri Sep 13 22:32:05 2013
@@ -0,0 +1,219 @@
+/*
+ * 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.rdf.model;
+
+import com.hp.hpl.jena.Jena;
+import com.hp.hpl.jena.n3.N3JenaWriter;
+import com.hp.hpl.jena.n3.N3JenaWriterPP;
+import com.hp.hpl.jena.n3.N3JenaWriterPlain;
+import com.hp.hpl.jena.n3.N3JenaWriterTriples;
+import com.hp.hpl.jena.n3.N3TurtleJenaWriter;
+import com.hp.hpl.jena.rdf.model.RDFWriter;
+import com.hp.hpl.jena.rdf.model.RDFWriterF;
+import com.hp.hpl.jena.rdf.model.impl.NTripleWriter;
+import com.hp.hpl.jena.shared.JenaException;
+import com.hp.hpl.jena.shared.NoWriterForLangException;
+import com.hp.hpl.jena.xmloutput.impl.Abbreviated;
+import com.hp.hpl.jena.xmloutput.impl.Basic;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class RDFWriterFTest 
+{
+	public static class RDFWriterMap implements RDFWriterF
+	{
+		protected final Map<String, Class<RDFWriter>> map = new HashMap<String, Class<RDFWriter>>();
+
+		public RDFWriterMap( final boolean preloadDefaults )
+		{
+			if (preloadDefaults)
+			{
+				loadDefaults();
+			}
+		}
+
+		@Override
+		public RDFWriter getWriter()
+		{
+			return getWriter("RDF/XML");
+		}
+
+		@Override
+		public RDFWriter getWriter( final String lang )
+		{
+			final Class<RDFWriter> result = map.get(lang);
+			if (result == null)
+			{
+				throw new NoWriterForLangException(lang);
+			}
+			try
+			{
+				return result.newInstance();
+			}
+			catch (final Exception e)
+			{
+				throw new JenaException(e);
+			}
+		}
+
+		private void loadDefaults()
+		{
+			setWriterClassName(RDFWriterFTest.TURTLE_WRITER, Jena.PATH
+					+ ".n3.N3TurtleJenaWriter");
+			setWriterClassName(RDFWriterFTest.TURTLE_WRITER_ALT1, Jena.PATH
+					+ ".n3.N3TurtleJenaWriter");
+			setWriterClassName(RDFWriterFTest.TURTLE_WRITER_ALT2, Jena.PATH
+					+ ".n3.N3TurtleJenaWriter");
+			setWriterClassName(RDFWriterFTest.RDF_XML, Jena.PATH
+					+ ".xmloutput.impl.Basic");
+			setWriterClassName(RDFWriterFTest.RDF_XML_ABBREV, Jena.PATH
+					+ ".xmloutput.impl.Abbreviated");
+			setWriterClassName(RDFWriterFTest.N3, Jena.PATH
+					+ ".n3.N3JenaWriter");
+			setWriterClassName(RDFWriterFTest.N3_PLAIN, Jena.PATH
+					+ ".n3.N3JenaWriterPlain");
+			setWriterClassName(RDFWriterFTest.N3_PP, Jena.PATH
+					+ ".n3.N3JenaWriterPP");
+			setWriterClassName(RDFWriterFTest.N3_TRIPLE, Jena.PATH
+					+ ".n3.N3JenaWriterTriples");
+			setWriterClassName(RDFWriterFTest.N3_TRIPLES, Jena.PATH
+					+ ".n3.N3JenaWriterTriples");
+			setWriterClassName(RDFWriterFTest.NTRIPLE, Jena.PATH
+					+ ".rdf.model.impl.NTripleWriter");
+			setWriterClassName(RDFWriterFTest.NTRIPLES, Jena.PATH
+					+ ".rdf.model.impl.NTripleWriter");
+		}
+
+		@Override
+		public String setWriterClassName( final String lang,
+				final String className )
+		{
+			try
+			{
+				final Class<RDFWriter> old = map.get(lang);
+				final Class<?> c = Class.forName(className);
+				if (RDFWriter.class.isAssignableFrom(c))
+				{
+					@SuppressWarnings( "unchecked" )
+					final Class<RDFWriter> x = (Class<RDFWriter>) c;
+					map.put(lang, x);
+				}
+				return old == null ? null : old.getName();
+			}
+			catch (final ClassNotFoundException e)
+			{
+				throw new JenaException(e);
+			}
+		}
+	}
+
+	public static final String TURTLE_WRITER_ALT2 = N3JenaWriter.turtleWriterAlt2;
+	public static final String TURTLE_WRITER_ALT1 = N3JenaWriter.turtleWriterAlt1;
+
+	public static final String TURTLE_WRITER = N3JenaWriter.turtleWriter;
+	public static final String RDF_XML = "RDF/XML";
+	public static final String RDF_XML_ABBREV = "RDF/XML-ABBREV";
+	public static final String NTRIPLE = "N-TRIPLE";
+	public static final String NTRIPLES = "N-TRIPLES";
+	public static final String N3 = "N3";
+	public static final String N3_PLAIN = "N3-PLAIN";
+	public static final String N3_PP = "N3-PP";
+	public static final String N3_TRIPLE = "N3-TRIPLE";
+
+	public static final String N3_TRIPLES = "N3-TRIPLES";
+
+	@Test
+	public void testDefaultWriter()
+	{
+		final RDFWriterF x = new RDFWriterMap(true);
+		Assert.assertEquals(x.getWriter("RDF/XML").getClass(), x.getWriter()
+				.getClass());
+	}
+
+	/*
+	 * public void testMe()
+	 * {
+	 * Assert.fail("SPOO");
+	 * }
+	 */
+
+	private void testWriterAbsent( final String w )
+	{
+		final RDFWriterF x = new RDFWriterMap(false);
+		try
+		{
+			x.getWriter(w);
+		}
+		catch (final NoWriterForLangException e)
+		{
+			Assert.assertEquals(w, e.getMessage());
+		}
+	}
+
+	@Test
+	public void testWritersAbsent()
+	{
+		testWriterAbsent(RDFWriterFTest.TURTLE_WRITER);
+		testWriterAbsent(RDFWriterFTest.TURTLE_WRITER_ALT1);
+		testWriterAbsent(RDFWriterFTest.TURTLE_WRITER_ALT2);
+		testWriterAbsent(RDFWriterFTest.RDF_XML);
+		testWriterAbsent(RDFWriterFTest.RDF_XML_ABBREV);
+		testWriterAbsent(RDFWriterFTest.NTRIPLE);
+		testWriterAbsent(RDFWriterFTest.NTRIPLES);
+		testWriterAbsent(RDFWriterFTest.N3);
+		testWriterAbsent(RDFWriterFTest.N3_PP);
+		testWriterAbsent(RDFWriterFTest.N3_PLAIN);
+		testWriterAbsent(RDFWriterFTest.N3_TRIPLE);
+		testWriterAbsent(RDFWriterFTest.N3_TRIPLES);
+	}
+
+	@Test
+	public void testWritersPresent()
+	{
+		final RDFWriterF x = new RDFWriterMap(true);
+		Assert.assertEquals(N3TurtleJenaWriter.class,
+				x.getWriter(RDFWriterFTest.TURTLE_WRITER).getClass());
+		Assert.assertEquals(N3TurtleJenaWriter.class,
+				x.getWriter(RDFWriterFTest.TURTLE_WRITER_ALT1).getClass());
+		Assert.assertEquals(N3TurtleJenaWriter.class,
+				x.getWriter(RDFWriterFTest.TURTLE_WRITER_ALT2).getClass());
+		Assert.assertEquals(Basic.class, x.getWriter(RDFWriterFTest.RDF_XML)
+				.getClass());
+		Assert.assertEquals(Abbreviated.class,
+				x.getWriter(RDFWriterFTest.RDF_XML_ABBREV).getClass());
+		Assert.assertEquals(NTripleWriter.class,
+				x.getWriter(RDFWriterFTest.NTRIPLE).getClass());
+		Assert.assertEquals(NTripleWriter.class,
+				x.getWriter(RDFWriterFTest.NTRIPLES).getClass());
+		Assert.assertEquals(N3JenaWriter.class, x
+				.getWriter(RDFWriterFTest.N3).getClass());
+		Assert.assertEquals(N3JenaWriterPP.class,
+				x.getWriter(RDFWriterFTest.N3_PP).getClass());
+		Assert.assertEquals(N3JenaWriterPlain.class,
+				x.getWriter(RDFWriterFTest.N3_PLAIN).getClass());
+		Assert.assertEquals(N3JenaWriterTriples.class,
+				x.getWriter(RDFWriterFTest.N3_TRIPLE).getClass());
+		Assert.assertEquals(N3JenaWriterTriples.class,
+				x.getWriter(RDFWriterFTest.N3_TRIPLES).getClass());
+	}
+}

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

Added: jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/rdf/model/RecordingModelListener.java
URL: http://svn.apache.org/viewvc/jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/rdf/model/RecordingModelListener.java?rev=1523135&view=auto
==============================================================================
--- jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/rdf/model/RecordingModelListener.java (added)
+++ jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/rdf/model/RecordingModelListener.java Fri Sep 13 22:32:05 2013
@@ -0,0 +1,176 @@
+/*
+ * 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.rdf.model;
+
+import static com.hp.hpl.jena.testing_framework.ModelHelper.*;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+
+import org.junit.Assert;
+
+import com.hp.hpl.jena.rdf.model.Model;
+import com.hp.hpl.jena.rdf.model.ModelChangedListener;
+import com.hp.hpl.jena.rdf.model.Statement;
+import com.hp.hpl.jena.rdf.model.StmtIterator;
+
+/**
+ * This testing listener records the event names and data, and provides a method
+ * for comparing the actual with the expected history.
+ */
+public class RecordingModelListener implements ModelChangedListener
+    {
+	
+	@SuppressWarnings("unchecked")
+    public static boolean checkEquality( final Object o1, final Object o2)
+	{
+		if (o1 == o2)
+		{
+			return true;
+		}
+		if (o1.getClass().isArray() && o2.getClass().isArray())
+		{
+			final Object[] o1a = (Object[])o1;
+			final Object[] o2a = (Object[])o2;
+
+			if (o1a.length == o2a.length)
+			{
+				for (int i=0;i<o1a.length;i++)
+				{
+					if (!checkEquality( o1a[i], o2a[i]))
+					{
+						return false;
+					}
+				}
+				return true;
+			}
+			return false;
+		}
+		else if ( (o1 instanceof Collection<?>) && (o2 instanceof Collection<?>) )
+		{
+			return checkEquality( ((Collection<Object>)o1).toArray(), ((Collection<Object>)o2).toArray() );
+
+		}
+		else if ((o1 instanceof Model) && (o2 instanceof Model))
+		{
+			return checkEquality( ((Model)o1).listStatements().toList(), ((Model)o2).listStatements().toList());
+
+		}
+		else if ((o1 instanceof Statement) && (o2 instanceof Statement))
+		{
+			return checkEquality( ((Statement)o1).asTriple(), ((Statement)o2).asTriple());
+
+		}
+		else
+		{
+			return o1.equals(o2);
+		}
+	}
+
+    List<Object> history = new ArrayList<Object>();
+    
+    @Override
+    public void addedStatement( Statement s )
+        { record( "add", s ); }
+        
+    @Override
+    public void addedStatements( Statement [] statements )
+        { record( "add[]", Arrays.asList( statements ) ); }
+        
+    @Override
+    public void addedStatements( List<Statement> statements )
+        { record( "addList", statements ); }
+        
+    @Override
+    public void addedStatements( StmtIterator statements )
+        { record( "addIterator", iteratorToList( statements ) ); }
+        
+    @Override
+    public void addedStatements( Model m )
+        { record( "addModel", m ); }
+        
+    @Override
+    public void removedStatements( Statement [] statements )
+        { record( "remove[]", Arrays.asList( statements ) ); }
+    
+   @Override
+public void removedStatement( Statement s )
+        { record( "remove", s ); }
+        
+    @Override
+    public void removedStatements( List<Statement> statements )
+        { record( "removeList", statements ); }
+        
+    @Override
+    public void removedStatements( StmtIterator statements )
+        { record( "removeIterator", iteratorToList( statements ) ); }
+        
+    @Override
+    public void removedStatements( Model m )
+        { record( "removeModel", m ); }
+    
+    @Override
+    public void notifyEvent( Model m, Object event )
+        { record( "someEvent", m, event ); }
+    
+    protected void record( String tag, Object x, Object y )
+        { history.add( tag ); history.add( x ); history.add( y ); }
+        
+    protected void record( String tag, Object info )
+        { history.add( tag ); history.add( info ); }
+        
+    public boolean has( Object [] things ) 
+        { return history.equals( Arrays.asList( things ) ); }
+        
+    public void assertHas( Object [] things )
+        {
+        if (has( things ) == false)
+            Assert.fail( "expected " + Arrays.asList( things ) + " but got " + history );
+        }    
+    
+    public boolean has( List<?> things )
+            { return history.equals( things ); } 
+        
+    public boolean hasStart( List<Object> L )
+        { return L.size() <= history.size() && L.equals( history.subList( 0, L.size() ) ); }
+    
+    public boolean hasEnd( List<Object> L )
+        { return L.size() <= history.size() && L.equals( history.subList( history.size() - L.size(), history.size() ) ); }
+    
+    public void assertHas( List<?> things )
+        { if (has( things ) == false) Assert.fail( "expected " + things + " but got " + history ); }  
+    
+    public void assertHasStart( Object [] start )
+        { 
+        List<Object> L = Arrays.asList( start );
+        if (hasStart( L ) == false) Assert.fail( "expected " + L + " at the beginning of " + history );
+        }
+    
+    public void assertHasEnd( Object [] end )
+        {
+        List<Object> L = Arrays.asList( end );
+        if (hasEnd( L ) == false) Assert.fail( "expected " + L + " at the end of " + history );        
+        }
+    
+    public void clear()
+    { history.clear(); }
+
+    }

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

Added: jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/rdf/model/ResourceFactoryTest.java
URL: http://svn.apache.org/viewvc/jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/rdf/model/ResourceFactoryTest.java?rev=1523135&view=auto
==============================================================================
--- jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/rdf/model/ResourceFactoryTest.java (added)
+++ jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/rdf/model/ResourceFactoryTest.java Fri Sep 13 22:32:05 2013
@@ -0,0 +1,228 @@
+/*
+ * 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.rdf.model;
+
+import com.hp.hpl.jena.datatypes.RDFDatatype;
+import com.hp.hpl.jena.datatypes.xsd.XSDDatatype;
+import com.hp.hpl.jena.rdf.model.Literal;
+import com.hp.hpl.jena.rdf.model.Property;
+import com.hp.hpl.jena.rdf.model.RDFNode;
+import com.hp.hpl.jena.rdf.model.Resource;
+import com.hp.hpl.jena.rdf.model.ResourceFactory;
+import com.hp.hpl.jena.rdf.model.Statement;
+
+import java.util.Calendar;
+import java.util.GregorianCalendar;
+import java.util.TimeZone;
+
+import org.junit.Assert;
+import junit.framework.TestCase;
+import junit.framework.TestSuite;
+
+public class ResourceFactoryTest extends TestCase
+{
+
+	class TestFactory implements ResourceFactory.Interface
+	{
+
+		Resource resource;
+
+		TestFactory( final Resource r )
+		{
+			resource = r;
+		}
+
+		@Override
+		public Literal createLangLiteral( final String string, final String lang )
+		{
+			return null;
+		}
+
+		@Override
+		public Literal createPlainLiteral( final String string )
+		{
+			return null;
+		}
+
+		@Override
+		public Property createProperty( final String uriref )
+		{
+			return null;
+		}
+
+		@Override
+		public Property createProperty( final String namespace,
+				final String localName )
+		{
+			return null;
+		}
+
+		@Override
+		public Resource createResource()
+		{
+			return resource;
+		}
+
+		@Override
+		public Resource createResource( final String uriref )
+		{
+			return null;
+		}
+
+		@Override
+		public Statement createStatement( final Resource subject,
+				final Property predicate, final RDFNode object )
+		{
+			return null;
+		}
+
+		@Override
+		public Literal createTypedLiteral( final Object value )
+		{
+			return null;
+		}
+
+		@Override
+		public Literal createTypedLiteral( final String string,
+				final RDFDatatype datatype )
+		{
+			return null;
+		}
+
+	}
+
+	static final String uri1 = "http://example.org/example#a1";
+
+	static final String uri2 = "http://example.org/example#a2";
+
+	public static TestSuite suite()
+	{
+		return new TestSuite(ResourceFactoryTest.class);
+	}
+
+	public ResourceFactoryTest( final String name )
+	{
+		super(name);
+	}
+
+	public void testCreateLiteral()
+	{
+		final Literal l = ResourceFactory.createPlainLiteral("lex");
+		Assert.assertTrue(l.getLexicalForm().equals("lex"));
+		Assert.assertTrue(l.getLanguage().equals(""));
+		Assert.assertNull(l.getDatatype());
+		Assert.assertNull(l.getDatatypeURI());
+	}
+
+	public void testCreateProperty()
+	{
+		final Property p1 = ResourceFactory
+				.createProperty(ResourceFactoryTest.uri1);
+		Assert.assertTrue(p1.getURI().equals(ResourceFactoryTest.uri1));
+		final Property p2 = ResourceFactory.createProperty(
+				ResourceFactoryTest.uri1, "2");
+		Assert.assertTrue(p2.getURI().equals(ResourceFactoryTest.uri1 + "2"));
+	}
+
+	public void testCreateResource()
+	{
+		Resource r1 = ResourceFactory.createResource();
+		Assert.assertTrue(r1.isAnon());
+		final Resource r2 = ResourceFactory.createResource();
+		Assert.assertTrue(r2.isAnon());
+		Assert.assertTrue(!r1.equals(r2));
+
+		r1 = ResourceFactory.createResource(ResourceFactoryTest.uri1);
+		Assert.assertTrue(r1.getURI().equals(ResourceFactoryTest.uri1));
+	}
+
+	public void testCreateStatement()
+	{
+		final Resource s = ResourceFactory.createResource();
+		final Property p = ResourceFactory
+				.createProperty(ResourceFactoryTest.uri2);
+		final Resource o = ResourceFactory.createResource();
+		final Statement stmt = ResourceFactory.createStatement(s, p, o);
+		Assert.assertTrue(stmt.getSubject().equals(s));
+		Assert.assertTrue(stmt.getPredicate().equals(p));
+		Assert.assertTrue(stmt.getObject().equals(o));
+	}
+
+	public void testCreateTypedLiteral()
+	{
+		final Literal l = ResourceFactory.createTypedLiteral("22",
+				XSDDatatype.XSDinteger);
+		Assert.assertTrue(l.getLexicalForm().equals("22"));
+		Assert.assertTrue(l.getLanguage().equals(""));
+		Assert.assertTrue(l.getDatatype() == XSDDatatype.XSDinteger);
+		Assert.assertTrue(l.getDatatypeURI().equals(
+				XSDDatatype.XSDinteger.getURI()));
+
+	}
+
+	public void testCreateTypedLiteralObject()
+	{
+		final Literal l = ResourceFactory.createTypedLiteral(new Integer(22));
+		Assert.assertEquals("22", l.getLexicalForm());
+		Assert.assertEquals("", l.getLanguage());
+		Assert.assertEquals(XSDDatatype.XSDint, l.getDatatype());
+	}
+
+	public void testCreateTypedLiteralOverload()
+	{
+		final Calendar testCal = new GregorianCalendar(
+				TimeZone.getTimeZone("GMT"));
+		testCal.set(1999, 4, 30, 15, 9, 32);
+		testCal.set(Calendar.MILLISECOND, 0); // ms field can be undefined on
+		// Linux
+		final Literal lc = ResourceFactory.createTypedLiteral(testCal);
+		Assert.assertEquals("calendar overloading test", ResourceFactory
+				.createTypedLiteral("1999-05-30T15:09:32Z",
+						XSDDatatype.XSDdateTime), lc);
+
+	}
+
+	public void testGetInstance()
+	{
+		ResourceFactory.getInstance();
+		final Resource r1 = ResourceFactory.createResource();
+		Assert.assertTrue(r1.isAnon());
+		final Resource r2 = ResourceFactory.createResource();
+		Assert.assertTrue(r2.isAnon());
+		Assert.assertTrue(!r1.equals(r2));
+	}
+
+	public void testSetInstance()
+	{
+		final Resource r = ResourceFactory.createResource();
+		final ResourceFactory.Interface oldFactory = ResourceFactory
+				.getInstance();
+		final ResourceFactory.Interface factory = new TestFactory(r);
+		try
+		{
+			ResourceFactory.setInstance(factory);
+			Assert.assertTrue(factory.equals(ResourceFactory.getInstance()));
+			Assert.assertTrue(ResourceFactory.createResource() == r);
+		}
+		finally
+		{
+			ResourceFactory.setInstance(oldFactory);
+		}
+	}
+}

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

Added: jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/rdf/model/SimpleSelectorTest.java
URL: http://svn.apache.org/viewvc/jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/rdf/model/SimpleSelectorTest.java?rev=1523135&view=auto
==============================================================================
--- jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/rdf/model/SimpleSelectorTest.java (added)
+++ jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/rdf/model/SimpleSelectorTest.java Fri Sep 13 22:32:05 2013
@@ -0,0 +1,72 @@
+package com.hp.hpl.jena.rdf.model;
+
+import static com.hp.hpl.jena.testing_framework.ModelHelper.*;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class SimpleSelectorTest {
+
+	private Selector check( final Resource S, final Property P, final RDFNode O )
+	{
+		final Selector s = new SimpleSelector(S, P, O);
+		Assert.assertTrue(s.isSimple());
+		Assert.assertEquals(S, s.getSubject());
+		Assert.assertEquals(P, s.getPredicate());
+		Assert.assertEquals(O, s.getObject());
+		return s;
+	}
+
+	@Test
+	public void testSelectors()
+	{
+		Resource A = resource("A");
+		Property B = property("B");
+		Literal ten = literal( "10" );
+		Resource C = resource( "C" );
+		Property D = property("D");
+		Resource E = resource( "_E" );
+		
+		Selector s = check(null, null, null);
+		Assert.assertTrue( s.test( statement( "A, B, C" ) ) );
+		Assert.assertTrue( s.test( statement( "A, D, C" ) ) );
+		Assert.assertTrue( s.test( statement( "A, B, 10" ) ) );
+		Assert.assertTrue( s.test( statement( "C, B, C" ) ) );
+		Assert.assertTrue( s.test( statement( "A, B, _E" ) ) );
+		Assert.assertTrue( s.test( statement( "C, D, _E" ) ) );
+		
+		s = check(resource( "A"), null, null);
+		Assert.assertTrue( s.test( statement( "A, B, C" ) ) );
+		Assert.assertTrue( s.test( statement( "A, D, C" ) ) );
+		Assert.assertTrue( s.test( statement( "A, B, 10" ) ) );
+		Assert.assertFalse( s.test( statement( "C, B, C" ) ) );
+		Assert.assertTrue( s.test( statement( "A, B, _E" ) ) );
+		Assert.assertFalse( s.test( statement( "C, D, _E" ) ) );
+		
+		s = check(null, property( "B"), null);
+		Assert.assertTrue( s.test( statement( "A, B, C" ) ) );
+		Assert.assertFalse( s.test( statement( "A, D, C" ) ) );
+		Assert.assertTrue( s.test( statement( "A, B, 10" ) ) );
+		Assert.assertTrue( s.test( statement( "C, B, C" ) ) );
+		Assert.assertTrue( s.test( statement( "A, B, _E" ) ) );
+		Assert.assertFalse( s.test( statement( "C, D, _E" ) ) );
+		
+		s = check(null, null, literal( "10"));
+		Assert.assertFalse( s.test( statement( "A, B, C" ) ) );
+		Assert.assertFalse( s.test( statement( "A, D, C" ) ) );
+		Assert.assertTrue( s.test( statement( "A, B, 10" ) ) );
+		Assert.assertFalse( s.test( statement( "C, B, C" ) ) );
+		Assert.assertFalse( s.test( statement( "A, B, _E" ) ) );
+		Assert.assertFalse( s.test( statement( "C, D, _E" ) ) );
+
+		s = check(resource( "C"),
+				property( "D"),
+				resource( "_E"));
+		Assert.assertFalse( s.test( statement( "A, B, C" ) ) );
+		Assert.assertFalse( s.test( statement( "A, D, C" ) ) );
+		Assert.assertFalse( s.test( statement( "A, B, 10" ) ) );
+		Assert.assertFalse( s.test( statement( "C, B, C" ) ) );
+		Assert.assertFalse( s.test( statement( "A, B, _E" ) ) );
+		Assert.assertTrue( s.test( statement( "C, D, _E" ) ) );
+	}
+}

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

Added: jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/rdf/model/impl/ModelMakerImplTest.java
URL: http://svn.apache.org/viewvc/jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/rdf/model/impl/ModelMakerImplTest.java?rev=1523135&view=auto
==============================================================================
--- jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/rdf/model/impl/ModelMakerImplTest.java (added)
+++ jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/rdf/model/impl/ModelMakerImplTest.java Fri Sep 13 22:32:05 2013
@@ -0,0 +1,84 @@
+/*
+ * 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.rdf.model.impl;
+
+import static com.hp.hpl.jena.testing_framework.ModelHelper.*;
+
+import com.hp.hpl.jena.graph.Graph;
+import com.hp.hpl.jena.graph.GraphMaker;
+import com.hp.hpl.jena.graph.Node;
+import com.hp.hpl.jena.rdf.model.AbstractModelMakerTest;
+import com.hp.hpl.jena.rdf.model.Model;
+import com.hp.hpl.jena.rdf.model.ModelMaker;
+import com.hp.hpl.jena.rdf.model.impl.ModelMakerImpl;
+import com.hp.hpl.jena.shared.ReificationStyle;
+import com.hp.hpl.jena.util.iterator.ExtendedIterator;
+import com.hp.hpl.jena.util.iterator.NullIterator;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.junit.After;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+
+/**
+ * Test ModelMakerImpl using a mock GraphMaker.
+ */
+@SuppressWarnings("deprecation")
+public class ModelMakerImplTest extends AbstractModelMakerTest
+{
+
+
+	@Override
+	protected ModelMaker getModelMaker() {
+		return maker;
+	}
+
+	@Override
+	protected Graph getModelMakerGraph() {
+		return graph;
+	}
+
+	@Override
+	protected GraphMaker getGraphMaker() {
+		return graphMaker;
+	}
+	
+	private ModelMaker maker;
+	private Graph graph;
+	private GraphMaker graphMaker;
+
+	@Before
+	public void setUpModelMakerImplTest()
+	{
+		graph = graphWith("");
+		graphMaker = new MockGraphMaker(graph);
+		maker = new ModelMakerImpl(graphMaker);
+	}
+
+	@After
+	public void teardownModelMakerImplTest()
+	{
+		maker.close();
+		graph.close();
+	}
+}

Propchange: jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/rdf/model/impl/ModelMakerImplTest.java
------------------------------------------------------------------------------
    svn:mime-type = text/plain

Added: jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/rdf/model/impl/PropertyImplTest.java
URL: http://svn.apache.org/viewvc/jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/rdf/model/impl/PropertyImplTest.java?rev=1523135&view=auto
==============================================================================
--- jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/rdf/model/impl/PropertyImplTest.java (added)
+++ jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/rdf/model/impl/PropertyImplTest.java Fri Sep 13 22:32:05 2013
@@ -0,0 +1,54 @@
+/*
+ * 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.rdf.model.impl;
+
+import static com.hp.hpl.jena.testing_framework.ModelHelper.*;
+
+import com.hp.hpl.jena.graph.Graph;
+import com.hp.hpl.jena.graph.GraphMaker;
+import com.hp.hpl.jena.graph.Node;
+import com.hp.hpl.jena.rdf.model.AbstractPropertyTest;
+import com.hp.hpl.jena.rdf.model.Model;
+import com.hp.hpl.jena.rdf.model.ModelMaker;
+import com.hp.hpl.jena.rdf.model.Property;
+import com.hp.hpl.jena.rdf.model.impl.ModelMakerImpl;
+import com.hp.hpl.jena.shared.ReificationStyle;
+import com.hp.hpl.jena.util.iterator.ExtendedIterator;
+import com.hp.hpl.jena.util.iterator.NullIterator;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+import junit.framework.TestCase;
+
+/**
+ * Test ModelMakerImpl using a mock GraphMaker.
+ */
+public class PropertyImplTest extends AbstractPropertyTest
+{
+
+	@Override
+	protected Property createProperty(String uri) {
+		return new PropertyImpl( uri );
+	}
+}

Propchange: jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/rdf/model/impl/PropertyImplTest.java
------------------------------------------------------------------------------
    svn:mime-type = text/plain

Added: jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/rdf/model/temp/AltMethodsTest.java
URL: http://svn.apache.org/viewvc/jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/rdf/model/temp/AltMethodsTest.java?rev=1523135&view=auto
==============================================================================
--- jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/rdf/model/temp/AltMethodsTest.java (added)
+++ jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/rdf/model/temp/AltMethodsTest.java Fri Sep 13 22:32:05 2013
@@ -0,0 +1,26 @@
+package com.hp.hpl.jena.rdf.model.temp;
+
+import com.hp.hpl.jena.rdf.model.AbstractAltMethodsTest;
+import com.hp.hpl.jena.rdf.model.Model;
+import com.hp.hpl.jena.rdf.model.ModelFactory;
+import com.hp.hpl.jena.testing_framework.AbstractModelProducer;
+import com.hp.hpl.jena.testing_framework.ModelProducerInterface;
+
+public class AltMethodsTest extends AbstractAltMethodsTest {
+
+	AbstractModelProducer producer = new AbstractModelProducer()
+	{
+
+		@Override
+		protected Model createNewModel() {
+			return ModelFactory.createDefaultModel();
+		}
+		
+	};
+	
+	@Override
+	public ModelProducerInterface getModelProducer() {
+		return producer;
+	}
+
+}

Propchange: jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/rdf/model/temp/AltMethodsTest.java
------------------------------------------------------------------------------
    svn:mime-type = text/plain

Added: jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/rdf/model/temp/BagMethodsTest.java
URL: http://svn.apache.org/viewvc/jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/rdf/model/temp/BagMethodsTest.java?rev=1523135&view=auto
==============================================================================
--- jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/rdf/model/temp/BagMethodsTest.java (added)
+++ jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/rdf/model/temp/BagMethodsTest.java Fri Sep 13 22:32:05 2013
@@ -0,0 +1,25 @@
+package com.hp.hpl.jena.rdf.model.temp;
+
+import com.hp.hpl.jena.rdf.model.AbstractBagMethodsTest;
+import com.hp.hpl.jena.rdf.model.Model;
+import com.hp.hpl.jena.rdf.model.ModelFactory;
+import com.hp.hpl.jena.testing_framework.AbstractModelProducer;
+import com.hp.hpl.jena.testing_framework.ModelProducerInterface;
+
+public class BagMethodsTest extends AbstractBagMethodsTest {
+
+	AbstractModelProducer producer = new AbstractModelProducer()
+	{
+
+		@Override
+		protected Model createNewModel() {
+			return ModelFactory.createDefaultModel();
+		}
+		
+	};
+	
+	@Override
+	public ModelProducerInterface getModelProducer() {
+		return producer;
+	}
+}

Propchange: jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/rdf/model/temp/BagMethodsTest.java
------------------------------------------------------------------------------
    svn:mime-type = text/plain

Added: jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/rdf/model/temp/FindPropertiesTest.java
URL: http://svn.apache.org/viewvc/jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/rdf/model/temp/FindPropertiesTest.java?rev=1523135&view=auto
==============================================================================
--- jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/rdf/model/temp/FindPropertiesTest.java (added)
+++ jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/rdf/model/temp/FindPropertiesTest.java Fri Sep 13 22:32:05 2013
@@ -0,0 +1,27 @@
+package com.hp.hpl.jena.rdf.model.temp;
+
+import com.hp.hpl.jena.rdf.model.AbstractFindPropertiesTests;
+import com.hp.hpl.jena.rdf.model.Model;
+import com.hp.hpl.jena.rdf.model.ModelFactory;
+import com.hp.hpl.jena.testing_framework.AbstractModelProducer;
+import com.hp.hpl.jena.testing_framework.ModelProducerInterface;
+
+
+
+public class FindPropertiesTest extends AbstractFindPropertiesTests {
+
+	AbstractModelProducer producer = new AbstractModelProducer()
+	{
+
+		@Override
+		protected Model createNewModel() {
+			return ModelFactory.createDefaultModel();
+		}
+		
+	};
+	
+	@Override
+	public ModelProducerInterface getModelProducer() {
+		return producer;
+	}
+}

Propchange: jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/rdf/model/temp/FindPropertiesTest.java
------------------------------------------------------------------------------
    svn:mime-type = text/plain

Added: jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/rdf/model/temp/IteratorTest.java
URL: http://svn.apache.org/viewvc/jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/rdf/model/temp/IteratorTest.java?rev=1523135&view=auto
==============================================================================
--- jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/rdf/model/temp/IteratorTest.java (added)
+++ jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/rdf/model/temp/IteratorTest.java Fri Sep 13 22:32:05 2013
@@ -0,0 +1,26 @@
+package com.hp.hpl.jena.rdf.model.temp;
+
+import com.hp.hpl.jena.rdf.model.AbstractIteratorTest;
+import com.hp.hpl.jena.rdf.model.AbstractModelTest;
+import com.hp.hpl.jena.rdf.model.Model;
+import com.hp.hpl.jena.rdf.model.ModelFactory;
+import com.hp.hpl.jena.testing_framework.AbstractModelProducer;
+import com.hp.hpl.jena.testing_framework.ModelProducerInterface;
+
+public class IteratorTest extends AbstractIteratorTest {
+
+	AbstractModelProducer producer = new AbstractModelProducer()
+	{
+
+		@Override
+		protected Model createNewModel() {
+			return ModelFactory.createDefaultModel();
+		}
+		
+	};
+	
+	@Override
+	public ModelProducerInterface getModelProducer() {
+		return producer;
+	}
+}

Propchange: jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/rdf/model/temp/IteratorTest.java
------------------------------------------------------------------------------
    svn:mime-type = text/plain