/*

 * 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.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * 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.

 */

import java.io.BufferedReader;

import java.io.ByteArrayInputStream;

import java.io.ByteArrayOutputStream;

import java.io.File;

import java.io.FileInputStream;

import java.io.InputStreamReader;

import java.io.ObjectInputStream;

import java.io.ObjectOutputStream;

import java.net.URISyntaxException;

import java.net.URL;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.IllformedLocaleException;

import java.util.List;

import java.util.Locale;

import java.util.Locale.Builder;

import java.util.Set;

/**

 * @test

 * @bug 6875847 6992272 7002320 7015500 7023613

 * @summary test API changes to Locale

 */

public class LocaleEnhanceTest extends LocaleTestFmwk {

    public static void main(String[] args) throws Exception {

        List<String> argList = new ArrayList<String>();

        argList.addAll(Arrays.asList(args));

        argList.add("-nothrow");

        new LocaleEnhanceTest().run(argList.toArray(new String[argList.size()]));

    }

    public LocaleEnhanceTest() {

    }

    ///

    /// Generic sanity tests

    ///

    /** A canonical language code. */

    private static final String l = "en";

    /** A canonical script code.. */

    private static final String s = "Latn";

    /** A canonical region code. */

    private static final String c = "US";

    /** A canonical variant code. */

    private static final String v = "NewYork";

    /**

     * Ensure that Builder builds locales that have the expected

     * tag and java6 ID.  Note the odd cases for the ID.

     */

    public void testCreateLocaleCanonicalValid() {

        String[] valids = {

            "en-Latn-US-NewYork", "en_US_NewYork_#Latn",

            "en-Latn-US", "en_US_#Latn",

            "en-Latn-NewYork", "en__NewYork_#Latn", // double underscore

            "en-Latn", "en__#Latn", // double underscore

            "en-US-NewYork", "en_US_NewYork",

            "en-US", "en_US",

            "en-NewYork", "en__NewYork", // double underscore

            "en", "en",

            "und-Latn-US-NewYork", "_US_NewYork_#Latn",

            "und-Latn-US", "_US_#Latn",

            "und-Latn-NewYork", "", // variant only not supported

            "und-Latn", "",

            "und-US-NewYork", "_US_NewYork",

            "und-US", "_US",

            "und-NewYork", "", // variant only not supported

            "und", ""

        };

        Builder builder = new Builder();

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

            String tag = valids[i];

            String id = valids[i+1];

            String idl = (i & 16) == 0 ? l : "";

            String ids = (i & 8) == 0 ? s : "";

            String idc = (i & 4) == 0 ? c : "";

            String idv = (i & 2) == 0 ? v : "";

            String msg = String.valueOf(i/2) + ": '" + tag + "' ";

            try {

                Locale l = builder

                    .setLanguage(idl)

                    .setScript(ids)

                    .setRegion(idc)

                    .setVariant(idv)

                    .build();

                assertEquals(msg + "language", idl, l.getLanguage());

                assertEquals(msg + "script", ids, l.getScript());

                assertEquals(msg + "country", idc, l.getCountry());

                assertEquals(msg + "variant", idv, l.getVariant());

                assertEquals(msg + "tag", tag, l.toLanguageTag());

                assertEquals(msg + "id", id, l.toString());

            }

            catch (IllegalArgumentException e) {

                errln(msg + e.getMessage());

            }

        }

    }

    /**

     * Test that locale construction works with 'multiple variants'.

     * <p>

     * The string "Newer__Yorker" is treated as three subtags,

     * "Newer", "", and "Yorker", and concatenated into one

     * subtag by omitting empty subtags and joining the remainer

     * with underscores.  So the resulting variant tag is "Newer_Yorker".

     * Note that 'New' and 'York' are invalid BCP47 variant subtags

     * because they are too short.

     */

    public void testCreateLocaleMultipleVariants() {

        String[] valids = {

            "en-Latn-US-Newer-Yorker",  "en_US_Newer_Yorker_#Latn",

            "en-Latn-Newer-Yorker",     "en__Newer_Yorker_#Latn",

            "en-US-Newer-Yorker",       "en_US_Newer_Yorker",

            "en-Newer-Yorker",          "en__Newer_Yorker",

            "und-Latn-US-Newer-Yorker", "_US_Newer_Yorker_#Latn",

            "und-Latn-Newer-Yorker",    "",

            "und-US-Newer-Yorker",      "_US_Newer_Yorker",

            "und-Newer-Yorker",         "",

        };

        Builder builder = new Builder(); // lenient variant

        final String idv = "Newer_Yorker";

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

            String tag = valids[i];

            String id = valids[i+1];

            String idl = (i & 8) == 0 ? l : "";

            String ids = (i & 4) == 0 ? s : "";

            String idc = (i & 2) == 0 ? c : "";

            String msg = String.valueOf(i/2) + ": " + tag + " ";

            try {

                Locale l = builder

                    .setLanguage(idl)

                    .setScript(ids)

                    .setRegion(idc)

                    .setVariant(idv)

                    .build();

                assertEquals(msg + " language", idl, l.getLanguage());

                assertEquals(msg + " script", ids, l.getScript());

                assertEquals(msg + " country", idc, l.getCountry());

                assertEquals(msg + " variant", idv, l.getVariant());

                assertEquals(msg + "tag", tag, l.toLanguageTag());

                assertEquals(msg + "id", id, l.toString());

            }

            catch (IllegalArgumentException e) {

                errln(msg + e.getMessage());

            }

        }

    }

    /**

     * Ensure that all these invalid formats are not recognized by

     * forLanguageTag.

     */

    public void testCreateLocaleCanonicalInvalidSeparator() {

        String[] invalids = {

            // trailing separator

            "en_Latn_US_NewYork_",

            "en_Latn_US_",

            "en_Latn_",

            "en_",

            "_",

            // double separator

            "en_Latn_US__NewYork",

            "_Latn_US__NewYork",

            "en_US__NewYork",

            "_US__NewYork",

            // are these OK?

            // "en_Latn__US_NewYork", // variant is 'US_NewYork'

            // "_Latn__US_NewYork", // variant is 'US_NewYork'

            // "en__Latn_US_NewYork", // variant is 'Latn_US_NewYork'

            // "en__US_NewYork", // variant is 'US_NewYork'

            // double separator without language or script

            "__US",

            "__NewYork",

            // triple separator anywhere except within variant

            "en___NewYork",

            "en_Latn___NewYork",

            "_Latn___NewYork",

            "___NewYork",

        };

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

            String id = invalids[i];

            Locale l = Locale.forLanguageTag(id);

            assertEquals(id, "und", l.toLanguageTag());

        }

    }

    /**

     * Ensure that all current locale ids parse.  Use DateFormat as a proxy

     * for all current locale ids.

     */

    public void testCurrentLocales() {

        Locale[] locales = java.text.DateFormat.getAvailableLocales();

        Builder builder = new Builder();

        for (Locale target : locales) {

            String tag = target.toLanguageTag();

            // the tag recreates the original locale,

            // except no_NO_NY

            Locale tagResult = Locale.forLanguageTag(tag);

            if (!target.getVariant().equals("NY")) {

                assertEquals("tagResult", target, tagResult);

            }

            // the builder also recreates the original locale,

            // except ja_JP_JP, th_TH_TH and no_NO_NY

            Locale builderResult = builder.setLocale(target).build();

            if (target.getVariant().length() != 2) {

                assertEquals("builderResult", target, builderResult);

            }

        }

    }

    /**

     * Ensure that all icu locale ids parse.

     */

    public void testIcuLocales() throws Exception {

        BufferedReader br = new BufferedReader(

            new InputStreamReader(

                LocaleEnhanceTest.class.getResourceAsStream("icuLocales.txt"),

                "UTF-8"));

        String id = null;

        while (null != (id = br.readLine())) {

            Locale result = Locale.forLanguageTag(id);

            assertEquals("ulocale", id, result.toLanguageTag());

        }

    }

    ///

    /// Compatibility tests

    ///

    public void testConstructor() {

        // all the old weirdness still holds, no new weirdness

        String[][] tests = {

            // language to lower case, region to upper, variant unchanged

            // short

            { "X", "y", "z", "x", "Y" },

            // long

            { "xXxXxXxXxXxX", "yYyYyYyYyYyYyYyY", "zZzZzZzZzZzZzZzZ",

              "xxxxxxxxxxxx", "YYYYYYYYYYYYYYYY" },

            // mapped language ids

            { "he", "IW", "", "iw" },

            { "iw", "IW", "", "iw" },

            { "yi", "DE", "", "ji" },

            { "ji", "DE", "", "ji" },

            { "id", "ID", "", "in" },

            { "in", "ID", "", "in" },

            // special variants

            { "ja", "JP", "JP" },

            { "th", "TH", "TH" },

            { "no", "NO", "NY" },

            { "no", "NO", "NY" },

            // no canonicalization of 3-letter language codes

            { "eng", "US", "" }

        };

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

            String[] test = tests[i];

            String id = String.valueOf(i);

            Locale locale = new Locale(test[0], test[1], test[2]);

            assertEquals(id + " lang", test.length > 3 ? test[3] : test[0], locale.getLanguage());

            assertEquals(id + " region", test.length > 4 ? test[4] : test[1], locale.getCountry());

            assertEquals(id + " variant", test.length > 5 ? test[5] : test[2], locale.getVariant());

        }

    }

    ///

    /// Locale API tests.

    ///

    public void testGetScript() {

        // forLanguageTag normalizes case

        Locale locale = Locale.forLanguageTag("und-latn");

        assertEquals("forLanguageTag", "Latn", locale.getScript());

        // Builder normalizes case

        locale = new Builder().setScript("LATN").build();

        assertEquals("builder", "Latn", locale.getScript());

        // empty string is returned, not null, if there is no script

        locale = Locale.forLanguageTag("und");

        assertEquals("script is empty string", "", locale.getScript());

    }

    public void testGetExtension() {

        // forLanguageTag does NOT normalize to hyphen

        Locale locale = Locale.forLanguageTag("und-a-some_ex-tension");

        assertEquals("some_ex-tension", null, locale.getExtension('a'));

        // regular extension

        locale = new Builder().setExtension('a', "some-ex-tension").build();

        assertEquals("builder", "some-ex-tension", locale.getExtension('a'));

        // returns null if extension is not present

        assertEquals("empty b", null, locale.getExtension('b'));

        // throws exception if extension tag is illegal

        new ExpectIAE() { public void call() { Locale.forLanguageTag("").getExtension('\uD800'); }};

        // 'x' is not an extension, it's a private use tag, but it's accessed through this API

        locale = Locale.forLanguageTag("x-y-z-blork");

        assertEquals("x", "y-z-blork", locale.getExtension('x'));

    }

    public void testGetExtensionKeys() {

        Locale locale = Locale.forLanguageTag("und-a-xx-yy-b-zz-ww");

        Set<Character> result = locale.getExtensionKeys();

        assertEquals("result size", 2, result.size());

        assertTrue("'a','b'", result.contains('a') && result.contains('b'));

        // result is not mutable

        try {

            result.add('x');

            errln("expected exception on add to extension key set");

        }

        catch (UnsupportedOperationException e) {

            // ok

        }

        // returns empty set if no extensions

        locale = Locale.forLanguageTag("und");

        assertTrue("empty result", locale.getExtensionKeys().isEmpty());

    }

    public void testGetUnicodeLocaleAttributes() {

        Locale locale = Locale.forLanguageTag("en-US-u-abc-def");

        Set<String> attributes = locale.getUnicodeLocaleAttributes();

        assertEquals("number of attributes", 2, attributes.size());

        assertTrue("attribute abc", attributes.contains("abc"));

        assertTrue("attribute def", attributes.contains("def"));

        locale = Locale.forLanguageTag("en-US-u-ca-gregory");

        attributes = locale.getUnicodeLocaleAttributes();

        assertTrue("empty attributes", attributes.isEmpty());

    }

    public void testGetUnicodeLocaleType() {

        Locale locale = Locale.forLanguageTag("und-u-co-japanese-nu-thai");

        assertEquals("collation", "japanese", locale.getUnicodeLocaleType("co"));

        assertEquals("numbers", "thai", locale.getUnicodeLocaleType("nu"));

        // Unicode locale extension key is case insensitive

        assertEquals("key case", "japanese", locale.getUnicodeLocaleType("Co"));

        // if keyword is not present, returns null

        assertEquals("locale keyword not present", null, locale.getUnicodeLocaleType("xx"));

        // if no locale extension is set, returns null

        locale = Locale.forLanguageTag("und");

        assertEquals("locale extension not present", null, locale.getUnicodeLocaleType("co"));

        // typeless keyword

        locale = Locale.forLanguageTag("und-u-kn");

        assertEquals("typeless keyword", "", locale.getUnicodeLocaleType("kn"));

        // invalid keys throw exception

        new ExpectIAE() { public void call() { Locale.forLanguageTag("").getUnicodeLocaleType("q"); }};

        new ExpectIAE() { public void call() { Locale.forLanguageTag("").getUnicodeLocaleType("abcdefghi"); }};

        // null argument throws exception

        new ExpectNPE() { public void call() { Locale.forLanguageTag("").getUnicodeLocaleType(null); }};

    }

    public void testGetUnicodeLocaleKeys() {

        Locale locale = Locale.forLanguageTag("und-u-co-japanese-nu-thai");

        Set<String> result = locale.getUnicodeLocaleKeys();

        assertEquals("two keys", 2, result.size());

        assertTrue("co and nu", result.contains("co") && result.contains("nu"));

        // result is not modifiable

        try {

            result.add("frobozz");

            errln("expected exception when add to locale key set");

        }

        catch (UnsupportedOperationException e) {

            // ok

        }

    }

    public void testPrivateUseExtension() {

        Locale locale = Locale.forLanguageTag("x-y-x-blork-");

        assertEquals("blork", "y-x-blork", locale.getExtension(Locale.PRIVATE_USE_EXTENSION));

        locale = Locale.forLanguageTag("und");

        assertEquals("no privateuse", null, locale.getExtension(Locale.PRIVATE_USE_EXTENSION));

    }

    public void testToLanguageTag() {

        // lots of normalization to test here

        // test locales created using the constructor

        String[][] tests = {

            // empty locale canonicalizes to 'und'

            { "", "", "", "und" },

            // variant alone is not a valid Locale, but has a valid language tag

            { "", "", "NewYork", "und-NewYork" },

            // standard valid locales

            { "", "Us", "", "und-US" },

            { "", "US", "NewYork", "und-US-NewYork" },

            { "EN", "", "", "en" },

            { "EN", "", "NewYork", "en-NewYork" },

            { "EN", "US", "", "en-US" },

            { "EN", "US", "NewYork", "en-US-NewYork" },

            // underscore in variant will be emitted as multiple variant subtags

            { "en", "US", "Newer_Yorker", "en-US-Newer-Yorker" },

            // invalid variant subtags are appended as private use

            { "en", "US", "new_yorker", "en-US-x-lvariant-new-yorker" },

            // the first invalid variant subtags and following variant subtags are appended as private use

            { "en", "US", "Windows_XP_Home", "en-US-Windows-x-lvariant-XP-Home" },

            // too long variant and following variant subtags disappear

            { "en", "US", "WindowsVista_SP2", "en-US" },

            // invalid region subtag disappears

            { "en", "USA", "", "en" },

            // invalid language tag disappears

            { "e", "US", "", "und-US" },

            // three-letter language tags are not canonicalized

            { "Eng", "", "", "eng" },

            // legacy languages canonicalize to modern equivalents

            { "he", "IW", "", "he-IW" },

            { "iw", "IW", "", "he-IW" },

            { "yi", "DE", "", "yi-DE" },

            { "ji", "DE", "", "yi-DE" },

            { "id", "ID", "", "id-ID" },

            { "in", "ID", "", "id-ID" },

            // special values are converted on output

            { "ja", "JP", "JP", "ja-JP-u-ca-japanese-x-lvariant-JP" },

            { "th", "TH", "TH", "th-TH-u-nu-thai-x-lvariant-TH" },

            { "no", "NO", "NY", "nn-NO" }

        };

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

            String[] test = tests[i];

            Locale locale = new Locale(test[0], test[1], test[2]);

            assertEquals("case " + i, test[3], locale.toLanguageTag());

        }

        // test locales created from forLanguageTag

        String[][] tests1 = {

            // case is normalized during the round trip

            { "EN-us", "en-US" },

            { "en-Latn-US", "en-Latn-US" },

            // reordering Unicode locale extensions

            { "de-u-co-phonebk-ca-gregory", "de-u-ca-gregory-co-phonebk" },

            // private use only language tag is preserved (no extra "und")

            { "x-elmer", "x-elmer" },

            { "x-lvariant-JP", "x-lvariant-JP" },

        };

        for (String[] test : tests1) {

            Locale locale = Locale.forLanguageTag(test[0]);

            assertEquals("case " + test[0], test[1], locale.toLanguageTag());

        }

    }

    public void testForLanguageTag() {

        // forLanguageTag implements the 'Language-Tag' production of

        // BCP47, so it handles private use and grandfathered tags,

        // unlike locale builder.  Tags listed below (except for the

        // sample private use tags) come from 4646bis Feb 29, 2009.

        String[][] tests = {

            // private use tags only

            { "x-abc", "x-abc" },

            { "x-a-b-c", "x-a-b-c" },

            { "x-a-12345678", "x-a-12345678" },

            // grandfathered tags with preferred mappings

            { "i-ami", "ami" },

            { "i-bnn", "bnn" },

            { "i-hak", "hak" },

            { "i-klingon", "tlh" },

            { "i-lux", "lb" }, // two-letter tag

            { "i-navajo", "nv" }, // two-letter tag

            { "i-pwn", "pwn" },

            { "i-tao", "tao" },

            { "i-tay", "tay" },

            { "i-tsu", "tsu" },

            { "art-lojban", "jbo" },

            { "no-bok", "nb" },

            { "no-nyn", "nn" },

            { "sgn-BE-FR", "sfb" },