// to EqualFold. Note that strings.ToUpper and strings.ToLower
// do not have the desired property in some corner cases.
func ToFold(s string) string {
	// Fast path: all ASCII, no upper case.
	// Most paths look like this already.
	for i := 0; i < len(s); i++ {
		c := s[i]
		if c >= utf8.RuneSelf || 'A' <= c && c <= 'Z' {
			goto Slow
		}
	}
	return s

Slow:
	var b strings.Builder
	for _, r := range s {

import org.apache.maven.api.services.ModelProblemCollector;

/**
 * Handles normalization of a model. In this context, normalization is the process of producing a canonical
 * representation for models that physically look different but are semantically equivalent.
 *
 */
public interface ModelNormalizer {

    /**
     * Merges duplicate elements like multiple declarations of the same build plugin in the specified model.
     *

            start {
                assert registry.getAll(Number).sort() == [12, 123]
                assert registry.getAll(String).sort() == ["12", "123"]
            }
        }
    }

    def "cannot look up services while closing"() {
        given:
        def registry = new DefaultServiceRegistry()
        registry.add(Closeable, {
            instant.closing
            thread.blockUntil.lookupDone

		fmt.Fprintln(os.Stderr, err)
		os.Exit(2)
	}

	// This goroutine may receive a profiling signal while creating the C-owned
	// thread. If it does, the SetCgoTraceback handler will make the leaf end of
	// the stack look almost (but not exactly) like the stacks the test case is
	// trying to find. Attach a profiler label so the test can filter out those
	// confusing samples.

	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		cxml := crossDomainXML
		if globalServerCtxt.CrossDomainXML != "" {
			cxml = globalServerCtxt.CrossDomainXML
		}
		// Look for 'crossdomain.xml' in the incoming request.
		if r.URL.Path == crossDomainXMLEntity {
			// Write the standard cross domain policy xml.
			w.Write([]byte(cxml))
			// Request completed, no need to serve to other handlers.

     * @param fileStore used whenever the resource is effectively downloaded, to move it into a cache
     * @param additionalCandidates a list of candidates, found in a different place than the cache. When null, will only look into the cache. When not null, the checksum of the resource is going to be checked
     * @return a locally available resource, if found
     * @throws IOException whenever an error occurs when downloading of fetching from the cache

@REM Find the project basedir, i.e., the directory that contains the directory ".mvn".
@REM Fallback to current working directory if not found.

set "EXEC_DIR=%CD%"
set "WDIR=%EXEC_DIR%"

@REM Look for the --file switch and start the search for the .mvn directory from the specified
@REM POM location, if supplied.

set FILE_ARG=
:arg_loop
if "%~1" == "-f" (
  set "FILE_ARG=%~2"
  shift
  goto process_file_arg

  - ${dir1}""")
    }

    def "SDK not available when registry dir does not contain any versions that look like an SDK"() {
        def visitor = new TreeFormatter()
        def dir1 = badKitDir("sdk1", "10.0.10240.0", "10.0.10150.0")

        given:

		return fmt.Errorf("math/big: cannot unmarshal %q into a *big.Int", text)
	}
	return nil
}

// The JSON marshalers are only here for API backward compatibility
// (programs that explicitly look for these two methods). JSON works
// fine with the TextMarshaler only.

// MarshalJSON implements the [encoding/json.Marshaler] interface.
func (x *Int) MarshalJSON() ([]byte, error) {
	if x == nil {

			}
			// If the PVC is invalid, we don't count the volume because
			// there's no guarantee that it belongs to the running predicate.
			logger.V(5).Info("Unable to look up PVC info", "pod", klog.KObj(pod), "PVC", klog.KRef(pod.Namespace, pvcName))
			continue
		}

		// The PVC for an ephemeral volume must be owned by the pod.
		if isEphemeral {