Ziele Untersuchung
mit Columbo Integrität von
Datenbanken Interaktion und
Portierbarkeit Ergonomie der
Schnittstellen

Angebot Produkte Projekt Beratung

Mittel Analytik Modellierung Sprachen Algebra Logik Hardware Denken Kreativität

Zusammenhänge Gesellschaft Wirtschaft Branche Firma


products/sources/formale Sprachen/Java/Openjdk/test/jdk/java/lang/String/ (Sun/Oracle ^©) Datei vom 13.11.2022 mit Größe 26 kB

Quelle Supplementary.java Sprache: JAVA

/*
* Copyright (c) 2003, 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 4533872 4915683 4922962 4985217 5017280 6242664 6588260
* @summary Unit tests for supplementary character support (JSR-204)
*/

public class Supplementary {

    public static void main(String[] args) {
        test1();        // Test for codePointAt(int index)
        test2();        // Test for codePointBefore(int index)
        test3();        // Test for indexOf(int ch)
        test4();        // Test for indexOf(int ch, int fromIndex)
        test5();        // Test for lastIndexOf(int ch)
        test6();        // Test for lastIndexOf(int ch, int fromIndex)
        test7();        // Test for String(int[] codePoint, int offset, int count)
        test8();        // Test for codePointCount(int beginIndex, int endIndex)
        test9();        // Test for offsetByCodePoints(int index, int offset)
        test10();       // Test for offsetByCodePoints(int index, int offset)
                        // To verify the fix for 6242664
    }

    /* Text strings which are used as input data.
     * The comment above each text string means the index of each 16-bit char
     * for convenience.
     */
    static final String[] input = {
      /*                               111     1     111111     22222
         0123     4     5678     9     012     3     456789     01234 */
        "abc\uD800\uDC00def\uD800\uD800ab\uD800\uDC00cdefa\uDC00bcdef",
      /*                          1     1111     1111     1     222
         0     12345     6789     0     1234     5678     9     012     */
        "\uD800defg\uD800hij\uD800\uDC00klm\uDC00nop\uDC00\uD800rt\uDC00",
      /*                          11     1     1111     1     112     222
         0     12345     6     78901     2     3456     7     890     123     */
        "\uDC00abcd\uDBFF\uDFFFefgh\uD800\uDC009ik\uDC00\uDC00lm\uDC00no\uD800",
      /*                                    111     111111     1 22     2
         0     1     2345     678     9     012     345678     9 01     2     */
        "\uD800\uDC00!#$\uD800%&\uD800\uDC00;+\uDC00<>;=^\uDC00\\@\uD800\uDC00",

        // includes an undefined supplementary character in Unicode 4.0.0
      /*                                    1     11     1     1111     1
         0     1     2345     6     789     0     12     3     4567     8     */
        "\uDB40\uDE00abc\uDE01\uDB40de\uDB40\uDE02f\uDB40\uDE03ghi\uDB40\uDE02",

        // all supplementary characters
      /*                                                             1     1
         0     1     2     3     4     5     6     7     8     9     0     1     */
        "\uD800\uDC00\uD800\uDC01\uD800\uDC02\uD800\uDC03\uD800\uDC04\uD800\uDC05"+
      /* 1     1     1     1     1     1     1     1     2     2     2     2
         2     3     4     5     6     7     8     9     0     1     2     3     */
        "\uD800\uDC06\uD800\uDC07\uD800\uDC08\uD800\uDC08\uD800\uDC09\uD800\uDC0A"+
      /* 2     2     2     2     2     2     3     3     3     3     3     3
         4     5     6     7     8     9     0     1     2     3     4     5     */
        "\uD800\uDC0B\uD800\uDC0C\uD800\uDC0D\uD800\uDC0A\uD800\uDC0F\uD800\uDC10"
    };

    /* Expected results for:
     *     test1(): for codePointAt()
     *
     * Each character in each array is the golden data for each text string
     * in the above input data. For example, the first data in each array is
     * for the first input string.
     */
    static final int[][] golden1 = {
        {'a',    0xD800,  0xDC00, 0x10000, 0xE0200, 0x10000},// codePointAt(0)
        {0xD800, 0x10000, 'g',    0xDC00,  0xE0202, 0xDC04}, // codePointAt(9)
        {'f',    0xDC00,  0xD800, 0xDC00,  0xDE02,  0xDC10}, // codePointAt(length-1)
        {'f',    'p',     0xDC00, '^',     0xE0202, 0xDC08}, // codePointAt() for a substring
    };

    /*
     * Test for codePointAt(int index) method
     */
    static void test1() {

        for (int i = 0; i < input.length; i++) {
            String s = input[i];

            /*
             * Normal case
             */
            testCodePoint(At, s, 0, golden1[0][i]);
            testCodePoint(At, s, 9, golden1[1][i]);
            testCodePoint(At, s, s.length()-1, golden1[2][i]);
            testCodePoint(At, s.substring(17), 0, golden1[3][i]);

            /*
             * Abnormal case - verify that an exception is thrown.
             */
            testCodePoint(At, s, -1);
            testCodePoint(At, s, s.length());
        }
    }

    /* Expected results for:
     *     test2(): for codePointBefore()
     *
     * Each character in each array is the golden data for each text string
     * in the above input data. For example, the first data in each array is
     * for the first input string.
     */
    static final int[][] golden2 = {
        {'a',    0xD800, 0xDC00,  0xD800,  0xDB40,  0xD800}, // codePointBefore(1)
        {0xD800, 'l',    0x10000, 0xDC00,  0xDB40,  0xD800}, // codePointBefore(13)
        {'f',    0xDC00, 0xD800,  0x10000, 0xE0202, 0x10010},// codePointBefore(length)
        {'b',    'd',    'a',     0xDC00,  0xDE00,  0xDC00}, // codePointBefore() for a substring
    };

    /*
     * Test for codePointBefore(int index) method
     */
    static void test2() {

        for (int i = 0; i < input.length; i++) {
            String s = input[i];

            /*
             * Normal case
             */
            testCodePoint(Before, s, 1, golden2[0][i]);
            testCodePoint(Before, s, 13, golden2[1][i]);
            testCodePoint(Before, s, s.length(), golden2[2][i]);
            testCodePoint(Before, s.substring(1), 1, golden2[3][i]);

            /*
             * Abnormal case - verify that an exception is thrown.
             */
            testCodePoint(Before, s, 0);
            testCodePoint(Before, s, s.length()+1);
        }
    }

    /* Expected results for:
     *     test3(): for indexOf(int ch)
     *     test4(): for indexOf(int ch, int fromIndex)
     *     test5(): for lastIndexOf(int ch)
     *     test6(): for lastIndexOf(int ch, int fromIndex)
     *
     * Unlike golden1 and golden2, golden3[m][] is the golden data for text
     * string in input[m].
     *
     * The meaning of each element in golden3[][n]
     *   golden3[][0]: character which is searched.
     *   golden3[][2]: the golden data for indexOf(int ch)
     *   From golden3[][2] to golden3[][n-1]:
     *       the golden data for indexOf(int ch, int fromIndex)
     *   The golden3[][n-2]: the golden data for lastIndexOf(int ch)
     *   From golden3[][1] to golden3[][n-2]:
     *       the golden data for lastIndexOf(int ch, int fromIndex)
     *
     *   In other words, the data format is
     *     { ch, -1, index1, index2, ..., -1}
     *   where index1, index2, ... are all indices of the ch occurrences.
     */
    static final int[][] golden3 = {
      /* ch       indices */
        {'b',     -1,  1, 11, 20,  -1},
        {0xD800,  -1,  0,  5,  9,  19, -1},
        {0xDC00,  -1,  0, 12, 16,  17, 20, -1},
        {0x10000, -1,  0,  8, 21,  -1},
        {0xE0202, -1,  9, 17, -1},
        {0x1000A, -1, 22, 30, -1}
    };

    /*
     * Test for indexOf(int ch) method
     */
    static void test3() {

        for (int i = 0; i < input.length; i++) {
            String s = input[i];

            /*
             * Normal case
             */
            testIndexOf(s, golden3[i][0], golden3[i][2]);

            /*
             * Abnormal case - char which isn't included in the string.
             */
            testIndexOf(s, 'Z', -1);
            testIndexOf(s, 0xDB98, -1);
            testIndexOf(s, 0xDE76, -1);
            testIndexOf(s, 0x12345, -1);
            testIndexOf(s, -1, -1);
            testIndexOf(s, 0x110000, -1);
        }
    }

    /*
     * Test for indexOf(int ch, int fromIndex) method
     */
    static void test4() {

        for (int i = 0; i < input.length; i++) {
            String s = input[i];
            int ch = golden3[i][0];

            /*
             * Normal case
             */
            int fromIndex = 0;
            for (int j = 2; j < golden3[i].length; j++) {
                fromIndex = testIndexOf(s, fromIndex, ch,
                                        golden3[i][j]) + 1;
            }

            /*
             * Abnormal case1 - char is included in the string but fromIndex
             *                  is incorrect.
             */
            testIndexOf(s, -1, ch, golden3[i][2]);
            testIndexOf(s, s.length(), ch,
                        golden3[i][golden3[i].length-1]);

            /*
             * Abnormal case2 - char which isn't included in the string.
             */
            testIndexOf(s, 0, 'Z', -1);
            testIndexOf(s, 0, 0xDB98, -1);
            testIndexOf(s, 0, 0xDE76, -1);
            testIndexOf(s, 0, 0x12345, -1);
            testIndexOf(s, 0, -1, -1);
            testIndexOf(s, 0, 0x110000, -1);
        }
    }

    /*
     * Test for lastIndexOf(int ch) method
     */
    static void test5() {

        for (int i = 0; i < input.length; i++) {
            String s = input[i];

            /*
             * Normal case
             */
            testLastIndexOf(s, golden3[i][0],
                        golden3[i][golden3[i].length-2]);

            /*
             * Abnormal case - char which isn't included in the string.
             */
            testLastIndexOf(s, 'Z', -1);
            testLastIndexOf(s, 0xDB98, -1);
            testLastIndexOf(s, 0xDE76, -1);
            testLastIndexOf(s, 0x12345, -1);
            testLastIndexOf(s, -1, -1);
            testLastIndexOf(s, 0x110000, -1);
        }
    }

    /*
     * Test for lastIndexOf(int ch, int fromIndex) method
     */
    static void test6() {

        for (int i = 0; i < input.length; i++) {
            String s = input[i];
            int ch = golden3[i][0];
            int len = s.length();

            /*
             * Normal case
             */
            int fromIndex = len - 1;
            for (int j = golden3[i].length - 2; j > 0; j--) {
                fromIndex = testLastIndexOf(s, fromIndex, ch,
                                        golden3[i][j]) - 1;
            }

            /*
             * Abnormal case1 - char is included in the string but fromIndex
             *                  is incorrect.
             */
            testLastIndexOf(s, -1, ch, golden3[i][1]);
            testLastIndexOf(s, len, ch, golden3[i][golden3[i].length-2]);

            /*
             * Abnormal case2 - char which isn't included in the string.
             */
            testLastIndexOf(s, len, 'Z', -1);
            testLastIndexOf(s, len, 0xDB98, -1);
            testLastIndexOf(s, len, 0xDE76, -1);
            testLastIndexOf(s, len, 0x12345, -1);
            testLastIndexOf(s, len, -1, -1);
            testLastIndexOf(s, len, 0x110000, -1);
        }
    }

    /**
     * Test for String(int[] codePoint, int offset, int count).
     */
    static void test7() {
        for (int i = 0; i < input.length; i++) {
            String s = input[i];
            int nCodePoints = 0;
            int c;
            for (int j = 0; j < s.length(); j += Character.charCount(c)) {
                c = s.codePointAt(j);
                nCodePoints++;
            }
            int[] codePoints = new int[nCodePoints];
            int count = 0, mid = 0, offset = 0;
            for (int j = 0; j < s.length(); j += Character.charCount(c)) {
                if (mid == 0 && j >= s.length()/2) {
                    mid = j;
                    offset = count;
                }
                c = s.codePointAt(j);
                codePoints[count++] = c;
            }

            String cps = new String(codePoints, 0, count);
            check(!s.equals(cps), "new String(int[]...) with input[" + i + "]");

            cps = new String(codePoints, 0, offset);
            check(!s.substring(0, mid).equals(cps),
                  "first half: new String(int[]...) with input[" + i + "]");

            cps = new String(codePoints, offset, count - offset);
            check(!s.substring(mid).equals(cps),
                  "second half: new String(int[]...) with input[" + i + "]");

            // test exceptions
            testNewString(null, 0, count, NullPointerException.class);
            testNewString(codePoints, -1, count, IndexOutOfBoundsException.class);
            testNewString(codePoints, 0, count+1, IndexOutOfBoundsException.class);
            testNewString(codePoints, offset, count, IndexOutOfBoundsException.class);
            testNewString(codePoints, offset, -1, IndexOutOfBoundsException.class);
            testNewString(codePoints, count, 1, IndexOutOfBoundsException.class);
            codePoints[offset] = -1;
            testNewString(codePoints, 0, count, IllegalArgumentException.class);
            codePoints[offset] = Character.MAX_CODE_POINT+1;
            testNewString(codePoints, 0, count, IllegalArgumentException.class);
        }

        {
            // 6588260: (str) ArrayIndexOutOfBoundsException when trying
            // to create a String from codePoints
            //int[] x = new int[Character.MAX_CODE_POINT+1];
            int[] x = new int[Character.MAX_CODE_POINT];
            for (int i = 0; i < x.length; i++)
                if (i != 0xdbff) // For round-trip safety
                    x[i] = i;
            final String s = new String(x, 0, x.length);
            check(s.codePointCount(0, s.length()) != x.length,
                  "s.codePointCount(0, s.length()) != x.length");
            check(s.length() <= x.length,
                  "s.length() <= x.length");
            for (int i = 0, j = 0; i < x.length; i++) {
                int c = s.codePointAt(j);
                check(c != x[i], "c != x[i]");
                j += Character.charCount(c);
            }
        }
    }

    /**
     * Test codePointCount(int, int)
     *
     * This test case assumes that
     * Character.codePointCount(CharSequence, int, int) works
     * correctly.
     */
    static void test8() {
        for (int i = 0; i < input.length; i++) {
            String str = input[i];
            int length = str.length();
            for (int j = 0; j <= length; j++) {
                int result = str.codePointCount(j, length);
                int expected = Character.codePointCount(str, j, length);
                check(result != expected, "codePointCount(input["+i+"], "+j+", "+length+")",
                      result, expected);
                // Create a substring of the text range. It shares the
                // underlying char[] of the String str.
                String substr = str.substring(j, length);
                result = substr.codePointCount(0, substr.length());
                check(result != expected, "substring:codePointCount(input["+i+"], "+j+", "+length+")",
                      result, expected);
            }
            for (int j = length; j >= 0; j--) {
                int result = str.codePointCount(0, j);
                int expected = Character.codePointCount(str, 0, j);
                check(result != expected, "codePointCount(input["+i+"], 0, "+j+")",
                      result, expected);
                String substr = str.substring(0, j);
                result = substr.codePointCount(0, substr.length());
                check(result != expected, "substring:codePointCount(input["+i+"], 0, "+j+")",
                      result, expected);
            }

            // test exceptions
            testCodePointCount(null, 0, 0, NullPointerException.class);
            testCodePointCount(str, -1, length, IndexOutOfBoundsException.class);
            testCodePointCount(str, 0, length+1, IndexOutOfBoundsException.class);
            testCodePointCount(str, length, length-1, IndexOutOfBoundsException.class);
        }
    }

    /**
     * Test offsetByCodePoints(int, int)
     *
     * This test case assumes that
     * Character.codePointCount(CharSequence, int, int) works
     * correctly.
     */
    static void test9() {
        for (int i = 0; i < input.length; i++) {
            String str = input[i];
            int length = str.length();
            for (int j = 0; j <= length; j++) {
                int nCodePoints = Character.codePointCount(str, j, length);
                int result = str.offsetByCodePoints(j, nCodePoints);
                check(result != length,
                      "offsetByCodePoints(input["+i+"], "+j+", "+nCodePoints+")",
                      result, length);
                result = str.offsetByCodePoints(length, -nCodePoints);
                int expected = j;
                if (j > 0 && j < length) {
                    int cp = str.codePointBefore(j+1);
                    if (Character.isSupplementaryCodePoint(cp)) {
                        expected--;
                    }
                }
                check(result != expected,
                      "offsetByCodePoints(input["+i+"], "+j+", "+(-nCodePoints)+")",
                      result, expected);
            }
            for (int j = length; j >= 0; j--) {
                int nCodePoints = Character.codePointCount(str, 0, j);
                int result = str.offsetByCodePoints(0, nCodePoints);
                int expected = j;
                if (j > 0 && j < length) {
                    int cp = str.codePointAt(j-1);
                     if (Character.isSupplementaryCodePoint(cp)) {
                        expected++;
                    }
                }
                check(result != expected,
                      "offsetByCodePoints(input["+i+"], 0, "+nCodePoints+")",
                      result, expected);
                result = str.offsetByCodePoints(j, -nCodePoints);
                check(result != 0,
                      "offsetByCodePoints(input["+i+"], "+j+", "+(-nCodePoints)+")",
                      result, 0);
            }

            // test exceptions
            testOffsetByCodePoints(null, 0, 0, NullPointerException.class);
            testOffsetByCodePoints(str, -1, length, IndexOutOfBoundsException.class);
            testOffsetByCodePoints(str, 0, length+1, IndexOutOfBoundsException.class);
            testOffsetByCodePoints(str, 1, -2, IndexOutOfBoundsException.class);
            testOffsetByCodePoints(str, length, length-1, IndexOutOfBoundsException.class);
            testOffsetByCodePoints(str, length, -(length+1), IndexOutOfBoundsException.class);
        }
    }

    /**
     * Test offsetByCodePoints(int, int) - to verify the fix for 6242664
     *
     * This test case assumes that
     * Character.codePointCount(CharSequence, int, int) works
     * correctly.
     */
    static void test10() {
        String header = "H\uD800e\uDFFFa\uDBFF\uDC00der<";
        for (int i = 0; i < input.length; i++) {
            String wholeString = header + input[i];
            String str = wholeString.substring(header.length());
            int length = str.length();
            for (int j = 0; j <= length; j++) {
                int nCodePoints = Character.codePointCount(str, j, length);
                int result = str.offsetByCodePoints(j, nCodePoints);
                check(result != length,
                      "offsetByCodePoints(input["+i+"], "+j+", "+nCodePoints+")",
                      result, length);
                result = str.offsetByCodePoints(length, -nCodePoints);
                int expected = j;
                if (j > 0 && j < length) {
                    int cp = str.codePointBefore(j+1);
                    if (Character.isSupplementaryCodePoint(cp)) {
                        expected--;
                    }
                }
                check(result != expected,
                      "offsetByCodePoints(input["+i+"], "+j+", "+(-nCodePoints)+")",
                      result, expected);
            }
            for (int j = length; j >= 0; j--) {
                int nCodePoints = Character.codePointCount(str, 0, j);
                int result = str.offsetByCodePoints(0, nCodePoints);
                int expected = j;
                if (j > 0 && j < length) {
                    int cp = str.codePointAt(j-1);
                     if (Character.isSupplementaryCodePoint(cp)) {
                        expected++;
                    }
                }
                check(result != expected,
                      "offsetByCodePoints(input["+i+"], 0, "+nCodePoints+")",
                      result, expected);
                result = str.offsetByCodePoints(j, -nCodePoints);
                check(result != 0,
                      "offsetByCodePoints(input["+i+"], "+j+", "+(-nCodePoints)+")",
                      result, 0);
            }
        }
    }

    static final boolean At = true, Before = false;
    static final boolean FIRST = true, LAST = false;

    static void testCodePoint(boolean isAt, String s, int index, int expected) {
        int c = isAt ? s.codePointAt(index) : s.codePointBefore(index);

        check(c != expected,
              "codePoint" + (isAt ? "At" : "Before") + "(" + index + ") for <"
              + s + ">", c, expected);
    }

    static void testCodePoint(boolean isAt, String s, int index) {
        boolean exceptionOccurred = false;

        try {
            int c = isAt ? s.codePointAt(index) : s.codePointBefore(index);
        }
        catch (StringIndexOutOfBoundsException e) {
            exceptionOccurred = true;
        }
        check(!exceptionOccurred,
              "codePoint" + (isAt ? "At" : "Before") + "(" + index + ") for <"
              + s + "> should throw StringIndexOutOfBoundsPointerException.");
    }

    static void testIndexOf(String s, int c, int expected) {
        testIndexOf2(s, c, expected);
        if (s.indexOf(c) != -1) {
            testIndexOf2(s + (char) c, c, expected);
            if (Character.isSupplementaryCodePoint(c)) {
                char[] surrogates = Character.toChars(c);
                testIndexOf2(s + new String(surrogates), c, expected);
                testIndexOf2(s + surrogates[0], c, expected);
                testIndexOf2(s + surrogates[1], c, expected);
                testIndexOf2(new String(surrogates) + s, c, 0);
                testIndexOf2(surrogates[0] + s, c, expected + 1);
                testIndexOf2(surrogates[1] + s, c, expected + 1);
            }
        }
    }

    static void testIndexOf2(String s, int c, int expected) {
        int index = s.indexOf(c);

        check(index != expected,
              "indexOf(" + toHexString(c) + ") for <" + s + ">",
              index, expected);
    }

    static void testLastIndexOf(String s, int c, int expected) {
        testLastIndexOf2(s, c, expected);
        if (s.lastIndexOf(c) != -1) {
            testLastIndexOf2((char) c + s, c, expected + 1);
            if (Character.isSupplementaryCodePoint(c)) {
                char[] surrogates = Character.toChars(c);
                testLastIndexOf2(s + new String(surrogates), c, s.length());
                testLastIndexOf2(s + surrogates[0], c, expected);
                testLastIndexOf2(s + surrogates[1], c, expected);
                testLastIndexOf2(new String(surrogates) + s, c, expected + 2);
                testLastIndexOf2(surrogates[0] + s, c, expected + 1);
                testLastIndexOf2(surrogates[1] + s, c, expected + 1);
            }
        }
    }

    static void testLastIndexOf2(String s, int c, int expected) {
        int index = s.lastIndexOf(c);

        check(index != expected,
              "lastIndexOf(" + toHexString(c) + ") for <" + s + ">",
              index, expected);
    }

    static int testIndexOf(String s, int fromIndex, int c, int expected) {
        int index = s.indexOf(c, fromIndex);

        check(index != expected,
              "indexOf(" + toHexString(c) + ", "
              + fromIndex + ") for <" + s + ">",
              index, expected);

        return index;
    }

    static int testLastIndexOf(String s, int fromIndex, int c, int expected) {
        int index = s.lastIndexOf(c, fromIndex);

        check(index != expected,
              "lastIndexOf(" + toHexString(c) + ", "
              + fromIndex + ") for <" + s + ">",
              index, expected);

        return index;
    }

    static void testNewString(int[] codePoints, int offset, int count, Class expectedException) {
        try {
            String s = new String(codePoints, offset, count);
        } catch (Exception e) {
            if (expectedException.isInstance(e)) {
                return;
            }
            throw new RuntimeException("Error: Unexpected exception", e);
        }
        check(true, "new String(int[]...) didn't throw " + expectedException.getName());
    }

    static void testCodePointCount(String str, int beginIndex, int endIndex,
                                   Class expectedException) {
        try {
            int n = str.codePointCount(beginIndex, endIndex);
        } catch (Exception e) {
            if (expectedException.isInstance(e)) {
                return;
            }
            throw new RuntimeException("Error: Unexpected exception", e);
        }
        check(true, "codePointCount() didn't throw " + expectedException.getName());
    }

    static void testOffsetByCodePoints(String str, int index, int offset,
                                       Class expectedException) {
        try {
            int n = str.offsetByCodePoints(index, offset);
        } catch (Exception e) {
            if (expectedException.isInstance(e)) {
                return;
            }
            throw new RuntimeException("Error: Unexpected exception", e);
        }
        check(true, "offsetByCodePoints() didn't throw " + expectedException.getName());
    }

    static void check(boolean err, String msg) {
        if (err) {
            throw new RuntimeException("Error: " + msg);
        }
    }

    static void check(boolean err, String s, int got, int expected) {
        if (err) {
            throw new RuntimeException("Error: " + s
                                       + " returned an unexpected value. got "
                                       + toHexString(got)
                                       + ", expected "
                                       + toHexString(expected));
        }
    }

    private static String toHexString(int c) {
        return "0x" + Integer.toHexString(c);
    }
}

quality85%

¤ Dauer der Verarbeitung: 0.18 Sekunden (vorverarbeitet) ¤

Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.