@Override public Sequence run(QueryPlus queryPlus, Map responseContext) { try { latch.await(); return Sequences.simple(Collections.singletonList(1)); } catch (InterruptedException ex) { throw new RuntimeException(ex); } } };
private <T> OrderedMergeSequence<T> makeMergedSequence( Ordering<T> ordering, List<TestSequence<T>> seqs ) { return new OrderedMergeSequence<T>( ordering, Sequences.simple((List<Sequence<T>>) (List) seqs) ); }
private <T> MergeSequence<T> makeUnorderedMergedSequence( Ordering<T> ordering, List<TestSequence<T>> seqs ) { return new MergeSequence<T>(ordering, Sequences.simple(seqs)); }
@Override public QueryRunner<Result<SearchResultValue>> mergeRunners( ExecutorService queryExecutor, Iterable<QueryRunner<Result<SearchResultValue>>> queryRunners ) { return new ConcatQueryRunner<>(Sequences.simple(queryRunners)); }
@Override public Sequence<Result<TimeseriesResultValue>> run( QueryPlus<Result<TimeseriesResultValue>> queryPlus, Map<String, Object> responseContext ) { if (queryPlus.getQuery().getDataSource().equals(new TableDataSource("ds1"))) { return Sequences.simple(descending ? Lists.reverse(ds1) : ds1); } else { return Sequences.simple(descending ? Lists.reverse(ds2) : ds2); } } }
@Test public void testNothing() throws Exception { final List<Integer> vals = Collections.emptyList(); SequenceTestHelper.testAll(Sequences.simple(vals), vals); }
@Test public void testSanity() throws Exception { final List<Integer> vals = Arrays.asList(1, 2, 3, 4, 5); SequenceTestHelper.testAll(Sequences.simple(vals), vals); }
@Test public void testOrderByWithLimit() { List<String> expected = rawInput.subList(0, Math.min(limit, rawInput.size())); List<String> inputs = Lists.newArrayList(rawInput); Collections.shuffle(inputs, new Random(2)); Sequence<String> result = new TopNSequence<String>(Sequences.simple(inputs), ordering, limit); Assert.assertEquals(expected, result.toList()); } }
private List<String> wrapAndReturn( final CachePopulator populator, final Cache.NamedKey key, final List<String> strings ) { return populator.wrap(Sequences.simple(strings), s -> ImmutableMap.of("s", s), cache, key).toList(); }
@Benchmark @BenchmarkMode(Mode.AverageTime) @OutputTimeUnit(TimeUnit.MILLISECONDS) public void mergeFlat(final Blackhole blackhole) { MergeSequence<Integer> mergeSequence = new MergeSequence<>(Ordering.natural(), Sequences.simple(sequences)); Integer accumulate = mergeSequence.accumulate(0, Integer::sum); blackhole.consume(accumulate); } }
@Test public void testMergeOne() throws Exception { final Sequence<Integer> mergeOne = new MergeSequence<>( Ordering.natural(), Sequences.simple( Collections.singletonList(TestSequence.create(1)) ) ); SequenceTestHelper.testAll(mergeOne, Collections.singletonList(1)); }
@Test public void testLazinessYielder() throws Exception { final ArrayList<Sequence<Integer>> sequences = makeSyncedSequences(); OrderedMergeSequence<Integer> seq = new OrderedMergeSequence<Integer>( Ordering.natural(), Sequences.simple(sequences) ); SequenceTestHelper.testYield("", seq, Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9)); }
@Test public void testTwo() throws Exception { final List<Integer> nums = Arrays.asList(0, 1, 2, 3, 4, 5, 6, 7, 8, 9); final int threshold = 2; SequenceTestHelper.testAll( Sequences.simple(nums).limit(threshold), Lists.newArrayList(Iterables.limit(nums, threshold)) ); }
@Test public void testOne() throws Exception { final List<Integer> nums = Arrays.asList(0, 1, 2, 3, 4, 5, 6, 7, 8, 9); final int threshold = 1; SequenceTestHelper.testAll( Sequences.simple(nums).limit(threshold), Lists.newArrayList(Iterables.limit(nums, threshold)) ); }
@Test public void testLazinessAccumulation() { final ArrayList<Sequence<Integer>> sequences = makeSyncedSequences(); OrderedMergeSequence<Integer> seq = new OrderedMergeSequence<Integer>( Ordering.natural(), Sequences.simple(sequences) ); SequenceTestHelper.testAccumulation("", seq, Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9)); }
@Test public void testSanityAccumulate() throws Exception { final List<Integer> nums = Arrays.asList(0, 1, 2, 3, 4, 5, 6, 7, 8, 9); final int threshold = 5; SequenceTestHelper.testAll( Sequences.simple(nums).limit(threshold), Lists.newArrayList(Iterables.limit(nums, threshold)) ); }
@Test public void testSanity() throws Exception { final AtomicInteger closedCounter = new AtomicInteger(0); Closeable closeable = () -> closedCounter.incrementAndGet(); final List<Integer> nums = Arrays.asList(1, 2, 3, 4, 5); SequenceTestHelper.testAll(Sequences.simple(nums).withBaggage(closeable), nums); Assert.assertEquals(3, closedCounter.get()); closedCounter.set(0); SequenceTestHelper.testClosed(closedCounter, new UnsupportedSequence().withBaggage(closeable)); }
@Override public Sequence<Row> run(QueryPlus<Row> queryPlus, Map<String, Object> responseContext) { return Sequences .simple( ImmutableList.of( theRunner.run(queryPlus, responseContext), theRunner2.run(queryPlus, responseContext) ) ) .flatMerge(Function.identity(), queryPlus.getQuery().getResultOrdering()); } }
@Override public Sequence<Row> run(QueryPlus<Row> queryPlus, Map<String, Object> responseContext) { return Sequences .simple( ImmutableList.of( theRunner.run(queryPlus, responseContext), theRunner2.run(queryPlus, responseContext) ) ) .flatMerge(Function.identity(), queryPlus.getQuery().getResultOrdering()); } }
@Override public Sequence<Row> run(QueryPlus<Row> queryPlus, Map<String, Object> responseContext) { return Sequences .simple( ImmutableList.of( theRunner.run(queryPlus, responseContext), theRunner2.run(queryPlus, responseContext) ) ) .flatMerge(Function.identity(), queryPlus.getQuery().getResultOrdering()); } }