fun absentValue() {
    assertThat(parse("permessage-deflate; server_max_window_bits")).isEqualTo(
      WebSocketExtensions(perMessageDeflate = true, unknownValues = true),
    )
  }

  @Test
  fun uppercase() {
    assertThat(parse("PERMESSAGE-DEFLATE; SERVER_NO_CONTEXT_TAKEOVER; CLIENT_NO_CONTEXT_TAKEOVER"))
      .isEqualTo(
        WebSocketExtensions(
          perMessageDeflate = true,

    // Ascii.equalsIgnoreCase(), but it is a signal that its documentation may need updating as
    // regards edge cases.

    // The Unicode point {@code 00df} is the lowercase form of sharp-S (ß), whose uppercase is "SS".
    assertEquals("PASSWORD", "pa\u00dfword".toUpperCase()); // [*]
    assertFalse("pa\u00dfword".equalsIgnoreCase("PASSWORD")); // [*]
    assertFalse(Ascii.equalsIgnoreCase("pa\u00dfword", "PASSWORD"));
  }

        UniAddress ua = new UniAddress(addr);
        // Act
        String called = ua.firstCalledName();
        // Assert
        assertEquals(expectedPrefix, called, "firstCalledName should return uppercase prefix or SMBSERVER_NAME");
    }

    @Test
    void nextCalledNameWithNbtAddressReturnsDelegateValue() {
        // Arrange
        NbtAddress nbtMock = mock(NbtAddress.class);

        assertEquals(16384, SMBUtil.readInt2(dst, descrEnd + 2));

        // Verify serverTypes
        assertEquals(serverTypes, SMBUtil.readInt4(dst, descrEnd + 4));

        // Verify domain (should be uppercase)
        int domainStart = descrEnd + 8;
        String writtenDomain = readNullTerminatedString(dst, domainStart);
        assertEquals(domain.toUpperCase(), writtenDomain);
    }

    @Test

    }

    @Nested
    @DisplayName("Domain and Host Fixup Tests")
    class FixupTests {

        @Test
        @DisplayName("Should fixup domain for uppercase NetBIOS name")
        void testFixupDomainWithNetBIOSName() {
            // Setup with uppercase server name
            setupReferralWithServer("SERVER");

            referralData.fixupDomain("example.com");

\#\u03B2  s:http h:example.org p:/foo/bar f:#\u03B2
data:text/html,test#test  s:data p:text/html,test f:#test

# Based on http://trac.webkit.org/browser/trunk/LayoutTests/fast/url/file.html

# Basic canonicalization, uppercase should be converted to lowercase
file:c:\\foo\\bar.html file:///tmp/mock/path s:file p:/c:/foo/bar.html

# Spaces should fail
\s\sFile:c|////foo\\bar.html  s:file p:/c:////foo/bar.html

# This should fail

          } else {
            evictToRecoverBytes(dynamicTableByteCount - maxDynamicTableByteCount)
          }
        }
      }
    }

  /**
   * An HTTP/2 response cannot contain uppercase header characters and must be treated as
   * malformed.
   */
  @Throws(IOException::class)
  fun checkLowercase(name: ByteString): ByteString {
    for (i in 0 until name.size) {

 *
 * This test includes tests from [Guava's](https://code.google.com/p/guava-libraries/)
 * MediaTypeTest.
 */
open class MediaTypeTest {
  open fun MediaType.charsetName(): String? = parameter("charset")?.uppercase()

  protected open fun parse(string: String): MediaType = string.toMediaTypeOrNull()!!

  protected open fun assertInvalid(
    string: String,
    exceptionMessage: String?,
  ) {

        val percentEncoded = Buffer()
        for (i in 0 until utf8.size) {
          percentEncoded
            .writeUtf8("%")
            .writeUtf8(ByteString.of(utf8[i]).hex().uppercase())
        }
        return percentEncoded.readUtf8()
      }
    },

    /** URLs that contain this character in this component are invalid.  */
    FORBIDDEN,

            when(mockInetAddress.getHostName()).thenReturn("h.ostname");
            UniAddress uniAddress = new UniAddress(mockInetAddress);
            // Dot at position 1, which is NOT > 1, so it doesn't substring, just uppercase
            assertEquals("H.OSTNAME", uniAddress.firstCalledName());
        }
    }

    @Nested
    @DisplayName("nextCalledName method tests")
    class NextCalledNameTests {