/*

 * Copyright (c) 2015, 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.

 */

/*

 * @test

 * @bug 8154556

 * @run testng/othervm -Diters=20000 -XX:TieredStopAtLevel=1 VarHandleTestByteArrayAsDouble

 * @run testng/othervm -Diters=20000                         VarHandleTestByteArrayAsDouble

 * @run testng/othervm -Diters=20000 -XX:-TieredCompilation  VarHandleTestByteArrayAsDouble

 */

import org.testng.annotations.DataProvider;

import org.testng.annotations.Test;

import java.lang.invoke.MethodHandles;

import java.lang.invoke.VarHandle;

import java.nio.ByteBuffer;

import java.nio.ByteOrder;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.EnumSet;

import java.util.List;

import static org.testng.Assert.*;

public class VarHandleTestByteArrayAsDouble extends VarHandleBaseByteArrayTest {

    static final int SIZE = Double.BYTES;

    static final double VALUE_1 = 0x0102030405060708L;

    static final double VALUE_2 = 0x1112131415161718L;

    static final double VALUE_3 = 0xFFFEFDFCFBFAF9F8L;

    @Override

        // Combinations of VarHandle byte[] or ByteBuffer

            ByteOrder bo = endianess == MemoryMode.BIG_ENDIAN

                    ? ByteOrder.BIG_ENDIAN : ByteOrder.LITTLE_ENDIAN;

            VarHandleSource aeh = new VarHandleSource(

                    endianess, MemoryMode.READ_WRITE);

            vhss.add(aeh);

            VarHandleSource bbh = new VarHandleSource(

                    endianess, MemoryMode.READ_WRITE);

            vhss.add(bbh);

        }

    }

    @Test(dataProvider = "varHandlesProvider")

    public void testIsAccessModeSupported(VarHandleSource vhs) {

        VarHandle vh = vhs.s;

        assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET));

        assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.SET));

        assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_VOLATILE));

        assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.SET_VOLATILE));

        assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_ACQUIRE));

        assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.SET_RELEASE));

        assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_OPAQUE));

        assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.SET_OPAQUE));

        assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.COMPARE_AND_SET));

        assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.COMPARE_AND_EXCHANGE));

        assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.COMPARE_AND_EXCHANGE_ACQUIRE));

        assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.COMPARE_AND_EXCHANGE_RELEASE));

        assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_PLAIN));

        assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET));

        assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_ACQUIRE));

        assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_RELEASE));

        assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_SET));

        assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_SET_ACQUIRE));

        assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_SET_RELEASE));

        assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_ADD));

        assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_ADD_ACQUIRE));

        assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_ADD_RELEASE));

        assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_OR));

        assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_OR_ACQUIRE));

        assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_OR_RELEASE));

        assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_AND));

        assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_AND_ACQUIRE));

        assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_AND_RELEASE));

        assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_XOR));

        assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_XOR_ACQUIRE));

        assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_XOR_RELEASE));

    }

    @Test(dataProvider = "typesProvider")

    public void testTypes(VarHandle vh, List<java.lang.Class<?>> pts) {

        assertEquals(vh.varType(), double.class);

        assertEquals(vh.coordinateTypes(), pts);

        testTypes(vh);

    }

    @DataProvider

    public Object[][] accessTestCaseProvider() throws Exception {

        List<AccessTestCase<?>> cases = new ArrayList<>();

        for (ByteArrayViewSource<?> bav : bavss) {

            for (VarHandleSource vh : vhss) {

                if (vh.matches(bav)) {

                    if (bav instanceof ByteArraySource) {

                        ByteArraySource bas = (ByteArraySource) bav;

                        cases.add(new VarHandleSourceAccessTestCase(

                                "read write", bav, vh, h -> testArrayReadWrite(bas, h),

                                true));

                        cases.add(new VarHandleSourceAccessTestCase(

                                "null array", bav, vh, h -> testArrayNPE(bas, h),

                                false));

                        cases.add(new VarHandleSourceAccessTestCase(

                                "unsupported", bav, vh, h -> testArrayUnsupported(bas, h),

                                false));

                        cases.add(new VarHandleSourceAccessTestCase(

                                "index out of bounds", bav, vh, h -> testArrayIndexOutOfBounds(bas, h),

                                false));

                        cases.add(new VarHandleSourceAccessTestCase(

                                "misaligned access", bav, vh, h -> testArrayMisalignedAccess(bas, h),

                                false));

                    }

                    else {

                        ByteBufferSource bbs = (ByteBufferSource) bav;

                        if (MemoryMode.READ_WRITE.isSet(bav.memoryModes)) {

                            cases.add(new VarHandleSourceAccessTestCase(

                                    "read write", bav, vh, h -> testArrayReadWrite(bbs, h),

                                    true));

                        }

                        else {

                            cases.add(new VarHandleSourceAccessTestCase(

                                    "read only", bav, vh, h -> testArrayReadOnly(bbs, h),

                                    true));

                        }

                        cases.add(new VarHandleSourceAccessTestCase(

                                "null buffer", bav, vh, h -> testArrayNPE(bbs, h),

                                false));

                        cases.add(new VarHandleSourceAccessTestCase(

                                "unsupported", bav, vh, h -> testArrayUnsupported(bbs, h),

                                false));

                        cases.add(new VarHandleSourceAccessTestCase(

                                "index out of bounds", bav, vh, h -> testArrayIndexOutOfBounds(bbs, h),

                                false));

                        cases.add(new VarHandleSourceAccessTestCase(

                                "misaligned access", bav, vh, h -> testArrayMisalignedAccess(bbs, h),

                                false));

                    }

                }

            }

        }

        // Work around issue with jtreg summary reporting which truncates

        // the String result of Object.toString to 30 characters, hence

        // the first dummy argument

        return cases.stream().map(tc -> new Object[]{tc.toString(), tc}).toArray(Object[][]::new);

    }

    @Test(dataProvider = "accessTestCaseProvider")

    public <T> void testAccess(String desc, AccessTestCase<T> atc) throws Throwable {

        T t = atc.get();

        int iters = atc.requiresLoop() ? ITERS : 1;

        for (int c = 0; c < iters; c++) {

            atc.testAccess(t);

        }

    }

    static void testArrayNPE(ByteArraySource bs, VarHandleSource vhs) {

        VarHandle vh = vhs.s;

        byte[] array = null;

        int ci = 1;

        checkNPE(() -> {

            double x = (double) vh.get(array, ci);

        });

        checkNPE(() -> {

            vh.set(array, ci, VALUE_1);

        });

        checkNPE(() -> {

            double x = (double) vh.getVolatile(array, ci);

        });

        checkNPE(() -> {

            double x = (double) vh.getAcquire(array, ci);

        });

        checkNPE(() -> {

            double x = (double) vh.getOpaque(array, ci);

        });

        checkNPE(() -> {

            vh.setVolatile(array, ci, VALUE_1);

        });

        checkNPE(() -> {

            vh.setRelease(array, ci, VALUE_1);

        });

        checkNPE(() -> {

            vh.setOpaque(array, ci, VALUE_1);

        });

        checkNPE(() -> {

            boolean r = vh.compareAndSet(array, ci, VALUE_1, VALUE_2);

        });

        checkNPE(() -> {

            double r = (double) vh.compareAndExchange(array, ci, VALUE_2, VALUE_1);

        });

        checkNPE(() -> {

            double r = (double) vh.compareAndExchangeAcquire(array, ci, VALUE_2, VALUE_1);

        });

        checkNPE(() -> {

            double r = (double) vh.compareAndExchangeRelease(array, ci, VALUE_2, VALUE_1);

        });

        checkNPE(() -> {

            boolean r = vh.weakCompareAndSetPlain(array, ci, VALUE_1, VALUE_2);

        });

        checkNPE(() -> {

            boolean r = vh.weakCompareAndSet(array, ci, VALUE_1, VALUE_2);

        });

        checkNPE(() -> {

            boolean r = vh.weakCompareAndSetAcquire(array, ci, VALUE_1, VALUE_2);

        });

        checkNPE(() -> {

            boolean r = vh.weakCompareAndSetRelease(array, ci, VALUE_1, VALUE_2);

        });

        checkNPE(() -> {

            double o = (double) vh.getAndSet(array, ci, VALUE_1);

        });

        checkNPE(() -> {

            double o = (double) vh.getAndSetAcquire(array, ci, VALUE_1);

        });

        checkNPE(() -> {

            double o = (double) vh.getAndSetRelease(array, ci, VALUE_1);

        });

    }

    static void testArrayNPE(ByteBufferSource bs, VarHandleSource vhs) {

        VarHandle vh = vhs.s;

        ByteBuffer array = null;

        int ci = 1;

        checkNPE(() -> {

            double x = (double) vh.get(array, ci);

        });

        checkNPE(() -> {

            vh.set(array, ci, VALUE_1);

        });

        checkNPE(() -> {

            double x = (double) vh.getVolatile(array, ci);

        });

        checkNPE(() -> {

            double x = (double) vh.getAcquire(array, ci);

        });

        checkNPE(() -> {

            double x = (double) vh.getOpaque(array, ci);

        });

        checkNPE(() -> {

            vh.setVolatile(array, ci, VALUE_1);

        });

        checkNPE(() -> {

            vh.setRelease(array, ci, VALUE_1);

        });

        checkNPE(() -> {

            vh.setOpaque(array, ci, VALUE_1);

        });

        checkNPE(() -> {

            boolean r = vh.compareAndSet(array, ci, VALUE_1, VALUE_2);

        });

        checkNPE(() -> {

            double r = (double) vh.compareAndExchange(array, ci, VALUE_2, VALUE_1);

        });

        checkNPE(() -> {

            double r = (double) vh.compareAndExchangeAcquire(array, ci, VALUE_2, VALUE_1);

        });

        checkNPE(() -> {

            double r = (double) vh.compareAndExchangeRelease(array, ci, VALUE_2, VALUE_1);

        });

        checkNPE(() -> {

            boolean r = vh.weakCompareAndSetPlain(array, ci, VALUE_1, VALUE_2);

        });

        checkNPE(() -> {

            boolean r = vh.weakCompareAndSet(array, ci, VALUE_1, VALUE_2);

        });

        checkNPE(() -> {

            boolean r = vh.weakCompareAndSetAcquire(array, ci, VALUE_1, VALUE_2);

        });

        checkNPE(() -> {

            boolean r = vh.weakCompareAndSetRelease(array, ci, VALUE_1, VALUE_2);

        });

        checkNPE(() -> {

            double o = (double) vh.getAndSet(array, ci, VALUE_1);

        });

        checkNPE(() -> {

            double o = (double) vh.getAndSetAcquire(array, ci, VALUE_1);

        });

        checkNPE(() -> {

            double o = (double) vh.getAndSetRelease(array, ci, VALUE_1);

        });

    }

    static void testArrayUnsupported(ByteArraySource bs, VarHandleSource vhs) {

        VarHandle vh = vhs.s;

        byte[] array = bs.s;

        int ci = 1;

        checkUOE(() -> {

            double o = (double) vh.getAndAdd(array, ci, VALUE_1);

        });

        checkUOE(() -> {

            double o = (double) vh.getAndAddAcquire(array, ci, VALUE_1);

        });

        checkUOE(() -> {

            double o = (double) vh.getAndAddRelease(array, ci, VALUE_1);

        });

        checkUOE(() -> {

            double o = (double) vh.getAndBitwiseOr(array, ci, VALUE_1);

        });

        checkUOE(() -> {

            double o = (double) vh.getAndBitwiseOrAcquire(array, ci, VALUE_1);

        });

        checkUOE(() -> {

            double o = (double) vh.getAndBitwiseOrRelease(array, ci, VALUE_1);

        });

        checkUOE(() -> {

            double o = (double) vh.getAndBitwiseAnd(array, ci, VALUE_1);

        });

        checkUOE(() -> {

            double o = (double) vh.getAndBitwiseAndAcquire(array, ci, VALUE_1);

        });

        checkUOE(() -> {

            double o = (double) vh.getAndBitwiseAndRelease(array, ci, VALUE_1);

        });

        checkUOE(() -> {

            double o = (double) vh.getAndBitwiseXor(array, ci, VALUE_1);

        });

        checkUOE(() -> {

            double o = (double) vh.getAndBitwiseXorAcquire(array, ci, VALUE_1);

        });

        checkUOE(() -> {

            double o = (double) vh.getAndBitwiseXorRelease(array, ci, VALUE_1);

        });

    }

    static void testArrayUnsupported(ByteBufferSource bs, VarHandleSource vhs) {

        VarHandle vh = vhs.s;

        ByteBuffer array = bs.s;

        int ci = 0;

        boolean readOnly = MemoryMode.READ_ONLY.isSet(bs.memoryModes);

        if (readOnly) {

            checkROBE(() -> {

                vh.set(array, ci, VALUE_1);

            });

        }

        if (readOnly) {

            checkROBE(() -> {

                vh.setVolatile(array, ci, VALUE_1);

            });

            checkROBE(() -> {

                vh.setRelease(array, ci, VALUE_1);

            });

            checkROBE(() -> {

                vh.setOpaque(array, ci, VALUE_1);

            });

            checkROBE(() -> {

                boolean r = vh.compareAndSet(array, ci, VALUE_1, VALUE_2);

            });

            checkROBE(() -> {

                double r = (double) vh.compareAndExchange(array, ci, VALUE_2, VALUE_1);

            });

            checkROBE(() -> {

                double r = (double) vh.compareAndExchangeAcquire(array, ci, VALUE_2, VALUE_1);

            });

            checkROBE(() -> {

                double r = (double) vh.compareAndExchangeRelease(array, ci, VALUE_2, VALUE_1);

            });

            checkROBE(() -> {

                boolean r = vh.weakCompareAndSetPlain(array, ci, VALUE_1, VALUE_2);

            });

            checkROBE(() -> {