/*

 * Copyright (c) 2016, 2019, 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 Binary data and view tests for byte buffers

 * @bug 8159257

 * @run testng ByteBufferViews

 */

import org.testng.annotations.DataProvider;

import org.testng.annotations.Test;

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.List;

import java.util.Map;

import java.util.function.Function;

import java.util.function.IntFunction;

import java.util.function.IntUnaryOperator;

import java.util.function.UnaryOperator;

import java.util.stream.Collectors;

import static org.testng.Assert.*;

public class ByteBufferViews {

    static final int SIZE = 32;

    // List of buffer allocator functions

    static final List<Map.Entry<String, IntFunction<ByteBuffer>>> BYTE_BUFFER_ALLOCATE_FUNCTIONS = List.of(

            // Heap

            Map.entry("ByteBuffer.allocate(ba)",

                      size -> ByteBuffer.allocate(size)),

            // Aligned

            Map.entry("ByteBuffer.allocate(size).position(8)",

                      size -> ByteBuffer.allocate(size).position(8)),

            Map.entry("ByteBuffer.allocate(size).position(8).slice()",

                      size -> ByteBuffer.allocate(size).position(8).slice()),

            Map.entry("ByteBuffer.allocate(size).position(8).slice().duplicate()",

                      size -> ByteBuffer.allocate(size).position(8).slice().duplicate()),

            Map.entry("ByteBuffer.allocate(size).slice(8,size-8)",

                      size -> ByteBuffer.allocate(size).slice(8,size-8)),

            // Unaligned

            Map.entry("ByteBuffer.allocate(size).position(1)",

                      size -> ByteBuffer.allocate(size).position(1)),

            Map.entry("ByteBuffer.allocate(size).position(1).slice()",

                      size -> ByteBuffer.allocate(size).position(1).slice()),

            Map.entry("ByteBuffer.allocate(size).position(1).slice().duplicate()",

                      size -> ByteBuffer.allocate(size).position(1).slice().duplicate()),

            Map.entry("ByteBuffer.allocate(size).slice(1,size-1)",

                      size -> ByteBuffer.allocate(size).slice(1,size-1)),

            // Off-heap

            Map.entry("ByteBuffer.allocateDirect(size)",

                      size -> ByteBuffer.allocateDirect(size)),

            // Aligned

            Map.entry("ByteBuffer.allocateDirect(size).position(8)",

                      size -> ByteBuffer.allocateDirect(size).position(8)),

            Map.entry("ByteBuffer.allocateDirect(size).position(8).slice()",

                      size -> ByteBuffer.allocateDirect(size).position(8).slice()),

            Map.entry("ByteBuffer.allocateDirect(size).position(8).slice().duplicate()",

                      size -> ByteBuffer.allocateDirect(size).position(8).slice().duplicate()),

            Map.entry("ByteBuffer.allocateDirect(size).slice(8,size-8)",

                      size -> ByteBuffer.allocateDirect(size).slice(8,size-8)),

            // Unaligned

            Map.entry("ByteBuffer.allocateDirect(size).position(1)",

                      size -> ByteBuffer.allocateDirect(size).position(1)),

            Map.entry("ByteBuffer.allocateDirect(size).position(1).slice()",

                      size -> ByteBuffer.allocateDirect(size).position(1).slice()),

            Map.entry("ByteBuffer.allocateDirect(size).position(1).slice().duplicate()",

                      size -> ByteBuffer.allocateDirect(size).position(1).slice().duplicate()),

            Map.entry("ByteBuffer.allocateDirect(size).slice(1,size-1)",

                      size -> ByteBuffer.allocateDirect(size).slice(1,size-1))

    );

    // List of buffer byte order functions

    static final List<Map.Entry<String, UnaryOperator<ByteBuffer>>> BYTE_BUFFER_ORDER_FUNCTIONS = List.of(

            Map.entry("order(ByteOrder.BIG_ENDIAN)",

                      (ByteBuffer bb) -> bb.order(ByteOrder.BIG_ENDIAN)),

            Map.entry("order(ByteOrder.LITTLE_ENDIAN)",

                      (ByteBuffer bb) -> bb.order(ByteOrder.LITTLE_ENDIAN))

    );

    // Produce a composition of allocation and byte order buffer functions

    static List<Map.Entry<String, IntFunction<ByteBuffer>>> composeBufferFunctions(

            List<Map.Entry<String, IntFunction<ByteBuffer>>> af,

            List<Map.Entry<String, UnaryOperator<ByteBuffer>>> of) {

        return af.stream().flatMap(afe -> of.stream().

                map(ofe -> {

                    String s = afe.getKey() + "." + ofe.getKey();

                    IntFunction<ByteBuffer> f = size -> ofe.getValue().

                            apply(afe.getValue().apply(size));

                    return Map.entry(s, f);

                })

        ).collect(Collectors.toList());

    }

    // List of buffer allocator functions to test

    static final List<Map.Entry<String, IntFunction<ByteBuffer>>> BYTE_BUFFER_FUNCTIONS =

            composeBufferFunctions(BYTE_BUFFER_ALLOCATE_FUNCTIONS, BYTE_BUFFER_ORDER_FUNCTIONS);

    // Creates a cross product of test arguments for

    // buffer allocator functions and buffer view functions

    static Object[][] product(List<? extends Map.Entry<String, ?>> la,

                              List<? extends Map.Entry<String, ?>> lb) {

        return la.stream().flatMap(lae -> lb.stream().

                map(lbe -> List.of(

                        lae.getKey() + " -> " + lbe.getKey(),

                        lae.getValue(),

                        lbe.getValue()).toArray()

                )).toArray(Object[][]::new);

    }

    static void assertValues(int i, Object bValue, Object bbValue, ByteBuffer bb) {

        if (!bValue.equals(bbValue)) {

            fail(String.format("Values %s and %s differ at index %d for %s",

                               bValue, bbValue, i, bb));

        }

    }

    static void assertValues(int i, Object bbValue, Object bvValue, ByteBuffer bb, Buffer bv) {

        if (!bbValue.equals(bvValue)) {

            fail(String.format("Values %s and %s differ at index %d for %s and %s",

                               bbValue, bvValue, i, bb, bv));

        }

    }

    static ByteBuffer allocate(IntFunction<ByteBuffer> f) {

        return allocate(f, i -> i);

    }

    static ByteBuffer allocate(IntFunction<ByteBuffer> f, IntUnaryOperator o) {

        return fill(f.apply(SIZE), o);

    }

    static ByteBuffer fill(ByteBuffer bb, IntUnaryOperator o) {

        for (int i = 0; i < bb.limit(); i++) {

            bb.put(i, (byte) o.applyAsInt(i));

        }

        return bb;

    }

    @DataProvider

    public static Object[][] shortViewProvider() {

        List<Map.Entry<String, Function<ByteBuffer, ShortBuffer>>> bfs = List.of(

                Map.entry("bb.asShortBuffer()",

                          bb -> bb.asShortBuffer()),

                Map.entry("bb.asShortBuffer().slice()",

                          bb -> bb.asShortBuffer().slice()),

                Map.entry("bb.asShortBuffer().slice().duplicate()",

                          bb -> bb.asShortBuffer().slice().duplicate())

        );

        return product(BYTE_BUFFER_FUNCTIONS, bfs);

    }

    @Test(dataProvider = "shortViewProvider")

    public void testShortGet(String desc, IntFunction<ByteBuffer> fbb,

                             Function<ByteBuffer, ShortBuffer> fbi) {

        ByteBuffer bb = allocate(fbb);

        ShortBuffer vb = fbi.apply(bb);

        int o = bb.position();

        for (int i = 0; i < vb.limit(); i++) {

            short fromBytes = getShortFromBytes(bb, o + i * 2);

            short fromMethodView = bb.getShort(o + i * 2);

            assertValues(i, fromBytes, fromMethodView, bb);

            short fromBufferView = vb.get(i);

            assertValues(i, fromMethodView, fromBufferView, bb, vb);

        }

        for (int i = 0; i < vb.limit(); i++) {

            short v = getShortFromBytes(bb, o + i * 2);

            short a = bb.getShort();

            assertValues(i, v, a, bb);

            short b = vb.get();

            assertValues(i, a, b, bb, vb);

        }

    }

    @Test(dataProvider = "shortViewProvider")

    public void testShortPut(String desc, IntFunction<ByteBuffer> fbb,

                             Function<ByteBuffer, ShortBuffer> fbi) {

        ByteBuffer bbfilled = allocate(fbb);

        ByteBuffer bb = allocate(fbb, i -> 0);

        ShortBuffer vb = fbi.apply(bb);

        int o = bb.position();

        for (int i = 0; i < vb.limit(); i++) {

            short fromFilled = bbfilled.getShort(o + i * 2);

            vb.put(i, fromFilled);

            short fromMethodView = bb.getShort(o + i * 2);

            assertValues(i, fromFilled, fromMethodView, bb, vb);

        }

        for (int i = 0; i < vb.limit(); i++) {

            short fromFilled = bbfilled.getShort(o + i * 2);

            vb.put(fromFilled);

            short fromMethodView = bb.getShort();

            assertValues(i, fromFilled, fromMethodView, bb, vb);

        }

        fill(bb, i -> 0);

        bb.clear().position(o);

        vb.clear();

        for (int i = 0; i < vb.limit(); i++) {

            short fromFilled = bbfilled.getShort(o + i * 2);

            bb.putShort(o + i * 2, fromFilled);

            short fromBufferView = vb.get(i);

            assertValues(i, fromFilled, fromBufferView, bb, vb);

        }

        for (int i = 0; i < vb.limit(); i++) {

            short fromFilled = bbfilled.getShort(o + i * 2);

            bb.putShort(fromFilled);

            short fromBufferView = vb.get();

            assertValues(i, fromFilled, fromBufferView, bb, vb);

        }

    }

    static short getShortFromBytes(ByteBuffer bb, int i) {

        int a = bb.get(i) & 0xFF;

        int b = bb.get(i + 1) & 0xFF;

        if (bb.order() == ByteOrder.BIG_ENDIAN) {

            return (short) ((a << 8) | b);

        }

        else {

            return (short) ((b << 8) | a);

        }

    }

    @DataProvider

    public static Object[][] charViewProvider() {

        List<Map.Entry<String, Function<ByteBuffer, CharBuffer>>> bfs = List.of(

                Map.entry("bb.asCharBuffer()",

                          bb -> bb.asCharBuffer()),

                Map.entry("bb.asCharBuffer().slice()",

                          bb -> bb.asCharBuffer().slice()),

                Map.entry("bb.asCharBuffer().slice().duplicate()",

                          bb -> bb.asCharBuffer().slice().duplicate())

        );

        return product(BYTE_BUFFER_FUNCTIONS, bfs);

    }

    @Test(dataProvider = "charViewProvider")

    public void testCharGet(String desc, IntFunction<ByteBuffer> fbb,

                            Function<ByteBuffer, CharBuffer> fbi) {

        ByteBuffer bb = allocate(fbb);

        CharBuffer vb = fbi.apply(bb);

        int o = bb.position();

        for (int i = 0; i < vb.limit(); i++) {

            char fromBytes = getCharFromBytes(bb, o + i * 2);

            char fromMethodView = bb.getChar(o + i * 2);

            assertValues(i, fromBytes, fromMethodView, bb);

            char fromBufferView = vb.get(i);

            assertValues(i, fromMethodView, fromBufferView, bb, vb);

        }

        for (int i = 0; i < vb.limit(); i++) {

            char fromBytes = getCharFromBytes(bb, o + i * 2);

            char fromMethodView = bb.getChar();

            assertValues(i, fromBytes, fromMethodView, bb);

            char fromBufferView = vb.get();

            assertValues(i, fromMethodView, fromBufferView, bb, vb);

        }

    }

    @Test(dataProvider = "charViewProvider")

    public void testCharPut(String desc, IntFunction<ByteBuffer> fbb,

                            Function<ByteBuffer, CharBuffer> fbi) {

        ByteBuffer bbfilled = allocate(fbb);

        ByteBuffer bb = allocate(fbb, i -> 0);

        CharBuffer vb = fbi.apply(bb);

        int o = bb.position();

        for (int i = 0; i < vb.limit(); i++) {

            char fromFilled = bbfilled.getChar(o + i * 2);

            vb.put(i, fromFilled);

            char fromMethodView = bb.getChar(o + i * 2);

            assertValues(i, fromFilled, fromMethodView, bb, vb);

        }

        for (int i = 0; i < vb.limit(); i++) {

            char fromFilled = bbfilled.getChar(o + i * 2);

            vb.put(fromFilled);

            char fromMethodView = bb.getChar();

            assertValues(i, fromFilled, fromMethodView, bb, vb);

        }

        fill(bb, i -> 0);

        bb.clear().position(o);

        vb.clear();

        for (int i = 0; i < vb.limit(); i++) {

            char fromFilled = bbfilled.getChar(o + i * 2);

            bb.putChar(o + i * 2, fromFilled);

            char fromBufferView = vb.get(i);

            assertValues(i, fromFilled, fromBufferView, bb, vb);

        }

        for (int i = 0; i < vb.limit(); i++) {

            char fromFilled = bbfilled.getChar(o + i * 2);

            bb.putChar(fromFilled);

            char fromBufferView = vb.get();

            assertValues(i, fromFilled, fromBufferView, bb, vb);

        }

    }

    static char getCharFromBytes(ByteBuffer bb, int i) {

        return (char) getShortFromBytes(bb, i);

    }

    @DataProvider

    public static Object[][] intViewProvider() {

        List<Map.Entry<String, Function<ByteBuffer, IntBuffer>>> bfs = List.of(

                Map.entry("bb.asIntBuffer()",

                          bb -> bb.asIntBuffer()),

                Map.entry("bb.asIntBuffer().slice()",

                          bb -> bb.asIntBuffer().slice()),

                Map.entry("bb.asIntBuffer().slice().duplicate()",

                          bb -> bb.asIntBuffer().slice().duplicate())

        );

        return product(BYTE_BUFFER_FUNCTIONS, bfs);

    }

    @Test(dataProvider = "intViewProvider")

    public void testIntGet(String desc, IntFunction<ByteBuffer> fbb,

                           Function<ByteBuffer, IntBuffer> fbi) {

        ByteBuffer bb = allocate(fbb);

        IntBuffer vb = fbi.apply(bb);

        int o = bb.position();

        for (int i = 0; i < vb.limit(); i++) {

            int fromBytes = getIntFromBytes(bb, o + i * 4);

            int fromMethodView = bb.getInt(o + i * 4);

            assertValues(i, fromBytes, fromMethodView, bb);

            int fromBufferView = vb.get(i);

            assertValues(i, fromMethodView, fromBufferView, bb, vb);

        }

        for (int i = 0; i < vb.limit(); i++) {

            int v = getIntFromBytes(bb, o + i * 4);

            int a = bb.getInt();

            assertValues(i, v, a, bb);

            int b = vb.get();

            assertValues(i, a, b, bb, vb);

        }

    }

    @Test(dataProvider = "intViewProvider")

    public void testIntPut(String desc, IntFunction<ByteBuffer> fbb,

                           Function<ByteBuffer, IntBuffer> fbi) {

        ByteBuffer bbfilled = allocate(fbb);

        ByteBuffer bb = allocate(fbb, i -> 0);

        IntBuffer vb = fbi.apply(bb);

        int o = bb.position();

        for (int i = 0; i < vb.limit(); i++) {

            int fromFilled = bbfilled.getInt(o + i * 4);

            vb.put(i, fromFilled);

            int fromMethodView = bb.getInt(o + i * 4);

            assertValues(i, fromFilled, fromMethodView, bb, vb);

        }