"istio.io/istio/pkg/test"
)

// Parse the given template content.
func Parse(tpl string) (*template.Template, error) {
	t := template.New("test template")
	return t.Funcs(sprig.TxtFuncMap()).Parse(tpl)
}

// ParseOrFail calls Parse and fails tests if it returns error.
func ParseOrFail(t test.Failer, tpl string) *template.Template {
	t.Helper()
	tpl2, err := Parse(tpl)
	if err != nil {

}

// Part is a single-part yaml source, along with its descriptor.
type Part struct {
	Contents   string
	Descriptor Descriptor
}

// Parse parses the given multi-part yaml text, and returns as Parts.
func Parse(yamlText string) ([]Part, error) {
	splitContent := SplitString(yamlText)
	parts := make([]Part, 0, len(splitContent))
	for _, part := range splitContent {
		if len(part) > 0 {

            spfactory.setFeature(Constants.FEATURE_EXTERNAL_PARAMETER_ENTITIES, false);
            // create a sax parser
            final SAXParser parser = spfactory.newSAXParser();
            try {
                parser.setProperty(XMLConstants.ACCESS_EXTERNAL_DTD, StringUtil.EMPTY);
                parser.setProperty(XMLConstants.ACCESS_EXTERNAL_SCHEMA, StringUtil.EMPTY);
            } catch (final Exception e) {

// Copyright 2022 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 cpu

import "strconv"

// parseRelease parses a dot-separated version number. It follows the semver
// syntax, but allows the minor and patch versions to be elided.
//
// This is a copy of the Go runtime's parseRelease from
// https://golang.org/cl/209597.

Nathan Mittler <******@****.***> 1645655146 -0800

Jes Cok <******@****.***> 1714824795 +0800

	// Convert proto to json and then parse into struct
	jsonText, err := protomarshal.MarshalIndent(message, "  ")
	if err != nil {
		return nil, fmt.Errorf("failed to convert proto to JSON: %v", err)
	}
	var parsed any
	err = json.Unmarshal(jsonText, &parsed)
	if err != nil {
		return nil, fmt.Errorf("failed to parse into JSON struct: %v", err)
	}
	return parsed, nil
}

	if err != nil {
		return types.NewErr("URL parse error during conversion from string: %v", err)
	}
	// We must parse again with Parse since ParseRequestURI incorrectly parses URLs that contain a fragment
	// part and will incorrectly append the fragment to either the path or the query, depending on which it was adjacent to.
	u, err := url.Parse(s)
	if err != nil {
		// Errors are not expected here since Parse is a more lenient parser than ParseRequestURI.

		if zone == "" {
			return Addr{}, fmt.Errorf("netaddr.ParseIP(%q): no zone after zone specifier", s)
		}
	default:
		return Addr{}, fmt.Errorf("netaddr.ParseIP(%q): too many zone specifiers", s) // TODO: less specific?
	}

	// IPv4 by itself is easy to do in a helper.
	if strings.Count(s, ":") == 0 {
		if zone != "" {
			return Addr{}, fmt.Errorf("netaddr.ParseIP(%q): IPv4 addresses cannot have a zone", s)
		}

    \) -name '*.go'
}

# find files using net.ParseIP()
netparseip_matches=$(find_files | xargs grep -nE "net.ParseIP\(.*\)" 2>/dev/null) || true
if [[ -n "${netparseip_matches}" ]]; then
  echo "net.ParseIP reject leading zeros in the dot-decimal notation of IPv4 addresses since golang 1.17:" >&2
  echo "${netparseip_matches}" >&2
  echo >&2
  echo "Use k8s.io/utils/net ParseIPSloppy() to parse IP addresses. Kubernetes #100895" >&2
  echo >&2