/**
Copyright (C) SYSTAP, LLC DBA Blazegraph 2006-2016. All rights reserved.
Contact:
SYSTAP, LLC DBA Blazegraph
2501 Calvert ST NW #106
Washington, DC 20008
licenses@blazegraph.com
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
package com.bigdata.bop.solutions;
import java.util.TimeZone;
import javax.xml.datatype.DatatypeConfigurationException;
import javax.xml.datatype.DatatypeFactory;
import junit.framework.TestCase2;
import org.openrdf.model.URI;
import com.bigdata.rdf.internal.IDatatypeURIResolver;
import com.bigdata.rdf.internal.IV;
import com.bigdata.rdf.internal.VTE;
import com.bigdata.rdf.internal.XSD;
import com.bigdata.rdf.internal.impl.TermId;
import com.bigdata.rdf.internal.impl.bnode.NumericBNodeIV;
import com.bigdata.rdf.internal.impl.bnode.SidIV;
import com.bigdata.rdf.internal.impl.extensions.DateTimeExtension;
import com.bigdata.rdf.internal.impl.literal.XSDBooleanIV;
import com.bigdata.rdf.internal.impl.literal.XSDNumericIV;
import com.bigdata.rdf.model.BigdataBNode;
import com.bigdata.rdf.model.BigdataLiteral;
import com.bigdata.rdf.model.BigdataURI;
import com.bigdata.rdf.model.BigdataValue;
import com.bigdata.rdf.model.BigdataValueFactory;
import com.bigdata.rdf.model.BigdataValueFactoryImpl;
import com.bigdata.rdf.spo.SPO;
/**
* Test suite for {@link IVComparator}.
*
* @author <a href="mailto:thompsonbry@users.sourceforge.net">Bryan Thompson</a>
* @version $Id$
*/
public class TestIVComparator extends TestCase2 {
public TestIVComparator() {
}
public TestIVComparator(String name) {
super(name);
}
/**
* Vocabulary for tests in the outer test suite.
*/
private static class V {
final String namespace = "test";
private long termId = 1L;
final BigdataValueFactory f = BigdataValueFactoryImpl
.getInstance(namespace);
/*
* Literals
*/
final IV<BigdataLiteral,Void> noninline_plain_lit1 = new TermId<BigdataLiteral>(VTE.LITERAL,termId++);
final IV<BigdataLiteral,Void> noninline_plain_lit2 = new TermId<BigdataLiteral>(VTE.LITERAL,termId++);
final IV<BigdataLiteral,Void> noninline_languageCode_en_lit1 = new TermId<BigdataLiteral>(VTE.LITERAL,termId++);
final IV<BigdataLiteral,Void> noninline_languageCode_en_lit2 = new TermId<BigdataLiteral>(VTE.LITERAL,termId++);
final IV<BigdataLiteral,Void> noninline_languageCode_de_lit1 = new TermId<BigdataLiteral>(VTE.LITERAL,termId++);
final IV<BigdataLiteral,Void> noninline_languageCode_de_lit2 = new TermId<BigdataLiteral>(VTE.LITERAL,termId++);
final IV<BigdataLiteral,Void> noninline_xsd_string_lit1 = new TermId<BigdataLiteral>(VTE.LITERAL,termId++);
final IV<BigdataLiteral,Void> noninline_xsd_string_lit2 = new TermId<BigdataLiteral>(VTE.LITERAL,termId++);
final IV<BigdataLiteral, Number> inline_xsd_byte1 = new XSDNumericIV<BigdataLiteral>((byte) 1);
final IV<BigdataLiteral, Number> inline_xsd_int1 = new XSDNumericIV<BigdataLiteral>(1);
final IV<BigdataLiteral, Boolean> inline_xsd_boolean_true = new XSDBooleanIV<BigdataLiteral>(true);
final IV<BigdataLiteral, Boolean> inline_xsd_boolean_false = new XSDBooleanIV<BigdataLiteral>(false);
final IV<BigdataLiteral, Number> inline_xsd_dateTime1 = new XSDNumericIV<BigdataLiteral>(1);
/*
* URIs
*/
final IV<BigdataURI, Void> noninline_uri1 = new TermId<BigdataURI>(VTE.URI, termId++);
final IV<BigdataURI, Void> noninline_uri2 = new TermId<BigdataURI>(VTE.URI, termId++);
/*
* Blank nodes.
*/
final IV<BigdataBNode,Integer> inline_bnode1 = new NumericBNodeIV<BigdataBNode>(1);
final IV<BigdataBNode,Integer> inline_bnode2 = new NumericBNodeIV<BigdataBNode>(2);
final SidIV<BigdataBNode> sid1 = new SidIV<BigdataBNode>(new SPO(
noninline_uri1, noninline_uri2, noninline_plain_lit1));
final SidIV<BigdataBNode> sid2 = new SidIV<BigdataBNode>(new SPO(
inline_bnode1, noninline_uri2, inline_xsd_dateTime1));
public V() {
final DatatypeFactory df;
try {
df = DatatypeFactory.newInstance();
} catch (DatatypeConfigurationException e) {
throw new RuntimeException(e);
}
final IDatatypeURIResolver resolver = new IDatatypeURIResolver() {
public BigdataURI resolve(final URI uri) {
final BigdataURI buri = f.createURI(uri.stringValue());
buri.setIV(new TermId<BigdataLiteral>(VTE.URI,termId++));
return buri;
}
};
final DateTimeExtension<BigdataValue> dtExt = new DateTimeExtension<BigdataValue>(
resolver, TimeZone.getTimeZone("GMT"));
dtExt.createIV(f.createLiteral(df
.newXMLGregorianCalendar("2001-10-26T21:32:52.126Z")));
dtExt.createIV(f.createLiteral("2001-10-26", XSD.DATE));
dtExt.createIV(f.createLiteral("21:32:52.126Z", XSD.TIME));
noninline_plain_lit1.setValue(f.createLiteral("bigdata"));
noninline_plain_lit2.setValue(f.createLiteral("systap"));
noninline_languageCode_en_lit1.setValue(f.createLiteral("bigdata","en"));
noninline_languageCode_en_lit2.setValue(f.createLiteral("systap","en"));
noninline_languageCode_de_lit1.setValue(f.createLiteral("bigdata","de"));
noninline_languageCode_de_lit2.setValue(f.createLiteral("systap","de"));
noninline_xsd_string_lit1.setValue(f.createLiteral("bigdata",XSD.STRING));
noninline_xsd_string_lit2.setValue(f.createLiteral("systap",XSD.STRING));
noninline_uri1.setValue(f.createURI("http://www.bigdata.com/"));
noninline_uri2.setValue(f.createURI("http://www.bigdata.com/blog/"));
}
}
/**
* Unit test verifies that an unbound value (a <code>null</code>) is LT
* anything else.
*/
public void test_null_lt_anything() {
final V v = new V();
final IVComparator c = new IVComparator();
assertLT(c.compare(null, v.inline_bnode1));
assertLT(c.compare(null, v.noninline_uri1));
assertLT(c.compare(null, v.inline_xsd_byte1));
assertLT(c.compare(null, v.sid1));
}
/**
* Unit test verifies the broad ordering which puts unbound values LT blank
* nodes LT uris LT literals.
*/
public void test_null_bnode_uri_literal() {
final V v = new V();
final IVComparator c = new IVComparator();
assertLT(c.compare(null, v.inline_bnode1));
assertLT(c.compare(null, v.sid2));
assertLT(c.compare(v.inline_bnode1, v.noninline_uri1));
assertLT(c.compare(v.sid2, v.noninline_uri1));
assertLT(c.compare(v.noninline_uri1, v.inline_xsd_byte1));
}
/**
* Unit test verifies that things compare equal to themselves.
*/
public void test_equalToSelf() {
final V v = new V();
final IVComparator c = new IVComparator();
assertEQ(c.compare(null,null));
assertEQ(c.compare(v.sid1, v.sid1));
assertEQ(c.compare(v.inline_bnode1, v.inline_bnode1));
assertEQ(c.compare(v.noninline_uri1, v.noninline_uri1));
assertEQ(c.compare(v.inline_xsd_byte1, v.inline_xsd_byte1));
}
/**
* Unit test of the relative ordering of blank nodes (they are ordered by
* the {@link IV}'s natural order in order to cause the same {@link IV}s to
* be groups).
*
* @see <a href="http://www.openrdf.org/issues/browse/SES-873"> Order the
* same Blank Nodes together in ORDER BY</a>
*/
public void test_bnode_ordering() {
final V v = new V();
final IVComparator c = new IVComparator();
// These are not the same bnode.
assertNotSame(v.inline_bnode1, v.inline_bnode2);
assertNotSame(v.sid1, v.sid2);
// The do not compare as EQ.
assertTrue(0 != c.compare(v.inline_bnode1, v.inline_bnode2));
assertTrue(0 != c.compare(v.sid1, v.inline_bnode2));
assertTrue(0 != c.compare(v.sid1, v.sid2));
assertTrue(0 != c.compare(v.inline_bnode1, v.sid2));
if (v.inline_bnode1.compareTo(v.inline_bnode2) < 0) {
assertLT(c.compare(v.inline_bnode1, v.inline_bnode2));
} else {
assertGT(c.compare(v.inline_bnode1, v.inline_bnode2));
}
if (v.sid1.compareTo(v.sid2) < 0) {
assertLT(c.compare(v.sid1, v.sid2));
} else {
assertGT(c.compare(v.sid1, v.sid2));
}
/*
* Comparisons between SIDs and blank nodes. Order SIDs after normal
* blank nodes.
*/
// if (v.inline_bnode1.compareTo(v.sid1) < 0) {
assertLT(c.compare(v.inline_bnode1, v.sid1));
// } else {
// assertGT(c.compare(v.inline_bnode1, v.sid1));
// }
// if (v.sid2.compareTo(v.inline_bnode2) < 0) {
// assertLT(c.compare(v.sid2, v.inline_bnode2));
// } else {
assertGT(c.compare(v.sid2, v.inline_bnode2));
// }
}
/**
* Unit test of the relative ordering of URIs.
*/
public void test_uri_ordering() {
final V v = new V();
final IVComparator c = new IVComparator();
assertLT(c.compare(v.noninline_uri1, v.noninline_uri2));
}
/**
* Unit test of the broad ordering of literals (plain LT language code LT
* datatype).
*/
public void test_literal_ordering_plain_languageCode_datatype() {
final V v = new V();
final IVComparator c = new IVComparator();
// plain LT languageCode
assertLT(c.compare(v.noninline_plain_lit1, v.noninline_languageCode_de_lit1));
// languageCode LT datatype
assertLT(c.compare(v.noninline_plain_lit1, v.noninline_xsd_string_lit1));
}
/**
* Unit test of order among plain literals.
*/
public void test_plain_literal_ordering() {
final V v = new V();
final IVComparator c = new IVComparator();
// lexiographic ordering.
assertLT(c.compare(v.noninline_plain_lit1, v.noninline_plain_lit2));
}
/**
* Unit test of order for language code literals having different language
* codes. The ordering is lexiographic by language code and then by label
* within each language code.
*/
public void test_languageCode_ordering() {
final V v = new V();
final IVComparator c = new IVComparator();
// lexiographic ordering by language code.
assertLT(c.compare(v.noninline_languageCode_de_lit1, v.noninline_languageCode_en_lit1));
// lexiographic ordering by label within language code.
assertLT(c.compare(v.noninline_languageCode_de_lit1, v.noninline_languageCode_de_lit2));
}
/**
* Unit test verifies the order imposed across the different datatypes (but
* not within those datatypes).
* <p>
* Note: openrdf imposes the following type precedence:
*
* <pre>
* - simple literal
* - numeric
* - xsd:boolean
* - xsd:dateTime
* - xsd:string
* - RDF term (equal and unequal only)
* </pre>
*/
public void test_datatype_ordering() {
final V v = new V();
final IVComparator c = new IVComparator();
// plain literal LT numeric
assertLT(c.compare(v.noninline_plain_lit1, v.inline_xsd_int1));
// numeric LT boolean
assertLT(c.compare(v.inline_xsd_int1, v.inline_xsd_boolean_true));
// assertLT(c.compare(v.inline_xsd_boolean_true, v.inline_xsd_dateTime1));
assertLT(c.compare(v.inline_xsd_dateTime1, v.noninline_xsd_string_lit1));
}
// /**
// * Unit test comparing different kinds of inline and non-inline {@link IV}s.
// */
// public void test_inline_with_noninline() {
//
// final V v = new V();
//
// final IVComparator c = new IVComparator();
//
// fail("write test");
//
// }
private void assertLT(final int ret) {
assertTrue(ret < 0);
}
private void assertGT(final int ret) {
assertTrue(ret > 0);
}
private void assertEQ(final int ret) {
assertTrue(ret == 0);
}
}