@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 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 testManyItems() { Generator<Double> globals = doubles(); for (Map<Long,Double> map: someMaps(positiveLongs(), doubles())) { double bias = globals.next(); Long2DoubleMap itemBiases = Long2DoubleSortedArrayMap.create(map); BiasModel model = new UserItemBiasModel(bias, Long2DoubleMaps.EMPTY_MAP, itemBiases); assertThat(model.getIntercept(), equalTo(bias)); assertThat(model.getItemBiases(itemBiases.keySet()), equalTo(itemBiases)); for (Set<Long> users : someSets(positiveLongs())) { Long2DoubleMap biases = model.getItemBiases(LongUtils.packedSet(users)); for (long user: users) { if (itemBiases.containsKey(user)) { assertThat(biases.get(user), equalTo(itemBiases.get(user))); } else { assertThat(biases.get(user), equalTo(0.0)); } } } } }
/** * 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 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 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())); } }
@Test public void testManyUsers() { Generator<Double> globals = doubles(); for (Map<Long,Double> map: someMaps(positiveLongs(), doubles())) { double bias = globals.next(); Long2DoubleMap userBiases = Long2DoubleSortedArrayMap.create(map); BiasModel model = new UserItemBiasModel(bias, userBiases, Long2DoubleMaps.EMPTY_MAP); assertThat(model.getIntercept(), equalTo(bias)); assertThat(model.getUserBiases(userBiases.keySet()), equalTo(userBiases)); for (Set<Long> users : someSets(positiveLongs())) { Long2DoubleMap biases = model.getUserBiases(LongUtils.packedSet(users)); for (long user: users) { if (userBiases.containsKey(user)) { assertThat(biases.get(user), equalTo(userBiases.get(user))); } else { assertThat(biases.get(user), equalTo(0.0)); } } } } }
@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)); } } }
@Test public void testRandomSearches() { for (List<Long> keys: someSortedLists(longs())) { List<Long> deduped = Lists.newArrayList(Sets.newLinkedHashSet(keys)); long key = longs().next(); BinarySearch search = BinarySearch.forList(key, deduped); int rv = search.search(0, keys.size()); assertThat(search.search(0, keys.size()), equalTo(Collections.binarySearch(deduped, key))); int idx = BinarySearch.resultToIndex(rv); if (deduped.isEmpty()) { assertThat(idx, equalTo(0)); } else if (idx == deduped.size()) { assertThat(key, greaterThan(deduped.get(deduped.size() - 1))); } else { assertThat(key, lessThanOrEqualTo(deduped.get(idx))); } } }
@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 testClampValue() { PreferenceDomain d = PreferenceDomain.fromString("[1.0,5.0]"); for (Map<Long,Double> vec: someMaps(longs(), doubles(0.0, 8.0))) { Long2DoubleMap clamped = d.clampVector(vec); assertThat(clamped.keySet(), equalTo(vec.keySet())); for (Long k: vec.keySet()) { double v = vec.get(k); if (v < 1.0) { assertThat(clamped, hasEntry(k, 1.0)); } else if (v > 5.0) { assertThat(clamped, hasEntry(k, 5.0)); } else { assertThat(clamped, hasEntry(k, v)); } } } } }
@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())); } }
for (List<Byte> keys: someSortedLists(bytes(), 10, 50)) {
@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)); } } }
@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 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 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 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 testUnitVector() { for (Map<Long,Double> map: someMaps(longs(), doubles(-100, 100))) { if (map.isEmpty()) { continue; } Long2DoubleMap vec = LongUtils.frozenMap(map); double norm = Vectors.euclideanNorm(vec); Long2DoubleMap unit = Vectors.unitVector(vec); assertThat(unit.size(), equalTo(vec.size())); assertThat(unit.keySet(), equalTo(vec.keySet())); assertThat(Vectors.euclideanNorm(unit), closeTo(1.0, 1.0e-6)); Long2DoubleMaps.fastForEach(unit, e -> { assertThat(e.getDoubleValue() * norm, closeTo(vec.get(e.getLongKey()), 1.0e-6)); }); } } }