Java Code Examples for groovy.lang.Closure#setResolveStrategy()

public void execute(T delegate) {
    if (closure == null) {
        return;
    }

    try {
        if (configureableAware && delegate instanceof Configurable) {
            ((Configurable) delegate).configure(closure);
        } else {
            Closure copy = (Closure) closure.clone();
            copy.setResolveStrategy(resolveStrategy);
            copy.setDelegate(delegate);
            if (copy.getMaximumNumberOfParameters() == 0) {
                copy.call();
            } else {
                copy.call(delegate);
            }
        }
    } catch (groovy.lang.MissingMethodException e) {
        if (Objects.equal(e.getType(), closure.getClass()) && Objects.equal(e.getMethod(), "doCall")) {
            throw new InvalidActionClosureException(closure, delegate);
        }
        throw e;
    }
}
 

public Verifiable verify(TestCaseProcess[] processes, Closure<?> cl) throws TestException {
    getTestCaseRun().setPreFilter(before -> substitute(before));

    if (cl != null) {
        cl.setResolveStrategy(Closure.DELEGATE_FIRST);
        cl.setDelegate(process);
        cl.call();
    }
    if (process.getExpectedResults() == null)
        process.setExpectedResults(getDefaultExpectedResults());
    if (process.getExcludeVariables() != null && !process.getExcludeVariables().isEmpty())
        processes[0].setExcludeVariables(process.getExcludeVariables());

    process.setSuccess(getTestCaseRun().verifyProcess(processes, process.getExpectedResults()));
    return process;
}
 

public void execute(T delegate) {
    if (closure == null) {
        return;
    }

    try {
        if (configureableAware && delegate instanceof Configurable) {
            ((Configurable)delegate).configure(closure);
        } else {
            Closure copy = (Closure) closure.clone();
            copy.setResolveStrategy(resolveStrategy);
            copy.setDelegate(delegate);
            if (copy.getMaximumNumberOfParameters() == 0) {
                copy.call();
            } else {
                copy.call(delegate);
            }
        }
    } catch (groovy.lang.MissingMethodException e) {
        if (e.getType().equals(closure.getClass()) && e.getMethod().equals("doCall")) {
            throw new InvalidActionClosureException(closure, delegate);
        }
    }
}
 

public TestCaseResponse response(Closure<?> cl) throws TestException {
    if (response == null)
        response = new TestCaseResponse();
    if (cl != null) {
        cl.setResolveStrategy(Closure.DELEGATE_FIRST);
        cl.setDelegate(response);
        cl.call();
    }
    return response;
}
 

public void environment(Closure<Properties> closure) {
    ConfigObject config = new ConfigObject();
    closure.setResolveStrategy(Closure.DELEGATE_ONLY);
    closure.setDelegate(config);
    closure.call();
    config.flatten(this.environment);
}
 

public TestCaseProcess process(Closure<?> cl) throws TestException {
    cl.setResolveStrategy(Closure.DELEGATE_FIRST);
    cl.setDelegate(process);
    cl.call();
    if (getTestCaseRun().testCaseProcess == null)
        getTestCaseRun().testCaseProcess = process;
    return process;
}
 

public TestCaseProcess process(String target, Closure<?> cl) throws TestException {
    process = new TestCaseProcess(getTestCaseRun().getProcess(target));
    if (cl != null) {
        cl.setResolveStrategy(Closure.DELEGATE_FIRST);
        cl.setDelegate(process);
        cl.call();
    }
    if (getTestCaseRun().testCaseProcess == null)
        getTestCaseRun().testCaseProcess = process;
    return process;
}
 

public ApiRequest request(String target, Map<String,String> options, Closure<?> cl) throws TestException {
    int dotPostmanSlash = target.lastIndexOf(".postman/");
    if (dotPostmanSlash == -1)
        throw new TestException("Bad API test path: " + target);
    String assetPath = target.substring(0, dotPostmanSlash + 8);
    Asset asset = asset(assetPath);
    if (asset == null)
        throw new TestException("API test case asset not found: " + assetPath);
    TestCase apiTestCase = new TestCase(asset.getPackageName(), new AssetInfo(asset.getName()));
    try {
        String itemPath = asset.getPackageName() + "/" + asset.getName() + "/"
                + target.substring(dotPostmanSlash + 9).replace('/', '~');
        TestCaseItem item = ServiceLocator.getTestingServices().getTestCaseItem(itemPath);
        if (item == null)
            throw new TestException("Test case item not found: " + itemPath);
        apiTestCase.addItem(item);
        apiRequest = new ApiRequest(apiTestCase, options);
        if (cl != null) {
            cl.setResolveStrategy(Closure.DELEGATE_FIRST);
            cl.setDelegate(apiRequest);
            cl.call();
        }

        return apiRequest;
    }
    catch (ServiceException ex) {
        throw new TestException(ex.getMessage(), ex);
    }
}
 

private ChainedHttpConfig configureRequest(final Class<?> type, final HttpVerb verb, final Closure closure) {
    final HttpConfigs.BasicHttpConfig myConfig = HttpConfigs.requestLevel(getObjectConfig());
    closure.setDelegate(myConfig);
    closure.setResolveStrategy(Closure.DELEGATE_FIRST);
    closure.call();

    myConfig.getChainedRequest().setVerb(verb);
    myConfig.getChainedResponse().setType(type);

    return myConfig;
}
 

@Override
public boolean onNodeChildren(final FactoryBuilderSupport builder, final Object node, final Closure childContent) {
    if (node instanceof SecureASTCustomizer) {
        Closure clone = (Closure) childContent.clone();
        clone.setDelegate(node);
        clone.setResolveStrategy(Closure.DELEGATE_FIRST);
        clone.call();
    }
    return false;
}
 

@SuppressWarnings("unchecked")
static <T> Closure<T> cloneWithDelegate(final Closure<T> predicate, final Object delegate) {
    Closure<T> clone = (Closure<T>) predicate.clone();
    clone.setDelegate(delegate);
    clone.setResolveStrategy(Closure.DELEGATE_FIRST);
    return clone;
}
 

@Override
public ClojureSourceSet clojure(Closure<?> configureAction) {
  configureAction.setResolveStrategy(Closure.DELEGATE_FIRST);
  configureAction.setDelegate(clojure);
  configureAction.call(clojure);
  return this;
}
 

public void setUpdate(Closure update) {
    if (update != null) {
        update.setDelegate(this);
        update.setResolveStrategy(Closure.DELEGATE_FIRST);
    }
    this.update = update;
}
 

private static void curryDelegateAndGetContent(Writer w, @DelegatesTo(StreamingJsonDelegate.class) Closure c, Object o, boolean first, JsonGenerator generator) {
    StreamingJsonDelegate delegate = new StreamingJsonDelegate(w, first, generator);
    Closure curried = c.curry(o);
    curried.setDelegate(delegate);
    curried.setResolveStrategy(Closure.DELEGATE_FIRST);
    curried.call();
}
 

public void execute(T subject, List<?> inputs) {
    Closure copy = (Closure) closure.clone();
    copy.setResolveStrategy(Closure.DELEGATE_FIRST);
    copy.setDelegate(subject);

    Object[] argList = new Object[inputs.size() + 1];
    argList[0] = subject;
    int i = 1;
    for (Object arg : inputs) {
        argList[i++] = arg;
    }
    copy.call(argList);
}
 

/**
 * Factory method for creating <code>JsonDelegate</code>s from closures currying an object
 * argument.
 *
 * @param c closure representing JSON objects
 * @param o an object curried to the closure
 * @return an instance of <code>JsonDelegate</code>
 */
public static Map<String, Object> curryDelegateAndGetContent(Closure<?> c, Object o) {
    JsonDelegate delegate = new JsonDelegate();
    Closure<?> curried = c.curry(o);
    curried.setDelegate(delegate);
    curried.setResolveStrategy(Closure.DELEGATE_FIRST);
    curried.call();

    return delegate.getContent();
}
 

public void execute(T subject, List<?> inputs) {
    Closure copy = (Closure) closure.clone();
    copy.setResolveStrategy(Closure.DELEGATE_FIRST);
    copy.setDelegate(subject);

    Object[] argList = new Object[inputs.size() + 1];
    argList[0] = subject;
    int i = 1;
    for (Object arg : inputs) {
        argList[i++] = arg;
    }
    copy.call(argList);
}
 

/**
 * responder closure call is delayed until stub server calls back
 */
public TestCaseAdapterStub adapter(Closure<Boolean> matcher, Closure<String> responder, Closure<?> init) throws TestException {
    final TestCaseAdapterStub adapterStub = new TestCaseAdapterStub(matcher, responder);
    if (init != null) {
        init.setResolveStrategy(Closure.DELEGATE_FIRST);
        init.setDelegate(adapterStub);
        init.call();
    }
    if (responder == null) {
        adapterStub.setResponder(new Closure<String>(this, adapterStub) {
            @Override
            public String call(Object request) {
                // binding for request
                final TestCaseRun testCaseRun = getTestCaseRun();
                if (adapterStub.getResponse().contains("${")) {
                    try {
                        Binding binding = getBinding();
                        if (request.toString().startsWith("{")) {
                            Object req = new JsonSlurper().parseText(request.toString());
                            binding.setVariable("request", req);
                        }
                        else {
                            GPathResult gpathRequest = new XmlSlurper().parseText(request.toString());
                            binding.setVariable("request", gpathRequest);
                        }
                        CompilerConfiguration compilerCfg = new CompilerConfiguration();
                        compilerCfg.setScriptBaseClass(DelegatingScript.class.getName());
                        GroovyShell shell = new GroovyShell(TestCaseScript.class.getClassLoader(), binding, compilerCfg);
                        shell.setProperty("out", testCaseRun.getLog());
                        DelegatingScript script = (DelegatingScript) shell.parse("return \"\"\"" + adapterStub.getResponse() + "\"\"\"");
                        script.setDelegate(TestCaseScript.this);
                        return script.run().toString();
                    }
                    catch (Exception ex) {
                        getTestCaseRun().getLog().println("Cannot perform stub substitutions for request: " + request);
                        ex.printStackTrace(getTestCaseRun().getLog());
                    }
                }
                return adapterStub.getResponse();
            }
        });
    }
    return adapterStub;
}
 

public void compiler(Closure<?> configureAction) {
  configureAction.setResolveStrategy(Closure.DELEGATE_FIRST);
  configureAction.setDelegate(compiler);
  configureAction.call(compiler);
}
 

public void ordered(Closure<?> closure) {
   ZigbeeSendOrdered ctx = new ZigbeeSendOrdered(GroovyCapabilityDefinition.CapabilityHandlerContext.getContext(this));
   closure.setResolveStrategy(Closure.DELEGATE_FIRST);
   closure.setDelegate(ctx);
   closure.call();
}