//
// which is in turn shorthand for:
//
//	w.Write(p.Printer().HTML(p.Parser().Parse(text)))
//
// If words may be non-nil, the longer replacement is:
//
//	parser := p.Parser()
//	parser.Words = words
//	w.Write(p.Printer().HTML(parser.Parse(d)))
func ToHTML(w io.Writer, text string, words map[string]string) {
	p := new(Package).Parser()
	p.Words = words
	d := p.Parse(text)
	pr := new(comment.Printer)

        getBuildDependencies() >> taskDependency
    }

    NotationParser<Object, MavenArtifact> parser

    def "setup"() {
        def fileResolver = Stub(FileResolver) {
            asNotationParser() >> fileNotationParser
            resolve(_) >> { Object path -> fileNotationParser.parseNotation(path) }
        }
        parser = new MavenArtifactNotationParserFactory(instantiator, fileResolver, TestFiles.taskDependencyFactory()).create()

        GsaConfigParser parser = new GsaConfigParser();
        try (InputStream is = ResourceUtil.getResourceAsStream("data/gsaconfig.xml")) {
            parser.parse(new InputSource(is));
        }
        parser.getWebConfig().ifPresent(c -> {
            System.out.println(c.toString());
        }).orElse(() -> fail());
        parser.getFileConfig().ifPresent(c -> {

            XMLStreamReader parser = new WstxInputFactory().createXMLStreamReader(is);
            if (parser.nextTag() == XMLStreamReader.START_ELEMENT
                    && parser.getLocalName().equals("project")) {
                for (int i = 0; i < parser.getAttributeCount(); i++) {
                    if ("root".equals(parser.getAttributeLocalName(i))) {

import org.gradle.nativeplatform.NativeLibraryRequirement
import spock.lang.Specification

class NativeDependencyNotationParserTest extends Specification {
    def parser = NativeDependencyNotationParser.parser()
    def requirement = Mock(NativeLibraryRequirement)
    def library = Mock(NativeLibrarySpec)
    def project = Mock(ProjectInternal)

    def "uses shared variant of library"() {
        when:

    @TaskAction
    public void process() {
        MutableDataSet options = new MutableDataSet();
        options.set(Parser.EXTENSIONS, Collections.singletonList(TablesExtension.create()));
        Parser parser = Parser.builder(options).build();
        HtmlRenderer renderer = HtmlRenderer.builder(options).build();
        File markdownFile = getMarkdownFile().get().getAsFile();

    private static final ObjectParser<StoredLtrQueryBuilder, Void> PARSER;

    static {
        PARSER = new ObjectParser<>(NAME);
        PARSER.declareString(StoredLtrQueryBuilder::modelName, MODEL_NAME);
        PARSER.declareString(StoredLtrQueryBuilder::featureSetName, FEATURESET_NAME);
        PARSER.declareString(StoredLtrQueryBuilder::storeName, STORE_NAME);

    return compare(args)


def get_parser():
    parser = argparse.ArgumentParser(
        description="Compare kubernetes yaml files")

    parser.add_argument("orig")
    parser.add_argument("new")
    parser.add_argument("--ignore-namespace", action="store_true", default=False,
                        help="Ignore namespace during comparison")
    parser.add_argument("--ignore-labels", action="store_true", default=False,

            class MockIt {
                void call() {
                }
            }
        """

        file("src/main/groovy/Caller.groovy") << """
            class Caller {
                private MockIt callable

                Caller(MockIt callable) {
                    this.callable = callable
                }

                void call() {
                   callable.call()

        thrown(UnsupportedNotationException)

        when:
        parser("").parseNotation(null)

        then:
        thrown(UnsupportedNotationException)
    }

    def "single parser understands String notation"() {
        //just smoke testing the single parser, it is covered in multiParser, too.
        when:
        def v = parser("").parseNotation("org.foo:bar:1.0")

        then: