final String[] parts = localeStr.split("_", 3);

        switch (parts.length) {
        case 1:
            return new Locale(parts[0]);
        case 2:
            return new Locale(parts[0], parts[1]);
        case 3:
            return new Locale(parts[0], parts[1], parts[2]);
        default:
            return LocaleUtil.getDefault();
        }
    }

 *   while (true) {
 *     val part = multipartReader.nextPart() ?: break
 *     process(part.headers, part.body)
 *   }
 * }
 * ```
 *
 * Note that [nextPart] will skip any unprocessed data from the preceding part. If the preceding
 * part is particularly large or if the underlying source is particularly slow, the [nextPart] call
 * may be slow!
 *

   */
  private static boolean validateSyntax(List<String> parts) {
    int lastIndex = parts.size() - 1;

    // Validate the last part specially, as it has different syntax rules.

    if (!validatePart(parts.get(lastIndex), true)) {
      return false;
    }

    for (int i = 0; i < lastIndex; i++) {
      String part = parts.get(i);
      if (!validatePart(part, false)) {
        return false;
      }
    }

import org.gradle.util.GradleVersion
import java.io.File


fun bumpPatchVersion(version: String): String {
    val parts = version.split(".")
    require(parts.size == 3 && parts.all { it.toIntOrNull() != null }) {
        "Version '$version' is not a valid x.y.z version."
    }
    return "${parts[0]}.${parts[1]}.${parts[2].toInt() + 1}"
}

      return specialCases.get(constantName);
    }
    List<String> parts = new ArrayList<>();
    for (String part : Splitter.on('_').split(constantName)) {
      if (!uppercaseAcronyms.contains(part)) {
        part = part.charAt(0) + Ascii.toLowerCase(part.substring(1));
      }
      parts.add(part);
    }
    return Joiner.on('-').join(parts);
  }

            # (a subdirectory under docs_src/<topic>/)
            parts = py_file.relative_to(docs_src_path).parts
            if len(parts) > 2:
                # File is inside a sub-package like docs_src/topic/app_xxx/...
                package_root = docs_src_path / parts[0] / parts[1]
                used_package_dirs.add(package_root)
    removed = 0

        // This could be enhanced with proper version parsing if needed
        try {
            String[] parts = modelVersion.split("\\.");
            if (parts.length >= 2) {
                int major = Integer.parseInt(parts[0]);
                int minor = Integer.parseInt(parts[1]);

                if (major > 4) {
                    return true;
                }

		// The general form of a test input line is:
		//	// comment
		//	INST args [// printed form] [// hex encoding]
		parts := strings.Split(line, "//")
		printed := strings.TrimSpace(parts[0])
		if printed == "" || strings.HasSuffix(printed, ":") { // empty or label
			continue
		}
		seq++

		var hexes string
		switch len(parts) {
		default:
			t.Errorf("%s:%d: unable to understand comments: %s", input, lineno, line)
		case 1:

  private static void checkResult(
      Joiner joiner, Iterable<? extends @Nullable Integer> parts, String expected) {
    assertThat(joiner.join(parts)).isEqualTo(expected);
    assertThat(joiner.join(parts.iterator())).isEqualTo(expected);

    StringBuilder sb1FromIterable = new StringBuilder().append('x');
    joiner.appendTo(sb1FromIterable, parts);
    assertThat(sb1FromIterable.toString()).isEqualTo("x" + expected);

		return false
	}

	base := strings.SplitN(strings.TrimSpace(version), "-", 2)[0]
	parts := strings.Split(base, ".")
	if len(parts) < 2 {
		return false
	}

	currentMajor, err := strconv.Atoi(parts[0])
	if err != nil {
		return false
	}

	currentMinor, err := strconv.Atoi(parts[1])
	if err != nil {
		return false
	}

	if currentMajor != major {