SSL Bug4640234.java

/*
 * Copyright (c) 2007, 2022, 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 4640234 4946057 4938151 4873691 5023181
 * @summary Verifies the translation of time zone names, this test will catch
 *          presence of country name for english and selected locales for all
 *          ISO country codes.
 *          The test program also displays which timezone, country and
 *          language names are not translated
 * @modules java.base/sun.util.resources
 */


/*
 * 4946057 Localization for ISO country & language data.
 * 4938151 Time zones not translated
 * 4873691 Changes in TimeZone mapping
 */

import java.text.MessageFormat;
import java.text.SimpleDateFormat;

import java.util.Date;
import java.util.Locale;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Map;
import java.util.ResourceBundle;
import java.util.TimeZone;

import sun.util.resources.LocaleData;

public class Bug4640234  {
    static SimpleDateFormat sdfEn = new SimpleDateFormat("zzzz", Locale.US);
    static SimpleDateFormat sdfEnShort = new SimpleDateFormat("z", Locale.US);
    static Locale locEn = Locale.ENGLISH;

    static SimpleDateFormat sdfLoc;
    static SimpleDateFormat sdfLocShort;
    static Date date = new Date();

    // Define supported locales
    static Locale[] locales2Test = new Locale[] {
        Locale.ENGLISH,
        Locale.GERMAN,
        Locale.of("es"),
        Locale.FRENCH,
        Locale.ITALIAN,
        Locale.JAPANESE,
        Locale.KOREAN,
        Locale.of("sv"),
        Locale.SIMPLIFIED_CHINESE,
        Locale.TRADITIONAL_CHINESE
    };

    public static void main(String[] args) throws Exception {
        Locale reservedLocale = Locale.getDefault();
        try {
            Locale.setDefault(Locale.ENGLISH);

            StringBuffer errors = new StringBuffer("");
            StringBuffer warnings = new StringBuffer("");

            String[] timezones = TimeZone.getAvailableIDs();
            String[] countries = locEn.getISOCountries();
            String[] languages = locEn.getISOLanguages();

            ResourceBundle resEn = LocaleData.getBundle("sun.util.resources.LocaleNames",
                                                        locEn);
            Map<String, String> countryMapEn = getList(resEn, true);
            Map<String, String> languageMapEn = getList(resEn, false);

            ResourceBundle resLoc;
            Map<String, String> countryMap;
            Map<String, String> languageMap;

            for (Locale locale : locales2Test) {
                resLoc = LocaleData.getBundle("sun.util.resources.LocaleNames",
                                              locale);

                sdfLoc = new SimpleDateFormat("zzzz", locale);
                sdfLocShort = new SimpleDateFormat("z", locale);

                for (String timezone : timezones) {
                    if (isTZIgnored(timezone)) {
                        continue;
                    }
                    warnings.append(testTZ(timezone, locale));
                }

                countryMap = getList(resLoc, true);

                for (String country : countries) {
                    String[] result = testEntry(country,
                        countryMapEn,
                        countryMap,
                        locale,
                        "ERROR: {0} country name for country code: {1} not found!\n",
                        "WARNING: {0} country name for country code: {1} not localized!\n"
                    );
                    if (warnings.indexOf(result[0]) == -1) {
                        warnings.append(result[0]);
                    }
                    if (errors.indexOf(result[1]) == -1) {
                        errors.append(result[1]);
                    }
                }

                languageMap = getList(resLoc, false);
                for (String language : languages) {
                    String[] result = testEntry(language,
                        languageMapEn,
                        languageMap,
                        locale,
                        "ERROR: {0} language name for language code: {1} not found!\n",
                        "WARNING: {0} language name for language code: {1} not localized!\n");
                    if (warnings.indexOf(result[0]) == -1) {
                        warnings.append(result[0]);
                    }
                    if (errors.indexOf(result[1]) == -1) {
                        errors.append(result[1]);
                    }
                }
            }

            StringBuffer message = new StringBuffer("");
            if (!"".equals(errors.toString())) {
                message.append("Test failed! ");
                message.append("ERROR: some keys are missing! ");
            }

            if ("".equals(message.toString())) {
                System.out.println("\nTest passed");
                System.out.println(warnings.toString());
            } else {
                System.out.println("\nTest failed!");
                System.out.println(errors.toString());
                System.out.println(warnings.toString());
                throw new Exception("\n" + message);
            }
        } finally {
            // restore the reserved locale
            Locale.setDefault(reservedLocale);
        }
    }

    /**
    * Compares the english timezone name and timezone name in specified locale
    * @param timeZoneName - name of the timezone to compare
    * @param locale - locale to test against english
    * @return empty string when passed, descriptive error message in other cases
    */
    private static String testTZ(String timeZoneName, Locale locale) {
        StringBuffer timeZoneResult = new StringBuffer("");
        TimeZone tz = TimeZone.getTimeZone(timeZoneName);
        sdfEn.setTimeZone(tz);
        sdfEnShort.setTimeZone(tz);
        sdfLoc.setTimeZone(tz);
        sdfLocShort.setTimeZone(tz);

        String en, enShort, loc, locShort;
        en = sdfEn.format(date);
        enShort = sdfEnShort.format(date);
        loc = sdfLoc.format(date);
        locShort = sdfLocShort.format(date);

        String displayLanguage = locale.getDisplayLanguage();
        String displayCountry = locale.getDisplayCountry();

        if (loc.equals(en)) {
            timeZoneResult.append("[");
            timeZoneResult.append(displayLanguage);
            if (!"".equals(displayCountry)) {
                timeZoneResult.append(" ");
                timeZoneResult.append(displayCountry);
            }
            timeZoneResult.append("] timezone \"");
            timeZoneResult.append(timeZoneName);
            timeZoneResult.append("\" long name \"" + en);
            timeZoneResult.append("\" not localized!\n");
        }

        if (!locShort.equals(enShort)) {
            timeZoneResult.append("[");
            timeZoneResult.append(displayLanguage);
            if (!"".equals(displayCountry)) {
                timeZoneResult.append(" ");
                timeZoneResult.append(displayCountry);
            }
            timeZoneResult.append("] timezone \"");
            timeZoneResult.append(timeZoneName);
            timeZoneResult.append("\" short name \"" + enShort);
            timeZoneResult.append("\" is localized \"");
            timeZoneResult.append(locShort);
            timeZoneResult.append("\"!\n");
        }
        return timeZoneResult.toString();
    }

    /**
    * Verifies whether the name for ISOCode is localized.
    * @param ISOCode - ISO country/language code for country/language name
    *      to test
    * @param entriesEn - array of english country/language names
    * @param entriesLoc - array of localized country/language names for
    *      specified locale
    * @param locale - locale to test against english
    * @param notFoundMessage - message in form ready for MessageFormat,
    *      {0} will be human readable language name, {1} will be ISOCode.
    * @param notLocalizedMessage - message in for ready for MessageFormat,
    *      same formatting like for notFountMessage
    * @return array of two empty strings when passed, descriptive error message
    *      in other cases, [0] - warnings for not localized, [1] - errors for
    *      missing keys.
    */
    private static String[] testEntry(String ISOCode,
                Map<String, String> entriesEn,
                Map<String, String> entriesLoc,
                Locale locale,
                String notFoundMessage,
                String notLocalizedMessage) {
        String nameEn = null;
        String nameLoc = null;

        for (String key: entriesEn.keySet()) {
            if (ISOCode.equalsIgnoreCase(key)) {
                nameEn = entriesEn.get(key);
                break;
            }
        }

        for (String key: entriesLoc.keySet()) {
            if (ISOCode.equalsIgnoreCase(key)) {
                nameLoc = entriesLoc.get(key);
                break;
            }
        }

        if (nameEn == null) {
            // We should not get here but test is a MUST have
            return new String[] {"",
                                 MessageFormat.format(notFoundMessage, "English", ISOCode)};
        }

        if (nameLoc == null) {
            return new String[] {"",
                                 MessageFormat.format(notFoundMessage,
                                                      locale.getDisplayName(), ISOCode)};
        }

        if (nameEn.equals(nameLoc)) {
            return new String[] {MessageFormat.format(notLocalizedMessage,
                                                      locale.getDisplayName(), ISOCode),
                                 ""};
        }

        return new String[] {"", ""};
    }

    private static boolean isTZIgnored(String TZName) {
        if (TZName.startsWith("Etc/GMT") ||
                TZName.indexOf("Riyadh8") != -1 ||
                TZName.equals("GMT0") ||
                TZName.equals("MET")
                ) {
            return true;
        }
        return false;
    }

    private static Map<String, String> getList(
            ResourceBundle rs, Boolean getCountryList) {
        char beginChar = 'a';
        char endChar = 'z';
        if (getCountryList) {
            beginChar = 'A';
            endChar = 'Z';
        }

        Map<String, String> hm = new HashMap<String, String>();
        Enumeration<String> keys = rs.getKeys();
        while (keys.hasMoreElements()) {
            String s = keys.nextElement();
            if (s.length() == 2 &&
                s.charAt(0) >= beginChar && s.charAt(0) <= endChar) {
                hm.put(s, rs.getString(s));
            }
        }
        return hm;
    }
}