Examples of java.text.ParsePosition

java.text.ParsePosition
ParsePosition is a simple class used by Format and its subclasses to keep track of the current position during parsing. The parseObject method in the various Format classes requires a ParsePosition object as an argument.
By design, as you parse through a string with different formats, you can use the same ParsePosition, since the index parameter records the current position. @version 1.20 11/17/05 @author Mark Davis @see java.text.Format

    public void testParseMinusInfinityBigDecimalFalse() {
        // Regression test for HARMONY-106
        DecimalFormat format = (DecimalFormat) DecimalFormat.getInstance();
        DecimalFormatSymbols symbols = new DecimalFormatSymbols();
        Number number = format.parse("-" + symbols.getInfinity(),
                new ParsePosition(0));
        assertTrue(number instanceof Double);
        assertTrue(Double.isInfinite(number.doubleValue()));
    }

View Full Code Here

    public void test_parseLjava_lang_StringLjava_text_ParsePosition() {
        // Test for method java.lang.Object []
        // java.text.MessageFormat.parse(java.lang.String,
        // java.text.ParsePosition)
        MessageFormat format = new MessageFormat("date is {0,date,MMM d, yyyy}");
        ParsePosition pos = new ParsePosition(2);
        Object[] result = (Object[]) format
                .parse("xxdate is Feb 28, 1999", pos);
        assertTrue("No result: " + result.length, result.length >= 1);
        assertTrue("Wrong answer", ((Date) result[0])
                .equals(new GregorianCalendar(1999, Calendar.FEBRUARY, 28)
                        .getTime()));


        MessageFormat mf = new MessageFormat("vm={0},{1},{2}");
        result = mf.parse("vm=win,foo,bar", new ParsePosition(0));
        assertTrue("Invalid parse", result[0].equals("win")
                && result[1].equals("foo") && result[2].equals("bar"));


        mf = new MessageFormat("{0}; {0}; {0}");
        String parse = "a; b; c";
        result = mf.parse(parse, new ParsePosition(0));
    assertEquals("Wrong variable result", "c", result[0]);
    }

View Full Code Here

     * @return the Date represented by the given string using one of the given masks. It returns <b>null</b> if it was
     *         not possible to parse the the string with any of the masks.
     */
    private static Date parseUsingMask(String[] masks, String sDate) {
        sDate = (sDate != null) ? sDate.trim() : null;
        ParsePosition pp;
        Date d = null;
        if (sDate != null) {
            for (int i = 0; d == null && i < masks.length; i++) {
                DateFormat df = new SimpleDateFormat(masks[i], Locale.US);
                df.setLenient(true);
                pp = new ParsePosition(0);
                d = df.parse(sDate, pp);
                if (pp.getIndex() != sDate.length()) {
                    d = null;
                }
            }
        }
        return d;

View Full Code Here

              
              if(value == null || value.length() == 0) {
                 writer.print("null");
              } else {
                 // Is it a number?
                 ParsePosition pos = new ParsePosition(0);
                 formatter.parse(value, pos);
                 if(value.length() == pos.getIndex()) {
                    // It's a number. Remove leading zeros and output
                    value = value.replaceFirst("^0+(\\d)", "$1");
                    writer.print(value);
                 } else {
                    // Not a number, escape it

View Full Code Here

    public void test_parseLjava_lang_StringLjava_text_ParsePosition() {
        // Test for method java.lang.Object []
        // java.text.MessageFormat.parse(java.lang.String,
        // java.text.ParsePosition)
        MessageFormat format = new MessageFormat("date is {0,date,MMM d, yyyy}");
        ParsePosition pos = new ParsePosition(2);
        Object[] result = (Object[]) format
                .parse("xxdate is Feb 28, 1999", pos);
        assertTrue("No result: " + result.length, result.length >= 1);
        assertTrue("Wrong answer", ((Date) result[0])
                .equals(new GregorianCalendar(1999, Calendar.FEBRUARY, 28)
                        .getTime()));


        MessageFormat mf = new MessageFormat("vm={0},{1},{2}");
        result = mf.parse("vm=win,foo,bar", new ParsePosition(0));
        assertTrue("Invalid parse", result[0].equals("win")
                && result[1].equals("foo") && result[2].equals("bar"));


        mf = new MessageFormat("{0}; {0}; {0}");
        String parse = "a; b; c";
        result = mf.parse(parse, new ParsePosition(0));
    assertEquals("Wrong variable result", "c", result[0]);
    }

View Full Code Here

        char allowed_chars[] = { 0x9, 0x20 };
        String allowed_char_names[] = { "tab", "space" };
        for (int i = 0; i < allowed_chars.length; i++) {
            Date expected = new GregorianCalendar(1970, Calendar.JANUARY, 1, 9,
                    7, 6).getTime();
            ParsePosition pp = new ParsePosition(0);
            Date d = df.parse(allowed_chars[i] + "9:07:06", pp);
            assertNotNull("hour may be prefixed by " + allowed_char_names[i], d);
            assertEquals(expected, d);


            pp = new ParsePosition(0);
            d = df.parse("09:" + allowed_chars[i] + "7:06", pp);
            assertNotNull("minute may be prefixed by " + allowed_char_names[i],
                    d);
            assertEquals(expected, d);


            pp = new ParsePosition(0);
            d = df.parse("09:07:" + allowed_chars[i] + "6", pp);
            assertNotNull("second may be prefixed by " + allowed_char_names[i],
                    d);
            assertEquals(expected, d);
        }


        char not_allowed_chars[] = {
        // whitespace
                0x1c, 0x1d, 0x1e, 0x1f, 0xa, 0xb, 0xc, 0xd, 0x2001, 0x2002,
                0x2003, 0x2004, 0x2005, 0x2006, 0x2008, 0x2009, 0x200a, 0x200b,
                0x2028, 0x2029, 0x3000,
                // non-breaking space
                0xA0, 0x2007, 0x202F };


        for (int i = 0; i < not_allowed_chars.length; i++) {


            ParsePosition pp = new ParsePosition(0);
            Date d = df.parse(not_allowed_chars[i] + "9:07", pp);
            assertNull(d);


            pp = new ParsePosition(0);
            d = df.parse("09:" + not_allowed_chars[i] + "7", pp);
            assertNull(d);


            pp = new ParsePosition(0);
            d = df.parse("09:07:" + not_allowed_chars[i] + "6", pp);
            assertNull(d);
        }
    }

View Full Code Here


    // Test the type of the returned object


    public void test_parseLjava_lang_String_Ljava_text_ParsePosition() {
        DecimalFormat form = (DecimalFormat) DecimalFormat.getInstance(Locale.US);
        Number number = form.parse("23.1", new ParsePosition(0));
        assertTrue(number instanceof Double);


        // Test parsed object of type double when
        // parseBigDecimal is set to true


        form = (DecimalFormat) DecimalFormat.getInstance(Locale.US);
        number = form.parse("23.1", new ParsePosition(0));
        assertTrue(number instanceof Double);


        form.setParseBigDecimal(true);
        number = form.parse("23.1", new ParsePosition(0));


        assertTrue(number instanceof BigDecimal);
        assertEquals(new BigDecimal("23.1"), number);


        // When parseIntegerOnly set to true, all float numbers will be parsed
        // into Long.
        // With the exception that, the value is out of the bound of Long or
        // some special values such as NaN or Infinity.


        form = (DecimalFormat) DecimalFormat.getInstance(Locale.US);
        form.setParseIntegerOnly(true);
        number = form.parse("23.1f", new ParsePosition(0));


        assertTrue(number instanceof Long);


        number = form.parse("23.0", new ParsePosition(0));
        assertTrue(number instanceof Long);


        number = form.parse("-0.0", new ParsePosition(0));
        assertTrue(number instanceof Long);
        assertTrue(new Long(0).equals(number));


        number = form.parse("-9,223,372,036,854,775,8080.00",
                new ParsePosition(0));
        assertTrue(number instanceof Double);


        // Even if parseIntegerOnly is set to true, NaN will be parsed to Double


        form = (DecimalFormat) DecimalFormat.getInstance(Locale.US);
        form.setParseIntegerOnly(true);
        DecimalFormatSymbols symbols = new DecimalFormatSymbols();
        number = form.parse(symbols.getNaN(), new ParsePosition(0));
        assertTrue(number instanceof Double);


        // Even if parseIntegerOnly is set to true, Infinity will still be
        // parsed to Double


        form = (DecimalFormat) DecimalFormat.getInstance(Locale.US);
        form.setParseIntegerOnly(true);
        symbols = new DecimalFormatSymbols();
        number = form.parse(symbols.getInfinity(), new ParsePosition(0));
        assertTrue(number instanceof Double);


        // ParseBigDecimal take precedence of parseBigInteger


        form = (DecimalFormat) DecimalFormat.getInstance(Locale.US);
        form.setParseIntegerOnly(true);
        form.setParseBigDecimal(true);


        number = form.parse("23.1f", new ParsePosition(0));


        assertTrue(number instanceof BigDecimal);


        number = form.parse("23.0", new ParsePosition(0));
        assertTrue(number instanceof BigDecimal);


        number = form.parse("-9,223,372,036,854,775,8080.00",
                new ParsePosition(0));
        assertFalse(number instanceof BigInteger);
        assertTrue(number instanceof BigDecimal);


        // Test whether the parsed object is of type float. (To be specific,
        // they are of type Double)


        form = (DecimalFormat) DecimalFormat.getInstance(Locale.US);


        number = form.parse("23.1f", new ParsePosition(0));
        assertTrue(number instanceof Double);


        form.setParseBigDecimal(true);
        number = form.parse("23.1f", new ParsePosition(0));
        assertTrue(number instanceof BigDecimal);
        assertEquals(new BigDecimal("23.1"), number);


        // Integer will be parsed to Long, unless parseBigDecimal is set to true


        form = (DecimalFormat) DecimalFormat.getInstance(Locale.US);


        number = form.parse("123", new ParsePosition(0));
        assertTrue(number instanceof Long);


        form.setParseBigDecimal(true);
        number = form.parse("123", new ParsePosition(0));
        assertTrue(number instanceof BigDecimal);
        assertEquals(new BigDecimal("123"), number);


        // NaN will be parsed to Double, no matter parseBigDecimal set or not.


        form = (DecimalFormat) DecimalFormat.getInstance(Locale.US);
        symbols = new DecimalFormatSymbols();
        number = form.parse(symbols.getNaN() + "", new ParsePosition(0));
        assertTrue(number instanceof Double);


        form.setParseBigDecimal(true);
        number = form.parse(symbols.getNaN() + "", new ParsePosition(0));
        assertTrue(number instanceof Double);


        // Infinity will be parsed to Double, no matter parseBigDecimal set or
        // not.


        form = (DecimalFormat) DecimalFormat.getInstance(Locale.US);
        symbols = new DecimalFormatSymbols();


        number = form.parse(symbols.getInfinity(), new ParsePosition(0));


        assertTrue(number instanceof Double);
        assertEquals("Infinity", number.toString());
        // When set bigDecimal to true, the result of parsing infinity


        form = (DecimalFormat) DecimalFormat.getInstance(Locale.US);
        symbols = new DecimalFormatSymbols();
        form.setParseBigDecimal(true);


        number = form.parse(symbols.getInfinity(), new ParsePosition(0));
        assertTrue(number instanceof Double);
        assertEquals("Infinity", number.toString());


        // Negative infinity will be parsed to double no matter parseBigDecimal
        // set or not


        form = (DecimalFormat) DecimalFormat.getInstance(Locale.US);
        symbols = new DecimalFormatSymbols();


        number = form.parse("-" + symbols.getInfinity(), new ParsePosition(0));


        assertTrue(number instanceof Double);
        assertEquals("-Infinity", number.toString());


        // When set bigDecimal to true, the result of parsing minus infinity


        form = (DecimalFormat) DecimalFormat.getInstance(Locale.US);
        symbols = new DecimalFormatSymbols();
        form.setParseBigDecimal(true);


        number = form.parse("-" + symbols.getInfinity(), new ParsePosition(0));


        assertTrue(number instanceof Double);
        assertEquals("-Infinity", number.toString());


        // -0.0 will be parsed to different type according to the combination of
        // parseBigDecimal and parseIntegerOnly


        form = (DecimalFormat) DecimalFormat.getInstance(Locale.US);


        // parseBigDecimal == true;
        // parseIntegerOnly == false;
        form.setParseBigDecimal(true);
        number = form.parse("-0", new ParsePosition(0));
        assertTrue(number instanceof BigDecimal);


        number = form.parse("-0.0", new ParsePosition(0));
        assertTrue(number instanceof BigDecimal);


        // parseBigDecimal == false;
        // parseIntegerOnly == true;
        form.setParseBigDecimal(false);
        form.setParseIntegerOnly(true);
        number = form.parse("-0", new ParsePosition(0));


        assertTrue(number instanceof Long);


        number = form.parse("-0.0", new ParsePosition(0));
        assertTrue(number instanceof Long);


        // parseBigDecimal == false;
        // parseIntegerOnly == false;
        form.setParseBigDecimal(false);
        form.setParseIntegerOnly(false);
        number = form.parse("-0", new ParsePosition(0));
        assertTrue(number instanceof Double);


        number = form.parse("-0.0", new ParsePosition(0));
        assertTrue(number instanceof Double);


        // parseBigDecimal == true;
        // parseIntegerOnly == true;
        // parseBigDecimal take precedence of parseBigInteger
        form.setParseBigDecimal(true);
        form.setParseIntegerOnly(true);
        number = form.parse("-0", new ParsePosition(0));
        assertTrue(number instanceof BigDecimal);


        number = form.parse("-0.0", new ParsePosition(0));
        assertTrue(number instanceof BigDecimal);


        number = form.parse("12.4", new ParsePosition(0));
        assertTrue(number instanceof BigDecimal);


        // When parseBigDecimal is set to false, no matter how massive the
        // mantissa part of a number is, the number will be parsed into Double


        form = (DecimalFormat) DecimalFormat.getInstance(Locale.US);


        number = form.parse("9,223,372,036,854,775,808.00",
                new ParsePosition(0));


        assertTrue(number instanceof Double);
        assertEquals("9.223372036854776E18", number.toString());


        number = form.parse("-9,223,372,036,854,775,8080.00",
                new ParsePosition(0));
        assertTrue(number instanceof Double);
        assertEquals("-9.223372036854776E19", number.toString());


        // When parseBigDecimal is set to true, if mantissa part of number
        // exceeds Long.MAX_VALUE, the number will be parsed into BigDecimal


        form = (DecimalFormat) DecimalFormat.getInstance(Locale.US);


        form.setParseBigDecimal(true);
        number = form.parse("9,223,372,036,854,775,808.00",
                new ParsePosition(0));


        assertTrue(number instanceof BigDecimal);


        assertEquals(9.223372036854776E18, number.doubleValue(), 0);


        number = form.parse("-9,223,372,036,854,775,8080.00",
                new ParsePosition(0));


        assertTrue(number instanceof BigDecimal);
        assertEquals(-9.223372036854776E19, number.doubleValue(), 0);


        // The minimum value of Long will be parsed to Long when parseBigDecimal
        // is not set


        ParsePosition pos = new ParsePosition(0);
        DecimalFormat df = new DecimalFormat();
        pos = new ParsePosition(0);
        Number nb = df.parse("" + Long.MIN_VALUE, pos);
        assertTrue(nb instanceof Long);


        // The maximum value of Long will be parsed to Long when parseBigDecimal
        // is set
        pos = new ParsePosition(0);
        df = new DecimalFormat();
        pos = new ParsePosition(0);
        nb = df.parse("" + Long.MAX_VALUE, pos);
        assertTrue(nb instanceof Long);


        // When parsing invalid string( which is neither consist of digits nor
        // NaN/Infinity), a null will be returned.


        pos = new ParsePosition(0);
        df = new DecimalFormat();
        try {
            nb = df.parse("invalid", pos);
            assertNull(nb);
        } catch (NullPointerException e) {

View Full Code Here

     */
    //FIXME This test fails on Harmony ClassLibrary
    public void test_parseLjava_lang_StringLjava_text_ParsePosition() {
        DecimalFormat format = (DecimalFormat) NumberFormat
                .getNumberInstance(Locale.ENGLISH);
        ParsePosition pos = new ParsePosition(0);
        Number result = format.parse("9223372036854775807", pos);
        assertTrue("Wrong result type for Long.MAX_VALUE",
                result.getClass() == Long.class);
        assertTrue("Wrong result Long.MAX_VALUE",
                result.longValue() == Long.MAX_VALUE);
        pos = new ParsePosition(0);
        result = format.parse("-9223372036854775808", pos);
        assertTrue("Wrong result type for Long.MIN_VALUE",
                result.getClass() == Long.class);
        assertTrue("Wrong result Long.MIN_VALUE: " + result.longValue(), result
                .longValue() == Long.MIN_VALUE);
        pos = new ParsePosition(0);
        result = format.parse("9223372036854775808", pos);
        assertTrue("Wrong result type for Long.MAX_VALUE+1",
                result.getClass() == Double.class);
        assertTrue("Wrong result Long.MAX_VALUE + 1",
                result.doubleValue() == (double) Long.MAX_VALUE + 1);
        pos = new ParsePosition(0);
        result = format.parse("-9223372036854775809", pos);
        assertTrue("Wrong result type for Long.MIN_VALUE+1",
                result.getClass() == Double.class);
        assertTrue("Wrong result Long.MIN_VALUE - 1",
                result.doubleValue() == (double) Long.MIN_VALUE - 1);


        pos = new ParsePosition(0);
        result = format.parse("18446744073709551629", pos);
        assertTrue("Wrong result type for overflow",
                result.getClass() == Double.class);
        assertTrue("Wrong result for overflow",
                result.doubleValue() == 18446744073709551629d);


        pos = new ParsePosition(0);
        result = format.parse("42325917317067571199", pos);
        assertTrue("Wrong result type for overflow a: " + result, result
                .getClass() == Double.class);
        assertTrue("Wrong result for overflow a: " + result, result
                .doubleValue() == 42325917317067571199d);
        pos = new ParsePosition(0);
        result = format.parse("4232591731706757119E1", pos);
        assertTrue("Wrong result type for overflow b: " + result, result
                .getClass() == Double.class);
        assertTrue("Wrong result for overflow b: " + result, result
                .doubleValue() == 42325917317067571190d);
        pos = new ParsePosition(0);
        result = format.parse(".42325917317067571199E20", pos);
        assertTrue("Wrong result type for overflow c: " + result, result
                .getClass() == Double.class);
        assertTrue("Wrong result for overflow c: " + result, result
                .doubleValue() == 42325917317067571199d);
        pos = new ParsePosition(0);
        result = format.parse("922337203685477580.9E1", pos);
        assertTrue("Wrong result type for overflow d: " + result, result
                .getClass() == Double.class);
        assertTrue("Wrong result for overflow d: " + result, result
                .doubleValue() == 9223372036854775809d);
        pos = new ParsePosition(0);
        result = format.parse("9.223372036854775809E18", pos);
        assertTrue("Wrong result type for overflow e: " + result, result
                .getClass() == Double.class);
        assertTrue("Wrong result for overflow e: " + result, result
                .doubleValue() == 9223372036854775809d);


        // test parse with multipliers
        format.setMultiplier(100);
        result = format.parse("9223372036854775807", new ParsePosition(0));
        assertTrue("Wrong result type multiplier 100: " + result, result
                .getClass() == Long.class);
        assertTrue("Wrong result for multiplier 100: " + result, result
                .longValue() == 92233720368547758L);


        format.setMultiplier(1000);
        result = format.parse("9223372036854775807", new ParsePosition(0));
        assertTrue("Wrong result type multiplier 1000: " + result, result
                .getClass() == Long.class);
        assertTrue("Wrong result for multiplier 1000: " + result, result
                .longValue() == 9223372036854776L);


        format.setMultiplier(10000);
        result = format.parse("9223372036854775807", new ParsePosition(0));
        assertTrue("Wrong result type multiplier 10000: " + result, result
                .getClass() == Double.class);
        assertTrue("Wrong result for multiplier 10000: " + result, result
                .doubleValue() == 922337203685477.5807d);

View Full Code Here

    public void test_setMultiplierI() {
        DecimalFormat df = new DecimalFormat("###0.##");
        df.setMultiplier(10);
        assertEquals("Wrong multiplier", 10, df.getMultiplier());
        assertEquals("Wrong format", "50", df.format(5));
        assertEquals("Wrong parse", 5, df.parse("50", new ParsePosition(0))
                .intValue());
        
        // regression test for HARMONY-879
        df.setMultiplier(-1);
        assertEquals("Wrong  multiplier for negative value", -1, df.getMultiplier());

View Full Code Here

    public void testParseInfinityBigDecimalFalse() {
        // Regression test for HARMONY-106
        DecimalFormat format = (DecimalFormat) DecimalFormat.getInstance();
        DecimalFormatSymbols symbols = new DecimalFormatSymbols();
        Number number = format.parse(symbols.getInfinity(),
                new ParsePosition(0));
        assertTrue(number instanceof Double);
        assertTrue(Double.isInfinite(number.doubleValue()));
    }

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

Related Classes of java.text.ParsePosition

com.alibaba.citrus.service.requestcontext.util.CookieSupportTests

com.couchbase.client.protocol.views.Query

com.datastax.driver.core.TypeCodec$DateCodec

com.dooapp.fxform.view.factory.delegate.AbstractNumberPropertyDelegate

com.facebook.presto.jdbc.internal.jackson.databind.util.StdDateFormat

com.fasterxml.jackson.databind.util.ISO8601UtilsTest

com.fasterxml.jackson.databind.util.StdDateFormat

com.google.visualization.datasource.base.BooleanFormat

com.google.visualization.datasource.base.BooleanFormatTest

com.google.visualization.datasource.base.TextFormatTest

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.