org.eclipse.rdf4j.rio.nquads.AbstractNQuadsParserUnitTest Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of rdf4j-rio-testsuite Show documentation
Test suite for Rio
There is a newer version: 5.1.0
/*******************************************************************************
 * Copyright (c) 2015 Eclipse RDF4J contributors, Aduna, and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Distribution License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/org/documents/edl-v10.php.
 *******************************************************************************/
package org.eclipse.rdf4j.rio.nquads;

import static org.hamcrest.core.Is.is;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.fail;

import java.io.BufferedReader;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.Collection;

import org.eclipse.rdf4j.model.BNode;
import org.eclipse.rdf4j.model.IRI;
import org.eclipse.rdf4j.model.Literal;
import org.eclipse.rdf4j.model.Resource;
import org.eclipse.rdf4j.model.Statement;
import org.eclipse.rdf4j.model.Value;
import org.eclipse.rdf4j.model.vocabulary.RDF;
import org.eclipse.rdf4j.rio.ParseLocationListener;
import org.eclipse.rdf4j.rio.RDFHandlerException;
import org.eclipse.rdf4j.rio.RDFParseException;
import org.eclipse.rdf4j.rio.RDFParser;
import org.eclipse.rdf4j.rio.helpers.AbstractRDFHandler;
import org.eclipse.rdf4j.rio.helpers.BasicParserSettings;
import org.eclipse.rdf4j.rio.helpers.NTriplesParserSettings;
import org.eclipse.rdf4j.rio.helpers.StatementCollector;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;

/**
 * JUnit test for the N-Quads parser that uses the tests that are available
 * online.
 */
public abstract class AbstractNQuadsParserUnitTest {

	/*-----------*
	 * Constants *
	 *-----------*/

	private static String NQUADS_TEST_URL = "http://www.w3.org/2000/10/rdf-tests/rdfcore/ntriples/test.nt";

	private static String NQUADS_TEST_FILE = "/testcases/nquads/test1.nq";

	private static String NTRIPLES_TEST_URL = "http://www.w3.org/2000/10/rdf-tests/rdfcore/ntriples/test.nt";

	private static String NTRIPLES_TEST_FILE = "/testcases/ntriples/test.nt";

	private RDFParser parser;

	private TestRDFHandler rdfHandler;

	@Before
	public void setUp()
		throws Exception
	{
		parser = createRDFParser();
		rdfHandler = new TestRDFHandler();
		parser.setRDFHandler(this.rdfHandler);
	}

	@After
	public void tearDown()
		throws Exception
	{
		parser = null;
	}

	/*---------*
	 * Methods *
	 *---------*/

	public void testNQuadsFile()
		throws Exception
	{
		RDFParser nquadsParser = createRDFParser();
		nquadsParser.setRDFHandler(new AbstractRDFHandler() {});

		InputStream in = AbstractNQuadsParserUnitTest.class.getResourceAsStream(NQUADS_TEST_FILE);
		try {
			nquadsParser.parse(in, NQUADS_TEST_URL);
		}
		catch (RDFParseException e) {
			fail("NQuadsParser failed to parse N-Quads test document: " + e.getMessage());
		}
		finally {
			in.close();
		}
	}

	/**
	 * The N-Quads parser must be able to parse the N-Triples test file without error.
	 */
	public void testNTriplesFile()
		throws Exception
	{
		RDFParser nquadsParser = createRDFParser();
		nquadsParser.setRDFHandler(new AbstractRDFHandler() {});

		InputStream in = AbstractNQuadsParserUnitTest.class.getResourceAsStream(NTRIPLES_TEST_FILE);
		try {
			nquadsParser.parse(in, NTRIPLES_TEST_URL);
		}
		catch (RDFParseException e) {
			fail("NQuadsParser failed to parse N-Triples test document: " + e.getMessage());
		}
		finally {
			in.close();
		}
	}

	/**
	 * Tests the correct behavior with incomplete input.
	 */
	@Test
	public void testIncompleteParsingWithoutPeriod()
		throws RDFHandlerException, IOException, RDFParseException
	{
		final ByteArrayInputStream bais = new ByteArrayInputStream(
				"   ".getBytes());
		try {
			parser.parse(bais, "http://test.base.uri");
			Assert.fail("Expected exception when not inserting a trailing period at the end of a statement.");
		}
		catch (RDFParseException rdfpe) {
			// FIXME: Enable this test when first line number is 1 in parser
			// instead of -1
			// Assert.assertEquals(1, rdfpe.getLineNumber());
			// FIXME: Enable column numbers when parser supports them
			// Assert.assertEquals(44, rdfpe.getColumnNumber());
		}
	}

	/**
	 * Tests the behaviour with non-whitespace characters after a period character without a context.
	 * 
	 * @throws RDFHandlerException
	 * @throws IOException
	 * @throws RDFParseException
	 */
	@Test
	public void testNonWhitespaceAfterPeriodNoContext()
		throws RDFHandlerException, IOException, RDFParseException
	{
		final ByteArrayInputStream bais = new ByteArrayInputStream(
				"  \"x\"^^ .  ".getBytes());
		try {
			parser.parse(bais, "http://base-uri");
			Assert.fail("Expected exception when there is non-whitespace characters after a period.");
		}
		catch (RDFParseException rdfpe) {
			Assert.assertEquals(1, rdfpe.getLineNumber());
			// FIXME: Enable column numbers when parser supports them
			// Assert.assertEquals(44, rdfpe.getColumnNumber());
		}
	}

	/**
	 * Tests the behaviour with non-whitespace characters after a period character without a context.
	 * 
	 * @throws RDFHandlerException
	 * @throws IOException
	 * @throws RDFParseException
	 */
	@Test
	public void testNonWhitespaceAfterPeriodWithContext()
		throws RDFHandlerException, IOException, RDFParseException
	{
		final ByteArrayInputStream bais = new ByteArrayInputStream(
				"  \"x\"^^  .  ".getBytes());
		try {
			parser.parse(bais, "http://base-uri");
			Assert.fail("Expected exception when there is non-whitespace characters after a period.");
		}
		catch (RDFParseException rdfpe) {
			Assert.assertEquals(1, rdfpe.getLineNumber());
			// FIXME: Enable column numbers when parser supports them
			// Assert.assertEquals(44, rdfpe.getColumnNumber());
		}
	}

	/**
	 * Tests the correct behaviour with no context.
	 */
	@Test
	public void testParseNoContext()
		throws RDFHandlerException, IOException, RDFParseException
	{
		final ByteArrayInputStream bais = new ByteArrayInputStream(
				"   .".getBytes());
		parser.parse(bais, "http://base-uri");
	}

	/**
	 * Tests parsing of empty lines and comments.
	 */
	@Test
	public void testParseEmptyLinesAndComments()
		throws RDFHandlerException, IOException, RDFParseException
	{
		final ByteArrayInputStream bais = new ByteArrayInputStream(
				"  \n\n\n# This is a comment\n\n#this is another comment.".getBytes());
		final TestRDFHandler rdfHandler = new TestRDFHandler();
		parser.setRDFHandler(rdfHandler);
		parser.parse(bais, "http://test.base.uri");
		Assert.assertEquals(rdfHandler.getStatements().size(), 0);
	}

	/**
	 * Tests basic N-Quads parsing.
	 */
	@Test
	public void testParseBasic()
		throws RDFHandlerException, IOException, RDFParseException
	{
		final ByteArrayInputStream bais = new ByteArrayInputStream(
				"    .".getBytes());
		final TestRDFHandler rdfHandler = new TestRDFHandler();
		parser.setRDFHandler(rdfHandler);
		parser.parse(bais, "http://test.base.uri");
		Assert.assertThat(rdfHandler.getStatements().size(), is(1));
		final Statement statement = rdfHandler.getStatements().iterator().next();
		Assert.assertEquals("http://www.v/dat/4b", statement.getSubject().stringValue());
		Assert.assertEquals("http://www.w3.org/20/ica#dtend", statement.getPredicate().stringValue());
		Assert.assertTrue(statement.getObject() instanceof IRI);
		Assert.assertEquals("http://sin/value/2", statement.getObject().stringValue());
		Assert.assertEquals("http://sin.siteserv.org/def/", statement.getContext().stringValue());
	}

	/**
	 * Tests basic N-Quads parsing with blank node.
	 */
	@Test
	public void testParseBasicBNode()
		throws RDFHandlerException, IOException, RDFParseException
	{
		final ByteArrayInputStream bais = new ByteArrayInputStream(
				"_:a123456768   .".getBytes());
		final TestRDFHandler rdfHandler = new TestRDFHandler();
		parser.setRDFHandler(rdfHandler);
		parser.parse(bais, "http://test.base.uri");
		Assert.assertThat(rdfHandler.getStatements().size(), is(1));
		final Statement statement = rdfHandler.getStatements().iterator().next();
		Assert.assertTrue(statement.getSubject() instanceof BNode);
		Assert.assertEquals("http://www.w3.org/20/ica#dtend", statement.getPredicate().stringValue());
		Assert.assertTrue(statement.getObject() instanceof IRI);
		Assert.assertEquals("http://sin/value/2", statement.getObject().stringValue());
		Assert.assertEquals("http://sin.siteserv.org/def/", statement.getContext().stringValue());
	}

	/**
	 * Tests basic N-Quads parsing with literal.
	 */
	@Test
	public void testParseBasicLiteral()
		throws RDFHandlerException, IOException, RDFParseException
	{
		final ByteArrayInputStream bais = new ByteArrayInputStream(
				"_:a123456768  \"2010-05-02\" .".getBytes());
		final TestRDFHandler rdfHandler = new TestRDFHandler();
		parser.setRDFHandler(rdfHandler);
		parser.parse(bais, "http://test.base.uri");
		Assert.assertThat(rdfHandler.getStatements().size(), is(1));
		final Statement statement = rdfHandler.getStatements().iterator().next();
		Assert.assertTrue(statement.getSubject() instanceof BNode);
		Assert.assertEquals("http://www.w3.org/20/ica#dtend", statement.getPredicate().stringValue());
		Assert.assertTrue(statement.getObject() instanceof Literal);
		Assert.assertEquals("2010-05-02", statement.getObject().stringValue());
		Assert.assertEquals("http://sin.siteserv.org/def/", statement.getContext().stringValue());
	}

	/**
	 * Tests N-Quads parsing with literal and language.
	 */
	@Test
	public void testParseBasicLiteralLang()
		throws RDFHandlerException, IOException, RDFParseException
	{
		final ByteArrayInputStream bais = new ByteArrayInputStream(
				"  \"2010-05-02\"@en .".getBytes());
		final TestRDFHandler rdfHandler = new TestRDFHandler();
		parser.setRDFHandler(rdfHandler);
		parser.parse(bais, "http://test.base.uri");
		final Statement statement = rdfHandler.getStatements().iterator().next();
		Assert.assertEquals("http://www.v/dat/4b2-21", statement.getSubject().stringValue());
		Assert.assertEquals("http://www.w3.org/20/ica#dtend", statement.getPredicate().stringValue());
		Assert.assertTrue(statement.getObject() instanceof Literal);
		Literal object = (Literal)statement.getObject();
		Assert.assertEquals("2010-05-02", object.stringValue());
		Assert.assertEquals("en", object.getLanguage().orElse(null));
		Assert.assertEquals(RDF.LANGSTRING, object.getDatatype());
		Assert.assertEquals("http://sin.siteserv.org/def/", statement.getContext().stringValue());
	}

	/**
	 * Tests N-Quads parsing with literal and datatype.
	 */
	@Test
	public void testParseBasicLiteralDatatype()
		throws RDFHandlerException, IOException, RDFParseException
	{
		final ByteArrayInputStream bais = new ByteArrayInputStream(
				(" " + " "
						+ "\"2010\"^^ "
						+ ".").getBytes());
		final TestRDFHandler rdfHandler = new TestRDFHandler();
		parser.setRDFHandler(rdfHandler);
		parser.parse(bais, "http://test.base.uri");
		final Statement statement = rdfHandler.getStatements().iterator().next();
		Assert.assertEquals("http://www.v/dat/4b2-21", statement.getSubject().stringValue());
		Assert.assertEquals("http://www.w3.org/20/ica#dtend", statement.getPredicate().stringValue());
		Assert.assertTrue(statement.getObject() instanceof Literal);
		Literal object = (Literal)statement.getObject();
		Assert.assertEquals("2010", object.stringValue());
		Assert.assertFalse(object.getLanguage().isPresent());
		Assert.assertEquals("http://www.w3.org/2001/XMLSchema#integer", object.getDatatype().toString());
		Assert.assertEquals("http://sin.siteserv.org/def/", statement.getContext().stringValue());
	}

	/**
	 * Tests N-Quads parsing with literal and datatype using a prefix, which is illegal in NQuads, but legal
	 * in N3/Turtle that may otherwise look like NQuads
	 */
	@Test
	public void testParseBasicLiteralDatatypePrefix()
		throws RDFHandlerException, IOException
	{

		final ByteArrayInputStream bais = new ByteArrayInputStream(
				(" " + " " + "\"2010\"^^xsd:integer "
						+ ".").getBytes());
		final TestRDFHandler rdfHandler = new TestRDFHandler();
		parser.setRDFHandler(rdfHandler);
		try {
			parser.parse(bais, "http://test.base.uri");
			Assert.fail("Expected exception when passing in a datatype using an N3 style prefix");
		}
		catch (RDFParseException rdfpe) {
			Assert.assertEquals(1, rdfpe.getLineNumber());
			// FIXME: Enable column numbers when parser supports them
			// Assert.assertEquals(69, rdfpe.getColumnNumber());
		}
	}

	/**
	 * Tests the correct support for literal escaping.
	 */
	@Test
	public void testLiteralEscapeManagement1()
		throws RDFHandlerException, IOException, RDFParseException
	{
		TestParseLocationListener parseLocationListener = new TestParseLocationListener();
		TestRDFHandler rdfHandler = new TestRDFHandler();
		parser.setParseLocationListener(parseLocationListener);
		parser.setRDFHandler(rdfHandler);

		final ByteArrayInputStream bais = new ByteArrayInputStream(
				"  \"\\\\\"  .".getBytes());
		parser.parse(bais, "http://base-uri");

		rdfHandler.assertHandler(1);
		// parseLocationListener.assertListener(1, 40);
		// FIXME: Enable column numbers when parser supports them
		parseLocationListener.assertListener(1, 1);
	}

	/**
	 * Tests the correct support for literal escaping.
	 */
	@Test
	public void testLiteralEscapeManagement2()
		throws RDFHandlerException, IOException, RDFParseException
	{
		TestParseLocationListener parseLocationListener = new TestParseLocationListener();
		TestRDFHandler rdfHandler = new TestRDFHandler();
		parser.setParseLocationListener(parseLocationListener);
		parser.setRDFHandler(rdfHandler);

		final ByteArrayInputStream bais = new ByteArrayInputStream(
				"  \"Line text 1\\nLine text 2\"  .".getBytes());
		parser.parse(bais, "http://base-uri");

		rdfHandler.assertHandler(1);
		final Value object = rdfHandler.getStatements().iterator().next().getObject();
		Assert.assertTrue(object instanceof Literal);
		final String literalContent = ((Literal)object).getLabel();
		Assert.assertEquals("Line text 1\nLine text 2", literalContent);
	}

	/**
	 * Tests the correct decoding of UTF-8 encoded chars in URIs.
	 */
	@Test
	public void testURIDecodingManagement()
		throws RDFHandlerException, IOException, RDFParseException
	{
		TestParseLocationListener parseLocationListener = new TestParseLocationListener();
		TestRDFHandler rdfHandler = new TestRDFHandler();
		parser.setParseLocationListener(parseLocationListener);
		parser.setRDFHandler(rdfHandler);

		final ByteArrayInputStream bais = new ByteArrayInputStream(
				"    .".getBytes());
		parser.parse(bais, "http://base-uri");

		rdfHandler.assertHandler(1);
		final Statement statement = rdfHandler.getStatements().iterator().next();

		final Resource subject = statement.getSubject();
		Assert.assertTrue(subject instanceof IRI);
		final String subjectURI = subject.toString();
		Assert.assertEquals("http://s/はむ", subjectURI);

		final Resource predicate = statement.getPredicate();
		Assert.assertTrue(predicate instanceof IRI);
		final String predicateURI = predicate.toString();
		Assert.assertEquals("http://p/はむ", predicateURI);

		final Value object = statement.getObject();
		Assert.assertTrue(object instanceof IRI);
		final String objectURI = object.toString();
		Assert.assertEquals("http://o/はむ", objectURI);

		final Resource graph = statement.getContext();
		Assert.assertTrue(graph instanceof IRI);
		final String graphURI = graph.toString();
		Assert.assertEquals("http://g/はむ", graphURI);
	}

	@Test
	public void testUnicodeLiteralDecoding()
		throws RDFHandlerException, IOException, RDFParseException
	{
		TestRDFHandler rdfHandler = new TestRDFHandler();
		parser.setRDFHandler(rdfHandler);
		final String INPUT_LITERAL_PLAIN = "[は]";
		final String INPUT_LITERAL_ENCODED = "[\\u306F]";
		final String INPUT_STRING = String.format("  \"%s\"  .",
				INPUT_LITERAL_ENCODED);
		final ByteArrayInputStream bais = new ByteArrayInputStream(INPUT_STRING.getBytes());
		parser.parse(bais, "http://base-uri");

		rdfHandler.assertHandler(1);
		final Literal obj = (Literal)rdfHandler.getStatements().iterator().next().getObject();
		Assert.assertEquals(INPUT_LITERAL_PLAIN, obj.getLabel());
	}

	@Test
	public void testWrongUnicodeEncodedCharFail()
		throws RDFHandlerException, IOException, RDFParseException
	{
		final ByteArrayInputStream bais = new ByteArrayInputStream(
				"  \"\\u123X\"  .".getBytes());
		try {
			parser.parse(bais, "http://test.base.uri");
			Assert.fail("Expected exception when an incorrect unicode character is included");
		}
		catch (RDFParseException rdfpe) {
			Assert.assertEquals(1, rdfpe.getLineNumber());
			// FIXME: Enable column numbers when parser supports them
			// Assert.assertEquals(30, rdfpe.getColumnNumber());
		}
	}

	/**
	 * Tests the correct support for EOS exception.
	 */
	@Test
	public void testEndOfStreamReached()
		throws RDFHandlerException, IOException, RDFParseException
	{
		final ByteArrayInputStream bais = new ByteArrayInputStream(
				"  \"\\\"  .".getBytes());
		try {
			parser.parse(bais, "http://test.base.uri");
			Assert.fail("Expected exception when a literal is not closed");
		}
		catch (RDFParseException rdfpe) {
			// FIXME: Enable this test when first line number is 1 in parser
			// instead of -1
			// Assert.assertEquals(1, rdfpe.getLineNumber());
			// FIXME: Enable column numbers when parser supports them
			// Assert.assertEquals(39, rdfpe.getColumnNumber());
		}
	}

	/**
	 * Tests the parser with all cases defined by the NQuads grammar.
	 */
	@Test
	public void testParserWithAllCases()
		throws IOException, RDFParseException, RDFHandlerException
	{
		TestParseLocationListener parseLocationListerner = new TestParseLocationListener();
		// SpecificTestRDFHandler rdfHandler = new SpecificTestRDFHandler();
		parser.setParseLocationListener(parseLocationListerner);
		parser.setRDFHandler(rdfHandler);

		BufferedReader br = new BufferedReader(new InputStreamReader(
				AbstractNQuadsParserUnitTest.class.getResourceAsStream("/testcases/nquads/test1.nq")));
		parser.parse(br, "http://test.base.uri");

		rdfHandler.assertHandler(6);
		parseLocationListerner.assertListener(9, 1);
	}

	/**
	 * Tests parser with real data.
	 */
	@Test
	public void testParserWithRealData()
		throws IOException, RDFParseException, RDFHandlerException
	{
		TestParseLocationListener parseLocationListener = new TestParseLocationListener();
		TestRDFHandler rdfHandler = new TestRDFHandler();
		parser.setParseLocationListener(parseLocationListener);
		parser.setRDFHandler(rdfHandler);

		parser.parse(AbstractNQuadsParserUnitTest.class.getResourceAsStream("/testcases/nquads/test2.nq"),
				"http://test.base.uri");

		rdfHandler.assertHandler(400);
		parseLocationListener.assertListener(401, 1);
	}

	@Test
	public void testStatementWithInvalidLiteralContentAndIgnoreValidation()
		throws RDFHandlerException, IOException, RDFParseException
	{
		// Note: Float declare as int.
		final ByteArrayInputStream bais = new ByteArrayInputStream(
				(" "
						+ " "
						+ "\"1380.0\"^^ "
						+ " .").getBytes());
		parser.getParserConfig().set(BasicParserSettings.VERIFY_DATATYPE_VALUES, false);
		parser.getParserConfig().set(BasicParserSettings.FAIL_ON_UNKNOWN_DATATYPES, false);
		parser.parse(bais, "http://base-uri");
	}

	@Test
	public void testStatementWithInvalidLiteralContentAndStrictValidation()
		throws RDFHandlerException, IOException, RDFParseException
	{
		// Note: Float declare as int.
		final ByteArrayInputStream bais = new ByteArrayInputStream(
				(" "
						+ " "
						+ "\"1380.0\"^^ "
						+ " .").getBytes());
		parser.getParserConfig().set(BasicParserSettings.VERIFY_DATATYPE_VALUES, true);
		parser.getParserConfig().set(BasicParserSettings.FAIL_ON_UNKNOWN_DATATYPES, true);
		try {
			parser.parse(bais, "http://test.base.uri");
			Assert.fail("Expected exception when passing in a datatype using an N3 style prefix");
		}
		catch (RDFParseException rdfpe) {
			// FIXME: Fix line numbers for validation errors during the line
			// Assert.assertEquals(1, rdfpe.getLineNumber());
			// FIXME: Enable column numbers when parser supports them
			// Assert.assertEquals(152, rdfpe.getColumnNumber());
		}
	}

	@Test
	public void testStatementWithInvalidDatatypeAndIgnoreValidation()
		throws RDFHandlerException, IOException, RDFParseException
	{
		verifyStatementWithInvalidDatatype(false);
	}

	@Test
	public void testStatementWithInvalidDatatypeAndVerifyValidation()
		throws RDFHandlerException, IOException, RDFParseException
	{
		try {
			verifyStatementWithInvalidDatatype(true);
			fail("Did not find expected exception");
		}
		catch (RDFParseException rdfpe) {
			// FIXME: Fix line numbers for validation errors during the line
			// Assert.assertEquals(1, rdfpe.getLineNumber());
		}
	}

	@Test
	public void testStopAtFirstErrorStrictParsing()
		throws RDFHandlerException, IOException, RDFParseException
	{
		final ByteArrayInputStream bais = new ByteArrayInputStream(
				("    .\n"
						+ "                                     .\n" + // Line
						// with
						// error.
						"    .\n").getBytes());

		parser.getParserConfig().set(NTriplesParserSettings.FAIL_ON_NTRIPLES_INVALID_LINES, false);

		try {
			parser.parse(bais, "http://test.base.uri");
			Assert.fail("Expected exception when encountering an invalid line");
		}
		catch (RDFParseException rdfpe) {
			Assert.assertEquals(2, rdfpe.getLineNumber());
			// Assert.assertEquals(50, rdfpe.getColumnNumber());
		}
	}

	@Test
	public void testStopAtFirstErrorTolerantParsing()
		throws RDFHandlerException, IOException, RDFParseException
	{
		final ByteArrayInputStream bais = new ByteArrayInputStream(
				("    .\n"
						+ "                                     .\n" + // Line
						// with
						// error.
						"    .\n").getBytes());
		final TestRDFHandler rdfHandler = new TestRDFHandler();
		parser.setRDFHandler(rdfHandler);

		parser.getParserConfig().set(NTriplesParserSettings.FAIL_ON_NTRIPLES_INVALID_LINES, false);
		parser.getParserConfig().addNonFatalError(NTriplesParserSettings.FAIL_ON_NTRIPLES_INVALID_LINES);

		parser.parse(bais, "http://base-uri");
		rdfHandler.assertHandler(2);
		final Collection statements = rdfHandler.getStatements();
		int i = 0;
		for (Statement nextStatement : statements) {
			Assert.assertEquals("http://s" + i, nextStatement.getSubject().stringValue());
			Assert.assertEquals("http://p" + i, nextStatement.getPredicate().stringValue());
			Assert.assertEquals("http://o" + i, nextStatement.getObject().stringValue());
			Assert.assertEquals("http://g" + i, nextStatement.getContext().stringValue());
			i++;
		}
	}

	private void verifyStatementWithInvalidDatatype(boolean useDatatypeVerification)
		throws RDFHandlerException, IOException, RDFParseException
	{
		TestRDFHandler rdfHandler = new TestRDFHandler();
		parser.setRDFHandler(rdfHandler);
		parser.getParserConfig().set(BasicParserSettings.VERIFY_DATATYPE_VALUES, useDatatypeVerification);
		parser.getParserConfig().set(BasicParserSettings.FAIL_ON_UNKNOWN_DATATYPES, useDatatypeVerification);
		if (!useDatatypeVerification) {
			parser.getParserConfig().addNonFatalError(BasicParserSettings.VERIFY_DATATYPE_VALUES);
			parser.getParserConfig().addNonFatalError(BasicParserSettings.FAIL_ON_UNKNOWN_DATATYPES);
		}

		final ByteArrayInputStream bais = new ByteArrayInputStream(
				(" "
						+ " "
						+ "\"1380.0\"^^ "
						+ " .").getBytes());
		parser.parse(bais, "http://base-uri");
		rdfHandler.assertHandler(1);
	}

	private class TestParseLocationListener implements ParseLocationListener {

		private long lastRow, lastCol;

		public void parseLocationUpdate(long r, long c) {
			lastRow = r;
			lastCol = c;
		}

		private void assertListener(int row, int col) {
			Assert.assertEquals("Unexpected last row", row, lastRow);
			Assert.assertEquals("Unexpected last col", col, lastCol);
		}

	}

	private class TestRDFHandler extends StatementCollector {

		private boolean started = false;

		private boolean ended = false;

		@Override
		public void startRDF()
			throws RDFHandlerException
		{
			super.startRDF();
			started = true;
		}

		@Override
		public void endRDF()
			throws RDFHandlerException
		{
			super.endRDF();
			ended = true;
		}

		public void assertHandler(int expected) {
			Assert.assertTrue("Never started.", started);
			Assert.assertTrue("Never ended.", ended);
			Assert.assertEquals("Unexpected number of statements.", expected, getStatements().size());
		}
	}

	@Test
	public void testSupportedSettings()
		throws Exception
	{
		assertEquals(12, parser.getSupportedSettings().size());
	}

	protected abstract RDFParser createRDFParser();
}