assertEquals("query count", 2, getQueryCount(queries));

        Query testTable = (Query)queries.get(0);
        assertEquals("name", "TEST_TABLE", testTable.getName());
        assertEquals("sql", "SELECT * FROM test_table ORDER BY column0 DESC", testTable.getSql());

        Query pkTable = (Query)queries.get(1);
        assertEquals("name", "PK_TABLE", pkTable.getName());
        assertEquals("sql", "SELECT * FROM pk_table", pkTable.getSql());
    }

	public void testExportWithQuerySet() {
		String targetName = "test-export-with-queryset";
		Export export = (Export)getFirstStepFromTarget(targetName);
		assertEquals("format", "csv", export.getFormat());
		
		List queries = export.getTables();
		
		assertEquals("query count", 1, getQueryCount(queries));
		assertEquals("table count", 1, getTableCount(queries));	
		assertEquals("queryset count", 2, getQuerySetCount(queries));
		
		Query secondTable = (Query)queries.get(0);
		assertEquals("name", "SECOND_TABLE", secondTable.getName());
		assertEquals("sql", "SELECT * FROM SECOND_TABLE", secondTable.getSql());
			
		QuerySet queryset1 = (QuerySet)queries.get(1);
		
		Query testTable = (Query)queryset1.getQueries().get(0);
		
		assertEquals("name", "TEST_TABLE", testTable.getName());
		
		QuerySet queryset2 = (QuerySet)queries.get(2);
		
		Query pkTable = (Query)queryset2.getQueries().get(0);
		Query testTable2 = (Query)queryset2.getQueries().get(1);
		
		assertEquals("name", "PK_TABLE", pkTable.getName());
		assertEquals("name", "TEST_TABLE", testTable2.getName());
		
		Table emptyTable = (Table)queries.get(3);
		
		assertEquals("name", "EMPTY_TABLE", emptyTable.getName());
	}
	
	public void testWithBadQuerySet() {
		expectBuildException("invalid-queryset",
			"Cannot specify 'id' and 'refid' attributes together in queryset.");
	}
	
	public void testWithReferenceQuerySet() {
		String targetName = "test-queryset-reference";
		
		Export export = (Export)getFirstStepFromTarget(targetName);
		
		List tables = export.getTables();
		
		assertEquals("total count", 1, tables.size());
		
		QuerySet queryset = (QuerySet)tables.get(0);
		Query testTable = (Query)queryset.getQueries().get(0);
		Query secondTable = (Query)queryset.getQueries().get(1);
		
		assertEquals("name", "TEST_TABLE", testTable.getName());
		assertEquals("sql", "SELECT * FROM TEST_TABLE WHERE COLUMN0 = 'row0 col0'", 
					testTable.getSql());
					
		assertEquals("name", "SECOND_TABLE", secondTable.getName());	
		assertEquals("sql", 
			"SELECT B.* FROM TEST_TABLE A, SECOND_TABLE B " +
			"WHERE A.COLUMN0 = 'row0 col0' AND B.COLUMN0 = A.COLUMN0",
			secondTable.getSql());
		
	}
	
    public void testExportQueryMixed() {
        String targetName = "test-export-query-mixed";
        Export export = (Export)getFirstStepFromTarget(targetName);
        assertEquals("format", "flat", export.getFormat());

        List tables = export.getTables();
        assertEquals("total count", 2, tables.size());
        assertEquals("table count", 1, getTableCount(tables));
        assertEquals("query count", 1, getQueryCount(tables));

        Table testTable = (Table)tables.get(0);
        assertEquals("name", "TEST_TABLE", testTable.getName());

        Query pkTable = (Query)tables.get(1);
        assertEquals("name", "PK_TABLE", pkTable.getName());
    }

    public void testDataTypeFactory() throws Exception
    {
        String targetName = "test-datatypefactory";
        DbUnitTask task = getFirstTargetTask(targetName);

        IDatabaseConnection connection = task.createConnection();
        IDataTypeFactory factory = (IDataTypeFactory)connection.getConfig().getProperty(
                        DatabaseConfig.PROPERTY_DATATYPE_FACTORY);

        Class expectedClass = OracleDataTypeFactory.class;
        assertEquals("factory", expectedClass, factory.getClass());
    }

    public void testEscapePattern() throws Exception
    {
        String targetName = "test-escapepattern";
        DbUnitTask task = getFirstTargetTask(targetName);

        IDatabaseConnection connection = task.createConnection();
        String actualPattern = (String)connection.getConfig().getProperty(
                        DatabaseConfig.PROPERTY_ESCAPE_PATTERN);

        String expectedPattern = "[?]";
        assertEquals("factory", expectedPattern, actualPattern);
    }

    public void testClasspath() throws Exception
    {
        String targetName = "test-classpath";

        try
        {
            executeTarget(targetName);
            fail("Should not be able to connect with invalid url!");
        }
        catch (BuildException e)
        {
            // Verify exception type
            assertEquals("nested exception type", SQLException.class, e.getException().getClass());
        }

    }

    public void testDriverNotInClasspath() throws Exception
    {
        String targetName = "test-drivernotinclasspath";

        try
        {
            executeTarget(targetName);
            fail("Should not have found driver!");
        }
        catch (BuildException e)
        {
            // Verify exception type
            assertEquals("nested exception type", ClassNotFoundException.class, e.getException().getClass());
        }
    }
	
    protected void assertOperationType(String failMessage, String targetName, DatabaseOperation expected)
    {
        Operation oper = (Operation)getFirstStepFromTarget(targetName);
        DatabaseOperation dbOper = oper.getDbOperation();
        assertTrue(failMessage + ", but was: " + dbOper, expected.equals(dbOper));
    }

    protected int getQueryCount(List tables)
    {
        int count = 0;
        for (Iterator it = tables.iterator(); it.hasNext();)
        {
            if (it.next() instanceof Query)
            {
                count++;
            }
        }

        return count;
    }

    protected int getTableCount(List tables)
    {
        int count = 0;
        for (Iterator it = tables.iterator(); it.hasNext();)
        {
            if (it.next() instanceof Table)
            {
                count++;
            }
        }

        return count;
    }

	protected int getQuerySetCount(List tables) {
		int count = 0;
		for (Iterator it = tables.iterator(); it.hasNext();) {
			if (it.next() instanceof QuerySet) {
				count++;
			}
		}

		return count;
	}
	
    protected DbUnitTaskStep getFirstStepFromTarget(String targetName)
    {
        DbUnitTaskStep result = null;
        DbUnitTask task = getFirstTargetTask(targetName);
        List steps = task.getSteps();
        if (steps != null && steps.size() > 0)
        {
            result = (DbUnitTaskStep)steps.get(0);
        }
        else
        {
            fail("Can't get a dbunit <step> from the target: " + targetName);
        }
        return result;
    }

    private DbUnitTask getFirstTargetTask(String targetName)
    {
        Hashtable targets = project.getTargets();
        executeTarget(targetName);
        Target target = (Target)targets.get(targetName);
        
        DbUnitTask task = null;
        
        Object[] tasks = target.getTasks();
        for(int i = 0; i < tasks.length; i++) {
        	if(tasks[i] instanceof DbUnitTask) {
        		task = (DbUnitTask)tasks[i];
        	}
        }
        
        return task;
    }

    public static Test suite()
    {
        TestSuite suite = new TestSuite(classUnderTest);
        return suite;
    }

    public static void main(String args[])
    {
        if (args.length > 0 && args[0].equals("-gui"))
        {
            String[] testCaseName = {classUnderTest.getName()};
            junit.swingui.TestRunner.main(testCaseName);
        }
        else
        {
            junit.textui.TestRunner.run(suite());
        }
    }
}