private void testIntOperation(Supplier<Integer> intSupplier, Cache<Integer, String> cache) { int range = 10; // First populate the cache with a bunch of values IntStream.range(0, range).boxed().forEach(i -> cache.put(i, i + "-value")); assertEquals(range, cache.size()); assertEquals((range - 1) * (range / 2), intSupplier.get().intValue()); }
private Optional<ScmInfo> generateScmInfoForAllFile(Component file) { if (file.getFileAttributes().getLines() == 0) { return Optional.empty(); } Set<Integer> newOrChangedLines = IntStream.rangeClosed(1, file.getFileAttributes().getLines()).boxed().collect(Collectors.toSet()); return Optional.of(GeneratedScmInfo.create(analysisMetadata.getAnalysisDate(), newOrChangedLines)); }
private static boolean checkParamsMatch(final List<FunctionParameter> functionArgTypes, final List<Schema> suppliedParamTypes) { if (functionArgTypes.size() != suppliedParamTypes.size()) { return false; } return IntStream.range(0, suppliedParamTypes.size()) .boxed() .allMatch(idx -> functionArgTypes.get(idx).matches(suppliedParamTypes.get(idx))); }
/** * Creates list of trees. * * @param treesQueue Trees queue. * @return List of trees. */ protected ArrayList<TreeRoot> initTrees(Queue<TreeNode> treesQueue) { assert featuresPerTree > 0; ArrayList<TreeRoot> roots = new ArrayList<>(); List<Integer> allFeatureIds = IntStream.range(0, meta.size()).boxed().collect(Collectors.toList()); for (TreeNode node : treesQueue) { Collections.shuffle(allFeatureIds, random); Set<Integer> featuresSubspace = allFeatureIds.stream() .limit(featuresPerTree).collect(Collectors.toSet()); roots.add(new TreeRoot(node, featuresSubspace)); } return roots; }
public void testKeyFilter() { Cache<Integer, String> cache = getCache(0); int range = 12; // First populate the cache with a bunch of values IntStream.range(0, range).boxed().forEach(i -> cache.put(i, i + "-value")); assertEquals(range, cache.size()); CacheSet<Map.Entry<Integer, String>> entrySet = cache.entrySet(); Set<Integer> keys = IntStream.of(2, 5, 8, 3, 1, range + 2).boxed().collect(Collectors.toSet()); assertEquals(keys.size() - 1, createStream(entrySet).filterKeys(keys).count()); } }
@Test public void testArrayShuffle() { List<Integer> expected = IntStream.rangeClosed(1, 500).boxed().collect(toList()); Set<List<Integer>> distinctResults = new HashSet<>(); distinctResults.add(expected); for (int i = 0; i < 3; i++) { MaterializedResult results = computeActual(format("SELECT shuffle(ARRAY %s) FROM orders LIMIT 10", expected)); List<MaterializedRow> rows = results.getMaterializedRows(); assertEquals(rows.size(), 10); for (MaterializedRow row : rows) { List<Integer> actual = (List<Integer>) row.getField(0); // check if the result is a correct permutation assertEqualsIgnoreOrder(actual, expected); distinctResults.add(actual); } } assertTrue(distinctResults.size() >= 24, "shuffle must produce at least 24 distinct results"); }
private static ScmInfo convertToScmInfo(ScannerReport.Changesets changesets) { return new ScmInfoImpl(IntStream.rangeClosed(1, changesets.getChangesetIndexByLineCount()) .boxed() .collect(Collectors.toMap(x -> x, new LineIndexToChangeset(changesets), MoreCollectors.mergeNotSupportedMerger(), LinkedHashMap::new))); }
@Override protected Stream<String> getQueryResourcePaths() { return IntStream.range(1, 100) .boxed() .flatMap(i -> { String queryId = format("q%02d", i); if (i == 14 || i == 23 || i == 24 || i == 39) { return Stream.of(queryId + "_1", queryId + "_2"); } return Stream.of(queryId); }) .map(queryId -> format("/sql/presto/tpcds/%s.sql", queryId)); }
public void testObjMin() { Cache<Integer, String> cache = getCache(0); int range = 10; // First populate the cache with a bunch of values IntStream.range(0, range).boxed().forEach(i -> cache.put(i, i + "-value")); assertEquals(range, cache.size()); CacheSet<Map.Entry<Integer, String>> entrySet = cache.entrySet(); assertEquals(Integer.valueOf(0), createStream(entrySet).min((e1, e2) -> Integer.compare(e1.getKey(), e2.getKey())).get().getKey()); }
@Test public void testAllArities() { for (int arity = MIN_ARITY; arity <= MAX_ARITY; arity++) { String[] arguments = IntStream.rangeClosed(1, arity) .mapToObj(index -> "ARRAY[" + index + "]") .toArray(String[]::new); Type[] types = IntStream.rangeClosed(1, arity) .mapToObj(index -> INTEGER) .toArray(Type[]::new); assertFunction( format("zip(%s)", join(", ", list(arguments))), zipReturnType(types), list(IntStream.rangeClosed(1, arity).boxed().collect(toList()))); } }
public ScmInfoRepositoryRule setScmInfo(int fileRef, Changeset... changesetList) { Map<Integer, Changeset> changeset = IntStream.rangeClosed(1, changesetList.length).boxed().collect(Collectors.toMap(x -> x, x -> changesetList[x - 1])); scmInfoByFileRef.put(fileRef, new ScmInfoImpl(changeset)); return this; }