/*

 * Copyright (c) 2003, 2008, 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 Test that SnmpTimeTicks wraps around when it is passed a long

 *          value

 * @bug     4955105

 * @build   TimeTicksWrapping

 * @run     main TimeTicksWrapping

 */

import java.lang.reflect.Constructor;

import java.lang.reflect.InvocationTargetException;

import java.lang.reflect.Method;

public class TimeTicksWrapping {

    // We use an SnmpTimeticksBuilder in order to adapt this test case to a

    // configuration where the SNMP packages are not present in rt.jar.

    //

    public static final class SnmpTimeticksBuilder {

        public static final long   MAX_VALUE = 0x0ffffffffL;

        public static final String SNMP_TIME_TICKS_CLASS_NAME =

            "com.sun.jmx.snmp.SnmpTimeticks";

        private static final Class<?> SNMP_TIME_TICKS_CLASS;

        private static final Constructor<?> SNMP_long_CTOR;

        private static final Constructor<?> SNMP_LONG_CTOR;

        private static final Method SNMP_LONG_VALUE;

        static {

            Class<?> snmpTimeTicksClass;

            try {

                snmpTimeTicksClass =

                    Class.forName(SNMP_TIME_TICKS_CLASS_NAME, true, null);

            } catch (ClassNotFoundException x) {

                snmpTimeTicksClass = null;

                System.err.println("WARNING: can't load "+

                        SNMP_TIME_TICKS_CLASS_NAME);

            } catch (NoClassDefFoundError x) {

                snmpTimeTicksClass = null;

                System.err.println("WARNING: can't load "+

                        SNMP_TIME_TICKS_CLASS_NAME);

            }

            SNMP_TIME_TICKS_CLASS = snmpTimeTicksClass;

            if (SNMP_TIME_TICKS_CLASS != null) {

                try {

                  SNMP_long_CTOR =

                          SNMP_TIME_TICKS_CLASS.getConstructor(long.class);

                } catch (Exception x) {

                    throw new ExceptionInInitializerError(x);

                }

            } else {

                SNMP_long_CTOR = null;

            }

            if (SNMP_TIME_TICKS_CLASS != null) {

                try {

                  SNMP_LONG_CTOR =

                          SNMP_TIME_TICKS_CLASS.getConstructor(Long.class);

                } catch (Exception x) {

                    throw new ExceptionInInitializerError(x);

                }

            } else {

                SNMP_LONG_CTOR = null;

            }

            if (SNMP_TIME_TICKS_CLASS != null) {

                try {

                  SNMP_LONG_VALUE =

                          SNMP_TIME_TICKS_CLASS.getMethod("longValue");

                } catch (Exception x) {

                    throw new ExceptionInInitializerError(x);

                }

            } else {

                SNMP_LONG_VALUE = null;

            }

        }

        private final Object timeticks;

        public SnmpTimeticksBuilder(long ticks) throws Exception {

            timeticks = newSnmpTimeticks(ticks);

        }

        public SnmpTimeticksBuilder(Long ticks) throws Exception {

            timeticks = newSnmpTimeticks(ticks);

        }

        public long longValue() throws Exception {

            return longValue(timeticks);

        }

        public static boolean isSnmpPresent() {

            System.out.println(TimeTicksWrapping.class.getName()+

                    ": Testing for SNMP Packages...");

            return SNMP_TIME_TICKS_CLASS != null;

        }

        private static Object newSnmpTimeticks(long time)

                throws Exception {

            try {

                return SNMP_long_CTOR.newInstance(time);

            } catch (InvocationTargetException x) {

                final Throwable cause = x.getCause();

                if (cause instanceof Exception) throw (Exception) cause;

                if (cause instanceof Error) throw (Error) cause;

                throw x;

            }

        }

        private static Object newSnmpTimeticks(Long time)

            throws Exception {

            try {

                return SNMP_LONG_CTOR.newInstance(time);

            } catch (InvocationTargetException x) {

                final Throwable cause = x.getCause();

                if (cause instanceof Exception) throw (Exception) cause;

                if (cause instanceof Error) throw (Error) cause;

                throw x;

            }

        }

        private static long longValue(Object o)

                throws Exception {

            try {

                return ((Long)SNMP_LONG_VALUE.invoke(o)).longValue();

            } catch (InvocationTargetException x) {

                final Throwable cause = x.getCause();

                if (cause instanceof Exception) throw (Exception) cause;

                if (cause instanceof Error) throw (Error) cause;

                throw x;

            }

        }

    }

    public static final long[] oks = {

        0L, 1L, (long)Integer.MAX_VALUE, (long)Integer.MAX_VALUE*2,

        (long)Integer.MAX_VALUE*2+1L, (long)Integer.MAX_VALUE*2+2L,

        (long)Integer.MAX_VALUE*3,

        SnmpTimeticksBuilder.MAX_VALUE, SnmpTimeticksBuilder.MAX_VALUE+1L,

        SnmpTimeticksBuilder.MAX_VALUE*3-1L, Long.MAX_VALUE

    };

    public static final long[] kos = {

        -1L, (long)Integer.MIN_VALUE, (long)Integer.MIN_VALUE*2,

        (long)Integer.MIN_VALUE*2-1L, (long)Integer.MIN_VALUE*3,

        -SnmpTimeticksBuilder.MAX_VALUE, -(SnmpTimeticksBuilder.MAX_VALUE+1L),

        -(SnmpTimeticksBuilder.MAX_VALUE*3-1L), Long.MIN_VALUE

    };

    public static void main(String args[]) {

        if (!SnmpTimeticksBuilder.isSnmpPresent()) {

            System.err.println("WARNING: "+

                    SnmpTimeticksBuilder.SNMP_TIME_TICKS_CLASS_NAME+

                    " not present.");

            System.err.println(TimeTicksWrapping.class.getName()+

                    ": test skipped.");

            return;

        }

        try {

            SnmpTimeticksBuilder t = null;

            for (int i=0;i<oks.length;i++) {

                final long t1,t2,t3;

                t1 = (new SnmpTimeticksBuilder(oks[i])).longValue();

                t2 = (new SnmpTimeticksBuilder(new Long(oks[i]))).longValue();

                t3 = oks[i]%0x0100000000L;

                if (t1 != t3)

                    throw new Exception("Value should have wrapped: " +

                                        oks[i] + " expected: " + t3);

                if (t2 != t3)

                    throw new Exception("Value should have wrapped: " +

                                        "Long("+oks[i]+") expected: " + t3);

                if (t1 > SnmpTimeticksBuilder.MAX_VALUE)

                    throw new Exception("Value should have wrapped " +

                                        "for " + oks[i] + ": " +

                                        t1 + " exceeds max: " +

                                        SnmpTimeticksBuilder.MAX_VALUE);

                if (t2 > SnmpTimeticksBuilder.MAX_VALUE)

                    throw new Exception("Value should have wrapped " +

                                        "for " + oks[i] + ": " +

                                        t2 + " exceeds max: " +

                                        SnmpTimeticksBuilder.MAX_VALUE);

                if (t1 < 0)

                    throw new Exception("Value should have wrapped: " +

                                        "for " + oks[i] + ": " +

                                        t1 + " is negative");

                if (t2 < 0)

                    throw new Exception("Value should have wrapped: " +

                                        "for " + oks[i] + ": " +

                                        t2 + " is negative");

                System.out.println("TimeTicks[" + oks[i] +

                                   "] rightfully accepted: " + t3);

            }

            for (int i=0;i<kos.length;i++) {

                try {

                    t = new SnmpTimeticksBuilder(kos[i]);

                    throw new Exception("Value should have been rejected: " +

                                        kos[i]);

                } catch (IllegalArgumentException x) {

                    // OK!

                }

                try {

                    t = new SnmpTimeticksBuilder(new Long(kos[i]));

                    throw new Exception("Value should have been rejected: " +

                                        "Long("+kos[i]+")");

                } catch (IllegalArgumentException x) {

                    // OK!

                }

                System.out.println("TimeTicks[" + kos[i] +

                                   "] rightfully rejected.");

            }

        } catch(Exception x) {

            x.printStackTrace();

            System.exit(1);

        }

    }

}