1 /*

     2  * Copyright (c) 2018, 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 8202771

    27  * @summary Check j.l.Character.isDigit/isLetter/isLetterOrDigit/isSpaceChar

    28  * /isWhitespace/isTitleCase/isISOControl/isIdentifierIgnorable

    29  * /isJavaIdentifierStart/isJavaIdentifierPart/isUnicodeIdentifierStart

    30  * /isUnicodeIdentifierPart

    31  * @run main CharPropTest

    32  */

    33 

    34 import java.nio.file.Files;

    35 import java.nio.file.Path;

    36 import java.nio.file.Paths;

    37 import java.util.stream.Stream;

    38 

    39 public class CharPropTest {

    40     private static int diffs = 0;

    41     private static int rangeStart = 0x0000;

    42     private static boolean isRange = false;

    43 

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

    45         Path path = Paths.get(System.getProperty("test.src", "."),

    46                 "UnicodeData.txt");

    47         try (Stream<String> lines = Files.lines(path)) {

    48             lines.map(String::trim)

    49                  .filter(line -> line.length() != 0 && line.charAt(0) != '#')

    50                  .forEach(line -> handleOneLine(line));

    51 

    52             if (diffs != 0) {

    53                 throw new RuntimeException("Total differences: " + diffs);

    54             }

    55         }

    56     }

    57 

    58     private static void handleOneLine(String line) {

    59         String[] fields = line.split(";");

    60         int currentCp = Integer.parseInt(fields[0], 16);

    61         String name = fields[1];

    62         String category = fields[2];

    63 

    64         // Except single code point, also handle ranges like the following:

    65         // 3400;<CJK Ideograph Extension A, First>;Lo;0;L;;;;;N;;;;;

    66         // 4DB5;<CJK Ideograph Extension A, Last>;Lo;0;L;;;;;N;;;;

    67         if (isRange) {

    68             if (name.endsWith("Last>")) {

    69                 for (int cp = rangeStart; cp <= currentCp; cp++) {

    70                     testCodePoint(cp, category);

    71                 }

    72             } else {

    73                 throw new RuntimeException("Not a valid range, first range <"

    74                         + Integer.toHexString(rangeStart) + "> without last.");

    75             }

    76             isRange = false;

    77         } else {

    78             if (name.endsWith("First>")) {

    79                 rangeStart = currentCp;

    80                 isRange = true;

    81             } else {

    82                 testCodePoint(currentCp, category);

    83             }

    84         }

    85     }

    86 

    87     private static void testCodePoint(int codePoint, String category) {

    88         isDigitTest(codePoint, category);

    89         isLetterTest(codePoint, category);

    90         isLetterOrDigitTest(codePoint, category);

    91 

    92         isSpaceCharTest(codePoint, category);

    93         isWhitespaceTest(codePoint, category);

    94 

    95         isTitleCaseTest(codePoint, category);

    96 

    97         isISOControlTest(codePoint);

    98 

    99         isIdentifierIgnorableTest(codePoint, category);

   100         isJavaIdentifierStartTest(codePoint, category);

   101         isJavaIdentifierPartTest(codePoint, category);

   102         isUnicodeIdentifierStartTest(codePoint, category);

   103         isUnicodeIdentifierPartTest(codePoint, category);

   104     }

   105 

   106     private static void isDigitTest(int codePoint, String category) {

   107         boolean actual = Character.isDigit(codePoint);

   108         boolean expected = category.equals("Nd");

   109         if (actual != expected) {

   110             printDiff(codePoint, "isDigit", actual, expected);

   111         }

   112     }

   113 

   114     private static void isLetterTest(int codePoint, String category) {

   115         boolean actual = Character.isLetter(codePoint);

   116         boolean expected = isLetter(category);

   117         if (actual != expected) {

   118             printDiff(codePoint, "isLetter", actual, expected);

   119         }

   120     }

   121 

   122     private static void isLetterOrDigitTest(int codePoint, String category) {

   123         boolean actual = Character.isLetterOrDigit(codePoint);

   124         boolean expected = isLetter(category) || category.equals("Nd");

   125         if (actual != expected) {

   126             printDiff(codePoint, "isLetterOrDigit", actual, expected);

   127         }

   128     }

   129 

   130     private static void isSpaceCharTest(int codePoint, String category) {

   131         boolean actual = Character.isSpaceChar(codePoint);

   132         boolean expected = isSpaceChar(category);

   133         if (actual != expected) {

   134             printDiff(codePoint, "isSpaceChar", actual, expected);

   135         }

   136     }

   137 

   138     private static void isWhitespaceTest(int codePoint, String category) {

   139         boolean actual = Character.isWhitespace(codePoint);

   140         boolean expected = isWhitespace(codePoint, category);

   141         if (actual != expected) {

   142             printDiff(codePoint, "isWhitespace", actual, expected);

   143         }

   144     }

   145 

   146     private static void isTitleCaseTest(int codePoint, String category) {

   147         boolean actual = Character.isTitleCase(codePoint);

   148         boolean expected = category.equals("Lt");

   149         if (actual != expected) {

   150             printDiff(codePoint, "isTitleCase", actual, expected);

   151         }

   152     }

   153 

   154     private static void isISOControlTest(int codePoint) {

   155         boolean actual = Character.isISOControl(codePoint);

   156         boolean expected = isISOControl(codePoint);

   157         if (actual != expected) {

   158             printDiff(codePoint, "isISOControl", actual, expected);

   159         }

   160     }

   161 

   162     private static void isIdentifierIgnorableTest(int codePoint, String category) {

   163         boolean actual = Character.isIdentifierIgnorable(codePoint);

   164         boolean expected = isIdentifierIgnorable(codePoint, category);

   165         if (actual != expected) {

   166             printDiff(codePoint, "isIdentifierIgnorable", actual, expected);

   167         }

   168     }

   169 

   170     private static void isJavaIdentifierStartTest(int codePoint, String category) {

   171         boolean actual = Character.isJavaIdentifierStart(codePoint);

   172         boolean expected = isJavaIdentifierStart(category);

   173         if (actual != expected) {

   174             printDiff(codePoint, "isJavaIdentifierStart", actual, expected);

   175         }

   176     }

   177 

   178     private static void isJavaIdentifierPartTest(int codePoint, String category) {

   179         boolean actual = Character.isJavaIdentifierPart(codePoint);

   180         boolean expected = isJavaIdentifierPart(codePoint, category);

   181         if (actual != expected) {

   182             printDiff(codePoint, "isJavaIdentifierPart", actual, expected);

   183         }

   184     }

   185 

   186     private static void isUnicodeIdentifierStartTest(int codePoint, String category) {

   187         boolean actual = Character.isUnicodeIdentifierStart(codePoint);

   188         boolean expected = isUnicodeIdentifierStart(category);

   189         if (actual != expected) {

   190             printDiff(codePoint, "isUnicodeIdentifierStart", actual, expected);

   191         }

   192     }

   193 

   194     private static void isUnicodeIdentifierPartTest(int codePoint, String category) {

   195         boolean actual = Character.isUnicodeIdentifierPart(codePoint);

   196         boolean expected = isUnicodeIdentifierPart(codePoint, category);

   197         if (actual != expected) {

   198             printDiff(codePoint, "isUnicodeIdentifierPart", actual, expected);

   199         }

   200     }

   201 

   202     private static boolean isLetter(String category) {

   203         return category.equals("Lu") || category.equals("Ll")

   204                || category.equals("Lt") || category.equals("Lm")

   205                || category.equals("Lo");

   206     }

   207 

   208     private static boolean isSpaceChar(String category) {

   209         return category.equals("Zs") || category.equals("Zl")

   210                || category.equals("Zp");

   211     }

   212 

   213     private static boolean isWhitespace(int codePoint, String category) {

   214         if (isSpaceChar(category) && codePoint != Integer.parseInt("00A0", 16)

   215                 && codePoint != Integer.parseInt("2007", 16)

   216                 && codePoint != Integer.parseInt("202F", 16)) {

   217             return true;

   218         } else {

   219             if (codePoint == Integer.parseInt("0009", 16)

   220                     || codePoint == Integer.parseInt("000A", 16)

   221                     || codePoint == Integer.parseInt("000B", 16)

   222                     || codePoint == Integer.parseInt("000C", 16)

   223                     || codePoint == Integer.parseInt("000D", 16)

   224                     || codePoint == Integer.parseInt("001C", 16)

   225                     || codePoint == Integer.parseInt("001D", 16)

   226                     || codePoint == Integer.parseInt("001E", 16)

   227                     || codePoint == Integer.parseInt("001F", 16)) {

   228                 return true;

   229             }

   230         }

   231         return false;

   232     }

   233 

   234     private static boolean isISOControl(int codePoint) {

   235         return (codePoint > 0x00 && codePoint < 0x1f)

   236                || (codePoint > 0x7f && codePoint < 0x9f)

   237                || (codePoint == 0x00 || codePoint == 0x1f || codePoint == 0x7f || codePoint == 0x9f);

   238     }

   239 

   240     private static boolean isIdentifierIgnorable(int codePoint, String category) {

   241         if (category.equals("Cf")) {

   242             return true;

   243         } else {

   244             int a1 = Integer.parseInt("0000", 16);

   245             int a2 = Integer.parseInt("0008", 16);

   246             int b1 = Integer.parseInt("000E", 16);

   247             int b2 = Integer.parseInt("001B", 16);

   248             int c1 = Integer.parseInt("007F", 16);

   249             int c2 = Integer.parseInt("009F", 16);

   250 

   251             if ((codePoint > a1 && codePoint < a2) || (codePoint > b1 && codePoint < b2)

   252                     || (codePoint > c1 && codePoint < c2) || (codePoint == a1 || codePoint == a2

   253                     || codePoint == b1 || codePoint == b2 || codePoint == c1 || codePoint == c2)) {

   254                 return true;

   255             }

   256         }

   257         return false;

   258     }

   259 

   260     private static boolean isJavaIdentifierStart(String category) {

   261         return isLetter(category) || category.equals("Nl") || category.equals("Sc")

   262                || category.equals("Pc");

   263     }

   264 

   265     private static boolean isJavaIdentifierPart(int codePoint, String category) {

   266         return isLetter(category) || category.equals("Sc") || category.equals("Pc")

   267                || category.equals("Nd") || category.equals("Nl")

   268                || category.equals("Mc") || category.equals("Mn")

   269                || isIdentifierIgnorable(codePoint, category);

   270     }

   271 

   272     private static boolean isUnicodeIdentifierStart(String category) {

   273         return isLetter(category) || category.equals("Nl");

   274     }

   275 

   276     private static boolean isUnicodeIdentifierPart(int codePoint, String category) {

   277         return isLetter(category) || category.equals("Pc") || category.equals("Nd")

   278                || category.equals("Nl") || category.equals("Mc") || category.equals("Mn")

   279                || isIdentifierIgnorable(codePoint, category);

   280     }

   281 

   282     private static void printDiff(int codePoint, String method, boolean actual, boolean expected) {

   283         System.out.println("Not equal at codePoint <" + Integer.toHexString(codePoint)

   284                 + ">, method: " + method

   285                 + ", actual: " + actual + ", expected: " + expected);

   286         diffs++;

   287     }

   288 }