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 testStorableInts() { for (int n: toIterable(integers(-512, 512), 10000)) { double d = n; assertThat(String.format("value %f should be %s", d, Math.abs(n) < 64 ? "storable" : "unstorable"), DoubleShard.Compact.isStorable(d), equalTo(n > -64 && n < 64)); } }
@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 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 testStorableHalfPrecision() { for (int n: toIterable(integers(-127, 127), 10000)) { double d = n / 2.0; assertThat(String.format("value %f should be storable", d), DoubleShard.Compact.isStorable(d), equalTo(true)); } }
@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 testStorableQuarterPrecision() { for (int n: toIterable(integers(-255, 255), 10000)) { double d = n / 4.0; assertThat(String.format("value %f should be %s", d, n % 2 == 0 ? "storable" : "unstorable"), DoubleShard.Compact.isStorable(d), equalTo(n % 2 == 0)); } }
@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 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 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())); } }
@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 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())); } }
/** * Use random lists to test that we always find the *first* matching element. */ @Test public void testRandomSearchesFindFirst() { for (List<String> keys: someNonEmptyLists(strings())) { Collections.sort(keys); // pick an element to duplicate int toDup = integers(0, keys.size() - 1).next(); // and # of times to duplicate int ndups = integers(0, 10).next(); String dupKey = keys.get(toDup); for (int i = 0; i < ndups; i++) { keys.add(toDup, dupKey); } BinarySearch search = BinarySearch.forList(dupKey, keys); int rv = search.search(0, keys.size()); assertThat(rv, greaterThanOrEqualTo(0)); assertThat(search.search(0, keys.size()), lessThanOrEqualTo(Collections.binarySearch(keys, dupKey))); assertThat(keys.get(rv), equalTo(dupKey)); if (rv > 0) { // this is the first one assertThat(keys.get(rv-1), lessThan(dupKey)); } } }
@Test public void testPackABunchOfRatings() { for (List<Rating> ratings: someLists(ratings(), integers(100, 5000))) { EntityCollectionDAOBuilder b = EntityCollectionDAO.newBuilder(); b.addEntityLayout(Rating.ENTITY_TYPE, Rating.ATTRIBUTES);
@Test public void testStoreABunchOfRatings() { for (List<Rating> ratings: someLists(ratings(), integers(100, 5000))) { EntityCollectionDAOBuilder b = EntityCollectionDAO.newBuilder(); b.addDefaultIndex(CommonAttributes.USER_ID);
@Test public void testCreateWithLists() { for (Set<Long> keys: someSets(longs(), integers(0, 500))) { LongSortedSet sorted = LongUtils.packedSet(keys); SortedKeyIndex dom = SortedKeyIndex.fromCollection(keys); double[] values = new double[dom.size()]; for (int i = 0; i < dom.size(); i++) { values[i] = doubles().next(); } Long2DoubleSortedMap map = new Long2DoubleSortedArrayMap(dom, values); assertThat(map.size(), equalTo(dom.size())); assertThat(map.size(), equalTo(keys.size())); if (map.size() > 0) { assertThat(map.entrySet().first().getKey(), equalTo(sorted.firstLong())); assertThat(map.entrySet().last().getKey(), equalTo(sorted.lastLong())); assertThat(map.firstLongKey(), equalTo(sorted.firstLong())); assertThat(map.lastLongKey(), equalTo(sorted.lastLong())); } assertThat(map.keySet(), equalTo(sorted)); for (Long k: keys) { assertThat(map.containsKey(k), equalTo(true)); } } }
public TableSchemaGenerator(int minNumIndices) { super(); this.numIndicesGen = PrimitiveGenerators.integers(minNumIndices, MYSQL_MAX_INDICES); }
public TableSchemaGenerator() { super(); this.numIndicesGen = PrimitiveGenerators.integers(0, MYSQL_MAX_INDICES); }
/** * Create a generator of sets with values from the content generator. Length * is between high and low. * * @param <T> * type of set elements generated * @param content * generator providing the content of sets generated * @param low * minimal size * @param high * max size */ public static <T> Generator<Set<T>> sets(Generator<? extends T> content, int low, int high) { return new SetGenerator<T>(content, integers(low, high), DEFAULT_MAX_TRIES); }