fun WriteContext.encodeLoop(coroutineContext: CoroutineContext) {
        do {
            val call = encodeCall!!
            suspend {
                codec.run {
                    encode(call.value)
                }
            }.startCoroutine(
                Continuation(coroutineContext) {
                    when (val k = call.k) {
                        null -> {
                            encodeCall = null

//  private:
//   void MyMethod();
//   FRIEND_TEST(MyClassTest, MyMethod);
// };
//
// class MyClassTest : public testing::Test {
//   // ...
// };
//
// TEST_F(MyClassTest, MyMethod) {
//   // Can call MyClass::MyMethod() here.
// }

#define FRIEND_TEST(test_case_name, test_name)\
friend class test_case_name##_##test_name##_Test

        if (failMessage != null) {
            addSyntaxError(failMessage, sourceUnit, statement);
        }

        return statement;
    }

    // Add the block line-number as an argument to call `plugins(int lineNumber, Closure pluginsBlock)`
    private void addLineNumberToMethodCall(ScriptBlock scriptBlock) {

 * by subclasses as they define our entry point behaviour, but they are protected to enable
 * testing as it's difficult to test something that will call System.exit().
 */
public abstract class EntryPoint {
    private final PrintStream originalStdErr = System.err;

    /**
     * Unless the createCompleter() method is overridden, the JVM will exit before returning from this method.
     */

If more than one init script is found, they will all be executed in the order specified above.

Scripts in a given directory are executed in alphabetical order.

        mv.visitCode();
        mv.visitTypeInsn(NEW, "java/lang/UnsupportedOperationException");
        mv.visitInsn(DUP);
        mv.visitLdcInsn(
            "You tried to call a method on an API class. Is the API jar on the classpath instead of the runtime jar?");
        mv.visitMethodInsn(
            INVOKESPECIAL, "java/lang/UnsupportedOperationException", "<init>", "(Ljava/lang/String;)V", false);

    abstract void setCurrentInterceptorSet(T newInterceptorSet);

    /**
     * Ensures that the global call interceptors are replaced with an implementation that maintains call interceptors per thread.
     * Then sets up the call interceptors for the current thread only.
     */
    void setupForCurrentThread() {
        synchronized (CallInterceptorRegistry.class) {

            public Object call() throws Exception {
                return toList("a");
            }
        };

        conventionAware.map("list1", callable);
        assertThat(conventionAware.getConventionValue(null, "list1", false), equalTo((Object) toList("a")));
    }

    @Test
    public void canSetMappingUsingDynamicProperty() {
        TestUtil.call("{ it.list1 = { ['a'] } }", conventionAware);

        cl.delegate = builder
        cl.call()
        def firstChild = parent.getFirstChild()
        builder.elements.each { element ->
            parent.insertBefore(element, firstChild)
        }
    }

    public static void addBefore(Node sibling, Closure cl) {
        DomBuilder builder = new DomBuilder(sibling.ownerDocument, null)
        cl.delegate = builder
        cl.call()
        def parent = sibling.parentNode

    /**
     * Returns the number of configurations in this provider.
     * <p>
     * This method is provided for performance reasons. It should be more efficient to call this method
     * than to call {@link #visitAll(Consumer)} and then call {@link Set#size()} on the result.
     *
     * @return the number of configurations in this provider, the same count as would be visited by calling {@link #visitAll(Consumer)}
     */