// This Source Code is in the Public Domain per: http://unlicense.org
package org.litesoft.orsup.selection;

import junit.framework.*;

import org.litesoft.*;
import org.litesoft.orsup.selection.nonpublic.*;

public class WhereClauseFactoryTest extends TestCasePlus
{
    public static Test suite()
    {
        return new TestSuite( WhereClauseFactoryTest.class );
    }

    public WhereClauseFactoryTest( String name )
    {
        super( name );
    }

    public static void main( String[] args )
    {
        junit.textui.TestRunner.run( suite() );
    }

    static class WCtableID implements SimpleFromIdentifier
    {
        @Override
        public String getTableName()
        {
            return "TheTable";
        }

        @Override
        public String getIdentifierName()
        {
            return "zTable";
        }
    }

    static class TestingColumnDefinition extends AbstractColumnDefinition
    {
        protected TestingColumnDefinition( String pName, boolean pAddSearchColumn, Class pColumnType )
        {
            super( pName + "Attr", pName + "Col", pAddSearchColumn ? pName + "Col_SC" : pName + "Col", pColumnType );
        }

        protected TestingColumnDefinition( String pName, Class pColumnType )
        {
            super( pName + "Attr", pName + "Col", pColumnType );
        }
    }

    static class CDstring extends TestingColumnDefinition
    {
        CDstring( String pName, boolean pAddSearchColumn )
        {
            super( pName, pAddSearchColumn, String.class );
        }

        CDstring( String pName )
        {
            this( pName, false );
        }
    }

    static class CDinteger extends TestingColumnDefinition
    {
        CDinteger( String pName )
        {
            super( pName, Integer.class );
        }
    }

    private WhereClauseFactory F = WhereClauseFactory.INSTANCE;

    private CDstring TheString = new CDstring( "TheStr" );
    private CDstring TheString_SC = new CDstring( "TheStr", true );
    private CDinteger TheInteger = new CDinteger( "TheInt" );
    private CDinteger TheInteger2 = new CDinteger( "TheInt2" );

    private WhereClause wcStrNull = F.isNull( TheString );
    private WhereClause wcStrNotNull = F.isNotNull( TheString );
    private WhereClause wcStrEqual = F.isEqual( TheString, "gas" );
    private WhereClause wcIntEqual = F.isEqual( TheInteger, 5 );
    private WhereClause wcIntEqual2 = F.isEqual( TheInteger2, 6 );
    private WhereClause wcStrNotEqual = F.isNotEqual( TheString, "gas" );
    private WhereClause wcintNotEqual = F.isNotEqual( TheInteger, 5 );

    private SingleColumnSelect zSingleColumnSelect = new SingleColumnSelect( TheInteger, new WCtableID(), wcStrNotNull );

    public void test_isNull()
            throws Exception
    {
        WhereClause wc = F.isNull( TheString );

        Assert.assertEquals( "Where TheStrAttr == null", wc.toString() );
        Assert.assertEquals( "WHERE TheStrCol IS NULL", wc.toSQL() );

        wc = F.isNull( TheString_SC );

        Assert.assertEquals( "Where TheStrAttr == null", wc.toString() );
        Assert.assertEquals( "WHERE TheStrCol_SC IS NULL", wc.toSQL() );
    }

    public void test_isNotNull()
            throws Exception
    {
        WhereClause wc = F.isNotNull( TheString );

        Assert.assertEquals( "Where TheStrAttr != null", wc.toString() );
        Assert.assertEquals( "WHERE TheStrCol IS NOT NULL", wc.toSQL() );
    }

    public void test_isEqual_Null()
            throws Exception
    {
        WhereClause wc = F.isEqual( TheString, null );

        Assert.assertEquals( wcStrNull.toString(), wc.toString() );
        Assert.assertEquals( wcStrNull.toSQL(), wc.toSQL() );
    }

    public void test_isNotEqual_Null()
            throws Exception
    {
        WhereClause wc = F.isNotEqual( TheString, null );

        Assert.assertEquals( wcStrNotNull.toString(), wc.toString() );
        Assert.assertEquals( wcStrNotNull.toSQL(), wc.toSQL() );
    }

    public void test_isEqual()
            throws Exception
    {
        WhereClause wc = F.isEqual( TheString, "gas" );

        Assert.assertEquals( "Where TheStrAttr == \"gas\"", wc.toString() );
        Assert.assertEquals( "WHERE TheStrCol = 'gas'", wc.toSQL() );
    }

    public void test_isNotEqual()
            throws Exception
    {
        WhereClause wc = F.isNotEqual( TheString, "gas" );

        Assert.assertEquals( "Where TheStrAttr != \"gas\"", wc.toString() );
        Assert.assertEquals( "WHERE (TheStrCol <> 'gas') OR (TheStrCol IS NULL)", wc.toSQL() );
    }

    public void test_isEqual_int()
            throws Exception
    {
        WhereClause wc = F.isEqual( TheInteger, 5 );

        Assert.assertEquals( "Where TheIntAttr == 5", wc.toString() );
        Assert.assertEquals( "WHERE TheIntCol = 5", wc.toSQL() );
    }

    public void test_isNotEqual_int()
            throws Exception
    {
        WhereClause wc = F.isNotEqual( TheInteger, 5 );

        Assert.assertEquals( "Where TheIntAttr != 5", wc.toString() );
        Assert.assertEquals( "WHERE (TheIntCol <> 5) OR (TheIntCol IS NULL)", wc.toSQL() );
    }

    public void test_isGreaterThan_Null()
            throws Exception
    {
        try
        {
            F.isGreaterThan( TheString, null );
            Assert.fail();
        }
        catch ( IllegalArgumentException expected )
        {
        }
    }

    public void test_isNotGreaterThan_Null()
            throws Exception
    {
        try
        {
            F.isNotGreaterThan( TheString, null );
            Assert.fail();
        }
        catch ( IllegalArgumentException expected )
        {
        }
    }

    public void test_isGreaterThan()
            throws Exception
    {
        WhereClause wc = F.isGreaterThan( TheString, "gas" );

        Assert.assertEquals( "Where TheStrAttr > \"gas\"", wc.toString() );
        Assert.assertEquals( "WHERE TheStrCol > 'gas'", wc.toSQL() );
    }

    public void test_isNotGreaterThan()
            throws Exception
    {
        WhereClause wc = F.isNotGreaterThan( TheString, "gas" );

        Assert.assertEquals( "Where TheStrAttr <= \"gas\"", wc.toString() );
        Assert.assertEquals( "WHERE TheStrCol <= 'gas'", wc.toSQL() );
    }

    public void test_isGreaterThan_int()
            throws Exception
    {
        WhereClause wc = F.isGreaterThan( TheInteger, 5 );

        Assert.assertEquals( "Where TheIntAttr > 5", wc.toString() );
        Assert.assertEquals( "WHERE TheIntCol > 5", wc.toSQL() );
    }

    public void test_isNotGreaterThan_int()
            throws Exception
    {
        WhereClause wc = F.isNotGreaterThan( TheInteger, 5 );

        Assert.assertEquals( "Where TheIntAttr <= 5", wc.toString() );
        Assert.assertEquals( "WHERE TheIntCol <= 5", wc.toSQL() );
    }

    public void test_isLessThan_Null()
            throws Exception
    {
        try
        {
            F.isLessThan( TheString, null );
            Assert.fail();
        }
        catch ( IllegalArgumentException expected )
        {
        }
    }

    public void test_isNotLessThan_Null()
            throws Exception
    {
        try
        {
            F.isNotLessThan( TheString, null );
            Assert.fail();
        }
        catch ( IllegalArgumentException expected )
        {
        }
    }

    public void test_isLessThan()
            throws Exception
    {
        WhereClause wc = F.isLessThan( TheString, "gas" );

        Assert.assertEquals( "Where TheStrAttr < \"gas\"", wc.toString() );
        Assert.assertEquals( "WHERE TheStrCol < 'gas'", wc.toSQL() );
    }

    public void test_isNotLessThan()
            throws Exception
    {
        WhereClause wc = F.isNotLessThan( TheString, "gas" );

        Assert.assertEquals( "Where TheStrAttr >= \"gas\"", wc.toString() );
        Assert.assertEquals( "WHERE TheStrCol >= 'gas'", wc.toSQL() );
    }

    public void test_isLessThan_int()
            throws Exception
    {
        WhereClause wc = F.isLessThan( TheInteger, 5 );

        Assert.assertEquals( "Where TheIntAttr < 5", wc.toString() );
        Assert.assertEquals( "WHERE TheIntCol < 5", wc.toSQL() );
    }

    public void test_isNotLessThan_int()
            throws Exception
    {
        WhereClause wc = F.isNotLessThan( TheInteger, 5 );

        Assert.assertEquals( "Where TheIntAttr >= 5", wc.toString() );
        Assert.assertEquals( "WHERE TheIntCol >= 5", wc.toSQL() );
    }

    public void test_isBetween_NullLeft()
            throws Exception
    {
        try
        {
            F.isBetween( TheString, null, "kls" );
            Assert.fail();
        }
        catch ( IllegalArgumentException expected )
        {
        }
    }

    public void test_isNotBetween_NullLeft()
            throws Exception
    {
        try
        {
            F.isNotBetween( TheString, null, "kls" );
            Assert.fail();
        }
        catch ( IllegalArgumentException expected )
        {
        }
    }

    public void test_isBetween_NullRight()
            throws Exception
    {
        try
        {
            F.isBetween( TheString, "gas", null );
            Assert.fail();
        }
        catch ( IllegalArgumentException expected )
        {
        }
    }

    public void test_isNotBetween_NullRight()
            throws Exception
    {
        try
        {
            F.isNotBetween( TheString, "gas", null );
            Assert.fail();
        }
        catch ( IllegalArgumentException expected )
        {
        }
    }

    public void test_isBetween_EqualNull()
            throws Exception
    {
        WhereClause wc = F.isBetween( TheString, null, null );

        Assert.assertEquals( wcStrNull.toString(), wc.toString() );
        Assert.assertEquals( wcStrNull.toSQL(), wc.toSQL() );
    }

    public void test_isNotBetween_EqualNull()
            throws Exception
    {
        WhereClause wc = F.isNotBetween( TheString, null, null );

        Assert.assertEquals( wcStrNotNull.toString(), wc.toString() );
        Assert.assertEquals( wcStrNotNull.toSQL(), wc.toSQL() );
    }

    public void test_isBetween_Equal()
            throws Exception
    {
        WhereClause wc = F.isBetween( TheString, "gas", "g" + "a" + "s" );

        Assert.assertEquals( wcStrEqual.toString(), wc.toString() );
        Assert.assertEquals( wcStrEqual.toSQL(), wc.toSQL() );
    }

    public void test_isNotBetween_Equal()
            throws Exception
    {
        WhereClause wc = F.isNotBetween( TheString, "gas", "g" + "a" + "s" );

        Assert.assertEquals( wcStrNotEqual.toString(), wc.toString() );
        Assert.assertEquals( wcStrNotEqual.toSQL(), wc.toSQL() );
    }

    public void test_isBetween_Equal_int()
            throws Exception
    {
        WhereClause wc = F.isBetween( TheInteger, 5, 5 );

        Assert.assertEquals( wcIntEqual.toString(), wc.toString() );
        Assert.assertEquals( wcIntEqual.toSQL(), wc.toSQL() );
    }

    public void test_isNotBetween_Equal_int()
            throws Exception
    {
        WhereClause wc = F.isNotBetween( TheInteger, 5, 5 );

        Assert.assertEquals( wcintNotEqual.toString(), wc.toString() );
        Assert.assertEquals( wcintNotEqual.toSQL(), wc.toSQL() );
    }

    public void test_isBetween()
            throws Exception
    {
        WhereClause wc = F.isBetween( TheString, "gas", "kls" );

        Assert.assertEquals( "Where \"gas\" <= TheStrAttr <= \"kls\"", wc.toString() );
        Assert.assertEquals( "WHERE TheStrCol BETWEEN 'gas' AND 'kls'", wc.toSQL() );
    }

    public void test_isNotBetween()
            throws Exception
    {
        WhereClause wc = F.isNotBetween( TheString, "gas", "kls" );

        Assert.assertEquals( "Where NOT (\"gas\" <= TheStrAttr <= \"kls\")", wc.toString() );
        Assert.assertEquals( "WHERE TheStrCol NOT BETWEEN 'gas' AND 'kls'", wc.toSQL() );
    }

    public void test_isBetween_int()
            throws Exception
    {
        WhereClause wc = F.isBetween( TheInteger, 5, 6 );

        Assert.assertEquals( "Where 5 <= TheIntAttr <= 6", wc.toString() );
        Assert.assertEquals( "WHERE TheIntCol BETWEEN 5 AND 6", wc.toSQL() );
    }

    public void test_isNotBetween_int()
            throws Exception
    {
        WhereClause wc = F.isNotBetween( TheInteger, 5, 6 );

        Assert.assertEquals( "Where NOT (5 <= TheIntAttr <= 6)", wc.toString() );
        Assert.assertEquals( "WHERE TheIntCol NOT BETWEEN 5 AND 6", wc.toSQL() );
    }

    public void test_endsWith_Null()
            throws Exception
    {
        try
        {
            F.endsWith( TheString, null );
            Assert.fail();
        }
        catch ( IllegalArgumentException expected )
        {
        }
    }

    public void test_doesNotEndWith_Null()
            throws Exception
    {
        try
        {
            F.doesNotEndWith( TheString, null );
            Assert.fail();
        }
        catch ( IllegalArgumentException expected )
        {
        }
    }

    public void test_endsWith()
            throws Exception
    {
        WhereClause wc = F.endsWith( TheString, "gas" );

        Assert.assertEquals( "Where TheStrAttr EndsWith \"gas\"", wc.toString() );
        Assert.assertEquals( "WHERE TheStrCol LIKE '%gas'", wc.toSQL() );
    }

    public void test_doesNotEndWith()
            throws Exception
    {
        WhereClause wc = F.doesNotEndWith( TheString, "gas" );

        Assert.assertEquals( "Where TheStrAttr Does NOT EndsWith \"gas\"", wc.toString() );
        Assert.assertEquals( "WHERE TheStrCol NOT LIKE '%gas'", wc.toSQL() );
    }

    public void test_startsWith_Null()
            throws Exception
    {
        try
        {
            F.startsWith( TheString, null );
            Assert.fail();
        }
        catch ( IllegalArgumentException expected )
        {
        }
    }

    public void test_doesNotStartWith_Null()
            throws Exception
    {
        try
        {
            F.doesNotStartWith( TheString, null );
            Assert.fail();
        }
        catch ( IllegalArgumentException expected )
        {
        }
    }

    public void test_startsWith()
            throws Exception
    {
        WhereClause wc = F.startsWith( TheString, "gas" );

        Assert.assertEquals( "Where TheStrAttr StartsWith \"gas\"", wc.toString() );
        Assert.assertEquals( "WHERE TheStrCol LIKE 'gas%'", wc.toSQL() );
    }

    public void test_doesNotStartWith()
            throws Exception
    {
        WhereClause wc = F.doesNotStartWith( TheString, "gas" );

        Assert.assertEquals( "Where TheStrAttr Does NOT StartsWith \"gas\"", wc.toString() );
        Assert.assertEquals( "WHERE TheStrCol NOT LIKE 'gas%'", wc.toSQL() );
    }

    public void test_contains_Null()
            throws Exception
    {
        try
        {
            F.contains( TheString, null );
            Assert.fail();
        }
        catch ( IllegalArgumentException expected )
        {
        }
    }

    public void test_doesNotContain_Null()
            throws Exception
    {
        try
        {
            F.doesNotContain( TheString, null );
            Assert.fail();
        }
        catch ( IllegalArgumentException expected )
        {
        }
    }

    public void test_like_Null()
            throws Exception
    {
        try
        {
            F.like( TheString, (String[]) null );
            Assert.fail();
        }
        catch ( IllegalArgumentException expected )
        {
        }
    }

    public void test_isNotLike_Null()
            throws Exception
    {
        try
        {
            F.isNotLike( TheString, (String[]) null );
            Assert.fail();
        }
        catch ( IllegalArgumentException expected )
        {
        }
    }

    public void test_like()
            throws Exception
    {
        WhereClause wc = F.like( TheString, "gas" );

        Assert.assertEquals( "Where TheStrAttr == \"gas\"", wc.toString() );
        Assert.assertEquals( "WHERE TheStrCol = 'gas'", wc.toSQL() );

        wc = F.like( TheString, "gas", "" );

        Assert.assertEquals( "Where TheStrAttr StartsWith \"gas\"", wc.toString() );
        Assert.assertEquals( "WHERE TheStrCol LIKE 'gas%'", wc.toSQL() );

        wc = F.like( TheString, "", "gas" );

        Assert.assertEquals( "Where TheStrAttr EndsWith \"gas\"", wc.toString() );
        Assert.assertEquals( "WHERE TheStrCol LIKE '%gas'", wc.toSQL() );

        wc = F.like( TheString, "", "gas", "" );

        Assert.assertEquals( "Where TheStrAttr Contains \"gas\"", wc.toString() );
        Assert.assertEquals( "WHERE TheStrCol LIKE '%gas%'", wc.toSQL() );

        wc = F.like( TheString, "kls", "gas" );

        Assert.assertEquals( "Where TheStrAttr matches( \"kls\", \"gas\" )", wc.toString() );
        Assert.assertEquals( "WHERE TheStrCol LIKE 'kls%gas'", wc.toSQL() );

        wc = F.like( TheString, "kls", "gas", "" );

        Assert.assertEquals( "Where TheStrAttr matches( \"kls\", \"gas\", \"\" )", wc.toString() );
        Assert.assertEquals( "WHERE TheStrCol LIKE 'kls%gas%'", wc.toSQL() );

        wc = F.like( TheString, "", "gas", "kls" );

        Assert.assertEquals( "Where TheStrAttr matches( \"\", \"gas\", \"kls\" )", wc.toString() );
        Assert.assertEquals( "WHERE TheStrCol LIKE '%gas%kls'", wc.toSQL() );

        wc = F.like( TheString, "as", "gas", "ds" );

        Assert.assertEquals( "Where TheStrAttr matches( \"as\", \"gas\", \"ds\" )", wc.toString() );
        Assert.assertEquals( "WHERE TheStrCol LIKE 'as%gas%ds'", wc.toSQL() );

        wc = F.like( TheString, "as", "gas", "", "ds" );

        Assert.assertEquals( "Where TheStrAttr matches( \"as\", \"gas\", \"ds\" )", wc.toString() );
        Assert.assertEquals( "WHERE TheStrCol LIKE 'as%gas%ds'", wc.toSQL() );

        wc = F.like( TheString, "gas", "as", "ds", "bs" );

        Assert.assertEquals( "Where TheStrAttr matches( \"gas\", \"as\", \"ds\", \"bs\" )", wc.toString() );
        Assert.assertEquals( "WHERE TheStrCol LIKE 'gas%as%ds%bs'", wc.toSQL() );
    }

    public void test_isNotLike()
            throws Exception
    {
        WhereClause wc = F.isNotLike( TheString, "gas" );

        Assert.assertEquals( "Where TheStrAttr != \"gas\"", wc.toString() );
        Assert.assertEquals( "WHERE (TheStrCol <> 'gas') OR (TheStrCol IS NULL)", wc.toSQL() );

        wc = F.isNotLike( TheString, "gas", "" );

        Assert.assertEquals( "Where TheStrAttr Does NOT StartsWith \"gas\"", wc.toString() );
        Assert.assertEquals( "WHERE TheStrCol NOT LIKE 'gas%'", wc.toSQL() );

        wc = F.isNotLike( TheString, "", "gas" );

        Assert.assertEquals( "Where TheStrAttr Does NOT EndsWith \"gas\"", wc.toString() );
        Assert.assertEquals( "WHERE TheStrCol NOT LIKE '%gas'", wc.toSQL() );

        wc = F.isNotLike( TheString, "", "gas", "" );

        Assert.assertEquals( "Where TheStrAttr Does NOT Contains \"gas\"", wc.toString() );
        Assert.assertEquals( "WHERE TheStrCol NOT LIKE '%gas%'", wc.toSQL() );

        wc = F.isNotLike( TheString, "kls", "gas" );

        Assert.assertEquals( "Where TheStrAttr Does NOT matches( \"kls\", \"gas\" )", wc.toString() );
        Assert.assertEquals( "WHERE TheStrCol NOT LIKE 'kls%gas'", wc.toSQL() );

        wc = F.isNotLike( TheString, "kls", "gas", "" );

        Assert.assertEquals( "Where TheStrAttr Does NOT matches( \"kls\", \"gas\", \"\" )", wc.toString() );
        Assert.assertEquals( "WHERE TheStrCol NOT LIKE 'kls%gas%'", wc.toSQL() );

        wc = F.isNotLike( TheString, "", "gas", "kls" );

        Assert.assertEquals( "Where TheStrAttr Does NOT matches( \"\", \"gas\", \"kls\" )", wc.toString() );
        Assert.assertEquals( "WHERE TheStrCol NOT LIKE '%gas%kls'", wc.toSQL() );

        wc = F.isNotLike( TheString, "as", "gas", "ds" );

        Assert.assertEquals( "Where TheStrAttr Does NOT matches( \"as\", \"gas\", \"ds\" )", wc.toString() );
        Assert.assertEquals( "WHERE TheStrCol NOT LIKE 'as%gas%ds'", wc.toSQL() );

        wc = F.isNotLike( TheString, "as", "gas", "", "ds" );

        Assert.assertEquals( "Where TheStrAttr Does NOT matches( \"as\", \"gas\", \"ds\" )", wc.toString() );
        Assert.assertEquals( "WHERE TheStrCol NOT LIKE 'as%gas%ds'", wc.toSQL() );

        wc = F.isNotLike( TheString, "gas", "as", "ds", "bs" );

        Assert.assertEquals( "Where TheStrAttr Does NOT matches( \"gas\", \"as\", \"ds\", \"bs\" )", wc.toString() );
        Assert.assertEquals( "WHERE TheStrCol NOT LIKE 'gas%as%ds%bs'", wc.toSQL() );
    }

    public void test_contains()
            throws Exception
    {
        WhereClause wc = F.contains( TheString, "gas" );

        Assert.assertEquals( "Where TheStrAttr Contains \"gas\"", wc.toString() );
        Assert.assertEquals( "WHERE TheStrCol LIKE '%gas%'", wc.toSQL() );
    }

    public void test_doesNotContain()
            throws Exception
    {
        WhereClause wc = F.doesNotContain( TheString, "gas" );

        Assert.assertEquals( "Where TheStrAttr Does NOT Contains \"gas\"", wc.toString() );
        Assert.assertEquals( "WHERE TheStrCol NOT LIKE '%gas%'", wc.toSQL() );
    }

    public void test_alwaysTrue()
            throws Exception
    {
        WhereClause wc = F.alwaysTrue();

        Assert.assertEquals( "Where TRUE", wc.toString() );
        Assert.assertEquals( "WHERE TRUE", wc.toSQL() );
    }

    public void test_alwaysFalse()
            throws Exception
    {
        WhereClause wc = F.alwaysFalse();

        Assert.assertEquals( "Where FALSE", wc.toString() );
        Assert.assertEquals( "WHERE FALSE", wc.toSQL() );
    }

    public void test_andTrue()
            throws Exception
    {
        WhereClause wc = F.and( wcStrEqual, F.alwaysTrue() );

        Assert.assertEquals( "Where TheStrAttr == \"gas\"", wc.toString() );
        Assert.assertEquals( "WHERE TheStrCol = 'gas'", wc.toSQL() );
    }

    public void test_andFalse()
            throws Exception
    {
        WhereClause wc = F.and( wcStrEqual, F.alwaysFalse() );

        Assert.assertEquals( "Where FALSE", wc.toString() );
        Assert.assertEquals( "WHERE FALSE", wc.toSQL() );
    }

    public void test_orTrue()
            throws Exception
    {
        WhereClause wc = F.or( wcStrEqual, F.alwaysTrue() );

        Assert.assertEquals( "Where TRUE", wc.toString() );
        Assert.assertEquals( "WHERE TRUE", wc.toSQL() );
    }

    public void test_orFalse()
            throws Exception
    {
        WhereClause wc = F.or( wcStrEqual, F.alwaysFalse() );

        Assert.assertEquals( "Where TheStrAttr == \"gas\"", wc.toString() );
        Assert.assertEquals( "WHERE TheStrCol = 'gas'", wc.toSQL() );
    }

    public void test_and()
            throws Exception
    {
        WhereClause wc = F.and( wcStrEqual, wcIntEqual );

        Assert.assertEquals( "Where (TheStrAttr == \"gas\") AND (TheIntAttr == 5)", wc.toString() );
        Assert.assertEquals( "WHERE (TheStrCol = 'gas') AND (TheIntCol = 5)", wc.toSQL() );
    }

    public void test_and_and()
            throws Exception
    {
        WhereClause wc = F.and( wcStrEqual, F.and( wcIntEqual, wcIntEqual2 ) );

        Assert.assertEquals( "Where (TheStrAttr == \"gas\") AND (TheIntAttr == 5) AND (TheInt2Attr == 6)", wc.toString() );
        Assert.assertEquals( "WHERE (TheStrCol = 'gas') AND (TheIntCol = 5) AND (TheInt2Col = 6)", wc.toSQL() );
    }

    public void test_not_and()
            throws Exception
    {
        WhereClause wc = F.not( F.and( wcStrEqual, wcIntEqual ) );

        Assert.assertEquals( "Where NOT ((TheStrAttr == \"gas\") AND (TheIntAttr == 5))", wc.toString() );
        Assert.assertEquals( "WHERE NOT ((TheStrCol = 'gas') AND (TheIntCol = 5))", wc.toSQL() );
    }

    public void test_or()
            throws Exception
    {
        WhereClause wc = F.or( wcStrEqual, wcIntEqual );

        Assert.assertEquals( "Where (TheStrAttr == \"gas\") OR (TheIntAttr == 5)", wc.toString() );
        Assert.assertEquals( "WHERE (TheStrCol = 'gas') OR (TheIntCol = 5)", wc.toSQL() );
    }

    public void test_or_or()
            throws Exception
    {
        WhereClause wc = F.or( wcStrEqual, F.or( wcIntEqual, wcIntEqual2 ) );

        Assert.assertEquals( "Where (TheStrAttr == \"gas\") OR (TheIntAttr == 5) OR (TheInt2Attr == 6)", wc.toString() );
        Assert.assertEquals( "WHERE (TheStrCol = 'gas') OR (TheIntCol = 5) OR (TheInt2Col = 6)", wc.toSQL() );
    }

    public void test_and_or()
            throws Exception
    {
        WhereClause wc = F.and( wcStrEqual, F.or( wcIntEqual, wcIntEqual2 ) );

        Assert.assertEquals( "Where (TheStrAttr == \"gas\") AND ((TheIntAttr == 5) OR (TheInt2Attr == 6))", wc.toString() );
        Assert.assertEquals( "WHERE (TheStrCol = 'gas') AND ((TheIntCol = 5) OR (TheInt2Col = 6))", wc.toSQL() );
    }

    public void test_isIn()
            throws Exception
    {
        WhereClause wc = F.isIn( TheInteger2, zSingleColumnSelect );

        Assert.assertEquals( "Where TheInt2Attr IsIn (Select TheIntAttr From zTable Where TheStrAttr != null)", wc.toString() );
        Assert.assertEquals( "WHERE TheInt2Col IN (SELECT TheIntCol FROM TheTable WHERE TheStrCol IS NOT NULL)", wc.toSQL() );
    }

    public void test_isNotIn()
            throws Exception
    {
        WhereClause wc = F.isNotIn( TheInteger2, zSingleColumnSelect );

        Assert.assertEquals( "Where TheInt2Attr IsNotIn (Select TheIntAttr From zTable Where TheStrAttr != null)", wc.toString() );
        Assert.assertEquals( "WHERE TheInt2Col NOT IN (SELECT TheIntCol FROM TheTable WHERE TheStrCol IS NOT NULL)", wc.toSQL() );
    }

    public void test_isAnyOf()
            throws Exception
    {
        WhereClause wc = F.isAnyOf( TheInteger2 );

        Assert.assertEquals( "Where FALSE", wc.toString() );
        Assert.assertEquals( "WHERE FALSE", wc.toSQL() );

        wc = F.isAnyOf( TheInteger2, "gas" );

        Assert.assertEquals( "Where TheInt2Attr == gas", wc.toString() );
        Assert.assertEquals( "WHERE TheInt2Col = gas", wc.toSQL() );

        wc = F.isAnyOf( TheInteger2, "gas", "drs" );

        Assert.assertEquals( "Where TheInt2Attr isAnyOf (gas,drs)", wc.toString() );
        Assert.assertEquals( "WHERE TheInt2Col IN (gas,drs)", wc.toSQL() );
    }

    public void test_isNotAnyOf()
            throws Exception
    {
        WhereClause wc = F.isNotAnyOf( TheInteger2 );

        Assert.assertEquals( "Where TRUE", wc.toString() );
        Assert.assertEquals( "WHERE TRUE", wc.toSQL() );

        wc = F.isNotAnyOf( TheInteger2, "gas" );

        Assert.assertEquals( "Where TheInt2Attr != gas", wc.toString() );
        Assert.assertEquals( "WHERE (TheInt2Col <> gas) OR (TheInt2Col IS NULL)", wc.toSQL() );

        wc = F.isNotAnyOf( TheInteger2, "gas", "drs" );

        Assert.assertEquals( "Where TheInt2Attr isNotAnyOf (gas,drs)", wc.toString() );
        Assert.assertEquals( "WHERE TheInt2Col NOT IN (gas,drs)", wc.toSQL() );
    }
}