buffer.write(this, length.toLong())
    }
    while (!buffer.exhausted()) {
      var publicSuffix = buffer.readUtf8LineStrict()
      if (publicSuffix.contains("*")) {
        // A wildcard rule, let's replace the wildcard with a value.
        publicSuffix = publicSuffix.replace("\\*".toRegex(), "square")
      }
      assertThat(publicSuffixDatabase.getEffectiveTldPlusOne(publicSuffix)).isNull()

     * Constructs a NetServerEnumIterator for enumerating network servers
     * @param parent
     *            the parent SMB file
     * @param th
     *            the tree handle to use
     * @param wildcard
     *            wildcard pattern for filtering servers
     * @param searchAttributes
     *            attributes to search for
     * @param filter
     *            optional resource name filter
     * @throws CIFSException

  }

  /** Check that wildcard SANs are supported.  */
  @Test
  fun commonThenWildcard() {
    server.enqueue(MockResponse())
    server.enqueue(MockResponse())
    assert200Http2Response(execute(url), server.hostName)
    val sanUrl = url.newBuilder().host("www.wildcard.com").build()
    assert200Http2Response(execute(sanUrl), "www.wildcard.com")

        assertNotNull(queryBuilder3);
    }

    public void test_convertWildcardQuery_withSpecialCharacters() throws Exception {
        // Test with special wildcard characters
        QueryContext queryContext1 = new QueryContext("te?t*", false);
        WildcardQuery wildcardQuery1 = new WildcardQuery(new Term("title", "te?t*"));

        verify(tree, atLeastOnce()).release();
    }

    @ParameterizedTest
    @ValueSource(strings = { "", " ", "*", "?" })
    @DisplayName("Supports various wildcard values without throwing (edge cases)")
    void wildcardEdgeCases(String wildcard) throws Exception {
        // minimal successful first response with a single entry

                "xxx:aaa");
        assertQueryBuilder(WildcardQueryBuilder.class, //
                "{\"wildcard\":{\"url\":{\"wildcard\":\"*aaa*\",\"boost\":1.0}}}", //
                "inurl:aaa");
        assertQueryBuilder(TermQueryBuilder.class, //
                "{\"term\":{\"url\":{\"value\":\"aaa\",\"boost\":1.0}}}", //

			// no need to heal them skip, only when bucket
			// is '.minio.sys'
			if bucket == minioMetaBucket {
				if wildcard.Match("buckets/*/.metacache/*", entry.name) {
					return
				}
				if wildcard.Match("tmp/.trash/*", entry.name) {
					return
				}
				if wildcard.Match("multipart/*", entry.name) {
					return
				}
			}

			// erasureObjects layer needs object names to be encoded

            if (dff.wildcard != null) {
                wildcard = dff.wildcard;
            }
            searchAttributes = dff.attributes;
        }

        try {
            final int hostlen = url.getHost().length();
            if (hostlen == 0 || getType() == TYPE_WORKGROUP) {
                doNetServerEnum(list, files, wildcard, searchAttributes, fnf, ff);

    private Trans2FindFirst2Response response;

    public DirFileEntryEnumIterator1(final SmbTreeHandleImpl th, final SmbResource parent, final String wildcard,
            final ResourceNameFilter filter, final int searchAttributes) throws CIFSException {
        super(th, parent, wildcard, filter, searchAttributes);
    }

    @SuppressWarnings("resource")
    @Override
    protected final FileEntry open() throws CIFSException {

        regQ(existsQuery);
        return existsQuery;
    }

    protected WildcardQueryBuilder regWildcardQ(String name, String wildcard) {
        checkEsInvalidQuery(name, wildcard);
        WildcardQueryBuilder wildcardQuery = QueryBuilders.wildcardQuery(name, wildcard);
        regQ(wildcardQuery);
        return wildcardQuery;
    }

    protected RegexpQueryBuilder regRegexpQ(String name, String regexp) {