/*
* 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);
}
}
}
}
}