SSL EqualsCompareTest.java Sprache: JAVA

/*
* Copyright (c) 2017, 2018, 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.
*/

import org.testng.Assert;
import org.testng.annotations.DataProvider;
import org.testng.annotations.Test;

import java.lang.invoke.MethodHandle;
import java.lang.invoke.MethodHandles;
import java.lang.invoke.MethodType;
import java.nio.Buffer;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.CharBuffer;
import java.nio.DoubleBuffer;
import java.nio.FloatBuffer;
import java.nio.IntBuffer;
import java.nio.LongBuffer;
import java.nio.ShortBuffer;
import java.util.HashMap;
import java.util.Map;
import java.util.function.BiFunction;
import java.util.function.LongFunction;
import java.util.stream.IntStream;

/*
* @test
* @bug 8193085 8199773
* @summary tests for buffer equals and compare
* @run testng EqualsCompareTest
*/

public class EqualsCompareTest {

    // Maximum width in bits
    static final int MAX_WIDTH = 512;

    static final Map<Class, Integer> typeToWidth;

    static {
        typeToWidth = new HashMap<>();
        typeToWidth.put(byte.class, Byte.SIZE);
        typeToWidth.put(short.class, Short.SIZE);
        typeToWidth.put(char.class, Character.SIZE);
        typeToWidth.put(int.class, Integer.SIZE);
        typeToWidth.put(long.class, Long.SIZE);
        typeToWidth.put(float.class, Float.SIZE);
        typeToWidth.put(double.class, Double.SIZE);
    }

    static int arraySizeFor(Class<?> type) {
        assert type.isPrimitive();
        return 4 * MAX_WIDTH / typeToWidth.get(type);
    }

    enum BufferKind {
        HEAP,
        HEAP_VIEW,
        DIRECT;
    }

    static abstract class BufferType<T extends Buffer, E> {
        final BufferKind k;
        final Class<?> bufferType;
        final Class<?> elementType;

        final MethodHandle eq;
        final MethodHandle cmp;
        final MethodHandle mismtch;

        final MethodHandle getter;
        final MethodHandle setter;

        BufferType(BufferKind k, Class<T> bufferType, Class<?> elementType) {
            this.k = k;
            this.bufferType = bufferType;
            this.elementType = elementType;

            var lookup = MethodHandles.lookup();
            try {
                eq = lookup.findVirtual(bufferType, "equals", MethodType.methodType(boolean.class, Object.class));
                cmp = lookup.findVirtual(bufferType, "compareTo", MethodType.methodType(int.class, bufferType));
                mismtch = lookup.findVirtual(bufferType, "mismatch", MethodType.methodType(int.class, bufferType));

                getter = lookup.findVirtual(bufferType, "get", MethodType.methodType(elementType, int.class));
                setter = lookup.findVirtual(bufferType, "put", MethodType.methodType(bufferType, int.class, elementType));
            }
            catch (Exception e) {
                throw new AssertionError(e);
            }
        }

        @Override
        public String toString() {
            return bufferType.getName() + " " + k;
        }

        T construct(int length) {
            return construct(length, ByteOrder.BIG_ENDIAN);
        }

        abstract T construct(int length, ByteOrder bo);

        @SuppressWarnings("unchecked")
        T slice(T a, int from, int to, boolean dupOtherwiseSlice) {
            a = (T) a.position(from).limit(to);
            return (T) (dupOtherwiseSlice ? a.duplicate() : a.slice());
        }

        @SuppressWarnings("unchecked")
        E get(T a, int i) {
            try {
                return (E) getter.invoke(a, i);
            }
            catch (RuntimeException | Error e) {
                throw e;
            }
            catch (Throwable t) {
                throw new Error(t);
            }
        }

        void set(T a, int i, Object v) {
            try {
                setter.invoke(a, i, convert(v));
            }
            catch (RuntimeException | Error e) {
                throw e;
            }
            catch (Throwable t) {
                throw new Error(t);
            }
        }

        abstract Object convert(Object o);

        boolean equals(T a, T b) {
            try {
                return (boolean) eq.invoke(a, b);
            }
            catch (RuntimeException | Error e) {
                throw e;
            }
            catch (Throwable t) {
                throw new Error(t);
            }
        }

        int compare(T a, T b) {
            try {
                return (int) cmp.invoke(a, b);
            }
            catch (RuntimeException | Error e) {
                throw e;
            }
            catch (Throwable t) {
                throw new Error(t);
            }
        }

        boolean pairWiseEquals(T a, T b) {
            if (a.remaining() != b.remaining())
                return false;
            int p = a.position();
            for (int i = a.limit() - 1, j = b.limit() - 1; i >= p; i--, j--)
                if (!get(a, i).equals(get(b, j)))
                    return false;
            return true;
        }

        int mismatch(T a, T b) {
            try {
                return (int) mismtch.invoke(a, b);
            }
            catch (RuntimeException | Error e) {
                throw e;
            }
            catch (Throwable t) {
              throw new Error(t);
            }
        }

        static class Bytes extends BufferType<ByteBuffer, Byte> {
            Bytes(BufferKind k) {
                super(k, ByteBuffer.class, byte.class);
            }

            @Override
            ByteBuffer construct(int length, ByteOrder bo) {
                switch (k) {
                    case DIRECT:
                        return ByteBuffer.allocateDirect(length).order(bo);
                    default:
                    case HEAP_VIEW:
                    case HEAP:
                        return ByteBuffer.allocate(length).order(bo);
                }
            }

            @Override
            Object convert(Object o) {
                return o instanceof Integer
                       ? ((Integer) o).byteValue()
                       : o;
            }
        }

        static class Chars extends BufferType<CharBuffer, Character> {
            Chars(BufferKind k) {
                super(k, CharBuffer.class, char.class);
            }

            @Override
            CharBuffer construct(int length, ByteOrder bo) {
                switch (k) {
                    case DIRECT:
                        return ByteBuffer.allocateDirect(length * Character.BYTES).
                                order(bo).
                                asCharBuffer();
                    case HEAP_VIEW:
                        return ByteBuffer.allocate(length * Character.BYTES).
                                order(bo).
                                asCharBuffer();
                    default:
                    case HEAP:
                        return CharBuffer.allocate(length);
                }
            }

            @Override
            Object convert(Object o) {
                return o instanceof Integer
                       ? (char) ((Integer) o).intValue()
                       : o;
            }

            CharBuffer transformToStringBuffer(CharBuffer c) {
                char[] chars = new char[c.remaining()];
                c.get(chars);
                return CharBuffer.wrap(new String(chars));
            }
        }

        static class Shorts extends BufferType<ShortBuffer, Short> {
            Shorts(BufferKind k) {
                super(k, ShortBuffer.class, short.class);
            }

            @Override
            ShortBuffer construct(int length, ByteOrder bo) {
                switch (k) {
                    case DIRECT:
                        return ByteBuffer.allocateDirect(length * Short.BYTES).
                                order(bo).
                                asShortBuffer();
                    case HEAP_VIEW:
                        return ByteBuffer.allocate(length * Short.BYTES).
                                order(bo).
                                asShortBuffer();
                    default:
                    case HEAP:
                        return ShortBuffer.allocate(length);
                }
            }

            @Override
            Object convert(Object o) {
                return o instanceof Integer
                       ? ((Integer) o).shortValue()
                       : o;
            }
        }

        static class Ints extends BufferType<IntBuffer, Integer> {
            Ints(BufferKind k) {
                super(k, IntBuffer.class, int.class);
            }

            @Override
            IntBuffer construct(int length, ByteOrder bo) {
                switch (k) {
                    case DIRECT:
                        return ByteBuffer.allocateDirect(length * Integer.BYTES).
                                order(bo).
                                asIntBuffer();
                    case HEAP_VIEW:
                        return ByteBuffer.allocate(length * Integer.BYTES).
                                order(bo).
                                asIntBuffer();
                    default:
                    case HEAP:
                        return IntBuffer.allocate(length);
                }
            }

            Object convert(Object o) {
                return o;
            }
        }

        static class Floats extends BufferType<FloatBuffer, Float> {
            Floats(BufferKind k) {
                super(k, FloatBuffer.class, float.class);
            }

            @Override
            FloatBuffer construct(int length, ByteOrder bo) {
                switch (k) {
                    case DIRECT:
                        return ByteBuffer.allocateDirect(length * Float.BYTES).
                                order(bo).
                                asFloatBuffer();
                    case HEAP_VIEW:
                        return ByteBuffer.allocate(length * Float.BYTES).
                                order(bo).
                                asFloatBuffer();
                    default:
                    case HEAP:
                        return FloatBuffer.allocate(length);
                }
            }

            @Override
            Object convert(Object o) {
                return o instanceof Integer
                       ? ((Integer) o).floatValue()
                       : o;
            }

            @Override
            boolean pairWiseEquals(FloatBuffer a, FloatBuffer b) {
                if (a.remaining() != b.remaining())
                    return false;
                int p = a.position();
                for (int i = a.limit() - 1, j = b.limit() - 1; i >= p; i--, j--) {
                    float av = a.get(i);
                    float bv = b.get(j);
                    if (av != bv && (!Float.isNaN(av) || !Float.isNaN(bv)))
                        return false;
                }
                return true;
            }
        }

        static class Longs extends BufferType<LongBuffer, Long> {
            Longs(BufferKind k) {
                super(k, LongBuffer.class, long.class);
            }

            @Override
            LongBuffer construct(int length, ByteOrder bo) {
                switch (k) {
                    case DIRECT:
                        return ByteBuffer.allocateDirect(length * Long.BYTES).
                                order(bo).
                                asLongBuffer();
                    case HEAP_VIEW:
                        return ByteBuffer.allocate(length * Long.BYTES).
                                order(bo).
                                asLongBuffer();
                    default:
                    case HEAP:
                        return LongBuffer.allocate(length);
                }
            }

            @Override
            Object convert(Object o) {
                return o instanceof Integer
                       ? ((Integer) o).longValue()
                       : o;
            }
        }

        static class Doubles extends BufferType<DoubleBuffer, Double> {
            Doubles(BufferKind k) {
                super(k, DoubleBuffer.class, double.class);
            }

            @Override
            DoubleBuffer construct(int length, ByteOrder bo) {
                switch (k) {
                    case DIRECT:
                        return ByteBuffer.allocateDirect(length * Double.BYTES).
                                order(bo).
                                asDoubleBuffer();
                    case HEAP_VIEW:
                        return ByteBuffer.allocate(length * Double.BYTES).
                                order(bo).
                                asDoubleBuffer();
                    default:
                    case HEAP:
                        return DoubleBuffer.allocate(length);
                }
            }

            @Override
            Object convert(Object o) {
                return o instanceof Integer
                       ? ((Integer) o).doubleValue()
                       : o;
            }

            @Override
            boolean pairWiseEquals(DoubleBuffer a, DoubleBuffer b) {
                if (a.remaining() != b.remaining())
                    return false;
                int p = a.position();
                for (int i = a.limit() - 1, j = b.limit() - 1; i >= p; i--, j--) {
                    double av = a.get(i);
                    double bv = b.get(j);
                    if (av != bv && (!Double.isNaN(av) || !Double.isNaN(bv)))
                        return false;
                }
                return true;
            }
        }
    }

    static Object[][] bufferTypes;

    @DataProvider
    public static Object[][] bufferTypesProvider() {
        if (bufferTypes == null) {
            bufferTypes = new Object[][]{
                    {new BufferType.Bytes(BufferKind.HEAP)},
                    {new BufferType.Bytes(BufferKind.DIRECT)},
                    {new BufferType.Chars(BufferKind.HEAP)},
                    {new BufferType.Chars(BufferKind.HEAP_VIEW)},
                    {new BufferType.Chars(BufferKind.DIRECT)},
                    {new BufferType.Shorts(BufferKind.HEAP)},
                    {new BufferType.Shorts(BufferKind.HEAP_VIEW)},
                    {new BufferType.Shorts(BufferKind.DIRECT)},
                    {new BufferType.Ints(BufferKind.HEAP)},
                    {new BufferType.Ints(BufferKind.HEAP_VIEW)},
                    {new BufferType.Ints(BufferKind.DIRECT)},
                    {new BufferType.Floats(BufferKind.HEAP)},
                    {new BufferType.Floats(BufferKind.HEAP_VIEW)},
                    {new BufferType.Floats(BufferKind.DIRECT)},
                    {new BufferType.Longs(BufferKind.HEAP)},
                    {new BufferType.Longs(BufferKind.HEAP_VIEW)},
                    {new BufferType.Longs(BufferKind.DIRECT)},
                    {new BufferType.Doubles(BufferKind.HEAP)},
                    {new BufferType.Doubles(BufferKind.HEAP_VIEW)},
                    {new BufferType.Doubles(BufferKind.DIRECT)},
            };
        }
        return bufferTypes;
    }

    static Object[][] floatbufferTypes;

    @DataProvider
    public static Object[][] floatBufferTypesProvider() {
        if (floatbufferTypes == null) {
            LongFunction<Object> bTof = rb -> Float.intBitsToFloat((int) rb);
            LongFunction<Object> bToD = Double::longBitsToDouble;

            floatbufferTypes = new Object[][]{
                    // canonical and non-canonical NaNs
                    // If conversion is a signalling NaN it may be subject to conversion to a
                    // quiet NaN on some processors, even if a copy is performed
                    // The tests assume that if conversion occurs it does not convert to the
                    // canonical NaN
                    new Object[]{new BufferType.Floats(BufferKind.HEAP), 0x7fc00000L, 0x7f800001L, bTof},
                    new Object[]{new BufferType.Floats(BufferKind.HEAP_VIEW), 0x7fc00000L, 0x7f800001L, bTof},
                    new Object[]{new BufferType.Floats(BufferKind.DIRECT), 0x7fc00000L, 0x7f800001L, bTof},
                    new Object[]{new BufferType.Doubles(BufferKind.HEAP), 0x7ff8000000000000L, 0x7ff0000000000001L, bToD},
                    new Object[]{new BufferType.Doubles(BufferKind.HEAP_VIEW), 0x7ff8000000000000L, 0x7ff0000000000001L, bToD},
                    new Object[]{new BufferType.Doubles(BufferKind.DIRECT), 0x7ff8000000000000L, 0x7ff0000000000001L, bToD},

                    // +0.0 and -0.0
                    new Object[]{new BufferType.Floats(BufferKind.HEAP), 0x0L, 0x80000000L, bTof},
                    new Object[]{new BufferType.Floats(BufferKind.HEAP_VIEW), 0x0L, 0x80000000L, bTof},
                    new Object[]{new BufferType.Floats(BufferKind.DIRECT), 0x0L, 0x80000000L, bTof},
                    new Object[]{new BufferType.Doubles(BufferKind.HEAP), 0x0L, 0x8000000000000000L, bToD},
                    new Object[]{new BufferType.Doubles(BufferKind.HEAP_VIEW), 0x0L, 0x8000000000000000L, bToD},
                    new Object[]{new BufferType.Doubles(BufferKind.DIRECT), 0x0L, 0x8000000000000000L, bToD},
            };
        }
        return floatbufferTypes;
    }

    static Object[][] charBufferTypes;

    @DataProvider
    public static Object[][] charBufferTypesProvider() {
        if (charBufferTypes == null) {
            charBufferTypes = new Object[][]{
                    {new BufferType.Chars(BufferKind.HEAP)},
                    {new BufferType.Chars(BufferKind.HEAP_VIEW)},
                    {new BufferType.Chars(BufferKind.DIRECT)},
            };
        }
        return charBufferTypes;
    }

    // Tests all primitive buffers
    @Test(dataProvider = "bufferTypesProvider")
    <E>
    void testBuffers(BufferType<Buffer, E> bufferType) {
        // Test with buffers of the same byte order (BE)
        BiFunction<BufferType<Buffer, E>, Integer, Buffer> constructor = (at, s) -> {
            Buffer a = at.construct(s);
            for (int x = 0; x < s; x++) {
                at.set(a, x, x % 8);
            }
            return a;
        };

        testBufferType(bufferType, constructor, constructor);

        // Test with buffers of different byte order
        if (bufferType.elementType != byte.class &&
            (bufferType.k == BufferKind.HEAP_VIEW ||
             bufferType.k == BufferKind.DIRECT)) {

            BiFunction<BufferType<Buffer, E>, Integer, Buffer> leConstructor = (at, s) -> {
                Buffer a = at.construct(s, ByteOrder.LITTLE_ENDIAN);
                for (int x = 0; x < s; x++) {
                    at.set(a, x, x % 8);
                }
                return a;
            };
            testBufferType(bufferType, constructor, leConstructor);
        }
    }

    // Tests float and double buffers with edge-case values (NaN, -0.0, +0.0)
    @Test(dataProvider = "floatBufferTypesProvider")
    public void testFloatBuffers(
            BufferType<Buffer, Float> bufferType,
            long rawBitsA, long rawBitsB,
            LongFunction<Object> bitsToFloat) {
        Object av = bitsToFloat.apply(rawBitsA);
        Object bv = bitsToFloat.apply(rawBitsB);

        BiFunction<BufferType<Buffer, Float>, Integer, Buffer> allAs = (at, s) -> {
            Buffer b = at.construct(s);
            for (int x = 0; x < s; x++) {
                at.set(b, x, av);
            }
            return b;
        };

        BiFunction<BufferType<Buffer, Float>, Integer, Buffer> allBs = (at, s) -> {
            Buffer b = at.construct(s);
            for (int x = 0; x < s; x++) {
                at.set(b, x, bv);
            }
            return b;
        };

        BiFunction<BufferType<Buffer, Float>, Integer, Buffer> halfBs = (at, s) -> {
            Buffer b = at.construct(s);
            for (int x = 0; x < s / 2; x++) {
                at.set(b, x, bv);
            }
            for (int x = s / 2; x < s; x++) {
                at.set(b, x, 1);
            }
            return b;
        };

        // Sanity check
        int size = arraySizeFor(bufferType.elementType);
        Assert.assertTrue(bufferType.pairWiseEquals(allAs.apply(bufferType, size),
                                                    allBs.apply(bufferType, size)));
        Assert.assertTrue(bufferType.equals(allAs.apply(bufferType, size),
                                            allBs.apply(bufferType, size)));

        testBufferType(bufferType, allAs, allBs);
        testBufferType(bufferType, allAs, halfBs);
    }

    // Tests CharBuffer for region sources and CharSequence sources
    @Test(dataProvider = "charBufferTypesProvider")
    public void testCharBuffers(BufferType.Chars charBufferType) {

        BiFunction<BufferType.Chars, Integer, CharBuffer> constructor = (at, s) -> {
            CharBuffer a = at.construct(s);
            for (int x = 0; x < s; x++) {
                at.set(a, x, x % 8);
            }
            return a;
        };

        BiFunction<BufferType.Chars, Integer, CharBuffer> constructorX = constructor.
                andThen(charBufferType::transformToStringBuffer);

        testBufferType(charBufferType, constructor, constructorX);
    }

    <B extends Buffer, E, BT extends BufferType<B, E>>
    void testBufferType(BT bt,
                        BiFunction<BT, Integer, B> aConstructor,
                        BiFunction<BT, Integer, B> bConstructor) {
        int n = arraySizeFor(bt.elementType);

        for (boolean dupOtherwiseSlice : new boolean[]{ false, true }) {
            for (int s : ranges(0, n)) {
                B a = aConstructor.apply(bt, s);
                B b = bConstructor.apply(bt, s);

                for (int aFrom : ranges(0, s)) {
                    for (int aTo : ranges(aFrom, s)) {
                        int aLength = aTo - aFrom;

                        B as = aLength != s
                               ? bt.slice(a, aFrom, aTo, dupOtherwiseSlice)
                               : a;

                        for (int bFrom : ranges(0, s)) {
                            for (int bTo : ranges(bFrom, s)) {
                                int bLength = bTo - bFrom;

                                B bs = bLength != s
                                       ? bt.slice(b, bFrom, bTo, dupOtherwiseSlice)
                                       : b;

                                boolean eq = bt.pairWiseEquals(as, bs);
                                Assert.assertEquals(bt.equals(as, bs), eq);
                                Assert.assertEquals(bt.equals(bs, as), eq);
                                if (eq) {
                                    Assert.assertEquals(bt.compare(as, bs), 0);
                                    Assert.assertEquals(bt.compare(bs, as), 0);

                                    // If buffers are equal, there shall be no mismatch
                                    Assert.assertEquals(bt.mismatch(as, bs), -1);
                                    Assert.assertEquals(bt.mismatch(bs, as), -1);
                                }
                                else {
                                    int aCb = bt.compare(as, bs);
                                    int bCa = bt.compare(bs, as);
                                    int v = Integer.signum(aCb) * Integer.signum(bCa);
                                    Assert.assertTrue(v == -1);

                                    int aMs = bt.mismatch(as, bs);
                                    int bMs = bt.mismatch(bs, as);
                                    Assert.assertNotEquals(aMs, -1);
                                    Assert.assertEquals(aMs, bMs);
                                }
                            }
                        }

                        if (aLength > 0 && !a.isReadOnly()) {
                            for (int i = aFrom; i < aTo; i++) {
                                B c = aConstructor.apply(bt, a.capacity());
                                B cs = aLength != s
                                       ? bt.slice(c, aFrom, aTo, dupOtherwiseSlice)
                                       : c;

                                // Create common prefix with a length of i - aFrom
                                bt.set(c, i, -1);

                                Assert.assertFalse(bt.equals(c, a));

                                int cCa = bt.compare(cs, as);
                                int aCc = bt.compare(as, cs);
                                int v = Integer.signum(cCa) * Integer.signum(aCc);
                                Assert.assertTrue(v == -1);

                                int cMa = bt.mismatch(cs, as);
                                int aMc = bt.mismatch(as, cs);
                                Assert.assertEquals(cMa, aMc);
                                Assert.assertEquals(cMa, i - aFrom);
                            }
                        }
                    }
                }
            }
        }
    }

    static int[] ranges(int from, int to) {
        int width = to - from;
        switch (width) {
            case 0:
                return new int[]{};
            case 1:
                return new int[]{from, to};
            case 2:
                return new int[]{from, from + 1, to};
            case 3:
                return new int[]{from, from + 1, from + 2, to};
            default:
                return IntStream.of(from, from + 1, from + 2, to / 2 - 1, to / 2, to / 2 + 1, to - 2, to - 1, to)
                        .filter(i -> i >= from && i <= to)
                        .distinct().toArray();
        }
    }
}

quality91%

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