}
}

public class DynamicBean extends ExtensibleDynamicObjectTest.Bean {
//    def propertyMissing(String name) {
//        super.getProperty(name)
//    }

//    def methodMissing(String name, params) {
//        super.methodMissing(name, params)
//    }

//    void setProperty(String name, Object value) {
//        super.setProperty(name, value)
//    }
}

public class GroovyBean extends DynamicBean {

            module(aid) {
                version(v, spec)
            }
        }
    }

    /**
     * Use {@link #id} when possible since it doesn't rely on {@code methodMissing} and integrates better with IDEs.
     */
    void methodMissing(String name, args) {
        def (gid, aid, v) = name.split(':') as List
        Closure spec = {}
        if (args && args.length == 1 && args[0] instanceof Closure) {

            return
        }
        throw new MissingPropertyException(name, BeanWithDynamicProperties)
    }

    String thing(Number l) {
        return l.toString()
    }

    Object methodMissing(String name, Object params) {
        if (name == "dyno") {
            return Arrays.toString((Object[]) params)
        }

                    return DynamicInvokeResult.found(Arrays.toString(arguments))
                }
                return DynamicInvokeResult.notFound()
            }
        }
    }

    Object methodMissing(String name, Object params) {
        throw new AssertionError("Should not be called")
    }

    Object invokeMethod(String name, Object args) {
        null
    }

    def propertyMissing(String name) {
        null
    }

    def propertyMissing(String name, def value) {
    }

    def methodMissing(String name, def args) {
    }

 *
 * Note that when a type implements this interface, dynamic Groovy dispatch will not be used to discover opaque methods. That is, methods such as methodMissing() will be ignored.
 */
public interface MethodMixIn {
    MethodAccess getAdditionalMethods();

    }

    def searchUpwards(boolean searchUpwards) {
        connector.searchUpwards(searchUpwards)
        this
    }

    def methodMissing(String name, args) {
        connector."$name"(*args)
    }

    def propertyMissing(String name, value) {
        connector."$name" = value
    }

    def propertyMissing(String name) {

    }

    TestFile link(String name, String target) {
        baseDir.file(name).createLink(target)
    }

    def setMode(int mode) {
        baseDir.mode = mode
    }

    def methodMissing(String name, Object args) {
        if (args.length == 1 && args[0] instanceof Closure) {
            baseDir.file(name).create(args[0])
        } else {
            throw new MissingMethodException(name, getClass(), args)

    default void configure(SigningExtension settings, Closure closure) {
        ConfigureUtil.configure(closure, new Object() {
            @SuppressWarnings("unused") // invoked by Groovy
            public void methodMissing(String name, Object args) {
                createSignatoryFor(settings.getProject(), name, asType(args, Object[].class));
            }
        });
    }

        moduleSpec.resolveStrategy = Closure.DELEGATE_ONLY
        moduleSpec()
    }

    void build(HttpRepository repository) {
        modules.values()*.build(repository)
    }

    void methodMissing(String name, args) {
        def (aid, v) = name.split(':') as List
        Closure spec = {}
        if (args && args.length == 1 && args[0] instanceof Closure) {
            spec = args[0]
        }