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

package syntax

import (
	"fmt"
	"strings"
	"testing"
	"unicode"
)

type parseTest struct {
	Regexp string
	Dump   string
}

var parseTests = []parseTest{
	// Base cases
	{`a`, `lit{a}`},
	{`a.`, `cat{lit{a}dot{}}`},
	{`a.b`, `cat{lit{a}dot{}lit{b}}`},
	{`ab`, `str{ab}`},
	{`a.b.c`, `cat{lit{a}dot{}lit{b}dot{}lit{c}}`},

    final static String XML_TEXT = '<wb-resource deploy-path="/" source-path="src/main/webapp"/>'

    def canReadFromXml() {
        when:
        WbResource wbResource = new WbResource(new XmlParser().parseText(XML_TEXT))

        then:
        wbResource == createWbResource()
    }

    def canWriteToXml() {
        Node rootNode = new Node(null, 'root')

        when:

class OutputTest extends Specification {
    final static String XML_TEXT = '<classpathentry kind="output" path="somePath"/>'

    def canReadFromXml() {
        when:
        Output output = new Output(new XmlParser().parseText(XML_TEXT))

        then:
        output == createOutput()
    }

    def canWriteToXml() {
        Node rootNode = new Node(null, 'root')

        when:
        createOutput().appendNode(rootNode)

class LatestNightlyBuildDeterminer {
    private static String latestNightlyVersion

    static String getLatestNightlyVersion() {
        if (latestNightlyVersion == null) {
            def version = new JsonSlurper().parseText(new URL("https://services.gradle.org/versions/nightly").text)
            if (version.empty) {
                throw new GradleException("Cannot determine latest nightly wrapper!")
            }

    final static String XML_TEXT = '<property name="java-output-path" value="/build/classes"/>'

    def canReadFromXml() {
        when:
        WbProperty wbProperty = new WbProperty(new XmlParser().parseText(XML_TEXT))

        then:
        wbProperty == createWbProperty()
    }

    def canWriteToXml() {
        Node rootNode = new Node(null, 'root')

        when:

}

func buildExtAuthzHTTP(push *model.PushContext,
	config *meshconfig.MeshConfig_ExtensionProvider_EnvoyExternalAuthorizationHttpProvider,
) (*builtExtAuthz, error) {
	var errs error
	port, err := parsePort(config.Port)
	if err != nil {
		errs = multierror.Append(errs, err)
	}
	hostname, cluster, err := model.LookupCluster(push, config.Service, port)
	if err != nil {
		model.IncLookupClusterFailures("authz")

                    </accessrules>
                </classpathentry>'''

    def canReadFromXml() {
        when:
        ProjectDependency projectDependency = new ProjectDependency(new XmlParser().parseText(XML_TEXT))

        then:
        projectDependency == createProjectDependency()
    }

    def canWriteToXml() {
        Node rootNode = new Node(null, 'root')

        when:

                    <dependency-type>uses</dependency-type>
                </dependent-module>'''

    def canReadFromXml() {
        when:
        WbDependentModule wbDependentModule = new WbDependentModule(new XmlParser().parseText(XML_TEXT))

        then:
        wbDependentModule == createWbDependentModule()
    }

    def canWriteToXml() {
        Node rootNode = new Node(null, 'root')

        when:

                    </accessrules>
                </classpathentry>'''

    def canReadFromXml() {
        when:
        Container container = new Container(new XmlParser().parseText(XML_TEXT))

        then:
        container == createContainer()
    }

    def canWriteToXml() {
        Node rootNode = new Node(null, 'root')

        when:

        this.file = file
        this.path = path
        if (!file.exists()) {
            return
        }

        text = file.text
        def xml = new XmlParser().parseText(text)

        groupId = xml.groupId[0]?.text()
        artifactId = xml.artifactId[0]?.text()

        def versioning = xml.versioning[0]

        lastUpdated = versioning.lastUpdated[0]?.text()