jdk-sandbox: comparison test/jdk/java/net/httpclient/DigestEchoClient.java

equal deleted inserted replaced

-:ffaea9a1eed5
+:66a9c3185028
 /**
 * @test
 * @summary this test verifies that a client may provides authorization
 *          headers directly when connecting with a server.
 * @bug 8087112
-* @library /lib/testlibrary
+* @library /lib/testlibrary http2/server
-* @build jdk.testlibrary.SimpleSSLContext DigestEchoServer DigestEchoClient
+* @build jdk.testlibrary.SimpleSSLContext HttpServerAdapters DigestEchoServer DigestEchoClient
-* @modules jdk.incubator.httpclient
+* @modules jdk.incubator.httpclient/jdk.incubator.http.internal.common
+*          jdk.incubator.httpclient/jdk.incubator.http.internal.frame
+*          jdk.incubator.httpclient/jdk.incubator.http.internal.hpack
+*          java.logging
+*          java.base/sun.net.www.http
 *          java.base/sun.net.www
 *          java.base/sun.net
 * @run main/othervm DigestEchoClient
 * @run main/othervm -Djdk.http.auth.proxying.disabledSchemes=
 *                   -Djdk.http.auth.tunneling.disabledSchemes=
 final DigestEchoServer.HttpAuthType authType;
 final DigestEchoServer.HttpAuthSchemeType authScheme;
 final String protocolScheme;
 final String key;
 final DigestEchoServer server;
+final Version serverVersion;
 private EchoServers(DigestEchoServer server,
+Version version,
 String protocolScheme,
 DigestEchoServer.HttpAuthType authType,
 DigestEchoServer.HttpAuthSchemeType authScheme) {
 this.authType = authType;
 this.authScheme = authScheme;
 this.protocolScheme = protocolScheme;
-this.key = key(protocolScheme, authType, authScheme);
+this.key = key(version, protocolScheme, authType, authScheme);
 this.server = server;
-}
+this.serverVersion = version;
+}
-static String key(String protocolScheme,
+static String key(Version version,
+String protocolScheme,
 DigestEchoServer.HttpAuthType authType,
 DigestEchoServer.HttpAuthSchemeType authScheme) {
-return String.format("%s:%s:%s", protocolScheme, authType, authScheme);
+return String.format("%s:%s:%s:%s", version, protocolScheme, authType, authScheme);
 }
-private static EchoServers create(String protocolScheme,
+private static EchoServers create(Version version,
+String protocolScheme,
 DigestEchoServer.HttpAuthType authType,
 DigestEchoServer.HttpAuthSchemeType authScheme) {
 try {
 serverCount.incrementAndGet();
 DigestEchoServer server =
-DigestEchoServer.create(protocolScheme, authType, authScheme);
+DigestEchoServer.create(version, protocolScheme, authType, authScheme);
-return new EchoServers(server, protocolScheme, authType, authScheme);
+return new EchoServers(server, version, protocolScheme, authType, authScheme);
 } catch (IOException x) {
 throw new UncheckedIOException(x);
 }
 }
-public static DigestEchoServer of(String protocolScheme,
+public static DigestEchoServer of(Version version,
+String protocolScheme,
 DigestEchoServer.HttpAuthType authType,
 DigestEchoServer.HttpAuthSchemeType authScheme) {
-String key = key(protocolScheme, authType, authScheme);
+String key = key(version, protocolScheme, authType, authScheme);
 return servers.computeIfAbsent(key, (k) ->
-create(protocolScheme, authType, authScheme)).server;
+create(version, protocolScheme, authType, authScheme)).server;
 }
 public static void stop() {
 for (EchoServers s : servers.values()) {
 s.server.stop();
 break;
 }
 return builder.build();
 }
+public static List<Version> serverVersions(Version clientVersion) {
+if (clientVersion == Version.HTTP_1_1) {
+return List.of(clientVersion);
+} else {
+return List.of(Version.values());
+}
+}
+public static List<Version> clientVersions() {
+return List.of(Version.values());
+}
+public static List<Boolean> expectContinue(Version serverVersion) {
+if (serverVersion == Version.HTTP_1_1) {
+return BOOLEANS;
+} else {
+// our test HTTP/2 server does not support Expect: 100-Continue
+return List.of(Boolean.FALSE);
+}
+}
 public static void main(String[] args) throws Exception {
 boolean useSSL = false;
 EnumSet<DigestEchoServer.HttpAuthType> types =
 EnumSet.complementOf(EnumSet.of(DigestEchoServer.HttpAuthType.PROXY305));
 if (args != null && args.length >= 1) {
 DigestEchoServer.HttpAuthSchemeType.BASIC);
 for (DigestEchoServer.HttpAuthSchemeType authScheme : basics) {
 DigestEchoClient dec = new DigestEchoClient(useSSL,
 authScheme,
 authType);
-for (Version version : HttpClient.Version.values()) {
+for (Version clientVersion : clientVersions()) {
-for (boolean expectContinue : BOOLEANS) {
+for (Version serverVersion : serverVersions(clientVersion)) {
-for (boolean async : BOOLEANS) {
+for (boolean expectContinue : expectContinue(serverVersion)) {
-for (boolean preemptive : BOOLEANS) {
+for (boolean async : BOOLEANS) {
-dec.testBasic(version, async,
+for (boolean preemptive : BOOLEANS) {
-expectContinue, preemptive);
+dec.testBasic(clientVersion,
+serverVersion, async,
+expectContinue, preemptive);
+}
 }
 }
 }
 }
 }
 EnumSet.of(DigestEchoServer.HttpAuthSchemeType.DIGEST);
 for (DigestEchoServer.HttpAuthSchemeType authScheme : digests) {
 DigestEchoClient dec = new DigestEchoClient(useSSL,
 authScheme,
 authType);
-for (Version version : HttpClient.Version.values()) {
+for (Version clientVersion : clientVersions()) {
-for (boolean expectContinue : BOOLEANS) {
+for (Version serverVersion : serverVersions(clientVersion)) {
-for (boolean async : BOOLEANS) {
+for (boolean expectContinue : expectContinue(serverVersion)) {
-dec.testDigest(version, async, expectContinue);
+for (boolean async : BOOLEANS) {
+dec.testDigest(clientVersion, serverVersion,
+async, expectContinue);
+}
 }
 }
 }
 }
 }
+} catch(Throwable t) {
+System.out.println("Unexpected exception: exiting: " + t);
+t.printStackTrace();
+throw t;
 } finally {
 EchoServers.stop();
 System.out.println(" ---------------------------------------------------------- ");
 System.out.println(String.format("DigestEchoClient %s %s", useSSL ? "SSL" : "CLEAR", types));
 System.out.println(String.format("Created %d clients and %d servers",
 }
 final static AtomicLong basics = new AtomicLong();
 final static AtomicLong basicCount = new AtomicLong();
 // @Test
-void testBasic(HttpClient.Version version, boolean async,
+void testBasic(Version clientVersion, Version serverVersion, boolean async,
 boolean expectContinue, boolean preemptive)
 throws Exception
 {
 final boolean addHeaders = authScheme == DigestEchoServer.HttpAuthSchemeType.BASICSERVER;
 // !preemptive has no meaning if we don't handle the authorization
 // headers ourselves
 if (!preemptive && !addHeaders) return;
-out.println(format("*** testBasic: version: %s,  async: %s, useSSL: %s, " +
+out.println(format("*** testBasic: client: %s, server: %s, async: %s, useSSL: %s, " +
 "authScheme: %s, authType: %s, expectContinue: %s preemptive: %s***",
-version, async, useSSL, authScheme, authType, expectContinue, preemptive));
+clientVersion, serverVersion, async, useSSL, authScheme, authType,
+expectContinue, preemptive));
-DigestEchoServer server = EchoServers.of(useSSL ? "https" : "http", authType, authScheme);
-URI uri = DigestEchoServer.uri(useSSL ? "https" : "http", server.getServerAddress(), "/foo/");
+DigestEchoServer server = EchoServers.of(serverVersion,
+useSSL ? "https" : "http", authType, authScheme);
+URI uri = DigestEchoServer.uri(useSSL ? "https" : "http",
+server.getServerAddress(), "/foo/");
 HttpClient client = newHttpClient(server);
 HttpResponse<String> r;
 CompletableFuture<HttpResponse<String>> cf1;
 String auth = null;
 out.println(DigestEchoServer.now() + " ----- iteration " + i + " -----");
 List<String> lines = List.of(Arrays.copyOfRange(data, 0, i+1));
 assert lines.size() == i + 1;
 String body = lines.stream().collect(Collectors.joining("\r\n"));
 HttpRequest.BodyPublisher reqBody = HttpRequest.BodyPublisher.fromString(body);
-HttpRequest.Builder builder = HttpRequest.newBuilder(uri).version(version)
+HttpRequest.Builder builder = HttpRequest.newBuilder(uri).version(clientVersion)
 .POST(reqBody).expectContinue(expectContinue);
 boolean isTunnel = isProxy(authType) && useSSL;
 if (addHeaders) {
 // handle authentication ourselves
 assert !client.authenticator().isPresent();
 throw new RuntimeException("Unexpected exception: " + t, t);
 }
 if (addHeaders && !preemptive && (i==0 || isSchemeDisabled())) {
 assert resp.statusCode() == 401 || resp.statusCode() == 407;
-request = HttpRequest.newBuilder(uri).version(version)
+System.out.println(String.format("%s received: adding header %s: %s",
+resp.statusCode(), authorizationKey(authType), auth));
+request = HttpRequest.newBuilder(uri).version(clientVersion)
 .POST(reqBody).header(authorizationKey(authType), auth).build();
 if (async) {
 resp = client.sendAsync(request, asLines()).join();
 } else {
 resp = client.send(request, asLines());
 continue;
 } else {
 System.out.println("Scheme enabled for [" + authType
 + ", " + authScheme
 + ", " + (useSSL ? "HTTPS" : "HTTP")
-+ "]: Expecting 200");
++ "]: Expecting 200, response is: " + resp);
-assert resp.statusCode() == 200;
+assert resp.statusCode() == 200 : "200 expected, received " + resp;
 respLines = resp.body().collect(Collectors.toList());
 }
 } finally {
 long stop = System.nanoTime();
 synchronized (basicCount) {
 }
 final static AtomicLong digests = new AtomicLong();
 final static AtomicLong digestCount = new AtomicLong();
 // @Test
-void testDigest(HttpClient.Version version, boolean async, boolean expectContinue)
+void testDigest(Version clientVersion, Version serverVersion,
+boolean async, boolean expectContinue)
 throws Exception
 {
-out.println(format("*** testDigest: version: %s,  async: %s, useSSL: %s, " +
+out.println(format("*** testDigest: client: %s, server: %s, async: %s, useSSL: %s, " +
 "authScheme: %s, authType: %s, expectContinue: %s  ***",
-version, async, useSSL, authScheme, authType, expectContinue));
+clientVersion, serverVersion, async, useSSL,
-DigestEchoServer server = EchoServers.of(useSSL ? "https" : "http", authType, authScheme);
+authScheme, authType, expectContinue));
+DigestEchoServer server = EchoServers.of(serverVersion,
-URI uri = DigestEchoServer.uri(useSSL ? "https" : "http", server.getServerAddress(), "/foo/");
+useSSL ? "https" : "http", authType, authScheme);
+URI uri = DigestEchoServer.uri(useSSL ? "https" : "http",
+server.getServerAddress(), "/foo/");
 HttpClient client = newHttpClient(server);
 HttpResponse<String> r;
 CompletableFuture<HttpResponse<String>> cf1;
 byte[] cnonce = new byte[16];
 List<String> lines = List.of(Arrays.copyOfRange(data, 0, i+1));
 assert lines.size() == i + 1;
 String body = lines.stream().collect(Collectors.joining("\r\n"));
 HttpRequest.BodyPublisher reqBody = HttpRequest.BodyPublisher.fromString(body);
 HttpRequest.Builder reqBuilder = HttpRequest
-.newBuilder(uri).version(version).POST(reqBody)
+.newBuilder(uri).version(clientVersion).POST(reqBody)
 .expectContinue(expectContinue);
 boolean isTunnel = isProxy(authType) && useSSL;
 String digestMethod = isTunnel ? "CONNECT" : "POST";
 }
 challenge = DigestEchoServer.DigestResponse
 .create(authenticate.substring("Digest ".length()));
 String auth = digestResponse(uri, digestMethod, challenge, cnonceStr);
 try {
-request = HttpRequest.newBuilder(uri).version(version)
+request = HttpRequest.newBuilder(uri).version(clientVersion)
 .POST(reqBody).header(authorizationKey(authType), auth).build();
 } catch (IllegalArgumentException x) {
 throw x;
 }
 assert resp.statusCode() == 200;
 respLines = resp.body().collect(Collectors.toList());
 }
 } finally {
 long stop = System.nanoTime();
-synchronized (basicCount) {
+synchronized (digestCount) {
-long n = basicCount.getAndIncrement();
+long n = digestCount.getAndIncrement();
-basics.set((basics.get() * n + (stop - start)) / (n + 1));
+digests.set((digests.get() * n + (stop - start)) / (n + 1));
 }
 }
 if (!lines.equals(respLines)) {
 throw new RuntimeException("Unexpected response: " + respLines);
 }

branch	http-client-branch
changeset 56070	66a9c3185028
parent 56054	352e845ae744
child 56081	20c6742e5545