*
     * @param value the value to convert
     * @return the converted value
     */
    protected String toLowercaseWildcard(final String value) {
        if (lowercaseWildcard) {
            return value.toLowerCase(Locale.ROOT);
        }
        return value;
    }

    /**
     * Sets the lowercase wildcard flag.
     *
     * @param lowercaseWildcard the lowercase wildcard flag
     */

     */
    protected String toLowercaseWildcard(final String value) {
        if (lowercaseWildcard) {
            return value.toLowerCase(Locale.ROOT);
        }
        return value;
    }

    /**
     * Sets whether wildcard terms should be converted to lowercase.
     *

        int state, t, x, i, off;
        byte ch;
        final byte[] type = new byte[128];
        final byte[] buf = new byte[16];
        final byte[] ext = extension.toLowerCase().getBytes("ASCII");

        state = ST_START;
        t = x = i = 0;
        for (off = 0; off < inLen; off++) {
            ch = in[off];
            switch (state) {
            case ST_START:

        super(providers);
        this.lookup = lookup;
        this.typeRegistry = typeRegistry;
    }

    @Override
    public Optional<Packaging> lookup(String id) {
        id = id.toLowerCase(Locale.ROOT);
        // TODO: we should be able to inject a Map<String, LifecycleMapping> directly,
        // however, SISU visibility filtering can only happen when an explicit

      s.add("concurrencyLevel", concurrencyLevel);
    }
    if (keyStrength != null) {
      s.add("keyStrength", Ascii.toLowerCase(keyStrength.toString()));
    }
    if (valueStrength != null) {
      s.add("valueStrength", Ascii.toLowerCase(valueStrength.toString()));
    }
    if (keyEquivalence != null) {
      s.addValue("keyEquivalence");
    }
    return s.toString();
  }

        String result = trans2QueryFSInfo.toString();

        assertNotNull(result);
        assertTrue(result.contains("Trans2QueryFSInformation"));
        assertTrue(result.toLowerCase().contains(expectedHex.toLowerCase()));
    }

    @Test
    @DisplayName("Test object state after multiple operations")
    void testObjectStateAfterMultipleOperations() {

    void nameBasedFilterTxt(String name, boolean expected) throws Exception {
        SmbFilenameFilter filter = (dir, n) -> n != null && n.toLowerCase().endsWith(".txt");

        boolean result = filter.accept(mockDir, name);

        assertEquals(expected, result, "Filter should evaluate .txt suffix correctly");
        verifyNoInteractions(mockDir);
    }

          public String apply(String value) {
            return Ascii.toLowerCase(value);
          }
        };

    static final EntryTransformer<String, String, String> ENTRY_TRANSFORMER =
        new EntryTransformer<String, String, String>() {
          @Override
          public String transformEntry(String key, String value) {
            return Ascii.toLowerCase(value);
          }
        };
  }

    testEncodingWithSeparators(encoding, decoded, encoded);
    testEncodingWithSeparators(encoding.upperCase(), decoded, Ascii.toUpperCase(encoded));
    testEncodingWithSeparators(encoding.lowerCase(), decoded, Ascii.toLowerCase(encoded));
  }

  private static void testEncodingWithSeparators(
      BaseEncoding encoding, String decoded, String encoded) {
    testEncoding(encoding, decoded, encoded);

    // test separators work

     */
    protected boolean isValidRedirectUrl(final String url) {
        if (StringUtil.isBlank(url)) {
            return false;
        }
        final String lowerUrl = url.toLowerCase();
        if (lowerUrl.startsWith("http://") || lowerUrl.startsWith("https://")) {
            return true;
        }