Java Code Examples for java.util.stream.Stream

The following examples show how to use java.util.stream.Stream. These examples are extracted from open source projects. You can vote up the ones you like or vote down the ones you don't like, and go to the original project or source file by following the links above each example. You may want to check out the right sidebar which shows the related API usage.
Example 1
Source Project: component-runtime   Source File: ContainerProviderRule.java    License: Apache License 2.0 6 votes vote down vote up
@Override
public Object resolveParameter(final ParameterContext parameterContext, final ExtensionContext extensionContext)
        throws ParameterResolutionException {
    if (super.supports(parameterContext.getParameter().getType())) {
        return super.findInstance(extensionContext, parameterContext.getParameter().getType());
    }
    final DependenciesTxtBuilder builder = new DependenciesTxtBuilder();
    final String[] deps = parameterContext.getParameter().getAnnotation(Instance.class).value();
    Stream.of(deps).forEach(builder::withDependency);
    return manager
            .get()
            .builder(extensionContext.getRequiredTestClass().getName() + "."
                    + extensionContext.getRequiredTestMethod().getName() + "#" + manager.get().findAll().size(),
                    create(builder.build()).getAbsolutePath())
            .create();
}
 
Example 2
Source Project: jaxrs-analyzer   Source File: ProjectAnalyzerTest.java    License: Apache License 2.0 6 votes vote down vote up
@Before
public void setUp() throws MalformedURLException {
    LogProvider.injectDebugLogger(System.out::println);

    final String testClassPath = "src/test/jaxrs-test";

    // invoke compilation for jaxrs-test classes
    final JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
    final StandardJavaFileManager fileManager = compiler.getStandardFileManager(null, null, null);
    final List<JavaFileObject> compilationUnits = findClassFiles(testClassPath, fileManager);

    final JavaCompiler.CompilationTask compilationTask = compiler.getTask(null, null, null, singletonList("-g"), null, compilationUnits);
    assertTrue("Could not compile test project", compilationTask.call());

    path = Paths.get(testClassPath).toAbsolutePath();

    final Set<Path> classPaths = Stream.of(System.getProperty("java.class.path").split(File.pathSeparator))
            .map(Paths::get)
            .collect(Collectors.toSet());

    classPaths.add(path);
    classUnderTest = new ProjectAnalyzer(classPaths);
}
 
Example 3
@Test
public void should_summarize_a_non_empty_stream_with_correct_substreams_content() {
    // Given
    Stream<String> strings = Stream.of("2", "4", "2", "4", "2", "4", "2");
    int groupingFactor = 2;
    LongSummaryStatistics stats = new LongSummaryStatistics();
    stats.accept(2L);
    stats.accept(4L);

    // When
    Stream<LongSummaryStatistics> summarizedStream = StreamsUtils.shiftingWindowSummarizingLong(strings, groupingFactor, Long::parseLong);
    List<LongSummaryStatistics> result = summarizedStream.collect(toList());

    // When
    assertThat(result.size()).isEqualTo(6);
    assertThat(result.get(0).toString()).isEqualTo(stats.toString());
    assertThat(result.get(1).toString()).isEqualTo(stats.toString());
    assertThat(result.get(2).toString()).isEqualTo(stats.toString());
    assertThat(result.get(3).toString()).isEqualTo(stats.toString());
    assertThat(result.get(4).toString()).isEqualTo(stats.toString());
    assertThat(result.get(5).toString()).isEqualTo(stats.toString());
}
 
Example 4
@Test
public void testSplitIterator() {
    PageFetcherCurrentAndTotalPagesSplitIterator<Integer> integerPageFetcherSplitIterator = new PageFetcherCurrentAndTotalPagesSplitIterator<>(pageToFetch -> {
        // return fake paginated result

        int startIdx = pageToFetch * 10;
        int endIdx = pageToFetch == 5 ? (pageToFetch + 1) * 10 - 5 : (pageToFetch + 1) * 10;

        List<Integer> collect = IntStream.range(startIdx, endIdx).boxed().collect(Collectors.toList());
        ListWithLastPage<Integer> list = new ListWithLastPage<>();
        list.setList(collect);
        list.setLastPage(5);
        return list;
    }, 0);

    Stream<Integer> stream = StreamSupport.stream(integerPageFetcherSplitIterator, false);

    assertEquals(
            IntStream.range(0, 55).boxed().collect(Collectors.toList()),
            stream.collect(Collectors.toList())
    );
}
 
Example 5
Source Project: rheem   Source File: FlinkIntegrationIT.java    License: Apache License 2.0 6 votes vote down vote up
@Test
public void testMultiSourceAndHoleAndMultiSink() throws URISyntaxException {
    // Define some input data.
    final List<String> collection1 = Arrays.asList("This is source 1.", "This is source 1, too.");
    final List<String> collection2 = Arrays.asList("This is source 2.", "This is source 2, too.");
    List<String> collector1 = new LinkedList<>();
    List<String> collector2 = new LinkedList<>();
    final RheemPlan rheemPlan = RheemPlans.multiSourceHoleMultiSink(collection1, collection2, collector1, collector2);


    makeAndRun(rheemPlan, FLINK);

    // Check the results in both sinks.
    List<String> expectedOutcome = Stream.concat(collection1.stream(), collection2.stream())
            .flatMap(string -> Arrays.asList(string.toLowerCase(), string.toUpperCase()).stream())
            .collect(Collectors.toList());
    Collections.sort(expectedOutcome);
    Collections.sort(collector1);
    Collections.sort(collector2);
    Assert.assertEquals(expectedOutcome, collector1);
    Assert.assertEquals(expectedOutcome, collector2);
}
 
Example 6
Source Project: amdb-proxy   Source File: DBServiceTest.java    License: Apache License 2.0 6 votes vote down vote up
@Test
void testInfo() throws IOException {
  Request<InfoRequest> request = new Request<InfoRequest>();
  request.setOp("info");

  InfoRequest params = new InfoRequest();
  params.setBlockHash("00000");
  params.setNum(100);
  params.setTable("t_demo");

  request.setParams(params);
  String content = objectMapper.writeValueAsString(request);
  String result = dbService.process(content);

  MockResponse<InfoResponse> response =
      objectMapper.readValue(result, new TypeReference<MockResponse<InfoResponse>>() {});

  assertEquals(response.getCode(), new Integer(0));
  InfoResponse info = (InfoResponse) response.getResult();

  assertLinesMatch(info.getIndices(),
      Stream.of("field1", "field2", "field3").collect(Collectors.toList()));
}
 
Example 7
@Test
public void should_accumulate_an_entry_stream_into_the_correct_entry_stream() {
    // Given
    Stream<Map.Entry<Integer, String>> entries =
            Stream.of(
                    new AbstractMap.SimpleEntry<>(1, "1"),
                    new AbstractMap.SimpleEntry<>(2, "2"),
                    new AbstractMap.SimpleEntry<>(3, "3"),
                    new AbstractMap.SimpleEntry<>(4, "4")
            );

    // When
    Stream<Map.Entry<Integer, String>> accumulate = StreamsUtils.accumulateEntries(entries, String::concat);

    // Then
    assertThat(accumulate.collect(toList())).containsExactly(
            new AbstractMap.SimpleEntry<>(1, "1"),
            new AbstractMap.SimpleEntry<>(2, "12"),
            new AbstractMap.SimpleEntry<>(3, "123"),
            new AbstractMap.SimpleEntry<>(4, "1234")
    );
}
 
Example 8
Source Project: durian   Source File: FieldsAndGetters.java    License: Apache License 2.0 6 votes vote down vote up
/**
 * Returns a {@code Stream} of all public getter methods which match {@code predicate} and their return values for the given object.
 * <p>
 * This method uses reflection to find all of the public instance methods which don't take any arguments
 * and return a value.  If they pass the given predicate, then they are called, and the return value is
 * included in a stream of {@code Map.Entry<Method, Object>}.
 * <p>
 * Note that there are some methods which have the signature of a getter, but actually mutate the object
 * being inspected, e.g. {@link java.io.InputStream#read()}.  These will be called unless you manually
 * exclude them using the predicate.
 */
public static Stream<Map.Entry<Method, Object>> getters(Object obj, Predicate<Method> predicate) {
	Class<?> clazz = obj == null ? ObjectIsNull.class : obj.getClass();
	return Arrays.asList(clazz.getMethods()).stream()
			// we only want methods that don't take parameters
			.filter(method -> method.getParameterTypes().length == 0)
			// we only want public methods
			.filter(method -> Modifier.isPublic(method.getModifiers()))
			// we only want instance methods
			.filter(method -> !Modifier.isStatic(method.getModifiers()))
			// we only want methods that don't return void
			.filter(method -> !method.getReturnType().equals(Void.TYPE))
			// we only want methods that pass our predicate
			.filter(predicate)
			// turn it into Map<Method, Result>
			.map(method -> createEntry(method, tryCall(method.getName(), () -> method.invoke(obj))));
}
 
Example 9
Source Project: component-runtime   Source File: ClientSetup.java    License: Apache License 2.0 6 votes vote down vote up
private ClientBuilder createClient(final ExecutorService executor, final Optional<String> keystoreLocation,
        final Optional<String> keystoreType, final String keystorePassword, final Optional<String> truststoreType,
        final List<String> serverHostnames) {
    final ClientBuilder builder = ClientBuilder.newBuilder();
    builder.connectTimeout(connectTimeout, MILLISECONDS);
    builder.readTimeout(readTimeout, MILLISECONDS);
    builder.executorService(executor);
    if (acceptAnyCertificate) {
        builder.hostnameVerifier((host, session) -> true);
        builder.sslContext(createUnsafeSSLContext());
    } else if (keystoreLocation.isPresent()) {
        builder.hostnameVerifier((host, session) -> serverHostnames.contains(host));
        builder.sslContext(createSSLContext(keystoreLocation, keystoreType, keystorePassword, truststoreType));
    }
    providers.map(it -> Stream.of(it.split(",")).map(String::trim).filter(v -> !v.isEmpty()).map(fqn -> {
        try {
            return Thread.currentThread().getContextClassLoader().loadClass(fqn).getConstructor().newInstance();
        } catch (final Exception e) {
            log.warn("Can't add provider " + fqn + ": " + e.getMessage(), e);
            return null;
        }
    }).filter(Objects::nonNull)).ifPresent(it -> it.forEach(builder::register));
    return ClientTracingRegistrar.configure(builder);
}
 
Example 10
@Test
public void getCaseInstanceWithTwoInvolvedGroups() {
    CaseInstance caseInstance = cmmnRuntimeService.createCaseInstanceBuilder()
            .caseDefinitionKey("oneTaskCase")
            .start();
    cmmnRuntimeService.addGroupIdentityLink(caseInstance.getId(), "testGroup", IdentityLinkType.PARTICIPANT);
    cmmnRuntimeService.addGroupIdentityLink(caseInstance.getId(), "testGroup2", IdentityLinkType.PARTICIPANT);

    assertThat(cmmnHistoryService.createHistoricCaseInstanceQuery().involvedGroups(
            Stream.of("testGroup", "testGroup2", "testGroup3").collect(Collectors.toSet())).count())
            .isEqualTo(1);
    assertThat(cmmnHistoryService.createHistoricCaseInstanceQuery().involvedGroups(
            Stream.of("testGroup", "testGroup2", "testGroup3").collect(Collectors.toSet())).list().get(0).getId()).isEqualTo(caseInstance.getId());
    assertThat(cmmnHistoryService.createHistoricCaseInstanceQuery().involvedGroups(
            Stream.of("testGroup", "testGroup2", "testGroup3").collect(Collectors.toSet())).singleResult().getId()).isEqualTo(caseInstance.getId());
}
 
Example 11
Source Project: pro   Source File: JShellConfigRunner.java    License: GNU General Public License v3.0 6 votes vote down vote up
private static void run(Path configFile, PropertySequence propertySeq, List<String> arguments) {
  //System.out.println("run with jshell " + configFile);
  
  var args =
    Stream.of(
      Stream.of("-R-XX:+EnableValhalla").filter(__ -> System.getProperty("valhalla.enableValhalla") != null),
      Stream.of("-R--add-modules=ALL-SYSTEM"),  // also add incubator modules
      Stream.of("-R--enable-preview"),
      Stream.of("-R-Dpro.exitOnError=false"),
      propertySeq.stream().map(entry -> "-D" + entry.getKey() + '=' + entry.getValue()),
      Stream.of(arguments).filter(a -> !a.isEmpty()).map(a -> "-R-Dpro.arguments=" + String.join(",", a)),
      Stream.of(configFile.toString())
      )
    .flatMap(s -> s)
    .toArray(String[]::new);
  
  int exitCode = JShellWrapper.run(System.in, System.out, System.err, args);
  if (exitCode != 0) {
    System.err.println("error while executing jshell " + String.join(" ", args));
  }
  System.exit(exitCode);
}
 
Example 12
Source Project: parquet-mr   Source File: TestColumnIndexFiltering.java    License: Apache License 2.0 6 votes vote down vote up
private static void assertContains(Stream<User> expected, List<User> actual) {
  Iterator<User> expIt = expected.iterator();
  if (!expIt.hasNext()) {
    return;
  }
  User exp = expIt.next();
  for (User act : actual) {
    if (act.equals(exp)) {
      if (!expIt.hasNext()) {
        break;
      }
      exp = expIt.next();
    }
  }
  assertFalse("Not all expected elements are in the actual list. E.g.: " + exp, expIt.hasNext());
}
 
Example 13
Source Project: openjdk-jdk9   Source File: GenModuleInfo.java    License: GNU General Public License v2.0 5 votes vote down vote up
private Set<String> packages(Path dir) {
    try (Stream<Path> stream = Files.find(dir, Integer.MAX_VALUE,
                         ((path, attrs) -> attrs.isRegularFile() &&
                                           path.toString().endsWith(".class")))) {
        return stream.map(path -> toPackageName(dir.relativize(path)))
                     .filter(pkg -> pkg.length() > 0)   // module-info
                     .distinct()
                     .collect(Collectors.toSet());
    } catch (IOException x) {
        throw new UncheckedIOException(x);
    }
}
 
Example 14
@Test
void multiple_StreamToSetWithDiffTypeMappingDuplicates_ReturnsSetOfMappedValuesWithDuplicates() {
    final Set<CompletableFuture<Integer>> futures = mapValuesToFutures(Stream.of("john", "john"),
        element -> completedFuture(element.length()), toSet());

    assertThat(futures).hasSize(2);
    assertThat(futures).isExactlyInstanceOf(HashSet.class);

    final List<Integer> results = futures.stream()
                                         .map(CompletableFuture::join)
                                         .collect(toList());


    assertThat(results).containsExactly(4, 4);
}
 
Example 15
@Test
public void should_conform_to_specified_trySplit_behavior() {
    // Given
    Stream<String> strings = Stream.of("a", "d", "c", "b");
    Stream<Map.Entry<String, String>> stream = StreamsUtils.crossProductNaturallyOrdered(strings);
    TryAdvanceCheckingSpliterator<Map.Entry<String, String>> spliterator = new TryAdvanceCheckingSpliterator<>(stream.spliterator());
    Stream<Map.Entry<String, String>> monitoredStream = StreamSupport.stream(spliterator, false);

    // When
    long count = monitoredStream.count();

    // Then
    assertThat(count).isEqualTo(6L);
}
 
Example 16
Source Project: tutorials   Source File: DoubleBraceUnitTest.java    License: MIT License 5 votes vote down vote up
@Test
public void whenInitializeUnmodifiableSetWithDoubleBrace_containsElements() {
     Set<String> countries = Stream.of("India", "USSR", "USA")
       .collect(collectingAndThen(toSet(), Collections::unmodifiableSet));

    assertTrue(countries.contains("India"));
}
 
Example 17
@Override
public <T> Optional<T> findData(MarketDataName<T> name) {
  if (name instanceof CurveName) {
    return Stream.concat(repoCurves.values().stream(), issuerCurves.values().stream())
        .map(df -> df.findData(name))
        .filter(opt -> opt.isPresent())
        .map(opt -> opt.get())
        .findFirst();
  }
  return Optional.empty();
}
 
Example 18
Source Project: mobi   Source File: SimpleOntology.java    License: GNU Affero General Public License v3.0 5 votes vote down vote up
private Stream<IRI> getSubClassesFor(OWLClass owlClass, boolean direct) {
    if (direct) {
        return owlOntology.axioms(AxiomType.SUBCLASS_OF, Imports.INCLUDED)
                .filter(axiom -> axiom.getSuperClass().equals(owlClass))
                .map(OWLSubClassOfAxiom::getSubClass)
                .filter(subclass -> !subclass.isBottomEntity() && subclass.isOWLClass()
                            && !subclass.asOWLClass().getIRI().equals(owlClass.getIRI()))
                .map(subclass -> SimpleOntologyValues.mobiIRI(subclass.asOWLClass().getIRI()));
    } else {
        return owlReasoner.getSubClasses(owlClass, false).entities()
                .filter(subclass -> !subclass.isBottomEntity() && !subclass.getIRI().equals(owlClass.getIRI()))
                .map(subclass -> SimpleOntologyValues.mobiIRI(subclass.getIRI()));
    }
}
 
Example 19
Source Project: openjdk-8   Source File: StreamBuilderTest.java    License: GNU General Public License v2.0 5 votes vote down vote up
@Test(dataProvider = "sizes")
public void testAfterBuilding(int size) {
    Stream.Builder<Integer> sb = Stream.builder();
    IntStream.range(0, size).boxed().forEach(sb);
    sb.build();

    checkISE(() -> sb.accept(1));
    checkISE(() -> sb.add(1));
    checkISE(() -> sb.build());
}
 
Example 20
Source Project: attic-polygene-java   Source File: EntityStateSerializer.java    License: Apache License 2.0 5 votes vote down vote up
private void serializeAssociations( final EntityState entityState,
                                    final Graph graph, URI entityUri,
                                    final Stream<? extends AssociationDescriptor> associations,
                                    final boolean includeNonQueryable
)
{
    ValueFactory values = graph.getValueFactory();

    // Associations
    associations.filter( type -> includeNonQueryable || type.queryable() ).forEach(
        associationType ->
        {
            EntityReference associatedId
                = entityState
                .associationValueOf(
                    associationType
                        .qualifiedName() );
            if( associatedId != null )
            {
                URI assocURI = values
                    .createURI(
                        associationType
                            .qualifiedName()
                            .toURI() );
                URI assocEntityURI
                    = values.createURI(
                    associatedId
                        .toURI() );
                graph.add( entityUri,
                           assocURI,
                           assocEntityURI );
            }
        } );
}
 
Example 21
Source Project: txtUML   Source File: WizardUtils.java    License: Eclipse Public License 1.0 5 votes vote down vote up
@Override
protected IStatus run(IProgressMonitor monitor) {
	List<?> types = getTypes(cUnit);

	types.stream().filter(type -> {
		try {
			return Stream.of(superClasses).anyMatch(
					superClass -> SharedUtils.typeIsAssignableFrom((TypeDeclaration) type, superClass));
		} catch (NullPointerException ex) {
			return false;
		}
	}).forEach(type -> typesWithGivenSuperclass
			.add((IType) ((TypeDeclaration) type).resolveBinding().getJavaElement()));
	return Status.OK_STATUS;
}
 
Example 22
private Enrolment getDissertationEnrolment() {
    Stream<Enrolment> enrolments = getGroup().getEnrolmentsSet().stream().filter(Enrolment::isDissertation);

    List<Dismissal> dismissalsList = new ArrayList<>();
    getGroup().collectDismissals(dismissalsList);

    Stream<Enrolment> dismissals =
            dismissalsList.stream().flatMap(d -> d.getSourceIEnrolments().stream())
                    .filter(e -> e.isEnrolment() && ((Enrolment) e).isDissertation()).map(ie -> (Enrolment) ie);
    return Stream.concat(enrolments, dismissals).max(Enrolment.COMPARATOR_BY_EXECUTION_PERIOD_AND_ID).orElse(null);
}
 
Example 23
Source Project: tutorials   Source File: JOOLUnitTest.java    License: MIT License 5 votes vote down vote up
@Test
public void givenOperationThatThrowsCheckedException_whenExecuteUsingUncheckedFuction_shouldPass() {
    // when
    List<Integer> collect = Stream.of("a", "b", "c").map(Unchecked.function(this::methodThatThrowsChecked)).collect(Collectors.toList());

    // then
    assertEquals(collect, Arrays.asList(1, 1, 1));
}
 
Example 24
Source Project: centraldogma   Source File: DefaultMirroringService.java    License: Apache License 2.0 5 votes vote down vote up
private void schedulePendingMirrors() {
    final ZonedDateTime now = ZonedDateTime.now();
    if (lastExecutionTime == null) {
        lastExecutionTime = now.minus(TICK);
    }

    final ZonedDateTime currentLastExecutionTime = lastExecutionTime;
    lastExecutionTime = now;

    projectManager.list().values().stream()
                  .map(Project::metaRepo)
                  .flatMap(r -> {
                      try {
                          return r.mirrors().stream();
                      } catch (Exception e) {
                          logger.warn("Failed to load the mirror list from: {}", r.parent().name(), e);
                          return Stream.empty();
                      }
                  })
                  .filter(m -> m.nextExecutionTime(currentLastExecutionTime).compareTo(now) < 0)
                  .forEach(m -> {
                      final ListenableFuture<?> future = worker.submit(() -> run(m, true));
                      Futures.addCallback(future, new FutureCallback<Object>() {
                          @Override
                          public void onSuccess(@Nullable Object result) {}

                          @Override
                          public void onFailure(Throwable cause) {
                              logger.warn("Unexpected Git-to-CD mirroring failure: {}", m, cause);
                          }
                      }, MoreExecutors.directExecutor());
                  });
}
 
Example 25
Source Project: jdk8u60   Source File: ChangeDir.java    License: GNU General Public License v2.0 5 votes vote down vote up
/** Remove dirs & files needed for test. */
private static void cleanup(Path dir) {
    try {
        if (Files.isDirectory(dir)) {
            try (Stream<Path> s = Files.list(dir)) {
                s.forEach( p -> cleanup(p));
            }
        }
        Files.delete(dir);
    } catch (IOException x) {
        fail(x.toString());
    }
}
 
Example 26
private static List<Pair<CompileCodeTestCase, Class<? extends Throwable>>>
        createTestCasesIncorrectBci() {
    List<Pair<CompileCodeTestCase, Class<? extends Throwable>>> result
            = new ArrayList<>();
    try {
        Class<?> aClass = DummyClass.class;
        Object receiver = new DummyClass();
        Method method = aClass.getMethod("dummyInstanceFunction");
        // greater than bytecode.length
        byte[] bytecode = CompilerToVMHelper.getBytecode(CTVMUtilities
                .getResolvedMethod(method));
        Stream.of(
                // greater than bytecode.length
                bytecode.length + 4,
                bytecode.length + 50,
                bytecode.length + 200,
                // negative cases
                -4, -50, -200)
                .map(bci -> new Pair<CompileCodeTestCase,
                        Class<? extends Throwable>>(
                        new CompileCodeTestCase(receiver, method, bci),
                        IllegalArgumentException.class))
                .collect(Collectors.toList());
    } catch (NoSuchMethodException e) {
        throw new Error("TEST BUG : " + e.getMessage(), e);
    }
    return result;
}
 
Example 27
@DataProvider(name = "Stream.limit")
@SuppressWarnings("rawtypes")
public static Object[][] sliceFunctionsDataProvider() {
    Function<String, String> f = s -> String.format(s, SKIP_LIMIT_SIZE);

    List<Object[]> data = new ArrayList<>();

    data.add(new Object[]{f.apply("Stream.limit(%d)"),
            (UnaryOperator<Stream>) s -> s.limit(SKIP_LIMIT_SIZE)});
    data.add(new Object[]{f.apply("Stream.skip(%1$d).limit(%1$d)"),
            (UnaryOperator<Stream>) s -> s.skip(SKIP_LIMIT_SIZE).limit(SKIP_LIMIT_SIZE)});

    return data.toArray(new Object[0][]);
}
 
Example 28
Source Project: pravega   Source File: PravegaControllerK8sService.java    License: Apache License 2.0 5 votes vote down vote up
@Override
public List<URI> getServiceDetails() {
    //fetch the URI.
    return Futures.getAndHandleExceptions(k8sClient.getStatusOfPodWithLabel(NAMESPACE, "component", PRAVEGA_CONTROLLER_LABEL)
                                                   .thenApply(statuses -> statuses.stream()
                                                                                 .flatMap(s -> Stream.of(URI.create(TCP + s.getPodIP() + ":" + CONTROLLER_GRPC_PORT),
                                                                                                         URI.create(TCP + s.getPodIP() + ":" + CONTROLLER_REST_PORT)))
                                                                                 .collect(Collectors.toList())),
                                          t -> new TestFrameworkException(RequestFailed, "Failed to fetch ServiceDetails for pravega-controller", t));
}
 
Example 29
Source Project: webtester2-core   Source File: ReflectionUtils.java    License: Apache License 2.0 5 votes vote down vote up
public Stream<Field> allFieldsOfClassLineage(Class<?> testClass) {
    return getClassLineage(testClass).stream()
        .sequential()
        .flatMap(aClass -> Arrays.stream(aClass.getDeclaredFields()))
        .peek(field -> field.setAccessible(true));

}
 
Example 30
/**
 * Generic procedure for discovering request/exception handlers and request/response interceptors
 * from a controller's methods.
 *
 * Applies method discovery logic consistently for all mapping types:
 * <ul>
 *     <li>resolve a {@link Predicate} of {@link HandlerInput} from the method</li>
 *     <li>delegate responsibility to the underlying handler, but guard it with the predicate</li>
 *     <li>look for the {@link Priority} annotation on each method</li>
 *     <li>order each handler in the controller by its priority</li>
 *     <li>methods not annotated with {@link Priority} are considered to have priority 0</li>
 * </ul>
 *
 * @param controller scanned for methods with mappers
 * @param resolvers set of resolvers
 * @param guardBuilder supplies a {@link Guard.Builder} for this mapping type
 * @param <T> type of handler/interceptor/etc. being discovered, e.g. {@link RequestInterceptor}
 * @param <G> type of guard, e.g. {@link RequestInterceptorGuard}
 * @param <B> type of guard builder, e.g. {@link RequestInterceptorGuard#builder()}
 * @return stream of constructed delegates, ordered by priority
 */
protected <T, G extends Guard<T>, B extends Guard.Builder<B, T, G>> Stream<G> find(
    Object controller,
    Set<? extends Resolver<ControllerMethodContext, T>> resolvers,
    Supplier<B> guardBuilder) {

    return Arrays.stream(controller.getClass().getMethods())
        .map(method -> ControllerMethodContext.builder()
            .withSkillContext(skillContext)
            .withController(controller)
            .withMethod(method)
            .build())
        .flatMap(context -> {
            Predicate<HandlerInput> predicate = findPredicates(context).orElse(TRUE);

            return resolvers.stream()
                .flatMap(resolver -> resolver.resolve(context).map(Stream::of).orElse(Stream.empty()))
                .map(delegate -> guardBuilder.get()
                    .withDelegate(delegate)
                    .withPredicate(predicate)
                    .withPriority(Optional.ofNullable(context.getMethod().getAnnotation(Priority.class))
                        .map(Priority::value)
                        .orElse(0))) // default to the '0' bucket for methods not annotated with Priority
                .map(Guard.Builder::<G>build);
        })
        // sort in descending order, so "higher priority" is more intuitive
        .sorted((a, b) -> -1 * Integer.compare(a.getPriority(), b.getPriority()));
}