assertTrue(result.startsWith("NtlmChallenge[challenge=0x"));
            assertTrue(result.endsWith(",dc=SERVER123]"));

            // Hexdump.toHexString with size = length * 2 produces 8 uppercase hex chars
            // The hex should be "010203FF"
            assertTrue(result.contains("010203FF"));
        }

        @Test
        @DisplayName("toString with empty challenge array")

    void testCaseSensitivity() {
        // Given
        String upperCase = "SERVER";
        String lowerCase = "server";
        String mixedCase = "Server";

        // Test different cases
        when(mockNetbiosName.getName()).thenReturn(upperCase);
        assertEquals(upperCase, mockNetbiosName.getName());

        when(mockNetbiosName.getName()).thenReturn(lowerCase);

            assertArrayEquals(NODE, uuid.node, "node array should match");
        }

        @Test
        @DisplayName("Constructor with valid uppercase UUID string should parse correctly")
        void testConstructorWithString() {
            // Act
            UUID uuid = new UUID(VALID_UUID_STRING);

            // Assert

        ScriptEngine upperCase = scriptEngineFactory.getScriptEngine("TESTENGINE");
        ScriptEngine mixedCase = scriptEngineFactory.getScriptEngine("TestEngine");

        assertNotNull(lowerCase);
        assertNotNull(upperCase);
        assertNotNull(mixedCase);
        assertEquals(testScriptEngine, lowerCase);
        assertEquals(testScriptEngine, upperCase);
        assertEquals(testScriptEngine, mixedCase);

            ).joinToString(separator = " ")
        steps {
            gradleWrapper {
                name =
                    "FLAKY_TEST_QUARANTINE_${testCoverage.testType.name.uppercase()}_${testCoverage.testJvmVersion.name.uppercase()}"
                val testTaskName =
                    if (testCoverage.testType ==
                        TestType.ISOLATED_PROJECTS
                    ) {

                                val performanceTestType = PerformanceTestType.valueOf(key.uppercase())
                                performanceTestType to
                                    value
                                        .map {
                                            Os.valueOf(it.uppercase(Locale.US))
                                        }.toSet()
                            }.toMap()

		<c:forEach var="fieldData" items="${facetResponse.fieldList}">
			<c:if test="${fieldData.name == 'label' && fieldData.valueCountMap.size() > 0}">
				<ul class="list-group mb-2">
					<li class="list-group-item text-uppercase"><la:message key="labels.facet_label_title" /></li>
					<c:forEach var="countEntry" items="${fieldData.valueCountMap}">
						<c:if test="${countEntry.value != 0 && fe:labelexists(countEntry.key)}">

  /** A bit mask which selects the bit encoding ASCII character case. */
  private static final char CASE_MASK = 0x20;

  /**
   * Returns a copy of the input string in which all {@linkplain #isUpperCase(char) uppercase ASCII
   * characters} have been converted to lowercase. All other characters are copied without
   * modification.
   */
  public static String toLowerCase(String string) {
    int length = string.length();

 * limitations under the License.
 */

package gradlebuild.basics

import java.util.Locale

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

fun String.decapitalize(): String =

 *       uppercase, hexadecimal representation of the byte value.
 * </ul>
 *
 * <p>For performance reasons the only currently supported character encoding of this class is
 * UTF-8.
 *
 * <p><b>Note:</b> This escaper produces <a
 * href="https://url.spec.whatwg.org/#percent-encode">uppercase</a> hexadecimal sequences.
 *
 * @author David Beaumont
 * @since 15.0
 */