/*

 * 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

 */

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);

    }

}