Quelle  MalformedSurrogates.java

/*
 * Copyright (c) 2002, 2013, 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 4153987
 * @summary Malformed surrogates should be handled by the converter in
 * substitution mode.
 */
import java.io.*;
import java.nio.charset.Charset;
import java.nio.charset.CharsetDecoder;
import java.nio.charset.CharsetEncoder;
import java.nio.CharBuffer;
import java.nio.ByteBuffer;
import java.nio.charset.CodingErrorAction;
import java.nio.charset.MalformedInputException;
import java.nio.charset.UnmappableCharacterException;
import java.util.SortedMap;

public class MalformedSurrogates {

    private static final String PREFIX = "abc";
    private static final String SUFFIX = "efgh";
    private static final String MALFORMED_SURROGATE = PREFIX + "\uD800\uDB00" + SUFFIX;
    private static final String NORMAL_SURROGATE = PREFIX + "\uD800\uDC00" + SUFFIX;
    private static final String REVERSED_SURROGATE = PREFIX + "\uDC00\uD800" + SUFFIX;
    private static final String SOLITARY_HIGH_SURROGATE = PREFIX + "\uD800" + SUFFIX;
    private static final String SOLITARY_LOW_SURROGATE = PREFIX + "\uDC00" + SUFFIX;

    public static void main(String[] args) throws IOException {
        SortedMap<String, Charset> map = Charset.availableCharsets();
        for (String name : map.keySet()) {
            Charset charset = map.get(name);
            if (charset.canEncode() && !charset.name().equals("x-COMPOUND_TEXT")) {
                testNormalSurrogate(charset, NORMAL_SURROGATE);
                testMalformedSurrogate(charset, MALFORMED_SURROGATE);
                testMalformedSurrogate(charset, REVERSED_SURROGATE);
                testMalformedSurrogate(charset, SOLITARY_HIGH_SURROGATE);
                testMalformedSurrogate(charset, SOLITARY_LOW_SURROGATE);
                testSurrogateWithReplacement(charset, NORMAL_SURROGATE);
                testSurrogateWithReplacement(charset, MALFORMED_SURROGATE);
                testSurrogateWithReplacement(charset, REVERSED_SURROGATE);
                testSurrogateWithReplacement(charset, SOLITARY_HIGH_SURROGATE);
                testSurrogateWithReplacement(charset, SOLITARY_LOW_SURROGATE);
            }
        }
    }

    public static void testMalformedSurrogate(Charset cs, String surrogate) throws IOException {
        CharsetEncoder en = cs.newEncoder();
        if (en.canEncode(surrogate)) {
            throw new RuntimeException("testMalformedSurrogate failed with charset " + cs.name());
        }

        try {
            en.encode(CharBuffer.wrap(surrogate));
            throw new RuntimeException("Should throw MalformedInputException or UnmappableCharacterException");
        } catch (MalformedInputException | UnmappableCharacterException ex) {
        } finally {
            en.reset();
        }

        try (OutputStreamWriter osw = new OutputStreamWriter(new ByteArrayOutputStream(), en)) {
            osw.write(surrogate);
            throw new RuntimeException("Should throw MalformedInputException or UnmappableCharacterException");
        } catch (MalformedInputException | UnmappableCharacterException ex) {
        }
    }

    public static void testNormalSurrogate(Charset cs, String surrogate) throws IOException {
        CharsetEncoder en = cs.newEncoder();
        try {
            en.encode(CharBuffer.wrap(surrogate));
        } catch (UnmappableCharacterException ex) {
        } finally {
            en.reset();
        }

        try (OutputStreamWriter osw = new OutputStreamWriter(new ByteArrayOutputStream(), en)) {
            osw.write(surrogate);
        } catch (UnmappableCharacterException ex) {
        }
    }

    public static void testSurrogateWithReplacement(Charset cs, String surrogate) throws IOException {
        CharsetEncoder en = cs.newEncoder();
        CharsetDecoder de = cs.newDecoder();
        if (!en.canEncode(NORMAL_SURROGATE)) {
            return;
        }
        String expected = null;
        String replace = new String(en.replacement(), cs);
        switch (surrogate) {
            case MALFORMED_SURROGATE:
            case REVERSED_SURROGATE:
                expected = PREFIX + replace + replace + SUFFIX;
                break;
            case SOLITARY_HIGH_SURROGATE:
            case SOLITARY_LOW_SURROGATE:
                expected = PREFIX + replace + SUFFIX;
                break;
            default:
                expected = NORMAL_SURROGATE;
        }

        try {
            en.onMalformedInput(CodingErrorAction.REPLACE);
            en.onUnmappableCharacter(CodingErrorAction.REPLACE);
            ByteBuffer bbuf = en.encode(CharBuffer.wrap(surrogate));
            CharBuffer cbuf = de.decode(bbuf);
            if (!cbuf.toString().equals(expected)) {
                throw new RuntimeException("charset " + cs.name() + " (en)decoded the surrogate " + surrogate + " to " + cbuf.toString() + " which is not same as the expected " + expected);
            }
        } finally {
            en.reset();
            de.reset();
        }

        try (ByteArrayOutputStream bos = new ByteArrayOutputStream();
                OutputStreamWriter osw = new OutputStreamWriter(bos, en);) {
            osw.write(surrogate);
            osw.flush();
            try (InputStreamReader isr = new InputStreamReader(new ByteArrayInputStream(bos.toByteArray()), de)) {
                CharBuffer cbuf = CharBuffer.allocate(expected.length());
                isr.read(cbuf);
                cbuf.rewind();
                if (!cbuf.toString().equals(expected)) {
                    throw new RuntimeException("charset " + cs.name() + " (en)decoded the surrogate " + surrogate + " to " + cbuf.toString() + " which is not same as the expected " + expected);
                }
            }
        }
    }
}