utilitytest.java

对xml很好的java处理引擎,编译中绑定xml

		} catch (JiBXException ex) {}
		try {
			Utility.parseDateTime("-0001-02-29T00:00:00");
			fail();
		} catch (JiBXException ex) {}
		try {
			Utility.parseDateTime("-0003-02-29T00:00:00");
			fail();
		} catch (JiBXException ex) {}
	}

	public void testDeserializeDateTime() {
	}
	
	private void trySerializeYear(String dt)
		throws JiBXException, ParseException {
		Date date = m_yearFormat.parse(dt);
		String result = Utility.serializeYear(date);
		assertEquals(dt, result);
	}
	
	private void tryRoundtripYear(String dt) throws JiBXException {
		long time = Utility.parseYear(dt);
		String result = Utility.serializeYear(new Date(time));
//		System.out.println("Parsed date " + dt + " to value " + time +
//			", serialized as " + result);
		assertEquals(dt, result);
	}

	public void testSerializeYear() throws JiBXException, ParseException {
		trySerializeYear("1970");
		trySerializeYear("1969");
		trySerializeYear("1968");
		trySerializeYear("1967");
		trySerializeYear("1966");
		trySerializeYear("1965");
		trySerializeYear("1800");
		trySerializeYear("1600");
		trySerializeYear("1999");
		trySerializeYear("2000");
		trySerializeYear("2999");
		trySerializeYear("3000");
		trySerializeYear("9999");
		tryRoundtripYear("1970");
		tryRoundtripYear("1969");
		tryRoundtripYear("1968");
		tryRoundtripYear("1967");
		tryRoundtripYear("1966");
		tryRoundtripYear("1965");
		tryRoundtripYear("1800");
		tryRoundtripYear("1600");
		tryRoundtripYear("1999");
		tryRoundtripYear("2000");
		tryRoundtripYear("2001");
		tryRoundtripYear("2002");
		tryRoundtripYear("2999");
		tryRoundtripYear("3000");
		tryRoundtripYear("9999");
		
		// the following values can only be tested roundtrip (because Java
		//  conversion insists on a discontinuity in Gregorian calendar)
		tryRoundtripYear("12999");
		tryRoundtripYear("1300");
		tryRoundtripYear("0300");
		tryRoundtripYear("0001");
		tryRoundtripYear("-0001");
		tryRoundtripYear("-0004");
		tryRoundtripYear("-0005");
		tryRoundtripYear("-0199");
		tryRoundtripYear("-0198");
	}

	public void testSerializeYearMonth() throws JiBXException {
		assertEquals("1970-01", Utility.serializeYearMonth(new Date(0)));
	}
	
	private void trySerializeDate(String dt)
		throws JiBXException, ParseException {
		Date date = m_dateFormat.parse(dt);
		String result = Utility.serializeDate(date);
		assertEquals(dt, result);
	}
	
	private void tryRoundtripDate(String dt) throws JiBXException {
		long time = Utility.parseDate(dt);
		String result = Utility.serializeDate(new Date(time));
//		System.out.println("Parsed date " + dt + " to value " + time +
//			", serialized as " + result);
		assertEquals(dt, result);
	}
    
//#!j2me{
    private void trySerializeSqlDate(String dt)
        throws JiBXException, ParseException {
        java.sql.Date date = java.sql.Date.valueOf(dt);
        String result = Utility.serializeSqlDate(date);
        assertEquals(dt, result);
    }
    
    private void tryRoundtripSqlDate(String dt) throws JiBXException {
        java.sql.Date date1 = Utility.deserializeSqlDate(dt);
        java.sql.Date date2 = java.sql.Date.valueOf(dt);
        assertEquals(date1, date2);
        String result = Utility.serializeSqlDate(date1);
        assertEquals(dt, result);
    }
    
    private void tryRoundtripOnlySqlDate(String dt) throws JiBXException {
        java.sql.Date date1 = Utility.deserializeSqlDate(dt);
        String result = Utility.serializeSqlDate(date1);
        assertEquals(dt, result);
    }
//#j2me}

	public void testSerializeDate() throws JiBXException, ParseException {
		trySerializeDate("1970-01-01");
		trySerializeDate("1970-02-01");
		trySerializeDate("1970-01-02");
		trySerializeDate("1969-12-31");
		trySerializeDate("1969-01-01");
		trySerializeDate("1969-02-28");
		trySerializeDate("1969-03-01");
		trySerializeDate("1968-01-01");
		trySerializeDate("1968-02-29");
		trySerializeDate("1968-03-01");
		trySerializeDate("1967-01-01");
		trySerializeDate("1966-01-01");
		trySerializeDate("1965-01-01");
		trySerializeDate("1800-01-01");
		trySerializeDate("1600-11-11");
		trySerializeDate("1999-12-31");
		trySerializeDate("2000-01-01");
		trySerializeDate("2000-02-29");
		trySerializeDate("2000-12-31");
		trySerializeDate("2001-01-01");
		trySerializeDate("2001-12-31");
		trySerializeDate("2002-01-01");
        trySerializeDate("2002-02-13");
		trySerializeDate("2999-12-31");
		trySerializeDate("3000-01-01");
		trySerializeDate("3000-12-31");
		trySerializeDate("9999-12-31");
		tryRoundtripDate("1970-01-01");
		tryRoundtripDate("1970-02-01");
		tryRoundtripDate("1970-01-02");
		tryRoundtripDate("1969-12-31");
		tryRoundtripDate("1969-01-01");
		tryRoundtripDate("1969-02-28");
		tryRoundtripDate("1969-03-01");
		tryRoundtripDate("1968-01-01");
		tryRoundtripDate("1968-02-29");
		tryRoundtripDate("1968-03-01");
		tryRoundtripDate("1967-01-01");
		tryRoundtripDate("1966-01-01");
		tryRoundtripDate("1965-01-01");
		tryRoundtripDate("1800-01-01");
		tryRoundtripDate("1600-11-11");
		tryRoundtripDate("1999-12-31");
		tryRoundtripDate("2000-01-01");
		tryRoundtripDate("2000-02-29");
		tryRoundtripDate("2000-12-31");
		tryRoundtripDate("2001-01-01");
		tryRoundtripDate("2001-12-31");
		tryRoundtripDate("2002-01-01");
        tryRoundtripDate("2002-02-13");
		tryRoundtripDate("2999-12-31");
		tryRoundtripDate("3000-01-01");
		tryRoundtripDate("3000-12-31");
		tryRoundtripDate("9999-12-31");
		
		// the following values can only be tested roundtrip (because Java
		//  conversion insists on a discontinuity in Gregorian calendar)
		tryRoundtripDate("12999-12-31");
		tryRoundtripDate("1300-01-01");
		tryRoundtripDate("0300-12-31");
		tryRoundtripDate("0001-01-01");
		tryRoundtripDate("-0001-12-31");
		tryRoundtripDate("-0004-02-29");
		tryRoundtripDate("-0004-03-01");
		tryRoundtripDate("-0004-12-31");
		tryRoundtripDate("-0005-02-28");
		tryRoundtripDate("-0005-03-01");
		tryRoundtripDate("-0199-12-31");
		tryRoundtripDate("-0198-01-01");
	}

//#!j2me{
    public void testSerializeSqlDate() throws JiBXException, ParseException {
        trySerializeSqlDate("1970-01-01");
        trySerializeSqlDate("1970-02-01");
        trySerializeSqlDate("1970-01-02");
        trySerializeSqlDate("1969-12-31");
        trySerializeSqlDate("1969-01-01");
        trySerializeSqlDate("1969-02-28");
        trySerializeSqlDate("1969-03-01");
        trySerializeSqlDate("1968-01-01");
        trySerializeSqlDate("1968-02-29");
        trySerializeSqlDate("1968-03-01");
        trySerializeSqlDate("1967-01-01");
        trySerializeSqlDate("1966-01-01");
        trySerializeSqlDate("1965-01-01");
        trySerializeSqlDate("1800-01-01");
        trySerializeSqlDate("1600-11-11");
        trySerializeSqlDate("1999-12-31");
        trySerializeSqlDate("2000-01-01");
        trySerializeSqlDate("2000-02-29");
        trySerializeSqlDate("2000-12-31");
        trySerializeSqlDate("2001-01-01");
        trySerializeSqlDate("2001-12-31");
        trySerializeSqlDate("2002-01-01");
        trySerializeSqlDate("2002-02-13");
        trySerializeSqlDate("2999-12-31");
        trySerializeSqlDate("3000-01-01");
        trySerializeSqlDate("3000-12-31");
        trySerializeSqlDate("9999-12-31");
        tryRoundtripSqlDate("1970-01-01");
        tryRoundtripSqlDate("1970-02-01");
        tryRoundtripSqlDate("1970-01-02");
        tryRoundtripSqlDate("1969-12-31");
        tryRoundtripSqlDate("1969-01-01");
        tryRoundtripSqlDate("1969-02-28");
        tryRoundtripSqlDate("1969-03-01");
        tryRoundtripSqlDate("1968-01-01");
        tryRoundtripSqlDate("1968-02-29");
        tryRoundtripSqlDate("1968-03-01");
        tryRoundtripSqlDate("1967-01-01");
        tryRoundtripSqlDate("1966-01-01");
        tryRoundtripSqlDate("1965-01-01");
        tryRoundtripSqlDate("1800-01-01");
        tryRoundtripSqlDate("1600-11-11");
        tryRoundtripSqlDate("1999-12-31");
        tryRoundtripSqlDate("2000-01-01");
        tryRoundtripSqlDate("2000-02-29");
        tryRoundtripSqlDate("2000-12-31");
        tryRoundtripSqlDate("2001-01-01");
        tryRoundtripSqlDate("2001-12-31");
        tryRoundtripSqlDate("2002-01-01");
        tryRoundtripSqlDate("2002-02-13");
        tryRoundtripSqlDate("2999-12-31");
        tryRoundtripSqlDate("3000-01-01");
        tryRoundtripSqlDate("3000-12-31");
        tryRoundtripSqlDate("9999-12-31");
        tryRoundtripSqlDate("12999-12-31");
        
        // the following values can only be tested roundtrip (because Java
        //  conversion insists on a discontinuity in Gregorian calendar)
        tryRoundtripOnlySqlDate("1300-01-01");
        tryRoundtripOnlySqlDate("0300-12-31");
        tryRoundtripOnlySqlDate("0001-01-01");
        tryRoundtripOnlySqlDate("-0001-12-31");
        // should work, but inconsistency in conversions at present
//        tryRoundtripOnlySqlDate("-0004-02-29");
        tryRoundtripOnlySqlDate("-0004-03-01");
        tryRoundtripOnlySqlDate("-0004-12-31");
        tryRoundtripOnlySqlDate("-0005-02-28");
        tryRoundtripOnlySqlDate("-0005-03-01");
        tryRoundtripOnlySqlDate("-0199-12-31");
        tryRoundtripOnlySqlDate("-0198-01-01");
    }
    
    public void testSerializeTimestamp() throws JiBXException {
        Timestamp ts = Timestamp.valueOf("2006-09-07 15:37:10.123456");
        String text = Utility.serializeTimestamp(ts);
        assertTrue("Timestamp serialization error",
            text.startsWith("2006-09-0"));
        assertTrue("Timestamp serialization error",
            text.endsWith(":37:10.123456Z"));
        assertEquals("Timestamp deserialization error", ts,
            Utility.deserializeTimestamp(text));
    }
//#j2me}
	
	private void trySerializeDateTime(String dt)
		throws JiBXException, ParseException {
		Date date = m_dateTimeFormat.parse(dt);
		String result = Utility.serializeDateTime(date);
		assertEquals(dt, result);
	}
	
	private void tryRoundtripDateTime(String dt) throws JiBXException {
		long time = Utility.parseDateTime(dt);
		String result = Utility.serializeDateTime(new Date(time));
//		System.out.println("Parsed date " + dt + " to value " + time +
//			", serialized as " + result);
		assertEquals(dt, result);
	}

	public void testSerializeDateTime() throws JiBXException, ParseException {
		assertEquals("1970-01-01T00:00:00Z",
			Utility.serializeDateTime(new Date(0)));
		trySerializeDateTime("1970-01-01T00:00:00Z");
		trySerializeDateTime("1970-01-01T01:00:00Z");
		trySerializeDateTime("1970-01-01T00:01:00Z");
		trySerializeDateTime("1970-01-01T00:00:01Z");
		trySerializeDateTime("1970-01-01T23:59:59Z");
		trySerializeDateTime("1970-02-01T00:00:00Z");
		trySerializeDateTime("1970-01-02T00:00:00Z");
		trySerializeDateTime("1969-12-31T23:59:59Z");
		trySerializeDateTime("1969-01-01T00:00:00Z");
		trySerializeDateTime("1969-02-28T00:00:00Z");
		trySerializeDateTime("1969-03-01T00:00:00Z");
		trySerializeDateTime("1968-01-01T00:00:00Z");
		trySerializeDateTime("1968-02-29T00:00:00Z");
		trySerializeDateTime("1968-03-01T00:00:00Z");
		trySerializeDateTime("1967-01-01T00:00:00Z");
		trySerializeDateTime("1966-01-01T00:00:00Z");
		trySerializeDateTime("1965-01-01T00:00:00Z");
		trySerializeDateTime("1800-01-01T00:00:00Z");
		trySerializeDateTime("1600-11-11T23:59:59Z");
		trySerializeDateTime("1999-12-31T23:59:59Z");
		trySerializeDateTime("2000-01-01T00:00:00Z");
		trySerializeDateTime("2000-02-29T00:00:00Z");
		trySerializeDateTime("2000-12-31T23:59:59Z");
		trySerializeDateTime("2001-01-01T00:00:00Z");
        trySerializeDateTime("2001-02-28T18:54:31Z");
		trySerializeDateTime("2001-12-31T23:59:59Z");
		trySerializeDateTime("2002-01-01T00:00:00Z");
		trySerializeDateTime("2999-12-31T23:59:59Z");
		trySerializeDateTime("3000-01-01T00:00:00Z");
		trySerializeDateTime("3000-12-31T23:59:59Z");
		trySerializeDateTime("9999-12-31T23:59:59Z");
		tryRoundtripDateTime("1970-01-01T00:00:00Z");
		tryRoundtripDateTime("1970-01-01T01:00:00Z");
		tryRoundtripDateTime("1970-01-01T00:01:00Z");
		tryRoundtripDateTime("1970-01-01T00:00:01Z");
		tryRoundtripDateTime("1970-01-01T23:59:59Z");
		tryRoundtripDateTime("1970-02-01T00:00:00Z");
		tryRoundtripDateTime("1970-01-02T00:00:00Z");
		tryRoundtripDateTime("1969-12-31T23:59:59Z");
		tryRoundtripDateTime("1969-01-01T00:00:00Z");
		tryRoundtripDateTime("1969-02-28T00:00:00Z");
		tryRoundtripDateTime("1969-03-01T00:00:00Z");
		tryRoundtripDateTime("1968-01-01T00:00:00Z");
		tryRoundtripDateTime("1968-02-29T00:00:00Z");
		tryRoundtripDateTime("1968-03-01T00:00:00Z");
		tryRoundtripDateTime("1967-01-01T00:00:00Z");
		tryRoundtripDateTime("1966-01-01T00:00:00Z");
		tryRoundtripDateTime("1965-01-01T00:00:00Z");
		tryRoundtripDateTime("1800-01-01T00:00:00Z");
		tryRoundtripDateTime("1600-11-11T23:59:59Z");
		tryRoundtripDateTime("1999-12-31T23:59:59Z");
		tryRoundtripDateTime("2000-01-01T00:00:00Z");
		tryRoundtripDateTime("2000-02-29T00:00:00Z");
		tryRoundtripDateTime("2000-12-31T23:59:59Z");
		tryRoundtripDateTime("2001-01-01T00:00:00Z");
        tryRoundtripDateTime("2001-02-28T18:54:31Z");
		tryRoundtripDateTime("2001-12-31T23:59:59Z");
		tryRoundtripDateTime("2002-01-01T00:00:00Z");
		tryRoundtripDateTime("2999-12-31T23:59:59Z");
		tryRoundtripDateTime("3000-01-01T00:00:00Z");
		tryRoundtripDateTime("3000-12-31T23:59:59Z");
		tryRoundtripDateTime("9999-12-31T23:59:59Z");
		
		// the following values can only be tested roundtrip (because Java
		//  conversion insists on a discontinuity in Gregorian calendar)
		tryRoundtripDateTime("12999-12-31T23:59:59Z");
		tryRoundtripDateTime("1300-01-01T00:00:00Z");
		tryRoundtripDateTime("0300-12-31T23:59:59Z");
		tryRoundtripDateTime("0001-01-01T00:00:00Z");
		tryRoundtripDateTime("-0001-12-31T23:59:59Z");
		tryRoundtripDateTime("-0004-02-29T23:59:59Z");
		tryRoundtripDateTime("-0004-03-01T23:59:59Z");
		tryRoundtripDateTime("-0199-12-31T23:59:59Z");
		tryRoundtripDateTime("-0198-01-01T00:00:00Z");
	}
    
    private boolean equalsBytes(byte[] a, byte[] b) {
        if (a == null) {
            return b == null;
        } else if (b == null) {
            return false;
        } else if (a.length != b.length) {
            return false;
        } else {
            for (int i = 0; i < a.length; i++) {
                if (a[i] != b[i]) {
                    return false;
                }
            }
            return true;
        }
    }
    
	public void testParseBase64() throws JiBXException {
		assertTrue(equalsBytes(Utility.parseBase64(""), new byte[0]));
        assertTrue(equalsBytes(Utility.parseBase64("Cg=="), "\n".getBytes()));
        assertTrue(equalsBytes(Utility.parseBase64("d2hhdA=="),
            "what".getBytes()));
        assertTrue(equalsBytes(Utility.parseBase64
            ("d2hhdCB3aWxsIHByaW50IG91dA=="),
            "what will print out".getBytes()));
        assertTrue(equalsBytes(Utility.parseBase64
            ("d2hhdCAgd2lsbCAgIHByaW50ICAgICBvdXQgICAgICA="),
            "what  will   print     out      ".getBytes()));
        assertTrue(equalsBytes(Utility.parseBase64
            ("d2hhdCAgd2lsbCAgIHByaW50ICAgICBvdXQ="),
            "what  will   print     out".getBytes()));
	}

	public void testSerializeBase64() {
		assertEquals(Utility.serializeBase64(new byte[0]), "");
		assertEquals(Utility.serializeBase64("\n".getBytes()), "Cg==");
		assertEquals(Utility.serializeBase64("what".getBytes()), "d2hhdA==");
		assertEquals(Utility.serializeBase64("what will print out".getBytes()),
            "d2hhdCB3aWxsIHByaW50IG91dA==");
		assertEquals(Utility.serializeBase64
            ("what  will   print     out      ".getBytes()),
            "d2hhdCAgd2lsbCAgIHByaW50ICAgICBvdXQgICAgICA=");
		assertEquals(Utility.serializeBase64
            ("what  will   print     out".getBytes()),
            "d2hhdCAgd2lsbCAgIHByaW50ICAgICBvdXQ=");
	}

	public void testIsEqual() {
		assertTrue(Utility.isEqual(null, null));
		assertFalse(Utility.isEqual(null, "text"));
		assertFalse(Utility.isEqual("text", null));
		assertTrue(Utility.isEqual("text", "text"));
	}
    
	public static void main(String[] args) {
		String[] names = { UtilityTest.class.getName() };
		junit.textui.TestRunner.main(names);
	}
}