appserver/tests/appserv-tests/devtests/ejb/util/methodmap/client/MethodMapTest.java

/*
 * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
 *
 * This program and the accompanying materials are made available under the
 * terms of the Eclipse Public License v. 2.0, which is available at
 * http://www.eclipse.org/legal/epl-2.0.
 *
 * This Source Code may also be made available under the following Secondary
 * Licenses when the conditions for such availability set forth in the
 * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
 * version 2 with the GNU Classpath Exception, which is available at
 * https://www.gnu.org/software/classpath/license.html.
 *
 * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
 */

package com.sun.s1asdev.ejb.util.methodmap.client;

import com.sun.ejte.ccl.reporter.SimpleReporterAdapter;

import com.sun.ejb.containers.util.MethodMap;
import java.util.Map;
import java.util.HashMap;
import java.lang.reflect.Method;
import java.util.Set;
import java.util.Iterator;

public class MethodMapTest {

    private static SimpleReporterAdapter stat =
        new SimpleReporterAdapter("appserv-tests");

    private static final Class[] TEST_CLASSES = {
        java.lang.Object.class,
        MethodMapTest1.class, MethodMapTest2.class, MethodMapTest3.class,
        MethodMapTest4.class, MethodMapTest3.class, MethodMapTest6.class,
        MethodMapTest.class, jakarta.ejb.EJBHome.class,
        jakarta.ejb.EJBObject.class, jakarta.ejb.EJBLocalObject.class,
        jakarta.ejb.EJBLocalHome.class, jakarta.ejb.SessionBean.class,
        jakarta.ejb.EnterpriseBean.class, java.util.Map.class,
        jakarta.jms.QueueConnection.class, jakarta.jms.QueueSession.class,
        jakarta.jms.Session.class, java.util.Date.class,
        javax.swing.Action.class, javax.swing.AbstractAction.class,
        javax.swing.JComboBox.class, javax.swing.JTextArea.class

    };

    public static void main (String[] args) {

        stat.addDescription("ejb-util-methodmap");
        MethodMapTest test = new MethodMapTest(args);
        test.doTest();
        stat.printSummary("ejb-util-methodmapID");
    }

    public MethodMapTest (String[] args) {
    }

    public void doTest() {

        for(int i = 0; i < TEST_CLASSES.length; i++) {
            Class c = TEST_CLASSES[i];
            System.out.println("Doing methodmap test for " + c);
            boolean result = testClass(c);
            if( result ) {
                stat.addStatus("methodmapclient main", stat.PASS);
            } else {
                stat.addStatus("methodmapclient main", stat.FAIL);
            }
        }

        testCtor();
        testUnsupportedOperations();



    }

    private void testCtor() {

        // negative bucket value is illegal
        boolean ctorTest1Passed = false;
        try {
            new MethodMap(new HashMap(), -1);
            System.out.println("bucketSize -1 should have thrown exception");
        } catch(IllegalArgumentException e) {
            ctorTest1Passed = true;
        } catch(Exception e) {
            e.printStackTrace();
        }

        // bucket value 0 is illegal
        boolean ctorTest2Passed = false;
        try {
            new MethodMap(new HashMap(), 0);
            System.out.println("bucketSize 0 should have thrown exception");
        } catch(IllegalArgumentException e) {
            ctorTest2Passed = true;
        } catch(Exception e) {
            e.printStackTrace();
        }

        // make sure empty hashmap doesn't cause problems
        boolean ctorTest3Passed = false;
        try {
            new MethodMap(new HashMap());
            ctorTest3Passed = true;
        } catch(Exception e) {
            e.printStackTrace();
        }

        // pass map containing something other than Method objects
        Map otherMap = new HashMap();
        otherMap.put("foo", "bar");
        boolean ctorTest4Passed = false;
        try {
            new MethodMap(otherMap);
        } catch(Exception e) {
            ctorTest4Passed = true;
        }

        if( ctorTest1Passed && ctorTest2Passed & ctorTest3Passed
            && ctorTest4Passed ) {
            stat.addStatus("methodmapclient ctor", stat.PASS);
        } else {
            stat.addStatus("methodmapclient ctor", stat.FAIL);
        }

    }

    private void testUnsupportedOperations() {
        Map map = new HashMap();

        Method[] methods = this.getClass().getDeclaredMethods();
        Method method1 = methods[0];
        Method method2 = methods[1];

        map.put(method1, method1.toString());
        Map methodMap = new MethodMap(map);

        boolean uoeTest1Passed = false;
        try {
            methodMap.put(method1, method1.toString());
            System.out.println("put should have failed");
        } catch(UnsupportedOperationException uoe) {
            uoeTest1Passed = true;
        } catch(Exception e) {
            e.printStackTrace();
        }

        boolean uoeTest2Passed = false;
        try {
            methodMap.putAll(map);
            System.out.println("putAll should have failed");
        } catch(UnsupportedOperationException uoe) {
            uoeTest2Passed = true;
        } catch(Exception e) {
            e.printStackTrace();
        }

        boolean uoeTest3Passed = false;
        try {
            methodMap.remove(method1);
            System.out.println("remove should have failed");
        } catch(UnsupportedOperationException uoe) {
            uoeTest3Passed = true;
        } catch(Exception e) {
            e.printStackTrace();
        }

        boolean uoeTest4Passed = false;
        try {
            map.put(null, "foo");
            Map illegalMethodMap = new MethodMap(map);
            System.out.println("MethodMap ctor should have failed b/c of " +
                               " null method value");
        } catch(Exception e) {
            uoeTest4Passed = true;
        }

        if( uoeTest1Passed && uoeTest2Passed && uoeTest3Passed &&
            uoeTest4Passed ) {
            stat.addStatus("methodmapclient unsupportedop", stat.PASS);
        } else {
            stat.addStatus("methodmapclient unsupportedop", stat.FAIL);
        }

    }

    private boolean testClass(Class c) {

        Map regularMap = new HashMap();

        Method[] methods = c.getDeclaredMethods();

        for(int i = 0; i < methods.length; i++) {
            regularMap.put(methods[i], methods[i].toString());
        }

        Map defaultMethodMap = new MethodMap(regularMap);
        System.out.println("Testing " + c + " with default MethodMap");
        boolean defaultTest =
            testClass(c, methods, false, regularMap, defaultMethodMap);
        boolean defaultTestOpt =
            testClass(c, methods, true, regularMap, defaultMethodMap);

        // test degenerate case where there is only 1 bucket in MethodMap.
        // unless there are less than 2 methods in the map, this should
        // always defer to parent.
        Map oneBucketMethodMap = new MethodMap(regularMap, 1);
        System.out.println("Testing " + c + " with 1-bucket MethodMap");
        boolean oneBucketTest =
            testClass(c, methods, false, regularMap, oneBucketMethodMap);
        boolean oneBucketTestOpt =
            testClass(c, methods, true, regularMap, oneBucketMethodMap);

        Map seventeenBucketMethodMap = new MethodMap(regularMap, 17);
        System.out.println("Testing " + c + " with 17-bucket MethodMap");
        boolean seventeenBucketTest =
            testClass(c, methods, false, regularMap, seventeenBucketMethodMap);
        boolean seventeenBucketTestOpt =
            testClass(c, methods, true, regularMap, seventeenBucketMethodMap);


        boolean clearTest = false;
        try {
            seventeenBucketMethodMap.clear();
            if( methods.length > 0 ) {
                Object obj = seventeenBucketMethodMap.get(methods[0]);
                if( obj == null ) {
                    // make sure another clear op doesn't cause exception.
                    seventeenBucketMethodMap.clear();
                    clearTest = true;
                } else {
                    System.out.println("Clear() should have returned null for " +
                                       methods[0]
                                       + " after clear().  instead it " +
                                       " returned " + obj);
                }
            } else {
                clearTest = true;
            }
        } catch(Exception e) {
            clearTest = false;
            System.out.println("clear() threw an exception");
            e.printStackTrace();
        }

        return (defaultTest && defaultTestOpt &&
                oneBucketTest && oneBucketTestOpt &&
                seventeenBucketTest && seventeenBucketTestOpt &&
                clearTest);
    }

    private boolean testClass(Class c, Method[] methods, boolean useParamOpt,
                              Map regularMap, Map methodMap) {

        for(int i = 0; i < methods.length; i++) {
            Method next = methods[i];
            int numParams = next.getParameterTypes().length;
            Object regularLookup = regularMap.get(next);

            Object methodMapLookup = null;
            if( useParamOpt ) {
                MethodMap mm = (MethodMap) methodMap;
                methodMapLookup = mm.get(next, numParams);
            } else {
                methodMapLookup = methodMap.get(next);
            }

            if( regularLookup != methodMapLookup ) {
                System.out.println("Error.  regularLookup = " + regularLookup
                                   + " methodMapLookup = " + methodMapLookup
                                   + " for Method " + next.toString());
                return false;
            }

            //            System.out.println("Got " + regularLookup + " for method " +
            //                 next.toString());

        }

        return true;

    }


    private interface MethodMapTest1 {}

    private interface MethodMapTest2 {
        // overloadeds methods
        void foo();
        void foo(int i);

        // short method names
        void a();

        // long method names
        void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();

        void ab();

        // method that throws exception
        void _ab() throws java.rmi.RemoteException;

        // array params
        int abc(int[] a);
        int def(int[][][][][][][][] b);

        // arbitrary unicode chars
        void _B\u8001$();
        void _CCMcx\u04e3\u05E90123();


    }

    private interface MethodMapTest3 {

        void A();

    }

    private interface MethodMapTest4 extends MethodMapTest3 {}

    private interface MethodMapTest5 extends MethodMapTest3 {
        void A();
        void B();
        void B(String c);
    }

    private interface MethodMapTest6 extends MethodMapTest5 {
        void B(String c);
    }

}