package com.philmcrew.util;

import junit.framework.Test;
import junit.framework.TestCase;
import junit.framework.TestSuite;

/**
 * ComparatorHelper Tester.
 *
 * @author Mitchell J. Friedman
 * @version 1.0
 * @since <pre>05/06/2005</pre>
 */
public class ComparatorHelperTest extends TestCase 
{
	ComparatorHelper comparatorHelper;
	public ComparatorHelperTest( String name ) 
	{
		super( name );
	}

	public void setUp() throws Exception 
	{
		super.setUp();
		comparatorHelper = new ComparatorHelper();
	}

	public void tearDown() throws Exception 
	{
		super.tearDown();
	}

	public void compareHelper( Object a, Object b ) throws Exception 
	{
		assertEquals( "compare " + a + " to " + b, -1, comparatorHelper.compare( a, b ) );
		assertEquals( "compare " + b + " to " + a, 1, comparatorHelper.compare( b, a ) );
		assertEquals( "compare " + a + " to " + a, 0, comparatorHelper.compare( a, a ) );
		assertEquals( "compare " + b + " to " + b, 0, comparatorHelper.compare( b, b ) );
		assertEquals( "compare " + a + " to " + null, 1, comparatorHelper.compare( a, null ) );
		assertEquals( "compare " + b + " to " + null, 1, comparatorHelper.compare( b, null ) );
		assertEquals( "compare " + null + " to " + null, 0, comparatorHelper.compare( null, null ) );

		assertTrue( "compare " + a + " < " + b, comparatorHelper.compare( a, Operator.LESS_THAN, b ) );
		assertFalse( "compare " + b + " < " + a, comparatorHelper.compare( b, Operator.LESS_THAN, a ) );
		assertFalse( "compare " + a + " < " + a, comparatorHelper.compare( a, Operator.LESS_THAN, a ) );
		assertFalse( "compare " + b + " < " + b, comparatorHelper.compare( b, Operator.LESS_THAN, b ) );
		assertFalse( "compare " + a + " < " + null, comparatorHelper.compare( a, Operator.LESS_THAN, null ) );
		assertFalse( "compare " + b + " < " + null, comparatorHelper.compare( b, Operator.LESS_THAN, null ) );
		assertFalse( "compare " + null + " < " + null, comparatorHelper.compare( null, Operator.LESS_THAN, null ) );

		assertTrue( "compare " + a + " <= " + b, comparatorHelper.compare( a, Operator.LESS_THAN_OR_EQUAL_TO, b ) );
		assertFalse( "compare " + b + " <= " + a, comparatorHelper.compare( b, Operator.LESS_THAN_OR_EQUAL_TO, a ) );
		assertTrue( "compare " + a + " <= " + a, comparatorHelper.compare( a, Operator.LESS_THAN_OR_EQUAL_TO, a ) );
		assertTrue( "compare " + b + " <= " + b, comparatorHelper.compare( b, Operator.LESS_THAN_OR_EQUAL_TO, b ) );
		assertFalse( "compare " + a + " <= " + null, comparatorHelper.compare( a, Operator.LESS_THAN_OR_EQUAL_TO, null ) );
		assertFalse( "compare " + b + " <= " + null, comparatorHelper.compare( b, Operator.LESS_THAN_OR_EQUAL_TO, null ) );
		assertTrue( "compare " + null + " <= " + null, comparatorHelper.compare( null, Operator.LESS_THAN_OR_EQUAL_TO, null ) );

		assertFalse( "compare " + a + " = " + b, comparatorHelper.compare( a, Operator.EQUAL_TO, b ) );
		assertFalse( "compare " + b + " = " + a, comparatorHelper.compare( b, Operator.EQUAL_TO, a ) );
		assertTrue( "compare " + a + " = " + a, comparatorHelper.compare( a, Operator.EQUAL_TO, a ) );
		assertTrue( "compare " + b + " = " + b, comparatorHelper.compare( b, Operator.EQUAL_TO, b ) );
		assertFalse( "compare " + a + " = " + null, comparatorHelper.compare( a, Operator.EQUAL_TO, null ) );
		assertFalse( "compare " + b + " = " + null, comparatorHelper.compare( b, Operator.EQUAL_TO, null ) );
		assertTrue( "compare " + null + " = " + null, comparatorHelper.compare( null, Operator.EQUAL_TO, null ) );

		assertFalse( "compare " + a + " >= " + b, comparatorHelper.compare( a, Operator.GREATER_THAN_OR_EQUAL_TO, b ) );
		assertTrue( "compare " + b + " >= " + a, comparatorHelper.compare( b, Operator.GREATER_THAN_OR_EQUAL_TO, a ) );
		assertTrue( "compare " + a + " >= " + a, comparatorHelper.compare( a, Operator.GREATER_THAN_OR_EQUAL_TO, a ) );
		assertTrue( "compare " + b + " >= " + b, comparatorHelper.compare( b, Operator.GREATER_THAN_OR_EQUAL_TO, b ) );
		assertTrue( "compare " + a + " >= " + null, comparatorHelper.compare( a, Operator.GREATER_THAN_OR_EQUAL_TO, null ) );
		assertTrue( "compare " + b + " >= " + null, comparatorHelper.compare( b, Operator.GREATER_THAN_OR_EQUAL_TO, null ) );
		assertTrue( "compare " + null + " >= " + null, comparatorHelper.compare( null, Operator.GREATER_THAN_OR_EQUAL_TO, null ) );

		assertFalse( "compare " + a + " > " + b, comparatorHelper.compare( a, Operator.GREATER_THAN, b ) );
		assertTrue( "compare " + b + " > " + a, comparatorHelper.compare( b, Operator.GREATER_THAN, a ) );
		assertFalse( "compare " + a + " > " + a, comparatorHelper.compare( a, Operator.GREATER_THAN, a ) );
		assertFalse( "compare " + b + " > " + b, comparatorHelper.compare( b, Operator.GREATER_THAN, b ) );
		assertTrue( "compare " + a + " > " + null, comparatorHelper.compare( a, Operator.GREATER_THAN, null ) );
		assertTrue( "compare " + b + " > " + null, comparatorHelper.compare( b, Operator.GREATER_THAN, null ) );
		assertFalse( "compare " + null + " > " + null, comparatorHelper.compare( null, Operator.GREATER_THAN, null ) );

		assertTrue( "compare " + a + " != " + b, comparatorHelper.compare( a, Operator.NOT_EQUAL_TO, b ) );
		assertTrue( "compare " + b + " != " + a, comparatorHelper.compare( b, Operator.NOT_EQUAL_TO, a ) );
		assertFalse( "compare " + a + " != " + a, comparatorHelper.compare( a, Operator.NOT_EQUAL_TO, a ) );
		assertFalse( "compare " + b + " != " + b, comparatorHelper.compare( b, Operator.NOT_EQUAL_TO, b ) );
		assertTrue( "compare " + a + " != " + null, comparatorHelper.compare( a, Operator.NOT_EQUAL_TO, null ) );
		assertTrue( "compare " + b + " != " + null, comparatorHelper.compare( b, Operator.NOT_EQUAL_TO, null ) );
		assertFalse( "compare " + null + " != " + null, comparatorHelper.compare( null, Operator.NOT_EQUAL_TO, null ) );
	}


	public void testCompare() throws Exception 
	{
		compareHelper( new Integer( 1 ), new Integer( 2 ) );
		compareHelper( new Long( 1 ), new Long( 2 ) );
		compareHelper( new Float( 1.1 ), new Float( 2.2 ) );
		compareHelper( new Double( 1.1 ), new Double( 2.2 ) );
		compareHelper( new String( "1.1" ), new String( "2.2" ) );

		compareHelper( new Integer( 1 ), new Long( 2 ) );
		compareHelper( new Integer( 1 ), new Float( 2.2 ) );
		compareHelper( new Integer( 1 ), new Double( 2.2 ) );
		compareHelper( new Integer( 1 ), new String( "2.2" ) );

		compareHelper( new Long( 1 ), new Integer( 2 ) );
		compareHelper( new Long( 1 ), new Float( 2.2 ) );
		compareHelper( new Long( 1 ), new Double( 2.2 ) );
		compareHelper( new Long( 1 ), new String( "2.2" ) );

		compareHelper( new Float( 1 ), new Integer( 2 ) );
		compareHelper( new Float( 1 ), new Long( 2 ) );
		compareHelper( new Float( 1.1 ), new Double( 2.2 ) );
		compareHelper( new Float( 1.1 ), new String( "2.2" ) );

		compareHelper( new Double( 1 ), new Integer( 2 ) );
		compareHelper( new Double( 1 ), new Long( 2 ) );
		compareHelper( new Double( 1.1 ), new Float( 2.2 ) );
		compareHelper( new Double( 1.1 ), new String( "2.2" ) );

		compareHelper( new String( "1" ), new Integer( 2 ) );
		compareHelper( new String( "1" ), new Long( 2 ) );
		compareHelper( new String( "1.1" ), new Float( 2.2 ) );
		compareHelper( new String( "1.1" ), new Double( 2.2 ) );
	}


	public void testCompareStrings() throws Exception 
	{
		String a = "aaa";
		String b = "bbb";

		assertEquals( "compare " + a + " to " + b, -1, comparatorHelper.compareStrings( a, b ) );
		assertEquals( "compare " + b + " to " + a, 1, comparatorHelper.compareStrings( b, a ) );
		assertEquals( "compare " + a + " to " + a, 0, comparatorHelper.compareStrings( a, a ) );
		assertEquals( "compare " + b + " to " + b, 0, comparatorHelper.compareStrings( b, b ) );
		assertEquals( "compare " + a + " to " + null, 1, comparatorHelper.compareStrings( a, null ) );
		assertEquals( "compare " + b + " to " + null, 1, comparatorHelper.compareStrings( b, null ) );
		assertEquals( "compare " + null + " to " + null, 0, comparatorHelper.compareStrings( null, null ) );

		assertTrue( "compare " + a + " < " + b, comparatorHelper.compareStrings( a, Operator.LESS_THAN, b ) );
		assertFalse( "compare " + b + " < " + a, comparatorHelper.compareStrings( b, Operator.LESS_THAN, a ) );
		assertFalse( "compare " + a + " < " + a, comparatorHelper.compareStrings( a, Operator.LESS_THAN, a ) );
		assertFalse( "compare " + b + " < " + b, comparatorHelper.compareStrings( b, Operator.LESS_THAN, b ) );
		assertFalse( "compare " + a + " < " + null, comparatorHelper.compareStrings( a, Operator.LESS_THAN, null ) );
		assertFalse( "compare " + b + " < " + null, comparatorHelper.compareStrings( b, Operator.LESS_THAN, null ) );
		assertFalse( "compare " + null + " < " + null, comparatorHelper.compareStrings( null, Operator.LESS_THAN, null ) );

		assertTrue( "compare " + a + " <= " + b, comparatorHelper.compareStrings( a, Operator.LESS_THAN_OR_EQUAL_TO, b ) );
		assertFalse( "compare " + b + " <= " + a, comparatorHelper.compareStrings( b, Operator.LESS_THAN_OR_EQUAL_TO, a ) );
		assertTrue( "compare " + a + " <= " + a, comparatorHelper.compareStrings( a, Operator.LESS_THAN_OR_EQUAL_TO, a ) );
		assertTrue( "compare " + b + " <= " + b, comparatorHelper.compareStrings( b, Operator.LESS_THAN_OR_EQUAL_TO, b ) );
		assertFalse( "compare " + a + " <= " + null, comparatorHelper.compareStrings( a, Operator.LESS_THAN_OR_EQUAL_TO, null ) );
		assertFalse( "compare " + b + " <= " + null, comparatorHelper.compareStrings( b, Operator.LESS_THAN_OR_EQUAL_TO, null ) );
		assertTrue( "compare " + null + " <= " + null, comparatorHelper.compareStrings( null, Operator.LESS_THAN_OR_EQUAL_TO, null ) );

		assertFalse( "compare " + a + " = " + b, comparatorHelper.compareStrings( a, Operator.EQUAL_TO, b ) );
		assertFalse( "compare " + b + " = " + a, comparatorHelper.compareStrings( b, Operator.EQUAL_TO, a ) );
		assertTrue( "compare " + a + " = " + a, comparatorHelper.compareStrings( a, Operator.EQUAL_TO, a ) );
		assertTrue( "compare " + b + " = " + b, comparatorHelper.compareStrings( b, Operator.EQUAL_TO, b ) );
		assertFalse( "compare " + a + " = " + null, comparatorHelper.compareStrings( a, Operator.EQUAL_TO, null ) );
		assertFalse( "compare " + b + " = " + null, comparatorHelper.compareStrings( b, Operator.EQUAL_TO, null ) );
		assertTrue( "compare " + null + " = " + null, comparatorHelper.compareStrings( null, Operator.EQUAL_TO, null ) );

		assertFalse( "compare " + a + " >= " + b, comparatorHelper.compareStrings( a, Operator.GREATER_THAN_OR_EQUAL_TO, b ) );
		assertTrue( "compare " + b + " >= " + a, comparatorHelper.compareStrings( b, Operator.GREATER_THAN_OR_EQUAL_TO, a ) );
		assertTrue( "compare " + a + " >= " + a, comparatorHelper.compareStrings( a, Operator.GREATER_THAN_OR_EQUAL_TO, a ) );
		assertTrue( "compare " + b + " >= " + b, comparatorHelper.compareStrings( b, Operator.GREATER_THAN_OR_EQUAL_TO, b ) );
		assertTrue( "compare " + a + " >= " + null, comparatorHelper.compareStrings( a, Operator.GREATER_THAN_OR_EQUAL_TO, null ) );
		assertTrue( "compare " + b + " >= " + null, comparatorHelper.compareStrings( b, Operator.GREATER_THAN_OR_EQUAL_TO, null ) );
		assertTrue( "compare " + null + " >= " + null, comparatorHelper.compareStrings( null, Operator.GREATER_THAN_OR_EQUAL_TO, null ) );

		assertFalse( "compare " + a + " > " + b, comparatorHelper.compareStrings( a, Operator.GREATER_THAN, b ) );
		assertTrue( "compare " + b + " > " + a, comparatorHelper.compareStrings( b, Operator.GREATER_THAN, a ) );
		assertFalse( "compare " + a + " > " + a, comparatorHelper.compareStrings( a, Operator.GREATER_THAN, a ) );
		assertFalse( "compare " + b + " > " + b, comparatorHelper.compareStrings( b, Operator.GREATER_THAN, b ) );
		assertTrue( "compare " + a + " > " + null, comparatorHelper.compareStrings( a, Operator.GREATER_THAN, null ) );
		assertTrue( "compare " + b + " > " + null, comparatorHelper.compareStrings( b, Operator.GREATER_THAN, null ) );
		assertFalse( "compare " + null + " > " + null, comparatorHelper.compareStrings( null, Operator.GREATER_THAN, null ) );

		assertTrue( "compare " + a + " != " + b, comparatorHelper.compareStrings( a, Operator.NOT_EQUAL_TO, b ) );
		assertTrue( "compare " + b + " != " + a, comparatorHelper.compareStrings( b, Operator.NOT_EQUAL_TO, a ) );
		assertFalse( "compare " + a + " != " + a, comparatorHelper.compareStrings( a, Operator.NOT_EQUAL_TO, a ) );
		assertFalse( "compare " + b + " != " + b, comparatorHelper.compareStrings( b, Operator.NOT_EQUAL_TO, b ) );
		assertTrue( "compare " + a + " != " + null, comparatorHelper.compareStrings( a, Operator.NOT_EQUAL_TO, null ) );
		assertTrue( "compare " + b + " != " + null, comparatorHelper.compareStrings( b, Operator.NOT_EQUAL_TO, null ) );
		assertFalse( "compare " + null + " != " + null, comparatorHelper.compareStrings( null, Operator.NOT_EQUAL_TO, null ) );
	}

	public void testCompareBoolean() throws Exception 
	{
		Boolean a = Boolean.TRUE;
		Boolean b = Boolean.FALSE;

		assertEquals( "compare " + a + " to " + b, -1, comparatorHelper.compareBoolean( a, b ) );
		assertEquals( "compare " + b + " to " + a, 1, comparatorHelper.compareBoolean( b, a ) );
		assertEquals( "compare " + a + " to " + a, 0, comparatorHelper.compareBoolean( a, a ) );
		assertEquals( "compare " + b + " to " + b, 0, comparatorHelper.compareBoolean( b, b ) );
		assertEquals( "compare " + a + " to " + null, 1, comparatorHelper.compareBoolean( a, null ) );
		assertEquals( "compare " + b + " to " + null, 1, comparatorHelper.compareBoolean( b, null ) );
		assertEquals( "compare " + null + " to " + null, 0, comparatorHelper.compareBoolean( null, null ) );

		assertTrue( "compare " + a + " < " + b, comparatorHelper.compareBoolean( a, Operator.LESS_THAN, b ) );
		assertFalse( "compare " + b + " < " + a, comparatorHelper.compareBoolean( b, Operator.LESS_THAN, a ) );
		assertFalse( "compare " + a + " < " + a, comparatorHelper.compareBoolean( a, Operator.LESS_THAN, a ) );
		assertFalse( "compare " + b + " < " + b, comparatorHelper.compareBoolean( b, Operator.LESS_THAN, b ) );
		assertFalse( "compare " + a + " < " + null, comparatorHelper.compareBoolean( a, Operator.LESS_THAN, null ) );
		assertFalse( "compare " + b + " < " + null, comparatorHelper.compareBoolean( b, Operator.LESS_THAN, null ) );
		assertFalse( "compare " + null + " < " + null, comparatorHelper.compareBoolean( null, Operator.LESS_THAN, null ) );

		assertTrue( "compare " + a + " <= " + b, comparatorHelper.compareBoolean( a, Operator.LESS_THAN_OR_EQUAL_TO, b ) );
		assertFalse( "compare " + b + " <= " + a, comparatorHelper.compareBoolean( b, Operator.LESS_THAN_OR_EQUAL_TO, a ) );
		assertTrue( "compare " + a + " <= " + a, comparatorHelper.compareBoolean( a, Operator.LESS_THAN_OR_EQUAL_TO, a ) );
		assertTrue( "compare " + b + " <= " + b, comparatorHelper.compareBoolean( b, Operator.LESS_THAN_OR_EQUAL_TO, b ) );
		assertFalse( "compare " + a + " <= " + null, comparatorHelper.compareBoolean( a, Operator.LESS_THAN_OR_EQUAL_TO, null ) );
		assertFalse( "compare " + b + " <= " + null, comparatorHelper.compareBoolean( b, Operator.LESS_THAN_OR_EQUAL_TO, null ) );
		assertTrue( "compare " + null + " <= " + null, comparatorHelper.compareBoolean( null, Operator.LESS_THAN_OR_EQUAL_TO, null ) );

		assertFalse( "compare " + a + " = " + b, comparatorHelper.compareBoolean( a, Operator.EQUAL_TO, b ) );
		assertFalse( "compare " + b + " = " + a, comparatorHelper.compareBoolean( b, Operator.EQUAL_TO, a ) );
		assertTrue( "compare " + a + " = " + a, comparatorHelper.compareBoolean( a, Operator.EQUAL_TO, a ) );
		assertTrue( "compare " + b + " = " + b, comparatorHelper.compareBoolean( b, Operator.EQUAL_TO, b ) );
		assertFalse( "compare " + a + " = " + null, comparatorHelper.compareBoolean( a, Operator.EQUAL_TO, null ) );
		assertFalse( "compare " + b + " = " + null, comparatorHelper.compareBoolean( b, Operator.EQUAL_TO, null ) );
		assertTrue( "compare " + null + " = " + null, comparatorHelper.compareBoolean( null, Operator.EQUAL_TO, null ) );

		assertFalse( "compare " + a + " >= " + b, comparatorHelper.compareBoolean( a, Operator.GREATER_THAN_OR_EQUAL_TO, b ) );
		assertTrue( "compare " + b + " >= " + a, comparatorHelper.compareBoolean( b, Operator.GREATER_THAN_OR_EQUAL_TO, a ) );
		assertTrue( "compare " + a + " >= " + a, comparatorHelper.compareBoolean( a, Operator.GREATER_THAN_OR_EQUAL_TO, a ) );
		assertTrue( "compare " + b + " >= " + b, comparatorHelper.compareBoolean( b, Operator.GREATER_THAN_OR_EQUAL_TO, b ) );
		assertTrue( "compare " + a + " >= " + null, comparatorHelper.compareBoolean( a, Operator.GREATER_THAN_OR_EQUAL_TO, null ) );
		assertTrue( "compare " + b + " >= " + null, comparatorHelper.compareBoolean( b, Operator.GREATER_THAN_OR_EQUAL_TO, null ) );
		assertTrue( "compare " + null + " >= " + null, comparatorHelper.compareBoolean( null, Operator.GREATER_THAN_OR_EQUAL_TO, null ) );

		assertFalse( "compare " + a + " > " + b, comparatorHelper.compareBoolean( a, Operator.GREATER_THAN, b ) );
		assertTrue( "compare " + b + " > " + a, comparatorHelper.compareBoolean( b, Operator.GREATER_THAN, a ) );
		assertFalse( "compare " + a + " > " + a, comparatorHelper.compareBoolean( a, Operator.GREATER_THAN, a ) );
		assertFalse( "compare " + b + " > " + b, comparatorHelper.compareBoolean( b, Operator.GREATER_THAN, b ) );
		assertTrue( "compare " + a + " > " + null, comparatorHelper.compareBoolean( a, Operator.GREATER_THAN, null ) );
		assertTrue( "compare " + b + " > " + null, comparatorHelper.compareBoolean( b, Operator.GREATER_THAN, null ) );
		assertFalse( "compare " + null + " > " + null, comparatorHelper.compareBoolean( null, Operator.GREATER_THAN, null ) );

		assertTrue( "compare " + a + " != " + b, comparatorHelper.compareBoolean( a, Operator.NOT_EQUAL_TO, b ) );
		assertTrue( "compare " + b + " != " + a, comparatorHelper.compareBoolean( b, Operator.NOT_EQUAL_TO, a ) );
		assertFalse( "compare " + a + " != " + a, comparatorHelper.compareBoolean( a, Operator.NOT_EQUAL_TO, a ) );
		assertFalse( "compare " + b + " != " + b, comparatorHelper.compareBoolean( b, Operator.NOT_EQUAL_TO, b ) );
		assertTrue( "compare " + a + " != " + null, comparatorHelper.compareBoolean( a, Operator.NOT_EQUAL_TO, null ) );
		assertTrue( "compare " + b + " != " + null, comparatorHelper.compareBoolean( b, Operator.NOT_EQUAL_TO, null ) );
		assertFalse( "compare " + null + " != " + null, comparatorHelper.compareBoolean( null, Operator.NOT_EQUAL_TO, null ) );
	}

	public void testComparedouble() throws Exception 
	{
		double a = 1.1d;
		double b = 2.2d;

		assertEquals( "compare " + a + " to " + b, -1, comparatorHelper.compareTo( a, b ) );
		assertEquals( "compare " + b + " to " + a, 1, comparatorHelper.compareTo( b, a ) );
		assertEquals( "compare " + a + " to " + a, 0, comparatorHelper.compareTo( a, a ) );
		assertEquals( "compare " + b + " to " + b, 0, comparatorHelper.compareTo( b, b ) );

		assertTrue( "compare " + a + " < " + b, comparatorHelper.compareTo( a, Operator.LESS_THAN, b ) );
		assertFalse( "compare " + b + " < " + a, comparatorHelper.compareTo( b, Operator.LESS_THAN, a ) );
		assertFalse( "compare " + a + " < " + a, comparatorHelper.compareTo( a, Operator.LESS_THAN, a ) );
		assertFalse( "compare " + b + " < " + b, comparatorHelper.compareTo( b, Operator.LESS_THAN, b ) );

		assertTrue( "compare " + a + " <= " + b, comparatorHelper.compareTo( a, Operator.LESS_THAN_OR_EQUAL_TO, b ) );
		assertFalse( "compare " + b + " <= " + a, comparatorHelper.compareTo( b, Operator.LESS_THAN_OR_EQUAL_TO, a ) );
		assertTrue( "compare " + a + " <= " + a, comparatorHelper.compareTo( a, Operator.LESS_THAN_OR_EQUAL_TO, a ) );
		assertTrue( "compare " + b + " <= " + b, comparatorHelper.compareTo( b, Operator.LESS_THAN_OR_EQUAL_TO, b ) );

		assertFalse( "compare " + a + " = " + b, comparatorHelper.compareTo( a, Operator.EQUAL_TO, b ) );
		assertFalse( "compare " + b + " = " + a, comparatorHelper.compareTo( b, Operator.EQUAL_TO, a ) );
		assertTrue( "compare " + a + " = " + a, comparatorHelper.compareTo( a, Operator.EQUAL_TO, a ) );
		assertTrue( "compare " + b + " = " + b, comparatorHelper.compareTo( b, Operator.EQUAL_TO, b ) );

		assertFalse( "compare " + a + " >= " + b, comparatorHelper.compareTo( a, Operator.GREATER_THAN_OR_EQUAL_TO, b ) );
		assertTrue( "compare " + b + " >= " + a, comparatorHelper.compareTo( b, Operator.GREATER_THAN_OR_EQUAL_TO, a ) );
		assertTrue( "compare " + a + " >= " + a, comparatorHelper.compareTo( a, Operator.GREATER_THAN_OR_EQUAL_TO, a ) );
		assertTrue( "compare " + b + " >= " + b, comparatorHelper.compareTo( b, Operator.GREATER_THAN_OR_EQUAL_TO, b ) );

		assertFalse( "compare " + a + " > " + b, comparatorHelper.compareTo( a, Operator.GREATER_THAN, b ) );
		assertTrue( "compare " + b + " > " + a, comparatorHelper.compareTo( b, Operator.GREATER_THAN, a ) );
		assertFalse( "compare " + a + " > " + a, comparatorHelper.compareTo( a, Operator.GREATER_THAN, a ) );
		assertFalse( "compare " + b + " > " + b, comparatorHelper.compareTo( b, Operator.GREATER_THAN, b ) );

		assertTrue( "compare " + a + " != " + b, comparatorHelper.compareTo( a, Operator.NOT_EQUAL_TO, b ) );
		assertTrue( "compare " + b + " != " + a, comparatorHelper.compareTo( b, Operator.NOT_EQUAL_TO, a ) );
		assertFalse( "compare " + a + " != " + a, comparatorHelper.compareTo( a, Operator.NOT_EQUAL_TO, a ) );
		assertFalse( "compare " + b + " != " + b, comparatorHelper.compareTo( b, Operator.NOT_EQUAL_TO, b ) );
	}

	public void testCompareDoubleString() throws Exception 
	{
		String a = "<<<NULL>>>";
		Double b = new Double( 1.1d );
		assertEquals( "compare " + a + " to " + b, -1, comparatorHelper.compareTo( a, b ) );
		assertEquals( "compare " + b + " to " + a, 1, comparatorHelper.compareTo( b, a ) );
	}

	public void testComparefloat() throws Exception 
	{
		float a = 1.1f;
		float b = 2.2f;

		assertEquals( "compare " + a + " to " + b, -1, comparatorHelper.compareTo( a, b ) );
		assertEquals( "compare " + b + " to " + a, 1, comparatorHelper.compareTo( b, a ) );
		assertEquals( "compare " + a + " to " + a, 0, comparatorHelper.compareTo( a, a ) );
		assertEquals( "compare " + b + " to " + b, 0, comparatorHelper.compareTo( b, b ) );

		assertTrue( "compare " + a + " < " + b, comparatorHelper.compareTo( a, Operator.LESS_THAN, b ) );
		assertFalse( "compare " + b + " < " + a, comparatorHelper.compareTo( b, Operator.LESS_THAN, a ) );
		assertFalse( "compare " + a + " < " + a, comparatorHelper.compareTo( a, Operator.LESS_THAN, a ) );
		assertFalse( "compare " + b + " < " + b, comparatorHelper.compareTo( b, Operator.LESS_THAN, b ) );

		assertTrue( "compare " + a + " <= " + b, comparatorHelper.compareTo( a, Operator.LESS_THAN_OR_EQUAL_TO, b ) );
		assertFalse( "compare " + b + " <= " + a, comparatorHelper.compareTo( b, Operator.LESS_THAN_OR_EQUAL_TO, a ) );
		assertTrue( "compare " + a + " <= " + a, comparatorHelper.compareTo( a, Operator.LESS_THAN_OR_EQUAL_TO, a ) );
		assertTrue( "compare " + b + " <= " + b, comparatorHelper.compareTo( b, Operator.LESS_THAN_OR_EQUAL_TO, b ) );

		assertFalse( "compare " + a + " = " + b, comparatorHelper.compareTo( a, Operator.EQUAL_TO, b ) );
		assertFalse( "compare " + b + " = " + a, comparatorHelper.compareTo( b, Operator.EQUAL_TO, a ) );
		assertTrue( "compare " + a + " = " + a, comparatorHelper.compareTo( a, Operator.EQUAL_TO, a ) );
		assertTrue( "compare " + b + " = " + b, comparatorHelper.compareTo( b, Operator.EQUAL_TO, b ) );

		assertFalse( "compare " + a + " >= " + b, comparatorHelper.compareTo( a, Operator.GREATER_THAN_OR_EQUAL_TO, b ) );
		assertTrue( "compare " + b + " >= " + a, comparatorHelper.compareTo( b, Operator.GREATER_THAN_OR_EQUAL_TO, a ) );
		assertTrue( "compare " + a + " >= " + a, comparatorHelper.compareTo( a, Operator.GREATER_THAN_OR_EQUAL_TO, a ) );
		assertTrue( "compare " + b + " >= " + b, comparatorHelper.compareTo( b, Operator.GREATER_THAN_OR_EQUAL_TO, b ) );

		assertFalse( "compare " + a + " > " + b, comparatorHelper.compareTo( a, Operator.GREATER_THAN, b ) );
		assertTrue( "compare " + b + " > " + a, comparatorHelper.compareTo( b, Operator.GREATER_THAN, a ) );
		assertFalse( "compare " + a + " > " + a, comparatorHelper.compareTo( a, Operator.GREATER_THAN, a ) );
		assertFalse( "compare " + b + " > " + b, comparatorHelper.compareTo( b, Operator.GREATER_THAN, b ) );

		assertTrue( "compare " + a + " != " + b, comparatorHelper.compareTo( a, Operator.NOT_EQUAL_TO, b ) );
		assertTrue( "compare " + b + " != " + a, comparatorHelper.compareTo( b, Operator.NOT_EQUAL_TO, a ) );
		assertFalse( "compare " + a + " != " + a, comparatorHelper.compareTo( a, Operator.NOT_EQUAL_TO, a ) );
		assertFalse( "compare " + b + " != " + b, comparatorHelper.compareTo( b, Operator.NOT_EQUAL_TO, b ) );
	}

	public void testComparelong() throws Exception {
		long a = 1;
		long b = 2;

		assertEquals( "compare " + a + " to " + b, -1, comparatorHelper.compareTo( a, b ) );
		assertEquals( "compare " + b + " to " + a, 1, comparatorHelper.compareTo( b, a ) );
		assertEquals( "compare " + a + " to " + a, 0, comparatorHelper.compareTo( a, a ) );
		assertEquals( "compare " + b + " to " + b, 0, comparatorHelper.compareTo( b, b ) );

		assertTrue( "compare " + a + " < " + b, comparatorHelper.compareTo( a, Operator.LESS_THAN, b ) );
		assertFalse( "compare " + b + " < " + a, comparatorHelper.compareTo( b, Operator.LESS_THAN, a ) );
		assertFalse( "compare " + a + " < " + a, comparatorHelper.compareTo( a, Operator.LESS_THAN, a ) );
		assertFalse( "compare " + b + " < " + b, comparatorHelper.compareTo( b, Operator.LESS_THAN, b ) );

		assertTrue( "compare " + a + " <= " + b, comparatorHelper.compareTo( a, Operator.LESS_THAN_OR_EQUAL_TO, b ) );
		assertFalse( "compare " + b + " <= " + a, comparatorHelper.compareTo( b, Operator.LESS_THAN_OR_EQUAL_TO, a ) );
		assertTrue( "compare " + a + " <= " + a, comparatorHelper.compareTo( a, Operator.LESS_THAN_OR_EQUAL_TO, a ) );
		assertTrue( "compare " + b + " <= " + b, comparatorHelper.compareTo( b, Operator.LESS_THAN_OR_EQUAL_TO, b ) );

		assertFalse( "compare " + a + " = " + b, comparatorHelper.compareTo( a, Operator.EQUAL_TO, b ) );
		assertFalse( "compare " + b + " = " + a, comparatorHelper.compareTo( b, Operator.EQUAL_TO, a ) );
		assertTrue( "compare " + a + " = " + a, comparatorHelper.compareTo( a, Operator.EQUAL_TO, a ) );
		assertTrue( "compare " + b + " = " + b, comparatorHelper.compareTo( b, Operator.EQUAL_TO, b ) );

		assertFalse( "compare " + a + " >= " + b, comparatorHelper.compareTo( a, Operator.GREATER_THAN_OR_EQUAL_TO, b ) );
		assertTrue( "compare " + b + " >= " + a, comparatorHelper.compareTo( b, Operator.GREATER_THAN_OR_EQUAL_TO, a ) );
		assertTrue( "compare " + a + " >= " + a, comparatorHelper.compareTo( a, Operator.GREATER_THAN_OR_EQUAL_TO, a ) );
		assertTrue( "compare " + b + " >= " + b, comparatorHelper.compareTo( b, Operator.GREATER_THAN_OR_EQUAL_TO, b ) );

		assertFalse( "compare " + a + " > " + b, comparatorHelper.compareTo( a, Operator.GREATER_THAN, b ) );
		assertTrue( "compare " + b + " > " + a, comparatorHelper.compareTo( b, Operator.GREATER_THAN, a ) );
		assertFalse( "compare " + a + " > " + a, comparatorHelper.compareTo( a, Operator.GREATER_THAN, a ) );
		assertFalse( "compare " + b + " > " + b, comparatorHelper.compareTo( b, Operator.GREATER_THAN, b ) );

		assertTrue( "compare " + a + " != " + b, comparatorHelper.compareTo( a, Operator.NOT_EQUAL_TO, b ) );
		assertTrue( "compare " + b + " != " + a, comparatorHelper.compareTo( b, Operator.NOT_EQUAL_TO, a ) );
		assertFalse( "compare " + a + " != " + a, comparatorHelper.compareTo( a, Operator.NOT_EQUAL_TO, a ) );
		assertFalse( "compare " + b + " != " + b, comparatorHelper.compareTo( b, Operator.NOT_EQUAL_TO, b ) );
	}

	public void testCompareint() throws Exception {
		int a = 1;
		int b = 2;

		assertEquals( "compare " + a + " to " + b, -1, comparatorHelper.compareTo( a, b ) );
		assertEquals( "compare " + b + " to " + a, 1, comparatorHelper.compareTo( b, a ) );
		assertEquals( "compare " + a + " to " + a, 0, comparatorHelper.compareTo( a, a ) );
		assertEquals( "compare " + b + " to " + b, 0, comparatorHelper.compareTo( b, b ) );

		assertTrue( "compare " + a + " < " + b, comparatorHelper.compareTo( a, Operator.LESS_THAN, b ) );
		assertFalse( "compare " + b + " < " + a, comparatorHelper.compareTo( b, Operator.LESS_THAN, a ) );
		assertFalse( "compare " + a + " < " + a, comparatorHelper.compareTo( a, Operator.LESS_THAN, a ) );
		assertFalse( "compare " + b + " < " + b, comparatorHelper.compareTo( b, Operator.LESS_THAN, b ) );

		assertTrue( "compare " + a + " <= " + b, comparatorHelper.compareTo( a, Operator.LESS_THAN_OR_EQUAL_TO, b ) );
		assertFalse( "compare " + b + " <= " + a, comparatorHelper.compareTo( b, Operator.LESS_THAN_OR_EQUAL_TO, a ) );
		assertTrue( "compare " + a + " <= " + a, comparatorHelper.compareTo( a, Operator.LESS_THAN_OR_EQUAL_TO, a ) );
		assertTrue( "compare " + b + " <= " + b, comparatorHelper.compareTo( b, Operator.LESS_THAN_OR_EQUAL_TO, b ) );

		assertFalse( "compare " + a + " = " + b, comparatorHelper.compareTo( a, Operator.EQUAL_TO, b ) );
		assertFalse( "compare " + b + " = " + a, comparatorHelper.compareTo( b, Operator.EQUAL_TO, a ) );
		assertTrue( "compare " + a + " = " + a, comparatorHelper.compareTo( a, Operator.EQUAL_TO, a ) );
		assertTrue( "compare " + b + " = " + b, comparatorHelper.compareTo( b, Operator.EQUAL_TO, b ) );

		assertFalse( "compare " + a + " >= " + b, comparatorHelper.compareTo( a, Operator.GREATER_THAN_OR_EQUAL_TO, b ) );
		assertTrue( "compare " + b + " >= " + a, comparatorHelper.compareTo( b, Operator.GREATER_THAN_OR_EQUAL_TO, a ) );
		assertTrue( "compare " + a + " >= " + a, comparatorHelper.compareTo( a, Operator.GREATER_THAN_OR_EQUAL_TO, a ) );
		assertTrue( "compare " + b + " >= " + b, comparatorHelper.compareTo( b, Operator.GREATER_THAN_OR_EQUAL_TO, b ) );

		assertFalse( "compare " + a + " > " + b, comparatorHelper.compareTo( a, Operator.GREATER_THAN, b ) );
		assertTrue( "compare " + b + " > " + a, comparatorHelper.compareTo( b, Operator.GREATER_THAN, a ) );
		assertFalse( "compare " + a + " > " + a, comparatorHelper.compareTo( a, Operator.GREATER_THAN, a ) );
		assertFalse( "compare " + b + " > " + b, comparatorHelper.compareTo( b, Operator.GREATER_THAN, b ) );

		assertTrue( "compare " + a + " != " + b, comparatorHelper.compareTo( a, Operator.NOT_EQUAL_TO, b ) );
		assertTrue( "compare " + b + " != " + a, comparatorHelper.compareTo( b, Operator.NOT_EQUAL_TO, a ) );
		assertFalse( "compare " + a + " != " + a, comparatorHelper.compareTo( a, Operator.NOT_EQUAL_TO, a ) );
		assertFalse( "compare " + b + " != " + b, comparatorHelper.compareTo( b, Operator.NOT_EQUAL_TO, b ) );
	}

	public void testCompareshort() throws Exception 
	{
		short a = 1;
		short b = 2;

		assertEquals( "compare " + a + " to " + b, -1, comparatorHelper.compareTo( a, b ) );
		assertEquals( "compare " + b + " to " + a, 1, comparatorHelper.compareTo( b, a ) );
		assertEquals( "compare " + a + " to " + a, 0, comparatorHelper.compareTo( a, a ) );
		assertEquals( "compare " + b + " to " + b, 0, comparatorHelper.compareTo( b, b ) );

		assertTrue( "compare " + a + " < " + b, comparatorHelper.compareTo( a, Operator.LESS_THAN, b ) );
		assertFalse( "compare " + b + " < " + a, comparatorHelper.compareTo( b, Operator.LESS_THAN, a ) );
		assertFalse( "compare " + a + " < " + a, comparatorHelper.compareTo( a, Operator.LESS_THAN, a ) );
		assertFalse( "compare " + b + " < " + b, comparatorHelper.compareTo( b, Operator.LESS_THAN, b ) );

		assertTrue( "compare " + a + " <= " + b, comparatorHelper.compareTo( a, Operator.LESS_THAN_OR_EQUAL_TO, b ) );
		assertFalse( "compare " + b + " <= " + a, comparatorHelper.compareTo( b, Operator.LESS_THAN_OR_EQUAL_TO, a ) );
		assertTrue( "compare " + a + " <= " + a, comparatorHelper.compareTo( a, Operator.LESS_THAN_OR_EQUAL_TO, a ) );
		assertTrue( "compare " + b + " <= " + b, comparatorHelper.compareTo( b, Operator.LESS_THAN_OR_EQUAL_TO, b ) );

		assertFalse( "compare " + a + " = " + b, comparatorHelper.compareTo( a, Operator.EQUAL_TO, b ) );
		assertFalse( "compare " + b + " = " + a, comparatorHelper.compareTo( b, Operator.EQUAL_TO, a ) );
		assertTrue( "compare " + a + " = " + a, comparatorHelper.compareTo( a, Operator.EQUAL_TO, a ) );
		assertTrue( "compare " + b + " = " + b, comparatorHelper.compareTo( b, Operator.EQUAL_TO, b ) );

		assertFalse( "compare " + a + " >= " + b, comparatorHelper.compareTo( a, Operator.GREATER_THAN_OR_EQUAL_TO, b ) );
		assertTrue( "compare " + b + " >= " + a, comparatorHelper.compareTo( b, Operator.GREATER_THAN_OR_EQUAL_TO, a ) );
		assertTrue( "compare " + a + " >= " + a, comparatorHelper.compareTo( a, Operator.GREATER_THAN_OR_EQUAL_TO, a ) );
		assertTrue( "compare " + b + " >= " + b, comparatorHelper.compareTo( b, Operator.GREATER_THAN_OR_EQUAL_TO, b ) );

		assertFalse( "compare " + a + " > " + b, comparatorHelper.compareTo( a, Operator.GREATER_THAN, b ) );
		assertTrue( "compare " + b + " > " + a, comparatorHelper.compareTo( b, Operator.GREATER_THAN, a ) );
		assertFalse( "compare " + a + " > " + a, comparatorHelper.compareTo( a, Operator.GREATER_THAN, a ) );
		assertFalse( "compare " + b + " > " + b, comparatorHelper.compareTo( b, Operator.GREATER_THAN, b ) );

		assertTrue( "compare " + a + " != " + b, comparatorHelper.compareTo( a, Operator.NOT_EQUAL_TO, b ) );
		assertTrue( "compare " + b + " != " + a, comparatorHelper.compareTo( b, Operator.NOT_EQUAL_TO, a ) );
		assertFalse( "compare " + a + " != " + a, comparatorHelper.compareTo( a, Operator.NOT_EQUAL_TO, a ) );
		assertFalse( "compare " + b + " != " + b, comparatorHelper.compareTo( b, Operator.NOT_EQUAL_TO, b ) );
	}

	public void compareResultsHelper( Operator operator, String op, boolean[] expectedResults ) 
	{
		assertEquals( "compareResults " + op, op, operator.toString() );
		assertEquals( "compareResults " + op + " -1", expectedResults[ 0 ], comparatorHelper.compareResults( operator, -1 ) );
		assertEquals( "compareResults " + op + " 0", expectedResults[ 1 ], comparatorHelper.compareResults( operator, 0 ) );
		assertEquals( "compareResults " + op + " 1", expectedResults[ 2 ], comparatorHelper.compareResults( operator, 1 ) );
	}

	public void testCompareResults() throws Exception 
	{
		compareResultsHelper( Operator.LESS_THAN, "<", new boolean[]{true, false, false} );
		compareResultsHelper( Operator.LESS_THAN_OR_EQUAL_TO, "<=", new boolean[]{true, true, false} );
		compareResultsHelper( Operator.EQUAL_TO, "=", new boolean[]{false, true, false} );
		compareResultsHelper( Operator.GREATER_THAN_OR_EQUAL_TO, ">=", new boolean[]{false, true, true} );
		compareResultsHelper( Operator.GREATER_THAN, ">", new boolean[]{false, false, true} );
		compareResultsHelper( Operator.NOT_EQUAL_TO, "<>", new boolean[]{true, false, true} );

	}

	public static Test suite() 
	{
		return new TestSuite( ComparatorHelperTest.class );
	}
}