package okhttp3.internal.http2

import okio.ByteString
import okio.ByteString.Companion.encodeUtf8

/** HTTP header: the name is an ASCII string, but the value can be UTF-8. */
data class Header(
  /** Name in case-insensitive ASCII encoding. */
  @JvmField val name: ByteString,
  /** Value in UTF-8 encoding. */
  @JvmField val value: ByteString,
) {
  @JvmField val hpackSize = 32 + name.size + value.size

            )
        else:
            return None

    def _create_credentials_fetcher(self):
        method = self.METHOD

        def fetch_credentials():
            # HTTP headers are case insensitive filter out
            # all duplicate headers and pick one.
            headers = {}
            headers['content-type'] = 'application/x-www-form-urlencoded'
            headers['authorization'] = urllib3.make_headers(

    }

    /**
     * Retrieves related queries for a given search term.
     * The search is performed using the current virtual host context and
     * the query term is converted to lowercase for case-insensitive matching.
     *
     * @param query the search term to find related queries for
     * @return an array of related query strings, or empty array if none found
     */

But a variable like `user-agent` is invalid in Python.

So, by default, `Header` will convert the parameter names characters from underscore (`_`) to hyphen (`-`) to extract and document the headers.

Also, HTTP headers are case-insensitive, so, you can declare them with standard Python style (also known as "snake_case").

 *   <li>Manages crawl delay settings per user agent</li>
 *   <li>Stores sitemap URLs listed in robots.txt</li>
 * </ul>
 *
 * <p>The class uses case-insensitive pattern matching for user agents and supports
 * wildcard characters (*) in user agent strings. When multiple directives match a user agent,
 * the most specific (longest) match is used.</p>
 *
 */
public class RobotsTxt {

      pattern += "."
    }
    // Hostname and pattern are now absolute domain names.

    pattern = pattern.asciiToLowercase()
    // Hostname and pattern are now in lower case -- domain names are case-insensitive.

    if ("*" !in pattern) {
      // Not a wildcard pattern -- hostname and pattern must match exactly.
      return hostname == pattern
    }

    // Wildcard pattern

        assertNotNull(retrieved2);
        assertEquals(engine1, retrieved1);
        assertEquals(engine2, retrieved2);
        assertNotSame(retrieved1, retrieved2);
    }

    // Test register method with case insensitive name
    public void test_register_caseInsensitive() {
        testScriptEngine.register();

        // Test various case combinations
        ScriptEngine lowerCase = scriptEngineFactory.getScriptEngine("testengine");

            assertEquals("application/octet-stream", mimeMap.getMimeType("doesnotexist"));
        }

        @Test
        @DisplayName("Should handle case insensitive extensions")
        void testCaseInsensitiveExtensions() throws IOException {
            assertEquals("application/pdf", mimeMap.getMimeType("PDF"));
            assertEquals("application/pdf", mimeMap.getMimeType("Pdf"));

        assertEquals("processed_site1", result);

        // Headers persist in same request, so subsequent headers are additive
        // Test with case insensitive matching
        request.addHeader("X-Forwarded-Host", "TEST.COM");
        result = virtualHostHelper.processVirtualHost(s -> "processed_" + s, "default");

		etag = metadata["md5Sum"]
	}
	// Success.
	return etag
}

// HasPrefix - Prefix matcher string matches prefix in a platform specific way.
// For example on windows since its case insensitive we are supposed
// to do case insensitive checks.
func HasPrefix(s string, prefix string) bool {
	if runtime.GOOS == globalWindowsOSName {
		return stringsHasPrefixFold(s, prefix)
	}
	return strings.HasPrefix(s, prefix)
}