private static final String UPPER = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";

  public void testToLowerCase() {
    assertEquals(LOWER, Ascii.toLowerCase(UPPER));
    assertSame(LOWER, Ascii.toLowerCase(LOWER));
    assertEquals(IGNORED, Ascii.toLowerCase(IGNORED));
    assertEquals("foobar", Ascii.toLowerCase("fOobaR"));
  }

  public void testToUpperCase() {
    assertEquals(UPPER, Ascii.toUpperCase(LOWER));

    }

    Alphabet lowerCase() {
      if (!hasUpperCase()) {
        return this;
      }
      checkState(!hasLowerCase(), "Cannot call lowerCase() on a mixed-case alphabet");
      char[] lowerCased = new char[chars.length];
      for (int i = 0; i < chars.length; i++) {
        lowerCased[i] = Ascii.toLowerCase(chars[i]);
      }
      Alphabet lowerCase = new Alphabet(name + ".lowerCase()", lowerCased);

    assertThat(base16().upperCase()).isSameInstanceAs(base16());
  }

  public void testBase16LowerCase() {
    BaseEncoding lowerCase = base16().lowerCase();
    assertThat(lowerCase).isNotSameInstanceAs(base16());
    assertThat(lowerCase).isSameInstanceAs(base16().lowerCase());
    testEncodingWithCasing(lowerCase, "foobar", "666f6f626172");
  }

  public void testBase16IgnoreCase() {
    BaseEncoding ignoreCase = base16().ignoreCase();

    assertThat(base16().upperCase()).isSameInstanceAs(base16());
  }

  public void testBase16LowerCase() {
    BaseEncoding lowerCase = base16().lowerCase();
    assertThat(lowerCase).isNotSameInstanceAs(base16());
    assertThat(lowerCase).isSameInstanceAs(base16().lowerCase());
    testEncodingWithCasing(lowerCase, "foobar", "666f6f626172");
  }

  public void testBase16IgnoreCase() {
    BaseEncoding ignoreCase = base16().ignoreCase();

  }

  /**
   * If the argument is a {@linkplain #isLowerCase(char) lowercase ASCII character}, returns the
   * uppercase equivalent. Otherwise returns the argument.
   */
  public static char toUpperCase(char c) {
    return isLowerCase(c) ? (char) (c ^ CASE_MASK) : c;
  }

  /**
   * Indicates whether {@code c} is one of the twenty-six lowercase ASCII alphabetic characters

 */

package gradlebuild.basics

import java.util.Locale

fun String.toLowerCase(): String =
    lowercase(Locale.US)

fun String.toUpperCase(): String =
    uppercase(Locale.US)

fun String.capitalize(): String =
    replaceFirstChar { it.uppercase(Locale.US) }

fun String.decapitalize(): String =

  }

  /**
   * If the argument is a {@linkplain #isLowerCase(char) lowercase ASCII character}, returns the
   * uppercase equivalent. Otherwise returns the argument.
   */
  public static char toUpperCase(char c) {
    return isLowerCase(c) ? (char) (c ^ CASE_MASK) : c;
  }

  /**
   * Indicates whether {@code c} is one of the twenty-six lowercase ASCII alphabetic characters

package common

enum class Arch(val suffix: String, val nameOnLinuxWindows: String, val nameOnMac: String) {
    AMD64("64bit", "amd64", "x86_64"),
    AARCH64("aarch64", "aarch64", "aarch64");

    fun asName() = name.lowercase().toCapitalized()
}

enum class Os(
    val agentRequirement: String,
    val androidHome: String,
    val jprofilerHome: String,
    val perfTestWorkingDir: String = "%teamcity.build.checkoutDir%",

  val typeSubtype: MatchResult =
    TYPE_SUBTYPE.matchAtPolyfill(this, 0)
      ?: throw IllegalArgumentException("No subtype found for: \"$this\"")
  val type = typeSubtype.groupValues[1].lowercase()
  val subtype = typeSubtype.groupValues[2].lowercase()

  val parameterNamesAndValues = mutableListOf<String>()
  var s = typeSubtype.range.last + 1
  while (s < length) {
    val parameter = PARAMETER.matchAtPolyfill(this, s)

  @get:JvmName("scheme") val scheme: String,
  authParams: Map<String?, String>,
) {
  /**
   * Returns the auth params, including [realm] and [charset] if present, but as
   * strings. The map's keys are lowercase and should be treated case-insensitively.
   */
  @get:JvmName("authParams")
  val authParams: Map<String?, String>

  /** Returns the protection space. */
  @get:JvmName("realm")
  val realm: String?