Java example source code file (ISO8601ZoneTest.java)

This example Java source code file (ISO8601ZoneTest.java) is included in the alvinalexander.com "Java Source Code Warehouse" project. The intent of this project is to help you "Learn Java by Example" ^TM.

Learn more about this Java project at its project page.

Java - Java tags/keywords

america\/los_angeles, australia\/sydney, gmt\+05\:30, gmt\-07\:00, illegalargumentexception, iso8601zonetest, parseexception, parseposition, runtimeexception, simpledateformat, string, text, utc, util, xxx

The ISO8601ZoneTest.java Java example source code

/*
 * Copyright (c) 2010, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

/*
 * @test
 * @bug 4919632
 * @summary Unit test for ISO8601 time zone format support
 */

import java.text.*;
import java.util.*;

public class ISO8601ZoneTest {
    static final Date TIMESTAMP = new Date(1283758039020L);

    static final String[][] formatData = {
        // time zone name, expected output at TIMESTAMP
        { "America/Los_Angeles", "2010-09-06T00:27:19.020-07", },
        { "America/Los_Angeles", "2010-09-06T00:27:19.020-0700", },
        { "America/Los_Angeles", "2010-09-06T00:27:19.020-07:00", },
        { "Australia/Sydney", "2010-09-06T17:27:19.020+10", },
        { "Australia/Sydney", "2010-09-06T17:27:19.020+1000", },
        { "Australia/Sydney", "2010-09-06T17:27:19.020+10:00", },
        { "GMT-07:00", "2010-09-06T00:27:19.020-07", },
        { "GMT-07:00", "2010-09-06T00:27:19.020-0700", },
        { "GMT-07:00", "2010-09-06T00:27:19.020-07:00", },
        { "UTC", "2010-09-06T07:27:19.020Z", },
        { "UTC", "2010-09-06T07:27:19.020Z", },
        { "UTC", "2010-09-06T07:27:19.020Z", },
    };

    static final String[] zones = {
        "America/Los_Angeles", "Australia/Sydney", "GMT-07:00",
        "UTC", "GMT+05:30", "GMT-01:23",
    };

    static final String[] isoZoneFormats = {
        "yyyy-MM-dd'T'HH:mm:ss.SSSX",
        "yyyy-MM-dd'T'HH:mm:ss.SSSXX",
        "yyyy-MM-dd'T'HH:mm:ss.SSSXXX",
    };

    // badData[][0] - format
    // badData[][1] - (bad) text to be parsed
    // badData[][2] - subtext at the end of which a parse error is detected
    static final String[][] badData = {
        { "X", "1", "1" },
        { "X", "+1", "+1" },
        { "X", "-2", "-2" },
        { "X", "-24", "-2" },
        { "X", "+24", "+2" },

        { "XX", "9", "9" },
        { "XX", "23", "2" },
        { "XX", "234", "2" },
        { "XX", "3456", "3" },
        { "XX", "23456", "2" },
        { "XX", "+1", "+1" },
        { "XX", "-12", "-12" },
        { "XX", "+123", "+123" },
        { "XX", "-12:34", "-12" },
        { "XX", "+12:34", "+12" },
        { "XX", "-2423", "-2" },
        { "XX", "+2423", "+2" },
        { "XX", "-1260", "-126" },
        { "XX", "+1260", "+126" },

        { "XXX", "9", "9" },
        { "XXX", "23", "2" },
        { "XXX", "234", "2" },
        { "XXX", "3456", "3" },
        { "XXX", "23456", "2" },
        { "XXX", "2:34", "2" },
        { "XXX", "12:4", "1" },
        { "XXX", "12:34", "1" },
        { "XXX", "-1", "-1" },
        { "XXX", "+1", "+1" },
        { "XXX", "-12", "-12" },
        { "XXX", "+12", "+12" },
        { "XXX", "-123", "-12" },
        { "XXX", "+123", "+12" },
        { "XXX", "-1234", "-12" },
        { "XXX", "+1234", "+12" },
        { "XXX", "+24:23", "+2" },
        { "XXX", "+12:60", "+12:6" },
        { "XXX", "+1:23", "+1" },
        { "XXX", "+12:3", "+12:3" },
    };

    static String[] badFormats = {
        "XXXX", "XXXXX", "XXXXXX",
    };

    public static void main(String[] args) throws Exception {
        TimeZone tz = TimeZone.getDefault();
        Locale loc = Locale.getDefault();
        Locale.setDefault(Locale.US);

        try {
            for (int i = 0; i < formatData.length; i++) {
                TimeZone.setDefault(TimeZone.getTimeZone(formatData[i][0]));
                formatTest(isoZoneFormats[i % isoZoneFormats.length],
                           formatData[i][1]);
            }

            for (String zone : zones) {
                TimeZone.setDefault(TimeZone.getTimeZone(zone));
                for (String fmt : isoZoneFormats) {
                    roundtripTest(fmt);
                    SimpleDateFormat f = new SimpleDateFormat(fmt);
                }

            }

            for (String[] d : badData) {
                badDataParsing(d[0], d[1], d[2].length());
            }

            for (String fmt : badFormats) {
                badFormat(fmt);
            }
        } finally {
            TimeZone.setDefault(tz);
            Locale.setDefault(loc);
        }

    }

    static void formatTest(String fmt, String expected) throws Exception {
        SimpleDateFormat sdf = new SimpleDateFormat(fmt);
        String s = sdf.format(TIMESTAMP);
        if (!expected.equals(s)) {
            throw new RuntimeException("formatTest: got " + s
                                       + ", expected " + expected);
        }

        Date d = sdf.parse(s);
        if (d.getTime() != TIMESTAMP.getTime()) {
            throw new RuntimeException("formatTest: parse(" + s
                                       + "), got " + d.getTime()
                                       + ", expected " + TIMESTAMP.getTime());
        }

        ParsePosition pos = new ParsePosition(0);
        d = sdf.parse(s + "123", pos);
        if (d.getTime() != TIMESTAMP.getTime()) {
            throw new RuntimeException("formatTest: parse(" + s
                                       + "), got " + d.getTime()
                                       + ", expected " + TIMESTAMP.getTime());
        }
        if (pos.getIndex() != s.length()) {
            throw new RuntimeException("formatTest: wrong resulting parse position: "
                                       + pos.getIndex() + ", expected " + s.length());
        }
    }

    static void roundtripTest(String fmt) throws Exception {
        SimpleDateFormat sdf = new SimpleDateFormat(fmt);
        Date date = new Date();

        int fractionalHour = sdf.getTimeZone().getOffset(date.getTime());
        fractionalHour %= 3600000; // fraction of hour

        String s = sdf.format(date);
        Date pd = sdf.parse(s);
        long diffsInMillis = pd.getTime() - date.getTime();
        if (diffsInMillis != 0) {
            if (diffsInMillis != fractionalHour) {
                throw new RuntimeException("fmt= " + fmt
                                           + ", diff="+diffsInMillis
                                           + ", fraction=" + fractionalHour);
            }
        }
    }


    static void badDataParsing(String fmt, String text, int expectedErrorIndex) {
        SimpleDateFormat sdf = new SimpleDateFormat(fmt);
        try {
            sdf.parse(text);
            throw new RuntimeException("didn't throw an exception: fmt=" + fmt
                                       + ", text=" + text);
        } catch (ParseException e) {
            // OK
        }

        ParsePosition pos = new ParsePosition(0);
        Date d = sdf.parse(text, pos);
        int errorIndex = pos.getErrorIndex();
        if (d != null || errorIndex != expectedErrorIndex) {
            throw new RuntimeException("Bad error index=" + errorIndex
                                       + ", expected=" + expectedErrorIndex
                                       + ", fmt=" + fmt + ", text=" + text);
        }
    }

    static void badFormat(String fmt) {
        try {
            SimpleDateFormat sdf = new SimpleDateFormat(fmt);
            throw new RuntimeException("Constructor didn't throw an exception: fmt=" + fmt);
        } catch (IllegalArgumentException e) {
            // OK
        }
        try {
            SimpleDateFormat sdf = new SimpleDateFormat();
            sdf.applyPattern(fmt);
            throw new RuntimeException("applyPattern didn't throw an exception: fmt=" + fmt);
        } catch (IllegalArgumentException e) {
            // OK
        }
    }
}