/*

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

 * @summary Tests the limits imposed on the domain name part of an

 *          ObjectName instance

 * @author Jaroslav Bachorik

 * @modules java.management

 * @run main CompressedStorageTest

 */

import java.lang.reflect.Field;

import java.lang.reflect.InvocationTargetException;

import java.lang.reflect.Method;

import java.util.function.Consumer;

import javax.management.MalformedObjectNameException;

import javax.management.ObjectName;

public class CompressedStorageTest {

    private static Method setDomainLengthM;

    private static Field compressedStorageFld;

    private static int DOMAIN_PATTERN;

    private static int PROPLIST_PATTERN;

    private static int PROPVAL_PATTERN;

    private static Method setDomainPattern;

    private static Method setPropertyListPattern;

    private static Method setPropertyValuePattern;

    static {

        try {

            Class<?> clz = ObjectName.class;

            setDomainLengthM = clz.getDeclaredMethod("setDomainLength", int.class);

            setDomainLengthM.setAccessible(true);

            compressedStorageFld = clz.getDeclaredField("_compressed_storage");

            compressedStorageFld.setAccessible(true);

            setDomainPattern = clz.getDeclaredMethod("setDomainPattern", boolean.class);

            setDomainPattern.setAccessible(true);

            setPropertyListPattern = clz.getDeclaredMethod("setPropertyListPattern", boolean.class);

            setPropertyListPattern.setAccessible(true);

            setPropertyValuePattern = clz.getDeclaredMethod("setPropertyValuePattern", boolean.class);

            setPropertyValuePattern.setAccessible(true);

            DOMAIN_PATTERN = getStaticIntFld("DOMAIN_PATTERN");

            PROPLIST_PATTERN = getStaticIntFld("PROPLIST_PATTERN");

            PROPVAL_PATTERN = getStaticIntFld("PROPVAL_PATTERN");

        } catch (Exception e) {

            throw new Error(e);

        }

    }

    public static void main(String[] args) throws Exception {

        testZeroLength();

        testNegativeLength();

        testMaxLength();

        testSetDomainPattern();

        testSetPropertyListPattern();

        testSetPropertyValuePattern();

    }

    private static ObjectName getObjectName()

    throws MalformedObjectNameException {

        return new ObjectName("domain", "key", "value");

    }

    /**

     * Test for accepting 0 being passed as argument to

     * {@linkplain ObjectName#setDomainLength(int)}.

     *

     */

    private static void testZeroLength() throws Exception {

        setDomainNameLength(0);

    }

    /**

     * Test for rejecting negative value being passed as argument to

     * {@linkplain ObjectName#setDomainLength(int)}.

     */

    private static void testNegativeLength() throws Exception {

        try {

            setDomainNameLength(-1);

        } catch (MalformedObjectNameException e) {

            return;

        }

        fail("Allowing negative domain name length");

    }

    /**

     * Test for rejecting value exceeding the maximum allowed length

     * being passed as argument to {@linkplain ObjectName#setDomainLength(int)}.

     */

    private static void testMaxLength() throws Exception {

        try {

            setDomainNameLength(Integer.MAX_VALUE / 4 + 1);

        } catch (MalformedObjectNameException e) {

            return;

        }

        fail("Maximum domain name length is not respected");

    }

    /**

     * Tests that calling {@linkplain ObjectName#setDomainPattern(boolean)}

     * results in setting correct bits in {@linkplain ObjectName#_compressed_storage}.

     */

    private static void testSetDomainPattern() throws Exception {

        ObjectName on = getObjectName();

        checkMask(DOMAIN_PATTERN, setDomainPattern, on);

    }

    /**

     * Tests that calling {@linkplain ObjectName#setPropertyListPattern(boolean)}

     * results in setting correct bits in {@linkplain ObjectName#_compressed_storage}.

     */

    private static void testSetPropertyListPattern() throws Exception {

        ObjectName on = getObjectName();

        checkMask(PROPLIST_PATTERN, setPropertyListPattern, on);

    }

    /**

     * Tests that calling {@linkplain ObjectName#setPropertyValuePattern(boolean)}

     * results in setting correct bits in {@linkplain ObjectName#_compressed_storage}.

     */

    private static void testSetPropertyValuePattern() throws Exception {

        ObjectName on = getObjectName();

        checkMask(PROPVAL_PATTERN, setPropertyValuePattern, on);

    }

    /**

     * Helper method to call {@linkplain ObjectName#setDomainLength(int)}

     * method via reflection.

     * @param len The domain name length

     * @throws MalformedObjectNameException Propagated from

     *           {@linkplain ObjectName#setDomainLength(int)} invocation.

     */

    private static void setDomainNameLength(int len)

    throws MalformedObjectNameException {

        try {

            setDomainLengthM.invoke(getObjectName(), len);

        } catch (InvocationTargetException e) {

            Throwable cause = e.getCause();

            if (cause instanceof MalformedObjectNameException) {

                throw (MalformedObjectNameException)cause;

            }

            throw new Error(cause);

        } catch (IllegalAccessException | IllegalArgumentException e) {

            throw new Error(e);

        }

    }

    /**

     * Helper method to assert that a particular boolean setter affects only

     * a particular bit in the {@linkplain ObjectName#_compressed_storage} field.

     * @param mask bitmask for storing the boolean value

     * @param setter setter method reference

     * @param on {@linkplain ObjectName} instance

     */

    private static void checkMask(int mask, Method setter, ObjectName on)

    throws Exception {

        int valBefore = compressedStorageFld.getInt(on);

        setter.invoke(on, true);

        int valAfter = compressedStorageFld.getInt(on);

        checkMask(mask, valAfter ^ valBefore);

        valBefore = valAfter;

        setter.invoke(on, false);

        valAfter = compressedStorageFld.getInt(on);

        checkMask(mask, valAfter ^ valBefore);

    }

    /**

     * Compare the changed bits with the given mask.

     * @param mask bitmask

     * @param val the changed bits; may be 0 if there was no change

     */

    private static void checkMask(int mask, int val) {

        if (val != 0 && val != mask) {

            fail("Invalid mask: expecting '" +

                    Integer.toBinaryString(mask) + "' , received '" +

                    Integer.toBinaryString(val) + "'");

        }

    }

    /**

     * Helper method to obtain the value of a static field via reflection.

     * @param name static field name

     * @return static field value

     */

    private static int getStaticIntFld(String name) throws Exception {

        Field fld = ObjectName.class.getDeclaredField(name);

        fld.setAccessible(true);

        return fld.getInt(null);

    }

    private static void fail(String msg) {

        throw new Error(msg);

    }

}