@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 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())); } }
/** * 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 testAttributeOrder() { for (List<String> strings: someNonEmptyLists(uniqueValues(nonEmptyStrings(), 10))) { DataSetBuilder bld = new DataSetBuilder(nonEmptyStrings().next()); StaticDataSource train = new StaticDataSource("train"); bld.setTrain(train); StaticDataSource test = new StaticDataSource("test"); bld.setTest(test); for (String str: strings) { bld.setAttribute(str, nonEmptyStrings().next()); } DataSet ds = bld.build(); assertThat(ds.getAttributes().size(), equalTo(strings.size() + 1)); List<String> stringArray = new ArrayList<>(); stringArray.add("DataSet"); stringArray.addAll(strings); String[] strs = stringArray.toArray(new String[stringArray.size()]); assertThat(ds.getAttributes().keySet(), contains(strs)); } } }
public FieldGenerator(ColumnSchema schema) { switch (schema.getType()) { case ULONG: case LONG: case TIME: { generator = new LongBytesGenerator(); break; } case DOUBLE: { generator = new DoubleBytesGenerator(); break; } case BINARY: { generator = CombinedGenerators.byteArrays( PrimitiveGenerators.integers(0, schema.getMaxLength())); break; } case STRING: { generator = new StringBytesGenerator(schema.getMaxLength()); break; } default: generator = CombinedGenerators.byteArrays( PrimitiveGenerators.fixedValues(32)); } if (schema.getIsNullable()) { generator = CombinedGenerators.nullsAnd(generator, 10); } }
/** * Create a generator of sets that are not empty. * * @param <T> * type of set elements generated * @param content * generator providing the content of sets generated */ public static <T> Generator<Set<T>> nonEmptySets(Generator<? extends T> content) { return sets(content, 1, SetGenerator.MAX_SIZE); }
/** * Create a generator of sorted lists with values from the content * generator. Length is between high and low. * * @param <T> * type of list elements generated * @param content * generator providing the content of lists generated * @param low * minimal size * @param high * max size */ public static <T extends Comparable<T>> Generator<List<T>> sortedLists( Generator<T> content, int low, int high) { return sortedLists(content, integers(low, high)); }
/** * Create a generator that omits a given set of values. * * @param generator used to create the raw values. * @param excluded values. These values will not be returned. */ public static <T> Generator<T> excludeValues(Generator<T> generator, T... excluded) { return excludeValues(generator, Arrays.asList(excluded)); }
/** * Create a deterministic generator which guarantees that all values from * the ensuredValues array will be returned if enough calls to * {@link Generator#next()} are issued (i.e. ensuredValues.size() <= # of * runs). The order of values is undefined. * * @param <T> * type of values return by the generator */ public static <T> StatefulGenerator<T> ensureValues(T... content) { return ensureValues(Arrays.asList(content)); }
/** * Create a generator of arrays that are not empty. * * @param <T> * type of arrays elements generated * @param content * generator providing the content of arrays generated * @param type * type of arrays generated */ public static <T> Generator<T[]> nonEmptyArrays(Generator<? extends T> content, Class<T> type) { return arrays(content, positiveIntegers(MAX_SIZE), type); }
/** * <p> * Create a generator that ensures unique values. * </p> * <p> * The actual values are created with an arbitrary generator. * </p> * <p> * Unique generator depends on the {@link Comparator} implementation to * decide if two instances are the same (i.e. when the comparator returns 0 * for {@link Comparator#compare(Object, Object)}). * </p> * * @param <T> * type of values returned by the generator * @param generator * used to create the raw values. This generator can create * duplicate values * @param comparator * that decides if two values are of the same equivalence class. * @return unique generator instance */ public static <T> StatefulGenerator<T> uniqueValues(Generator<T> generator, Comparator<? super T> comparator) { return uniqueValues(generator, comparator, DEFAULT_MAX_TRIES); }
@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()))); } }
/** * Create a generator that omits a given set of values. * * @param values of generator * @param excluded values. These values will not be returned. */ public static <T> Generator<T> excludeValues(Collection<T> values, T... excluded) { return excludeValues(values, Arrays.asList(excluded)); }
@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 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)); } } }
/** * Create a generator that omits a given value. * * @param generator used to create the raw values. * @param excluded value. This value will not be returned. */ public static <T> Generator<T> excludeValues(Generator<T> generator, T excluded) { return excludeValues(generator, singletonList(excluded)); }
@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())); } }
/** * Create a generator of lists with values from the content generator. * Length is at least low. * * @param <T> * type of list elements generated * @param content * generator providing the content of lists generated * @param low * minimal size. If low is larger than * {@link CombinedGenerators#DEFAULT_COLLECTION_MAX_SIZE} then it * is the upper size bound as well. */ public static <T> Generator<List<T>> lists(Generator<? extends T> content, int low) { return lists(content, low, Math.max(low, ListGenerator.MAX_SIZE) ); }
/** * Create a generator that omits a given set of values. * * @param values of generator * @param excluded values. These values will not be returned. */ public static <T> Generator<T> excludeValues(Collection<T> values, Collection<T> excluded) { return excludeValues(fixedValues(values), excluded); }
@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())); } }