/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.apache.jena.sparql.expr;

import static org.junit.Assert.*;

import java.math.BigDecimal ;
import java.util.*;

import org.apache.jena.datatypes.xsd.XSDDatatype ;
import org.apache.jena.graph.Node ;
import org.apache.jena.graph.NodeFactory ;
import org.apache.jena.query.*;
import org.apache.jena.rdf.model.Model;
import org.apache.jena.rdf.model.ModelFactory;
import org.apache.jena.sparql.expr.nodevalue.XSDFuncOp ;
import org.apache.jena.sparql.sse.SSE;
import org.apache.jena.sparql.util.NodeCmp;
import org.apache.jena.sparql.util.NodeFactoryExtra ;
import org.junit.AfterClass ;
import org.junit.BeforeClass ;
import org.junit.Test ;

/** Break expression testing suite into parts
 * @see TestExpressions
 * @see TestExprLib
 * @see TestNodeValue
 */
public class TestNodeValue
{
    static final double doubleAccuracy = 0.00000001d ;
    static boolean warningSetting ;

    @BeforeClass public static void beforeClass() {
        warningSetting = NodeValue.VerboseWarnings ;
        NodeValue.VerboseWarnings = false ;
    }

    @AfterClass public static void afterClass() {
        NodeValue.VerboseWarnings = warningSetting ;
    }

    @Test
    public void testInt1() {
        NodeValue v = NodeValue.makeInteger(5);
        assertTrue("Not a number: " + v, v.isNumber());
        assertTrue("Not an integer: " + v, v.isInteger());
        assertFalse("Is a node: " + v, v.hasNode());
    }

    @Test
    public void testInt2() {
        NodeValue v = NodeValue.makeNodeInteger(5);
        assertTrue("Not a number: " + v, v.isNumber());
        assertTrue("Not an integer: " + v, v.isInteger());
        assertTrue("Not a node: " + v, v.hasNode());
    }

    @Test
    public void testInt3() {
        NodeValue v1 = NodeValue.makeNodeInteger(5);
        NodeValue v2 = NodeValue.makeInteger(5);
        assertTrue("Not same integer: " + v1 + " & " + v2, v1.getInteger().equals(v2.getInteger()));
    }

    @Test
    public void testFloat1() {
        NodeValue v = NodeValue.makeFloat(5);
        assertTrue("Not a number: " + v, v.isNumber());
        assertTrue("Not a float: " + v, v.isFloat());
        assertTrue("Float not a double: " + v, v.isDouble());
        assertFalse("No node: " + v, v.hasNode());
    }

    @Test
    public void testFloat2() {
        NodeValue v = NodeValue.makeNodeFloat(5);
        assertTrue("Not a number: " + v, v.isNumber());
        assertTrue("Not a float: " + v, v.isDouble());
        assertTrue("Float not a double: " + v, v.isDouble());
        assertTrue("Not a node: " + v, v.hasNode());
    }

    @Test
    public void testFloat3() {
        NodeValue v1 = NodeValue.makeNodeFloat(5.7f);
        NodeValue v2 = NodeValue.makeFloat(5.7f);
        assertTrue("Not same float: " + v1 + " & " + v2, v1.getFloat() == v2.getFloat());
        assertTrue("Not same float as double: " + v1 + " & " + v2, v1.getDouble() == v2.getDouble());
    }

    @Test
    public void testDouble1() {
        NodeValue v = NodeValue.makeDouble(5);
        assertTrue("Not a number: " + v, v.isNumber());
        assertTrue("Not a double: " + v, v.isDouble());
        assertFalse("No node: " + v, v.hasNode());
    }

    @Test
    public void testDouble2() {
        NodeValue v = NodeValue.makeNodeDouble(5);
        assertTrue("Not a number: " + v, v.isNumber());
        assertTrue("Not a double: " + v, v.isDouble());
        assertTrue("Not a node: " + v, v.hasNode());
    }

    @Test
    public void testDouble3() {
        NodeValue v1 = NodeValue.makeNodeDouble(5.7);
        NodeValue v2 = NodeValue.makeDouble(5.7);
        assertTrue("Not same double: " + v1 + " & " + v2, v1.getDouble() == v2.getDouble());
    }

    @Test
    public void testDecimal1() {
        NodeValue v = NodeValue.makeDecimal(new BigDecimal("1.3"));
        assertTrue("Not a number: " + v, v.isNumber());
        assertTrue("Not a double: " + v, v.isDecimal());
        assertFalse("Is a node: " + v, v.hasNode());
    }

    @Test
    public void testDecimal2() {
        NodeValue v = NodeValue.makeNodeDecimal("1.3");
        assertTrue("Not a number: " + v, v.isNumber());
        assertTrue("Not a double: " + v, v.isDecimal());
        assertTrue("Not a node: " + v, v.hasNode());
    }

    @Test
    public void testDecimal3() {
        NodeValue v1 = NodeValue.makeDecimal(new BigDecimal("1.3"));
        NodeValue v2 = NodeValue.makeNodeDecimal("1.3");
        assertTrue("Not same decimal: " + v1 + " & " + v2, v1.getDecimal().compareTo(v2.getDecimal()) == 0);
        assertEquals("Not same decimal by equals: " + v1 + " & " + v2, v1, v2);
    }

    @Test
    public void testDateTime1() {
        Calendar cal = new GregorianCalendar();
        cal.setTimeZone(TimeZone.getTimeZone("GMT"));
        // Clear/ set all fields (milliseconds included).
        cal.setTimeInMillis(0);
        cal.set(2005, 01, 18, 20, 39, 10); // NB Months from 0, not 1

        NodeValue v = NodeValue.makeDateTime(cal);
        assertTrue("Not a dateTime: " + v, v.isDateTime());
        assertFalse("A date: " + v, v.isDate());
        // DateTimes always have nodes because we used that to parse the thing.
    }

    @Test
    public void testDateTime2() {
        NodeValue v = NodeValue.makeNodeDateTime("2005-02-18T20:39:10Z");
        assertTrue("Not a dateTime: " + v, v.isDateTime());
        assertFalse("A date: " + v, v.isDate());
        assertTrue("Not a node: " + v, v.hasNode());
    }

    @Test
    public void testDateTime3() {
        NodeValue v1 = NodeValue.makeDateTime("2005-02-18T20:39:10Z");
        NodeValue v2 = NodeValue.makeNodeDateTime("2005-02-18T20:39:10Z");
        assertEquals("Not Calendar.equals: ", v1.getDateTime(), v2.getDateTime());
    }

    @Test
    public void testDateTime4() {
        Calendar cal1 = new GregorianCalendar();
        cal1.setTimeZone(TimeZone.getTimeZone("GMT"));
        // Clear/ set all fields (milliseconds included).
        cal1.setTimeInMillis(0);
        cal1.set(2005, 01, 18, 20, 39, 10); // NB Months from 0, not 1

        NodeValue v = NodeValue.makeNode("2005-02-18T20:39:10Z", XSDDatatype.XSDdateTime);
        assertTrue("Not a dateTime: " + v, v.isDateTime());
        assertFalse("A date: " + v, v.isDate());
        assertTrue("Not a node: " + v, v.hasNode());
        Calendar cal2 = v.getDateTime().toGregorianCalendar();
        assertEquals("Not equal: " + v, 0, cal1.compareTo(cal2));
    }

    @Test
    public void testDateTime5() {
        boolean b = NodeValue.VerboseWarnings;
        try {
            NodeValue.VerboseWarnings = false;
            // Illegal lexical for a dateTime.
            NodeValue v = NodeValue.makeNode("2005-02-18", XSDDatatype.XSDdateTime);
            assertFalse("Date!: " + v, v.isDate());
            assertFalse("Datetime!: " + v, v.isDateTime());
        }
        finally {
            NodeValue.VerboseWarnings = b;
        }
    }

    @Test
    public void testDateTime6() {
        NodeValue v0 = NodeValue.makeDateTime("2005-02-18T20:39:10Z");
        NodeValue v1 = NodeValue.makeDateTime("2005-02-18T20:39:10.0Z");
        NodeValue v2 = NodeValue.makeDateTime("2005-02-18T20:39:10.00Z");
        NodeValue v3 = NodeValue.makeDateTime("2005-02-18T20:39:10.000Z");
        assertEquals("Not Calendar.equals: ", v0.getDateTime(), v1.getDateTime());
        assertEquals("Not Calendar.equals: ", v0.getDateTime(), v2.getDateTime());
        assertEquals("Not Calendar.equals: ", v0.getDateTime(), v3.getDateTime());
    }

    @Test
    public void testDateTime7() {
        NodeValue v0 = NodeValue.makeDateTime("2005-02-18T20:39:10Z");
        NodeValue v1 = NodeValue.makeDateTime("2005-02-18T20:39:10.001Z");
        assertNotSame("Calendar.equals: ", v0.getDateTime(), v1.getDateTime());
    }

    @Test
    public void testDateTime8() {
        NodeValue v0 = NodeValue.makeDateTime("2005-02-18T20:39:10-05:00");
        NodeValue v1 = NodeValue.makeDateTime("2005-02-18T17:39:10.000-08:00");
        assertEquals("Not Calendar.equals: ", v0.getDateTime(), v1.getDateTime());
    }

    private static NodeValue parse(String nodeString) {
        Node n = SSE.parseNode(nodeString);
        NodeValue nv = NodeValue.makeNode(n);
        return nv;
    }

    @Test
    public void testDateTimeStamp1() {
        // xsd:dateTimeStamp is a derived datatype of xsd:dateTime.
        NodeValue nv = parse("'2000-01-01T00:00:00+00:00'^^xsd:dateTimeStamp");
        assertTrue(nv.isDateTime());
        assertFalse(nv.isDate());
    }

    @Test
    public void testDate1() {
        Calendar cal = new GregorianCalendar();
        cal.setTimeZone(TimeZone.getTimeZone("GMT"));
        // Clear/ set all fields (milliseconds included).
        cal.setTimeInMillis(0);
        // NB Months from 0, not 1
        // For a date, must be time = 00:00:00
        cal.set(2005, 01, 18, 0, 0, 0);

        NodeValue v = NodeValue.makeDate(cal);
        assertTrue("Not a date: " + v, v.isDate());
        assertFalse("A dateTime: " + v, v.isDateTime());
        // DateTimes always have nodes because we used that to parse the thing.
    }

    @Test
    public void testDate2() {
        NodeValue v = NodeValue.makeNodeDate("2005-02-18");
        assertTrue("Not a date: " + v, v.isDate());
        assertFalse("A dateTime: " + v, v.isDateTime());
        assertTrue("Not a node: " + v, v.hasNode());
    }

    @Test
    public void testDate3() {
        NodeValue v1 = NodeValue.makeDate("2005-02-18+01:00");
        NodeValue v2 = NodeValue.makeNodeDate("2005-02-18+01:00");
        assertEquals("Not Calendar.equals: ", v1.getDateTime(), v2.getDateTime());
    }

    @Test
    public void testDate4() {
        Calendar cal1 = new GregorianCalendar();
        cal1.setTimeZone(TimeZone.getTimeZone("GMT"));
        // Clear/ set all fields (milliseconds included).
        cal1.setTimeInMillis(0);
        // Must be ",0,0,0"
        cal1.set(2005, 01, 18, 0, 0, 0); // NB Months from 0, not 1

        NodeValue v = NodeValue.makeNode("2005-02-18Z", XSDDatatype.XSDdate);
        assertTrue("Not a date: " + v, v.isDate());
        assertFalse("A dateTime: " + v, v.isDateTime());
        assertTrue("Not a node: " + v, v.hasNode());
        Calendar cal2 = v.getDateTime().toGregorianCalendar();
        assertEquals("Not equal: " + v, 0, cal1.compareTo(cal2));
    }

    @Test
    public void testDate5() {
        boolean b = NodeValue.VerboseWarnings;
        try {
            NodeValue.VerboseWarnings = false;
            // Illegal lexical for a date.
            NodeValue v = NodeValue.makeNode("2005-02-18T20:39:10Z", XSDDatatype.XSDdate);
            assertFalse("Datetime!: " + v, v.isDateTime());
            assertFalse("Date!: " + v, v.isDate());
        }
        finally {
            NodeValue.VerboseWarnings = b;
        }
    }

    @Test
    public void testNodeInt1() {
        NodeValue v = NodeValue.makeNode("57", XSDDatatype.XSDinteger);
        assertTrue("Not a number: " + v, v.isNumber());
        assertTrue("Not an integer: " + v, v.isInteger());
        assertTrue("Not a node: " + v, v.hasNode());
    }

    @Test
    public void testNodeInt2() {
        NodeValue v = NodeValue.makeNode("57", XSDDatatype.XSDdouble);
        assertTrue("Not a number: " + v, v.isNumber());
        assertTrue("Not a double: " + v, v.isDouble());
        assertTrue("Not a node: " + v, v.hasNode());
    }

    @Test
    public void testNodeInt3() {
        NodeValue v = NodeValue.makeNode("57", XSDDatatype.XSDinteger);
        assertTrue("Not a number: " + v, v.isNumber());
        assertTrue("Not an integer: " + v, v.isInteger());
        assertTrue("Not a node: " + v, v.hasNode());
        String actualStr = v.asQuotedString();
        assertEquals("Print form mismatch", "57", actualStr);
    }

    @Test
    public void testNodeInt4() {
        NodeValue v = NodeValue.makeNodeInteger(18);
        assertTrue("Not a number: " + v, v.isNumber());
        assertTrue("Not an integer: " + v, v.isInteger());
        assertTrue("Not a node: " + v, v.hasNode());
        String actualStr = v.asQuotedString();
        assertEquals("Print form mismatch", "18", actualStr);
    }

    @Test
    public void testNodeInt5() {
        // Legal as a bare integer but not canonical form
        NodeValue v = NodeValue.makeNodeInteger("018");
        assertTrue("Not a number: " + v, v.isNumber());
        assertTrue("Not an integer: " + v, v.isInteger());
        assertTrue("Not a node: " + v, v.hasNode());
        String actualStr = v.asQuotedString();
        assertEquals("Print form mismatch", "018", actualStr);
    }

    @Test
    public void testNodeInt6() {
        // Leading/trail whitespace.
        NodeValue v = NodeValue.makeNodeInteger(" 18");
        assertTrue("Not a number: " + v, v.isNumber());
        assertTrue("Not an integer: " + v, v.isInteger());
        assertTrue("Not a node: " + v, v.hasNode());
    }

    @Test
    public void testNodeInt7() {
        // Leading/trail whitespace.
        NodeValue v = NodeValue.makeNodeInteger(" 18 ");
        assertTrue("Not a number: " + v, v.isNumber());
        assertTrue("Not an integer: " + v, v.isInteger());
        assertTrue("Not a node: " + v, v.hasNode());
    }

    @Test
    public void testNodeInt8() {
        // Internal whitespace. Not a number.
        NodeValue v = NodeValue.makeNodeInteger("1 8");
        assertFalse("A number!: " + v, v.isNumber());
        assertFalse("An integer!: " + v, v.isInteger());
        assertTrue("Not a node: " + v, v.hasNode());
    }


    @Test
    public void testNodeFloat1() {
        // There is no SPARQL representation in short form of a float.
        NodeValue v = NodeValue.makeNode("57.0", XSDDatatype.XSDfloat);
        assertTrue("Not a number: " + v, v.isNumber());
        assertTrue("Not a float: " + v, v.isFloat());
        assertTrue("Not a double(float): " + v, v.isDouble());
        assertTrue("Not a node: " + v, v.hasNode());
        String actualStr = v.asQuotedString();

        assertEquals("Print form mismatch", "\"57.0\"^^<" + XSDDatatype.XSDfloat.getURI() + ">", actualStr);
    }

    @Test
    public void testNodeFloat2() {
        // WhiteSpace facet
        NodeValue v = NodeValue.makeNode(" 57.0 ", XSDDatatype.XSDfloat);
        assertTrue("Not a number: " + v, v.isNumber());
        assertTrue("Not a float: " + v, v.isFloat());
        assertTrue("Not a double(float): " + v, v.isDouble());
        assertTrue("Not a node: " + v, v.hasNode());
        String actualStr = v.asQuotedString();

        assertEquals("Print form mismatch", "\" 57.0 \"^^<" + XSDDatatype.XSDfloat.getURI() + ">", actualStr);
    }


    @Test
    public void testNodeDouble1() {
        // Note input form is legal and canonical as a lexical form double
        NodeValue v = NodeValue.makeNode("57.0e0", XSDDatatype.XSDdouble);
        assertTrue("Not a number: " + v, v.isNumber());
        assertTrue("Not a double: " + v, v.isDouble());
        assertTrue("Not a node: " + v, v.hasNode());
        String actualStr = v.asQuotedString();

        assertEquals("Print form mismatch", "57.0e0", actualStr) ;
//                     "\"57\"^^<"+XSDDatatype.XSDdouble.getURI()+">",
//                     actualStr);
    }

    @Test
    public void testNodeDouble2() {
        // Note input form is not legal as a lexical form double
        NodeValue v = NodeValue.makeNode("57", XSDDatatype.XSDdouble);
        assertTrue("Not a number: " + v, v.isNumber());
        assertTrue("Not a double: " + v, v.isDouble());
        assertTrue("Not a node: " + v, v.hasNode());
        String actualStr = v.asQuotedString();

        assertEquals("Print form mismatch", "\"57\"^^<" + XSDDatatype.XSDdouble.getURI() + ">", actualStr);
    }

    @Test
    public void testNodeDouble3() {
        // Note input form is legal but not canonical as a bare FP
        NodeValue v = NodeValue.makeNode("057.0e0", XSDDatatype.XSDdouble);
        assertTrue("Not a number: " + v, v.isNumber());
        assertTrue("Not a double: " + v, v.isDouble());
        assertTrue("Not a node: " + v, v.hasNode());
        String actualStr = v.asQuotedString();

        assertEquals("Print form mismatch", "057.0e0", actualStr);
    }

    @Test
    public void testNodeDouble4() {
        // Leading/trail whitespace.
        NodeValue v = NodeValue.makeNode(" 057.0e0 ", XSDDatatype.XSDdouble);
        assertTrue("Not a number: " + v, v.isNumber());
        assertTrue("Not a double: " + v, v.isDouble());
        assertTrue("Not a node: " + v, v.hasNode());
    }

    @Test
    public void testNodeBool1() {
        NodeValue v = NodeValue.makeNode("true", XSDDatatype.XSDboolean);
        assertTrue("Not a boolean: " + v, v.isBoolean());
        assertTrue("Not a node: " + v, v.hasNode());
        assertTrue("Not satisfied: " + v, v.getBoolean());
    }

    @Test
    public void testNodeBool2() {
        NodeValue v = NodeValue.makeNode("false", XSDDatatype.XSDboolean);
        assertTrue("Not a boolean: " + v, v.isBoolean());
        assertTrue("Not a node: " + v, v.hasNode());
        assertFalse("Satisfied: " + v, v.getBoolean());
    }

    @Test
    public void testNodeBool3() {
        NodeValue v = NodeValue.makeBoolean(true);
        assertTrue("Not a boolean: " + v, v.isBoolean());
        // assertTrue("Not a node: "+v, v.hasNode()) ;
        assertTrue("Not true: " + v, v.getBoolean());
        assertTrue("Not true: " + v, XSDFuncOp.booleanEffectiveValue(v));
    }

    @Test
    public void testNodeBool4() {
        NodeValue v = NodeValue.makeBoolean(false);
        assertTrue("Not a boolean: " + v, v.isBoolean());
        // assertTrue("Not a node: "+v, v.hasNode()) ;
        assertFalse("Not false: " + v, v.getBoolean());
        assertFalse("Not false: " + v, XSDFuncOp.booleanEffectiveValue(v));
    }

    @Test
    public void testNodeDateTime1() {
        NodeValue v = NodeValue.makeNode("2021-11-08T20:37:25+01:00", XSDDatatype.XSDdateTime);
        assertTrue("Not a dateTime: " + v, v.isDateTime());
    }

    @Test
    public void testNodeDateTime2() {
        NodeValue v = NodeValue.makeNode("\t2021-11-08T20:37:26+01:00\t", XSDDatatype.XSDdateTime);
        assertTrue("Not a dateTime: " + v, v.isDateTime());
    }

    @Test
    public void testNodeGYear1() {
        NodeValue v = NodeValue.makeNode("2021", XSDDatatype.XSDgYear);
        assertTrue("Not a gYear: " + v, v.isGYear());
    }

    @Test
    public void testNodeGYear2() {
        NodeValue v = NodeValue.makeNode("\t2021\t", XSDDatatype.XSDgYear);
        assertTrue("Not a gYear: " + v, v.isGYear());
    }

    @Test
    public void testNodeDuration1() {
        NodeValue v = NodeValue.makeNode("P1Y", XSDDatatype.XSDyearMonthDuration);
        assertTrue("Not a yearMonthDuration: " + v, v.isYearMonthDuration());
        assertTrue("Not a duration: " + v, v.isDuration());
    }

    @Test
    public void testNodeDuration2() {
        NodeValue v = NodeValue.makeNode("P1Y  ", XSDDatatype.XSDduration);
        assertTrue("Not a yearMonthDuration: " + v, v.isDuration());
    }

    @Test
    public void testNodeDuration3() {
        // Internal whiespace -> invalide.
        NodeValue v = NodeValue.makeNode("P1Y  10S", XSDDatatype.XSDduration);
        assertFalse("Is a valid duration: " + v, v.isDuration());
    }

    static NodeValue make(String str) {
        Node n = NodeFactoryExtra.parseNode(str);
        NodeValue nv = NodeValue.makeNode(n);
        return nv;
    }

    @Test public void gregorian_01() {
        NodeValue nv = make("'1999'^^xsd:gYear") ;

        assertTrue(nv.isGYear()) ;
        assertFalse(nv.isGYearMonth()) ;
        assertFalse(nv.isGMonth()) ;
        assertFalse(nv.isGMonthDay()) ;
        assertFalse(nv.isGDay()) ;
    }

    @Test public void gregorian_02() {
        NodeValue nv = make("'1999-01'^^xsd:gYearMonth") ;

        assertFalse(nv.isGYear()) ;
        assertTrue(nv.isGYearMonth()) ;
        assertFalse(nv.isGMonth()) ;
        assertFalse(nv.isGMonthDay()) ;
        assertFalse(nv.isGDay()) ;
    }

    @Test public void gregorian_03() {
        NodeValue nv = make("'--01'^^xsd:gMonth") ;

        assertFalse(nv.isGYear()) ;
        assertFalse(nv.isGYearMonth()) ;
        assertTrue(nv.isGMonth()) ;
        assertFalse(nv.isGMonthDay()) ;
        assertFalse(nv.isGDay()) ;
    }

    @Test public void gregorian_04() {
        NodeValue nv = make("'--01-30'^^xsd:gMonthDay") ;

        assertFalse(nv.isGYear()) ;
        assertFalse(nv.isGYearMonth()) ;
        assertFalse(nv.isGMonth()) ;
        assertTrue(nv.isGMonthDay()) ;
        assertFalse(nv.isGDay()) ;
    }

    @Test public void gregorian_05() {
        NodeValue nv = make("'---30'^^xsd:gDay") ;

        assertFalse(nv.isGYear()) ;
        assertFalse(nv.isGYearMonth()) ;
        assertFalse(nv.isGMonth()) ;
        assertFalse(nv.isGMonthDay()) ;
        assertTrue(nv.isGDay()) ;
    }

    @Test public void langString_01() {

        NodeValue nv = make("''@en") ;
        assertFalse(nv.isString()) ;
        assertTrue(nv.isLangString()) ;
        assertEquals("en", nv.getLang()) ;
        assertEquals("", nv.getString()) ;
        assertEquals("", nv.asString()) ;
    }

    @Test public void langString_02() {
        NodeValue nv = make("'not empty'@cy") ;
        assertFalse(nv.isString()) ;
        assertTrue(nv.isLangString()) ;
        assertEquals("cy", nv.getLang()) ;
        assertEquals("not empty", nv.getString()) ;
        assertEquals("not empty", nv.asString()) ;
    }

    @Test
    public void testBadLexcial1() {
        boolean b = NodeValue.VerboseWarnings;
        try {
            NodeValue.VerboseWarnings = false;
            NodeValue v = NodeValue.makeNodeInteger("abc");
            assertFalse("Good integer: " + v, v.isInteger());
            assertFalse("Good number: " + v, v.isNumber());
        }
        finally {
            NodeValue.VerboseWarnings = b;
        }
    }

    @Test
    public void testBadLexcial2() {
        boolean b = NodeValue.VerboseWarnings;
        try {
            NodeValue.VerboseWarnings = false;
            NodeValue v = NodeValue.makeNodeInteger("1.8");
            assertFalse("Good integer: " + v, v.isInteger());
            assertFalse("Good number: " + v, v.isNumber());
        }
        finally {
            NodeValue.VerboseWarnings = b;
        }
    }

    @Test
    public void testBadLexcial3() {
        boolean b = NodeValue.VerboseWarnings;
        try {
            NodeValue.VerboseWarnings = false;
            NodeValue v = NodeValue.makeDateTime("2005-10-34T00:00:01Z");
            assertFalse("Good date: " + v, v.isDateTime());
        }
        finally {
            NodeValue.VerboseWarnings = b;
        }
    }

    @Test
    public void testBadLexcial4() {
        boolean b = NodeValue.VerboseWarnings;
        try {
            // Has a space
            String s = "2005-10-14T 09:30:23+01:00";
            NodeValue.VerboseWarnings = false;
            NodeValue v1 = NodeValue.makeDateTime(s);
            assertFalse("Good date: " + v1, v1.isDateTime());
            s = s.replaceAll(" ", "");
            NodeValue v2 = NodeValue.makeDateTime(s);
            assertTrue("Bad date: " + v2, v2.isDateTime());
        }
        finally {
            NodeValue.VerboseWarnings = b;
        }
    }

    // Effective boolean value rules.
    // boolean: value of the boolean
    // string: length(string) > 0 is true
    // numeric: number != Nan && number != 0 is true
    // http://www.w3.org/TR/xquery/#dt-ebv

    @Test
    public void testEBV1() {
        assertTrue("Not a boolean", NodeValue.TRUE.isBoolean());
        assertTrue("Not true", NodeValue.TRUE.getBoolean());
        assertTrue("Not true", XSDFuncOp.booleanEffectiveValue(NodeValue.TRUE));
    }

    @Test
    public void testEBV2() {
        assertTrue("Not a boolean", NodeValue.FALSE.isBoolean());
        assertFalse("Not false", NodeValue.FALSE.getBoolean());
        assertFalse("Not false", XSDFuncOp.booleanEffectiveValue(NodeValue.FALSE));
    }

    @Test
    public void testEBV3() {
        NodeValue v = NodeValue.makeInteger(1);
        assertFalse("It's a boolean: " + v, v.isBoolean());
        assertTrue("Not EBV true: " + v, XSDFuncOp.booleanEffectiveValue(v));
    }

    @Test
    public void testEBV4() {
        NodeValue v = NodeValue.makeInteger(0);
        assertFalse("It's a boolean: " + v, v.isBoolean());
        try {
            v.getBoolean();
            fail("getBoolean should fail");
        }
        catch (ExprEvalException e) {}
        assertFalse("Not EBV false: " + v, XSDFuncOp.booleanEffectiveValue(v));
    }

    @Test
    public void testEBV5() {
        NodeValue v = NodeValue.makeString("xyz");
        assertFalse("It's a boolean: " + v, v.isBoolean());
        // assertTrue("Not a node: "+v, v.hasNode()) ;
        try {
            v.getBoolean();
            fail("getBoolean should fail");
        }
        catch (ExprEvalException e) {}
        assertTrue("Not EBV true: " + v, XSDFuncOp.booleanEffectiveValue(v));
    }

    @Test
    public void testEBV6() {
        NodeValue v = NodeValue.makeString("");
        assertFalse("It's a boolean: " + v, v.isBoolean());
        try {
            v.getBoolean();
            fail("getBoolean should fail");
        }
        catch (ExprEvalException e) {}
        assertFalse("Not EBV false: " + v, XSDFuncOp.booleanEffectiveValue(v));
    }

    // EBV includes plain literals which includes language tagged literals.
    @Test
    public void testEBV7() {
        Node x = NodeFactory.createLiteralLang("", "en");
        NodeValue v = NodeValue.makeNode(x);
        assertFalse("Not EBV false: " + v, XSDFuncOp.booleanEffectiveValue(v));
    }

    @Test
    public void testEBV8() {
        Node x = NodeFactory.createLiteralLang("not empty", "en");
        NodeValue v = NodeValue.makeNode(x);
        assertTrue("Not EBV true: " + v, XSDFuncOp.booleanEffectiveValue(v));
    }

    static boolean ebvDouble(double d) {
        return XSDFuncOp.booleanEffectiveValue(NodeValue.makeDouble(d));
    }

    @Test
    public void testEBV9() {
        assertTrue ( ebvDouble(0.01d) );
        assertFalse( ebvDouble(0.0d) );
        assertFalse( ebvDouble(-0.0d) );

        assertFalse( ebvDouble(Double.NaN) );

        assertTrue ( ebvDouble(Double.MIN_NORMAL) );
        assertTrue ( ebvDouble(Double.MIN_VALUE) );
        assertTrue ( ebvDouble(Double.MAX_VALUE) );

        assertTrue ( ebvDouble(Double.POSITIVE_INFINITY) );
        assertTrue ( ebvDouble(Double.NEGATIVE_INFINITY) );

        Node x = NodeFactory.createLiteral("NaN", XSDDatatype.XSDdouble);
        NodeValue v = NodeValue.makeNode(x);
        assertFalse(XSDFuncOp.booleanEffectiveValue(v));
    }

    static boolean ebvFloat(float f) {
        return XSDFuncOp.booleanEffectiveValue(NodeValue.makeFloat(f));
    }

    @Test
    public void testEBV10() {
        assertTrue ( ebvFloat(0.01f) );
        assertFalse( ebvFloat(0.0f) );
        assertFalse( ebvFloat(-0.0f) );

        assertFalse( ebvFloat(Float.NaN) );

        assertTrue ( ebvFloat(Float.MIN_NORMAL) );
        assertTrue ( ebvFloat(Float.MIN_VALUE) );
        assertTrue ( ebvFloat(Float.MAX_VALUE) );

        assertTrue ( ebvFloat(Float.POSITIVE_INFINITY) );
        assertTrue ( ebvFloat(Float.NEGATIVE_INFINITY) );

        Node x = NodeFactory.createLiteral("NaN", XSDDatatype.XSDfloat);
        NodeValue v = NodeValue.makeNode(x);
        assertFalse(XSDFuncOp.booleanEffectiveValue(v));
    }

    private static boolean filterEBV(NodeValue nv) {
        try {
            return XSDFuncOp.booleanEffectiveValue(nv);
        }
        catch (ExprEvalException ex) {
            return false;
        }
    }

    @Test
    public void testFloatDouble1() {
        NodeValue v1 = NodeValue.makeNodeDouble("1.5");
        NodeValue v2 = NodeValue.makeNode("1.5", XSDDatatype.XSDfloat);
        assertTrue("Should be equal: 1.5 float and 1.5 double", NodeValue.sameValueAs(v1, v2));
    }

    @Test
    public void testFloatDouble5() {
        NodeValue v1 = NodeValue.makeNodeDouble("1.3");
        NodeValue v2 = NodeValue.makeNode("1.3", XSDDatatype.XSDfloat);
        assertFalse("Should not be equal: 1.3 float and 1.3 double", NodeValue.sameValueAs(v1, v2));
    }

    // More effective boolean values - see TestExpressionARQ

    @Test
    public void testString1() {
        NodeValue v = NodeValue.makeString("string");
        assertTrue("Not a string: " + v, v.isString());
        assertFalse("Is a node: " + v, v.hasNode());

    }

    @Test
    public void testNodeString1() {
        NodeValue v = NodeValue.makeNode("string", null, (String)null); // Plain
                                                                        // literal
        assertTrue("Not a string: " + v, v.isString());
        assertTrue("Not a node: " + v, v.hasNode());
    }

    @Test
    public void testNodeString2() {
        NodeValue v = NodeValue.makeNode("string", null, (String)null); // Plain
                                                                        // literal
        assertTrue("Not a string: " + v, v.isString());
        assertTrue("Not a node: " + v, v.hasNode());
        String actualStr = v.asQuotedString();
        assertEquals("Print form mismatch", "\"string\"", actualStr);
    }

    @Test
    public void testNodeString3() {
        NodeValue v = NodeValue.makeNode("string", XSDDatatype.XSDstring);
        assertTrue("Not a string: " + v, v.isString());
        assertTrue("Not a node: " + v, v.hasNode());
        String actualStr = v.asQuotedString();
        // RDF 1.1 -- appearance is a without ^^
        String rightAnswer = "\"string\"";
        assertEquals("Print form mismatch", rightAnswer, actualStr);
    }

    @Test
    public void testNodeSortKey1() {
        NodeValue nv = NodeValue.makeSortKey("Wagen", "de");
        assertTrue("Not a sort key: " + nv, nv.isSortKey());
        String actualStr = nv.asQuotedString();
        String rightAnswer = "\"Wagen\"";
        assertEquals("Print form mismatch", rightAnswer, actualStr);
    }

    @Test
    public void testNodeSortKey2() {
        final String[] unordered =
                {"Broager", "Åkirkeby", "Børkop", "Ærøskøbing", "Brædstrup", "Wandsbek"};
        final String[] ordered =
                {"Broager", "Brædstrup", "Børkop", "Wandsbek", "Ærøskøbing", "Åkirkeby"};
        // tests collation sort order for Danish
        final String collation = "da";
        List<NodeValue> nodeValues = new LinkedList<>();
        for (String string : unordered) {
            nodeValues.add(NodeValue.makeSortKey(string, collation));
        }
        nodeValues.sort(new Comparator<NodeValue>() {
            @Override
            public int compare(NodeValue o1, NodeValue o2) {
                return NodeValue.compare(o1, o2);
            }
        });
        List<String> result = new LinkedList<>();
        for (NodeValue nv : nodeValues) {
            String s = nv.asNode().getLiteralLexicalForm();
            result.add(s);
        }
        assertArrayEquals(ordered, result.toArray(new String[0]));
    }

    @Test
    public void testNodeSortKey3() {
        final String[] unordered = new String[]
                {"Broager", "Åkirkeby", "Børkop", "Ærøskøbing", "Brædstrup", "Wandsbek"};
        final String[] ordered = new String[]
                {"Ærøskøbing", "Åkirkeby", "Brædstrup", "Broager", "Børkop", "Wandsbek"};
        // tests collation sort order with Danish words, but New Zealand English collation rules
        final String collation = "en-NZ";
        List<NodeValue> nodeValues = new LinkedList<>();
        for (String string : unordered) {
            nodeValues.add(NodeValue.makeSortKey(string, collation));
        }
        nodeValues.sort(new Comparator<NodeValue>() {
            @Override
            public int compare(NodeValue o1, NodeValue o2) {
                return NodeValue.compare(o1, o2);
            }
        });
        List<String> result = new LinkedList<>();
        for (NodeValue nv : nodeValues) {
            String s = nv.asNode().getLiteralLexicalForm();
            result.add(s);
        }
        assertArrayEquals(ordered, result.toArray(new String[0]));
    }

    @Test
    public void testNodeSortKey4() {
        // Collation sort order for Finnish
        final String collation = "fi";
        String[] ordered = new String[]
                {"tsahurin kieli", "tšekin kieli", "tulun kieli", "töyhtöhyyppä"};
        // Query String
        final String queryString = "PREFIX skos: <http://www.w3.org/2004/02/skos/core#>\n" +
                "PREFIX arq: <http://jena.apache.org/ARQ/function#>\n" +
                "SELECT ?label WHERE {\n" +
                "   VALUES ?label { \"tulun kieli\"@es \"tšekin kieli\" \"tsahurin kieli\"@en \"töyhtöhyyppä\"@fi }\n" +
                "}\n" +
                "ORDER BY arq:collation(\"" + collation + "\", ?label)";
        Model model = ModelFactory.createDefaultModel();
        Query query = QueryFactory.create(queryString);
        List<String> result = new LinkedList<>();
        try (QueryExecution qExec = QueryExecutionFactory.create(query, model)) {
            ResultSet results = qExec.execSelect();
            while (results.hasNext()) {
                QuerySolution solution = results.nextSolution();
                result.add(solution.getLiteral(solution.varNames().next()).getLexicalForm());
            }
        }
        assertArrayEquals(ordered, result.toArray(new String[0]));
    }

    @Test
    public void testNodeSortKey5() {
     // Collation sort order for English from Belize
        final String collation = "en-BZ";
        String[] ordered = new String[]
                {"töyhtöhyyppä", "tsahurin kieli", "tšekin kieli", "tulun kieli"};
        // Query String
        final String queryString = "PREFIX skos: <http://www.w3.org/2004/02/skos/core#>\n" +
                "PREFIX arq: <http://jena.apache.org/ARQ/function#>\n" +
                "SELECT ?label WHERE {\n" +
                "   VALUES ?label { \"tulun kieli\"@es \"tšekin kieli\" \"tsahurin kieli\"@en \"töyhtöhyyppä\"@fi }\n" +
                "}\n" +
                "ORDER BY arq:collation(\"" + collation + "\", ?label)";
        Model model = ModelFactory.createDefaultModel();
        Query query = QueryFactory.create(queryString);
        List<String> result = new LinkedList<>();
        try (QueryExecution qExec = QueryExecutionFactory.create(query, model)) {
            ResultSet results = qExec.execSelect();
            while (results.hasNext()) {
                QuerySolution solution = results.nextSolution();
                result.add(solution.getLiteral(solution.varNames().next()).getLexicalForm());
            }
        }
        assertArrayEquals(ordered, result.toArray(new String[0]));
    }

    @Test
    public void testSameValue1() {
        NodeValue nv1 = NodeValue.makeInteger(5);
        NodeValue nv2 = NodeValue.makeInteger(7);
        assertTrue("Same values (" + nv1 + "," + nv2 + ")", NodeValue.notSameValueAs(nv1, nv2));
        assertFalse("Same values (" + nv1 + "," + nv2 + ")", NodeValue.sameValueAs(nv1, nv2));

        NodeValue nv3 = NodeValue.makeInteger(5);
        assertTrue("Different values (" + nv1 + "," + nv3 + ")", NodeValue.sameValueAs(nv1, nv3));
        assertFalse("Different values - notNotSame (" + nv1 + "," + nv3 + ")", NodeValue.notSameValueAs(nv1, nv3));
    }

    @Test
    public void testSameValue2() {
        NodeValue nv1 = NodeValue.makeInteger(5);
        NodeValue nv2 = NodeValue.makeNodeInteger(7);
        assertTrue("Same values (" + nv1 + "," + nv2 + ")", NodeValue.notSameValueAs(nv1, nv2));
        assertFalse("Same values (" + nv1 + "," + nv2 + ")", NodeValue.sameValueAs(nv1, nv2));

        NodeValue nv3 = NodeValue.makeNodeInteger(5);
        assertTrue("Different values (" + nv1 + "," + nv3 + ")", NodeValue.sameValueAs(nv1, nv3));
        assertFalse("Different values - notNotSame (" + nv1 + "," + nv3 + ")", NodeValue.notSameValueAs(nv1, nv3));
    }

    @Test
    public void testSameValue3() {
        NodeValue nv1 = NodeValue.makeDecimal("1.5");
        NodeValue nv2 = NodeValue.makeDecimal("1.6");
        assertTrue("Same values (" + nv1 + "," + nv2 + ")", NodeValue.notSameValueAs(nv1, nv2));
        assertFalse("Same values (" + nv1 + "," + nv2 + ")", NodeValue.sameValueAs(nv1, nv2));

        NodeValue nv3 = NodeValue.makeDecimal("1.50");
        assertTrue("Different values (" + nv1 + "," + nv3 + ")", NodeValue.sameValueAs(nv1, nv3));
        assertFalse("Different values - notNotSame (" + nv1 + "," + nv3 + ")", NodeValue.notSameValueAs(nv1, nv3));
    }

    @Test
    public void testSameValue4() {
        NodeValue nv1 = NodeValue.makeDecimal("3");
        NodeValue nv2 = NodeValue.makeInteger(4);
        assertTrue("Same values (" + nv1 + "," + nv2 + ")", NodeValue.notSameValueAs(nv1, nv2));
        assertFalse("Same values (" + nv1 + "," + nv2 + ")", NodeValue.sameValueAs(nv1, nv2));

        NodeValue nv3 = NodeValue.makeInteger(3);
        assertTrue("Different values (" + nv1 + "," + nv3 + ")", NodeValue.sameValueAs(nv1, nv3));
        assertFalse("Different values - notNotSame (" + nv1 + "," + nv3 + ")", NodeValue.notSameValueAs(nv1, nv3));
    }

    @Test
    public void testSameValue5() {
        NodeValue nv1 = NodeValue.makeDecimal("-1.5"); // Must be exact for
                                                       // double and decimal
        NodeValue nv2 = NodeValue.makeDouble(1.5);
        assertTrue("Same values (" + nv1 + "," + nv2 + ")", NodeValue.notSameValueAs(nv1, nv2));
        assertFalse("Same values (" + nv1 + "," + nv2 + ")", NodeValue.sameValueAs(nv1, nv2));

        NodeValue nv3 = NodeValue.makeDouble(-1.5);
        assertTrue("Different values (" + nv1 + "," + nv3 + ")", NodeValue.sameValueAs(nv1, nv3));
        assertFalse("Different values - notNotSame (" + nv1 + "," + nv3 + ")", NodeValue.notSameValueAs(nv1, nv3));
    }

    @Test
    public void testSameValue6() {
        NodeValue nv1 = NodeValue.makeNodeInteger(17);
        NodeValue nv2 = NodeValue.makeDouble(34);
        assertTrue("Same values (" + nv1 + "," + nv2 + ")", NodeValue.notSameValueAs(nv1, nv2));
        assertFalse("Same values (" + nv1 + "," + nv2 + ")", NodeValue.sameValueAs(nv1, nv2));

        NodeValue nv3 = NodeValue.makeDouble(17);
        assertTrue("Different values (" + nv1 + "," + nv3 + ")", NodeValue.sameValueAs(nv1, nv3));
        assertFalse("Different values - notNotSame (" + nv1 + "," + nv3 + ")", NodeValue.notSameValueAs(nv1, nv3));
    }

    @Test
    public void testSameValue7() {
        NodeValue nv1 = NodeValue.makeBoolean(true);
        NodeValue nv2 = NodeValue.makeString("a");
        assertTrue("Same values (" + nv1 + "," + nv2 + ")", NodeValue.notSameValueAs(nv1, nv2));
        assertFalse("Same values (" + nv1 + "," + nv2 + ")", NodeValue.sameValueAs(nv1, nv2));

        NodeValue nv3 = NodeValue.makeNodeBoolean(true);
        assertTrue("Different values (" + nv1 + "," + nv3 + ")", NodeValue.sameValueAs(nv1, nv3));
        assertFalse("Different values - notNotSame (" + nv1 + "," + nv3 + ")", NodeValue.notSameValueAs(nv1, nv3));
    }

    @Test
    public void testSameValueNaN_double_1() {
        NodeValue nv1 = NodeValue.makeNode("NaN", XSDDatatype.XSDdouble);
        NodeValue nv2 = NodeValue.makeNode("NaN", XSDDatatype.XSDdouble);
        assertEquals(nv1, nv2);
        assertFalse(NodeValue.sameValueAs(nv1, nv2));
        assertTrue(NodeValue.notSameValueAs(nv1, nv2));
    }

    @Test
    public void testSameValueNaN_float_1() {
        NodeValue nv1 = NodeValue.makeNode("NaN", XSDDatatype.XSDfloat);
        NodeValue nv2 = NodeValue.makeNode("NaN", XSDDatatype.XSDfloat);
        assertEquals(nv1, nv2);
        assertFalse(NodeValue.sameValueAs(nv1, nv2));
        assertTrue(NodeValue.notSameValueAs(nv1, nv2));
        // NaN is weird.
        assertFalse(NodeValue.sameValueAs(nv1, nv1));
        assertTrue(NodeValue.notSameValueAs(nv1, nv1));
    }

    @Test
    public void testSameValueNaN_double_2() {
        NodeValue nv1 = NodeValue.makeDouble(Double.NaN);
        NodeValue nv2 = NodeValue.makeDouble(Double.NaN);
        assertEquals(nv1, nv2);
        assertFalse(NodeValue.sameValueAs(nv1, nv2));
        assertTrue(NodeValue.notSameValueAs(nv1, nv2));

        assertFalse(NodeValue.sameValueAs(nv1, nv1));
        assertTrue(NodeValue.notSameValueAs(nv1, nv1));
    }

    @Test
    public void testSameValueNaN_float_2() {
        NodeValue nv1 = NodeValue.makeFloat(Float.NaN);
        NodeValue nv2 = NodeValue.makeFloat(Float.NaN);
        assertEquals(nv1, nv2);
        assertFalse(NodeValue.sameValueAs(nv1, nv2));
        assertTrue(NodeValue.notSameValueAs(nv1, nv2));

        assertFalse(NodeValue.sameValueAs(nv1, nv1));
        assertTrue(NodeValue.notSameValueAs(nv1, nv1));
    }

    @Test
    public void testLang1() {
        Node n1 = org.apache.jena.graph.NodeFactory.createLiteralLang("xyz", "en");
        NodeValue nv1 = NodeValue.makeNode(n1);
        Node n2 = org.apache.jena.graph.NodeFactory.createLiteralLang("xyz", "en");
        NodeValue nv2 = NodeValue.makeNode(n2);
        assertTrue(NodeValue.sameValueAs(nv1, nv2));
    }

    @Test
    public void testLang2() {
        Node n1 = org.apache.jena.graph.NodeFactory.createLiteralLang("xyz", "en");
        NodeValue nv1 = NodeValue.makeNode(n1);
        Node n2 = org.apache.jena.graph.NodeFactory.createLiteralLang("xyz", "EN");
        NodeValue nv2 = NodeValue.makeNode(n2);
        assertTrue(NodeValue.sameValueAs(nv1, nv2));
        // Jena5 - langtags are formatted on creation so node are unique upto case.
        assertTrue(nv1.equals(nv2));
    }

    @Test
    public void testLang3() {
        Node n1 = org.apache.jena.graph.NodeFactory.createLiteralLang("xyz", "en");
        NodeValue nv1 = NodeValue.makeNode(n1);
        Node n2 = org.apache.jena.graph.NodeFactory.createLiteralLang("xyz", "en");
        NodeValue nv2 = NodeValue.makeNode(n2);
        assertFalse(NodeValue.notSameValueAs(nv1, nv2));
    }

    @Test
    public void testLang4() {
        NodeValue nv1 = parse("'xyz'@en");
        NodeValue nv2 = parse("'xyz'@EN");
        assertFalse(NodeValue.notSameValueAs(nv1, nv2));
        // Jena5 - langtags are formatted on creation so node are unique upto case.
        assertTrue(nv1.equals(nv2));
    }

    //Compare value first and then language tag
    @Test
    public void testLangCompareAlways1() {
        // @de before @en => "'abc'@en" > "'bcd'@de" => +1
        NodeValue nv1 = parse("'abc'@en");
        NodeValue nv2 = parse("'bcd'@de");
        assertEquals(Expr.CMP_GREATER, NodeCmp.compareRDFTerms(nv1.getNode(), nv2.getNode()));
        assertEquals(Expr.CMP_GREATER, NodeValue.compareAlways(nv1, nv2));
    }

    //Language tag comparison ignore case first, then case sensitive
    @Test
    public void testLangCompareAlways2() {
        // @FR before @it. => "'abc'@it" > "'abc'@FR" => +1
        NodeValue nv1 = parse("'abc'@it");
        NodeValue nv2 = parse("'abc'@FR");
        assertEquals(Expr.CMP_GREATER, NodeCmp.compareRDFTerms(nv1.getNode(), nv2.getNode()));
        assertEquals(Expr.CMP_GREATER, NodeValue.compareAlways(nv1, nv2));
    }

    public void testLangCompareAlways3() {
        // @FR after @en. => "'abc'@en" < "'abc'@FR" => -1
        NodeValue nv1 = parse("'abc'@en");
        NodeValue nv2 = parse("'abc'@FR");
        assertEquals(Expr.CMP_LESS, NodeCmp.compareRDFTerms(nv1.getNode(), nv2.getNode()));
        assertEquals(Expr.CMP_LESS, NodeValue.compareAlways(nv1, nv2));
    }


    @Test
    public void testEquals1() {
        NodeValue nv1 = NodeValue.makeInteger(1);
        NodeValue nv2 = NodeValue.makeInteger(1);
        assertEquals("Not NodeValue.equals()", nv1, nv2);
    }

    @Test
    public void testEquals2() {
        NodeValue nv1 = NodeValue.makeNodeInteger(1);
        NodeValue nv2 = NodeValue.makeInteger(1);
        assertEquals("Not NodeValue.equals()", nv1, nv2);
    }

    @Test
    public void testEquals3() { // Make different ways but equals
        NodeValue nv1 = NodeValue.makeInteger(1);
        NodeValue nv2 = NodeValue.makeNodeInteger(1);
        assertEquals("Not NodeValue.equals()", nv1, nv2);
    }

    @Test
    public void testEquals4() {
        NodeValue nv1 = NodeValue.makeNode(NodeFactory.createURI("http://example"));
        NodeValue nv2 = NodeValue.makeNode(NodeFactory.createURI("http://example"));
        assertEquals("Not NodeValue.equals()", nv1, nv2);
    }

    @Test
    public void testNotEquals1() {
        NodeValue nv1 = NodeValue.makeInteger(1);
        NodeValue nv2 = NodeValue.makeInteger(2);
        assertFalse("NodeValue.equals()", nv1.equals(nv2));
    }

    @Test
    public void testNotEquals2() {
        NodeValue nv1 = NodeValue.makeNodeInteger(1);
        NodeValue nv2 = NodeValue.makeNodeString("1");
        assertFalse("NodeValue.equals()", nv1.equals(nv2));
    }

    @Test
    public void testNotEquals3() { // Literals and URIs are different.
        NodeValue nv1 = NodeValue.makeNode(org.apache.jena.graph.NodeFactory.createURI("http://example"));
        NodeValue nv2 = NodeValue.makeNode(org.apache.jena.graph.NodeFactory.createLiteralString("http://example"));
        assertFalse("NodeValue.equals()", nv1.equals(nv2));
    }

    @Test
    public void testTripleTerms1() {
        Node n1 = SSE.parseNode("<<:s :p 123>>");
        Node n2 = SSE.parseNode("<<:s :p 456>>");
        NodeValue nv1 = NodeValue.makeNode(n1);
        NodeValue nv2 = NodeValue.makeNode(n2);
        int xa = NodeValue.compare(nv1, nv2);
        assertEquals(Expr.CMP_LESS, xa);
        int xb = NodeValue.compare(nv2, nv1);
        assertEquals(Expr.CMP_GREATER, xb);
    }

    @Test(expected=ExprNotComparableException.class)
    public void testTripleTerms2() {
        Node n1 = SSE.parseNode("<<:s :p 123>>");
        Node n2 = SSE.parseNode("<<:s :p 'abc'>>");
        NodeValue nv1 = NodeValue.makeNode(n1);
        NodeValue nv2 = NodeValue.makeNode(n2);
        NodeValue.compare(nv1, nv2);
    }

    @Test
    public void testTripleTerms3() {
        // Jena 4.6.0 :: 'abc' < before 123
        Node n1 = SSE.parseNode("<<:s :p 123>>");
        Node n2 = SSE.parseNode("<<:s :p 'abc'>>");
        NodeValue nv1 = NodeValue.makeNode(n1);
        NodeValue nv2 = NodeValue.makeNode(n2);
        int x = NodeValue.compareAlways(nv1, nv2);
        assertEquals(Expr.CMP_GREATER, x);
    }

}
