}
    }

    @Override
    public Map<String, ?> getProperties() {
        return Collections.emptyMap();
    }

    @Override
    public boolean hasMethod(String name, @Nullable Object... arguments) {
        return false;
    }

    @Override
    public DynamicInvokeResult tryInvokeMethod(String name, @Nullable Object... arguments) {

            return
        }
        throw new AssertionError("Should not have found method $name(${Arrays.toString(argTypes)}) on class $c")
    }

    protected static Method hasMethod(Class c, String name, Class... argTypes) {
        try {
            c.getDeclaredMethod(name, argTypes)
        } catch (NoSuchMethodException ex) {

        }

        @Override
        public Map<String, T> getProperties() {
            return getAsMap();
        }

        @Override
        public boolean hasMethod(String name, @Nullable Object... arguments) {
            return isConfigureMethod(name, arguments);
        }

        @Override

// license that can be found in the LICENSE file.

package main

import "./other"

type Imported interface {
	Do()
}

type HasAMethod struct {
	x int
}

func (me *HasAMethod) Do() {
	println(me.x)
}

func InMyCode(x *Imported, y *HasAMethod, z *other.Exported) {
	x.Do() // ERROR "x\.Do undefined \(type \*Imported is pointer to interface, not interface\)|type that is pointer to interface"

        }
    }

    private boolean hasMethods(ClassDoc classDoc) {
        boolean hasMethods = false;
        if (!classDoc.getClassMethods().isEmpty()) {
            hasMethods = true;
        }
        for (ClassExtensionDoc extensionDoc : classDoc.getClassExtensions()) {
            hasMethods |= !extensionDoc.getExtensionMethods().isEmpty();
        }
        return hasMethods;
    }

        scriptData.hasMethods
    }

    def "imports are not considered imperative code"() {
        expect:
        def scriptData = parse("""import java.lang.String
import java.lang.*
import static java.lang.String.*
""")
        !scriptData.runDoesSomething
        !scriptData.data.hasImperativeStatements
        !scriptData.hasMethods
    }

 *   <li>hashMethod: how to hash the data (using the Hashing API or the MessageDigest API).
 * </ul>
 *
 * @author Kurt Alfred Kluever
 */
public class MessageDigestAlgorithmBenchmark {
  @Param({"10", "1000", "100000", "1000000"})
  int size;

  @Param Algorithm algorithm;
  @Param HashMethod hashMethod;

  private enum HashMethod {
    MESSAGE_DIGEST_API() {
      @Override

 *   <li>hashMethod: how to hash the data (using the Hashing API or the MessageDigest API).
 * </ul>
 *
 * @author Kurt Alfred Kluever
 */
public class MessageDigestAlgorithmBenchmark {
  @Param({"10", "1000", "100000", "1000000"})
  int size;

  @Param Algorithm algorithm;
  @Param HashMethod hashMethod;

  private enum HashMethod {
    MESSAGE_DIGEST_API() {
      @Override

        private ClassLoaderScope scope;

        public ClassesDirCompiledScript(boolean isEmpty, boolean hasMethods, Class<T> scriptBaseClass, ClassPath scriptClassPath, ClassLoaderScope targetScope, ScriptSource source, HashCode sourceHashCode, M metadata) {
            this.isEmpty = isEmpty;
            this.hasMethods = hasMethods;
            this.scriptBaseClass = scriptBaseClass;
            this.scriptClassPath = scriptClassPath;

        _ * scriptRunner.data >> new BuildScriptData(true)
        _ * scriptRunner.runDoesSomething >> true
        _ * scriptRunner.hasMethods >> true
        1 * scriptRunner.script >> script
        1 * target.setScript(script)
        0 * target.addDeferredConfiguration(_)
        1 * scriptRunner.run(target, _ as ServiceRegistry)