Quelle TestByteChunk.java Sprache: JAVA

/*
*  Licensed to the Apache Software Foundation (ASF) under one or more
*  contributor license agreements.  See the NOTICE file distributed with
*  this work for additional information regarding copyright ownership.
*  The ASF licenses this file to You under the Apache License, Version 2.0
*  (the "License"); you may not use this file except in compliance with
*  the License.  You may obtain a copy of the License at
*
*      http://www.apache.org/licenses/LICENSE-2.0
*
*  Unless required by applicable law or agreed to in writing, software
*  distributed under the License is distributed on an "AS IS" BASIS,
*  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*  See the License for the specific language governing permissions and
*  limitations under the License.
*/
package org.apache.tomcat.util.buf;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.UnsupportedEncodingException;
import java.nio.ByteBuffer;
import java.nio.charset.StandardCharsets;
import java.util.Arrays;

import org.junit.Assert;
import org.junit.Ignore;
import org.junit.Test;

import org.apache.tomcat.util.buf.ByteChunk.ByteOutputChannel;

/**
* Test cases for {@link ByteChunk}.
*/
public class TestByteChunk {

    @Test
    public void testConvertToBytes() throws UnsupportedEncodingException {
        String string = "HTTP/1.1 100 \r\n\r\n";
        byte[] bytes = ByteChunk.convertToBytes(string);
        byte[] expected = string.getBytes("ISO-8859-1");
        Assert.assertTrue(Arrays.equals(bytes, expected));
    }

    /*
     * Test for {@code findByte} vs. {@code indexOf} methods difference.
     *
     * <p>
     * As discussed in the "Re: r944918" thread on dev@, {@code
     * ByteChunk.indexOf()} works for 0-127 ASCII chars only, and cannot find
     * any chars outside of the range. {@code ByteChunk.findByte()} works for
     * any ISO-8859-1 chars.
     */
    @Test
    public void testFindByte() throws UnsupportedEncodingException {
        // 0xa0 = 160 =   character
        byte[] bytes = "Hello\u00a0world".getBytes("ISO-8859-1");
        final int len = bytes.length;

        // indexOf() does not work outside of 0-127
        Assert.assertEquals(5, ByteChunk.findByte(bytes, 0, len, (byte) '\u00a0'));
        Assert.assertEquals(-1, ByteChunk.indexOf(bytes, 0, len, '\u00a0'));

        Assert.assertEquals(0, ByteChunk.findByte(bytes, 0, len, (byte) 'H'));
        Assert.assertEquals(0, ByteChunk.indexOf(bytes, 0, len, 'H'));

        Assert.assertEquals(len - 1, ByteChunk.findByte(bytes, 0, len, (byte) 'd'));
        Assert.assertEquals(len - 1, ByteChunk.indexOf(bytes, 0, len, 'd'));

        Assert.assertEquals(-1, ByteChunk.findByte(bytes, 0, len, (byte) 'x'));
        Assert.assertEquals(-1, ByteChunk.indexOf(bytes, 0, len, 'x'));

        Assert.assertEquals(7, ByteChunk.findByte(bytes, 5, len, (byte) 'o'));
        Assert.assertEquals(7, ByteChunk.indexOf(bytes, 5, len, 'o'));

        Assert.assertEquals(-1, ByteChunk.findByte(bytes, 2, 5, (byte) 'w'));
        Assert.assertEquals(-1, ByteChunk.indexOf(bytes, 5, 5, 'w'));
    }

    @Test
    public void testIndexOf_Char() throws UnsupportedEncodingException {
        byte[] bytes = "Hello\u00a0world".getBytes("ISO-8859-1");
        final int len = bytes.length;

        ByteChunk bc = new ByteChunk();
        bc.setBytes(bytes, 0, len);

        Assert.assertEquals(0, bc.indexOf('H', 0));
        Assert.assertEquals(6, bc.indexOf('w', 0));

        // Does not work outside of 0-127
        Assert.assertEquals(-1, bc.indexOf('\u00a0', 0));

        bc.setBytes(bytes, 6, 5);
        Assert.assertEquals(1, bc.indexOf('o', 0));

        bc.setBytes(bytes, 6, 2);
        Assert.assertEquals(0, bc.indexOf('w', 0));
        Assert.assertEquals(-1, bc.indexOf('d', 0));
    }

    @Test
    public void testIndexOf_String() throws UnsupportedEncodingException {
        byte[] bytes = "Hello\u00a0world".getBytes("ISO-8859-1");
        final int len = bytes.length;

        ByteChunk bc = new ByteChunk();
        bc.setBytes(bytes, 0, len);

        Assert.assertEquals(0, bc.indexOf("Hello", 0, "Hello".length(), 0));
        Assert.assertEquals(2, bc.indexOf("ll", 0, 2, 0));
        Assert.assertEquals(2, bc.indexOf("Hello", 2, 2, 0));

        Assert.assertEquals(7, bc.indexOf("o", 0, 1, 5));

        // Does not work outside of 0-127
        Assert.assertEquals(-1, bc.indexOf("\u00a0", 0, 1, 0));

        bc.setBytes(bytes, 6, 5);
        Assert.assertEquals(1, bc.indexOf("o", 0, 1, 0));

        bc.setBytes(bytes, 6, 2);
        Assert.assertEquals(0, bc.indexOf("wo", 0, 1, 0));
        Assert.assertEquals(-1, bc.indexOf("d", 0, 1, 0));
    }

    @Test
    public void testFindBytes() throws UnsupportedEncodingException {
        byte[] bytes = "Hello\u00a0world".getBytes("ISO-8859-1");
        final int len = bytes.length;

        Assert.assertEquals(0, ByteChunk.findBytes(bytes, 0, len, new byte[] { 'H' }));
        Assert.assertEquals(5, ByteChunk.findBytes(bytes, 0, len, new byte[] {
                (byte) '\u00a0', 'x' }));
        Assert.assertEquals(5, ByteChunk.findBytes(bytes, 0, len - 4, new byte[] {
                'x', (byte) '\u00a0' }));
        Assert.assertEquals(len - 1, ByteChunk.findBytes(bytes, 2, len, new byte[] {
                'x', 'd' }));
        Assert.assertEquals(1, ByteChunk.findBytes(bytes, 0, len, new byte[] { 'o',
                'e' }));
        Assert.assertEquals(-1, ByteChunk.findBytes(bytes, 2, 5, new byte[] { 'w' }));
    }

    @Test
    public void testSerialization() throws Exception {
        String data = "Hello world!";
        byte[] bytes = data.getBytes(StandardCharsets.UTF_8);

        ByteChunk bcIn = new ByteChunk();
        bcIn.setBytes(bytes, 0, bytes.length);
        bcIn.setCharset(StandardCharsets.UTF_8);

        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(baos);
        oos.writeObject(bcIn);
        oos.close();

        ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
        ObjectInputStream ois = new ObjectInputStream(bais);
        ByteChunk bcOut = (ByteChunk) ois.readObject();

        Assert.assertArrayEquals(bytes, bcOut.getBytes());
        Assert.assertEquals(bcIn.getCharset(), bcOut.getCharset());
    }

    @Ignore // Requires a 6GB heap (on markt's desktop - YMMV)
    @Test
    public void testAppend() throws Exception {
        ByteChunk bc = new ByteChunk();
        bc.setByteOutputChannel(new Sink());
        // Defaults to no limit

        byte data[] = new byte[32 * 1024 * 1024];

        for (int i = 0; i < 100; i++) {
            bc.append(data, 0, data.length);
        }

        Assert.assertEquals(AbstractChunk.ARRAY_MAX_SIZE, bc.getBuffer().length);
    }

    public static class Sink implements ByteOutputChannel {

        @Override
        public void realWriteBytes(byte[] cbuf, int off, int len) throws IOException {
            // NO-OP
        }

        @Override
        public void realWriteBytes(ByteBuffer from) throws IOException {
            // NO-OP
        }
    }

    @Test
    public void testToString() {
        ByteChunk bc = new ByteChunk();
        Assert.assertNull(bc.toString());
        byte[] data = new byte[8];
        bc.setBytes(data, 0, data.length);
        Assert.assertNotNull(bc.toString());
        bc.recycle();
        // toString() should behave consistently for new ByteChunk and
        // immediately after a call to recycle().
        Assert.assertNull(bc.toString());
    }
}

quality100%

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