SSL BashStreams.java Sprache: 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);

    }

}

quality93%

¤ Dauer der Verarbeitung: 0.24 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.

Bemerkung:

Die farbliche Syntaxdarstellung ist noch experimentell.