utilitytest.java

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

/*
 * Created on Mar 6, 2003
 *
 * To change this generated comment go to 
 * Window>Preferences>Java>Code Generation>Code Template
 */

package org.jibx.runtime;

import java.sql.Timestamp;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.TimeZone;

import junit.framework.TestCase;

/**
 * @author dennis
 */
 
public class UtilityTest extends TestCase {
	
	private static long LMS_PER_DAY = (long)24*60*60*1000;
	private DateFormat m_dateTimeFormat =
		new SimpleDateFormat("yyyy-MM-dd'T'hh:mm:ss");
	private DateFormat m_dateFormat =
		new SimpleDateFormat("yyyy-MM-dd");
	private DateFormat m_yearFormat =
		new SimpleDateFormat("yyyy");
	private Calendar m_calendar = 
		new GregorianCalendar(TimeZone.getTimeZone("UTC"));

	/**
	 * Constructor for UtilityTest.
	 * @param arg0
	 */
	public UtilityTest(String arg0) {
		super(arg0);
		m_dateTimeFormat.setCalendar(m_calendar);
		m_dateFormat.setCalendar(m_calendar);
		m_yearFormat.setCalendar(m_calendar);
	}

	public void testParseInt() throws JiBXException {
		assertEquals(0, Utility.parseInt("0"));
		assertEquals(2000000000, Utility.parseInt("2000000000"));
		assertEquals(-2000000000, Utility.parseInt("-2000000000"));
		assertEquals(2000000000, Utility.parseInt("[phone]"));
		try {
			Utility.parseInt("-");
			fail();
		} catch (JiBXException ex) {}
		try {
			Utility.parseInt("+");
			fail();
		} catch (JiBXException ex) {}
		try {
			Utility.parseInt("20000000000");
			fail();
		} catch (JiBXException ex) {}
		try {
			Utility.parseInt("-20000000000");
			fail();
		} catch (JiBXException ex) {}
		try {
			Utility.parseInt("[phone]");
			fail();
		} catch (JiBXException ex) {}
		try {
			Utility.parseInt("2000000X");
			fail();
		} catch (JiBXException ex) {}
	}

	public void testSerializeInt() throws JiBXException {
		assertEquals("0", Utility.serializeInt(0));
		assertEquals("2000000", Utility.serializeInt(2000000));
		assertEquals("2000000000", Utility.serializeInt(2000000000));
		assertEquals("-2000000", Utility.serializeInt(-2000000));
		assertEquals("-2000000000", Utility.serializeInt(-2000000000));
	}

	public void testParseLong() throws JiBXException {
		assertEquals(0, Utility.parseLong("0"));
		assertEquals(2000000000, Utility.parseLong("2000000000"));
		assertEquals(-2000000000, Utility.parseLong("-2000000000"));
		assertEquals(2000000000, Utility.parseLong("[phone]"));
		assertEquals(200000000000000L, Utility.parseLong("200000000000000"));
		assertEquals(-200000000000000L, Utility.parseLong("-200000000000000"));
		assertEquals(200000000000000L, Utility.parseLong("[phone]"));
		try {
			Utility.parseLong("-");
			fail();
		} catch (JiBXException ex) {}
		try {
			Utility.parseLong("+");
			fail();
		} catch (JiBXException ex) {}
		try {
			Utility.parseLong("2000000X");
			fail();
		} catch (JiBXException ex) {}
	}

	public void testSerializeLong() {
		assertEquals("0", Utility.serializeLong(0));
		assertEquals("2000000", Utility.serializeLong(2000000));
		assertEquals("2000000000000000",
			Utility.serializeLong(2000000000000000L));
		assertEquals("-2000000", Utility.serializeLong(-2000000));
		assertEquals("-2000000000000000",
			Utility.serializeLong(-2000000000000000L));
	}
	
	public void testParseShort() throws JiBXException {
		assertEquals(0, Utility.parseShort("0"));
		assertEquals(20000, Utility.parseShort("20000"));
		assertEquals(-20000, Utility.parseShort("-20000"));
		assertEquals(20000, Utility.parseShort("+20000"));
		try {
			Utility.parseShort("-");
			fail();
		} catch (JiBXException ex) {}
		try {
			Utility.parseShort("+");
			fail();
		} catch (JiBXException ex) {}
		try {
			Utility.parseShort("2000000");
			fail();
		} catch (JiBXException ex) {}
		try {
			Utility.parseShort("2000X");
			fail();
		} catch (JiBXException ex) {}
	}

	public void testSerializeShort() {
		assertEquals("0", Utility.serializeShort((short)0));
		assertEquals("20000", Utility.serializeShort((short)20000));
		assertEquals("-20000", Utility.serializeShort((short)-20000));
	}
	
	public void testParseByte() throws JiBXException {
		assertEquals(0, Utility.parseByte("0"));
		assertEquals(100, Utility.parseByte("100"));
		assertEquals(-100, Utility.parseByte("-100"));
		assertEquals(100, Utility.parseByte("+100"));
		try {
			Utility.parseByte("-");
			fail();
		} catch (JiBXException ex) {}
		try {
			Utility.parseByte("+");
			fail();
		} catch (JiBXException ex) {}
		try {
			Utility.parseByte("128");
			fail();
		} catch (JiBXException ex) {}
		try {
			Utility.parseByte("10X");
			fail();
		} catch (JiBXException ex) {}
	}

	public void testSerializeByte() {
		assertEquals("0", Utility.serializeByte((byte)0));
		assertEquals("100", Utility.serializeByte((byte)100));
		assertEquals("-100", Utility.serializeByte((byte)-100));
	}

	public void testParseBoolean() throws JiBXException {
		assertTrue(Utility.parseBoolean("true"));
		assertTrue(Utility.parseBoolean("1"));
		assertFalse(Utility.parseBoolean("false"));
		assertFalse(Utility.parseBoolean("0"));
		try {
			Utility.parseBoolean("x");
			fail();
		} catch (JiBXException ex) {}
		try {
			Utility.parseBoolean("2");
			fail();
		} catch (JiBXException ex) {}
		try {
			Utility.parseBoolean("+1");
			fail();
		} catch (JiBXException ex) {}
	}

	public void testSerializeBoolean() {
		assertEquals("true", Utility.serializeBoolean(true));
		assertEquals("false", Utility.serializeBoolean(false));
	}

	public void testParseChar() throws JiBXException {
		assertEquals(0, Utility.parseChar("0"));
		assertEquals(100, Utility.parseChar("100"));
		assertEquals(1000, Utility.parseChar("+1000"));
		assertEquals(65000, Utility.parseChar("65000"));
		try {
			Utility.parseChar("-");
			fail();
		} catch (JiBXException ex) {}
		try {
			Utility.parseChar("+");
			fail();
		} catch (JiBXException ex) {}
		try {
			Utility.parseChar("-10");
			fail();
		} catch (JiBXException ex) {}
		try {
			Utility.parseChar("69000");
			fail();
		} catch (JiBXException ex) {}
	}

	public void testSerializeChar() {
		assertEquals("0", Utility.serializeChar((char)0));
		assertEquals("100", Utility.serializeChar((char)100));
		assertEquals("60000", Utility.serializeChar((char)60000));
	}

	public void testParseFloat() throws JiBXException {
		assertEquals(1.0f, Utility.parseFloat("1.0"), 0.000001f);
		assertEquals(1000000000.0f, Utility.parseFloat("1000000000.0"), 100.0f);
		assertEquals(0.0000000001f,
			Utility.parseFloat("0.0000000001"), 1.0e-17f);
		assertEquals(0, Float.compare(-0.0f, Utility.parseFloat("-0")));
		assertEquals(0, Float.compare(Float.NEGATIVE_INFINITY,
			Utility.parseFloat("-INF")));
		assertEquals(0, Float.compare(Float.POSITIVE_INFINITY,
			Utility.parseFloat("INF")));
		assertEquals(0, Float.compare(Float.NaN, Utility.parseFloat("NaN")));
		try {
			Utility.parseFloat("NAN");
			fail();
		} catch (JiBXException ex) {}
		try {
			Utility.parseFloat("+INF");
			fail();
		} catch (JiBXException ex) {}
		try {
			Utility.parseFloat("1E+2.5");
			fail();
		} catch (JiBXException ex) {}
	}

	public void testSerializeFloat() {
		assertEquals("1.0", Utility.serializeFloat(1.0f));
		assertEquals("1.0E9", Utility.serializeFloat(1000000000.0f));
		assertEquals("1.0E-10", Utility.serializeFloat(0.0000000001f));
		assertEquals("-INF", Utility.serializeFloat(Float.NEGATIVE_INFINITY));
		assertEquals("INF", Utility.serializeFloat(Float.POSITIVE_INFINITY));
		assertEquals("NaN", Utility.serializeFloat(Float.NaN));
	}

	public void testParseDouble() throws JiBXException {
		assertEquals(1.0d, Utility.parseDouble("1.0"), 1.0e-12d);
		assertEquals(1000000000.0d, Utility.parseDouble("1000000000.0"), 0.01d);
		assertEquals(0.0000000001d,
			Utility.parseDouble("0.0000000001"), 1.0e-22d);
		assertEquals(0, Double.compare(-0.0d, Utility.parseDouble("-0")));
		assertEquals(0, Double.compare(Double.NEGATIVE_INFINITY,
			Utility.parseDouble("-INF")));
		assertEquals(0, Double.compare(Double.POSITIVE_INFINITY,
			Utility.parseDouble("INF")));
		assertEquals(0, Double.compare(Double.NaN, Utility.parseDouble("NaN")));
		try {
			Utility.parseDouble("NAN");
			fail();
		} catch (JiBXException ex) {}
		try {
			Utility.parseDouble("+INF");
			fail();
		} catch (JiBXException ex) {}
		try {
			Utility.parseDouble("1E+2.5");
			fail();
		} catch (JiBXException ex) {}
	}

	public void testSerializeDouble() {
		assertEquals("1.0", Utility.serializeDouble(1.0d));
		assertEquals("1.0E9", Utility.serializeDouble(1000000000.0d));
		assertEquals("1.0E-10", Utility.serializeDouble(0.0000000001d));
		assertEquals("-INF", Utility.serializeDouble(Double.NEGATIVE_INFINITY));
		assertEquals("INF", Utility.serializeDouble(Double.POSITIVE_INFINITY));
		assertEquals("NaN", Utility.serializeDouble(Double.NaN));
	}

	public void testParseYear() {
	}

	public void testParseYearMonth() {
	}

	public void testParseDate() throws JiBXException {
		assertEquals(0, Utility.parseDate("1970-01-01"));
		assertEquals(LMS_PER_DAY, Utility.parseDate("1970-01-02"));
		assertEquals(LMS_PER_DAY,
			Utility.parseDate("0001-03-01") - Utility.parseDate("0001-02-28"));
		assertEquals(LMS_PER_DAY,
			Utility.parseDate("0001-01-01") - Utility.parseDate("-0001-12-31"));
		assertEquals(LMS_PER_DAY,
			Utility.parseDate("-0001-03-01") -
			Utility.parseDate("-0001-02-28"));
		assertEquals(LMS_PER_DAY*2,
			Utility.parseDate("-0004-03-01") -
			Utility.parseDate("-0004-02-28"));
		try {
			Utility.parseDate("[phone]");
			fail();
		} catch (JiBXException ex) {}
		try {
			Utility.parseDate("197X-01-01");
			fail();
		} catch (JiBXException ex) {}
		try {
			Utility.parseDate("1970-1-01");
			fail();
		} catch (JiBXException ex) {}
		try {
			Utility.parseDate("1970-01-32");
			fail();
		} catch (JiBXException ex) {}
		try {
			Utility.parseDate("1970-02-29");
			fail();
		} catch (JiBXException ex) {}
		try {
			Utility.parseDate("01-01-01");
			fail();
		} catch (JiBXException ex) {}
		try {
			Utility.parseDate("0001-02-29");
			fail();
		} catch (JiBXException ex) {}
		try {
			Utility.parseDate("0000-01-01");
			fail();
		} catch (JiBXException ex) {}
		try {
			Utility.parseDate("-0001-02-29");
			fail();
		} catch (JiBXException ex) {}
		try {
			Utility.parseDate("-0003-02-29");
			fail();
		} catch (JiBXException ex) {}
	}

	public void testParseDateTime() throws JiBXException {
		assertEquals(0, Utility.parseDateTime("1970-01-01T00:00:00.000"));
		assertEquals(0, Utility.parseDateTime("1970-01-01T00:00:00"));
		assertEquals(1, Utility.parseDateTime("1970-01-01T00:00:00.001"));
		assertEquals(1000, Utility.parseDateTime("1970-01-01T00:00:01"));
		assertEquals(60*1000, Utility.parseDateTime("1970-01-01T00:01:00"));
		assertEquals(60*60*1000, Utility.parseDateTime("1970-01-01T01:00:00Z"));
		assertEquals(60*60*1000,
			Utility.parseDateTime("1970-01-01T02:00:00+01:00"));
		assertEquals(LMS_PER_DAY,
			Utility.parseDateTime("1970-01-02T00:00:00Z"));
		assertEquals(LMS_PER_DAY,
			Utility.parseDateTime("0001-03-01T00:00:00Z") -
			Utility.parseDateTime("0001-02-28T00:00:00Z"));
		assertEquals(1000, Utility.parseDateTime("0001-01-01T00:00:00Z") -
			Utility.parseDateTime("-0001-12-31T23:59:59Z"));
		assertEquals(LMS_PER_DAY,
			Utility.parseDateTime("0001-01-01T00:00:00Z") -
			Utility.parseDateTime("-0001-12-31T00:00:00Z"));
		assertEquals(LMS_PER_DAY,
			Utility.parseDateTime("-0001-03-01T00:00:00Z") -
			Utility.parseDateTime("-0001-02-28T00:00:00Z"));
		assertEquals(LMS_PER_DAY*2,
			Utility.parseDateTime("-0004-03-01T00:00:00Z") -
			Utility.parseDateTime("-0004-02-28T00:00:00Z"));
		try {
			Utility.parseDateTime("[phone]T00:00:00.000");
			fail();
		} catch (JiBXException ex) {}
		try {
			Utility.parseDateTime("197X-01-01T00:00:00.000");
			fail();
		} catch (JiBXException ex) {}
		try {
			Utility.parseDateTime("1970-1-01T00:00:00.000");
			fail();
		} catch (JiBXException ex) {}
		try {
			Utility.parseDateTime("1970-01-01T00:00");
			fail();
		} catch (JiBXException ex) {}
		try {
			Utility.parseDateTime("1970-01-32T00:00:00");
			fail();
		} catch (JiBXException ex) {}
		try {
			Utility.parseDateTime("1970-02-29T00:00:00");
			fail();
		} catch (JiBXException ex) {}
		try {
			Utility.parseDateTime("1970-01-01T60:00:00");
			fail();
		} catch (JiBXException ex) {}
		try {
			Utility.parseDateTime("1970-01-01T-5:00:00");
			fail();
		} catch (JiBXException ex) {}
		try {
			Utility.parseDateTime("01-01-01T00:00:00");
			fail();
		} catch (JiBXException ex) {}
		try {
			Utility.parseDateTime("0001-02-29T00:00:00");
			fail();
		} catch (JiBXException ex) {}
		try {
			Utility.parseDateTime("0000-01-01T00:00:00");
			fail();