criteriatest.java

另外一种持久性o/m软件

        String result = null;
        try
        {
            result = BasePeer.createQueryString(c);
        }
        catch (TorqueException e)
        {
            fail("TorqueException thrown in BasePeer.createQueryString()");
        }

        assertEquals(expect, result);

        // test the postgresql variation
        c = new Criteria();
        Criteria.Criterion cc =
            c.getNewCriterion("TABLE.COLUMN", Boolean.TRUE, Criteria.EQUAL);

        Configuration conf = new BaseConfiguration();
        conf.addProperty("driver", "org.postgresql.Driver");
        try
        {
            cc.setDB(DBFactory.create("org.postgresql.Driver"));
        }
        catch (Exception e)
        {
            fail("Exception thrown in DBFactory");
        }

        assertEquals("TABLE.COLUMN=TRUE", cc.toString());
    }

    /**
     * testcase for addDate()
     */
    public void testAddDate()
    {
        Criteria c = new Criteria();
        c.addDate("TABLE.DATE_COLUMN", 2003, 0, 22);

        String expect = "SELECT  FROM TABLE WHERE TABLE.DATE_COLUMN='20030122000000'";

        String result = null;
        try
        {
            result = BasePeer.createQueryString(c);
        }
        catch (TorqueException e)
        {
            e.printStackTrace();
            fail("TorqueException thrown in BasePeer.createQueryString()");
        }
        assertEquals(expect, result);
    }

    /**
     * testcase for add(Date)
     */
    public void testDateAdd()
    {
        Calendar cal = Calendar.getInstance();
        cal.set(2003, 0, 22, 0, 0, 0);
        Date date = cal.getTime();
        Criteria c = new Criteria();
        c.add("TABLE.DATE_COLUMN", date);

        String expect = "SELECT  FROM TABLE WHERE TABLE.DATE_COLUMN='20030122000000'";

        String result = null;
        try
        {
            result = BasePeer.createQueryString(c);
        }
        catch (TorqueException e)
        {
            e.printStackTrace();
            fail("TorqueException thrown in BasePeer.createQueryString()");
        }
        assertEquals(expect, result);
    }

    public void testCurrentDate()
    {
        Criteria c = new Criteria()
                .add("TABLE.DATE_COLUMN", Criteria.CURRENT_DATE)
                .add("TABLE.TIME_COLUMN", Criteria.CURRENT_TIME);

        String expect = "SELECT  FROM TABLE WHERE TABLE.TIME_COLUMN=CURRENT_TIME AND TABLE.DATE_COLUMN=CURRENT_DATE";

        String result = null;
        try
        {
            result = BasePeer.createQueryString(c);
        }
        catch (TorqueException e)
        {
            e.printStackTrace();
            fail("TorqueException thrown in BasePeer.createQueryString()");
        }

        assertEquals(expect,result);
    }

    public void testCountAster()
    {
        Criteria c = new Criteria()
                .addSelectColumn("COUNT(*)")
                .add("TABLE.DATE_COLUMN", Criteria.CURRENT_DATE)
                .add("TABLE.TIME_COLUMN", Criteria.CURRENT_TIME);

        String expect = "SELECT COUNT(*) FROM TABLE WHERE TABLE.TIME_COLUMN=CURRENT_TIME AND TABLE.DATE_COLUMN=CURRENT_DATE";

        String result = null;
        try
        {
            result = BasePeer.createQueryString(c);
        }
        catch (TorqueException e)
        {
            e.printStackTrace();
            fail("TorqueException thrown in BasePeer.createQueryString()");
        }

        assertEquals(expect,result);

    }

    /**
     * This test case has been written to try out the fix applied to resolve
     * TRQS73 - i.e. ensuring that Criteria.toString() does not alter any limit
     * or offset that may be stored in the Criteria object.  This testcase
     * could actually pass without the fix if the database in use does not
     * support native limits and offsets.
     */
    public void testCriteriaToStringOffset()
    {
        Criteria c = new Criteria()
                .add("TABLE.DATE_COLUMN", Criteria.CURRENT_DATE)
                .setOffset(3)
                .setLimit(5);

        String toStringExpect = "Criteria:: TABLE.DATE_COLUMN<=>TABLE.DATE_COLUMN=CURRENT_DATE:  "
                + "\nCurrent Query SQL (may not be complete or applicable): "
                + "SELECT  FROM TABLE WHERE TABLE.DATE_COLUMN=CURRENT_DATE LIMIT 3, 5";

        String cString = c.toString();
        //System.out.println(cString);
        assertEquals(toStringExpect, cString);

        // Note that this is intentially the same as above as the behaviour is
        // only observed on subsequent invocations of toString().
        cString = c.toString();
        //System.out.println(cString);
        assertEquals(toStringExpect, cString);
    }

    /**
     * This test case has been written to try out the fix applied to resolve
     * TRQS73 - i.e. ensuring that Criteria.toString() does not alter any limit
     * or offset that may be stored in the Criteria object.  This testcase
     * could actually pass without the fix if the database in use does not
     * support native limits and offsets.
     */
    public void testCriteriaToStringLimit()
    {
        Criteria c = new Criteria()
                .add("TABLE.DATE_COLUMN", Criteria.CURRENT_DATE)
                .setLimit(5);

        String toStringExpect = "Criteria:: TABLE.DATE_COLUMN<=>TABLE.DATE_COLUMN=CURRENT_DATE:  "
                + "\nCurrent Query SQL (may not be complete or applicable): "
                + "SELECT  FROM TABLE WHERE TABLE.DATE_COLUMN=CURRENT_DATE LIMIT 5";

        String cString = c.toString();
        //System.out.println(cString);
        assertEquals(toStringExpect, cString);

        // Note that this is intentially the same as above as the behaviour is
        // only observed on subsequent invocations of toString().
        cString = c.toString();
        //System.out.println(cString);
        assertEquals(toStringExpect, cString);
    }

    /**
     * This test case verifies if the Criteria.LIKE comparison type will
     * get replaced through Criteria.EQUAL if there are no SQL wildcards
     * in the given value.
     */
    public void testLikeWithoutWildcards()
    {
        Criteria c = new Criteria();
        c.add("TABLE.COLUMN", (Object) "no wildcards", Criteria.LIKE);

        String expect = "SELECT  FROM TABLE WHERE TABLE.COLUMN = 'no wildcards'";

        String result = null;
        try
        {
            result = BasePeer.createQueryString(c);
        }
        catch (TorqueException e)
        {
            e.printStackTrace();
            fail("TorqueException thrown in BasePeer.createQueryString()");
        }

        assertEquals(expect, result);
    }

    /**
     * This test case verifies if the Criteria.NOT_LIKE comparison type will
     * get replaced through Criteria.NOT_EQUAL if there are no SQL wildcards
     * in the given value.
     */
    public void testNotLikeWithoutWildcards()
    {
        Criteria c = new Criteria();
        c.add("TABLE.COLUMN", (Object) "no wildcards", Criteria.NOT_LIKE);

        String firstExpect = "SELECT  FROM TABLE WHERE TABLE.COLUMN != 'no wildcards'";
        String secondExpect = "SELECT  FROM TABLE WHERE TABLE.COLUMN <> 'no wildcards'";

        String result = null;
        try
        {
            result = BasePeer.createQueryString(c);
        }
        catch (TorqueException e)
        {
            e.printStackTrace();
            fail("TorqueException thrown in BasePeer.createQueryString()");
        }

        assertTrue(result.equals(firstExpect) || result.equals(secondExpect));
    }

    /**
     * test for TRQS25
     */
/*
    public void testCriteriaAndString()
    {
        Criteria c = new Criteria()
                .add("TABLE.COLUMN1", "string")
                .and("TABLE.COLUMN2", "string", Criteria.LIKE);
    }
*/
}