boot/src/test/java/org/netbeans/html/boot/impl/JsClassLoaderBase.java
author Jaroslav Tulach <jaroslav.tulach@apidesign.org>
Mon, 16 Dec 2013 16:59:43 +0100
branchnetbeans
changeset 362 92fb71afdc0e
parent 358 boot/src/test/java/org/apidesign/html/boot/impl/JsClassLoaderBase.java@80702021b851
child 365 5c93ad8c7a15
permissions -rw-r--r--
Moving implementation classes into org.netbeans.html namespace
     1 /**
     2  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
     3  *
     4  * Copyright 1997-2010 Oracle and/or its affiliates. All rights reserved.
     5  *
     6  * Oracle and Java are registered trademarks of Oracle and/or its affiliates.
     7  * Other names may be trademarks of their respective owners.
     8  *
     9  * The contents of this file are subject to the terms of either the GNU
    10  * General Public License Version 2 only ("GPL") or the Common
    11  * Development and Distribution License("CDDL") (collectively, the
    12  * "License"). You may not use this file except in compliance with the
    13  * License. You can obtain a copy of the License at
    14  * http://www.netbeans.org/cddl-gplv2.html
    15  * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
    16  * specific language governing permissions and limitations under the
    17  * License.  When distributing the software, include this License Header
    18  * Notice in each file and include the License file at
    19  * nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this
    20  * particular file as subject to the "Classpath" exception as provided
    21  * by Oracle in the GPL Version 2 section of the License file that
    22  * accompanied this code. If applicable, add the following below the
    23  * License Header, with the fields enclosed by brackets [] replaced by
    24  * your own identifying information:
    25  * "Portions Copyrighted [year] [name of copyright owner]"
    26  *
    27  * Contributor(s):
    28  *
    29  * The Original Software is NetBeans. The Initial Developer of the Original
    30  * Software is Oracle. Portions Copyright 2013-2013 Oracle. All Rights Reserved.
    31  *
    32  * If you wish your version of this file to be governed by only the CDDL
    33  * or only the GPL Version 2, indicate your decision by adding
    34  * "[Contributor] elects to include this software in this distribution
    35  * under the [CDDL or GPL Version 2] license." If you do not indicate a
    36  * single choice of license, a recipient has the option to distribute
    37  * your version of this file under either the CDDL, the GPL Version 2 or
    38  * to extend the choice of license to its licensees as provided above.
    39  * However, if you add GPL Version 2 code and therefore, elected the GPL
    40  * Version 2 license, then the option applies only if the new code is
    41  * made subject to such option by the copyright holder.
    42  */
    43 package org.netbeans.html.boot.impl;
    44 
    45 import java.lang.reflect.InvocationTargetException;
    46 import java.lang.reflect.Method;
    47 import java.lang.reflect.Modifier;
    48 import static org.testng.Assert.*;
    49 import org.testng.annotations.BeforeMethod;
    50 import org.testng.annotations.Test;
    51 
    52 /**
    53  *
    54  * @author Jaroslav Tulach <jaroslav.tulach@apidesign.org>
    55  */
    56 public class JsClassLoaderBase {
    57     protected static Class<?> methodClass;
    58     
    59     public JsClassLoaderBase() {
    60     }
    61     
    62     @BeforeMethod
    63     public void assertClassDefined() {
    64         assertNotNull(methodClass, "BeforeClass set up code should provide methodClass");
    65     }
    66 
    67     @Test public void noParamMethod() throws Throwable {
    68         Method plus = methodClass.getMethod("fortyTwo");
    69         try {
    70             final Object val = plus.invoke(null);
    71             assertTrue(val instanceof Number, "A number returned " + val);
    72             assertEquals(((Number)val).intValue(), 42);
    73         } catch (InvocationTargetException ex) {
    74             throw ex.getTargetException();
    75         }
    76     }
    77     
    78     @Test public void testExecuteScript() throws Throwable {
    79         Method plus = methodClass.getMethod("plus", int.class, int.class);
    80         try {
    81             assertEquals(plus.invoke(null, 10, 20), 30);
    82         } catch (InvocationTargetException ex) {
    83             throw ex.getTargetException();
    84         }
    85     }
    86 
    87     @Test public void overloadedMethod() throws Throwable {
    88         Method plus = methodClass.getMethod("plus", int.class);
    89         try {
    90             assertEquals(plus.invoke(null, 10), 10);
    91         } catch (InvocationTargetException ex) {
    92             throw ex.getTargetException();
    93         }
    94     }
    95     
    96     @Test public void instanceMethod() throws Throwable {
    97         Method plus = methodClass.getMethod("plusInst", int.class);
    98         Object inst = methodClass.newInstance();
    99         try {
   100             assertEquals(plus.invoke(inst, 10), 10);
   101         } catch (InvocationTargetException ex) {
   102             throw ex.getTargetException();
   103         }
   104     }
   105     
   106     @Test public void staticThis() throws Throwable {
   107         Method st = methodClass.getMethod("staticThis");
   108         try {
   109             assertNull(st.invoke(null));
   110         } catch (InvocationTargetException ex) {
   111             throw ex.getTargetException();
   112         }
   113     }
   114 
   115     @Test public void getThis() throws Throwable {
   116         Object th = methodClass.newInstance();
   117         Method st = methodClass.getMethod("getThis");
   118         try {
   119             assertEquals(st.invoke(th), th);
   120         } catch (InvocationTargetException ex) {
   121             throw ex.getTargetException();
   122         }
   123     }
   124     
   125     @Test public void truth() throws Throwable {
   126         Method st = methodClass.getMethod("truth");
   127         assertTrue((st.getModifiers() & Modifier.STATIC) != 0, "Is static");
   128         assertEquals(st.invoke(null), Boolean.TRUE, "Can return boolean");
   129     }
   130     
   131     @Test public void callback() throws Throwable {
   132         class R implements Runnable {
   133             int cnt;
   134             
   135             @Override
   136             public void run() {
   137                 cnt++;
   138             }
   139         }
   140         R r = new R();
   141         
   142         Method inc = methodClass.getMethod("callback", Runnable.class);
   143         inc.invoke(null, r);
   144         
   145         assertEquals(r.cnt, 1, "Callback happened");
   146     }
   147     
   148     @Test public void sumArray() throws Throwable {
   149         Method st = methodClass.getMethod("sumArr", int[].class);
   150         assertEquals(st.invoke(null, new int[] { 1, 2, 3 }), 6, "1+2+3 is six");
   151     }
   152     
   153     @Test public void javaScriptResource() throws Throwable {
   154         try {
   155             Method st = methodClass.getMethod("useExternalMul", int.class, int.class);
   156             assertEquals(st.invoke(null, 6, 7), 42, "Meaning of JavaScript?");
   157         } catch (InvocationTargetException ex) {
   158             throw ex.getTargetException();
   159         }
   160     }
   161     
   162     @Test public void callJavaScriptMethodOnOwnClass() throws Throwable {
   163         try {
   164             Object thiz = methodClass.newInstance();
   165             Method st = methodClass.getMethod("returnYourSelf", methodClass);
   166             assertEquals(st.invoke(null, thiz), thiz, "Returns this");
   167         } catch (InvocationTargetException ex) {
   168             throw ex.getTargetException();
   169         }
   170     }
   171     
   172     @Test public void callStaticJavaMethod() throws Throwable {
   173         Method st = methodClass.getMethod("staticCallback", int.class, int.class);
   174         assertEquals(st.invoke(null, 6, 7), 42, "Meaning of JavaScript?");
   175     }
   176 
   177     @Test public void callStaticStringParamMethod() throws Throwable {
   178         Method st = methodClass.getMethod("parseInt", String.class);
   179         assertEquals(st.invoke(null, "42"), 42, "Meaning of JavaScript?");
   180     }
   181     
   182     @Test public void firstLong() throws Throwable {
   183         Method st = methodClass.getMethod("chooseLong", boolean.class, boolean.class, long.class, long.class);
   184         assertEquals(st.invoke(null, true, false, 10, 20), 10L, "Take first value");
   185     }
   186 
   187     @Test public void secondLong() throws Throwable {
   188         Method st = methodClass.getMethod("chooseLong", boolean.class, boolean.class, long.class, long.class);
   189         assertEquals(st.invoke(null, false, true, 10, 20), 20L, "Take 2nd value");
   190     }
   191 
   192     @Test public void bothLong() throws Throwable {
   193         Method st = methodClass.getMethod("chooseLong", boolean.class, boolean.class, long.class, long.class);
   194         assertEquals(st.invoke(null, true, true, 10, 20), 30L, "Take both values");
   195     }
   196     
   197     @Test public void recordError() throws Throwable {
   198         Method st = methodClass.getMethod("recordError", Object.class);
   199         assertEquals(st.invoke(methodClass.newInstance(), "Hello"), "Hello", "The same parameter returned");
   200     }
   201 }