--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/test/sun/net/www/http/ChunkedOutputStream/checkError.java Sat Dec 01 00:00:00 2007 +0000
@@ -0,0 +1,251 @@
+/*
+ * Copyright 2004 Sun Microsystems, Inc. All Rights Reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+ * CA 95054 USA or visit www.sun.com if you need additional information or
+ * have any questions.
+ */
+
+/**
+ * @test
+ * @bug 5054016
+ * @run main/othervm/timeout=300 checkError
+ * @summary get the failure immediately when writing individual chunks over socket fail
+ */
+
+import java.io.*;
+import java.net.*;
+import java.util.StringTokenizer;
+
+
+public class checkError {
+ static final int TEST_PASSED = 95;
+ static final int TEST_FAILED = 97;
+
+ static int testStatus = TEST_PASSED;
+
+ static String serverName = "localhost";
+ static int bufferSize = 8192; // 8k
+ static int totalBytes = 1048576; // 1M
+
+ static int j = 0;
+
+ static public Object threadStarting = new Object();
+ static public Object threadWaiting = new Object();
+
+
+ public static void main(String[] args) throws Exception {
+ HttpURLConnection conn = null;
+ OutputStream toServer = null;
+ byte[] buffer = null;
+ HTTPServer server = null;
+ synchronized(threadWaiting) {
+ System.out.println("HTTP-client>Starting default Http-server");
+ synchronized(threadStarting) {
+ server = new HTTPServer();
+ server.start();
+ try {
+ System.out.println("waiting server to be start");
+ threadStarting.wait();
+ } catch (InterruptedException e) {
+ }
+ }
+ int port = server.getPort();
+ URL url = new URL("http://" + serverName + ":" + port);
+ conn = (HttpURLConnection )url.openConnection();
+ conn.setRequestMethod("POST");
+ conn.setDoOutput(true);
+
+ System.out.println("assigning 1024 to the chunk length");
+ conn.setChunkedStreamingMode(1024);
+ conn.connect();
+
+ toServer = conn.getOutputStream();
+ buffer = getThickBuffer(bufferSize);
+ System.out.println("sending " + totalBytes + " bytes");
+ }
+
+ int byteAtOnce = 0;
+ int sendingBytes = totalBytes;
+ try {
+ while (sendingBytes > 0) {
+ if (sendingBytes > bufferSize) {
+ byteAtOnce = bufferSize;
+ } else {
+ byteAtOnce = sendingBytes;
+ }
+ toServer.write(buffer, 0, byteAtOnce);
+ sendingBytes -= byteAtOnce;
+ // System.out.println((totalBytes - sendingBytes) + " was sent");
+ toServer.flush();
+ }
+ } catch (OutOfMemoryError e) {
+ e.printStackTrace();
+ System.out.println("***ERR***> UNEXPECTED error: " + e);
+ testStatus = TEST_FAILED;
+ testExit();
+ } catch (IOException e) {
+ // e.printStackTrace();
+ // this is the expected IOException
+ // due to server.close()
+ testStatus = TEST_PASSED;
+ testExit();
+ } finally {
+ toServer.close();
+ }
+
+ // we have not received the expected IOException
+ // test fail
+ testStatus = TEST_FAILED;
+ testExit();
+
+ }
+
+ static void testExit() {
+ if (testStatus == TEST_FAILED) {
+ throw new RuntimeException("Test Failed: haven't received the expected IOException");
+ } else {
+ System.out.println("TEST PASSED");
+ }
+ System.exit(testStatus);
+ }
+
+ static byte[] getThickBuffer(int size) {
+
+ byte[] buffer = new byte[size];
+
+ for (int i = 0; i < size; i++) {
+ if (j > 9)
+ j = 0;
+ String s = Integer.toString(j);
+ buffer[i] = (byte )s.charAt(0);
+ j++;
+ }
+
+ return buffer;
+ }
+}
+
+
+class HTTPServer extends Thread {
+
+ static volatile boolean isCompleted;
+
+ Socket client;
+ ServerSocket serverSocket;
+
+ int getPort() {
+ return serverSocket.getLocalPort();
+ }
+
+ public void run() {
+
+ synchronized(checkError.threadStarting) {
+
+ try {
+ serverSocket = new ServerSocket(0, 100);
+ } catch (Exception e) {
+ e.printStackTrace();
+ checkError.testStatus = checkError.TEST_FAILED;
+ return;
+ }
+ checkError.threadStarting.notify();
+ }
+
+ try {
+ client = serverSocket.accept();
+ } catch (Exception e) {
+ e.printStackTrace();
+ checkError.testStatus = checkError.TEST_FAILED;
+ return;
+ }
+
+ System.out.println("Server started");
+
+ BufferedReader in = null;
+ PrintStream out = null;
+ InputStreamReader reader = null;
+ String version = null;
+ String line;
+ String method;
+
+ synchronized(checkError.threadWaiting) {
+ try {
+ reader = new InputStreamReader(client.getInputStream());
+ in = new BufferedReader(reader);
+ line = in.readLine();
+
+ } catch (Exception e) {
+ e.printStackTrace();
+ checkError.testStatus = checkError.TEST_FAILED;
+ return;
+ }
+ StringTokenizer st = new StringTokenizer(line);
+ method = st.nextToken();
+ String fileName = st.nextToken();
+
+ // save version for replies
+ if (st.hasMoreTokens()) version = st.nextToken();
+
+ System.out.println("HTTP version: " + version);
+
+ }
+
+ try {
+
+ while (line != null && line.length() > 0) {
+ line = in.readLine();
+ System.out.println(line);
+ }
+ } catch (IOException e) {
+ e.printStackTrace();
+ checkError.testStatus = checkError.TEST_FAILED;
+ return;
+ }
+
+ if (method.equals("POST")) {
+ System.out.println("receiving data");
+ byte[] buf = new byte[1024];
+ try {
+ //reading bytes until chunk whose size is zero,
+ // see 19.4.6 Introduction of Transfer-Encoding in RFC2616
+ int count = 0;
+ while (count <=5) {
+ count++;
+ in.readLine();
+ }
+
+ System.out.println("Server socket is closed");
+ in.close();
+ client.close();
+ serverSocket.close();
+
+ } catch (IOException e) {
+ e.printStackTrace();
+ checkError.testStatus = checkError.TEST_FAILED;
+ return;
+ } catch (OutOfMemoryError e) {
+ e.printStackTrace();
+ checkError.testStatus = checkError.TEST_FAILED;
+ return;
+ }
+
+ }
+ }
+
+}