How to use

count

method

in

java.util.stream.Stream

public static void assertCount(long expected, Stream stream) {
  org.junit.Assert.assertEquals(expected, stream.count());
}

private static int getNullFlagsCount(List<ArgumentProperty> argumentProperties)
{
  return (int) argumentProperties.stream()
      .filter(argumentProperty -> argumentProperty.getNullConvention() == USE_NULL_FLAG)
      .count();
}

public boolean impliesClusterPermissionPermission(String action) {
  return roles.stream()
      .filter(r->r.impliesClusterPermission(action)).count() > 0;
}

@Benchmark
public void serial_lazy_jdk()
{
  long evens = this.integersJDK.stream().filter(each -> each % 2 == 0).count();
  Assert.assertEquals(SIZE / 2, evens);
}

public int missingSpeakerPreferredTimeslotTagCount() {
  if (timeslot == null) {
    return 0;
  }
  return (int) speakerList.stream().flatMap(speaker -> speaker.getPreferredTimeslotTagSet().stream())
      .filter(tag -> !timeslot.hasTag(tag)).count();
}

@Test
public void testLoadNonExistent() {
  assertEquals(0L, testSubject.readEvents(randomUUID().toString()).asStream().count());
}

@Benchmark
public void parallel_lazy_jdk()
{
  long evens = this.integersJDK.parallelStream().filter(each -> each % 2 == 0).count();
  Assert.assertEquals(SIZE / 2, evens);
}

@Test
public void streamIsEmptyForEmptyValues() {
  MutablePropertyValues pvs = new MutablePropertyValues();
  assertThat(pvs.stream(), notNullValue());
  assertThat(pvs.stream().count(), is(0L));
}

@Test
public void shouldNotRewindPastStartOfQueueWhenDisplayingHistory() {
  basicReader().historyRecords(Long.MAX_VALUE).execute();
  assertThat(capturedOutput.stream().
      filter(msg -> !msg.startsWith("0x")).count(), is(24L));
}

private static boolean hasMixedDistinctAndNonDistincts(AggregationNode aggregation)
{
  long distincts = aggregation.getAggregations()
      .values().stream()
      .map(Aggregation::getCall)
      .filter(FunctionCall::isDistinct)
      .count();
  return distincts > 0 && distincts < aggregation.getAggregations().size();
}

@Test
public void streamAlreadyConsumed() {
  AssertSubscriber<Integer> ts = AssertSubscriber.create();
  Stream<Integer> s = source.stream();
  s.count();
  Flux.fromStream(s)
    .subscribe(ts);
  ts.assertNoValues()
   .assertNotComplete()
   .assertError(IllegalStateException.class);
}

@Test
public void testNonDeterministic()
{
  MaterializedResult materializedResult = computeActual("SELECT rand() FROM orders LIMIT 10");
  long distinctCount = materializedResult.getMaterializedRows().stream()
      .map(row -> row.getField(0))
      .distinct()
      .count();
  assertTrue(distinctCount >= 8, "rand() must produce different rows");
  materializedResult = computeActual("SELECT apply(1, x -> x + rand()) FROM orders LIMIT 10");
  distinctCount = materializedResult.getMaterializedRows().stream()
      .map(row -> row.getField(0))
      .distinct()
      .count();
  assertTrue(distinctCount >= 8, "rand() must produce different rows");
}

@Benchmark
public void serial_lazy_jdk()
{
  long evens = this.integersJDK.stream().filter(each -> each % 2 == 0).count();
  Assert.assertEquals(SIZE / 2, evens);
}

private static int getBlockPositionCount(List<ArgumentProperty> argumentProperties)
{
  return (int) argumentProperties.stream()
      .filter(argumentProperty -> argumentProperty.getNullConvention() == BLOCK_AND_POSITION)
      .count();
}

public int prevailingSpeakerUndesiredTimeslotTagCount() {
  if (timeslot == null) {
    return 0;
  }
  return (int) speakerList.stream().flatMap(speaker -> speaker.getUndesiredTimeslotTagSet().stream())
      .filter(tag -> timeslot.hasTag(tag)).count();
}

@Test
public void largeTest() throws Exception {
  final int numDoc = 30000;
  final String store = "vertex";
  initialize(store);
  for (int i = 1; i <= numDoc; i++) {
    add(store, "doc" + i, getRandomDocument(), true);
  }
  clopen();
  final long time = System.currentTimeMillis();
  Stream<String> result = tx.queryStream(new IndexQuery(store, And.of(PredicateCondition.of(WEIGHT, Cmp.GREATER_THAN_EQUAL, 0.2), PredicateCondition.of(WEIGHT, Cmp.LESS_THAN, 0.6), PredicateCondition.of(LOCATION, Geo.WITHIN, Geoshape.circle(48.5, 0.5, 1000.00)))));
  final long oldResultSize = result.count();
  System.out.println(oldResultSize + " vs " + (numDoc / 1000 * 2.4622623015));
  System.out.println("Query time on " + numDoc + " docs (ms): " + (System.currentTimeMillis() - time));
  result = tx.queryStream(new IndexQuery(store, And.of(PredicateCondition.of(WEIGHT, Cmp.GREATER_THAN_EQUAL, 0.2), PredicateCondition.of(WEIGHT, Cmp.LESS_THAN, 0.6), PredicateCondition.of(LOCATION, Geo.WITHIN, Geoshape.circle(48.5, 0.5, 1000.00))), numDoc / 1000));
  assertEquals(numDoc / 1000, result.count());
  result = tx.queryStream(new IndexQuery(store, And.of(PredicateCondition.of(WEIGHT, Cmp.GREATER_THAN_EQUAL, 0.2), PredicateCondition.of(WEIGHT, Cmp.LESS_THAN, 0.6), PredicateCondition.of(LOCATION, Geo.WITHIN, Geoshape.circle(48.5, 0.5, 1000.00))), numDoc / 1000 * 100));
  assertEquals(oldResultSize, result.count());
}

private void checkAtLeastOneActionIsDefined(Set<String> actions) {
 long actionsDefined = actions.stream().filter(action -> !action.equals(COMMENT_KEY)).count();
 checkArgument(actionsDefined > 0, "At least one action must be provided");
}

@Benchmark
public void parallel_lazy_jdk()
{
  long evens = this.integersJDK.parallelStream().filter(each -> each % 2 == 0).count();
  Assert.assertEquals(SIZE / 2, evens);
}

@Test
public void streamIsEmptyForEmptySources() {
  MutablePropertySources sources = new MutablePropertySources();
  assertThat(sources.stream(), notNullValue());
  assertThat(sources.stream().count(), is(0L));
}

@Test
public void shouldFilterByMultipleExclusionRegex() {
  basicReader().withExclusionRegex(".*bye$").withExclusionRegex(".*ell.*").execute();
  assertThat(capturedOutput.stream().filter(msg -> !msg.startsWith("0x")).count(), is(0L));
}