when(mockNetbiosName.getName()).thenReturn(testName);
            assertEquals(testName, mockNetbiosName.getName());
        }
    }

    @Test
    @DisplayName("Should handle case sensitivity")
    void testCaseSensitivity() {
        // Given
        String upperCase = "SERVER";
        String lowerCase = "server";
        String mixedCase = "Server";

        // Test different cases

    }

    /**
     * Test case sensitivity in patterns
     */
    public void test_caseSensitivity() {
        String sessionId = "test-session-019";
        urlFilter.init(sessionId);

        urlFilter.addInclude(".*\\.PDF$");

        // Test case sensitivity
        assertFalse(urlFilter.match("https://example.com/document.pdf"));

/**
 * Query command for handling wildcard queries.
 * Converts Lucene WildcardQuery objects to OpenSearch QueryBuilder objects,
 * supporting wildcard pattern matching with configurable case sensitivity.
 */
public class WildcardQueryCommand extends QueryCommand {

    /**
     * Default constructor.
     */
    public WildcardQueryCommand() {
        super();
    }

        // Then
        assertNull(type1.getSuppliedDomain());
        assertNull(type1.getSuppliedWorkstation());
    }

    @Test
    @DisplayName("Should handle case sensitivity in domain and workstation")
    void testCaseSensitivity() {
        // Given
        String domain = "TestDomain";
        String workstation = "TestWorkstation";

        // When

    filesystem.

    It is not possible to determine whether a file-based location will
    be available except on a case-by-case basis (or a root-url by
    root-url basis). We may want to move the offline sensitivity entirely to
    Maven-Artifact, below, so we can be smarter about testing filesystem-based
    repositories, etc.

  * If not otherwise specified, all other wagons are assumed to be

            assertNotNull(type3.getMic());
            assertEquals(16, type3.getMic().length); // MIC is 16 bytes
        }
    }

    @Test
    @DisplayName("Should handle case sensitivity correctly")
    void testCaseSensitivity() throws Exception {
        // Given
        Type2Message type2 = createMockType2Message();
        String mixedCaseDomain = "TestDomain";

            PropertyConfiguration config = new PropertyConfiguration(props);
            assertEquals(strategy, config.getLoadBalancingStrategy());
        }

        // Test case insensitivity
        props.setProperty("jcifs.smb.client.loadBalancingStrategy", "ADAPTIVE");
        PropertyConfiguration config = new PropertyConfiguration(props);
        assertEquals("ADAPTIVE", config.getLoadBalancingStrategy());

	if _, ok := formValues[xhttp.AmzSignatureV2]; ok {
		delete(mustFindInPolicy, xhttp.AmzSignatureV2)
		for k := range mustFindInPolicy {
			// case-insensitivity for AWSAccessKeyId
			if strings.EqualFold(k, xhttp.AmzAccessKeyID) {
				delete(mustFindInPolicy, k)
				break
			}
		}
	}

	return Replace(s, old, new, -1)
}

// EqualFold reports whether s and t, interpreted as UTF-8 strings,
// are equal under simple Unicode case-folding, which is a more general
// form of case-insensitivity.
func EqualFold(s, t []byte) bool {
	// ASCII fast path
	i := 0
	for n := min(len(s), len(t)); i < n; i++ {
		sr := s[i]
		tr := t[i]
		if sr|tr >= utf8.RuneSelf {
			goto hasUnicode
		}