"truncate20_filter",
            "lowercase",
            "arabic_stop",
            "arabic_normalization",
            "arabic_keywords",
            "arabic_override",
            "arabic_stemmer"
          ]
        },
        "armenian_analyzer": {
          "tokenizer":  "standard",
          "filter": [
            "truncate20_filter",
            "lowercase",
            "armenian_stop",

  }

  /**
   * 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

    }

    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();

            assertEquals(TIME_HI_AND_VERSION, uuid.time_hi_and_version,
                    "time_hi_and_version should be parsed correctly with lowercase hex");
            assertEquals(CLOCK_SEQ_HI_AND_RESERVED, uuid.clock_seq_hi_and_reserved,
                    "clock_seq_hi_and_reserved should be parsed correctly with lowercase hex");

        }
    }
}

fun javaHome(
    jvm: Jvm,
    os: Os,
    arch: Arch = Arch.AMD64,
) = "%${if (os == Os.ALPINE) "linux" else os.name.lowercase()}.${
    jvm.version.name.lowercase().replace(
        "_",
        "",
    )
}.${jvm.vendor.name.lowercase()}.${arch.suffix}%"

fun BuildType.paramsForBuildToolBuild(
    buildJvm: Jvm = BuildToolBuildJvm,
    os: Os,
    arch: Arch = Arch.AMD64,
) {

        }
        return Collections.emptyList();
    }

    /**
     * Converts a string to lowercase.
     *
     * @param term The string to convert.
     * @return The lowercase string.
     */
    private String toLowerCase(final String term) {
        return term != null ? term.toLowerCase(Locale.ROOT) : term;
    }

        assertNotNull(testBuilder.initialSettings);
        assertTrue(testBuilder.initialSettings.isEmpty());
    }

    @Test
    public void testSetSettingsIndexName() {
        // Test setting index name with lowercase conversion
        SuggestSettingsBuilder result = builder.setSettingsIndexName("TEST_INDEX");
        assertEquals(builder, result); // Test method chaining
        assertEquals("test_index", builder.settingsIndexName);

      }

      override operator fun get(url: HttpUrl): String {
        val host = url.host
        return host.substring(1, host.length - 5).lowercase()
      }

      override fun canonicalize(s: String): String = s.lowercase()
    },

    PATH {
      override fun urlString(value: String): String = "http://example.com/a${value}z/"

      override fun encodedValue(url: HttpUrl): String {

            // Expected
            assertTrue(e.getMessage().contains("INVALID"));
        }

        try {
            CrawlerStatus.valueOf("initializing"); // lowercase
            fail("Should throw IllegalArgumentException for lowercase value");
        } catch (IllegalArgumentException e) {
            // Expected
            assertTrue(e.getMessage().contains("initializing"));
        }

        try {