This is an automated email from the ASF dual-hosted git repository.

jtulach pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/netbeans-html4j.git

commit 51d1a5b543c23a071775ad3746f5f1582c9e95f9
Author: Jaroslav Tulach <jaroslav.tul...@apidesign.org>
AuthorDate: Mon Dec 7 12:22:04 2020 +0100

    Enhancing the TCK documentation with showcases from Script engine TCK usage
---
 .../{SingleCase.java => ScriptEngineCase.java}     | 57 ++++------------------
 ...riptTst.java => ScriptEngineJavaScriptTCK.java} | 18 +++++--
 ...23JavaScriptTest.java => ScriptEngineTest.java} | 20 ++------
 .../net/java/html/boot/script/ScriptsTest.java     |  2 +-
 .../main/java/org/netbeans/html/boot/spi/Fn.java   |  5 ++
 .../org/netbeans/html/json/tck/JavaScriptTCK.java  | 44 ++++++++++++++---
 6 files changed, 71 insertions(+), 75 deletions(-)

diff --git 
a/boot-script/src/test/java/net/java/html/boot/script/SingleCase.java 
b/boot-script/src/test/java/net/java/html/boot/script/ScriptEngineCase.java
similarity index 53%
rename from boot-script/src/test/java/net/java/html/boot/script/SingleCase.java
rename to 
boot-script/src/test/java/net/java/html/boot/script/ScriptEngineCase.java
index 872673e..af8b1a7 100644
--- a/boot-script/src/test/java/net/java/html/boot/script/SingleCase.java
+++ b/boot-script/src/test/java/net/java/html/boot/script/ScriptEngineCase.java
@@ -18,10 +18,7 @@
  */
 package net.java.html.boot.script;
 
-import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
-import java.util.concurrent.Executor;
-import java.util.concurrent.Executors;
 import org.netbeans.html.boot.spi.Fn;
 import org.netbeans.html.boot.impl.FnContext;
 import org.testng.IHookCallBack;
@@ -34,65 +31,31 @@ import org.testng.annotations.Test;
  *
  * @author Jaroslav Tulach
  */
-public final class SingleCase implements ITest, IHookable, Runnable {
-    static final Executor JS = Executors.newSingleThreadExecutor();
+public final class ScriptEngineCase implements ITest, IHookable {
     private final Fn.Presenter p;
-    private final Method m;
-    private Object result;
-    private Object inst;
+    private final Method method;
     private final String prefix;
 
-    SingleCase(String prefix, Fn.Presenter p, Method m) {
+    ScriptEngineCase(String prefix, Fn.Presenter p, Method m) {
         this.prefix = prefix;
         this.p = p;
-        this.m = m;
+        this.method = m;
     }
 
     @Override
     public String getTestName() {
-        return prefix + m.getName();
+        return prefix + method.getName();
     }
 
     @Test
     public synchronized void executeTest() throws Exception {
-        if (result == null) {
-            JS.execute(this);
-            wait();
-        }
-        if (result instanceof Exception) {
-            throw (Exception)result;
-        }
-        if (result instanceof Error) {
-            throw (Error)result;
-        }
-    }
-
-    @Override
-    public synchronized void run() {
-        boolean notify = true;
         try {
             FnContext.currentPresenter(p);
-            if (inst == null) {
-                inst = m.getDeclaringClass().newInstance();
-            }
-            result = m.invoke(inst);
-            if (result == null) {
-                result = this;
-            }
-        } catch (InvocationTargetException ex) {
-            Throwable r = ex.getTargetException();
-            if (r instanceof InterruptedException) {
-                notify = false;
-                JS.execute(this);
-                return;
-            }
-            result = r;
-        } catch (Exception ex) {
-            result = ex;
+            // BEGIN: net.java.html.boot.script.ScriptEngineCase#run
+            Object instance = method.getDeclaringClass().newInstance();
+            method.invoke(instance);
+            // END: net.java.html.boot.script.ScriptEngineCase#run
         } finally {
-            if (notify) {
-                notifyAll();
-            }
             FnContext.currentPresenter(null);
         }
     }
@@ -101,5 +64,5 @@ public final class SingleCase implements ITest, IHookable, 
Runnable {
     public void run(IHookCallBack ihcb, ITestResult itr) {
         ihcb.runTestMethod(itr);
     }
-    
+
 }
diff --git 
a/boot-script/src/test/java/net/java/html/boot/script/Jsr223JavaScriptTst.java 
b/boot-script/src/test/java/net/java/html/boot/script/ScriptEngineJavaScriptTCK.java
similarity index 59%
rename from 
boot-script/src/test/java/net/java/html/boot/script/Jsr223JavaScriptTst.java
rename to 
boot-script/src/test/java/net/java/html/boot/script/ScriptEngineJavaScriptTCK.java
index 8cf8c66..755751b 100644
--- 
a/boot-script/src/test/java/net/java/html/boot/script/Jsr223JavaScriptTst.java
+++ 
b/boot-script/src/test/java/net/java/html/boot/script/ScriptEngineJavaScriptTCK.java
@@ -18,14 +18,26 @@
  */
 package net.java.html.boot.script;
 
+import java.lang.reflect.Method;
+import java.util.List;
+import java.util.function.Function;
 import org.netbeans.html.json.tck.JavaScriptTCK;
+import org.netbeans.html.json.tck.KOTest;
 
 /**
  *
  * @author Jaroslav Tulach
  */
-public final class Jsr223JavaScriptTst extends JavaScriptTCK {
-    public static Class[] tests() {
-        return testClasses();
+// BEGIN: net.java.html.boot.script.ScriptEngineJavaScriptTCK
+public final class ScriptEngineJavaScriptTCK extends JavaScriptTCK {
+    static <R> void collectTckTests(List<R> res, Function<Method, R> factory) {
+        for (Class c : testClasses()) {
+            for (Method m : c.getMethods()) {
+                if (m.getAnnotation(KOTest.class) != null) {
+                    res.add(factory.apply(m));
+                }
+            }
+        }
     }
 }
+// END: net.java.html.boot.script.ScriptEngineJavaScriptTCK
diff --git 
a/boot-script/src/test/java/net/java/html/boot/script/Jsr223JavaScriptTest.java 
b/boot-script/src/test/java/net/java/html/boot/script/ScriptEngineTest.java
similarity index 87%
rename from 
boot-script/src/test/java/net/java/html/boot/script/Jsr223JavaScriptTest.java
rename to 
boot-script/src/test/java/net/java/html/boot/script/ScriptEngineTest.java
index d21cbbd..c82f697 100644
--- 
a/boot-script/src/test/java/net/java/html/boot/script/Jsr223JavaScriptTest.java
+++ b/boot-script/src/test/java/net/java/html/boot/script/ScriptEngineTest.java
@@ -18,8 +18,6 @@
  */
 package net.java.html.boot.script;
 
-import java.lang.annotation.Annotation;
-import java.lang.reflect.Method;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.concurrent.CountDownLatch;
@@ -31,7 +29,6 @@ import javax.script.ScriptEngineManager;
 import javax.script.ScriptException;
 import net.java.html.boot.BrowserBuilder;
 import org.netbeans.html.boot.spi.Fn;
-import org.netbeans.html.json.tck.KOTest;
 import static org.testng.Assert.assertEquals;
 import org.testng.annotations.Factory;
 
@@ -39,8 +36,8 @@ import org.testng.annotations.Factory;
  *
  * @author Jaroslav Tulach
  */
-public class Jsr223JavaScriptTest {
-    public Jsr223JavaScriptTest() {
+public class ScriptEngineTest {
+    public ScriptEngineTest() {
     }
 
     @Factory public static Object[] compatibilityTests() throws Exception {
@@ -79,16 +76,7 @@ public class Jsr223JavaScriptTest {
         assertNoGlobalSymbolsLeft(engine);
         final String prefix = "[" + engine.getFactory().getEngineName() + "] ";
 
-        Class<? extends Annotation> test = KOTest.class;
-        Class[] arr = Jsr223JavaScriptTst.tests();
-        for (Class c : arr) {
-            for (Method m : c.getMethods()) {
-                if (m.getAnnotation(test) != null) {
-                    res.add(new SingleCase(prefix, browserPresenter[0], m));
-                }
-            }
-        }
-
+        ScriptEngineJavaScriptTCK.collectTckTests(res, (m) -> new 
ScriptEngineCase(prefix, browserPresenter[0], m));
     }
 
     private static void assertNoGlobalSymbolsLeft(ScriptEngine engine) throws 
ScriptException {
@@ -111,7 +99,7 @@ public class Jsr223JavaScriptTest {
     }
 
     private static Fn.Presenter createPresenter(ScriptEngine engine) {
-        final Executor someExecutor = SingleCase.JS;
+        final Executor someExecutor = (r) -> r.run();
         // BEGIN: Jsr223JavaScriptTest#createPresenter
         return Scripts.newPresenter()
             .engine(engine)
diff --git 
a/boot-script/src/test/java/net/java/html/boot/script/ScriptsTest.java 
b/boot-script/src/test/java/net/java/html/boot/script/ScriptsTest.java
index 9b4775a..a43f01c 100644
--- a/boot-script/src/test/java/net/java/html/boot/script/ScriptsTest.java
+++ b/boot-script/src/test/java/net/java/html/boot/script/ScriptsTest.java
@@ -39,7 +39,7 @@ public class ScriptsTest {
         List<Object[]> res = new ArrayList<>();
         final ScriptEngineManager manager = new ScriptEngineManager();
         for (ScriptEngineFactory f : manager.getEngineFactories()) {
-            if (!Jsr223JavaScriptTest.isJavaScriptEngineFactory(f)) {
+            if (!ScriptEngineTest.isJavaScriptEngineFactory(f)) {
                 continue;
             }
             res.add(new Object[] { f.getScriptEngine() });
diff --git a/boot/src/main/java/org/netbeans/html/boot/spi/Fn.java 
b/boot/src/main/java/org/netbeans/html/boot/spi/Fn.java
index a4f2f45..ffe2d79 100644
--- a/boot/src/main/java/org/netbeans/html/boot/spi/Fn.java
+++ b/boot/src/main/java/org/netbeans/html/boot/spi/Fn.java
@@ -240,7 +240,12 @@ public abstract class Fn {
      * Should be provided by a library included in the application and 
registered
      * in <code>META-INF/services</code>, for example with
      * <code>@ServiceProvider(service = Fn.Presenter.class)</code> annotation.
+     * To verify the implementation of the presenter is correct, implement
+     * associated TCK (e.g. test compatibility kit) at least the headless
+     * one as illustrated at:
      * <p>
+     * {@codesnippet net.java.html.boot.script.ScriptEngineJavaScriptTCK}
+     * 
      * Since 0.7 a presenter may implement {@link Executor} interface, in case
      * it supports single threaded execution environment. The executor's
      * {@link Executor#execute(java.lang.Runnable)} method is then supposed
diff --git 
a/json-tck/src/main/java/org/netbeans/html/json/tck/JavaScriptTCK.java 
b/json-tck/src/main/java/org/netbeans/html/json/tck/JavaScriptTCK.java
index 09b8315..5d39f9a 100644
--- a/json-tck/src/main/java/org/netbeans/html/json/tck/JavaScriptTCK.java
+++ b/json-tck/src/main/java/org/netbeans/html/json/tck/JavaScriptTCK.java
@@ -24,27 +24,55 @@ import net.java.html.js.tests.ExposedPropertiesTest;
 import org.netbeans.html.boot.spi.Fn;
 import org.netbeans.html.boot.spi.Fn.Presenter;
 
-/** Entry point for those who want to verify that their implementation of
- * {@link Presenter} is good enough to support existing Java/JavaScript 
- * communication use-cases. Subclass this class, get list of {@link 
#testClasses() classes}
- * find methods annotated by {@link KOTest} annotation and execute them.
+/** Basic <em>Test Compatibility Kit</em> for people providing their own
+ * implementation of {@link Presenter} or any other system that understands
+ * {@link net.java.html.js.JavaScriptBody} annotation. The {@link 
JavaScriptTCK}
+ * tests are <em>headless</em> - e.g. they don't need access to browser APIs
+ * like DOM. It is possible to execute them in <em>node</em>
+ * or in a plain {@link javax.script.ScriptEngine} environment. The tests are 
focused
+ * on Java/JavaScript interactions, calls and exchange of objects between the
+ * two worlds. See {@link KnockoutTCK} for UI oriented tests.
  * <p>
+ * Implement your system, setup your <em>headless</em> environment for
+ * execution of JavaScript and execute the tests. There are the steps to 
follow:
+ * <ul>
+ *  <li>subclass this class</li>
+ *  <li>get list of {@link #testClasses() test classes}</li>
+ *  <li>find their methods annotated by {@link KOTest} annotation</li>
+ *  <li>execute them</li>
+ * </ul>
+ * <p>
+ * Typical way to iterate through all the test methods looks like this:
+ * <p>
+ * {@codesnippet net.java.html.boot.script.ScriptEngineJavaScriptTCK}
+ * <p>
+ * by subclassing {@link JavaScriptTCK} one gets access to {@code protected}
+ * method {@link JavaScriptTCK#testClasses} and can obtain all the TCK classes.
+ * One can use any <em>factory</em> and create objects suitable for any
+ * testing framework. Typical invocation of a single test then looks like
+ * <p>
+ * {@codesnippet net.java.html.boot.script.ScriptEngineCase#run}
+ * e.g. one creates an instance of the object and invokes its test {@code 
method}.
+ * <p>
+ * When the test provided by this <em>headless TCK</em> are passing,
+ * consider also testing your environment on a
+ * {@link KnockoutTCK visual DOM-based TCK}.
  *
  * @author Jaroslav Tulach
+ * @see KnockoutTCK
  * @since 0.7
  */
 public abstract class JavaScriptTCK {
     /** Gives you list of classes included in the TCK. Their test methods
      * are annotated by {@link KOTest} annotation. The methods are public
-     * instance methods that take no arguments. The method should be 
+     * instance methods that take no arguments. The method should be
      * invoke in a presenter context {@link 
Fn#activate(org.netbeans.html.boot.spi.Fn.Presenter)}.
-     * 
+     *
      * @return classes with methods annotated by {@link KOTest} annotation
      */
     protected static Class<?>[] testClasses() {
-        return new Class[] { 
+        return new Class[] {
             JavaScriptBodyTest.class, GCBodyTest.class, 
ExposedPropertiesTest.class
         };
     }
-    
 }


---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscr...@netbeans.apache.org
For additional commands, e-mail: commits-h...@netbeans.apache.org

For further information about the NetBeans mailing lists, visit:
https://cwiki.apache.org/confluence/display/NETBEANS/Mailing+lists

Reply via email to