test/jdk/java/net/httpclient/DependentPromiseActionsTest.java
changeset 49944 4690a2871b44
parent 49765 ee6f7a61f3a5
child 50681 4254bed3c09d
child 56507 2294c51eae30
equal deleted inserted replaced
49943:8e1ed2a15845 49944:4690a2871b44
   175                 https2URI_fixed,
   175                 https2URI_fixed,
   176                 https2URI_chunk,
   176                 https2URI_chunk,
   177         };
   177         };
   178     }
   178     }
   179 
   179 
       
   180     enum SubscriberType {EAGER, LAZZY}
       
   181 
   180     static final class SemaphoreStallerSupplier
   182     static final class SemaphoreStallerSupplier
   181             implements Supplier<SemaphoreStaller> {
   183             implements Supplier<SemaphoreStaller> {
   182         @Override
   184         @Override
   183         public SemaphoreStaller get() {
   185         public SemaphoreStaller get() {
   184             return new SemaphoreStaller();
   186             return new SemaphoreStaller();
   289             throws Exception
   291             throws Exception
   290     {
   292     {
   291         String test = format("testAsStringAsync(%s, %b, %s)",
   293         String test = format("testAsStringAsync(%s, %b, %s)",
   292                 uri, sameClient, stallers);
   294                 uri, sameClient, stallers);
   293         testDependent(test, uri, sameClient, BodyHandlers::ofString,
   295         testDependent(test, uri, sameClient, BodyHandlers::ofString,
   294                 this::finish, this::extractString, stallers);
   296                 this::finish, this::extractString, stallers,
       
   297                 SubscriberType.EAGER);
   295     }
   298     }
   296 
   299 
   297     @Test(dataProvider = "variants")
   300     @Test(dataProvider = "variants")
   298     public void testAsLinesAsync(String uri,
   301     public void testAsLinesAsync(String uri,
   299                                  boolean sameClient,
   302                                  boolean sameClient,
   301             throws Exception
   304             throws Exception
   302     {
   305     {
   303         String test = format("testAsLinesAsync(%s, %b, %s)",
   306         String test = format("testAsLinesAsync(%s, %b, %s)",
   304                 uri, sameClient, stallers);
   307                 uri, sameClient, stallers);
   305         testDependent(test, uri, sameClient, BodyHandlers::ofLines,
   308         testDependent(test, uri, sameClient, BodyHandlers::ofLines,
   306                 this::finish, this::extractStream, stallers);
   309                 this::finish, this::extractStream, stallers,
       
   310                 SubscriberType.LAZZY);
   307     }
   311     }
   308 
   312 
   309     @Test(dataProvider = "variants")
   313     @Test(dataProvider = "variants")
   310     public void testAsInputStreamAsync(String uri,
   314     public void testAsInputStreamAsync(String uri,
   311                                        boolean sameClient,
   315                                        boolean sameClient,
   313             throws Exception
   317             throws Exception
   314     {
   318     {
   315         String test = format("testAsInputStreamAsync(%s, %b, %s)",
   319         String test = format("testAsInputStreamAsync(%s, %b, %s)",
   316                 uri, sameClient, stallers);
   320                 uri, sameClient, stallers);
   317         testDependent(test, uri, sameClient, BodyHandlers::ofInputStream,
   321         testDependent(test, uri, sameClient, BodyHandlers::ofInputStream,
   318                 this::finish, this::extractInputStream, stallers);
   322                 this::finish, this::extractInputStream, stallers,
       
   323                 SubscriberType.LAZZY);
   319     }
   324     }
   320 
   325 
   321     private <T,U> void testDependent(String name, String uri, boolean sameClient,
   326     private <T,U> void testDependent(String name, String uri, boolean sameClient,
   322                                      Supplier<BodyHandler<T>> handlers,
   327                                      Supplier<BodyHandler<T>> handlers,
   323                                      Finisher finisher,
   328                                      Finisher finisher,
   324                                      Extractor<T> extractor,
   329                                      Extractor<T> extractor,
   325                                      Supplier<Staller> stallers)
   330                                      Supplier<Staller> stallers,
       
   331                                      SubscriberType subscriberType)
   326             throws Exception
   332             throws Exception
   327     {
   333     {
   328         out.printf("%n%s%s%n", now(), name);
   334         out.printf("%n%s%s%n", now(), name);
   329         try {
   335         try {
   330             testDependent(uri, sameClient, handlers, finisher, extractor, stallers);
   336             testDependent(uri, sameClient, handlers, finisher,
       
   337                           extractor, stallers, subscriberType);
   331         } catch (Error | Exception x) {
   338         } catch (Error | Exception x) {
   332             FAILURES.putIfAbsent(name, x);
   339             FAILURES.putIfAbsent(name, x);
   333             throw x;
   340             throw x;
   334         }
   341         }
   335     }
   342     }
   336 
   343 
   337     private <T,U> void testDependent(String uri, boolean sameClient,
   344     private <T,U> void testDependent(String uri, boolean sameClient,
   338                                      Supplier<BodyHandler<T>> handlers,
   345                                      Supplier<BodyHandler<T>> handlers,
   339                                      Finisher finisher,
   346                                      Finisher finisher,
   340                                      Extractor<T> extractor,
   347                                      Extractor<T> extractor,
   341                                      Supplier<Staller> stallers)
   348                                      Supplier<Staller> stallers,
       
   349                                      SubscriberType subscriberType)
   342             throws Exception
   350             throws Exception
   343     {
   351     {
   344         HttpClient client = null;
   352         HttpClient client = null;
   345         for (Where where : EnumSet.of(Where.BODY_HANDLER)) {
   353         for (Where where : EnumSet.of(Where.BODY_HANDLER)) {
   346             if (!sameClient || client == null)
   354             if (!sameClient || client == null)
   353                     new StallingPushPromiseHandler<>(where, handlers, stallers);
   361                     new StallingPushPromiseHandler<>(where, handlers, stallers);
   354             BodyHandler<T> handler = handlers.get();
   362             BodyHandler<T> handler = handlers.get();
   355             System.out.println("try stalling in " + where);
   363             System.out.println("try stalling in " + where);
   356             CompletableFuture<HttpResponse<T>> responseCF =
   364             CompletableFuture<HttpResponse<T>> responseCF =
   357                     client.sendAsync(req, handler, promiseHandler);
   365                     client.sendAsync(req, handler, promiseHandler);
   358             assert !responseCF.isDone();
   366             assert subscriberType == SubscriberType.LAZZY || !responseCF.isDone();
   359             finisher.finish(where, responseCF, promiseHandler, extractor);
   367             finisher.finish(where, responseCF, promiseHandler, extractor);
   360         }
   368         }
   361     }
   369     }
   362 
   370 
   363     enum Where {
   371     enum Where {