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

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

	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.

}

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")

                .addArguments("--info")
                .run()
        }

        then:
        thrown(BuildException)
        def problems = listener.problems.collect { new JsonSlurper().parseText(it.descriptor.json) }
        problems.size() == 0
    }

    class ProblemProgressListener implements ProgressListener {

        List<?> problems = []
        @Override

                    )
                )
            )
        )
    }

    private
    fun jsonModelFor(builder: JsonModelWriter.() -> Unit): Map<String, Any> =
        JsonSlurper().parseText(
            StringWriter().also {
                JsonModelWriter(it).apply(builder)
            }.toString()
        ).uncheckedCast()

	goDebug := netdns.Value()
	parsePart := func(s string) {
		if s == "" {
			return
		}
		if '0' <= s[0] && s[0] <= '9' {
			debugLevel, _, _ = dtoi(s)
		} else {
			dnsMode = s
		}
	}
	if i := bytealg.IndexByteString(goDebug, '+'); i != -1 {
		parsePart(goDebug[:i])
		parsePart(goDebug[i+1:])
		return
	}
	parsePart(goDebug)
	return
}

	if err != nil {
		t.Fatalf("couldn't parse certificate and key: %v", err)
	}

	parsedCert, err := x509.ParseCertificate(certPair.Certificate[0])
	if err != nil {
		t.Fatalf("couldn't parse certificate: %v", err)
	}

	return parsedCert, certPair.PrivateKey
}

func TestCreateKeyAndCSR(t *testing.T) {
	dir, err := os.MkdirTemp("", t.Name())
	if err != nil {

	if r.err != nil {
		return r.err
	}

	if info.fset == nil {
		return nil
	}

	// Parse file header & record imports.
	info.parsed, info.parseErr = parser.ParseFile(info.fset, info.name, info.header, parser.ImportsOnly|parser.ParseComments)
	if info.parseErr != nil {
		return nil
	}

	hasEmbed := false
	for _, decl := range info.parsed.Decls {
		d, ok := decl.(*ast.GenDecl)
		if !ok {
			continue

    List<BuildScanConfig.Attributes> allAttributes(String output) {
        output.findAll("buildScan\\.attributes: \\{(.+)\\}\\\n") {
            it[1]
        }.collect {
            def map = new JsonSlurper().parseText("{" + it + "}")
            new BuildScanConfig.Attributes() {
                @Override
                boolean isRootProjectHasVcsMappings() {
                    return false
                }