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 {

}

// ParsePort parses a string representing a TCP port.
// If the string is not a valid representation of a TCP port, ParsePort returns an error.
func ParsePort(port string) (int, error) {
	portInt, err := netutils.ParsePort(port, true)
	if err == nil && (1 <= portInt && portInt <= 65535) {
		return portInt, nil
	}

	}
	return m, nil
}

// parseText parses the output of a single call to TextHandler.Handle.
// It can parse the output of the tests in this package,
// but it doesn't handle quoted keys or values.
// It doesn't need to handle all cases, because slogtest deliberately
// uses simple inputs so handler writers can focus on testing
// handler behavior, not parsing.
func parseText(bs []byte) (map[string]any, error) {

}

func TestParsePort(t *testing.T) {
	// The following test cases are cribbed from the strconv
	for _, tt := range parsePortTests {
		if port, needsLookup := parsePort(tt.service); port != tt.port || needsLookup != tt.needsLookup {
			t.Errorf("parsePort(%q) = %d, %t; want %d, %t", tt.service, port, needsLookup, tt.port, tt.needsLookup)
		}
	}

		// 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
}

// Copyright 2016 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package net

// parsePort parses service as a decimal integer and returns the
// corresponding value as port. It is the caller's responsibility to
// parse service as a non-decimal integer when needsLookup is true.
//
// Some system resolvers will return a valid port number when given a number

    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',