@Override
    public Object evaluate(final String template, final Map<String, Object> paramMap) {
        final Map<String, Object> bindingMap = new HashMap<>(paramMap);
        bindingMap.put("container", SingletonLaContainerFactory.getContainer());
        final GroovyShell groovyShell = new GroovyShell(new Binding(bindingMap));
        try {
            return groovyShell.evaluate(template);
        } catch (final JobProcessingException e) {

        final List<String> wordList = Analysis.parseWordList(environment, settings, "stopwords", s -> s);
        if (wordList != null) {
            stopwords = wordList.toArray(new String[wordList.size()]);
        } else {
            stopwords = new String[0];
        }

        ignoreCase = settings.getAsBoolean("ignore_case", Boolean.FALSE).booleanValue();
        if (ignoreCase) {

        startLatch = new CountDownLatch(size);
        endLatch = new CountDownLatch(size);
        Map<String, String> output = new ConcurrentHashMap<String, String>();

        TransferListener listener = new SimplexTransferListener(new ConsoleMavenTransferListener(
                new JLineMessageBuilderFactory(),
                new PrintWriter(System.out) {

                    @Override

            PacDataInputStream pacStream = new PacDataInputStream(new DataInputStream(new ByteArrayInputStream(data)));

            if ( data.length <= 8 )
                throw new PACDecodingException("Empty PAC");

            int bufferCount = pacStream.readInt();
            int version = pacStream.readInt();

            if ( version != PacConstants.PAC_VERSION ) {

        super.setUp();

        QueryFieldConfig queryFieldConfig = new QueryFieldConfig();
        queryFieldConfig.init();
        ComponentUtil.register(queryFieldConfig, "queryFieldConfig");

        QueryParser queryParser = new QueryParser();
        queryParser.init();
        ComponentUtil.register(queryParser, "queryParser");

        queryCommand = new TermQueryCommand();
    }

    @Override

        if (servers == null) {
            servers = new ArrayList<>();
        }

        return servers;
    }

    public ArtifactResolutionRequest setMirrors(List<Mirror> mirrors) {
        this.mirrors = mirrors;

        return this;
    }

    public List<Mirror> getMirrors() {
        if (mirrors == null) {
            mirrors = new ArrayList<>();
        }

        return mirrors;

    }

    public void addArtifact(Artifact artifact) {
        if (artifacts == null) {
            artifacts = new LinkedHashSet<>();
        }

        artifacts.add(artifact);
    }

    public Set<Artifact> getArtifacts() {
        if (artifacts == null) {
            artifacts = new LinkedHashSet<>();
        }

        return artifacts;
    }

    public void setArtifacts(Set<Artifact> artifacts) {

    return Arrays.asList(
        new Object[][] {
          {new MapIteratorCache<String, String>(new HashMap<String, String>())},
          {new MapIteratorCache<String, String>(new TreeMap<String, String>(nullsLast))},
          {new MapRetrievalCache<String, String>(new HashMap<String, String>())},
          {new MapRetrievalCache<String, String>(new TreeMap<String, String>(nullsLast))}
        });
  }

  @Before

        JavadocLexer lexer = new HtmlToXmlJavadocLexer(new BasicJavadocLexer(new JavadocScanner(rawCommentText)));
        DocBookBuilder nodes = new DocBookBuilder(document);
        final HtmlGeneratingTokenHandler handler = new HtmlGeneratingTokenHandler(nodes, document);
        handler.add(new HtmlElementTranslatingHandler(nodes, document));
        handler.add(new PreElementHandler(nodes, document));

    Comparable<?> endpoint() {
      throw new IllegalStateException("range unbounded on this side");
    }

    @Override
    boolean isLessThan(Comparable<?> value) {
      return true;
    }

    @Override
    BoundType typeAsLowerBound() {
      throw new IllegalStateException();
    }

    @Override
    BoundType typeAsUpperBound() {