How to use net.java.quickcheck.generator

/**
 * Method to compute the data points. Split out so that errors it throws get reported.
 */
@BeforeClass
public static void makeDataPoints() {
  KeyData[] data = new KeyData[10];
  Generator<Long> intGen = longs(Integer.MIN_VALUE, Integer.MAX_VALUE);
  Generator<Long> longGen = longs(Integer.MAX_VALUE + 1L, Long.MAX_VALUE);
  for (int i = 0; i < 10; i++) {
    Generator<List<Long>> listGen;
    if (i % 2 == 0) {
      // generate ints
      listGen = sortedLists(uniqueValues(intGen), 25, 25);
    } else {
      // generate longs
      listGen = sortedLists(uniqueValues(longGen), 25, 25);
    }
    List<Long> nums = listGen.next();
    data[i] = new KeyData(nums);
  }
  DATA_POINTS = data;
}

  @Test
  public void testFromMap() {
    for (Map<String,String> map: someMaps(strings(), strings())) {
      MetricResult result = MetricResult.fromMap(map);
      assertThat(result.getValues(), equalTo((Map) map));
    }
  }
}

@Test
public void testCollectMany() {
  for (List<Long> ids: someLists(longs(), 10, 100)) {
    List<Double> values = lists(doubles(), ids.size()).next();
    ResultList results = IntStream.range(0, ids.size())
                   .mapToObj(i -> Results.create(ids.get(i), values.get(i)))
                   .collect(Results.listCollector());
    assertThat(results.stream().map(Result::getId).collect(Collectors.toList()),
          equalTo(ids));
    assertThat(results.stream().map(Result::getScore).collect(Collectors.toList()),
          equalTo(values));
  }
}

@Test
public void testAddABunchOfMediumLongs() {
  for (List<Long> strings: someLists(nullsAnd(longs(Integer.MIN_VALUE, Integer.MAX_VALUE), 20),
                    integers(2 * Shard.SHARD_SIZE + 20, 10 * Shard.SHARD_SIZE))) {
    AttrStoreBuilder asb = new AttrStoreBuilder(LongShard::create);
    strings.forEach(asb::add);
    assertThat(asb.size(), equalTo(strings.size()));
    AttrStore store = asb.build();
    assertThat(store.size(), equalTo(strings.size()));
    assertThat(IntStream.range(0, strings.size())
              .mapToObj(store::get)
              .collect(Collectors.toList()),
          contains(strings.toArray()));
  }
}

@Test
public void testAddABunchOfStrings() {
  for (List<String> strings: someLists(nullsAnd(strings(), 20),
                     integers(2 * Shard.SHARD_SIZE + 20, 10 * Shard.SHARD_SIZE))) {
    AttrStoreBuilder asb = new AttrStoreBuilder();
    strings.forEach(asb::add);
    assertThat(asb.size(), equalTo(strings.size()));
    AttrStore store = asb.build();
    assertThat(store.size(), equalTo(strings.size()));
    assertThat(IntStream.range(0, strings.size())
              .mapToObj(store::get)
              .collect(Collectors.toList()),
          contains(strings.toArray()));
  }
}

@Test
public void testAddABunchOfDoubles() {
  for (List<Double> strings: someLists(nullsAnd(doubles(), 20),
                     integers(2 * Shard.SHARD_SIZE + 20, 10 * Shard.SHARD_SIZE))) {
    AttrStoreBuilder asb = new AttrStoreBuilder(DoubleShard::create);
    strings.forEach(asb::add);
    assertThat(asb.size(), equalTo(strings.size()));
    AttrStore store = asb.build();
    assertThat(store.size(), equalTo(strings.size()));
    assertThat(IntStream.range(0, strings.size())
              .mapToObj(store::get)
              .collect(Collectors.toList()),
          contains(strings.toArray()));
  }
}

@Test
public void testAddABunchOfSmallInts() {
  for (List<Integer> strings: someLists(nullsAnd(integers(Short.MIN_VALUE, Short.MAX_VALUE), 20),
                     integers(2 * Shard.SHARD_SIZE + 20, 10 * Shard.SHARD_SIZE))) {
    AttrStoreBuilder asb = new AttrStoreBuilder(IntShard::create);
    strings.forEach(asb::add);
    assertThat(asb.size(), equalTo(strings.size()));
    AttrStore store = asb.build();
    assertThat(store.size(), equalTo(strings.size()));
    assertThat(IntStream.range(0, strings.size())
              .mapToObj(store::get)
              .collect(Collectors.toList()),
          contains(strings.toArray()));
  }
}

@Test
public void testRandomMaps() {
  for (Map<Long,Double> map: someMaps(longs(), doubles())) {
    Long2DoubleSortedArrayMap vec = Long2DoubleSortedArrayMap.create(map);
    Set<Long> picked = sets(map.keySet()).next();
    Set<Long> extra = sets(longs()).next();
    LongSortedSet wanted = LongUtils.setUnion(LongUtils.asLongSet(picked), LongUtils.asLongSet(extra));
    Long2DoubleSortedMap sv = vec.subMap(wanted);
    assertThat(sv.keySet(), everyItem(isIn(wanted)));
    assertThat(sv.keySet(), containsInAnyOrder(picked.toArray()));
    assertThat(sv.entrySet(), everyItem(isIn(map.entrySet())));
  }
}

@Test
public void testAddScalarSorted() {
  for (Map<Long,Double> map: someMaps(longs(), doubles(-1000, 1000))) {
    double scalar = doubles(-250, 250).next();
    Long2DoubleMap m = Long2DoubleSortedArrayMap.create(map);
    Long2DoubleMap result = Vectors.addScalar(m, scalar);
    assertThat(Vectors.sum(result), closeTo(Vectors.sum(m) + m.size() * scalar, 1.0e-6));
    for (long key: result.keySet()) {
      assertThat(result.get(key), closeTo(map.get(key) + scalar, 1.0e-6));
    }
  }
}

@Test
public void testRandomSearchesPresent() {
  for (List<Long> keys: someSortedLists(longs())) {
    List<Long> deduped = Lists.newArrayList(Sets.newLinkedHashSet(keys));
    long key = integers(0, deduped.size()).next();
    BinarySearch search = BinarySearch.forList(key, deduped);
    assertThat(search.search(0, keys.size()),
          equalTo(Collections.binarySearch(deduped, key)));
  }
}

@Test
public void testGetters() {
  for (Pair<Long,Double> pair: somePairs(longs(), doubles())) {
    Result r = new BasicResult(pair.getFirst(), pair.getSecond());
    assertThat(r.getId(), equalTo(pair.getFirst()));
    assertThat(r.getScore(), equalTo(pair.getSecond()));
    assertThat(r.hasScore(), equalTo(true));
  }
}

@Test
public void testManyNumbersMightBeZero() {
  for (Pair<Double,Double> pair: somePairs(doubles(-10, 10), doubles(0, 2))) {
    assertThat(Scalars.isZero(pair.getFirst(), pair.getSecond()),
          equalTo(Math.abs(pair.getFirst()) < pair.getSecond()));
  }
}

private List<Rating> makeRatings() {
  Generator<Rating> rgen = ratings();
  int n = integers(10, 1000).next();
  return Stream.generate(rgen::next)
         .limit(n)
         .collect(Collectors.toList());
}

  @Test
  public void testMapSomeStuff() {
    for (Set<Long> keys: someSets(longs())) {
      Long2DoubleMap map = LongUtils.flyweightMap(LongUtils.frozenSet(keys),
                            x -> (-x) % 10);
      assertThat(map.keySet(), equalTo(keys));
      assertThat(map.size(), equalTo(keys.size()));
      for (Long k: keys) {
        assertThat(map, hasEntry(k, (double) ((-k) % 10)));
      }
    }
  }
}

@Test
public void testIndexOfShard() {
  for (int i: someIntegers(0)) {
    assertThat(Shard.indexOfShard(i),
          equalTo(i / Shard.SHARD_SIZE));
  }
}

@Test
public void testAddABunchOfSmallLongs() {
  for (List<Long> strings: someLists(nullsAnd(longs(Short.MIN_VALUE, Short.MAX_VALUE), 20),
                     integers(2 * Shard.SHARD_SIZE + 20, 10 * Shard.SHARD_SIZE))) {
    AttrStoreBuilder asb = new AttrStoreBuilder(LongShard::create);
    strings.forEach(asb::add);
    assertThat(asb.size(), equalTo(strings.size()));
    AttrStore store = asb.build();
    assertThat(store.size(), equalTo(strings.size()));
    assertThat(IntStream.range(0, strings.size())
              .mapToObj(store::get)
              .collect(Collectors.toList()),
          contains(strings.toArray()));
  }
}

  @Test
  public void testParallelCollect() {
    for (List<Long> ids: someLists(longs(), 100, 10000)) {
      List<Double> values = lists(doubles(), ids.size()).next();
      ResultList results = IntStream.range(0, ids.size())
                     .parallel()
                     .mapToObj(i -> Results.create(ids.get(i), values.get(i)))
                     .collect(Results.listCollector());
      assertThat(results.stream().map(Result::getId).collect(Collectors.toList()),
            equalTo(ids));
      assertThat(results.stream().map(Result::getScore).collect(Collectors.toList()),
            equalTo(values));
    }
  }
}

@Test
public void testAddABunchOfInts() {
  for (List<Integer> strings: someLists(nullsAnd(integers(), 20),
                     integers(2 * Shard.SHARD_SIZE + 20, 10 * Shard.SHARD_SIZE))) {
    AttrStoreBuilder asb = new AttrStoreBuilder(IntShard::create);
    strings.forEach(asb::add);
    assertThat(asb.size(), equalTo(strings.size()));
    AttrStore store = asb.build();
    assertThat(store.size(), equalTo(strings.size()));
    assertThat(IntStream.range(0, strings.size())
              .mapToObj(store::get)
              .collect(Collectors.toList()),
          contains(strings.toArray()));
  }
}

@Test
public void testAddScalar() {
  for (Map<Long,Double> map: someMaps(longs(), doubles(-1000, 1000))) {
    double scalar = doubles(-250, 250).next();
    Long2DoubleMap m = new Long2DoubleOpenHashMap(map);
    Long2DoubleMap result = Vectors.addScalar(m, scalar);
    assertThat(Vectors.sum(result), closeTo(Vectors.sum(m) + m.size() * scalar, 1.0e-6));
    for (long key: result.keySet()) {
      assertThat(result.get(key), closeTo(map.get(key) + scalar, 1.0e-6));
    }
  }
}

@Test
public void testAddABunchOfLongs() {
  for (List<Long> strings: someLists(nullsAnd(longs(), 20),
                     integers(2 * Shard.SHARD_SIZE + 20, 10 * Shard.SHARD_SIZE))) {
    AttrStoreBuilder asb = new AttrStoreBuilder(LongShard::create);
    strings.forEach(asb::add);
    assertThat(asb.size(), equalTo(strings.size()));
    AttrStore store = asb.build();
    assertThat(store.size(), equalTo(strings.size()));
    assertThat(IntStream.range(0, strings.size())
              .mapToObj(store::get)
              .collect(Collectors.toList()),
          contains(strings.toArray()));
  }
}