/*
 * 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
// /////////////
package org.apache.jena.rdf.model.test;

// Imports
// /////////////
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;

import org.apache.jena.rdf.model.* ;
import org.apache.jena.rdf.model.test.helpers.TestingModelFactory ;
import org.apache.jena.vocabulary.RDF ;
import org.junit.Assert;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * <p>
 * A collection of unit tests for the standard implementation of {@link RDFList}
 * .
 * </p>
 * 
 * 
 */
public class TestList extends AbstractModelTestBase
{
	// Constants
	// ////////////////////////////////

	public static final String NS = "uri:urn:x-rdf:test#";

	/** Test that an iterator delivers the expected values */
	protected static void iteratorTest( final Iterator<?> i,
			final Object[] expected )
	{
		final Logger logger = LoggerFactory.getLogger(TestList.class);
		final List<Object> expList = new ArrayList<>();
		for (final Object element : expected)
		{
			expList.add(element);
		}

		while (i.hasNext())
		{
			final Object next = i.next();

			// debugging
			if (!expList.contains(next))
			{
				logger.debug("TestList - Unexpected iterator result: " + next);
			}

			Assert.assertTrue("Value " + next
					+ " was not expected as a result from this iterator ",
					expList.contains(next));
			Assert.assertTrue("Value " + next
					+ " was not removed from the list ", expList.remove(next));
		}

		if (!(expList.size() == 0))
		{
			logger.debug("TestList - Expected iterator results not found");
			for (final Object object : expList)
			{
				logger.debug("TestList - missing: " + object);
			}
		}
		Assert.assertEquals(
				"There were expected elements from the iterator that were not found",
				0, expList.size());
	}

	// Static variables
	// ////////////////////////////////

	// Instance variables
	// ////////////////////////////////

	// Constructors
	// ////////////////////////////////

	// public TestList( String name ) {
	// super( name );
	// }

	// External signature methods
	// ////////////////////////////////
	/*
	 * public static TestSuite suite() {
	 * TestSuite s = new TestSuite( "TestList" );
	 * TestList tl = new TestList();
	 * for (int i = 0; i <= 5; i++) {
	 * s.addTest( new CountTest( i ) );
	 * s.addTest( new TailTest( i ) );
	 * }
	 * 
	 * s.addTest( new ValidityTest() );
	 * s.addTest( new HeadTest() );
	 * s.addTest( new SetHeadTest() );
	 * s.addTest( new SetTailTest() );
	 * s.addTest( new ConsTest() );
	 * s.addTest( new AddTest() );
	 * s.addTest( new TestListGet() );
	 * s.addTest( new ReplaceTest() );
	 * s.addTest( new IndexTest1() );
	 * s.addTest( new IndexTest2() );
	 * s.addTest( new AppendTest() );
	 * s.addTest( new ConcatenateTest() );
	 * s.addTest( new ConcatenateTest2() );
	 * s.addTest( new ApplyTest() );
	 * s.addTest( new ReduceTest() );
	 * s.addTest( new RemoveTest() );
	 * s.addTest( new Map1Test() );
	 * s.addTest( new ListEqualsTest() );
	 * s.addTest( new ListSubclassTest() );
	 * s.addTest( new UserDefinedListTest() );
	 * 
	 * return s;
	 * }
	 */

	// public ListTest( String n ) {super(n);}

	public TestList( final TestingModelFactory modelFactory, final String name )
	{
		super(modelFactory, name);
	}

	protected void checkValid( final String testName, final RDFList l,
			final boolean validExpected )
	{
		l.setStrict(true);
		final boolean valid = l.isValid();
		// for debugging ... String s = l.getValidityErrorMessage();
		Assert.assertEquals("Validity test " + testName
				+ " returned wrong isValid() result", validExpected, valid);
	}

	// Internal implementation methods
	// ////////////////////////////////

	protected RDFList getListRoot( final Model m )
	{
		final Resource root = m.getResource(TestList.NS + "root");
		Assert.assertNotNull("Root resource should not be null", root);

		final Resource listHead = root.getRequiredProperty(
				m.getProperty(TestList.NS + "p")).getResource();

		final RDFList l = listHead.as(RDFList.class);
		Assert.assertNotNull("as(RDFList) should not return null for root", l);

		return l;
	}

	public void testAdd()
	{

		final Resource root = model.createResource(TestList.NS + "root");
		final Property p = model.createProperty(TestList.NS, "p");

		final Resource nil = model.getResource(RDF.nil.getURI());
		RDFList list = nil.as(RDFList.class);

		final Resource[] toAdd = new Resource[] {
				model.createResource(TestList.NS + "a"),
				model.createResource(TestList.NS + "b"),
				model.createResource(TestList.NS + "c"),
				model.createResource(TestList.NS + "d"),
				model.createResource(TestList.NS + "e"), };

		// add each of these resources onto the end of the list
		for (final Resource element : toAdd)
		{
			final RDFList list0 = list.with(element);

			checkValid("addTest0", list0, true);
			Assert.assertTrue("added'ed lists should be equal",
					list.equals(nil) || list0.equals(list));

			list = list0;
		}

		// relate the root to the list
		model.add(root, p, list);

		// should be isomorphic with list 5
		final Model m0 = ModelFactory.createDefaultModel();
		m0.read( getFileName( "ontology/list5.rdf"));

		Assert.assertTrue("Add'ed and read models should be the same",
				m0.isIsomorphicWith(model));

	}

	public void testAppend()
	{
		model.read(getFileName("ontology/list5.rdf"));

		final Resource nil = model.getResource(RDF.nil.getURI());
		RDFList list = nil.as(RDFList.class);

		final Resource r = model.createResource(TestList.NS + "foo");

		// create a list of foos
		for (int i = 0; i < 5; i++)
		{
			list = list.cons(r);
		}

		final int listLen = list.size();

		// now append foos to the root list
		final RDFList root = getListRoot(model);
		final int rootLen = root.size();

		final RDFList appended = root.append(list);

		// original list should be unchanged
		checkValid("appendTest0", root, true);
		Assert.assertEquals("Original list should be unchanged", rootLen,
				root.size());

		checkValid("appendTest1", list, true);
		Assert.assertEquals("Original list should be unchanged", listLen,
				list.size());

		// new list should be length of combined
		checkValid("appendTest2", appended, true);
		Assert.assertEquals("Appended list not correct length", rootLen
				+ listLen, appended.size());
	}

	public void testApply()
	{
		model.read(getFileName("ontology/list5.rdf"));

		final RDFList root = getListRoot(model);

		class MyApply implements RDFList.ApplyFn
		{
			String collect = "";

			@Override
			public void apply( final RDFNode n )
			{
				collect = collect + ((Resource) n).getLocalName();
			}
		}

		final MyApply f = new MyApply();
		root.apply(f);

		Assert.assertEquals(
				"Result of apply should be concatentation of local names",
				"abcde", f.collect);

	}

	public void testConcatenate()
	{
		model.read(getFileName("ontology/list5.rdf"));

		final Resource nil = model.getResource(RDF.nil.getURI());
		RDFList list = nil.as(RDFList.class);

		final Resource r = model.createResource(TestList.NS + "foo");

		// create a list of foos
		for (int i = 0; i < 5; i++)
		{
			list = list.cons(r);
		}

		final int listLen = list.size();

		// now append foos to the root list
		final RDFList root = getListRoot(model);
		final int rootLen = root.size();
		root.concatenate(list);

		// original list should be unchanged
		checkValid("concatTest0", list, true);
		Assert.assertEquals("Original list should be unchanged", listLen,
				list.size());

		// but lhs list has changed
		checkValid("concatTest1", root, true);
		Assert.assertEquals("Root list should be new length",
				rootLen + listLen, root.size());
	}

	public void testConcatenate2()
	{
		model.read(getFileName("ontology/list5.rdf"));

		final Resource a = model.createResource(TestList.NS + "a");

		// create a list of foos
		final Resource[] rs = new Resource[] {
				model.createResource(TestList.NS + "b"),
				model.createResource(TestList.NS + "c"),
				model.createResource(TestList.NS + "d"),
				model.createResource(TestList.NS + "e") };

		final RDFList aList = model.createList().cons(a);
		final RDFList rsList = model.createList(rs);

		// concatenate the above resources onto the empty list
		aList.concatenate(rsList);
		checkValid("concatTest3", aList, true);

		final RDFList root = getListRoot(model);
		Assert.assertTrue("Constructed and loaded lists should be the same",
				aList.sameListAs(root));
	}

	public void testCons()
	{
		final Resource root = model.createResource(TestList.NS + "root");
		final Property p = model.createProperty(TestList.NS, "p");

		final Resource nil = model.getResource(RDF.nil.getURI());
		RDFList list = nil.as(RDFList.class);

		final Resource[] toAdd = new Resource[] {
				model.createResource(TestList.NS + "e"),
				model.createResource(TestList.NS + "d"),
				model.createResource(TestList.NS + "c"),
				model.createResource(TestList.NS + "b"),
				model.createResource(TestList.NS + "a"), };

		// cons each of these resources onto the front of the list
		for (final Resource element : toAdd)
		{
			final RDFList list0 = list.cons(element);

			checkValid("constest1", list0, true);
			Assert.assertTrue("cons'ed lists should not be equal",
					!list0.equals(list));

			list = list0;
		}

		// relate the root to the list
		model.add(root, p, list);

		// should be isomorphic with list 5
		final Model m0 = ModelFactory.createDefaultModel();
		m0.read(getFileName("ontology/list5.rdf"));

		Assert.assertTrue("Cons'ed and read models should be the same",
				m0.isIsomorphicWith(model));
	}

	public void testCount()
	{
		for (int i = 0; i <= 5; i++)
		{
			model.removeAll();
			model.read( getFileName("ontology/list" + i + ".rdf"));

			final RDFList l0 = getListRoot(model);
			Assert.assertEquals("List size should be " + i, i, l0.size());
		}

	}

	public void testHead()
	{
		model.read(getFileName("ontology/list5.rdf"));

		RDFList l0 = getListRoot(model);

		final String[] names = { "a", "b", "c", "d", "e" };
		for (final String name : names)
		{
			Assert.assertEquals("head of list has incorrect URI", TestList.NS
					+ name, ((Resource) l0.getHead()).getURI());
			l0 = l0.getTail();
		}
	}

	public void testIndex1()
	{
		model.read(getFileName("ontology/list5.rdf"));

		final Resource[] toGet = new Resource[] {
				model.createResource(TestList.NS + "a"),
				model.createResource(TestList.NS + "b"),
				model.createResource(TestList.NS + "c"),
				model.createResource(TestList.NS + "d"),
				model.createResource(TestList.NS + "e"), };

		final RDFList l1 = getListRoot(model);

		// check the indexes are correct
		for (int i = 0; i < toGet.length; i++)
		{
			Assert.assertTrue("list should contain element " + i,
					l1.contains(toGet[i]));
			Assert.assertEquals("list element " + i + " is not correct", i,
					l1.indexOf(toGet[i]));
		}
	}

	public void testIndex2()
	{

		final Resource nil = model.getResource(RDF.nil.getURI());
		RDFList list = nil.as(RDFList.class);

		final Resource r = model.createResource(TestList.NS + "a");

		// cons each a's onto the front of the list
		for (int i = 0; i < 10; i++)
		{
			list = list.cons(r);
		}

		// now index them back again
		for (int j = 0; j < 10; j++)
		{
			Assert.assertEquals("index of j'th item should be j", j,
					list.indexOf(r, j));
		}

	}

	public void testListEquals()
	{
		final Resource nil = model.getResource(RDF.nil.getURI());
		final RDFList nilList = nil.as(RDFList.class);

		// create a list of foos
		final Resource[] r0 = new Resource[] {
				model.createResource(TestList.NS + "a"), // canonical
				model.createResource(TestList.NS + "b"),
				model.createResource(TestList.NS + "c"),
				model.createResource(TestList.NS + "d"),
				model.createResource(TestList.NS + "e") };
		final Resource[] r1 = new Resource[] {
				model.createResource(TestList.NS + "a"), // same
				model.createResource(TestList.NS + "b"),
				model.createResource(TestList.NS + "c"),
				model.createResource(TestList.NS + "d"),
				model.createResource(TestList.NS + "e") };
		final Resource[] r2 = new Resource[] {
				model.createResource(TestList.NS + "a"), // one shorter
				model.createResource(TestList.NS + "b"),
				model.createResource(TestList.NS + "c"),
				model.createResource(TestList.NS + "d") };
		final Resource[] r3 = new Resource[] {
				model.createResource(TestList.NS + "a"), // elements
				// swapped
				model.createResource(TestList.NS + "b"),
				model.createResource(TestList.NS + "d"),
				model.createResource(TestList.NS + "c"),
				model.createResource(TestList.NS + "e") };
		final Resource[] r4 = new Resource[] {
				model.createResource(TestList.NS + "a"), // different
				// name
				model.createResource(TestList.NS + "b"),
				model.createResource(TestList.NS + "c"),
				model.createResource(TestList.NS + "D"),
				model.createResource(TestList.NS + "e") };

		final Object[][] testSpec = new Object[][] { { r0, r1, Boolean.TRUE },
				{ r0, r2, Boolean.FALSE }, { r0, r3, Boolean.FALSE },
				{ r0, r4, Boolean.FALSE }, { r1, r2, Boolean.FALSE },
				{ r1, r3, Boolean.FALSE }, { r1, r4, Boolean.FALSE },
				{ r2, r3, Boolean.FALSE }, { r2, r4, Boolean.FALSE }, };

		for (int i = 0; i < testSpec.length; i++)
		{
			final RDFList l0 = nilList.append(Arrays.asList(
					(Resource[]) testSpec[i][0]).iterator());
			final RDFList l1 = nilList.append(Arrays.asList(
					(Resource[]) testSpec[i][1]).iterator());
			final boolean expected = ((Boolean) testSpec[i][2]).booleanValue();

			Assert.assertEquals("sameListAs testSpec[" + i + "] incorrect",
					expected, l0.sameListAs(l1));
			Assert.assertEquals("sameListAs testSpec[" + i
					+ "] (swapped) incorrect", expected, l1.sameListAs(l0));
		}
	}

	public void testListGet()
	{
		model.read(getFileName("ontology/list5.rdf"));

		final Resource[] toGet = new Resource[] {
				model.createResource(TestList.NS + "a"),
				model.createResource(TestList.NS + "b"),
				model.createResource(TestList.NS + "c"),
				model.createResource(TestList.NS + "d"),
				model.createResource(TestList.NS + "e"), };

		final RDFList l1 = getListRoot(model);

		// test normal gets
		for (int i = 0; i < toGet.length; i++)
		{
			Assert.assertEquals("list element " + i + " is not correct",
					toGet[i], l1.get(i));
		}

		// now test we get an exception for going beyong the end of the list
		boolean gotEx = false;
		try
		{
			l1.get(toGet.length + 1);
		}
		catch (final ListIndexException e)
		{
			gotEx = true;
		}

		Assert.assertTrue(
				"Should see exception raised by accessing beyond end of list",
				gotEx);
	}

	public void testMap1()
	{
		model.read(getFileName("ontology/list5.rdf"));

		final RDFList root = getListRoot(model);
		TestList.iteratorTest(root.mapWith(n ->((Resource) n).getLocalName()), new Object[] { "a", "b", "c", "d", "e" });

	}

	public void testReduce()
	{
		model.read(getFileName("ontology/list5.rdf"));

		final RDFList root = getListRoot(model);

		final RDFList.ReduceFn f = new RDFList.ReduceFn() {
			@Override
			public Object reduce( final RDFNode n, final Object acc )
			{
				return ((String) acc) + ((Resource) n).getLocalName();
			}
		};

		Assert.assertEquals(
				"Result of reduce should be concatentation of local names",
				"abcde", root.reduce(f, ""));
	}

	public void testRemove()
	{

		final Resource nil = model.getResource(RDF.nil.getURI());
		RDFList list0 = nil.as(RDFList.class);
		RDFList list1 = nil.as(RDFList.class);

		final Resource r0 = model.createResource(TestList.NS + "x");
		final Resource r1 = model.createResource(TestList.NS + "y");
		final Resource r2 = model.createResource(TestList.NS + "z");

		for (int i = 0; i < 10; i++)
		{
			list0 = list0.cons(r0);
			list1 = list1.cons(r1);
		}

		// delete the elements of list0 one at a time
		while (!list0.isEmpty())
		{
			list0 = list0.removeHead();
			checkValid("removeTest0", list0, true);
		}

		// delete all of list1 in one go
		list1.removeList();

		// model should now be empty
		Assert.assertEquals("Model should be empty after deleting two lists",
				0, model.size());

		// selective remove
		RDFList list2 = (nil.as(RDFList.class)).cons(r2).cons(r1).cons(r0);

		Assert.assertTrue("list should contain x ", list2.contains(r0));
		Assert.assertTrue("list should contain y ", list2.contains(r1));
		Assert.assertTrue("list should contain z ", list2.contains(r2));

		list2 = list2.remove(r1);
		Assert.assertTrue("list should contain x ", list2.contains(r0));
		Assert.assertTrue("list should contain y ", !list2.contains(r1));
		Assert.assertTrue("list should contain z ", list2.contains(r2));

		list2 = list2.remove(r0);
		Assert.assertTrue("list should contain x ", !list2.contains(r0));
		Assert.assertTrue("list should contain y ", !list2.contains(r1));
		Assert.assertTrue("list should contain z ", list2.contains(r2));

		list2 = list2.remove(r2);
		Assert.assertTrue("list should contain x ", !list2.contains(r0));
		Assert.assertTrue("list should contain y ", !list2.contains(r1));
		Assert.assertTrue("list should contain z ", !list2.contains(r2));
		Assert.assertTrue("list should be empty", list2.isEmpty());
	}

	public void testReplace()
	{
		model.read(getFileName("ontology/list5.rdf"));

		final Literal[] toSet = new Literal[] { model.createLiteral("a"),
				model.createLiteral("b"), model.createLiteral("c"),
				model.createLiteral("d"), model.createLiteral("e"), };

		final RDFList l1 = getListRoot(model);

		// change all the values
		for (int i = 0; i < toSet.length; i++)
		{
			l1.replace(i, toSet[i]);
		}

		// then check them
		for (int i = 0; i < toSet.length; i++)
		{
			Assert.assertEquals("list element " + i + " is not correct",
					toSet[i], l1.get(i));
		}

		// now test we get an exception for going beyong the end of the list
		boolean gotEx = false;
		try
		{
			l1.replace(toSet.length + 1, toSet[0]);
		}
		catch (final ListIndexException e)
		{
			gotEx = true;
		}

		Assert.assertTrue(
				"Should see exception raised by accessing beyond end of list",
				gotEx);

	}

	public void testSetHead()
	{

		final Resource root = model.createResource(TestList.NS + "root");
		final Property p = model.createProperty(TestList.NS, "p");

		// a list of the nil object, but not typed
		final Resource nil = RDF.nil;
		model.add(nil, RDF.type, RDF.List);

		final Resource list = model.createResource();
		model.add(list, RDF.type, RDF.List);
		model.add(list, RDF.first, "fred");
		model.add(list, RDF.rest, nil);

		model.add(root, p, list);
		final RDFList l1 = getListRoot(model);
		checkValid("sethead1", l1, true);

		Assert.assertEquals("List head should be 'fred'", "fred",
				((Literal) l1.getHead()).getString());

		l1.setHead(model.createTypedLiteral(42));
		checkValid("sethead2", l1, true);
		Assert.assertEquals("List head should be '42'", 42,
				((Literal) l1.getHead()).getInt());

	}

	public void testSetTail()
	{
		final Model m = ModelFactory.createDefaultModel();

		final Resource root = m.createResource(TestList.NS + "root");
		final Property p = m.createProperty(TestList.NS, "p");

		final Resource nil = RDF.nil;
		m.add(nil, RDF.type, RDF.List);

		final Resource list0 = m.createResource();
		m.add(list0, RDF.type, RDF.List);
		m.add(list0, RDF.first, "fred");
		m.add(list0, RDF.rest, nil);

		m.add(root, p, list0);
		final RDFList l1 = getListRoot(m);
		checkValid("settail1", l1, true);

		final Resource list1 = m.createResource();
		m.add(list1, RDF.type, RDF.List);
		m.add(list1, RDF.first, "george");
		m.add(list1, RDF.rest, nil);

		final RDFList l2 = list1.as(RDFList.class);
		Assert.assertNotNull("as(RDFList) should not return null for root", l2);
		checkValid("settail2", l2, true);

		Assert.assertEquals("l1 should have length 1", 1, l1.size());
		Assert.assertEquals("l2 should have length 1", 1, l2.size());

		// use set tail to join the lists together
		l1.setTail(l2);

		checkValid("settail3", l1, true);
		checkValid("settail4", l2, true);

		Assert.assertEquals("l1 should have length 2", 2, l1.size());
		Assert.assertEquals("l2 should have length 1", 1, l2.size());

	}

	public void testTail()
	{
		for (int i = 0; i <= 5; i++)
		{
			model.read( getFileName("ontology/list" + i + ".rdf"));

			RDFList l0 = getListRoot(model);

			// get the tail n times, should be nil at the end
			for (int j = 0; j < i; j++)
			{
				l0 = l0.getTail();
			}

			Assert.assertTrue("Should have reached the end of the list after "
					+ i + " getTail()'s", l0.isEmpty());
		}
	}

	public void testValidity()
	{

		final Resource root = model.createResource(TestList.NS + "root");
		final Property p = model.createProperty(TestList.NS, "p");

		// a list of the nil object, but not typed
		final Resource nil = RDF.nil;
		model.add(root, p, nil);
		final RDFList l0 = getListRoot(model);
		checkValid("valid1", l0, true);

		// add another node to the head of the list
		final Resource badList = model.createResource();
		model.getRequiredProperty(root, p).remove();
		model.add(root, p, badList);
		model.add(badList, RDF.type, RDF.List);

		final RDFList l1 = getListRoot(model);
		checkValid("valid2", l1, false);

		// checkValid( "valid3", l1, false );

		model.add(badList, RDF.first, "fred");
		checkValid("valid4", l1, false);

		model.add(badList, RDF.rest, nil);
		checkValid("valid5", l1, true);

	}

	// public void testListSubclass() {
	// String NS = "http://example.org/test#";
	// Resource a = model.createResource( NS + "a" );
	// Resource b = model.createResource( NS + "b" );
	//
	// Resource cell0 = model.createResource();
	// Resource cell1 = model.createResource();
	// cell0.addProperty( RDF.first, a );
	// cell0.addProperty( RDF.rest, cell1 );
	// cell1.addProperty( RDF.first, b );
	// cell1.addProperty( RDF.rest, RDF.nil );
	//
	// UserList ul = getUserListInstance(cell0);
	//
	// assertEquals( "User list length ", 2, ul.size() );
	// assertEquals( "head of user list ", a, ul.getHead() );
	//
	// RDFList l = ul.as( RDFList.class );
	// assertNotNull( "RDFList facet of user-defined list subclass", l );
	//
	// }
	//
	// /** A simple extension to RDFList to test user-subclassing of RDFList */
	// protected static interface UserList extends RDFList {
	// }
	//
	// /** Impl of a simple extension to RDFList to test user-subclassing of
	// RDFList */
	// protected static class UserListImpl extends RDFListImpl implements
	// UserList {
	// public UserListImpl( Node n, EnhGraph g ) {
	// super( n, g );
	// }
	// }
	//
	// public UserList getUserListInstance( Resource r )
	// {
	// return new UserListImpl( r.asNode(), (EnhGraph) model );
	// }
	//
	// public void testUserDefinedList() {
	// BuiltinPersonalities.model.add( UserDefList.class,
	// UserDefListImpl.factoryForTests );
	//
	// String NS = "http://example.org/test#";
	// Resource a = model.createResource( NS + "a" );
	// Resource b = model.createResource( NS + "b" );
	//
	// Resource empty = model.createResource( UserDefListImpl.NIL.getURI() );
	// UserDefList ul = empty.as( UserDefList.class );
	// assertNotNull( "UserList facet of empty list", ul );
	//
	// UserDefList ul0 = (UserDefList) ul.cons( b );
	// ul0 = (UserDefList) ul0.cons( a );
	// assertEquals( "should be length 2", 2, ul0.size() );
	// assertTrue( "first statement", model.contains( ul0,
	// UserDefListImpl.FIRST, a ) );
	// }
	//
	// protected static interface UserDefList extends RDFList {}
	//
	// protected static class UserDefListImpl extends RDFListImpl implements
	// UserDefList {
	// @SuppressWarnings("hiding") public static final String NS =
	// "http://example.org/testlist#";
	// public static final Property FIRST = ResourceFactory.createProperty(
	// NS+"first" );
	// public static final Property REST = ResourceFactory.createProperty(
	// NS+"rest" );
	// public static final Resource NIL = ResourceFactory.createResource(
	// NS+"nil" );
	// public static final Resource LIST = ResourceFactory.createResource(
	// NS+"List" );
	//
	// /**
	// * A factory for generating UserDefList facets from nodes in enhanced
	// graphs.
	// */
	// public static Implementation factoryForTests = new Implementation() {
	// @Override public EnhNode wrap( Node n, EnhGraph eg ) {
	// if (canWrap( n, eg )) {
	// UserDefListImpl impl = new UserDefListImpl( n, eg );
	//
	// Model model = impl.getModel();
	// impl.m_listFirst = FIRST.inModel( model );
	// impl.m_listRest = REST.inModel( model );
	// impl.m_listNil = NIL.inModel( model );
	// impl.m_listType = LIST.inModel( model );
	//
	// return impl;
	// }
	// else {
	// throw new JenaException( "Cannot convert node " + n + " to UserDefList");
	// }
	// }
	//
	// @Override public boolean canWrap( Node node, EnhGraph eg ) {
	// Graph g = eg.asGraph();
	//
	// return node.equals( NIL.asNode() ) ||
	// g.contains( node, FIRST.asNode(), Node.ANY ) ||
	// g.contains( node, REST.asNode(), Node.ANY ) ||
	// g.contains( node, RDF.type.asNode(), LIST.asNode() );
	// }
	// };
	//
	// /** This method returns the Java class object that defines which
	// abstraction facet is presented */
	// @Override public Class<? extends RDFList> listAbstractionClass() {
	// return UserDefList.class;
	// }
	//
	// public UserDefListImpl( Node n, EnhGraph g ) {
	// super( n, g );
	// }
	//
	// }

}
