Using MockExecutorService to make the sample code look asynchronous, …

…but run it in a synchronous way in the TruffleTCK test

truffle/com.oracle.truffle.api.debug/src/com/oracle/truffle/api/debug/SuspendedEvent.java

@@ -286,7 +286,10 @@ public Object eval(String code, FrameInstance frame) throws IOException {
     }
 
     /**
-     * Prepare to terminate the suspended execution represented by this event.
+     * Prepare to terminate the suspended execution represented by this event. One use-case for this
+     * method is to shield an execution of an unknown code with a timeout:
+     *
+     * {@link com.oracle.truffle.tck.TckSnippets.ExecWithTimeOut}
      *
      * @since 0.12
      */

truffle/com.oracle.truffle.tck/src/com/oracle/truffle/tck/CountAndKill.java

@@ -30,15 +30,15 @@
 import com.oracle.truffle.api.interop.TruffleObject;
 import com.oracle.truffle.api.nodes.Node;
 import com.oracle.truffle.tck.impl.TckLanguage;
-import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.ScheduledExecutorService;
 
 @MessageResolution(language = TckLanguage.class, receiverType = CountAndKill.class)
 final class CountAndKill implements TruffleObject {
-    final CountDownLatch onZero;
+    final ScheduledExecutorService onZero;
     int countDown;
     int lastParameter;
 
-    CountAndKill(int counter, CountDownLatch onZero) {
+    CountAndKill(int counter, ScheduledExecutorService onZero) {
         this.onZero = onZero;
         this.countDown = counter;
     }
@@ -56,8 +56,7 @@ static boolean isInstance(TruffleObject obj) {
     abstract static class AddOne extends Node {
         protected boolean access(CountAndKill counter, Object... arguments) {
             if (counter.countDown == 0) {
-                counter.onZero.countDown();
-                Thread.yield();
+                counter.onZero.shutdownNow();
             } else {
                 counter.countDown--;
             }

truffle/com.oracle.truffle.tck/src/com/oracle/truffle/tck/MockExecutorService.java

@@ -0,0 +1,145 @@
+/*
+ * Copyright (c) 2015, 2016, 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.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * 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.
+ */
+package com.oracle.truffle.tck;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Future;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.ScheduledFuture;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+
+final class MockExecutorService implements ScheduledExecutorService {
+    private final List<Object> pending = new ArrayList<>();
+
+    @Override
+    public ScheduledFuture<?> schedule(Runnable command, long delay, TimeUnit unit) {
+        pending.add(command);
+        return null;
+    }
+
+    @Override
+    public <V> ScheduledFuture<V> schedule(Callable<V> callable, long delay, TimeUnit unit) {
+        pending.add(callable);
+        return null;
+    }
+
+    @Override
+    public ScheduledFuture<?> scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public ScheduledFuture<?> scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public void shutdown() {
+        Object[] run = pending.toArray();
+        pending.clear();
+        for (Object obj : run) {
+            if (obj instanceof Runnable) {
+                ((Runnable) obj).run();
+            } else {
+                try {
+                    ((Callable<?>) obj).call();
+                } catch (Exception ex) {
+                    throw new IllegalStateException(ex);
+                }
+            }
+        }
+    }
+
+    @Override
+    public List<Runnable> shutdownNow() {
+        shutdown();
+        return Collections.emptyList();
+    }
+
+    @Override
+    public boolean isShutdown() {
+        return pending.isEmpty();
+    }
+
+    @Override
+    public boolean isTerminated() {
+        return false;
+    }
+
+    @Override
+    public boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedException {
+        return false;
+    }
+
+    @Override
+    public <T> Future<T> submit(Callable<T> task) {
+        pending.add(task);
+        return null;
+    }
+
+    @Override
+    public <T> Future<T> submit(Runnable task, T result) {
+        pending.add(task);
+        return null;
+    }
+
+    @Override
+    public Future<?> submit(Runnable task) {
+        pending.add(task);
+        return null;
+    }
+
+    @Override
+    public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks) throws InterruptedException {
+        throw new InterruptedException();
+    }
+
+    @Override
+    public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit) throws InterruptedException {
+        throw new InterruptedException();
+    }
+
+    @Override
+    public <T> T invokeAny(Collection<? extends Callable<T>> tasks) throws InterruptedException, ExecutionException {
+        throw new InterruptedException();
+    }
+
+    @Override
+    public <T> T invokeAny(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException {
+        throw new InterruptedException();
+    }
+
+    @Override
+    public void execute(Runnable command) {
+        pending.add(command);
+    }
+
+}

truffle/com.oracle.truffle.tck/src/com/oracle/truffle/tck/TckSnippets.java

@@ -0,0 +1,110 @@
+/*
+ * Copyright (c) 2015, 2016, 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.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * 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.
+ */
+package com.oracle.truffle.tck;
+
+import com.oracle.truffle.api.debug.Debugger;
+import com.oracle.truffle.api.debug.SuspendedEvent;
+import com.oracle.truffle.api.vm.EventConsumer;
+import com.oracle.truffle.api.vm.PolyglotEngine;
+import java.io.IOException;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
+class TckSnippets {
+
+    /**
+     * Example of an execution shielded by a timeout. Used in {@link SuspendedEvent#prepareKill()}
+     * javadoc.
+     */
+    // BEGIN: com.oracle.truffle.tck.TckSnippets.ExecWithTimeOut
+    class ExecWithTimeOut extends EventConsumer<SuspendedEvent> //
+                    implements Runnable {
+
+        boolean pauseRequested;
+        boolean pauseResult;
+
+        ExecWithTimeOut() {
+            super(SuspendedEvent.class);
+        }
+
+        private void initTimeOut(ScheduledExecutorService executor) {
+            // schedule pausing actions after a timeout
+            executor.schedule(this, 10, TimeUnit.SECONDS);
+        }
+
+        @Override
+        public void run() {
+            // if the script is running too long
+            pauseRequested = true;
+            final Debugger debugger = getDebugger();
+            // request pause to generate SuspendedEvent
+            pauseResult = debugger.pause();
+        }
+
+        @Override
+        protected void on(SuspendedEvent event) {
+            if (pauseRequested) {
+                // when execution stops either debug or kill it:
+                event.prepareKill();
+            }
+        }
+
+        void executeWithTimeOut(
+                        ScheduledExecutorService executor, // run us later
+                        PolyglotEngine.Value function, // unknown function
+                        Object parameter // parameter for the function
+        ) throws IOException {
+            initTimeOut(executor);
+            Throwable caught = null;
+            try {
+                // execute with timer on
+                function.execute(parameter);
+            } catch (ThreadDeath t) {
+                caught = t;
+            }
+            assertTrue("Pause requested", pauseRequested);
+            assertTrue("Pause performed successfully", pauseResult);
+            assertNotNull("Execution ended with throwable", caught);
+            assertEquals("Our Exception", // prepareKill produces
+                            "com.oracle.truffle.api.debug.KillException", //
+                            caught.getClass().getName());
+        }
+        // FINISH: com.oracle.truffle.tck.TckSnippets.ExecWithTimeOut
+
+        PolyglotEngine engine;
+        Debugger foundDebugger;
+
+        Debugger getDebugger() {
+            if (foundDebugger == null) {
+                foundDebugger = Debugger.find(engine);
+            }
+            return foundDebugger;
+        }
+
+    }
+}