return 0;
    }


    @Override
    public String toString () {
        return new String(
            "NtTransNotifyChange[" + super.toString() + ",fid=0x" + Hexdump.toHexString(this.fid, 4) + ",filter=0x"
                    + Hexdump.toHexString(this.completionFilter, 4) + ",watchTree=" + this.watchTree + "]");
    }

        }, e -> {});
        long after = countTmpFiles();
        logger.info("After close response. Number of temp files: " + after);

        // ## Assert ##
        assertEquals(before, after);
    }

    private long countTmpFiles() {
        return Arrays.stream(Objects.requireNonNull(Curl.tmpDir.listFiles())).map(File::getName)
                .filter(s -> s.startsWith(PREFIX) && s.endsWith(SUFFIX)).count();

 *
 * @author Louis Wasserman
 * @since 11.0
 */
@GwtCompatible(emulated = true)
@ElementTypesAreNonnullByDefault
public final class IntMath {
  // NOTE: Whenever both tests are cheap and functional, it's faster to use &, | instead of &&, ||

  @VisibleForTesting static final int MAX_SIGNED_POWER_OF_TWO = 1 << (Integer.SIZE - 2);

  /**
   * Returns the smallest power of two greater than or equal to {@code x}. This is equivalent to

                final String name = accessToken.getParameterName();
                stream(request.getParameterValues(name)).of(stream -> stream.filter(StringUtil::isNotBlank).forEach(permissionSet::add));
                return OptionalEntity.of(permissionSet);
            }).orElseThrow(() -> new InvalidAccessTokenException("invalid_token", "Invalid token: " + token));

import org.apache.maven.api.SessionData;
import org.apache.maven.api.services.MessageBuilderFactory;
import org.apache.maven.artifact.Artifact;
import org.apache.maven.artifact.resolver.filter.ArtifactFilter;
import org.apache.maven.artifact.resolver.filter.CumulativeScopeArtifactFilter;
import org.apache.maven.execution.ExecutionEvent;
import org.apache.maven.execution.MavenSession;
import org.apache.maven.internal.MultilineMessageHelper;

  private static class HasBoth extends TypeA implements TypeB {}

  @GwtIncompatible // Iterables.filter(Iterable, Class)
  public void testFilterByType_iterator() throws Exception {
    HasBoth hasBoth = new HasBoth();
    Iterable<TypeA> alist = Lists.newArrayList(new TypeA(), new TypeA(), hasBoth, new TypeA());
    Iterable<TypeB> blist = Iterables.filter(alist, TypeB.class);
    assertThat(blist).containsExactly(hasBoth).inOrder();
  }

    }

    public static PrunedTag[] parse(final String value) {
        return split(value, ",").get(stream -> stream.filter(StringUtil::isNotBlank).map(v -> {
            final Pattern pattern = Pattern.compile("(\\w+)(\\[[^\\]]+\\])?(\\.[\\w\\-]+)?(#[\\w\\-]+)?");
            final Matcher matcher = pattern.matcher(v.trim());

                        }
                    }
                } catch (final Exception e) {
                    logger.warn("Failed to load {}", fileMap, e);
                }
                return null;
            }).filter(file -> file != null).toArray(n -> new DictionaryFile<?>[n]);
        } catch (final IOException e) {
            throw new DictionaryException("Failed to access dictionaries", e);
        }
    }

            final Consumer<SearchRequestBuilder> cb = builder -> {
                final QueryBuilder queryBuilder =
                        QueryBuilders.boolQuery().filter(QueryBuilders.termsQuery(EsAccessResult.SESSION_ID, sessionIdList))
                                .filter(QueryBuilders.termQuery(EsAccessResult.STATUS, org.codelibs.fess.crawler.Constants.OK_STATUS));
                builder.setQuery(queryBuilder);
                builder.setFrom(0);

        bool((must, should, mustNot, filter) -> {
            filteredLambda.callback(must, filter);
        }, opLambda);
    }

    public void not(OperatorCall<CrawlingInfoCQ> notLambda) {
        not(notLambda, null);
    }

    public void not(final OperatorCall<CrawlingInfoCQ> notLambda, final ConditionOptionCall<BoolQueryBuilder> opLambda) {
        bool((must, should, mustNot, filter) -> notLambda.callback(mustNot), opLambda);