t.Errorf("failed to read %s file: %v", caCertFile, err)
	}
	return parseCert(t, certBytes)
}

func parseCert(t framework.TestContext, certBytes []byte) *x509.Certificate {
	parsedCert, err := util.ParsePemEncodedCertificate(certBytes)
	if err != nil {
		t.Errorf("failed to parse certificate pem file: %v", err)
	}
	return parsedCert

		t.Errorf("ParsePort(127.0.0.1) => Got %d, want 0", port)
	}
	if port := model.ParsePort("[::1]:3000"); port != 3000 {
		t.Errorf("ParsePort([::1]:3000) => Got %d, want 3000", port)
	}
	if port := model.ParsePort("::1"); port != 0 {
		t.Errorf("ParsePort(::1) => Got %d, want 0", port)
	}
	if port := model.ParsePort("[2001:4860:0:2001::68]:3000"); port != 3000 {

		// whether the kernel is Solaris or illumos.
		ver = un.Release[:]
	}

	parseNext := func() (n int) {
		for i, c := range ver {
			if c == '.' {
				ver = ver[i+1:]
				return
			}
			if '0' <= c && c <= '9' {
				n = n*10 + int(c-'0')
			}
		}
		ver = nil
		return
	}

	major = parseNext()
	minor = parseNext()

	return
}

    def canReadFromXml() {
        when:
        Facet facet = new Facet(new XmlParser().parseText(XML_TEXT))

        then:
        facet == createFacet()
    }

    def canReadFixedFromXml() {
        when:
        Facet facet = new Facet(new XmlParser().parseText(FIXED_XML_TEXT))

        then:
        facet == createFixedFacet()
    }

    def canWriteToXml() {

	return validatePortList("excludeOutboundPorts", ports)
}

// validateStatusPort validates the statusPort parameter
func validateStatusPort(port string) error {
	if _, e := parsePort(port); e != nil {
		return fmt.Errorf("excludeInboundPorts invalid: %v", e)
	}
	return nil
}

// validateUInt32 validates that the given annotation value is a positive integer.

    def "can generate cross version json data"() {
        when:
        generator.render(mockCrossVersionHistory(), writer)

        then:
        assert new JsonSlurper().parseText(writer.toString()) == [
            executionLabels: [
                [
                    id: '1450575490',
                    branch: 'master',
                    date: '1970-01-01',

// 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!")
            }