verbose = args.verbose
  build_log_path = os.path.expandvars(args.build_log)
  links = parse_log(build_log_path, verbose=verbose)

  if args.xml_out_path:
    output_path = os.path.expandvars(args.xml_out_path)
    create_xml_file(links, output_path, verbose=verbose)
  if args.print:
    print_invocation_results(links)


if __name__ == '__main__':

        when:
        def link = renderer.link(type('java.util.List', true), listener)

        then:
        format(link) == '<classname><ulink url="https://docs.oracle.com/javase/javaVersion/docs/api/java/util/List.html"><classname>List</classname></ulink>[]</classname>'
    }

    def rendersLinkToPrimitiveType() {
        when:
        def link = renderer.link(type('boolean'), listener)

        then:

        }
        phase.links().forEach(link -> {
            if (link.pointer().type() == Lifecycle.Pointer.Type.PROJECT) {
                if (link.kind() == Lifecycle.Link.Kind.AFTER) {
                    graph.addEdge(graph.addVertex(link.pointer().phase()), ep0);
                } else {
                    graph.addEdge(ep3, graph.addVertex(BEFORE + link.pointer().phase()));
                }
            }

    if links:
        message += "\n\n### Modified Pages\n\n"
        for link in links:
            message += f"* {link.preview_link}"
            message += f" - ([before]({link.previous_link}))"
            if link.en_link:
                message += f" - ([English]({link.en_link}))"
            message += "\n"

    print(message)
    issue = use_pr.as_issue()

    public void setDomain(final String domain) {
        this.domain = domain;
    }

    @Override
    public String getLink() {
        return this.link;
    }

    @Override
    public void setLink(final String link) {
        this.link = link;
    }

    /**
     * @return the key
     */
    @Override
    public String getKey() {
        return this.key;
    }

    /**

            }
            roots.remove(root);
            links = null;
        }

        if (links == null) {
            log.trace("Loadings roots");
            final String refServerName = domain;
            dr = fetchRootReferral(tf, domain, root, refServerName);
            links = cacheRootReferral(tf, domain, root, roots, dr, links);
        } else if (links instanceof NegativeCacheEntry) {

                 */
                CacheEntry links = (CacheEntry) roots.get(root);
                if (links != null && now > links.expiration) {
                    roots.remove(root);
                    links = null;
                }

                if (links == null) {
                    trans = getDc(domain, auth);
                    if (trans == null) {
                        return null;

            public void visit(final Link link) {
                final String destination = link.getDestination();
                if (StringUtil.isNotBlank(destination)) {
                    links.add(destination);
                }
                super.visit(link);
            }
        });

        if (!links.isEmpty()) {
            extractData.putValues("links", links.toArray(new String[0]));
        }
    }

    this.lastEntry = ENDPOINT;
    if (links != null) {
      Arrays.fill(links, 0, size(), 0);
    }
    super.clear();
  }

  /*
   * For discussion of the safety of the following methods, see the comments near the end of
   * CompactHashMap.
   */

  private long[] requireLinks() {
    return requireNonNull(links);
  }

  private long link(int i) {
    return requireLinks()[i];
  }

    }

    /**
     * A link from a phase to another phase, consisting of a type which can be
     * {@link Kind#BEFORE} or {@link Kind#AFTER}, and a {@link Pointer} to
     * another phase.
     */
    interface Link {
        enum Kind {
            BEFORE,
            AFTER
        }

        /**
         * Returns the kind of link (BEFORE or AFTER).
         *