testCases := []struct {
		ipList       []string
		sortedIPList []string
	}{
		// Default case of two ips one with higher octet moves
		// to the beginning of the list.
		{
			ipList:       []string{"127.0.0.1", "10.0.0.13"},
			sortedIPList: []string{"10.0.0.13", "127.0.0.1"},
		},
		// With multiple types of octet, chooses a higher octet.
		{
			ipList:       []string{"127.0.0.1", "172.0.21.1", "192.168.1.106"},

 * governing permissions and limitations under the License.
 */
package org.codelibs.fess.opensearch.client;

import static org.codelibs.core.stream.StreamUtil.split;

import org.codelibs.core.lang.StringUtil;
import org.codelibs.fesen.client.HttpClient;
import org.codelibs.fess.Constants;
import org.codelibs.fess.crawler.client.FesenClient;

	settings := map[string]string{}
	names := strings.Split(str, sep)

	var parsedNames []string
	for i := 0; i < len(names); i++ {
		s := names[i]
		for strings.HasSuffix(s, "\\") && i+1 < len(names) {
			i++
			s = s[:len(s)-1] + sep + names[i]
		}
		parsedNames = append(parsedNames, s)
	}

	for _, tag := range parsedNames {
		values := strings.Split(tag, ":")
		k := strings.TrimSpace(strings.ToUpper(values[0]))

    void testInheritedMethods() {
        // Given
        when(request.isResponseAsync()).thenReturn(true);
        when(request.getNext()).thenReturn(nextRequest);
        when(request.split()).thenReturn(nextRequest);
        when(request.allowChain(nextRequest)).thenReturn(true);
        when(request.createCancel()).thenReturn(nextRequest);
        when(request.size()).thenReturn(1024);

	if err != nil {
		t.Fatalf("go tool addr2line %v: %v\n%s", os.Args[0], err, string(out))
	}
	f := strings.Split(string(out), "\n")
	if len(f) < 3 && f[2] == "" {
		t.Fatal("addr2line output must have 2 lines")
	}
	funcname = f[0]
	pathAndLineNo := f[1]
	f = strings.Split(pathAndLineNo, ":")
	if runtime.GOOS == "windows" && len(f) == 3 {
		// Reattach drive letter.
		f = []string{f[0] + ":" + f[1], f[2]}
	}

    fun collectMirrorUrls(): Map<String, String> =
        // expected env var format: repo1_id:repo1_url,repo2_id:repo2_url,...
        System.getenv("REPO_MIRROR_URLS")?.ifBlank { null }?.split(',')?.associate { nameToUrl ->
            val (name, url) = nameToUrl.split(':', limit = 2)
            name to url
        } ?: emptyMap()

- Adheres to MinIO’s coding standards (e.g., Go style, error handling, testing).

PRs must flow smoothly through review to reach production. Large PRs should be split into smaller, manageable ones.

## Submitting PRs

1. **Title and Summary**:
   - Use a scannable title: `[Subsystem] Action Description #Issue` (e.g., `[IAM] Add role-based access control #567`).

     */
    @PostConstruct
    public void init() {
        StreamUtil.split(ComponentUtil.getFessConfig().getIndexFiletype(), "\n")
                .of(stream -> stream.filter(StringUtil::isNotBlank).forEach(s -> {
                    final String[] values = StringUtils.split(s, "=", 2);
                    if (values.length == 2) {
                        mimetypeMap.put(values[0], values[1]);

func NestedRelationName(prefix, name string) string {
	return prefix + nestedRelationSplit + name
}

// SplitNestedRelationName Split nested relationships to `[]string{"Manager","Company"}`
func SplitNestedRelationName(name string) []string {
	return strings.Split(name, nestedRelationSplit)
}

// JoinNestedRelationNames nested relationships like `Manager__Company`

	}
	return keyStr + k.Extension + func() string {
		if k.Compress {
			return compressExt
		}
		return ""
	}()
}

func getItemCount(k string) (count int, err error) {
	count = 1
	v := strings.Split(k, ":")
	if len(v) == 2 {
		return strconv.Atoi(v[0])
	}
	return count, err
}

func parseKey(k string) (key Key) {
	key.Name = k
	if strings.HasSuffix(k, compressExt) {
		key.Compress = true