397 lines
12 KiB
Java
397 lines
12 KiB
Java
/*
|
|
* Copyright (c) 2010, 2016, 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
|
|
* @summary Stochastic test of charset-based streams
|
|
* @key randomness
|
|
*/
|
|
|
|
import java.io.*;
|
|
import java.util.*;
|
|
import java.nio.*;
|
|
import java.nio.channels.*;
|
|
import java.nio.charset.*;
|
|
|
|
|
|
public class BashStreams {
|
|
|
|
static final PrintStream log = System.err;
|
|
|
|
|
|
static class CharacterGenerator {
|
|
|
|
private final Random rand;
|
|
private final int max;
|
|
private final int limit;
|
|
private int count = 0;
|
|
|
|
CharacterGenerator(long seed, String csn, int limit) {
|
|
rand = new Random(seed);
|
|
this.max = Character.MAX_CODE_POINT + 1;
|
|
this.limit = limit;
|
|
}
|
|
|
|
private char[] saved = new char[10];
|
|
private int savedCount = 0;
|
|
|
|
void push(char c) {
|
|
saved[savedCount++] = c;
|
|
count--;
|
|
}
|
|
|
|
int count() {
|
|
return count;
|
|
}
|
|
|
|
boolean hasNext() {
|
|
return count < limit;
|
|
}
|
|
|
|
char next() {
|
|
if (count >= limit)
|
|
throw new RuntimeException("EOF");
|
|
if (savedCount > 0) {
|
|
savedCount--;
|
|
count++;
|
|
return saved[savedCount];
|
|
}
|
|
int c;
|
|
for (;;) {
|
|
c = rand.nextInt(max);
|
|
if ((Character.isBmpCodePoint(c)
|
|
&& (Character.isSurrogate((char) c)
|
|
|| (c == 0xfffe) || (c == 0xffff))))
|
|
continue;
|
|
if (Character.isSupplementaryCodePoint(c)
|
|
&& (count == limit - 1))
|
|
continue;
|
|
break;
|
|
}
|
|
count++;
|
|
if (Character.isSupplementaryCodePoint(c)) {
|
|
count++;
|
|
push(Character.lowSurrogate(c));
|
|
return Character.highSurrogate(c);
|
|
}
|
|
return (char)c;
|
|
}
|
|
|
|
}
|
|
|
|
|
|
static void mismatch(String csn, int count, char c, char d) {
|
|
throw new RuntimeException(csn + ": Mismatch at count "
|
|
+ count
|
|
+ ": " + Integer.toHexString(c)
|
|
+ " != "
|
|
+ Integer.toHexString(d));
|
|
}
|
|
|
|
static void mismatchedEOF(String csn, int count, int cgCount) {
|
|
throw new RuntimeException(csn + ": Mismatched EOFs: "
|
|
+ count
|
|
+ " != "
|
|
+ cgCount);
|
|
}
|
|
|
|
|
|
static class Sink // One abomination...
|
|
extends OutputStream
|
|
implements WritableByteChannel
|
|
{
|
|
|
|
private final String csn;
|
|
private final CharacterGenerator cg;
|
|
private int count = 0;
|
|
|
|
Sink(String csn, long seed) {
|
|
this.csn = csn;
|
|
this.cg = new CharacterGenerator(seed, csn, Integer.MAX_VALUE);
|
|
}
|
|
|
|
public void write(int b) throws IOException {
|
|
write (new byte[] { (byte)b }, 0, 1);
|
|
}
|
|
|
|
private int check(byte[] ba, int off, int len) throws IOException {
|
|
String s = new String(ba, off, len, csn);
|
|
int n = s.length();
|
|
for (int i = 0; i < n; i++) {
|
|
char c = s.charAt(i);
|
|
char d = cg.next();
|
|
if (c != d) {
|
|
if (c == '?') {
|
|
if (Character.isHighSurrogate(d))
|
|
cg.next();
|
|
continue;
|
|
}
|
|
mismatch(csn, count + i, c, d);
|
|
}
|
|
}
|
|
count += n;
|
|
return len;
|
|
}
|
|
|
|
public void write(byte[] ba, int off, int len) throws IOException {
|
|
check(ba, off, len);
|
|
}
|
|
|
|
public int write(ByteBuffer bb) throws IOException {
|
|
int n = check(bb.array(),
|
|
bb.arrayOffset() + bb.position(),
|
|
bb.remaining());
|
|
bb.position(bb.position() + n);
|
|
return n;
|
|
}
|
|
|
|
public void close() {
|
|
count = -1;
|
|
}
|
|
|
|
public boolean isOpen() {
|
|
return count >= 0;
|
|
}
|
|
|
|
}
|
|
|
|
static void testWrite(String csn, int limit, long seed, Writer w)
|
|
throws IOException
|
|
{
|
|
Random rand = new Random(seed);
|
|
CharacterGenerator cg = new CharacterGenerator(seed, csn,
|
|
Integer.MAX_VALUE);
|
|
int count = 0;
|
|
char[] ca = new char[16384];
|
|
|
|
int n = 0;
|
|
while (count < limit) {
|
|
n = rand.nextInt(ca.length);
|
|
for (int i = 0; i < n; i++)
|
|
ca[i] = cg.next();
|
|
w.write(ca, 0, n);
|
|
count += n;
|
|
}
|
|
if (Character.isHighSurrogate(ca[n - 1]))
|
|
w.write(cg.next());
|
|
w.close();
|
|
}
|
|
|
|
static void testStreamWrite(String csn, int limit, long seed)
|
|
throws IOException
|
|
{
|
|
log.println(" write stream");
|
|
testWrite(csn, limit, seed,
|
|
new OutputStreamWriter(new Sink(csn, seed), csn));
|
|
}
|
|
|
|
static void testChannelWrite(String csn, int limit, long seed)
|
|
throws IOException
|
|
{
|
|
log.println(" write channel");
|
|
testWrite(csn, limit, seed,
|
|
Channels.newWriter(new Sink(csn, seed),
|
|
Charset.forName(csn)
|
|
.newEncoder()
|
|
.onMalformedInput(CodingErrorAction.REPLACE)
|
|
.onUnmappableCharacter(CodingErrorAction.REPLACE),
|
|
8192));
|
|
}
|
|
|
|
|
|
static class Source // ... and another
|
|
extends InputStream
|
|
implements ReadableByteChannel
|
|
{
|
|
|
|
private final String csn;
|
|
private final CharsetEncoder enc;
|
|
private final CharacterGenerator cg;
|
|
private int count = 0;
|
|
|
|
Source(String csn, long seed, int limit) {
|
|
this.csn = csn.startsWith("\1") ? csn.substring(1) : csn;
|
|
this.enc = Charset.forName(this.csn).newEncoder()
|
|
.onMalformedInput(CodingErrorAction.REPLACE)
|
|
.onUnmappableCharacter(CodingErrorAction.REPLACE);
|
|
this.cg = new CharacterGenerator(seed, csn, limit);
|
|
}
|
|
|
|
public int read() throws IOException {
|
|
byte[] b = new byte[1];
|
|
read(b);
|
|
return b[0];
|
|
}
|
|
|
|
private CharBuffer cb = CharBuffer.allocate(8192);
|
|
private ByteBuffer bb = null;
|
|
|
|
public int read(byte[] ba, int off, int len) throws IOException {
|
|
if (!cg.hasNext())
|
|
return -1;
|
|
int end = off + len;
|
|
int i = off;
|
|
while (i < end) {
|
|
if ((bb == null) || !bb.hasRemaining()) {
|
|
cb.clear();
|
|
while (cb.hasRemaining()) {
|
|
if (!cg.hasNext())
|
|
break;
|
|
char c = cg.next();
|
|
if (Character.isHighSurrogate(c)
|
|
&& cb.remaining() == 1) {
|
|
cg.push(c);
|
|
break;
|
|
}
|
|
cb.put(c);
|
|
}
|
|
cb.flip();
|
|
if (!cb.hasRemaining())
|
|
break;
|
|
bb = enc.encode(cb);
|
|
}
|
|
int d = Math.min(bb.remaining(), end - i);
|
|
bb.get(ba, i, d);
|
|
i += d;
|
|
}
|
|
return i - off;
|
|
}
|
|
|
|
public int read(ByteBuffer bb) throws IOException {
|
|
int n = read(bb.array(),
|
|
bb.arrayOffset() + bb.position(),
|
|
bb.remaining());
|
|
if (n >= 0)
|
|
bb.position(bb.position() + n);
|
|
return n;
|
|
}
|
|
|
|
public void close() {
|
|
count = -1;
|
|
}
|
|
|
|
public boolean isOpen() {
|
|
return count != -1;
|
|
}
|
|
|
|
}
|
|
|
|
static void testRead(String csn, int limit, long seed, int max,
|
|
Reader rd)
|
|
throws IOException
|
|
{
|
|
Random rand = new Random(seed);
|
|
CharacterGenerator cg = new CharacterGenerator(seed, csn, limit);
|
|
int count = 0;
|
|
char[] ca = new char[16384];
|
|
|
|
int n = 0;
|
|
while (count < limit) {
|
|
int rn = rand.nextInt(ca.length);
|
|
n = rd.read(ca, 0, rn);
|
|
if (n < 0)
|
|
break;
|
|
for (int i = 0; i < n; i++) {
|
|
char c = ca[i];
|
|
if (!cg.hasNext())
|
|
mismatchedEOF(csn, count + i, cg.count());
|
|
char d = cg.next();
|
|
if (c == '?') {
|
|
if (Character.isHighSurrogate(d)) {
|
|
cg.next();
|
|
continue;
|
|
}
|
|
if (d > max)
|
|
continue;
|
|
}
|
|
if (c != d)
|
|
mismatch(csn, count + i, c, d);
|
|
}
|
|
count += n;
|
|
}
|
|
if (cg.hasNext())
|
|
mismatchedEOF(csn, count, cg.count());
|
|
rd.close();
|
|
}
|
|
|
|
static void testStreamRead(String csn, int limit, long seed, int max)
|
|
throws IOException
|
|
{
|
|
log.println(" read stream");
|
|
testRead(csn, limit, seed, max,
|
|
new InputStreamReader(new Source(csn, seed, limit), csn));
|
|
}
|
|
|
|
static void testChannelRead(String csn, int limit, long seed, int max)
|
|
throws IOException
|
|
{
|
|
log.println(" read channel");
|
|
testRead(csn, limit, seed, max,
|
|
Channels.newReader(new Source(csn, seed, limit), csn));
|
|
}
|
|
|
|
|
|
static final int LIMIT = 1 << 21;
|
|
|
|
static void test(String csn, int limit, long seed, int max)
|
|
throws Exception
|
|
{
|
|
log.println();
|
|
log.println(csn);
|
|
|
|
testStreamWrite(csn, limit, seed);
|
|
testChannelWrite(csn, limit, seed);
|
|
testStreamRead(csn, limit, seed, max);
|
|
testChannelRead(csn, limit, seed, max);
|
|
}
|
|
|
|
public static void main(String[] args) throws Exception {
|
|
|
|
if (System.getProperty("os.arch").equals("ia64")) {
|
|
// This test requires 54 minutes on an Itanium-1 processor
|
|
return;
|
|
}
|
|
|
|
int ai = 0, an = args.length;
|
|
|
|
int limit;
|
|
if (ai < an)
|
|
limit = 1 << Integer.parseInt(args[ai++]);
|
|
else
|
|
limit = LIMIT;
|
|
log.println("limit = " + limit);
|
|
|
|
long seed;
|
|
if (ai < an)
|
|
seed = Long.parseLong(args[ai++]);
|
|
else
|
|
seed = System.currentTimeMillis();
|
|
log.println("seed = " + seed);
|
|
|
|
test("UTF-8", limit, seed, Integer.MAX_VALUE);
|
|
test("US-ASCII", limit, seed, 0x7f);
|
|
test("ISO-8859-1", limit, seed, 0xff);
|
|
|
|
}
|
|
|
|
}
|