test/jdk/java/text/Format/DateFormat/SimpleDateFormatPatternTest.java
changeset 58534 6c4f71874b36
equal deleted inserted replaced
58533:46b0b7fe255c 58534:6c4f71874b36
       
     1 /*
       
     2  * Copyright (c) 2019, Oracle and/or its affiliates. All rights reserved.
       
     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
       
     4  *
       
     5  * This code is free software; you can redistribute it and/or modify it
       
     6  * under the terms of the GNU General Public License version 2 only, as
       
     7  * published by the Free Software Foundation.
       
     8  *
       
     9  * This code is distributed in the hope that it will be useful, but WITHOUT
       
    10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
       
    11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
       
    12  * version 2 for more details (a copy is included in the LICENSE file that
       
    13  * accompanied this code).
       
    14  *
       
    15  * You should have received a copy of the GNU General Public License version
       
    16  * 2 along with this work; if not, write to the Free Software Foundation,
       
    17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
       
    18  *
       
    19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
       
    20  * or visit www.oracle.com if you need additional information or have any
       
    21  * questions.
       
    22  */
       
    23 
       
    24 /**
       
    25  * @test
       
    26  * @bug 4326988 6990146 8231213
       
    27  * @summary test SimpleDateFormat, check its pattern in the constructor
       
    28  * @run testng/othervm SimpleDateFormatPatternTest
       
    29  */
       
    30 import java.lang.IllegalArgumentException;
       
    31 import java.text.DateFormat;
       
    32 import java.text.DateFormatSymbols;
       
    33 import java.text.SimpleDateFormat;
       
    34 import java.util.Locale;
       
    35 
       
    36 import org.testng.annotations.DataProvider;
       
    37 import org.testng.annotations.Test;
       
    38 
       
    39 public class SimpleDateFormatPatternTest {
       
    40     private static String[] validPat = {
       
    41             "yyyy-MM-dd h.mm.ss.a z",
       
    42             "yyyy'M'd' ahh'mm'ss' z",
       
    43             "dd MMMM yyyy hh:mm:ss",
       
    44             "d MMM yy HH:mm:ss",
       
    45             "dd/MM/yyyy HH:mm:ss",
       
    46             "d' / 'MMMM' / 'yyyy HH:mm:ss z",
       
    47             "d.M.yyyy H:mm:ss",
       
    48             "d' de 'MMMM' de 'yyyy H'h'm'min's's' z",
       
    49             "dd. MMMM yyyy HH:mm:ss z",
       
    50             "d-M-yyyy H:mm:ss",
       
    51             "EEEE''d MMMM G yyyy, H'  'm'  'ss' '",
       
    52             "dd.MMM.yyyy HH:mm:ss",
       
    53             "yy-MM-dd h:mm:ss.a",
       
    54             "d' de 'MMMM' de 'yyyy hh:mm:ss a z",
       
    55             "EEEE d MMMM yyyy H' h 'mm' min 'ss' s 'z",
       
    56             "d MMMM yyyy H:mm:ss",
       
    57             "d/MM/yyyy hh:mm:ss a",
       
    58             "EEEE, d, MMMM yyyy HH:mm:ss z",
       
    59             "EEEE, d. MMMM yyyy HH.mm.' h' z",
       
    60             "EEEE, d' / 'MMMM' / 'yyyy HH:mm:ss z",
       
    61             "d/MM/yyyy HH:mm:ss",
       
    62             "d MMMM yyyy H:mm:ss z",
       
    63             "MMMM d, yyyy h:mm:ss a z",
       
    64             "yyyy. MMMM d. H:mm:ss z",
       
    65             "d' de 'MMMM' de 'yyyy H:mm:ss z",
       
    66             "EEEE, MMMM d, yyyy h:mm:ss a z",
       
    67             "d/M/yyyy H:mm:ss",
       
    68             "d-MMM-yy HH:mm:ss",
       
    69             "EEEE d' de 'MMMM' de 'yyyy hh:mm:ss a z",
       
    70             "yyyy'M'd' ahh'mm'ss'",
       
    71             "yyyy'MM'dd' EEEE ahh'mm'ss'",
       
    72             "EEEE, d MMMM yyyy HH:mm:ss z",
       
    73 
       
    74             //6990146: 'Y' for year; 'X' for time zone; 'u' for day number of the week
       
    75             "d/M/YYYY H:mm:ss",
       
    76             "d-MMM-YY HH:mm:ss",
       
    77             "EEEE d' de 'MMMM' de 'YYYY hh:mm:ss a X",
       
    78             "YYYY M d ahh:mm:ss",
       
    79             "YYYY MM dd EEEE u ahh/mm/ss",
       
    80             "EEEE, u, d MMMM YYYY HH:mm:ss X",
       
    81             "YYYY M d Z ahh mm ss",
       
    82             "YYYY-MM-dd EEEE u ahh-mm-ss",
       
    83 
       
    84             //*added for sr-Latn*
       
    85             "EEEE, dd. MMMM y. HH.mm.ss zzzz",
       
    86             "dd. MMMM y. HH.mm.ss z",
       
    87             "dd.MM.y. HH.mm.ss",
       
    88             "d.M.yy. HH.mm"
       
    89     };
       
    90 
       
    91     private static String[] invalidPat = {
       
    92             "yyyy'M'd' ahh:mm:ss",
       
    93             "EEEe d MM MM yyyy HH' h 'mm zzzZ",
       
    94             "d MMMM\\ yyyy, H'  'm' 'g",
       
    95             "EEEE d' @# MMMMde 'yyys HHH'mm z",
       
    96             "yyyy'MMe 2 #dd' EEEEahh'mm'ss' z,z",
       
    97             "yyyy.M.d H;mm.ses",
       
    98             "EEEe, d MMMM yyyy h:mm:ss a z",
       
    99             "EEEE, MMMM d, 'y y y y h:mm:ss 'o''clock' a z",
       
   100             "dd MMMM yyyy 0HHcl:mm:ss z",
       
   101             "d.M_M_y.yy1yy HextH:mm|45:",
       
   102             "d,D MMMTTTTTTTTTKM yy|+yy HH:m m:ss z",
       
   103             "d-MDtM M-yy H:mm:ss",
       
   104             "yyyy/M///m/nM/d Dd H:m$m:s s",
       
   105             "EEEE, dd. MMMM yyyy HH:m'''m' Uhr 'z",
       
   106             //6990146
       
   107             "EEEE d' de 'MMMM' de 'YYYY hh:mm:ss a x",
       
   108             "EEEE, U, d MMMM YYYY HH:mm:ss Z"
       
   109     };
       
   110 
       
   111     private static Locale[] locales = DateFormat.getAvailableLocales();
       
   112     private static Object[][] dfAllLocalesObj = createAllLocales();
       
   113     private static Object[][] invalidPatObj = createPatternObj(invalidPat);
       
   114     private static Object[][] validPatObj = createPatternObj(validPat);
       
   115 
       
   116     private static Object[][] createAllLocales() {
       
   117         Object[][] objArray = new Object[locales.length][];
       
   118         for (int i = 0; i < locales.length; i++) {
       
   119             objArray[i] = new Object[1];
       
   120             objArray[i][0] = locales[i];
       
   121         }
       
   122         return objArray;
       
   123     }
       
   124 
       
   125     private static Object[][] createPatternObj(String[] pattern){
       
   126         Object[][] objArray = new Object[locales.length * pattern.length][];
       
   127         int k = 0;
       
   128         for (int i = 0; i < locales.length; i++) {
       
   129             for (int j = 0; j < pattern.length; j++) {
       
   130                 objArray[k] = new Object[2];
       
   131                 objArray[k][0] = pattern[j];
       
   132                 objArray[k][1] = locales[i];
       
   133                 k = k + 1;
       
   134             }
       
   135         }
       
   136         return objArray;
       
   137     }
       
   138 
       
   139     @DataProvider(name = "dfAllLocalesObj")
       
   140     Object[][] dfAllLocalesObj() {
       
   141         return dfAllLocalesObj;
       
   142     }
       
   143 
       
   144     @DataProvider(name = "invalidPatternObj")
       
   145     Object[][] invalidPatternObj() {
       
   146         return invalidPatObj;
       
   147     }
       
   148 
       
   149     @DataProvider(name = "validPatternObj")
       
   150     Object[][] validPatternObj() {
       
   151         return validPatObj;
       
   152     }
       
   153 
       
   154     //check Constructors for invalid pattern
       
   155     @Test(dataProvider = "invalidPatternObj",
       
   156             expectedExceptions = IllegalArgumentException.class)
       
   157     public void testIllegalArgumentException1(String pattern, Locale loc)
       
   158             throws IllegalArgumentException {
       
   159         Locale.setDefault(loc);
       
   160         new SimpleDateFormat(pattern);
       
   161     }
       
   162 
       
   163     @Test(dataProvider = "invalidPatternObj",
       
   164             expectedExceptions = IllegalArgumentException.class)
       
   165     public void testIllegalArgumentException2(String pattern, Locale loc)
       
   166             throws IllegalArgumentException {
       
   167         Locale.setDefault(loc);
       
   168         new SimpleDateFormat(pattern, new DateFormatSymbols());
       
   169     }
       
   170 
       
   171     @Test(dataProvider = "invalidPatternObj",
       
   172             expectedExceptions = IllegalArgumentException.class)
       
   173     public void testIllegalArgumentException3 (String pattern, Locale loc)
       
   174             throws IllegalArgumentException {
       
   175         Locale.setDefault(loc);
       
   176         new SimpleDateFormat(pattern, Locale.getDefault());
       
   177     }
       
   178 
       
   179     @Test(dataProvider = "invalidPatternObj",
       
   180             expectedExceptions = IllegalArgumentException.class)
       
   181     public void testIllegalArgumentException4(String pattern, Locale loc)
       
   182             throws IllegalArgumentException {
       
   183         Locale.setDefault(loc);
       
   184         new SimpleDateFormat().applyPattern(pattern);
       
   185     }
       
   186 
       
   187     //check Constructors for null pattern
       
   188     @Test(dataProvider = "dfAllLocalesObj",
       
   189             expectedExceptions = NullPointerException.class)
       
   190     public void testNullPointerException1(Locale loc)
       
   191             throws NullPointerException {
       
   192         Locale.setDefault(loc);
       
   193         new SimpleDateFormat(null);
       
   194     }
       
   195 
       
   196     @Test(dataProvider = "dfAllLocalesObj",
       
   197             expectedExceptions = NullPointerException.class)
       
   198     public void testNullPointerException2(Locale loc)
       
   199             throws NullPointerException {
       
   200         Locale.setDefault(loc);
       
   201         new SimpleDateFormat(null, new DateFormatSymbols());
       
   202     }
       
   203 
       
   204     @Test(dataProvider = "dfAllLocalesObj",
       
   205             expectedExceptions = NullPointerException.class)
       
   206     public void testNullPointerException3(Locale loc)
       
   207             throws NullPointerException {
       
   208         Locale.setDefault(loc);
       
   209         new SimpleDateFormat(null, Locale.getDefault());
       
   210     }
       
   211 
       
   212     @Test(dataProvider = "dfAllLocalesObj",
       
   213             expectedExceptions = NullPointerException.class)
       
   214     public void testNullPointerException4(Locale loc)
       
   215             throws NullPointerException {
       
   216         Locale.setDefault(loc);
       
   217         new SimpleDateFormat().applyPattern(null);
       
   218     }
       
   219 
       
   220     @Test(dataProvider = "validPatternObj")
       
   221     //check Constructors for valid pattern
       
   222     public void testValidPattern(String pattern, Locale loc) {
       
   223         Locale.setDefault(loc);
       
   224         new SimpleDateFormat(pattern);
       
   225         new SimpleDateFormat(pattern, new DateFormatSymbols());
       
   226         new SimpleDateFormat(pattern, Locale.getDefault());
       
   227         new SimpleDateFormat().applyPattern(pattern);
       
   228     }
       
   229 }